gsd-pi 2.82.0-dev.725028083 → 2.82.0-dev.98ea09b1e

package/dist/resources/extensions/gsd/prompts/guided-discuss-project.md

@@ -1,6 +1,6 @@
 **Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` elsewhere. For `.gsd` files, use absolute paths rooted at `{{workingDirectory}}`, not `Glob`.
 
-Discuss the **project** as a whole: vision, users, anti-goals, constraints, and rough milestone sequence. Ask only real gray areas, then write `.gsd/PROJECT.md` with the **Project** template below. If a `GSD Skill Preferences` block exists, use it; artifact rules still apply.
+Discuss the **project** as a whole: vision, users, anti-goals, constraints, and rough milestone sequence. Ask only real gray areas, then persist the final Project template through `gsd_summary_save` with `artifact_type: "PROJECT"`. The tool renders `.gsd/PROJECT.md`; do not write the projection directly. If a `GSD Skill Preferences` block exists, use it; artifact rules still apply.
 
 This runs once before milestone discussion. Later milestones, requirements, and roadmaps depend on it.
 
@@ -34,7 +34,7 @@ After the opening answer, classify project shape as **`simple`** or **`complex`*
 
 **Default to `complex` when uncertain.** The user can override the verdict in plain text; if they do, accept it and proceed.
 
-Persist the verdict to PROJECT.md -> `## Project Shape`; downstream `discuss-requirements`, `discuss-milestone`, and `discuss-slice` read it from there.
+Persist the verdict through `gsd_summary_save` with `artifact_type: "PROJECT"` into `## Project Shape`; downstream `discuss-requirements`, `discuss-milestone`, and `discuss-slice` read the rendered projection.
 
 ### Before deeper rounds
 
@@ -95,7 +95,7 @@ If they clarify, absorb the correction and re-verify.
 
 The depth verification is the only required confirmation gate. Do not add a second "ready to proceed?" gate after it.
 
-**CRITICAL — Confirmation gate:** Do not write final PROJECT.md until the user selects the "(Recommended)" option (structured path) or explicitly confirms (plain-text path). If the user declines, cancels, does not respond, or the tool fails, re-ask.
+**CRITICAL — Confirmation gate:** Do not persist final PROJECT content until the user selects the "(Recommended)" option (structured path) or explicitly confirms (plain-text path). If the user declines, cancels, does not respond, or the tool fails, re-ask.
 
 ---
 
@@ -104,7 +104,7 @@ The depth verification is the only required confirmation gate. Do not add a seco
 Once the user confirms depth:
 
 1. Use the **Project** output template (inlined above).
-2. Call `gsd_summary_save` with `artifact_type: "PROJECT"` and full project markdown as `content`; omit `milestone_id`. The tool writes `.gsd/PROJECT.md` and persists to DB. Preserve the user's terms and framing.
+2. Call `gsd_summary_save` with `artifact_type: "PROJECT"` and full project markdown as `content`; omit `milestone_id`. The tool persists the DB-backed PROJECT artifact and renders `.gsd/PROJECT.md`. Preserve the user's terms and framing.
 3. The `## Project Shape` section MUST contain `**Complexity:** simple` or `**Complexity:** complex` (matching the verdict you announced) plus a one-line `**Why:**` rationale. Downstream stages read this line.
 4. The `## Capability Contract` section MUST reference `.gsd/REQUIREMENTS.md` — that file does not yet exist; the next stage (`discuss-requirements`) will produce it.
 5. The `## Milestone Sequence` MUST list at least M001 with title and one-liner. Subsequent milestones may be listed as known intents; they will be elaborated in their own discuss-milestone stages.

package/dist/resources/extensions/gsd/prompts/guided-discuss-requirements.md

@@ -1,6 +1,6 @@
 **Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` elsewhere. For `.gsd` files, use absolute paths rooted at `{{workingDirectory}}`, not `Glob`.
 
-Discuss **project-level requirements**. Read `.gsd/PROJECT.md` first; it is authoritative for vision, core value, anti-goals, and milestone sequence. Requirements must trace to it. Ask capability gray areas, then write `.gsd/REQUIREMENTS.md` using v2 `R###` format and the **Requirements** template.
+Discuss **project-level requirements**. Read `.gsd/PROJECT.md` first; it is the rendered project artifact for vision, core value, anti-goals, and milestone sequence. Requirements must trace to it. Ask capability gray areas, then persist requirements with `gsd_requirement_save` and render `.gsd/REQUIREMENTS.md` through `gsd_summary_save` using v2 `R###` format and the **Requirements** template.
 
 This runs once after `discuss-project` and before milestone work, creating the capability contract for milestones, slices, and verification.
 
@@ -25,7 +25,7 @@ Before your first action, print this banner verbatim in chat:
 3. If `.gsd/REQUIREMENTS.md` exists, read it as the working set.
 
 **Shape-dependent cadence:**
-- **`simple`**: one fast pass. Extract from PROJECT.md, ask 1-2 plain-text clarifiers only when class/status is ambiguous, then write REQUIREMENTS.md.
+- **`simple`**: one fast pass. Extract from PROJECT.md, ask 1-2 plain-text clarifiers only when class/status is ambiguous, then persist requirements through the DB-backed tools.
 - **`complex`**: multi-round questioning with structured 3-4-option questions where alternatives matter.
 
 ---
@@ -81,7 +81,7 @@ Before the wrap-up gate, verify: every milestone has an Active requirement; Core
 
 If they adjust, absorb and re-verify.
 
-**CRITICAL — Confirmation gate:** Do not write final REQUIREMENTS.md until explicit confirmation. Never rationalize past it.
+**CRITICAL — Confirmation gate:** Do not persist final REQUIREMENTS content until explicit confirmation. Never rationalize past it.
 
 ---
 

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

@@ -26,7 +26,7 @@ Before planning, validate roadmap assumptions against code and dependency summar
 
 {{sourceFilePaths}}
 
-If slice research is inlined, trust it. Explore enough code to confirm paths, boundaries, and verification. Executors later get only task plans, slice excerpt, and prior summaries, so put required paths, steps, inputs, and outputs in task plans.
+If slice research is inlined, trust its architectural findings, but verify every concrete file path you place in task `inputs` or `expectedOutput` against the current tree or prior/same-task outputs. Explore enough code to confirm paths, boundaries, and verification. Executors later get only task plans, slice excerpt, and prior summaries, so put required paths, steps, inputs, and outputs in task plans.
 
 {{executorContextConstraints}}
 
@@ -39,10 +39,10 @@ If slice research is inlined, trust it. Explore enough code to confirm paths, bo
 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/`.
 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. Each task needs a concrete title, Why / Files / Do / Verify / Done when, plus task-plan description, steps, must-haves, verification, inputs, and expected output. Inputs and Expected Output must include concrete backtick-wrapped paths. 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. **`expected_output` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, or tests — those belong only in `inputs`. If a task is a pure verification or test task that produces no new files, its `expected_output` may be empty or limited to test-result artifacts (e.g. a log or assertion output). A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expected_output` — if no prior task creates it, add a task before this one that does.
-9. Persist with `gsd_plan_slice` using goal, successCriteria, optional 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.
+8. 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, or tests — those belong only in `inputs`. If a task is a pure verification or test task that produces no new files, `expectedOutput` may be `[]` or limited to test-result artifacts (e.g. a log or assertion output). 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. 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.
 10. Self-audit before finishing: goal/demo closure, requirement coverage, 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.
-11. If planning creates structural decisions, append them to `.gsd/DECISIONS.md`.
+11. If planning creates structural decisions, call `gsd_decision_save` for each; the tool persists the decision and regenerates `.gsd/DECISIONS.md`.
 12. {{commitInstruction}}
 
 The slice directory already exists. Do not mkdir.

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

@@ -114,10 +114,10 @@ Once the user is satisfied, in one pass for **each** new milestone:
 
 After all milestone directories and context files are written:
 
-3. Update `.gsd/PROJECT.md` by adding new milestones to the Milestone Sequence. Keep existing entries exactly as-is; only add new lines.
-4. If `.gsd/REQUIREMENTS.md` exists and the queued work introduces new in-scope capabilities or promotes Deferred items, update it.
-5. If discussion produced decisions relevant to existing work, append to `.gsd/DECISIONS.md`.
-6. Append to `.gsd/QUEUE.md`.
+3. Refresh project state through `gsd_summary_save` with `artifact_type: "PROJECT"` and full PROJECT content that includes the new milestones in the Milestone Sequence; omit `milestone_id`.
+4. If the queued work introduces new in-scope capabilities or promotes Deferred items, persist those changes with `gsd_requirement_save` or `gsd_requirement_update`, then call `gsd_summary_save` with `artifact_type: "REQUIREMENTS"` so `.gsd/REQUIREMENTS.md` renders from DB rows.
+5. If discussion produced decisions relevant to existing work, call `gsd_decision_save` for each decision; the tool regenerates `.gsd/DECISIONS.md`.
+6. If `.gsd/QUEUE.md` is maintained, update it only as an audit projection of queued intent. Runtime queue state must come from the DB-backed milestone/context tool calls above.
 7. {{commitInstruction}}
 
 **Do NOT write roadmaps for queued milestones.**

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

@@ -64,10 +64,10 @@ Then:
 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.
 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 must have Why / Files / Do / Verify / Done-when, plus a task plan with description, steps, must-haves, verification, inputs (backtick-wrapped paths), and expected output (backtick-wrapped paths).
+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"`).
 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, append them to `.gsd/DECISIONS.md`.
+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`.
 9. {{commitInstruction}}
 
 The slice directory and tasks/ subdirectory already exist. Do NOT mkdir.

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

@@ -23,7 +23,7 @@ An override was issued by the user that changes a fundamental decision or approa
    - For DECISIONS.md: append a new decision entry documenting the override and why. Do NOT delete prior decisions — mark them as superseded with a note.
    - For slice plans (S##-PLAN.md): update Goal, Demo, and Verification sections if affected. Update Files Likely Touched if the override changes scope. Do NOT modify completed task entries.
    - For REQUIREMENTS.md: update requirement descriptions if the override changes what "done" means, but do not remove requirements.
-   - For PROJECT.md: update if the override changes project-level facts.
+   - For PROJECT.md: do not edit the projection directly. If the override changes project-level facts, persist the revised Project content through `gsd_summary_save` with `artifact_type: "PROJECT"` so the DB remains authoritative.
    - Milestone context files are reference only — do not modify them.
 4. Mark all active overrides as resolved: change `**Scope:** active` to `**Scope:** resolved` in `{{overridesPath}}`
 5. Do not commit manually — the system auto-commits your changes after this unit completes.

package/dist/resources/extensions/gsd/state-reconciliation/drift/merge-state.js

@@ -10,6 +10,7 @@ import { isAbsolute, join, resolve } from "node:path";
 import { getErrorMessage } from "../../error-utils.js";
 import { nativeAddPaths, nativeCheckoutTheirs, nativeCommit, nativeConflictFiles, nativeMergeAbort, nativeRebaseAbort, nativeResetHard, } from "../../native-git-bridge.js";
 import { logError, logWarning } from "../../workflow-logger.js";
+import { isGsdWorktreePath } from "../../worktree-root.js";
 const SILENT_NOTIFY = () => { };
 function resolveGitDir(basePath) {
     try {
@@ -23,7 +24,11 @@ function resolveGitDir(basePath) {
         }
     }
     catch (err) {
-        logWarning("recovery", `gitdir resolution failed: ${getErrorMessage(err)}`);
+        const message = getErrorMessage(err);
+        logWarning("recovery", `gitdir resolution failed: ${message}`);
+        if (isGsdWorktreePath(basePath)) {
+            throw new Error(`Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${message.split("\n")[0]}). Repair or recreate the worktree before retrying.`);
+        }
     }
     return join(basePath, ".git");
 }

package/dist/resources/extensions/gsd/state-reconciliation/drift/project-md.js

@@ -1,12 +1,11 @@
 // Project/App: GSD-2
 // File Purpose: ADR-017 unregistered-milestone drift handler. Detects
 // milestones whose on-disk directory has meaningful content (ROADMAP/
-// CONTEXT/SUMMARY) but no DB row, then runs the markdown importer to
-// reconcile. PROJECT.md is the human-facing index — the importer's source
-// of truth is the .gsd/milestones/ directory tree.
+// CONTEXT/SUMMARY) but no DB row, then fails closed with an explicit recovery
+// instruction. Markdown hierarchy import is reserved for operator-controlled
+// migration/recovery commands, not automatic runtime reconciliation.
 import { existsSync } from "node:fs";
 import { getMilestone, isDbAvailable } from "../../gsd-db.js";
-import { migrateHierarchyToDb } from "../../md-importer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { resolveMilestoneFile } from "../../paths.js";
 function milestoneHasContent(basePath, milestoneId) {
@@ -31,17 +30,13 @@ export function detectUnregisteredMilestoneDrift(_state, ctx) {
     return drifts;
 }
 /**
- * Repair: invoke the markdown importer. migrateHierarchyToDb walks the same
- * findMilestoneIds list the detector uses and INSERTs OR IGNOREs every
- * missing milestone (and its slices/tasks) — idempotent under cap=2 retry.
- *
- * Note: even though we receive one record at a time, the importer is a
- * project-wide operation. Repeated invocation across multiple drift records
- * in the same pass is wasteful but safe; a future optimization could
- * coalesce by checking whether the importer has already run this pass.
+ * Repair intentionally fails closed. The project-root DB is authoritative at
+ * runtime; markdown-only milestones must be imported through an explicit
+ * migration/recovery command so operators opt into changing canonical state.
  */
-export function repairUnregisteredMilestone(_record, ctx) {
-    migrateHierarchyToDb(ctx.basePath);
+export function repairUnregisteredMilestone(record, _ctx) {
+    throw new Error(`Milestone ${record.milestoneId} exists only as markdown projection. ` +
+        "Runtime reconciliation will not import markdown into the authoritative DB; run explicit GSD recovery/migration if this markdown should repopulate the database.");
 }
 export const unregisteredMilestoneHandler = {
     kind: "unregistered-milestone",

package/dist/resources/extensions/gsd/state-reconciliation/drift/roadmap.js

@@ -1,14 +1,15 @@
 // Project/App: GSD-2
 // File Purpose: ADR-017 roadmap-divergence drift handler. Detects mismatches
-// between ROADMAP.md (parsed slice sequence + depends declarations) and the
-// DB slice rows for that milestone, then reconciles via the markdown
-// importer plus an explicit junction-table sync.
+// between ROADMAP.md (parsed slice sequence, depends declarations, and
+// checkboxes) and the DB slice rows for that milestone, then re-renders the
+// ROADMAP projection from the authoritative DB rows.
 import { existsSync, readFileSync } from "node:fs";
-import { getMilestone, getMilestoneSlices, isDbAvailable, syncSliceDependencies, } from "../../gsd-db.js";
-import { migrateHierarchyToDb } from "../../md-importer.js";
+import { getMilestone, getMilestoneSlices, isDbAvailable, } from "../../gsd-db.js";
+import { renderRoadmapFromDb } from "../../markdown-renderer.js";
 import { findMilestoneIds } from "../../milestone-ids.js";
 import { parseRoadmap } from "../../parsers-legacy.js";
 import { resolveMilestoneFile } from "../../paths.js";
+import { isClosedStatus } from "../../status-guards.js";
 function arraysEqual(a, b) {
     if (a.length !== b.length)
         return false;
@@ -30,8 +31,10 @@ function milestoneHasDivergence(basePath, milestoneId) {
     }
     const dbSlices = getMilestoneSlices(milestoneId);
     const dbSliceMap = new Map(dbSlices.map((s) => [s.id, s]));
+    const roadmapSliceIds = new Set();
     for (let i = 0; i < roadmap.slices.length; i++) {
         const roadmapSlice = roadmap.slices[i];
+        roadmapSliceIds.add(roadmapSlice.id);
         const expectedSequence = i + 1;
         const dbSlice = dbSliceMap.get(roadmapSlice.id);
         if (!dbSlice)
@@ -40,6 +43,12 @@ function milestoneHasDivergence(basePath, milestoneId) {
             return true;
         if (!arraysEqual(dbSlice.depends, roadmapSlice.depends))
             return true;
+        if (isClosedStatus(dbSlice.status) !== roadmapSlice.done)
+            return true;
+    }
+    for (const dbSlice of dbSlices) {
+        if (!roadmapSliceIds.has(dbSlice.id))
+            return true;
     }
     return false;
 }
@@ -59,26 +68,12 @@ export function detectRoadmapDivergenceDrift(_state, ctx) {
     return drifts;
 }
 /**
- * Repair a milestone's roadmap divergence:
- *   1. migrateHierarchyToDb upserts slice rows (sequence + depends JSON
- *      update via ON CONFLICT DO UPDATE).
- *   2. syncSliceDependencies updates the junction table per slice — the
- *      importer only writes the JSON column, not the relational view.
+ * Repair a milestone's roadmap divergence by regenerating the projection from
+ * DB rows. ROADMAP.md is a projection; runtime reconciliation must not import
+ * slice presence, sequence, dependencies, or checkbox state from markdown.
  */
-export function repairRoadmapDivergence(record, ctx) {
-    migrateHierarchyToDb(ctx.basePath);
-    const roadmapPath = resolveMilestoneFile(ctx.basePath, record.milestoneId, "ROADMAP");
-    if (!roadmapPath || !existsSync(roadmapPath))
-        return;
-    try {
-        const roadmap = parseRoadmap(readFileSync(roadmapPath, "utf-8"));
-        for (const slice of roadmap.slices) {
-            syncSliceDependencies(record.milestoneId, slice.id, slice.depends);
-        }
-    }
-    catch {
-        /* parse failure: detector will fire again next pass */
-    }
+export async function repairRoadmapDivergence(record, ctx) {
+    await renderRoadmapFromDb(ctx.basePath, record.milestoneId);
 }
 export const roadmapDivergenceHandler = {
     kind: "roadmap-divergence",

package/dist/resources/extensions/gsd/status-guards.js

@@ -22,3 +22,7 @@ export function isDeferredStatus(status) {
 export function isInactiveStatus(status) {
     return isClosedStatus(status) || isDeferredStatus(status);
 }
+/** Returns true when a prior milestone should not block dispatch ordering. */
+export function isSkippedForDispatch(status) {
+    return isClosedStatus(status) || status === "parked" || isDeferredStatus(status);
+}

package/dist/resources/extensions/gsd/templates/plan.md

@@ -99,11 +99,11 @@
   - "Improve UI"
 
   Each task should usually include:
-  - Why: why this task exists / what part of the slice it closes
-  - Files: the main files likely touched
-  - Do: concrete implementation steps and important constraints
-  - Verify: the command, test, or runtime check that proves it worked
-  - Done when: a measurable acceptance condition
+  - description: why this task exists, concrete steps, and done-when acceptance
+  - files: JSON array of likely touched paths
+  - verify: the command, test, or runtime check that proves it worked
+  - inputs: JSON array of existing paths or prior task outputs this task consumes
+  - expectedOutput: JSON array of paths this task creates or overwrites
 
   Keep the checkbox line format exactly:
   - [ ] **T01: Title** `est:30m`
@@ -131,10 +131,13 @@
 
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
+  - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, or output trimming
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"
+  - BAD: `python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5`
   - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
+  - GOOD: `python3 -m pytest tests/ -q --tb=short`
   - GOOD: `grep -c "^## " doc.md` returns >= 4 (4+ sections), `! grep -q "TBD\|TODO" doc.md`
 
   Integration closure rule:

package/dist/resources/extensions/gsd/templates/task-plan.md

@@ -72,7 +72,8 @@ skills_used:
 <!-- Every input MUST be a backtick-wrapped file path. These paths are machine-parsed to
      derive task dependencies — vague descriptions without paths break dependency detection.
      For the first task in a slice with no prior task outputs, list the existing source files
-     this task reads or modifies. -->
+     this task reads or modifies.
+     Tool field: inputs must be an array of strings, e.g. ["src/index.ts"], never a single string. -->
 
 - `{{filePath}}` — {{whatThisTaskNeedsFromPriorWork}}
 
@@ -82,6 +83,7 @@ skills_used:
      or modifies. These paths are machine-parsed to derive task dependencies.
      This task should produce a real increment toward making the slice goal/demo true. A full
      slice plan should not be able to mark every task complete while the claimed slice behavior
-     still does not work at the stated proof level. -->
+     still does not work at the stated proof level.
+     Tool field: expectedOutput must be an array of strings, e.g. ["src/index.ts"], never a single string. -->
 
 - `{{filePath}}` — {{whatThisTaskCreatesOrModifies}}

package/dist/resources/extensions/gsd/tools/complete-milestone.js

@@ -24,11 +24,11 @@ function renderMilestoneSummaryMarkdown(params, completedAt) {
     const keyFiles = params.keyFiles ?? [];
     const lessonsLearned = params.lessonsLearned ?? [];
     const keyDecisionsYaml = keyDecisions.length > 0
-        ? keyDecisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyDecisions.map(d => `  - ${d}`).join("\n")}`
+        : " []";
     const keyFilesYaml = keyFiles.length > 0
-        ? keyFiles.map(f => `  - ${f}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyFiles.map(f => `  - ${f}`).join("\n")}`
+        : " []";
     const lessonsYaml = lessonsLearned.length > 0
         ? lessonsLearned.map(l => `  - ${l}`).join("\n")
         : "  - (none)";
@@ -37,10 +37,8 @@ id: ${params.milestoneId}
 title: "${displayTitle}"
 status: complete
 completed_at: ${completedAt}
-key_decisions:
-${keyDecisionsYaml}
-key_files:
-${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
+key_files:${keyFilesYaml}
 lessons_learned:
 ${lessonsYaml}
 ---

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -65,11 +65,11 @@ function renderSliceSummaryMarkdown(params) {
         ? affects.map(a => `  - ${a}`).join("\n")
         : "  []";
     const keyFilesYaml = keyFiles.length > 0
-        ? keyFiles.map(f => `  - ${f}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyFiles.map(f => `  - ${f}`).join("\n")}`
+        : " []";
     const keyDecisionsYaml = keyDecisions.length > 0
-        ? keyDecisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyDecisions.map(d => `  - ${d}`).join("\n")}`
+        : " []";
     const patternsYaml = patternsEstablished.length > 0
         ? patternsEstablished.map(p => `  - ${p}`).join("\n")
         : "  - (none)";
@@ -106,10 +106,8 @@ requires:
 ${requiresYaml}
 affects:
 ${affectsYaml}
-key_files:
-${keyFilesYaml}
-key_decisions:
-${keyDecisionsYaml}
+key_files:${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
 patterns_established:
 ${patternsYaml}
 observability_surfaces:

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -1,6 +1,6 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
-import { isNonEmptyString, validateStringArray } from "../validation.js";
+import { isNonEmptyString, validateStringArray, validateTitle } from "../validation.js";
 import { transaction, getMilestone, getMilestoneSlices, getSlice, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
@@ -77,6 +77,9 @@ function validateSlices(value) {
         seen.add(sliceId);
         if (!isNonEmptyString(title))
             throw new Error(`slices[${index}].title must be a non-empty string`);
+        const titleIssue = validateTitle(title);
+        if (titleIssue)
+            throw new Error(`slices[${index}].title is invalid: ${titleIssue}`);
         if (!isNonEmptyString(risk))
             throw new Error(`slices[${index}].risk must be a non-empty string`);
         if (!Array.isArray(depends) || depends.some((item) => !isNonEmptyString(item))) {
@@ -127,6 +130,9 @@ function validateParams(params) {
         throw new Error("title is required");
     if (!isNonEmptyString(params?.vision))
         throw new Error("vision is required");
+    const milestoneTitleIssue = validateTitle(params.title);
+    if (milestoneTitleIssue)
+        throw new Error(`title is invalid: ${milestoneTitleIssue}`);
     return {
         ...params,
         dependsOn: params.dependsOn ? validateStringArray(params.dependsOn, "dependsOn") : [],

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -1,7 +1,9 @@
+import { existsSync, rmSync } from "node:fs";
+import { join, relative } from "node:path";
 import { clearParseCache } from "../files.js";
 import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
-import { isNonEmptyString } from "../validation.js";
-import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, } from "../gsd-db.js";
+import { isNonEmptyString, validateStringArray } from "../validation.js";
+import { transaction, getMilestone, getSlice, getSliceTasks, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, setSliceSketchFlag, deleteTask, deleteArtifactByPath, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -9,6 +11,8 @@ import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning } from "../workflow-logger.js";
 import { validatePlanningPathScope } from "../planning-path-scope.js";
+import { checkFilePathConsistency, checkTaskOrdering } from "../pre-execution-checks.js";
+import { buildTaskFileName, gsdRoot, resolveTasksDir } from "../paths.js";
 function validateTasks(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -39,17 +43,11 @@ function validateTasks(value) {
             throw new Error(`tasks[${index}].description must be a non-empty string`);
         if (!isNonEmptyString(estimate))
             throw new Error(`tasks[${index}].estimate must be a non-empty string`);
-        if (!Array.isArray(files) || files.some((item) => !isNonEmptyString(item))) {
-            throw new Error(`tasks[${index}].files must be an array of non-empty strings`);
-        }
+        const validatedFiles = validateStringArray(files, `tasks[${index}].files`);
         if (!isNonEmptyString(verify))
             throw new Error(`tasks[${index}].verify must be a non-empty string`);
-        if (!Array.isArray(inputs) || inputs.some((item) => !isNonEmptyString(item))) {
-            throw new Error(`tasks[${index}].inputs must be an array of non-empty strings`);
-        }
-        if (!Array.isArray(expectedOutput) || expectedOutput.some((item) => !isNonEmptyString(item))) {
-            throw new Error(`tasks[${index}].expectedOutput must be an array of non-empty strings`);
-        }
+        const validatedInputs = validateStringArray(inputs, `tasks[${index}].inputs`);
+        const validatedExpectedOutput = validateStringArray(expectedOutput, `tasks[${index}].expectedOutput`);
         if (observabilityImpact !== undefined && !isNonEmptyString(observabilityImpact)) {
             throw new Error(`tasks[${index}].observabilityImpact must be a non-empty string when provided`);
         }
@@ -58,10 +56,10 @@ function validateTasks(value) {
             title,
             description,
             estimate,
-            files,
+            files: validatedFiles,
             verify,
-            inputs,
-            expectedOutput,
+            inputs: validatedInputs,
+            expectedOutput: validatedExpectedOutput,
             observabilityImpact: typeof observabilityImpact === "string" ? observabilityImpact : "",
         };
     });
@@ -84,6 +82,53 @@ function validateParams(params) {
         tasks: validateTasks(params.tasks),
     };
 }
+function toTaskRows(params) {
+    return params.tasks.map((task, index) => ({
+        milestone_id: params.milestoneId,
+        slice_id: params.sliceId,
+        id: task.taskId,
+        title: task.title,
+        status: "pending",
+        one_liner: "",
+        narrative: "",
+        verification_result: "",
+        duration: "",
+        completed_at: null,
+        blocker_discovered: false,
+        deviations: "",
+        known_issues: "",
+        key_files: [],
+        key_decisions: [],
+        full_summary_md: "",
+        description: task.description,
+        estimate: task.estimate,
+        files: task.files,
+        verify: task.verify,
+        inputs: task.inputs,
+        expected_output: task.expectedOutput,
+        observability_impact: task.observabilityImpact ?? "",
+        full_plan_md: task.fullPlanMd ?? "",
+        sequence: index + 1,
+        blocker_source: "",
+        escalation_pending: 0,
+        escalation_awaiting_review: 0,
+        escalation_artifact_path: null,
+        escalation_override_applied_at: null,
+    }));
+}
+function validateTaskPathsBeforePersist(params, basePath) {
+    const taskRows = toTaskRows(params);
+    const checks = [
+        ...checkFilePathConsistency(taskRows, basePath),
+        ...checkTaskOrdering(taskRows, basePath),
+    ];
+    const blocking = checks.filter((check) => !check.passed && check.blocking);
+    if (blocking.length === 0)
+        return null;
+    return blocking
+        .map((check) => `[${check.category}] ${check.target}: ${check.message}`)
+        .join("\n");
+}
 export async function handlePlanSlice(rawParams, basePath) {
     let params;
     try {
@@ -100,10 +145,15 @@ export async function handlePlanSlice(rawParams, basePath) {
     if (pathScopeError) {
         return { error: `validation failed: ${pathScopeError}` };
     }
+    const pathError = validateTaskPathsBeforePersist(params, basePath);
+    if (pathError) {
+        return { error: `pre-execution validation failed:\n${pathError}` };
+    }
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     // Guards must be inside the transaction so the state they check cannot
     // change between the read and the write (#2723).
     let guardError = null;
+    let omittedTaskIds = [];
     try {
         transaction(() => {
             const parentMilestone = getMilestone(params.milestoneId);
@@ -124,9 +174,21 @@ export async function handlePlanSlice(rawParams, basePath) {
                 guardError = `cannot re-plan slice ${params.sliceId}: it is already complete — use gsd_slice_reopen first`;
                 return;
             }
+            const newTaskIds = new Set(params.tasks.map((task) => task.taskId));
+            const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
+            omittedTaskIds = existingTasks
+                .filter((task) => !newTaskIds.has(task.id))
+                .map((task) => task.id);
+            for (const task of existingTasks) {
+                if (!newTaskIds.has(task.id) && isClosedStatus(task.status)) {
+                    guardError = `cannot remove completed task ${task.id}`;
+                    return;
+                }
+            }
             if (isDeferredStatus(parentSlice.status)) {
                 updateSliceStatus(params.milestoneId, params.sliceId, "pending");
             }
+            setSliceSketchFlag(params.milestoneId, params.sliceId, false);
             upsertSlicePlanning(params.milestoneId, params.sliceId, {
                 goal: params.goal,
                 successCriteria: params.successCriteria,
@@ -134,6 +196,9 @@ export async function handlePlanSlice(rawParams, basePath) {
                 integrationClosure: params.integrationClosure,
                 observabilityImpact: params.observabilityImpact,
             });
+            for (const taskId of omittedTaskIds) {
+                deleteTask(params.milestoneId, params.sliceId, taskId);
+            }
             for (const task of params.tasks) {
                 insertTask({
                     id: task.taskId,
@@ -176,6 +241,16 @@ export async function handlePlanSlice(rawParams, basePath) {
         return { error: guardError };
     }
     try {
+        const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);
+        for (const taskId of omittedTaskIds) {
+            if (!tasksDir)
+                continue;
+            const taskPlanPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
+            if (existsSync(taskPlanPath))
+                rmSync(taskPlanPath, { force: true });
+            const artifactPath = relative(gsdRoot(basePath), taskPlanPath).replace(/\\/g, "/");
+            deleteArtifactByPath(artifactPath);
+        }
         const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
         invalidateStateCache();
         clearParseCache();