Skip to content

simiancraft/simiancraft-skills / skills/carve-github-issue

carve-github-issue

Verified

Break one GitHub issue that is too large to work into sub-issues, unattended, and keep the carving honest as the children close. A carver names the pieces along the highest natural seam (domain, tier, route, area, file, unit, material), matches each against the backlog so nothing is authored twice, and a second engine confirms the cut covers the parent before anything is created. The parent becomes a trunk that is finished by closing its children; every child close re-checks the trunk, and a trunk with nothing left goes back to the appraiser. Use when the task is "this issue is too big, split it", "carve #N into sub-issues", "is this carving still good", or when burn-down-github-issues sizes an issue over its ceiling. Requires a per-repository config (its own, or the burndown's), the codex and claude CLIs for the default seats, and GitHub sub-issues on the repository. Skip for fixing anything; this skill writes only to the tracker.

FileKindSize
SKILL.mdskill md7.5 KB
carve.tsscript10.6 KB
lib/callbacks.tsscript1.4 KB
lib/carve.test.tsscript19.7 KB
lib/carve.tsscript25.7 KB
lib/claims.test.tsscript13.3 KB
lib/claims.tsscript14.2 KB
lib/fake-tracker.tsscript9.7 KB
lib/knife.test.tsscript69.3 KB
lib/knife.tsscript63.1 KB
lib/record.tsscript12.7 KB
lib/tree.tsscript23.9 KB
lib/validate.test.tsscript12.8 KB
prompts/carve.mdmarkdown8.1 KB
prompts/confirm-carve.mdmarkdown4.1 KB
prompts/revisit.mdmarkdown4.9 KB
references/adopting.mdmarkdown6.6 KB
references/callbacks.mdmarkdown1.8 KB
references/lifecycle.mdmarkdown30.3 KB
references/seams.mdmarkdown9.1 KB
references/the-record.mdmarkdown6.6 KB

prompts/confirm-carve.md

View on GitHub
You are the second opinion on a proposed carving of issue **#{{ISSUE}}** of the {{PROJECT}}
repository: "{{TITLE}}". Round {{ROUND}} of at most {{MAX_ROUNDS}}.

A carver on another engine read this issue and answered **`{{VERDICT}}`** in {{MODE}} mode. You did
not read the issue with that carver and you have none of its context. That is the point: a cut
that ships wrong costs every leaf under it, so it gets a reader who trusts nothing. You judge
meaning; the driver has already checked everything mechanical (shapes, bounds, cycles, orders).

You are running headless. Nobody will answer a question, so a question is a verdict, not a pause.

This is a read-only job. Your working directory is an empty scratch directory, not a checkout, and
it carries no repository context: address GitHub explicitly with `gh -R {{REPO}}`. The repository's
main checkout is at `{{MAIN_CHECKOUT}}`; read code from it freely, but write nothing there, switch
no branches, and run nothing in it that creates files. Do not edit, label, or comment on any issue.

## Read first

- The methodology: `{{SEAMS_PATH}}`. Your finding is judged by the same standard as the cut.
- The issue and its whole thread: `gh -R {{REPO}} issue view {{ISSUE}} --comments`. On a revisit,
  every child's thread too, closed ones included: {{CHILDREN}}
- The previous ledger, when there is one: {{PREVIOUS_LEDGER}}

## The carver's answer

```json
{{CARVING}}
```

{{CARVER_REPLY}}

## What you check

On a `carve` or `amend`:

1. **The inventory is real and complete.** Every criterion in it is in the thread; nothing the
   thread asks for is missing from it. Ids carried forward name the same criterion as before.
2. **Cover.** The union of the pieces is the parent: no criterion unowned (`gap`), nothing the
   parent did not ask for (`overreach`). For a width cut (interchangeable instances) judge
   partition integrity instead: each instance in exactly one chunk, the manifest stable and
   deduplicated, the same acceptance per chunk (`partition-intact` or `partition-broken`).
3. **Each piece stands alone**: one bounded outcome, its own acceptance and proof available at its
   close, and the base usable after it lands in its stated order.
4. **Dependencies are necessary and minimal**; every groundwork item has one owner, and no
   groundwork piece lacks a named consumer.
5. **An adopted or referenced issue really is the piece it stands in for.** Open it and check.
6. **Sizes are honest**, including tests and proof.
7. **A partial cut's deferred criteria are exactly the ones the spike's questions decide.**
8. **The seam.** Is a higher rung admissible for this issue? A dispute is allowed only when the
   higher seam you see is `domain` or `tier`; between the mechanistic rungs any admissible covering
   cut ships, and you note the alternative in `seamCase` without disputing. A dispute goes back to
   the carver with your case; on round {{MAX_ROUNDS}} it hands the whole carving to a person.

On `still-good`: the ledger against the tree. Reject when any criterion is `orphaned`, or
`deferred` while its spike is closed, or when a child changed in a way the ledger does not reflect.

On `exhausted`: every criterion is `completed` by a child or reference closed `COMPLETED`, or
`withdrawn` by a comment you can find, and no recorded dependency is open.

On a hand-off (`small-enough`, `indivisible`, `nothing-left`, `too-uncertain`): the reason against
the thread and the code, and that `affected` is exactly the criteria the question touches.

## Your answer

Write `{{CONFIRMATION_FILE}}` in your working directory:

```json
{
  "issue": {{ISSUE}},
  "mode": "{{MODE}}",
  "agree": true,
  "finding": "cover | gap | overreach | partition-intact | partition-broken | still-good | not-still-good | exhausted | not-exhausted | hand-off-agree | hand-off-disagree",
  "seam": "agree | higher-available",
  "seamCase": "with higher-available, the higher seam and why it is admissible here; an empty string with agree",
  "reason": "one or two sentences a stranger could re-check"
}
```

`agree` is true only for `cover`, `partition-intact`, `still-good`, `exhausted`, or
`hand-off-agree`, with `seam: "agree"`. Anything else goes back to the carver as feedback.
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 323kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 323kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 323kUpdated Claude CodeCodexVerifiedInstall