diff --git a/CHANGELOG.md b/CHANGELOG.md index 2fe889ac0..801933326 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,56 @@ # Changelog +## [1.60.0.0] - 2026-07-09 + +## **Nine guard bugs fixed in one wave.** +## **Every fix ships with a tripwire that proves the guard actually guards.** + +This release closes out the silent-failure class across gstack: guards and tools that reported success while doing nothing. Question cards render again on current Claude Code builds. /careful catches chained, substituted, and capital-flag deletes it used to wave through. The design CLI fails loudly on bad flags instead of billing you for a guess. Shared team brains (thin clients) get brain-aware planning instead of silent suppression. Four of the fixes came from community PRs, absorbed with authorship intact and hardened on top. + +### The six numbers that matter + +Source: this branch's diff against v1.58.5.0. Every new test was first run against the unfixed code and confirmed failing, then confirmed passing after the fix. + +| What | Before | After | +|------|--------|-------| +| AskUserQuestion on Claude Code 2.1.89+ | "Tool result missing due to internal error" | card renders | +| `rm -R /`, `rm -rf $(cmd)/node_modules` via /careful | silent allow | ask | +| `design variants --count abc` | 0 variants, exit 0 | exit 1 with usage hint | +| Thin-client team brains | broken-config, brain blocks suppressed | usable, sync stages skip with reason | +| /office-hours SESSION_COUNT | ~2x inflated | exact | +| New tripwire test cases | n/a | 72 | + +The first row is the one to feel. The question-card primitive every interactive skill depends on was orphaned on current Claude Code builds: the preference hook emitted `permissionDecision:'defer'`, whose semantics became "pause for external resumption" in CC v2.1.89. The fix is a two-branch pass-through (exact-empty stdout, or additionalContext-only output for plan-tune memory nuggets), plus a corrected protocol reference doc so the mistake cannot be re-learned from our own docs. + +### What this means for you + +Interactive skills ask you questions again on current Claude Code. Safety guards fail closed: chained deletes, command substitution, capital `-R`, and destructive credential phrasings ("reset my secrets") all reach a human now. If your team runs a shared remote brain, `/sync-gbrain` and brain-aware planning work on thin clients out of the box. Run `/gstack-upgrade` to get all of it. The hook fix arrives with the file update, no settings change needed. + +### Itemized changes + +#### Fixed + +- **AskUserQuestion orphaned on Claude Code 2.1.89+ (#2035, #2006).** `question-preference-hook` pass-through is now exit 0 with exactly empty stdout (or additionalContext-only output for plan-tune memory nuggets), never `permissionDecision:'defer'`. `defer()` renamed `passThrough()`; the protocol contract in `docs/spikes/claude-code-hook-mutation.md` corrected in the same commit; 13 assertions rewritten across 3 test files; the tripwire asserts exact-empty stdout so a garbage write cannot slip past an optional-chained parse. Existing installs pick the fix up via `/gstack-upgrade` (the registered hook shim execs the TypeScript live). +- **/careful chained-rm bypass (#2039).** Contributed by @jbetala7: the safe-exception shortcut applies only to single commands; any shell separator falls through to the warning. Hardened on top: `$(` and backtick substitution count as separators, and both greps accept capital `-R` (the BSD/macOS recursive flag). `rm -rf /; rm -rf node_modules`, `rm -rf $(./wipe-all)/node_modules`, and `rm -R /` all ask now; `rm -Rf node_modules` alone still allows. +- **/context-restore loading a sibling worktree's checkpoint (#2052).** Contributed by @jbetala7: restore prefers the current branch's own checkpoint over newer sibling-worktree saves (scans 200 newest, partitions by branch frontmatter), and keeps the Conductor handoff fallback when the branch has no checkpoint. +- **/sync-gbrain drift re-register on gbrain 0.42+ (#1985).** Contributed by @jbetala7: the drift remove passes `--confirm-destructive`. Hardened on top: the remove routes through the #1734 data-loss guards (refuses loudly while an autopilot runs), propagates `--keep-storage`, realpath-normalizes drift detection (a symlink alias of the same directory is a match, not drift, the probable cause of the reporter's unmoved-repo drift), and logs old vs new path whenever drift fires. +- **Developer-profile double counting (#2067).** Contributed by @mvann: `mode:"resources"` bookkeeping rows no longer inflate SESSION_COUNT, TIER, or the builder-to-founder nudge; 8 regression tests pin the tier boundaries from both sides. +- **One-way-door credential net inert and leaky (#2024).** revoke/reset/rotate now share one noun list with plurals ("reset my secrets" classifies one-way), and the net is wired into the runtime: `gstack-question-preference --check --summary-stdin` pipes the question text (stdin, never argv, so quotes and newlines survive), and the enforcement hook falls back to the classifier for unregistered ids, so an ad-hoc destructive question with a stored never-ask preference can no longer auto-decide. +- **design CLI silent NaN flags (#2032).** `--count`, `--retry`, and `--timeout` share one loud contract via `design/src/flag-utils.ts`: non-integer input errors with exit 1 ("3.7" is rejected, not truncated), above-max clamps with a stderr warning, and the variants ceiling derives from the style list instead of a magic 7. Previously `--retry abc` made generate a silent no-op and `--timeout abc` killed the serve board at boot. +- **Thin-client brains misclassified as broken (#2051).** New `thin-client` engine state, read from gbrain's own `remote_mcp` config marker before any probe. Usable at every suppression gate (`--is-ok`, gen-skill-docs detection, `gstack-config gbrain-refresh`) while the local sync stages skip with an accurate reason (code indexing runs on the brain server; memory syncs via the remote brain's artifacts pull). The detect JSON reports `gbrain_thin_client: {probed: false}`: config verified, reachability checked at use time where gbrain calls degrade gracefully. detectMcpMode also recognizes gbrain servers registered under variant names or matched by the config's `mcp_url`. + +#### Closed as already fixed, with receipts + +- #1965 (GBRAIN_PREPARE pooler breakage): `lib/gbrain-exec.ts:86` never sets it; pinned by `test/build-gbrain-env.test.ts:121-142`. +- #1950 (Windows git-bash learnings silently dropped): `bin/gstack-learnings-log:10-15` cygpath fix + stderr surfacing; pinned by `test/bin-windows-bun-import-paths.test.ts`. +- #1964 (slow engines misclassified): `probeTimeoutMs()` honors `GSTACK_GBRAIN_PROBE_TIMEOUT_MS`; timeout classifies usable; pinned by `test/gbrain-local-status.test.ts`. + +#### For contributors + +- 11 bisect commits; 4 community PRs absorbed with authorship preserved. Contributed by @jbetala7 (#2040, #2054, #2031) and @mvann (#1991). Thank you both. +- 72 new test cases across 9 files, each verified failing against the unfixed code before the fix landed. +- Three follow-ups filed in TODOS.md: wire `design/test/` into CI (all 8 existing files are invisible to every runner today, plus a documented pre-existing timing flake), /context-save worktree-identity hardening (the #2052 residual), and conditional gbrain reindex-in-place gated on the new drift log. + ## [1.58.5.0] - 2026-06-21 ## **A fresh install now lands on a concrete first move, not a dead end.** diff --git a/TODOS.md b/TODOS.md index f9753970b..b80079492 100644 --- a/TODOS.md +++ b/TODOS.md @@ -45,6 +45,74 @@ a silent mistake breaks all 52 skills. High blast radius — needs its own focus ## Test infrastructure +### P2: Wire `design/test/` into CI (all 8 files are invisible to every runner) + +**What:** Add `design/test/` to the `bun test` glob (`package.json:21`) and +`TEST_ROOTS` (`scripts/test-free-shards.ts:32`) after auditing its 8 files for +server-spawning/flakiness (they were plausibly excluded on purpose). While in +there, fix the known timing flake: `variants-retry-after.test.ts` "HTTP-date: +honors a future date with no extra leading exponential" fails ~1-2 in 9 runs +under parallel suite load (verified pre-existing on v1.58.5.0 during the +June 2026 fix wave — wall-clock assertion with a ~2s window). + +**Why:** Every test in `design/test/` runs only when someone types the path by +hand — a silent coverage hole, the fix wave's theme at meta-level. The wave's +own design tests went into `test/design-flag-utils.test.ts` to dodge this. + +**Pros:** design binary gets CI coverage; kills a latent "we have tests" illusion. +**Cons:** unaudited files may spawn servers or flake; audit first, wire second. + +**Context:** Filed from the June 2026 fix-wave eng review (issue 11 + flake +receipts). Start with the audit: which of the 8 files are hermetic? Wire the +hermetic ones, quarantine or fix the rest. + +**Effort:** S-M (human ~1d, CC ~30min). **Depends on:** None. + +### P2: /context-save worktree-identity hardening (the #2052 residual) + +**What:** Persist a stable worktree identity (path hash or worktree name) into +checkpoint frontmatter at save time; `/context-restore` prefers identity match +over branch-name match. PR #2054 (@jbetala7, absorbed in the June 2026 wave) +fixed restore ORDERING (current-branch first), but branch frontmatter is not a +stable worktree identity: same-name branches across clones/remotes, renamed +branches, and detached HEAD can still restore the wrong checkpoint. + +**Why:** Closes the residual wrong-checkpoint class entirely instead of the +common case. Codex outside-voice concurred during the wave's eng review. + +**Pros:** Eliminates cross-clone checkpoint collisions. +**Cons:** Frontmatter schema change; needs a migration story for old +checkpoints (no-identity checkpoints rank as fallback, like #2054's +no-branch handling). + +**Context:** Filed from the June 2026 fix-wave eng review (NOT-in-scope item). +Start at `context-restore/SKILL.md.tmpl` Step 1 + `/context-save`'s frontmatter +writer; mirror #2054's partition logic with identity as the first key. + +**Effort:** S (human ~4h, CC ~20min). **Depends on:** #2054 (landed in the wave). + +### P3: gbrain reindex-in-place on perpetual drift (conditional — check the drift log first) + +**What:** IF the `[gbrain-sources] drift:` stderr line (added in the June 2026 +wave) shows drift firing on every sync for some environment, implement #1985's +reporter design: refresh an existing source in place with `gbrain reindex-code` +instead of remove+add (which drops and re-embeds the full index — 768 pages / +6,786 embeddings in the reporter's case). + +**Why:** Perpetual drift means paying full re-embed cost every sync. The wave's +`realpathSync` normalization (symlink aliases are a match, not drift) may have +eliminated the drift class entirely — that's why this is conditional. + +**Pros:** Avoids repeated embedding spend for affected environments. +**Cons:** Speculative until the drift log produces evidence; reindex-in-place +has its own consistency questions (stale chunks for deleted files). + +**Context:** Filed from the June 2026 fix-wave eng review (4A observability). +Trigger condition documented in `lib/gbrain-sources.ts` at the drift log line. + +**Effort:** M (human ~1d, CC ~45min). **Depends on:** drift-log evidence from +the wave's `ensureSourceRegistered` logging. + ### Eval harness: live progress + incremental result persistence (kill the silent hour) **Priority:** P1 diff --git a/VERSION b/VERSION index 2153ce66b..267a65ff8 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.58.5.0 +1.60.0.0 diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md index 5346f1d43..de3536c63 100644 --- a/autoplan/SKILL.md +++ b/autoplan/SKILL.md @@ -711,7 +711,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/canary/SKILL.md b/canary/SKILL.md index 08d4d7369..1bce6dea6 100644 --- a/canary/SKILL.md +++ b/canary/SKILL.md @@ -703,7 +703,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/codex/SKILL.md b/codex/SKILL.md index 33228ff9b..9d2710fcc 100644 --- a/codex/SKILL.md +++ b/codex/SKILL.md @@ -706,7 +706,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/context-restore/SKILL.md b/context-restore/SKILL.md index 4a0132af5..5f3d5d498 100644 --- a/context-restore/SKILL.md +++ b/context-restore/SKILL.md @@ -707,7 +707,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/context-save/SKILL.md b/context-save/SKILL.md index a1eb24595..57a70247f 100644 --- a/context-save/SKILL.md +++ b/context-save/SKILL.md @@ -706,7 +706,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/cso/SKILL.md b/cso/SKILL.md index a08d7e9fe..0f173d41b 100644 --- a/cso/SKILL.md +++ b/cso/SKILL.md @@ -709,7 +709,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/design-consultation/SKILL.md b/design-consultation/SKILL.md index 83eed0a2d..6efd5c5b2 100644 --- a/design-consultation/SKILL.md +++ b/design-consultation/SKILL.md @@ -729,7 +729,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/design-html/SKILL.md b/design-html/SKILL.md index a480bd62c..6abfbfeb9 100644 --- a/design-html/SKILL.md +++ b/design-html/SKILL.md @@ -710,7 +710,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/design-review/SKILL.md b/design-review/SKILL.md index 645453162..89720c0c2 100644 --- a/design-review/SKILL.md +++ b/design-review/SKILL.md @@ -707,7 +707,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/design-shotgun/SKILL.md b/design-shotgun/SKILL.md index 3386d18fa..5faa4b8a8 100644 --- a/design-shotgun/SKILL.md +++ b/design-shotgun/SKILL.md @@ -724,7 +724,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/devex-review/SKILL.md b/devex-review/SKILL.md index 7ef324b3e..21f1cf930 100644 --- a/devex-review/SKILL.md +++ b/devex-review/SKILL.md @@ -709,7 +709,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/diagram/SKILL.md b/diagram/SKILL.md index 9e5a41066..0bd159f86 100644 --- a/diagram/SKILL.md +++ b/diagram/SKILL.md @@ -704,7 +704,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/document-generate/SKILL.md b/document-generate/SKILL.md index 30846fc4d..83af17881 100644 --- a/document-generate/SKILL.md +++ b/document-generate/SKILL.md @@ -709,7 +709,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/document-release/SKILL.md b/document-release/SKILL.md index b95873625..7ad9cf40f 100644 --- a/document-release/SKILL.md +++ b/document-release/SKILL.md @@ -707,7 +707,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/health/SKILL.md b/health/SKILL.md index e68199dec..1e9e602e8 100644 --- a/health/SKILL.md +++ b/health/SKILL.md @@ -705,7 +705,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/investigate/SKILL.md b/investigate/SKILL.md index 5d54b4256..583937771 100644 --- a/investigate/SKILL.md +++ b/investigate/SKILL.md @@ -744,7 +744,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/ios-clean/SKILL.md b/ios-clean/SKILL.md index 127649646..2937a9869 100644 --- a/ios-clean/SKILL.md +++ b/ios-clean/SKILL.md @@ -707,7 +707,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/ios-design-review/SKILL.md b/ios-design-review/SKILL.md index 904da7589..ef6589618 100644 --- a/ios-design-review/SKILL.md +++ b/ios-design-review/SKILL.md @@ -709,7 +709,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/ios-fix/SKILL.md b/ios-fix/SKILL.md index 3ddae1ac0..b2662eced 100644 --- a/ios-fix/SKILL.md +++ b/ios-fix/SKILL.md @@ -710,7 +710,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/ios-qa/SKILL.md b/ios-qa/SKILL.md index a5d4575d4..8343a1ad0 100644 --- a/ios-qa/SKILL.md +++ b/ios-qa/SKILL.md @@ -713,7 +713,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/ios-sync/SKILL.md b/ios-sync/SKILL.md index 2f689c4d6..a7585fbc1 100644 --- a/ios-sync/SKILL.md +++ b/ios-sync/SKILL.md @@ -707,7 +707,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/land-and-deploy/SKILL.md b/land-and-deploy/SKILL.md index 54ebf52c0..f53675abc 100644 --- a/land-and-deploy/SKILL.md +++ b/land-and-deploy/SKILL.md @@ -702,7 +702,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/landing-report/SKILL.md b/landing-report/SKILL.md index 8f7e6e210..ddcbfe6b7 100644 --- a/landing-report/SKILL.md +++ b/landing-report/SKILL.md @@ -703,7 +703,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/learn/SKILL.md b/learn/SKILL.md index a0c6ae053..edc67a480 100644 --- a/learn/SKILL.md +++ b/learn/SKILL.md @@ -705,7 +705,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/office-hours/SKILL.md b/office-hours/SKILL.md index 83161b8ca..76f1ba049 100644 --- a/office-hours/SKILL.md +++ b/office-hours/SKILL.md @@ -740,7 +740,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/open-gstack-browser/SKILL.md b/open-gstack-browser/SKILL.md index 28fb1ddb2..60e2d02d2 100644 --- a/open-gstack-browser/SKILL.md +++ b/open-gstack-browser/SKILL.md @@ -702,7 +702,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/package.json b/package.json index 4727042e5..c7358be18 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "gstack", - "version": "1.58.5.0", + "version": "1.60.0.0", "description": "Garry's Stack — Claude Code skills + fast headless browser. One repo, one install, entire AI engineering workflow.", "license": "MIT", "type": "module", diff --git a/pair-agent/SKILL.md b/pair-agent/SKILL.md index eed9d171a..fe16ad3ec 100644 --- a/pair-agent/SKILL.md +++ b/pair-agent/SKILL.md @@ -704,7 +704,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/plan-ceo-review/SKILL.md b/plan-ceo-review/SKILL.md index 3d3208bee..cbe6f7a23 100644 --- a/plan-ceo-review/SKILL.md +++ b/plan-ceo-review/SKILL.md @@ -734,7 +734,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/plan-design-review/SKILL.md b/plan-design-review/SKILL.md index e81f7f12a..c8afb02fb 100644 --- a/plan-design-review/SKILL.md +++ b/plan-design-review/SKILL.md @@ -706,7 +706,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/plan-devex-review/SKILL.md b/plan-devex-review/SKILL.md index 20a32da8b..a03230616 100644 --- a/plan-devex-review/SKILL.md +++ b/plan-devex-review/SKILL.md @@ -712,7 +712,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/plan-eng-review/SKILL.md b/plan-eng-review/SKILL.md index 5557a33fa..4770180b9 100644 --- a/plan-eng-review/SKILL.md +++ b/plan-eng-review/SKILL.md @@ -710,7 +710,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/plan-tune/SKILL.md b/plan-tune/SKILL.md index f49b66fac..b5ec6ab1c 100644 --- a/plan-tune/SKILL.md +++ b/plan-tune/SKILL.md @@ -715,7 +715,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/qa-only/SKILL.md b/qa-only/SKILL.md index 801a935c0..b5ace46a9 100644 --- a/qa-only/SKILL.md +++ b/qa-only/SKILL.md @@ -705,7 +705,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/qa/SKILL.md b/qa/SKILL.md index c1ac10253..18cc7414c 100644 --- a/qa/SKILL.md +++ b/qa/SKILL.md @@ -711,7 +711,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/retro/SKILL.md b/retro/SKILL.md index 3fbc44726..2ce902083 100644 --- a/retro/SKILL.md +++ b/retro/SKILL.md @@ -722,7 +722,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/review/SKILL.md b/review/SKILL.md index 5f26e2e42..0bb8ce714 100644 --- a/review/SKILL.md +++ b/review/SKILL.md @@ -707,7 +707,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/scrape/SKILL.md b/scrape/SKILL.md index dc965ec5f..a241757ca 100644 --- a/scrape/SKILL.md +++ b/scrape/SKILL.md @@ -703,7 +703,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/setup-deploy/SKILL.md b/setup-deploy/SKILL.md index 3465dc564..62e1596dd 100644 --- a/setup-deploy/SKILL.md +++ b/setup-deploy/SKILL.md @@ -706,7 +706,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/setup-gbrain/SKILL.md b/setup-gbrain/SKILL.md index 89c2ffbc3..216f84476 100644 --- a/setup-gbrain/SKILL.md +++ b/setup-gbrain/SKILL.md @@ -705,7 +705,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. @@ -820,9 +824,13 @@ Capture the JSON output. It contains: `gbrain_on_path`, `gbrain_version`, `gbrain_config_exists`, `gbrain_engine`, `gbrain_doctor_ok`, `gbrain_mcp_mode`, `gstack_brain_sync_mode`, `gstack_brain_git`, `gstack_artifacts_remote`, and the v1.34.0.0+ `gbrain_local_status` field (one of: `ok`, `no-cli`, -`missing-config`, `broken-config`, `broken-db`, `timeout`). Treat `timeout` -like `ok` (slow-but-healthy engine, #1964) — it never triggers Step 1.5 -remediation. +`missing-config`, `broken-config`, `broken-db`, `timeout`, `thin-client`). +Treat `timeout` like `ok` (slow-but-healthy engine, #1964) — it never triggers +Step 1.5 remediation. Treat `thin-client` like `ok` too (#2051): the machine +is a thin client of a remote-HTTP MCP brain, no local engine by design — +brain-aware blocks render, and the detect JSON carries +`gbrain_thin_client: {probed: false}` (config verified; remote reachability +is checked at use time, where gbrain calls degrade gracefully). Skip downstream steps that are already done. Report the detected state in one line so the user knows what you found: diff --git a/ship/SKILL.md b/ship/SKILL.md index eadffaa8f..845951470 100644 --- a/ship/SKILL.md +++ b/ship/SKILL.md @@ -707,7 +707,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/skillify/SKILL.md b/skillify/SKILL.md index 7cb434d0c..7ca21f3b7 100644 --- a/skillify/SKILL.md +++ b/skillify/SKILL.md @@ -703,7 +703,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/spec/SKILL.md b/spec/SKILL.md index 0894e98d1..e0e06fa7a 100644 --- a/spec/SKILL.md +++ b/spec/SKILL.md @@ -704,7 +704,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. @@ -1774,7 +1778,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. diff --git a/sync-gbrain/SKILL.md b/sync-gbrain/SKILL.md index bfaf291d2..abe5c4d68 100644 --- a/sync-gbrain/SKILL.md +++ b/sync-gbrain/SKILL.md @@ -705,7 +705,11 @@ If you are looping on the same diagnostic, same file, or failed fix variants, ST ## Question Tuning (skip entirely if `QUESTION_TUNING: false`) -Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run `~/.claude/skills/gstack/bin/gstack-question-preference --check ""`. `AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. +Before each AskUserQuestion, choose `question_id` from `scripts/question-registry.ts` or `{skill}-{slug}`, then run the check with the question summary piped on stdin (the summary lets the one-way keyword net catch ad-hoc destructive questions whose id has no registry entry — #2024; stdin, never argv, so quotes/newlines survive): +```bash +printf '%s' "" | ~/.claude/skills/gstack/bin/gstack-question-preference --check "" --summary-stdin +``` +`AUTO_DECIDE` means choose the recommended option and say "Auto-decided [summary] → [option] (your preference). Change with /plan-tune." `ASK_NORMALLY` means ask. **Embed the question_id as a marker in the question text** so hooks can identify it deterministically (plan-tune cathedral T14 / D18 progressive markers). Append `` somewhere in the rendered question (the leading line or trailing line is fine; the marker doesn't render visibly to the user when wrapped in HTML-style angle brackets, but the hook strips it). Without the marker the PreToolUse enforcement hook treats the AUQ as observed-only and never auto-decides — so always include it when the question matches a registered `question_id`. @@ -893,6 +897,14 @@ BEFORE invoking the orchestrator: slow (cold pooler connection, #1964). Tell the user in one line: "Engine probe timed out (>15s) — proceeding; raise `GSTACK_GBRAIN_PROBE_TIMEOUT_MS` if your pooler is slow." Do NOT treat this as a broken config. +- **`thin-client`**: proceed to Step 2 — this machine is a thin client of a + remote-HTTP MCP brain (#2051): no local engine BY DESIGN, so the code, + memory, and dream stages will SKIP with a thin-client reason (code indexing + runs on the brain server; memory syncs via the remote brain's artifacts + pull). Only the brain-sync push runs locally. Tell the user in one line: + "Thin client of a remote brain — local stages skip by design; brain queries + work via remote MCP (reachability is verified at use time, not probed + here)." Do NOT route this into the broken-config remediation. - **`no-cli`**: STOP. "Local gbrain CLI not installed. Run `/setup-gbrain` first." - **`missing-config`** AND `gbrain_mcp_mode == "remote-http"`: tell the user