@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.8e6112e9

package/dist/resources/extensions/gsd/prompts/plan-milestone.md

@@ -47,6 +47,8 @@ If milestone research is inlined, trust it and skip redundant exploration. If fi
 
 Narrate decomposition reasoning in complete sentences: grouping, risk order, verification strategy.
 
+**Web apps:** when inlined Web App UAT guidance is present, set milestone `Verification Classes` → UAT to browser-observable acceptance (Playwright spec or `browser_*` checks). Order an early slice to add Playwright smoke scaffolding when the dependency is missing.
+
 Then:
 1. Use the **Roadmap** output template from the inlined context above
 2. {{skillActivation}}
@@ -116,4 +118,4 @@ If external API keys or secrets are required, use the inlined **Secrets Manifest
 
 If no external API keys or secrets are required, skip this step; do not create an empty manifest.
 
-When done, say: "Milestone {{milestoneId}} planned."
+When done, say: "Milestone {{milestoneId}} planned." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -41,10 +41,11 @@ If slice research is inlined, trust its architectural findings, but verify every
 3. Use the inlined Output Template sections already present in this prompt. Do not read template files from disk.
 4. {{skillActivation}} Record expected executor skills in each task plan's `skills_used` frontmatter.
 5. Define slice verification before tasks. Non-trivial slices need real tests or executable assertions; boundary contracts need contract-exercising checks. Tests must not read .gitignore/gitignored paths such as `.gsd/`, `.planning/`, or `.audits/`.
+   **Web apps:** when inlined Web App UAT guidance is present, follow it — add Playwright smoke scaffolding on the first UI slice if missing, name localhost preconditions, and plan verification commands that match browser-capable UAT modes at slice closeout.
 6. Include Threat Surface (Q3), Requirement Impact (Q4), proof level, observability, integration closure, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) only where applicable.
 7. Right-size tasks. Simple slices can be one task; split only when context, ownership, or verification boundaries justify it.
 8. Task `verify` commands must be safe, simple commands. Do not use shell pipes, redirects, semicolons, backticks, command substitution, output trimming, or grep regex alternation with `|`. If multiple checks are needed, create a small test file and run it with `node --test` or a package test script, or use separate simple commands joined only with `&&`. For absence checks, verify a pattern does not exist with `! grep -q 'pattern' file` or `! rg -q 'pattern' file`; do not use `grep -c` or `rg -c` to assert zero matches because count commands exit 1 when they find zero matches, and the verification gate treats that as failure.
-9. Each task needs the exact `gsd_plan_slice.tasks[]` shape: `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. `description` should contain the Why / Do / Done-when narrative. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even when there is only one path (for example, `"inputs": ["src/index.ts"]`, never `"inputs": "src/index.ts"`). Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expectedOutput` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, tests, or describes — those belong in `inputs`, `verify`, `description`, or slice success criteria. If a task is a pure verification or test task that produces no new files, `expectedOutput` must be `[]`; if it writes a test-result log or assertion output file, list only that concrete file path. A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expectedOutput` — if no prior task creates it, add a task before this one that does.
+9. Each task needs the exact `gsd_plan_slice.tasks[]` shape: `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. `description` should contain the Why / Do / Done-when narrative. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even when there is only one path (for example, `"inputs": ["src/index.ts"]`, never `"inputs": "src/index.ts"`). Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expectedOutput` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, tests, or describes — those belong in `inputs`, `verify`, `description`, or slice success criteria. If a task is a pure verification or test task that produces no new files, `expectedOutput` must be `[]`; if it writes a test-result log or assertion output file, list only that concrete file path. A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expectedOutput` — if no prior task creates it, add a task before this one that does. Never list GSD planning artifacts — anything under `.gsd/`, `.planning/`, or `.audits/`, or artifact names like `M001-CONTEXT.md` / `S01-PLAN.md` — in `inputs`, `files`, or `expectedOutput`: their content is preloaded as context, and they are written by workflow tools, not by tasks.
 10. Persist with `gsd_plan_slice` using `milestoneId`, `sliceId`, `goal`, optional `successCriteria`/`proofLevel`/`integrationClosure`/`observabilityImpact`, and `tasks`. `gsd_plan_slice` handles task persistence transactionally and renders `{{outputPath}}` plus task plans; do not call `gsd_plan_task`. The DB-backed tool is the canonical write path. Do **not** rely on direct `PLAN.md` writes as the source of truth.
 11. Self-audit before finishing: goal/demo closure, requirement coverage, deliverable coverage audit (cross-check every file listed in CONTEXT.md `## Scope` / `### In Scope` against task `files` or `expectedOutput`), locked decisions, concrete paths, dependency order, wiring, scope size, proof truthfulness, feature completeness, and quality gates. Quality gates: non-trivial slices/tasks include specific Q3-Q7 coverage where applicable.
 12. If planning creates structural decisions, call `gsd_decision_save` for each; the tool persists the decision and regenerates `.gsd/DECISIONS.md`.
@@ -56,4 +57,4 @@ The slice directory already exists. Do not mkdir.
 
 **You MUST call `gsd_plan_slice` to persist planning state before finishing, unless the stale-path safety rule above stops the unit before safe planning can occur.**
 
-When done, say: "Slice {{sliceId}} planned."
+When done, say: "Slice {{sliceId}} planned." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/quick-task.md

@@ -37,4 +37,4 @@ You are executing a GSD quick task — a lightweight, focused unit of work outsi
 - <what was tested/verified>
 ```
 
-When done, say: "Quick task {{taskNum}} complete."
+When done, say: "Quick task {{taskNum}} complete." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/reassess-roadmap.md

@@ -67,4 +67,4 @@ If `.gsd/REQUIREMENTS.md` exists and requirement ownership or status changed, up
 
 **DB access safety:** Do NOT query `.gsd/gsd.db` directly via `sqlite3` or `node -e require('better-sqlite3')`. Use `gsd_milestone_status` to read current milestone and slice state. All roadmap mutations go through `gsd_reassess_roadmap` — the tool writes to the DB and re-renders ROADMAP.md atomically.
 
-When done, say: "Roadmap reassessed."
+When done, say: "Roadmap reassessed." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/refine-slice.md

@@ -63,8 +63,9 @@ Then:
    - `{{taskPlanTemplatePath}}`
 2. {{skillActivation}} Record the installed skills you expect executors to use in each task plan's `skills_used` frontmatter.
 3. Define slice-level verification: the objective stopping condition. Plan real test files with real assertions; for simple slices, executable commands are fine.
+   **Web apps:** when inlined Web App UAT guidance is present, follow it for Playwright scaffolding and browser-capable verification commands.
 4. For non-trivial slices, plan observability / proof level / integration closure, threat surface, and requirement impact. Omit entirely for simple slices.
-5. Decompose the slice into tasks that fit one context window each. Every task passed to `gsd_plan_slice` must use the exact keys `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. Put Why / Do / Done-when detail in `description`. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even for one path (for example, `"expectedOutput": ["src/index.ts"]`, never `"expectedOutput": "src/index.ts"`). `expectedOutput` is path-only: list only files the task creates or overwrites, and use `[]` for pure verification tasks.
+5. Decompose the slice into tasks that fit one context window each. Every task passed to `gsd_plan_slice` must use the exact keys `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. Put Why / Do / Done-when detail in `description`. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even for one path (for example, `"expectedOutput": ["src/index.ts"]`, never `"expectedOutput": "src/index.ts"`). `expectedOutput` is path-only: list only files the task creates or overwrites, and use `[]` for pure verification tasks. Never list GSD planning artifacts — anything under `.gsd/`, `.planning/`, or `.audits/`, or artifact names like `M001-CONTEXT.md` / `S01-PLAN.md` — in `inputs`, `files`, or `expectedOutput`: their content is preloaded as context, and they are written by workflow tools, not by tasks.
 6. **Persist planning state through `gsd_plan_slice`.** Call it with the full payload. The tool writes to the DB and renders `{{outputPath}}` and `{{slicePath}}/tasks/T##-PLAN.md` automatically. Do NOT rely on direct `PLAN.md` writes.
 7. **Self-audit the plan.** If every task were completed exactly as written, the slice goal/demo should be true. Every must-have maps to a task. Inputs and Expected Output are backtick-wrapped file paths.
 8. If refinement produced structural decisions that diverge from the sketch, call `gsd_decision_save` for each; the tool persists the decision and regenerates `.gsd/DECISIONS.md`.
@@ -76,4 +77,4 @@ The slice directory and tasks/ subdirectory already exist. Do NOT mkdir.
 
 **You MUST call `gsd_plan_slice` to persist planning state before finishing.** After success, the pipeline clears the sketch flag on next state derivation; the on-disk PLAN file is the signal.
 
-When done, say: "Slice {{sliceId}} refined."
+When done, say: "Slice {{sliceId}} refined." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/replan-slice.md

@@ -34,8 +34,8 @@ Consider these captures when rewriting the remaining tasks — they represent th
 
 1. Use the inlined blocker summary excerpt first. Read the full blocker task summary only if the excerpt is absent, marked truncated, or lacks the specific blocker evidence needed to replan.
 2. Analyze the remaining `[ ]` tasks in the slice plan. Determine which are still valid, which need modification, and which should be replaced.
-3. **Persist replan state through `gsd_replan_slice`.** Call it with: `milestoneId`, `sliceId`, `blockerTaskId`, `blockerDescription`, `whatChanged`, `updatedTasks` (array of task objects with taskId, title, description, estimate, files, verify, inputs, expectedOutput), `removedTaskIds` (array of task ID strings). The tool structurally enforces preservation of completed tasks, writes replan history to the DB, re-renders `{{planPath}}`, and renders `{{replanPath}}`. Preserve or update the Threat Surface and Requirement Impact sections if the replan changes the slice's security posture or requirement coverage.
+3. **Persist replan state through `gsd_replan_slice`.** Call it with: `milestoneId`, `sliceId`, `blockerTaskId`, `blockerDescription`, `whatChanged`, `updatedTasks` (array of task objects with taskId, title, description, estimate, files, verify, inputs, expectedOutput), `removedTaskIds` (array of task ID strings). Never list GSD planning artifacts — anything under `.gsd/`, `.planning/`, or `.audits/`, or artifact names like `M001-CONTEXT.md` / `S01-PLAN.md` — in `inputs`, `files`, or `expectedOutput`: their content is preloaded as context, and they are written by workflow tools, not by tasks. The tool structurally enforces preservation of completed tasks, writes replan history to the DB, re-renders `{{planPath}}`, and renders `{{replanPath}}`. Preserve or update the Threat Surface and Requirement Impact sections if the replan changes the slice's security posture or requirement coverage.
 4. If any incomplete task had a `T0x-PLAN.md`, remove or rewrite it to match the new task description.
 5. Do not commit manually — the system auto-commits your changes after this unit completes.
 
-When done, say: "Slice {{sliceId}} replanned."
+When done, say: "Slice {{sliceId}} replanned." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/research-milestone.md

@@ -46,4 +46,4 @@ Then research the codebase and relevant technologies. Narrate key findings and s
 
 **You MUST call `gsd_summary_save` with the research content before finishing.**
 
-When done, say: "Milestone {{milestoneId}} researched."
+When done, say: "Milestone {{milestoneId}} researched." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/research-slice.md

@@ -55,4 +55,4 @@ The slice directory already exists at `{{slicePath}}/`. Do NOT mkdir.
 
 **You MUST call `gsd_summary_save` with the research content before finishing.**
 
-When done, say: "Slice {{sliceId}} researched."
+When done, say: "Slice {{sliceId}} researched." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/rewrite-docs.md

@@ -30,4 +30,4 @@ An override was issued by the user that changes a fundamental decision or approa
 
 **You MUST update the relevant documents AND mark overrides as resolved in `{{overridesPath}}` before finishing.**
 
-When done, say: "Override applied across all documents."
+When done, say: "Override applied across all documents." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/run-uat.md

@@ -10,6 +10,8 @@ If any inlined plan, summary, verification command, or prior artifact names an a
 
 All relevant context has been preloaded below. Start working immediately without re-reading these files.
 
+If a `.gsd/**` or `.gsd/**/*` glob returns no matches, treat that as a possible symlink-backed traversal limitation; do not infer that the GSD harness is missing. Use the preloaded UAT context and direct `.gsd/...` file paths named in this prompt instead.
+
 {{inlinedContext}}
 
 {{skillActivation}}
@@ -27,21 +29,23 @@ You are the UAT runner. Execute every check defined in `{{uatPath}}` as deeply a
 ### Automation rules by mode
 
 - `artifact-driven` — verify with shell commands, scripts, file reads, and artifact structure checks.
-- `browser-executable` — use browser tools to navigate to the target URL and verify expected behavior. Prefer direct `browser_*` tools when available. Capture screenshots as evidence. Record pass/fail with specific assertions.
-- `runtime-executable` — execute the specified command or script. Capture stdout/stderr as evidence. Record pass/fail based on exit code and output.
+- `browser-executable` — use browser tools to navigate to the target URL and verify expected behavior. Prefer direct `browser_*` tools when available. Capture screenshots as evidence. Record pass/fail with specific assertions. When the UAT **Evidence** section names a self-contained runtime harness (for example `npm run test:uat` or `node tests/browser/search-uat.mjs`), treat the effective mode as **runtime-executable** instead: run that command only and do not start a separate server or `browser_navigate` to a hardcoded localhost port.
+- `runtime-executable` — execute the specified command or script. Capture stdout/stderr as evidence. Record pass/fail based on exit code and output. When the verification script starts its own dev/static server (for example `node tests/browser/search-uat.mjs`), do **not** start a separate server with `uat-service-start` — the script owns server lifecycle and binds an ephemeral port. If a server is already running, pass its URL via `UAT_BASE_URL` or `PORT` in the `gsd_uat_exec` environment instead of hardcoding a fixed port like 4173.
 - `live-runtime` — exercise the real runtime path. Start or connect to the app/service if needed, use browser/runtime/network checks, and verify observable behavior.
 - `mixed` — run all automatable artifact-driven and live-runtime checks. Separate any remaining human-only checks explicitly.
 - `human-experience` — automate setup, preconditions, screenshots, logs, and objective checks, but do **not** invent subjective PASS results. Mark taste-based, experiential, or purely human-judgment checks as `NEEDS-HUMAN`. Use an overall verdict of `PASS` when all automatable checks succeed (even if human-only checks remain as `NEEDS-HUMAN`). Use `PARTIAL` only when automatable checks themselves were inconclusive.
 
 ### Evidence tools
 
-Choose the lightest tool that proves the check honestly:
+The **Tool Surface** block prepended above lists unavailable tools for this unit. In short:
 
 - Run automated checks with `gsd_uat_exec`
   - Use `uat-artifact-check` as `intent` for static file, grep, structure, or artifact checks.
   - Use `uat-runtime-check` as `intent` for executing tests, scripts, or runtime assertions.
   - Use `uat-browser-check` as `intent` for browser interaction or screenshot-backed UI checks.
-  - Use `uat-service-start` as `intent` only when starting or connecting to an app/service.
+  - Use `uat-service-start` as `intent` only when starting or connecting to an app/service that the UAT checks will not start themselves.
+  - Do not start a dev/static server separately when a runtime test script owns server lifecycle — run the script directly instead.
+  - When you do start a service, capture the URL from its stdout (for example `Ready at http://127.0.0.1:PORT`) and pass it to downstream checks via `UAT_BASE_URL` rather than assuming a fixed port.
   - Use `uat-log-inspection` as `intent` for checking logs or captured output files.
   - The result-table evidence mode is separate; do not use `artifact`, `runtime`, or `human-follow-up` as `intent`.
 - Run `grep` / `rg` checks against files
@@ -98,4 +102,4 @@ checks: [{
 
 **You MUST call `gsd_uat_result_save` before finishing. Do not write the assessment file directly, and do not call `gsd_summary_save` as a substitute.**
 
-When done, say: "UAT {{sliceId}} complete."
+When done, say: "UAT {{sliceId}} complete." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/system.md

@@ -110,9 +110,12 @@ Templates are in `{{templatesDir}}`.
 
 **External facts:** Use `search-the-web` + `fetch_page`, or `search_and_read`; use `freshness` for recency. Never state current facts from training data without verification.
 
-**Background processes:** Use `bg_shell` `start` + `wait_for_ready` for servers/watchers/daemons. Never use `bash` with `&` or `nohup`; inherited stdout can hang. Never poll with `sleep`; use `wait_for_ready`. For status use `digest`, `highlights` for significant lines, and `output` only when debugging.
+**Choosing a shell tool — decide by how the command runs, not how long it takes:**
 
-**One-shot commands:** Use `async_bash` for builds, tests, and installs. Results are pushed on exit; use `await_job` only to block on a specific job.
+- **Runs and exits (a batch command):** anything that does work and finishes — `terraform apply`, DB migrations, builds, tests, installs, long scripts. Use synchronous `bash` when you want to block and read the result now (uncapped; in auto-mode genuine hangs are caught by the stalled-tool watchdog, interactively they end on human ESC). Use `async_bash` when you want it non-blocking — it returns a job ID immediately and you `await_job` later. **Never** put a run-to-completion command under `bg_shell` `wait_for_ready`: it exits instead of staying alive, so readiness never trips and a clean exit looks like a failure.
+- **Stays alive and you interact with it over time:** servers, watchers, daemons, REPLs. Use `bg_shell` `start`, then `wait_for_ready` (block until it listens/prints its ready pattern), `output`/`digest`/`highlights` to inspect, `send`/`send_and_wait` to drive it, and `kill`/`restart` to manage it. Never use `bash` with `&` or `nohup` (inherited stdout can hang); never poll with `sleep` (use `wait_for_ready`).
+
+Quick rule of thumb: if the command would exit on its own, it's `bash`/`async_bash`; if it would keep running until you stop it, it's `bg_shell`.
 
 **Stale job hygiene:** After editing source to fix a failure, `cancel_job` every in-flight `async_bash` job before rerunning. Changed inputs make in-flight outputs untrusted.
 
@@ -158,7 +161,7 @@ Fix root causes, not symptoms. If applying temporary mitigation, label it and pr
 - State uncertainty plainly: "Not sure this handles X - testing it." No performed confidence, no hedging paragraphs.
 - All user-visible narration must be grammatical English. Do not emit compressed planner notes like "Need inspect X". If it fits a commit comment or standup note, it is acceptable.
 - When debugging, stay curious. Problems are puzzles. Say what's interesting about the failure before reaching for fixes.
-- After completing a task, give a brief summary and 2-4 numbered next-step options; last option is always "Other". Omit the list for strict output formats.
+- After completing a task, give a brief summary and 2-4 numbered next-step options; last option is always "Other". Omit the list for strict output formats, or when the active workflow prompt already ends with its own explicit "Next steps:" handoff block — in that case follow the workflow's handoff and do not add a second list.
 
   If any next step is destructive/outward-facing, present it via `ask_user_questions` and wait for the user's answer before execution. Do not execute a next-step item from a prior plain-text numbered list without fresh confirmation.
 

package/dist/resources/extensions/gsd/prompts/triage-captures.md

@@ -65,4 +65,4 @@ Classify each capture as one of:
 
 **Important:** Do NOT execute any resolutions. Only classify and update CAPTURES.md. Resolution execution happens separately (in auto-mode dispatch or manually by the user).
 
-When done, say: "Triage complete."
+When done, say: "Triage complete." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/validate-milestone.md

@@ -87,4 +87,4 @@ If verdict is `needs-remediation`:
 
 **File system safety:** When scanning milestone directories, use `ls` or `find` first. Never pass a directory path such as `tasks/` or `slices/` directly to `read`; it only accepts files.
 
-When done, say: "Milestone {{milestoneId}} validation complete — verdict: <verdict>."
+When done, say: "Milestone {{milestoneId}} validation complete — verdict: <verdict>." Say this exactly once — if you already said it in a prior message, do not repeat it.

package/dist/resources/extensions/gsd/prompts/workflow-start.md

@@ -25,4 +25,5 @@ Follow the workflow defined below. Execute each phase in order, completing one b
 3. **Atomic commits.** Commit working code after each meaningful change. Use conventional commit format: `<type>(<scope>): <description>`.
 4. **Verify before shipping.** Run the project's test suite and build before marking the workflow complete.
 5. **Decision gates, not ceremony.** After each phase, summarize what changed. For low/medium complexity, ask for confirmation only when the next phase depends on a real user choice or external approval. For high complexity, confirm before proceeding to each new phase.
-6. **Stay focused.** This is a {{complexity}}-complexity workflow. Match your ceremony level to the task — don't over-engineer or under-deliver.
+6. **Persist workflow state.** If the artifact directory contains `STATE.json`, update it after each phase: mark the finished phase `completed`, mark the next phase `active`, set `currentPhase` to the active phase index, and refresh `updatedAt`. When every phase is completed, set `completedAt` to the completion timestamp.
+7. **Stay focused.** This is a {{complexity}}-complexity workflow. Match your ceremony level to the task — don't over-engineer or under-deliver.

package/dist/resources/extensions/gsd/provider-error-guidance.js

@@ -1,5 +1,6 @@
 /**
  * Actionable remediation hints when auto-mode pauses on provider/model errors.
+ * Render with formatGuidance from the Guidance module.
  */
 /** Map auto unit types to the `models:` key in PREFERENCES.md. */
 export function unitTypeToPrefsPhaseKey(unitType) {
@@ -91,8 +92,3 @@ export function resolveProviderErrorGuidance(input) {
     steps.push("Run /gsd next to resume the paused unit.");
     return { summary, steps };
 }
-/** Flatten guidance into a pause banner / notification string. */
-export function formatProviderErrorGuidance(guidance) {
-    const numbered = guidance.steps.map((step, index) => `${index + 1}. ${step}`).join("\n");
-    return `${guidance.summary}\n\n${numbered}`;
-}

package/dist/resources/extensions/gsd/provider-payload-policy.js

@@ -0,0 +1,83 @@
+/**
+ * Provider Payload Policy - ordered shaping of provider request payloads.
+ *
+ * The order is intentional:
+ * 1. observation budgeting masks old tool results in auto-mode,
+ * 2. display truncation caps tool-result text for every mode,
+ * 3. the protected Source Context Block is appended after truncation,
+ * 4. supported models receive the configured service tier.
+ */
+import { createObservationMask, createResponsesInputObservationMask, truncateContextResultMessages, truncateResponsesInputResultItems, } from "./context-masker.js";
+import { getSourceObservationStore, isAutoActive } from "./auto-runtime-state.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { getEffectiveServiceTier, supportsServiceTier } from "./service-tier.js";
+import { injectSourceContextBlockIntoPayload } from "./source-observations.js";
+const DEFAULT_OBSERVATION_MASK_TURNS = 8;
+const DEFAULT_TOOL_RESULT_MAX_CHARS = 800;
+export const DEFAULT_PROVIDER_PAYLOAD_POLICY_DEPS = {
+    isAutoActive,
+    loadContextManagementConfig: () => loadEffectiveGSDPreferences()?.preferences.context_management,
+    renderSourceContextBlock: () => getSourceObservationStore().renderActiveBlock(),
+    getEffectiveServiceTier,
+    supportsServiceTier,
+};
+export function applyProviderPayloadPolicy({ payload, modelId, deps: overrides, }) {
+    const deps = { ...DEFAULT_PROVIDER_PAYLOAD_POLICY_DEPS, ...overrides };
+    try {
+        applyContextManagement(payload, deps);
+    }
+    catch {
+        // Provider payload shaping should not block a request when optional
+        // context management preferences or adapters fail.
+    }
+    try {
+        applySourceContextBlock(payload, deps);
+    }
+    catch {
+        // Source observations are opportunistic; execution can continue without
+        // an injected block.
+    }
+    applyServiceTier(payload, modelId, deps);
+    return payload;
+}
+function applyContextManagement(payload, deps) {
+    const config = deps.loadContextManagementConfig();
+    applyObservationBudget(payload, config, deps.isAutoActive());
+    applyDisplayTruncation(payload, config);
+}
+function applyObservationBudget(payload, config, autoActive) {
+    if (!autoActive || config?.observation_masking === false)
+        return;
+    const keepTurns = config?.observation_mask_turns ?? DEFAULT_OBSERVATION_MASK_TURNS;
+    if (Array.isArray(payload.messages)) {
+        payload.messages = createObservationMask(keepTurns)(payload.messages);
+    }
+    if (Array.isArray(payload.input)) {
+        payload.input = createResponsesInputObservationMask(keepTurns)(payload.input);
+    }
+}
+function applyDisplayTruncation(payload, config) {
+    const maxChars = config?.tool_result_max_chars ?? DEFAULT_TOOL_RESULT_MAX_CHARS;
+    if (Array.isArray(payload.messages)) {
+        payload.messages = truncateContextResultMessages(payload.messages, maxChars);
+    }
+    if (Array.isArray(payload.input)) {
+        payload.input = truncateResponsesInputResultItems(payload.input, maxChars);
+    }
+}
+function applySourceContextBlock(payload, deps) {
+    if (!deps.isAutoActive())
+        return;
+    const sourceContextBlock = deps.renderSourceContextBlock();
+    if (!sourceContextBlock)
+        return;
+    Object.assign(payload, injectSourceContextBlockIntoPayload(payload, sourceContextBlock));
+}
+function applyServiceTier(payload, modelId, deps) {
+    if (!modelId)
+        return;
+    const tier = deps.getEffectiveServiceTier();
+    if (!tier || !deps.supportsServiceTier(modelId))
+        return;
+    payload.service_tier = tier;
+}

package/dist/resources/extensions/gsd/provider-switch-observer.js

@@ -92,7 +92,7 @@ function emitAudit(report) {
 }
 function emitNotification(report) {
     try {
-        appendNotification(summarize(report), "warning", "workflow-logger");
+        appendNotification(summarize(report), "warning", "workflow-logger", { kind: "provider-switch" });
     }
     catch {
         // Notification persistence is best-effort.

package/dist/resources/extensions/gsd/publication.js

@@ -0,0 +1,87 @@
+// Project/App: gsd-pi
+// File Purpose: Publication module — push and draft-PR creation for a merged milestone (ADR-034).
+//
+// Publication is distinct from the merge verb: merging a milestone branch is a
+// Worktree Lifecycle concern (worktree, branch, lease, stash discipline);
+// publication needs only the resulting commit, a remote, and preferences.
+// Extracted from the tail of `mergeMilestoneToMain` (auto-worktree.ts) so it is
+// testable without a merge fixture and reachable from any closeout path.
+//
+// Publication failure is non-fatal to a completed local merge: every failure is
+// logged and reported in the result, never thrown.
+import { execFileSync } from "node:child_process";
+import { buildPullRequestEvidence, createDraftPullRequestFromEvidence, } from "./pull-request-process.js";
+import { logWarning } from "./workflow-logger.js";
+export function gitRemoteExists(basePath, remote) {
+    try {
+        execFileSync("git", ["remote", "get-url", remote], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Publish a merged milestone per preferences: push the integration branch
+ * (auto-push, suppressed when auto-PR owns the remote interaction) and/or
+ * push the milestone branch and open a draft PR (auto-PR).
+ */
+export function publishMilestone(request) {
+    const result = { pushed: false, prCreated: false };
+    if (request.nothingToCommit)
+        return result;
+    const { basePath, prefs } = request;
+    const remote = prefs.remote ?? "origin";
+    if (prefs.autoPush && !prefs.autoPr && gitRemoteExists(basePath, remote)) {
+        try {
+            execFileSync("git", ["push", remote, request.integrationBranch], {
+                cwd: basePath,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+            });
+            result.pushed = true;
+        }
+        catch (err) {
+            // Push failure is non-fatal
+            logWarning("worktree", `git push failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    // #2302: PR creation is not gated on pushed/auto-push.
+    if (prefs.autoPr && gitRemoteExists(basePath, remote)) {
+        try {
+            // Push the milestone branch to remote first
+            execFileSync("git", ["push", remote, request.milestoneBranch], {
+                cwd: basePath,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+            });
+            const prEvidence = buildPullRequestEvidence({
+                milestoneId: request.milestoneId,
+                milestoneTitle: request.milestoneTitle,
+                changeType: "feat",
+                summaries: [...request.sliceSummaries],
+                testsRun: ["Auto-created after milestone merge. Run `npm run verify:merge` before marking this draft ready."],
+                rollbackNotes: ["Close the draft PR or revert the merge commit if review finds a behavior regression."],
+                how: "Generated by git.auto_pr after the milestone branch was pushed and merged locally.",
+            });
+            const prUrl = createDraftPullRequestFromEvidence(basePath, request.milestoneId, prEvidence, {
+                head: request.milestoneBranch,
+                base: prefs.prTargetBranch ?? request.integrationBranch,
+            });
+            if (!prUrl) {
+                throw new Error("gh pr create returned no URL");
+            }
+            result.prCreated = true;
+            result.prUrl = prUrl;
+        }
+        catch (err) {
+            // PR creation failure is non-fatal — gh may not be installed or authenticated
+            logWarning("worktree", `PR creation failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return result;
+}

package/dist/resources/extensions/gsd/pull-request-process.js

@@ -0,0 +1,13 @@
+// Project/App: gsd-pi
+// File Purpose: Process-level pull request policy for GSD-generated PRs.
+import { createDraftPR } from "./git-service.js";
+import { buildPrEvidence, } from "./pr-evidence.js";
+export function buildPullRequestEvidence(input) {
+    return buildPrEvidence({
+        ...input,
+        aiAssisted: false,
+    });
+}
+export function createDraftPullRequestFromEvidence(basePath, milestoneId, evidence, options, deps = { createDraftPR }) {
+    return deps.createDraftPR(basePath, milestoneId, evidence.title, evidence.body, options);
+}

package/dist/resources/extensions/gsd/quality-gate-closure.js

@@ -0,0 +1,109 @@
+// Project/App: gsd-pi
+// File Purpose: Canonical quality-gate closure from durable DB and artifact evidence.
+import { existsSync, readFileSync } from "node:fs";
+import { extractSection } from "./files.js";
+import { getGateDefinition } from "./gate-registry.js";
+import { getMilestoneSlices, getPendingGates, saveGateResult } from "./gsd-db.js";
+import { resolveSliceFile, resolveTaskFile } from "./paths.js";
+const GATE_SECTION_HEADINGS = {
+    Q3: ["Threat Surface", "Abuse Surface"],
+    Q4: ["Requirement Impact", "Broken Promises"],
+    Q5: ["Failure Modes"],
+    Q6: ["Load Profile"],
+    Q7: ["Negative Tests"],
+    Q8: ["Operational Readiness"],
+};
+function readFile(path) {
+    if (!path || !existsSync(path))
+        return null;
+    return readFileSync(path, "utf-8");
+}
+function firstSection(content, gateId) {
+    if (!content)
+        return null;
+    for (const heading of GATE_SECTION_HEADINGS[gateId] ?? []) {
+        const section = extractSection(content, heading);
+        if (section)
+            return section;
+    }
+    return null;
+}
+function evidenceArtifactContent(row, basePath) {
+    const def = getGateDefinition(row.gate_id);
+    switch (def?.ownerTurn) {
+        case "gate-evaluate":
+            return readFile(resolveSliceFile(basePath, row.milestone_id, row.slice_id, "PLAN"));
+        case "execute-task":
+            return readFile(resolveTaskFile(basePath, row.milestone_id, row.slice_id, row.task_id, "SUMMARY"));
+        case "complete-slice":
+            return readFile(resolveSliceFile(basePath, row.milestone_id, row.slice_id, "SUMMARY"));
+        default:
+            return null;
+    }
+}
+function closureEvidence(row, options) {
+    const def = getGateDefinition(row.gate_id);
+    if (!def)
+        return null;
+    if (def.ownerTurn === "validate-milestone" && options.milestoneValidationPassed) {
+        return {
+            verdict: "pass",
+            rationale: `${def.promptSection} covered by passing milestone validation`,
+            findings: "",
+        };
+    }
+    if (!options.artifactBasePath)
+        return null;
+    const section = firstSection(evidenceArtifactContent(row, options.artifactBasePath), row.gate_id);
+    if (section) {
+        return {
+            verdict: "pass",
+            rationale: `${def.promptSection} evidence found in durable artifact`,
+            findings: section,
+        };
+    }
+    if (!options.milestoneValidationPassed)
+        return null;
+    return {
+        verdict: "omitted",
+        rationale: `${def.promptSection} has no durable artifact section; milestone validation passed`,
+        findings: "",
+    };
+}
+function closeGate(row, evidence) {
+    saveGateResult({
+        milestoneId: row.milestone_id,
+        sliceId: row.slice_id,
+        gateId: row.gate_id,
+        taskId: row.task_id,
+        verdict: evidence.verdict,
+        rationale: evidence.rationale,
+        findings: evidence.findings,
+    });
+}
+export function closeQualityGatesFromEvidence(milestoneId, options = {}) {
+    const repaired = [];
+    const unresolved = [];
+    for (const slice of getMilestoneSlices(milestoneId)) {
+        const sliceId = slice.id;
+        for (const row of getPendingGates(milestoneId, sliceId)) {
+            if (!getGateDefinition(row.gate_id)) {
+                unresolved.push(row);
+                continue;
+            }
+            const evidence = closureEvidence(row, options);
+            if (!evidence) {
+                unresolved.push(row);
+                continue;
+            }
+            closeGate(row, evidence);
+            repaired.push({
+                gateId: row.gate_id,
+                sliceId: row.slice_id,
+                ...(row.task_id ? { taskId: row.task_id } : {}),
+                verdict: evidence.verdict,
+            });
+        }
+    }
+    return { repaired, unresolved };
+}

package/dist/resources/extensions/gsd/question-transport.js

@@ -0,0 +1,86 @@
+// Project/App: gsd-pi
+// File Purpose: Resolve how workflow units should ask the user for input.
+import { parseMcpToolName, toMcpToolName } from "./mcp-tool-name.js";
+function isWorkflowMcpServerName(serverName) {
+    const normalized = serverName.toLowerCase();
+    return normalized === "gsd" || normalized.includes("workflow");
+}
+export function usesWorkflowMcpTransport(authMode, baseUrl) {
+    return authMode === "externalCli" && typeof baseUrl === "string" && baseUrl.startsWith("local://");
+}
+export function hasAskUserQuestionsTool(activeTools) {
+    return activeTools.some((toolName) => {
+        if (toolName === "ask_user_questions")
+            return true;
+        const mcp = parseMcpToolName(toolName);
+        if (!mcp)
+            return false;
+        if (mcp.toolName === "ask_user_questions")
+            return true;
+        return mcp.toolName === "*" && isWorkflowMcpServerName(mcp.serverName);
+    });
+}
+function workflowMcpStructuredQuestionsEnabled(env = process.env) {
+    const value = env.GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS?.trim().toLowerCase();
+    return value !== "0" && value !== "false" && value !== "off";
+}
+export function resolveQuestionTransport(options) {
+    const questionToolAvailable = hasAskUserQuestionsTool(options.activeTools);
+    const usesWorkflowMcp = usesWorkflowMcpTransport(options.authMode, options.baseUrl);
+    if (!questionToolAvailable) {
+        return {
+            structuredQuestionsAvailable: "false",
+            questionToolAvailable,
+            usesWorkflowMcp,
+            reason: "question-tool-missing",
+        };
+    }
+    if (options.authMode === "externalCli" && !workflowMcpStructuredQuestionsEnabled(options.env)) {
+        return {
+            structuredQuestionsAvailable: "false",
+            questionToolAvailable,
+            usesWorkflowMcp,
+            reason: "workflow-mcp-disabled",
+        };
+    }
+    return {
+        structuredQuestionsAvailable: "true",
+        questionToolAvailable,
+        usesWorkflowMcp,
+        reason: "question-tool-available",
+    };
+}
+export function supportsStructuredQuestions(activeTools, options = {}) {
+    return resolveQuestionTransport({
+        ...options,
+        activeTools,
+    }).structuredQuestionsAvailable === "true";
+}
+export function resolveWorkflowQuestionToolSurface(options) {
+    const questionToolName = options.workflowServerName && !options.workflowExplicitlyBlocked
+        ? toMcpToolName(options.workflowServerName, "ask_user_questions")
+        : undefined;
+    const activeTools = [
+        ...options.exactWorkflowMcpTools,
+        ...options.workflowMcpTools,
+        ...(questionToolName ? [questionToolName] : []),
+    ];
+    const transport = resolveQuestionTransport({
+        activeTools,
+        authMode: "externalCli",
+        baseUrl: "local://claude-code",
+        env: options.env,
+    });
+    const exactQuestionToolAllowed = !!questionToolName && options.exactWorkflowMcpTools.includes(questionToolName);
+    const workflowQuestionsEnabled = transport.structuredQuestionsAvailable === "true" &&
+        (options.workflowMcpTools.length > 0 || exactQuestionToolAllowed);
+    const disallowedTools = options.workflowServerName && transport.questionToolAvailable && !workflowQuestionsEnabled
+        ? [toMcpToolName(options.workflowServerName, "ask_user_questions")]
+        : [];
+    return {
+        ...transport,
+        questionToolName,
+        workflowQuestionsEnabled,
+        disallowedTools,
+    };
+}