feat(#3841): assert gsd-tools identity on every state-mutating verb (#3848)

* feat(#3841): assert gsd-tools identity before any state-mutating verb

only this package publishes. The path-based branches — a project-local install,
a runtime config directory — had no such guarantee; they trusted their
configured location. This closes them.

Mechanism: once resolution finishes, and before any verb runs, the preamble
probes the tool it picked with `runtime-identity --raw` and matches the answer
with a shell `case` pattern ANCHORED to the start of the compact payload
(`{"packageName":"@opengsd/gsd-core"`). An unanchored substring match accepts
the decoy `{"packageName":"get-shit-done-cc","note":"@opengsd/gsd-core"}`, which
any colliding package could publish. The outcome is exported as the two-valued
`GSD_IDENTITY_STATUS` (`ok`/`unverified`), so the gate is asserted on a VALUE
rather than on warning prose. Rollout is warn-then-fail per the #3146 ruling:
`unverified` prints one line naming BOTH causes and continues, because
`no_identity_verb` cannot tell a foreign package from an `@opengsd/gsd-core`
older than the verb, and at rollout the old-version case is the common one.

The blocker was byte budget, not design. The preamble is inlined into 112
shipped files and several sat within single-digit bytes of frozen ceilings
(`gsd-verifier.md` 16 bytes, `gsd-executor.md` 33, `execute-phase.md` 234); a
first attempt broke five of them. What made room was collapsing the resolver's
twenty near-identical `elif [ -f … ]` arms into one candidate-list helper
(`_gsd_at`), which buys far more than the assertion costs. The preamble is now
2,624 bytes against 4,500 — a net 1,876 bytes SMALLER per inlined file, so every
capped file moved away from its ceiling rather than toward it. No cap raised, no
size-budget exception added, no override token emitted.

Resolution order, every runtime-home probe, the `unset -f gsd_run` re-source
fix, the fail-closed `exit 1`, and the `CLAUDE_ENV_FILE` persistence are all
preserved byte-for-byte in substring terms; the snippet still begins with
`_GSD_SHIM_NAME=` and still ends with `fi`, which the parity extractors anchor
on. `gsd-core/references/gsd-run-resolver.md` is re-synced byte-equal.

Also fixes two stale claims found in passing: CONTEXT.md and FEATURES.md both
described an `[ -x ]` guard as the load-bearing re-source defense. That guard
was tried and REMOVED in #3831 — it rejected the bare function name, fell
through every branch, and hit `exit 1`, which kills a sourced caller's shell.
`unset -f gsd_run` is the actual mechanism.

Refs #3841

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(#3841): pair the anchor's brace by requiring a closed identity payload

The matrix went red on `tests/new-project-mvp-prompt.test.cjs` — "new-project.md
has unbalanced braces: net depth 2" — plus a knock-on report from its parent
`bug #1516` describe, which is the same failure counted once at the child and
once at the block.

Root cause: that guard (:182-189, mirroring #3784 bd53925f) walks characters and
increments on `{`, decrements on `}`, with no awareness of shell quoting. It
scans `new-project.md` PLUS every `new-project/steps/*.md`, and both
`new-project.md` and `steps/auto-mode-config.md` carry one inlined preamble copy
— hence net 2 from a snippet that was off by exactly one. The unpaired brace was
the `{` inside the single-quoted `case` pattern of the identity anchor, which is
correct shell and invisible to a text scanner.

Fix in the snippet, not the guard. The pattern now anchors at BOTH ends:
`'{"packageName":"@opengsd/gsd-core"'*'}'`. That balances 51/51 with a brace that
does real work rather than a cosmetic pair — a truncated payload whose prefix
matches now fails too, where before it verified. Safe for any future additive
field: a JSON object's own closing brace is always the last character, whatever
type the last value has, which is pinned by two negative-space tests (a nested
object and an array-valued last key must both still verify). Cost: +3 bytes,
against the 1,873 the resolver fold already gave back.

The alternative considered and rejected was dropping the literal `{` for a `?`
glob. It balances too, but weakens the anchor from "must be an opening brace" to
"must be any one character", and the anchor is the entire point.

Two guards added so this cannot recur silently:
- runtime-launcher-parity (F0) pins brace balance at the SNIPPET, so the next
  edit to that pattern fails on the file it broke instead of surfacing three
  files downstream in a test whose name mentions neither the launcher nor this
  issue. It also asserts depth never goes negative, since a `}` preceding its
  `{` nets to zero while being unbalanced at every prefix.
- runtime-identity gains behavioral truncated-payload and trailing-garbage
  fixtures, so the added `}` is proven load-bearing rather than merely present.

Verified: snippet 51/51 braces; new-project combined net depth 0; the seven
other preamble-bearing files with nonzero depth are unchanged from merged next
(their own prose, not the preamble, and not in any guard's scan set); all 112
inlined copies and the resolver reference re-synced byte-equal; sync:launcher
idempotent on the second run.

Refs #3841

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* chore(#3841): backfill changeset PR number

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

---------

Co-authored-by: sim <sim@local>
Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

src/runtime-identity.cts

@@ -11,9 +11,19 @@
  * That collision is now prevented in the resolver rather than detected here:
  * the launcher's PATH branch resolves `gsd_run`, which only this package
  * publishes and which self-locates to its sibling shim, so a foreign binary is
- * unreachable from PATH. This module backs the `runtime-identity` verb, a
- * MANUAL diagnostic for answering "which tool am I actually running?" — it is
- * not an automatic gate, and nothing calls it on the hot path.
+ * unreachable from PATH. The path-based branches — a project-local install, a
+ * runtime config directory — have no such structural guarantee: they trust
+ * their configured location. #3841 closes that remaining route by making the
+ * launcher preamble PROBE the resolved tool once, before any verb runs, and
+ * warn when it cannot prove it is this package. This module backs both the
+ * `runtime-identity` verb the preamble calls and the vocabulary that gate
+ * reports in (`IDENTITY_STATUS`).
+ *
+ * The rollout is warn-then-fail (the #3146 maintainer ruling): the preamble
+ * prints one actionable line and proceeds. It cannot hard-fail yet because
+ * `no_identity_verb` does not distinguish a foreign package from an
+ * `@opengsd/gsd-core` older than the verb — and during rollout the old-version
+ * case is the common one, so a hard failure would stop working installs.
  *
  * Parsing is deliberately STRICT. The whole value of the check is telling "us"
  * from "not us"; a lenient parse that accepts the predecessor's usage text as
@@ -43,6 +53,42 @@ export type IdentityReason =
   | 'unparseable'
   | 'probe_failed';
 
+/**
+ * The two-valued status the launcher preamble exports as `GSD_IDENTITY_STATUS`
+ * (#3841). Frozen so it is a VALUE a test can assert on: CONTRIBUTING forbids
+ * proving the gate fired by matching its human-readable warning prose.
+ *
+ * Two values, not five: the shell has no use for the distinction between
+ * `no_identity_verb` and `unparseable` — it either holds proof or it does not.
+ * The five-way {@link IdentityReason} stays the diagnostic vocabulary;
+ * {@link statusForVerdict} is the only bridge between them.
+ */
+export const IDENTITY_STATUS = Object.freeze({
+  OK: 'ok',
+  UNVERIFIED: 'unverified',
+} as const);
+
+/** A value of {@link IDENTITY_STATUS}. */
+export type IdentityStatus = (typeof IDENTITY_STATUS)[keyof typeof IDENTITY_STATUS];
+
+/**
+ * The exact byte prefix the preamble anchors its `case` pattern to.
+ *
+ * ANCHORED, never a substring search. `JSON.stringify` emits keys in insertion
+ * order and `buildIdentityPayload` inserts `packageName` first, so a genuine
+ * `--raw` payload always STARTS with this. An unanchored match would verify the
+ * decoy `{"packageName":"get-shit-done-cc","note":"@opengsd/gsd-core"}`, which
+ * is exactly the shape a colliding package could publish.
+ *
+ * The preamble anchors at BOTH ends: its `case` pattern is this prefix, then
+ * anything, then a literal `}`, so a truncated payload fails too. That is safe
+ * for any future additive field — a JSON object's own closing brace is always
+ * the last character, whatever the last value's type. It also pairs the literal
+ * `{` for the raw-text brace guards the preamble is inlined into (#3841); the
+ * pairing is a consequence of the stronger check, not the reason for it.
+ */
+export const IDENTITY_RAW_PREFIX = `{"packageName":"${EXPECTED_PACKAGE_NAME}"`;
+
 /** Raw result of running `<resolved gsd-tools> runtime-identity`. */
 export interface IdentityProbe {
   stdout: string;
@@ -134,6 +180,16 @@ export function classifyIdentityProbe(
   return { reason: 'ok', expected, actual, version };
 }
 
+/**
+ * Collapse a five-way verdict onto the two-valued shell status.
+ *
+ * Total by construction: anything that is not `ok` is `unverified`. A future
+ * sixth reason code therefore fails CLOSED here rather than silently verifying.
+ */
+export function statusForVerdict(verdict: IdentityVerdict): IdentityStatus {
+  return verdict.reason === 'ok' ? IDENTITY_STATUS.OK : IDENTITY_STATUS.UNVERIFIED;
+}
+
 export interface PayloadDeps {
   /** Injectable for tests; defaults to the shipped host-version reader. */
   readVersion?: () => string;