@opengsd/gsd-core 1.12.0 → 1.13.0

package/gsd-core/workflows/section-manifest.json

@@ -150,6 +150,18 @@
         "read": "gsd-core/workflows/progress/steps/forensic-audit.md"
       }
     ],
+    "quick-batch": [
+      {
+        "id": "research-phase",
+        "when": "flag:--research",
+        "read": "gsd-core/workflows/quick-batch/steps/research-phase.md"
+      },
+      {
+        "id": "verification-wave",
+        "when": "flag:--validate",
+        "read": "gsd-core/workflows/quick-batch/steps/verification-wave.md"
+      }
+    ],
     "quick": [
       {
         "id": "discussion-phase",

package/gsd-core/workflows/secure-phase.md

@@ -23,7 +23,7 @@ if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_AUDITOR=$(gsd_run query agent-skills gsd-security-auditor)
 ```
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 Parse: `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`.
 

package/gsd-core/workflows/session-report.md

@@ -1,3 +1,5 @@
+@~/.claude/gsd-core/references/response-language-directive.md
+
 <purpose>
 Generate a post-session summary document capturing work performed, outcomes achieved, and estimated resource usage. Writes SESSION_REPORT.md to .planning/reports/ for human review and stakeholder sharing.
 </purpose>

package/gsd-core/workflows/settings-advanced.md

@@ -1,3 +1,5 @@
+Apply response_language to all user-facing prose — narration between tool calls, status updates, progress notes, and findings included; preserve code, paths, and identifiers.
+
 <purpose>
 Interactive configuration of GSD power-user knobs — plan bounce, node repair, subagent timeouts,
 inline plan threshold, cross-AI execution, base branch, branch templates, response language,

package/gsd-core/workflows/settings-integrations.md

@@ -60,7 +60,7 @@ if [[ -z "${GSD_CONFIG_PATH:-}" ]]; then
 fi
 ```
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 Store `$GSD_CONFIG_PATH`. Every subsequent read/write uses it.
 </step>
@@ -163,12 +163,13 @@ namespace — any other slug fails with `Unknown config key`.
 Settable keys (the shipped registry's model-bearing lanes):
 
 `review.models.agy` (Antigravity), `review.models.claude`, `review.models.codex`,
-`review.models.gemini`, `review.models.kimi-code`, `review.models.llama_cpp`,
-`review.models.lm_studio`, `review.models.ollama`, `review.models.opencode`.
+`review.models.cursor`, `review.models.gemini`, `review.models.kimi-code`,
+`review.models.llama_cpp`, `review.models.lm_studio`, `review.models.ollama`,
+`review.models.opencode`.
 
-Reviewer lanes `cursor`, `qwen`, and `coderabbit` declare no `modelConfigKey` —
-there is nothing to configure for them here (whether they should have a
-per-lane model key is a separate question, out of scope for this workflow).
+Reviewer lanes `qwen` and `coderabbit` declare no `modelConfigKey` — there is
+nothing to configure for them here (whether they should have a per-lane model
+key is a separate question, out of scope for this workflow).
 If the user asks for one of those, say exactly that and skip.
 
 ```text
@@ -208,8 +209,8 @@ If it is not one of the settable keys, print:
 
 ```text
 Rejected: review.models.<slug> is not settable — only the reviewer lanes whose
-keys are enumerated above can be configured here. (cursor, qwen, and
-coderabbit have no per-lane model key.)
+keys are enumerated above can be configured here. (qwen and coderabbit have no
+per-lane model key.)
 ```
 
 and re-prompt.

package/gsd-core/workflows/settings.md

@@ -28,7 +28,7 @@ if [[ -z "${GSD_CONFIG_PATH:-}" ]]; then
 fi
 ```
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 Creates `config.json` (at the resolved path) with defaults if missing. `INIT` still holds `state.load` output for any step that needs STATE fields.
 Store `$GSD_CONFIG_PATH` — all subsequent reads and writes use this path, not a hardcoded `.planning/config.json`, so active-workstream installs target the correct file (#2282).

package/gsd-core/workflows/ship.md

@@ -30,7 +30,7 @@ INIT=$(gsd_run query init.phase-op "${PHASE_ARG}")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 Parse from init JSON: `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `padded_phase`, `commit_docs`.
 
@@ -309,16 +309,16 @@ Example configured sections:
 
 **8. TDD Audit section:**
 
-Reconstruct the per-commit TDD gate trail before squash-merge discards it. Walk the PR branch's own commits (merges excluded) and read each commit's `gate_status:` trailer with Git's native trailer machinery — never a raw `%B` grep, which would also match the string written in prose:
+Reconstruct the per-commit TDD gate trail before squash-merge discards it. Walk the PR branch's own commits (merges excluded) and read each commit's `gate-status:` trailer with Git's native trailer machinery — never a raw `%B` grep, which would also match the string written in prose:
 
 ```bash
 # Anchor on the merge-base so a stale local ${BASE_BRANCH} ref cannot over-count.
 RANGE_BASE=$(git merge-base "${BASE_BRANCH}" HEAD)
 git log "${RANGE_BASE}..HEAD" --no-merges --reverse \
-  --format='%H%x1f%s%x1f%(trailers:key=gate_status,valueonly,separator=%x2c)%x1e'
+  --format='%H%x1f%s%x1f%(trailers:key=gate-status,valueonly,separator=%x2c)%x1e'
 ```
 
-Records are separated by `\x1e`; the fields inside each are `\x1f`-separated — `<sha>`, `<subject>`, `<gate_status value>`.
+Records are separated by `\x1e`; the fields inside each are `\x1f`-separated — `<sha>`, `<subject>`, `<gate-status value>`.
 
 Pair commits by their conventional-commit type (the `type:` prefix of the subject):
 
@@ -326,16 +326,16 @@ Pair commits by their conventional-commit type (the `type:` prefix of the subjec
 - A `refactor:`, `docs:`, or `chore:` commit that is not consumed as an Impl pairing is a standalone row with Impl commit `—`.
 - A `feat:`/`fix:` commit with no preceding unpaired `test:` is a standalone row.
 
-Surface each commit's `gate_status:` value, normalized to exactly one of `skill`, `fallback`, `exempt`, or `missing` — never the raw trailer text. A commit whose trailer is absent, whose value is none of the first three, or which carries more than one `gate_status:` trailer (ambiguous) is counted as **missing** and still listed. This section is informational; it never blocks the ship.
+Surface each commit's `gate-status:` value, normalized to exactly one of `skill`, `fallback`, `exempt`, or `missing` — never the raw trailer text. A commit whose trailer is absent, whose value is none of the first three, or which carries more than one `gate-status:` trailer (ambiguous) is counted as **missing** and still listed. This section is informational; it never blocks the ship.
 
-**Self-suppress when every commit is missing (#2431):** the execute pipeline only writes `gate_status:` trailers when TDD mode is active. If every commit in the scan normalizes to `missing`, skip this section and the aggregate trailer (step 9) entirely — a 100%-missing table is pure noise. Only emit when at least one commit carries a real value (`skill`, `fallback`, or `exempt`).
+**Self-suppress when every commit is missing (#2431):** the execute pipeline only writes `gate-status:` trailers when TDD mode is active. If every commit in the scan normalizes to `missing`, skip this section and the aggregate trailer (step 9) entirely — a 100%-missing table is pure noise. Only emit when at least one commit carries a real value (`skill`, `fallback`, or `exempt`).
 
-Harden every table cell against injection, not just subjects: escape `|` as `\|` and strip `\r`/`\n` from both commit subjects and the rendered `gate_status` value. Prefer NUL (`-z` / `%x00`) record separation, and reject any record whose fields contain the `\x1f`/`\x1e` delimiters, so an adversarial commit message cannot corrupt record or field boundaries.
+Harden every table cell against injection, not just subjects: escape `|` as `\|` and strip `\r`/`\n` from both commit subjects and the rendered `gate-status` value. Prefer NUL (`-z` / `%x00`) record separation, and reject any record whose fields contain the `\x1f`/`\x1e` delimiters, so an adversarial commit message cannot corrupt record or field boundaries.
 
 ```markdown
 ## TDD Audit
 
-| Test commit | Impl commit | gate_status |
+| Test commit | Impl commit | gate-status |
 |---|---|---|
 | `a1b2c3d` test: failing parser test | `e4f5g6h` feat: implement parser | skill |
 | `i7j8k9l` test: failing export test | `m0n1o2p` feat: implement export | fallback |
@@ -346,12 +346,12 @@ Aggregate: 2 skill, 1 fallback, 1 exempt — 0 missing.
 
 This `## TDD Audit` section is the final body section — it renders after the configured `pr_body_sections`, immediately before the aggregate trailer — so the frozen core sections and the append-only configured sections both keep their existing order.
 
-**9. Aggregate gate_status trailer (final line)** (only when step 8 was emitted — i.e., at least one real `gate_status` value exists):
+**9. Aggregate gate-status trailer (final line)** (only when step 8 was emitted — i.e., at least one real `gate-status` value exists):
 
 After every other section — including any configured `pr_body_sections` — emit the audit aggregate as a single Git trailer on the **final line** of the PR body, preceded by a blank line so it parses as a valid trailer:
 
 ```
-gate_status: skill=2, fallback=1, exempt=1, missing=0
+gate-status: skill=2, fallback=1, exempt=1, missing=0
 ```
 
 Use the exact key order `skill=`, `fallback=`, `exempt=`, `missing=` so downstream tooling parses it stably. Keeping it last means a GitHub squash-merge that defaults its commit message to the PR description carries the aggregate into `${BASE_BRANCH}`, preserving the audit footprint in `git log` after the PR branch is deleted. (Best-effort: it depends on the repo's squash-message default; the in-body `## TDD Audit` section is the source of truth regardless.)

package/gsd-core/workflows/sketch-wrap-up.md

@@ -1,3 +1,5 @@
+@~/.claude/gsd-core/references/response-language-directive.md
+
 <purpose>
 Curate sketch design findings and package them into a persistent project skill for future
 UI implementation. Reads from `.planning/sketches/`, writes skill to `./.claude/skills/sketch-findings-[project]/`

package/gsd-core/workflows/sketch.md

@@ -102,7 +102,7 @@ RESPONSE_LANGUAGE=$(gsd_run query config-get response_language --raw --default "
 COMMIT_DOCS=$(gsd_run query config-get commit_docs --raw 2>/dev/null || echo "true")
 ```
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 </step>
 
 <step name="mood_intake">

package/gsd-core/workflows/smart-entry.md

@@ -34,7 +34,7 @@ RESPONSE_LANGUAGE=$(gsd_run query config-get response_language --raw --default "
 SNAPSHOT=$(gsd_run smart-entry --json 2>/dev/null)
 ```
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 Parse `SNAPSHOT` as JSON. It has the shape:
 

package/gsd-core/workflows/spec-phase.md

@@ -63,7 +63,7 @@ if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 
 Parse JSON for: `phase_found`, `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`, `state_path`, `requirements_path`, `roadmap_path`, `planning_path`, `response_language`, `commit_docs`.
 
-**If `response_language` is set:** All user-facing text in this workflow MUST be in `{response_language}`. Technical terms, code, and file paths stay in English.
+**If `response_language` is set:** All user-facing text in this workflow — narration between tool calls, status updates, progress notes, findings, questions, and report prose — MUST be in `{response_language}`. Technical terms, code, and file paths stay in English.
 
 **If `phase_found` is false:**
 ```
@@ -192,21 +192,25 @@ If gate passes (ambiguity ≤ 0.20 AND all minimums met):
 Run AFTER the ambiguity gate passes (you probe edges of clear requirements, not vague
 ones). Reference: @~/.claude/gsd-core/references/edge-probe.md.
 
-**Non-English projects — the probe input is translated, the SPEC is not.** The shape cues the
-classifier matches are **English** word-boundary patterns, so requirement prose written in
-another language matches nothing, classifies to zero shapes, and lands every row in
-`unclassified` (#1110) — the taxonomy contributes nothing and `--auto` leaves it all
-`unresolved`. The `$REQS_JSON` payload below is **engine input, never user-facing output**, so
-the `response_language` rule at the top of this workflow does not govern it: write each
-requirement's `text` as a faithful **English** translation of the SPEC requirement.
-The SPEC keeps the original language — only the probe input is translated, and requirement
+**Non-English projects — `text_en` carries the classifier-facing translation; the SPEC is
+not.** The shape cues the classifier matches are **English** word-boundary patterns, so
+requirement prose written in another language matches nothing, classifies to zero shapes, and
+lands every row in `unclassified` (#1110) — the taxonomy contributes nothing and `--auto`
+leaves it all `unresolved`. When this project has `response_language` set, add an optional
+`text_en` key to each `$REQS_JSON` entry: a faithful **English** translation of that
+requirement's `text`. `text_en` is **engine input, never user-facing output**, so the
+`response_language` rule at the top of this workflow does not govern it — but `text` itself is
+NOT translated: write it as the requirement's own text, exactly as it appears in the SPEC.
+The SPEC keeps the original language — only `text_en` is translated, and requirement
 `id`s are never translated or renumbered (coverage rows join back on `id`, and any Acceptance
-Criteria you write from the resolved edges go into the SPEC in `response_language`).
-Translate **every** requirement, not only the ones that look edge-relevant: the
+Criteria you write from the resolved edges go into the SPEC in `response_language`). Populate
+`text_en` for **every** requirement, not only the ones that look edge-relevant: the
 `$APPLICABLE = 0` warning below fires only when *all* requirements are unclassified, so a
-partly-classified spec slips through with no signal at all.
-If a requirement still classifies to zero shapes after translation, it carries no cue in any
-language (the recorded recall gap — ADR-857 §98 / ADR-550 D7b, not a translation failure);
+partly-classified spec slips through with no signal at all. When `response_language` is unset
+(an English-language project), omit `text_en` — `text` is already English and the engine
+falls back to it automatically (`text_en ?? text`).
+If a requirement still classifies to zero shapes with `text_en` populated, it carries no cue in
+any language (the recorded recall gap — ADR-857 §98 / ADR-550 D7b, not a translation failure);
 author an explicit `shapes` array on that requirement instead of relying on the prose
 classifier.
 
@@ -251,11 +255,12 @@ fi
 
 # Write the Requirements gathered in THIS spec session to a temp JSON, then invoke the
 # canonical coverage compute. Populate the heredoc from the SPEC's Requirements — one object
-# per requirement: {"id","text","shapes"?}. This is the load-bearing step: an empty file makes
-# the probe a no-op, so the guard below fails loud rather than silently skipping (RR-04).
-# When `response_language` is set, `text` carries a faithful ENGLISH translation (see above) —
-# the shape cues are English-only, so original-language prose classifies to zero shapes and the
-# probe becomes a silent no-op. Keep every `id` exactly as it appears in the SPEC.
+# per requirement: {"id","text","text_en"?,"shapes"?}. This is the load-bearing step: an empty
+# file makes the probe a no-op, so the guard below fails loud rather than silently skipping
+# (RR-04). When `response_language` is set, ALSO add `text_en` — a faithful ENGLISH
+# translation of `text` (see above) — the shape cues are English-only, so original-language
+# `text` alone classifies to zero shapes; `text` itself stays the SPEC's own requirement text
+# and is never translated. Keep every `id` exactly as it appears in the SPEC.
 # BSD/macOS mktemp only randomizes XXXXXX when it is the final path component, so make a
 # suffixless temp then append the extension — portable across BSD + GNU (#1520).
 REQS_JSON=$(mktemp "${TMPDIR:-/tmp}/edge-probe-reqs-XXXXXX") && mv "$REQS_JSON" "${REQS_JSON}.json" && REQS_JSON="${REQS_JSON}.json" || exit 1

package/gsd-core/workflows/spike-wrap-up.md

@@ -1,3 +1,5 @@
+@~/.claude/gsd-core/references/response-language-directive.md
+
 <purpose>
 Package spike experiment findings into a persistent project skill — an implementation blueprint
 for future build conversations. Reads from `.planning/spikes/`, writes skill to

package/gsd-core/workflows/spike.md

@@ -18,7 +18,7 @@ _GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-pars
 RESPONSE_LANGUAGE=$(gsd_run query config-get response_language --raw --default "" 2>/dev/null || echo "")
 ```
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 <step name="banner">
 ```

package/gsd-core/workflows/stats.md

@@ -1,3 +1,5 @@
+@~/.claude/gsd-core/references/response-language-directive.md
+
 <purpose>
 Display comprehensive project statistics including phases, plans, requirements, git metrics, and timeline.
 </purpose>

package/gsd-core/workflows/sync-skills.md

@@ -1,3 +1,5 @@
+@~/.claude/gsd-core/references/response-language-directive.md
+
 # sync-skills — Cross-Runtime GSD Skill Sync
 
 **Command:** `/gsd-sync-skills`
@@ -30,14 +32,14 @@ IS_APPLY=false
 
 # Parse --from
 if [[ "$@" == *"--from"* ]]; then
-  FROM_RUNTIME=$(echo "$@" | grep -oP '(?<=--from )\S+')
+  FROM_RUNTIME=$(echo "$@" | sed -E 's/.*--from[[:space:]]+([^[:space:]]+).*/\1/')
 fi
 
 # Parse --to
 if [[ "$@" == *"--to all"* ]]; then
   TO_RUNTIMES=(antigravity augment claude cline codebuddy codex copilot cursor grok hermes kilo kimi kimi-code opencode pi qwen trae windsurf zcode)
 elif [[ "$@" == *"--to"* ]]; then
-  TO_RUNTIMES=( $(echo "$@" | grep -oP '(?<=--to )\S+') )
+  TO_RUNTIMES=( $(echo "$@" | sed -E 's/.*--to[[:space:]]+([^[:space:]]+).*/\1/') )
 fi
 
 # Parse --apply
@@ -237,12 +239,18 @@ mkdir -p "$DEST_ROOT"
 # empty. If per-runtime conversion is ever wired in, this is where it would go;
 # until then the cp -r must never run for a destination != source.
 
-for SKILL in $CREATE_LIST $UPDATE_LIST; do
+# Rewrapped through unquoted command substitution (gsd-core#4109): a bare
+# `$VAR` word-splits under bash but not zsh, collapsing every element onto
+# one iteration there.
+for SKILL in $(printf '%s' "$CREATE_LIST") $(printf '%s' "$UPDATE_LIST"); do
   rm -rf "$DEST_ROOT/$SKILL"
   cp -r "$SRC_SKILLS_ROOT/$SKILL" "$DEST_ROOT/$SKILL"
 done
 
-for SKILL in $REMOVE_LIST; do
+# Rewrapped through unquoted command substitution (gsd-core#4109): a bare
+# `$VAR` word-splits under bash but not zsh, collapsing every element onto
+# one iteration there.
+for SKILL in $(printf '%s' "$REMOVE_LIST"); do
   rm -rf "$DEST_ROOT/$SKILL"
 done
 ```

package/gsd-core/workflows/thread.md

@@ -1,3 +1,5 @@
+@~/.claude/gsd-core/references/response-language-directive.md
+
 # Thread Workflow
 
 Invoked by `/gsd:thread` (`commands/gsd/thread.md`).

package/gsd-core/workflows/transition.md

@@ -1,3 +1,5 @@
+@~/.claude/gsd-core/references/response-language-directive.md
+
 <internal_workflow>
 
 **This is an INTERNAL workflow — NOT a user-facing command.**

package/gsd-core/workflows/ui-phase.md

@@ -28,7 +28,7 @@ AGENT_SKILLS_UI_CHECKER=$(gsd_run query agent-skills gsd-ui-checker)
 
 Parse JSON for: `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`, `has_context`, `has_research`, `commit_docs`, `response_language`.
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 **File paths:** `state_path`, `roadmap_path`, `requirements_path`, `context_path`, `research_path`.
 
@@ -238,8 +238,9 @@ Display blocking issues. Proceed to step 9.
 Track `revision_count` (starts at 0).
 
 **If `revision_count` < 2:**
-- Increment `revision_count`
-- Re-spawn gsd-ui-researcher with revision context:
+- Re-spawn gsd-ui-researcher with revision context. `revision_count` is incremented on the
+  researcher's RETURN, not here — a return of `## REVISION_CONFLICT` must not spend an
+  iteration, and an increment made before dispatch cannot be withheld afterwards:
 
 ```markdown
 <revision>
@@ -248,12 +249,32 @@ The UI checker found issues with the current UI-SPEC.md.
 ### Issues to Fix
 {paste blocking issues from checker return}
 
-Read the existing UI-SPEC.md, fix ONLY the listed issues, re-write the file.
+`required_property` + evidence + severity BIND. `fix_hint` is ONE non-binding example route: a
+smaller or different mechanism reaching the same property resolves the issue in full — say which
+you used. Re-check the user's locked answers, capability guidance (CLAUDE.md, project skills) and
+the constraints this UI-SPEC already encodes BEFORE editing; if a hint would contradict one, or
+the property is unreachable without breaking one, return `## REVISION_CONFLICT` with the conflict
+and the alternatives rather than applying or working around it — see your `## Revision Conflict`
+section for its shape.
+
+Read the existing UI-SPEC.md, resolve ONLY the listed issues, re-write the file.
 Do NOT re-ask the user questions that are already answered.
 </revision>
 ```
 
-- After researcher returns → re-spawn checker (step 7)
+- **If the researcher returns `## REVISION_CONFLICT`:** do NOT increment `revision_count` and do
+  NOT re-spawn the checker — a conflict is not resolvable by re-running the same loop. Present the
+  conflict and its alternatives to the user and ask which to take: adopt a named alternative /
+  override the named constraint and apply the hint / amend the constraint itself. Every option
+  resolves the conflict — accepting the spec with the BLOCK still open is NOT offered here, because
+  the blocking `required_property` still fails; that choice belongs to the cap escalation below.
+  Re-spawn the researcher with the chosen resolution and return to this step.
+
+  **Bounded:** a conflict naming the SAME `required_property` twice in a row (no successful revision in between) is a stall, and so is
+  the THIRD conflict return of this loop whatever property it names — alternating property names
+  would otherwise never trip the repeat rule. Stop re-spawning and route it to the same cap
+  escalation below, so declining to spend an iteration cannot make this path unbounded.
+- **On any other return:** increment `revision_count`, then re-spawn checker (step 7)
 
 **If `revision_count` >= 2:**
 ```

package/gsd-core/workflows/ui-review.md

@@ -23,7 +23,7 @@ if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_UI_REVIEWER=$(gsd_run query agent-skills gsd-ui-auditor)
 ```
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 Parse: `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`, `commit_docs`.
 

package/gsd-core/workflows/ultraplan-phase.md

@@ -1,3 +1,5 @@
+@~/.claude/gsd-core/references/response-language-directive.md
+
 # Ultraplan Phase Workflow [BETA]
 
 Offload GSD's plan phase to Claude Code's ultraplan cloud infrastructure.

package/gsd-core/workflows/undo.md

@@ -13,7 +13,7 @@ _GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-pars
 RESPONSE_LANGUAGE=$(gsd_run query config-get response_language --raw --default "" 2>/dev/null || echo "")
 ```
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 <step name="banner" priority="first">
 Display the stage banner:

package/gsd-core/workflows/update.md

@@ -7,14 +7,14 @@ Read all files referenced by the invoking prompt's execution_context before star
 </required_reading>
 
 <process>
-**If `response_language` is configured:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in that language. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is configured:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in that language. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 <step name="get_installed_version">
 Detect the installed GSD version, scope, runtime, and config dir.
 
 First, derive `PREFERRED_CONFIG_DIR` and `PREFERRED_RUNTIME` from the invoking prompt's `execution_context` path — this is the one input only the workflow knows:
 - If the path contains `/gsd-core/workflows/update.md`, strip that suffix and store the remainder as `PREFERRED_CONFIG_DIR`.
-- Infer `PREFERRED_RUNTIME` from the path: `/.codex/` -> `codex`; `/.gemini/antigravity-ide/`, `/.gemini/antigravity-cli/`, `/.gemini/antigravity/`, `/.agents/` or `/.agent/` -> `antigravity` (`.agents` is the canonical local Antigravity install dir (#791); `.agent` is the legacy form (#503); see bin/install.js `getDirName('antigravity')`); `/.config/kilo/` or `/.kilo/` -> `kilo`; `/.config/opencode/` or `/.opencode/` -> `opencode`; otherwise `claude`.
+- Infer `PREFERRED_RUNTIME` from the path: `/.claude/` -> `claude`; `/.codex/` -> `codex`; `/.gemini/antigravity-ide/`, `/.gemini/antigravity-cli/`, `/.gemini/antigravity/`, `/.agents/` or `/.agent/` -> `antigravity` (`.agents` is the canonical local Antigravity install dir (#791); `.agent` is the legacy form (#503); see bin/install.js `getDirName('antigravity')`); `/.windsurf/`, `/.devin/` -> `windsurf`; `/.config/kilo/` or `/.kilo/` -> `kilo`; `/.config/opencode/` or `/.opencode/` -> `opencode`; otherwise leave it empty.
 
 Then resolve the install context via the deterministic projection (#498). **Do NOT re-derive scope, runtime, or version by hand** — `update-context` owns that cascade in tested code (`gsd-core/bin/lib/update-context.cjs`), the same way `check-latest-version` owns the package name (#2992):
 
@@ -50,17 +50,17 @@ if [ -n "$UC" ]; then
   # then silently degrades to the fresh-install fallback. The field name is
   # passed as argv, never interpolated into the script text.
   uc_field() {
-    printf '%s' "$UC" | node -e "let d='';process.stdin.setEncoding('utf8');process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const v=JSON.parse(d)[process.argv[1]];process.stdout.write(v==null?'':String(v));}catch{}})" "$1" 2>/dev/null
+    printf '%s' "${2:-$UC}" | node -e "let d='';process.stdin.setEncoding('utf8');process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const v=JSON.parse(d)[process.argv[1]];process.stdout.write(v==null?'':String(v));}catch{}})" "$1" 2>/dev/null
   }
   INSTALLED_VERSION="$(uc_field installedVersion)"
   INSTALL_SCOPE="$(uc_field scope)"
   TARGET_RUNTIME="$(uc_field runtime)"
   GSD_DIR="$(uc_field gsdDir)"
 else
-  # No tool resolvable / projection failed -> treat as a fresh install.
+  # No tool resolvable / projection failed -> no update target is known.
   INSTALLED_VERSION="0.0.0"
   INSTALL_SCOPE="UNKNOWN"
-  TARGET_RUNTIME="claude"
+  TARGET_RUNTIME=""
   GSD_DIR=""
 fi
 
@@ -73,15 +73,26 @@ echo "$GSD_DIR"
 Parse output:
 - Line 1 = installed version (`0.0.0` means unknown version)
 - Line 2 = install scope (`LOCAL`, `GLOBAL`, or `UNKNOWN`)
-- Line 3 = target runtime (`claude`, `opencode`, `kilo`, `codex`, `antigravity`)
-- Line 4 = resolved GSD config dir (e.g. `/Users/me/.claude`, `/Users/me/.gemini`); empty if scope is `UNKNOWN`. Capture this as `GSD_DIR` and pass it to subsequent steps so they don't re-derive the runtime path.
-- If scope is `UNKNOWN`, proceed to install using the `--claude --global` fallback.
+- Line 3 = target runtime (`claude`, `opencode`, `kilo`, `codex`, `antigravity`, `windsurf`); empty when no installed target is resolved
+- Line 4 = resolved GSD config dir (e.g. `/Users/me/.claude`, `/Users/me/.gemini`); empty when no installed target is resolved. Capture this as `GSD_DIR` and pass it to subsequent steps so they don't re-derive the runtime path.
 
 `update-context` reproduces the previous detection cascade — preferred-config-dir fast path, local-over-global with same-path dedup (so `CWD=$HOME` does not misdetect as LOCAL), env-var overrides (`CLAUDE_CONFIG_DIR`, `OPENCODE_CONFIG_DIR`, `KILO_CONFIG`, `XDG_CONFIG_HOME`, `CODEX_HOME`, …), and semver validation — but as a tested projection rather than ~280 lines of inline bash. Branch coverage lives in `tests/update-context.test.cjs`.
 
 If multiple runtime installs are detected and the invoking runtime cannot be determined from execution_context, ask the user which runtime to update before running install.
 
-**If VERSION file missing (version resolves to `0.0.0`):** report the installed version as Unknown and proceed to install (treated as `0.0.0` for comparison).
+**If `INSTALL_SCOPE` is `UNKNOWN`, `TARGET_RUNTIME` is empty, or `GSD_DIR` is empty:** this gate takes precedence over the VERSION-missing case below — a fully-unresolved target also reports version `0.0.0`, and must exit here rather than fall through to "proceed to install".
+
+```text
+UPDATE_TARGET_UNRESOLVED
+
+GSD could not resolve an installed update target. No update was performed.
+
+Rerun from a valid installed runtime: `/gsd:update`. For a fresh installation, run `npx -y --package=@opengsd/gsd-core@latest -- gsd-core --global`.
+```
+
+Exit.
+
+**Otherwise, if VERSION file missing (version resolves to `0.0.0`) but the target above resolved:** report the installed version as Unknown and proceed to install (treated as `0.0.0` for comparison).
 </step>
 
 <step name="parse_update_channel">
@@ -121,34 +132,31 @@ Extract `section_manifest` from `INIT_UPDATE` — gates the `channel-banner` sec
 <step name="check_latest_version">
 Check npm for latest version via the deterministic script. **Do NOT run `npm view` or `npm search` directly** — the package name must come from the script, not from a free choice at execution time. (#2992: LLM-driven prescriptions of npm package names produced wrong-package queries; moving the package name into a script constant closes that gap.)
 
-The `GSD_DIR` value emitted by `get_installed_version` (line 4) resolves to the runtime-specific config dir (`~/.claude/`, `~/.gemini/`, `~/.codex/`, etc.), so the script invocation works for every runtime — not just Claude. If `GSD_DIR` is empty (scope `UNKNOWN`), skip this step and go directly to install.
+The `GSD_DIR` value emitted by `get_installed_version` (line 4) resolves to the runtime-specific config dir (`~/.claude/`, `~/.gemini/`, `~/.codex/`, etc.), so the script invocation works for every runtime — not just Claude. An unresolved target exits in `get_installed_version` before this step.
 
-`LATEST_RESULT` is a JSON document with the documented shape `{ ok: bool, version: string, reason: string, detail?: string }`. Parse via `jq` ONLY when the script actually ran. When `GSD_DIR` is empty (scope `UNKNOWN`), skip the check entirely and seed the parsed fields with their no-op values so downstream logic does not mistake an unset `LATEST_RESULT` for a failed network check (#2993 CR feedback):
+`LATEST_RESULT` is a JSON document with the documented shape `{ ok: bool, version: string, reason: string, detail?: string }`. Parse it with the Node-only `uc_field` helper. When the script cannot run or returns nothing, preserve its failure as a meaningful diagnostic (#2993 CR feedback):
 
 ```bash
-if [ -z "$GSD_DIR" ]; then
-  # No install detected — fall through to install step; version-check is skipped.
-  LATEST_RESULT=""
+uc_field() {
+  printf '%s' "$2" | node -e "let d='';process.stdin.setEncoding('utf8');process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const v=JSON.parse(d)[process.argv[1]];process.stdout.write(v==null?'':String(v));}catch{}})" "$1" 2>/dev/null
+}
+if LATEST_RESULT="$(node "$GSD_DIR/gsd-core/bin/check-latest-version.cjs" --json --tag "$TAG" 2>/dev/null)"; then
   LATEST_STATUS=0
-  LATEST_OK=false
-  LATEST_VERSION=""
-  LATEST_REASON="no_install_detected"
 else
-  LATEST_RESULT="$(node "$GSD_DIR/gsd-core/bin/check-latest-version.cjs" --json --tag "$TAG" 2>/dev/null)"
   LATEST_STATUS=$?
-  # #2993 CR: when node is missing or the script doesn't exist, LATEST_RESULT
-  # is empty and piping it to `jq` produces a parse error on stderr while
-  # leaving LATEST_OK / LATEST_REASON as empty strings. Fail the check with a
-  # meaningful reason instead of a blank diagnostic.
-  if [ -n "$LATEST_RESULT" ]; then
-    LATEST_OK="$(printf '%s' "$LATEST_RESULT" | jq -r '.ok // false')"
-    LATEST_VERSION="$(printf '%s' "$LATEST_RESULT" | jq -r '.version // empty')"
-    LATEST_REASON="$(printf '%s' "$LATEST_RESULT" | jq -r '.reason // empty')"
-  else
-    LATEST_OK=false
-    LATEST_VERSION=""
-    LATEST_REASON="script_not_found_or_node_unavailable"
-  fi
+fi
+# #2993 CR: when node is missing or the script doesn't exist, LATEST_RESULT
+# is empty. Fail the check with a meaningful reason instead of a blank
+# diagnostic.
+if [ -n "$LATEST_RESULT" ]; then
+  LATEST_OK="$(uc_field ok "$LATEST_RESULT")"
+  LATEST_OK="${LATEST_OK:-false}"
+  LATEST_VERSION="$(uc_field version "$LATEST_RESULT")"
+  LATEST_REASON="$(uc_field reason "$LATEST_RESULT")"
+else
+  LATEST_OK=false
+  LATEST_VERSION=""
+  LATEST_REASON="script_not_found_or_node_unavailable"
 fi
 ```
 
@@ -305,8 +313,8 @@ detected in `get_installed_version`:
 
 ```bash
 # RUNTIME_DIR is the resolved config directory (e.g. ~/.config/opencode, ~/.gemini).
-# get_installed_version emits it as GSD_DIR (LOCAL or GLOBAL install dir, or empty
-# when scope is UNKNOWN). Empty RUNTIME_DIR skips the backup below.
+# get_installed_version emits it as GSD_DIR for a resolved LOCAL or GLOBAL install.
+# The unresolved-target gate exits before this step; the empty guard remains defensive.
 RUNTIME_DIR="$GSD_DIR"
 ```
 
@@ -387,11 +395,6 @@ npx -y --package=@opengsd/gsd-core@"$TAG" -- gsd-core "$RUNTIME_FLAG" --local
 npx -y --package=@opengsd/gsd-core@"$TAG" -- gsd-core "$RUNTIME_FLAG" --global
 ```
 
-**If UNKNOWN install:**
-```bash
-npx -y --package=@opengsd/gsd-core@"$TAG" -- gsd-core --claude --global
-```
-
 Capture output. If install fails, show error and exit.
 
 Clear the update cache so statusline indicator disappears:

package/gsd-core/workflows/validate-phase.md

@@ -23,7 +23,7 @@ if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_AUDITOR=$(gsd_run query agent-skills gsd-nyquist-auditor)
 ```
 
-**If `response_language` is set:** All user-facing questions, prompts, and explanations in this workflow MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
+**If `response_language` is set:** All user-facing output of this workflow — narration between tool calls, status updates, progress notes, findings, questions, prompts, and explanations — MUST be presented in `{response_language}`. Technical terms, code, file paths, and subagent prompts stay in English — only user-facing output is translated.
 
 Parse: `phase_dir`, `phase_number`, `phase_name`, `phase_slug`, `padded_phase`.