cad-land

Files (1)

• SKILL.md

SKILL.md (first lines)

<objective>
Land the current branch's work. By default there is no preselected publish
action: cad-land reports the state, asks how to publish, and executes only what
you choose - nothing more. The one exception is the `git.auto_close` arm that
both opt-ins authorize (this repository's config and your user-global config),
which runs the close unattended; it is stated once, at step 3(b).
</objective>

<execution_context>
@${CLAUDE_PLUGIN_ROOT}/cadence-core/references/git-guard.md
</execution_context>

<process>
Read every config key this run needs in ONE `config.mjs get` up front
(conventions.md Parallel work) - `git.base_branch git.protected_branches
git.on_land_cleanup git.create_tag` - and reuse the values across the steps
below rather than re-reading per step. Step 3 asks a seam, not this read.

1. **Report git state.** Current branch; the base = `$ARGUMENTS`, else
   `git.base_branch`, else the first `git.protected_branches` entry that
   exists here (references/git-guard.md's fallback); commits ahead of base; unpushed commits; uncommitted/untracked
   changes; and the remote host detected from the origin URL (gitlab -> MR,
   github -> PR, any other host where `tea` holds a login -> Forgejo/Gitea PR
   via `tea`, else local only). Show this plainly before doing anything.

   **Then the tracker, in the same report.** Run it here, before any publish
   ask, on both step-3 arms:

```
node "${CLAUDE_PLUGIN_ROOT}/cadence-core/bin/issue-check.mjs" check --dir <root> --base <base>
```

   Branch on `action` alone. On `report`: say in ONE sentence which issues this
   branch's commits reference and which of them are still open ("your branch
   references #42 and #47; #42 is still open"), naming a `not-found` number as
   not found and an `unresolved` one unresolved, never closed or not found.
   Print the `open` list ONLY when
   `referenced` is empty - it is the fallback, never the headline, because a
   bare list is what a reader skims past. On `skip`: print `reason` verbatim as
   ONE line and carry on - never block, never retry, never ask, and never list
   an issue the seam did not read. On `off` - `git.issue_check: false`, decided
   before any forge CLI runs - say NOTHING about the tracker: not the reason,
   not that it was skipped. The off switch is off, so this paragraph produces
   no output at all.

   This report never writes: landing closes no issue, and closing one stays an
   explicit ask you make at publish time.

2. **Uncommitted changes.** If the tree is dirty, do NOT auto-commit. Ask
   (ask-user seam): commit them first (then continue), leave them out of this
   land, or stop. If HEAD is a protected branch, the protected-branch guard
   (references/git-guard.md) applies to any commit here.

3. **Publish - branch on the `git.auto_close` authorization.**

   **First the deferred queue, on BOTH arms and ahead of the branch below.** A
   gate resolved `deferred` ran its reviewer and let the run continue, so the
   finding stops the LAND. Ask what is still queued:

```
node "${CLAUDE_PLUGIN_ROOT}/cadence-core/bin/planning.mjs" deferred list
```

   On ANY entry in `members`, STOP the land here: no publish ask, no seam call,
   no merge, no tag, neither arm. Print each member's `trigger`,
   `discriminator` and finding count with the `path` its bodies are in, then
   point the reader at
   `${CLAUDE_PLUGIN_ROOT}/cadence-core/references/triage-gate.md`, whose
   `deferred` arm says how to clear one - triage the member's findings and
   record the rulings with `planning.mjs adjudication` for the same trigger,
   discriminator and round, which supersedes it. A non-empty `unreadable`
   arrives as `ok:false` and refuses exactly as a member does: the queue could
   not be PROVEN empty, and this gate never reports "nothing deferred" about
   input it could not read, the disposition `land-cleanup.mjs gate` already
   takes for a findings payload it could not parse.

   It is NOT `land-cleanup.mjs gate` and must not be folded into it: that gate
   halts only under an authorized `git.auto_close` and reads only `risk_surface`
   survivors, so a default-configured project would publish straight over a
   deferred `plan`, `diff` or `phase_diff` finding.

   **Then the ONE answer both arms branch on**, on its own line:

```
node "${CLAUDE_PLUGIN_ROOT}/cadence-core/bin/git-publish.mjs" authorized --dir <root>
```

   `ok:true` takes 3(b), `ok:false` takes 3(a). It is true only when this
   repository's config and your user-global config BOTH set `git.auto_close`;
   either alone authorizes nothing. When the refusal's `requested` is true,
   print its `detail` as one line first, so a user who set one half learns why
   the ask came back.

   **(a) `git.auto_close` false, or not set in both layers (default): ask the
   mechanism (ask-user seam, NO preselected default):**
   - **Direct push** - push the current branch to its remote.
   - **Open MR / PR** - the detected host's mechanism (`glab mr create` on
     GitLab, `gh pr create` on GitHub, `tea pr create --base <base> --head
     <branch>` on a Forgejo/Gitea remote - `tea` does not push the source
     branch itself, so push it first as part of this same chosen action). If
     no remote, or `tea` holds no login at all, this option is absent.
   - **Tag** - create an annotated tag (ask the name); ask separately
     whether to push it.
   - **Leave local** - do nothing further.

   **Read the publish rails before a publishing answer.** When the answer is
   direct push, open MR/PR, or a tag the user chose to push, Read
   `${CLAUDE_PLUGIN_ROOT}/cadence-core/references/git-publish.md` (one
   consult site - step 3a or 3b, never both) first: rail 3 and the
   `git.auto_close` policy govern all three, and this skill no longer preloads
   them.

   Then **execute exactly that, raw.** Run only the chosen action. Never push
   unless push (or push-tag) was chosen. No PR-body templating beyond a
   title/summary the user confirms. Report precisely what was done (branch
   pushed, MR/PR URL, tag created) and nothing implied.

   **(b) `git.auto_close` true, set in both layers: land the integration branch
   on base via `PR -> merge`, no prompts.** Skip the 3a ask entirely (this is the single

From crenshawdev/cadence, MIT.

More from crenshawdev/cadence