gsd-pi 2.45.0 → 2.46.0-dev.cc9d310

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

@@ -48,7 +48,7 @@ Then:
 3. Create the roadmap: decompose into demoable vertical slices — as many as the work genuinely needs, no more. A simple feature might be 1 slice. Don't decompose for decomposition's sake.
 4. Order by risk (high-risk first)
 5. Call `gsd_plan_milestone` to persist the milestone planning fields and slice rows in the DB-backed planning path. Do **not** write `{{outputPath}}`, `ROADMAP.md`, or other planning artifacts manually — the planning tool owns roadmap rendering and persistence.
-6. If planning produced structural decisions (e.g. slice ordering rationale, technology choices, scope exclusions), append them to `.gsd/DECISIONS.md` (use the **Decisions** output template from the inlined context above if the file doesn't exist yet)
+6. If planning produced structural decisions (e.g. slice ordering rationale, technology choices, scope exclusions), call `gsd_decision_save` for each decision — the tool auto-assigns IDs and regenerates `.gsd/DECISIONS.md` automatically.
 
 ## Requirement Mapping Rules
 

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

@@ -72,9 +72,11 @@ Then:
     - **Key links planned:** For every pair of artifacts that must connect, there is an explicit step that wires them.
     - **Scope sanity:** Target 2–5 steps and 3–8 files per task. 10+ steps or 12+ files — must split. Each task must be completable in a single fresh context window.
     - **Feature completeness:** Every task produces real, user-facing progress — not just internal scaffolding.
-8. If planning produced structural decisions, append them to `.gsd/DECISIONS.md`
-9. {{commitInstruction}}
+10. If planning produced structural decisions, append them to `.gsd/DECISIONS.md`
+11. {{commitInstruction}}
 
 The slice directory and tasks/ subdirectory already exist. Do NOT mkdir. All work stays in your working directory: `{{workingDirectory}}`.
 
+**You MUST write the file `{{outputPath}}` before finishing.**
+
 When done, say: "Slice {{sliceId}} planned."

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

@@ -8,7 +8,7 @@ Before asking "What do you want to add?", check the existing milestones context
 
 1. Tell the user which milestones have draft contexts and briefly summarize what each draft contains (read the draft file).
 2. Use `ask_user_questions` to ask per-draft milestone:
-   - **"Discuss now"** — Treat this draft as the primary topic. Read the draft content, use it as seed material, and conduct a focused discussion following the standard discussion flow (reflection → investigation → questioning → depth verification → requirements → roadmap). After the discussion, write the full CONTEXT.md and delete the `CONTEXT-DRAFT.md` file. The milestone is then ready for auto-planning.
+   - **"Discuss now"** — Treat this draft as the primary topic. Read the draft content, use it as seed material, and conduct a focused discussion following the standard discussion flow (reflection → investigation → questioning → depth verification → requirements → roadmap). After the discussion, call `gsd_summary_save` with the milestone ID and `artifact_type: "CONTEXT"` to write the full context — then delete the `CONTEXT-DRAFT.md` file. The milestone is then ready for auto-planning.
    - **"Leave for later"** — Keep the draft as-is. The user will discuss it in a future session. Auto-mode will continue to pause when it reaches this milestone.
 3. Handle all draft discussions before proceeding to new queue work.
 4. If no drafts exist in the context, skip this section entirely and proceed to "What do you want to add?"
@@ -108,7 +108,7 @@ The user confirms or corrects before you write. One depth verification per miles
 Once the user is satisfied, in a single pass for **each** new milestone:
 
 1. Call `gsd_milestone_generate_id` to get the milestone ID — never invent milestone IDs manually. Then `mkdir -p .gsd/milestones/<ID>/slices`.
-2. Write `.gsd/milestones/<ID>/<ID>-CONTEXT.md` — use the **Context** output template below. Capture intent, scope, risks, constraints, integration points, and relevant requirements. Mark the status as "Queued — pending auto-mode execution." **If this milestone depends on other milestones, add YAML frontmatter with `depends_on`:**
+2. Call `gsd_summary_save` with `milestone_id: <ID>`, `artifact_type: "CONTEXT"`, and the full context markdown as `content` — the tool computes the file path and persists to both DB and disk. Capture intent, scope, risks, constraints, integration points, and relevant requirements in the content. Mark the status as "Queued — pending auto-mode execution." **If this milestone depends on other milestones, include YAML frontmatter with `depends_on` in the content:**
    ```yaml
    ---
    depends_on: [M001, M002]

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

@@ -21,7 +21,9 @@ You are executing a GSD quick task — a lightweight, focused unit of work outsi
    - Use conventional commit messages (feat:, fix:, refactor:, etc.)
    - Stage only relevant files — never commit secrets or runtime files.
    - Commit logical units separately if the task involves distinct changes.
+   - Quick tasks run outside the auto-mode lifecycle — there is no system auto-commit, so commit directly here.
 7. Write a brief summary to `{{summaryPath}}`:
+   - Quick tasks operate outside the milestone/slice/task DB structure, so `gsd_summary_save` (which requires a `milestone_id`) cannot be used here. Write the file directly.
 
 ```markdown
 # Quick Task: {{description}}

package/dist/resources/extensions/gsd/prompts/reactive-execute.md

@@ -26,7 +26,7 @@ You are executing **multiple tasks in parallel** for this slice. The task graph
 2. **Wait for all subagents** to complete.
 3. **Verify each dispatched task's outputs** — check that expected files were created/modified, that verification commands pass where applicable, and that each task wrote its own `T##-SUMMARY.md`.
 4. **Do not rewrite successful task summaries or duplicate completion tool calls.** Treat a subagent-written summary as authoritative for that task.
-5. **If a failed task produced no summary, write a recovery summary for that task** with `blocker_discovered: true`, clear failure details, and leave the task unchecked so replan/retry has an authoritative record.
+5. **If a failed task produced no summary, call `gsd_summary_save`** with `milestone_id: {{milestoneId}}`, `slice_id: {{sliceId}}`, the failed task's `task_id`, and `artifact_type: "SUMMARY"` — include `blocker_discovered: true` and clear failure details in the `content`. Do NOT call `gsd_task_complete` for the failed task — leave it uncompleted so replan/retry has an authoritative record.
 6. **Preserve successful sibling tasks exactly as they landed.** Do not roll back good work because another parallel task failed.
 7. **Do NOT create a batch commit.** The surrounding unit lifecycle owns commits; this parent batch agent should not invent a second commit layer.
 8. **Report the batch outcome** — which tasks succeeded, which failed, and any output collisions or dependency surprises.

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

@@ -48,10 +48,10 @@ Research what this slice needs. Narrate key findings and surprises as you go —
 4. Use `resolve_library` / `get_library_docs` for unfamiliar libraries — skip this for libraries already used in the codebase
 5. **Web search budget:** You have a limited budget of web searches (max ~15 per session). Use them strategically — prefer `resolve_library` / `get_library_docs` for library documentation. Do NOT repeat the same or similar queries. If a search didn't find what you need, rephrase once or move on. Target 3-5 total web searches for a typical research unit.
 6. Use the **Research** output template from the inlined context above — include only sections that have real content. The template is already inlined above; do NOT attempt to read any template file from disk (there is no `templates/SLICE-RESEARCH.md` — the correct template is already present in this prompt).
-7. Write `{{outputPath}}`
+7. Call `gsd_summary_save` with `milestone_id: {{milestoneId}}`, `slice_id: {{sliceId}}`, `artifact_type: "RESEARCH"`, and the full research markdown as `content` — the tool computes the file path and persists to both DB and disk.
 
-The slice directory already exists at `{{slicePath}}/`. Do NOT mkdir — just write the file.
+The slice directory already exists at `{{slicePath}}/`. Do NOT mkdir.
 
-**You MUST write the file `{{outputPath}}` before finishing.**
+**You MUST call `gsd_summary_save` with the research content before finishing.**
 
 When done, say: "Slice {{sliceId}} researched."

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

@@ -16,6 +16,11 @@ You are a project reorganization assistant for a GSD (Get Shit Done) project. Th
 
 ## Supported Operations
 
+<!-- NOTE: Park, unpark, reorder, discard, and dependency-update operations are intentionally
+     file-based. No gsd_* tool API exists for these milestone-lifecycle mutations yet.
+     The single-writer DB tools (gsd_plan_milestone, gsd_complete_milestone, etc.) own
+     create and complete; queue management is file-driven until tool support is added. -->
+
 ### Reorder milestones
 Change execution order of pending/active milestones. Write `.gsd/QUEUE-ORDER.json`:
 ```json
@@ -44,7 +49,7 @@ Remove the `{ID}-PARKED.md` file from the milestone directory to reactivate it.
 **Permanently** delete a milestone directory and prune it from QUEUE-ORDER.json. **Always confirm with the user before discarding.** Warn explicitly if the milestone has completed work.
 
 ### Add a new milestone
-Use the `gsd_milestone_generate_id` tool to get the next ID, then write a `{ID}-CONTEXT.md` file in `.gsd/milestones/{ID}/` with scope, goals, and success criteria. Update QUEUE-ORDER.json to place it at the desired position.
+Use the `gsd_milestone_generate_id` tool to get the next ID, then call `gsd_summary_save` with `milestone_id: {ID}`, `artifact_type: "CONTEXT"`, and the scope/goals/success criteria as `content` — the tool writes the context file to disk and persists to DB. Update QUEUE-ORDER.json to place it at the desired position.
 
 ### Update dependencies
 Edit `depends_on` in the YAML frontmatter of a milestone's `{ID}-CONTEXT.md` file. For example:
@@ -75,4 +80,4 @@ If a proposed order would violate constraints, explain the issue and suggest alt
 - Do NOT park completed milestones — it would corrupt dependency satisfaction
 - Park is preferred over discard when a milestone has any completed work
 - Always persist queue order changes to `.gsd/QUEUE-ORDER.json`
-- After changes, run `git add .gsd/ && git commit -m "docs: rethink milestone order"` to persist
+- After changes, run `git add .gsd/ && git commit -m "docs(gsd): rethink milestone plan"` to persist (rethink runs interactively outside auto-mode, so no system auto-commit)

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

@@ -112,7 +112,7 @@ In all modes, slices commit sequentially on the active branch; there are no per-
 - **Milestones** are major project phases (M001, M002, ...)
 - **Slices** are demoable vertical increments (S01, S02, ...) ordered by risk. After each slice completes, the roadmap is reassessed before the next slice begins.
 - **Tasks** are single-context-window units of work (T01, T02, ...)
-- Checkboxes in roadmap and plan files track completion (`[ ]` → `[x]`)
+- Checkboxes in roadmap and plan files track completion (`[ ]` → `[x]`) — toggled automatically by gsd_* tools, never edited manually
 - Summaries compress prior work - read them instead of re-reading all task details
 - `STATE.md` is a system-managed status file — rebuilt automatically after each unit completes
 

package/dist/resources/extensions/gsd/session-lock.js

@@ -169,7 +169,6 @@ export function acquireSessionLock(basePath) {
         unitType: "starting",
         unitId: "bootstrap",
         unitStartedAt: new Date().toISOString(),
-        completedUnits: 0,
     };
     let lockfile;
     try {
@@ -314,7 +313,7 @@ function acquireFallbackLock(basePath, lp, lockData) {
  * Update the lock file metadata (called on each unit dispatch).
  * Does NOT re-acquire the OS lock — just updates the JSON content.
  */
-export function updateSessionLock(basePath, unitType, unitId, completedUnits, sessionFile) {
+export function updateSessionLock(basePath, unitType, unitId, sessionFile) {
     if (_lockedPath !== basePath && _lockedPath !== null)
         return;
     const lp = lockPath(basePath);
@@ -325,7 +324,6 @@ export function updateSessionLock(basePath, unitType, unitId, completedUnits, se
             unitType,
             unitId,
             unitStartedAt: new Date().toISOString(),
-            completedUnits,
             sessionFile,
         };
         atomicWriteSync(lp, JSON.stringify(data, null, 2));

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

@@ -57,6 +57,10 @@ export function isValidationTerminal(validationContent) {
 }
 const CACHE_TTL_MS = 100;
 let _stateCache = null;
+// ── Telemetry counters for derive-path observability ────────────────────────
+let _telemetry = { dbDeriveCount: 0, markdownDeriveCount: 0 };
+export function getDeriveTelemetry() { return { ..._telemetry }; }
+export function resetDeriveTelemetry() { _telemetry = { dbDeriveCount: 0, markdownDeriveCount: 0 }; }
 /**
  * Invalidate the deriveState() cache. Call this whenever planning files on disk
  * may have changed (unit completion, merges, file writes).
@@ -141,14 +145,17 @@ export async function deriveState(basePath) {
             const stopDbTimer = debugTime("derive-state-db");
             result = await deriveStateFromDb(basePath);
             stopDbTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
+            _telemetry.dbDeriveCount++;
         }
         else {
             // DB open but empty hierarchy tables — pre-migration project, use filesystem
             result = await _deriveStateImpl(basePath);
+            _telemetry.markdownDeriveCount++;
         }
     }
     else {
         result = await _deriveStateImpl(basePath);
+        _telemetry.markdownDeriveCount++;
     }
     stopTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
     debugCount("deriveStateCalls");

package/dist/resources/extensions/gsd/sync-lock.js

@@ -0,0 +1,89 @@
+// GSD Extension — Advisory Sync Lock
+// Prevents concurrent worktree syncs from colliding via a simple file lock.
+// Stale locks (mtime > 60s) are auto-overridden. Lock acquisition waits up
+// to 5 seconds then skips non-fatally.
+import { existsSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteSync } from "./atomic-write.js";
+const STALE_THRESHOLD_MS = 60_000; // 60 seconds
+const DEFAULT_TIMEOUT_MS = 5_000; // 5 seconds
+const SPIN_INTERVAL_MS = 100; // 100ms polling interval
+// SharedArrayBuffer for synchronous sleep via Atomics.wait
+const SLEEP_BUFFER = new SharedArrayBuffer(4);
+const SLEEP_VIEW = new Int32Array(SLEEP_BUFFER);
+function lockFilePath(basePath) {
+    return join(basePath, ".gsd", "sync.lock");
+}
+function sleepSync(ms) {
+    Atomics.wait(SLEEP_VIEW, 0, 0, ms);
+}
+/**
+ * Acquire an advisory sync lock for the given basePath.
+ * Returns { acquired: true } on success, { acquired: false } after timeout.
+ *
+ * - Creates lock file at {basePath}/.gsd/sync.lock with JSON { pid, acquired_at }
+ * - If lock exists and mtime > 60s (stale), overrides it
+ * - If lock exists and not stale, spins up to timeoutMs before giving up
+ */
+export function acquireSyncLock(basePath, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const lp = lockFilePath(basePath);
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        // Check if lock file exists
+        if (existsSync(lp)) {
+            // Check staleness
+            try {
+                const stat = statSync(lp);
+                const age = Date.now() - stat.mtimeMs;
+                if (age > STALE_THRESHOLD_MS) {
+                    // Stale lock — override it
+                    try {
+                        unlinkSync(lp);
+                    }
+                    catch { /* race: already removed */ }
+                }
+                else {
+                    // Lock is held and not stale — wait or give up
+                    if (Date.now() >= deadline) {
+                        return { acquired: false };
+                    }
+                    sleepSync(SPIN_INTERVAL_MS);
+                    continue;
+                }
+            }
+            catch {
+                // stat failed (file removed between exists check and stat) — try to acquire
+            }
+        }
+        // Lock file does not exist (or was just removed) — try to write it
+        try {
+            const lockData = {
+                pid: process.pid,
+                acquired_at: new Date().toISOString(),
+            };
+            atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
+            return { acquired: true };
+        }
+        catch {
+            // Write failed (race condition with another process) — retry or give up
+            if (Date.now() >= deadline) {
+                return { acquired: false };
+            }
+            sleepSync(SPIN_INTERVAL_MS);
+        }
+    }
+}
+/**
+ * Release the advisory sync lock. No-op if lock file does not exist.
+ */
+export function releaseSyncLock(basePath) {
+    const lp = lockFilePath(basePath);
+    try {
+        if (existsSync(lp)) {
+            unlinkSync(lp);
+        }
+    }
+    catch {
+        // Non-fatal — lock may have been released by another process
+    }
+}

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

@@ -7,10 +7,13 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
-import { transaction, getMilestoneSlices, _getAdapter, } from "../gsd-db.js";
+import { transaction, getMilestone, getMilestoneSlices, getSliceTasks, _getAdapter, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
 function renderMilestoneSummaryMarkdown(params) {
     const now = new Date().toISOString();
     const keyDecisionsYaml = params.keyDecisions.length > 0
@@ -72,25 +75,56 @@ export async function handleCompleteMilestone(params, basePath) {
     if (!params.title || typeof params.title !== "string" || params.title.trim() === "") {
         return { error: "title is required and must be a non-empty string" };
     }
-    // ── Verify all slices are complete ───────────────────────────────────────
-    const slices = getMilestoneSlices(params.milestoneId);
-    if (slices.length === 0) {
-        return { error: `no slices found for milestone ${params.milestoneId}` };
+    // ── Verify that verification passed ─────────────────────────────────────
+    if (params.verificationPassed !== true) {
+        return { error: "verification did not pass — milestone completion blocked. verificationPassed must be explicitly set to true after all verification steps succeed" };
     }
-    const incompleteSlices = slices.filter(s => s.status !== "complete" && s.status !== "done");
-    if (incompleteSlices.length > 0) {
-        const incompleteIds = incompleteSlices.map(s => `${s.id} (status: ${s.status})`).join(", ");
-        return { error: `incomplete slices: ${incompleteIds}` };
-    }
-    // ── DB writes inside a transaction ──────────────────────────────────────
+    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
+    let guardError = null;
     transaction(() => {
+        // State machine preconditions (inside txn for atomicity)
+        const milestone = getMilestone(params.milestoneId);
+        if (!milestone) {
+            guardError = `milestone not found: ${params.milestoneId}`;
+            return;
+        }
+        if (milestone.status === "complete" || milestone.status === "done") {
+            guardError = `milestone ${params.milestoneId} is already complete`;
+            return;
+        }
+        // Verify all slices are complete
+        const slices = getMilestoneSlices(params.milestoneId);
+        if (slices.length === 0) {
+            guardError = `no slices found for milestone ${params.milestoneId}`;
+            return;
+        }
+        const incompleteSlices = slices.filter(s => s.status !== "complete" && s.status !== "done");
+        if (incompleteSlices.length > 0) {
+            const incompleteIds = incompleteSlices.map(s => `${s.id} (status: ${s.status})`).join(", ");
+            guardError = `incomplete slices: ${incompleteIds}`;
+            return;
+        }
+        // Deep check: verify all tasks in all slices are complete
+        for (const slice of slices) {
+            const tasks = getSliceTasks(params.milestoneId, slice.id);
+            const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
+            if (incompleteTasks.length > 0) {
+                const ids = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
+                guardError = `slice ${slice.id} has incomplete tasks: ${ids}`;
+                return;
+            }
+        }
+        // All guards passed — perform write
         const adapter = _getAdapter();
         adapter.prepare(`UPDATE milestones SET status = 'complete', completed_at = :completed_at WHERE id = :mid`).run({
             ":completed_at": completedAt,
             ":mid": params.milestoneId,
         });
     });
+    if (guardError) {
+        return { error: guardError };
+    }
     // ── Filesystem operations (outside transaction) ─────────────────────────
     const summaryMd = renderMilestoneSummaryMarkdown(params);
     let summaryPath;
@@ -121,6 +155,22 @@ export async function handleCompleteMilestone(params, basePath) {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
+    // ── Post-mutation hook: projections, manifest, event log ───────────────
+    try {
+        await renderAllProjections(basePath, params.milestoneId);
+        writeManifest(basePath);
+        appendEvent(basePath, {
+            cmd: "complete-milestone",
+            params: { milestoneId: params.milestoneId },
+            ts: new Date().toISOString(),
+            actor: "agent",
+            actor_name: params.actorName,
+            trigger_reason: params.triggerReason,
+        });
+    }
+    catch (hookErr) {
+        process.stderr.write(`gsd: complete-milestone post-mutation hook warning: ${hookErr.message}\n`);
+    }
     return {
         milestoneId: params.milestoneId,
         summaryPath,

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

@@ -8,11 +8,15 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
-import { transaction, insertMilestone, insertSlice, getSliceTasks, updateSliceStatus, _getAdapter, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, getSlice, getSliceTasks, getMilestone, updateSliceStatus, _getAdapter, } from "../gsd-db.js";
 import { resolveSlicePath, clearPathCache } from "../paths.js";
+import { checkOwnership, sliceUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapCheckboxes } from "../markdown-renderer.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
 /**
  * Render slice summary markdown matching the template format.
  * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
@@ -162,23 +166,48 @@ export async function handleCompleteSlice(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    // ── Verify all tasks are complete ───────────────────────────────────────
-    const tasks = getSliceTasks(params.milestoneId, params.sliceId);
-    if (tasks.length === 0) {
-        return { error: `no tasks found for slice ${params.sliceId} in milestone ${params.milestoneId}` };
+    // ── Ownership check (opt-in: only enforced when claim file exists) ──────
+    const ownershipErr = checkOwnership(basePath, sliceUnitKey(params.milestoneId, params.sliceId), params.actorName);
+    if (ownershipErr) {
+        return { error: ownershipErr };
     }
-    const incompleteTasks = tasks.filter(t => t.status !== "complete");
-    if (incompleteTasks.length > 0) {
-        const incompleteIds = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
-        return { error: `incomplete tasks: ${incompleteIds}` };
-    }
-    // ── DB writes inside a transaction ──────────────────────────────────────
+    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
+    let guardError = null;
     transaction(() => {
+        // State machine preconditions (inside txn for atomicity).
+        // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
+        // Only block if they exist and are closed.
+        const milestone = getMilestone(params.milestoneId);
+        if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
+            guardError = `cannot complete slice in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
+            return;
+        }
+        const slice = getSlice(params.milestoneId, params.sliceId);
+        if (slice && (slice.status === "complete" || slice.status === "done")) {
+            guardError = `slice ${params.sliceId} is already complete — use gsd_slice_reopen first if you need to redo it`;
+            return;
+        }
+        // Verify all tasks are complete
+        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
+        if (tasks.length === 0) {
+            guardError = `no tasks found for slice ${params.sliceId} in milestone ${params.milestoneId}`;
+            return;
+        }
+        const incompleteTasks = tasks.filter(t => t.status !== "complete" && t.status !== "done");
+        if (incompleteTasks.length > 0) {
+            const incompleteIds = incompleteTasks.map(t => `${t.id} (status: ${t.status})`).join(", ");
+            guardError = `incomplete tasks: ${incompleteIds}`;
+            return;
+        }
+        // All guards passed — perform writes
         insertMilestone({ id: params.milestoneId });
         insertSlice({ id: params.sliceId, milestoneId: params.milestoneId });
         updateSliceStatus(params.milestoneId, params.sliceId, "complete", completedAt);
     });
+    if (guardError) {
+        return { error: guardError };
+    }
     // ── Filesystem operations (outside transaction) ─────────────────────────
     // If disk render fails, roll back the DB status so deriveState() and
     // verifyExpectedArtifact() stay consistent (both say "not done").
@@ -235,6 +264,22 @@ export async function handleCompleteSlice(params, basePath) {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
+    // ── Post-mutation hook: projections, manifest, event log ───────────────
+    try {
+        await renderAllProjections(basePath, params.milestoneId);
+        writeManifest(basePath);
+        appendEvent(basePath, {
+            cmd: "complete-slice",
+            params: { milestoneId: params.milestoneId, sliceId: params.sliceId },
+            ts: new Date().toISOString(),
+            actor: "agent",
+            actor_name: params.actorName,
+            trigger_reason: params.triggerReason,
+        });
+    }
+    catch (hookErr) {
+        process.stderr.write(`gsd: complete-slice post-mutation hook warning: ${hookErr.message}\n`);
+    }
     return {
         sliceId: params.sliceId,
         milestoneId: params.milestoneId,

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

@@ -8,11 +8,15 @@
  */
 import { join } from "node:path";
 import { mkdirSync } from "node:fs";
-import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, _getAdapter, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, insertTask, insertVerificationEvidence, getMilestone, getSlice, getTask, _getAdapter, } from "../gsd-db.js";
 import { resolveSliceFile, resolveTasksDir, clearPathCache } from "../paths.js";
+import { checkOwnership, taskUnitKey } from "../unit-ownership.js";
 import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanCheckboxes } from "../markdown-renderer.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
 /**
  * Render task summary markdown matching the template format.
  * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
@@ -105,9 +109,34 @@ export async function handleCompleteTask(params, basePath) {
     if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
         return { error: "milestoneId is required and must be a non-empty string" };
     }
-    // ── DB writes inside a transaction ──────────────────────────────────────
+    // ── Ownership check (opt-in: only enforced when claim file exists) ──────
+    const ownershipErr = checkOwnership(basePath, taskUnitKey(params.milestoneId, params.sliceId, params.taskId), params.actorName);
+    if (ownershipErr) {
+        return { error: ownershipErr };
+    }
+    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
+    let guardError = null;
     transaction(() => {
+        // State machine preconditions (inside txn for atomicity).
+        // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
+        // Only block if they exist and are closed.
+        const milestone = getMilestone(params.milestoneId);
+        if (milestone && (milestone.status === "complete" || milestone.status === "done")) {
+            guardError = `cannot complete task in a closed milestone: ${params.milestoneId} (status: ${milestone.status})`;
+            return;
+        }
+        const slice = getSlice(params.milestoneId, params.sliceId);
+        if (slice && (slice.status === "complete" || slice.status === "done")) {
+            guardError = `cannot complete task in a closed slice: ${params.sliceId} (status: ${slice.status})`;
+            return;
+        }
+        const existingTask = getTask(params.milestoneId, params.sliceId, params.taskId);
+        if (existingTask && (existingTask.status === "complete" || existingTask.status === "done")) {
+            guardError = `task ${params.taskId} is already complete — use gsd_task_reopen first if you need to redo it`;
+            return;
+        }
+        // All guards passed — perform writes
         insertMilestone({ id: params.milestoneId });
         insertSlice({ id: params.sliceId, milestoneId: params.milestoneId });
         insertTask({
@@ -138,6 +167,9 @@ export async function handleCompleteTask(params, basePath) {
             });
         }
     });
+    if (guardError) {
+        return { error: guardError };
+    }
     // ── Filesystem operations (outside transaction) ─────────────────────────
     // If disk render fails, roll back the DB status so deriveState() and
     // verifyExpectedArtifact() stay consistent (both say "not done").
@@ -195,6 +227,22 @@ export async function handleCompleteTask(params, basePath) {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
+    // ── Post-mutation hook: projections, manifest, event log ───────────────
+    try {
+        await renderAllProjections(basePath, params.milestoneId);
+        writeManifest(basePath);
+        appendEvent(basePath, {
+            cmd: "complete-task",
+            params: { milestoneId: params.milestoneId, sliceId: params.sliceId, taskId: params.taskId },
+            ts: new Date().toISOString(),
+            actor: "agent",
+            actor_name: params.actorName,
+            trigger_reason: params.triggerReason,
+        });
+    }
+    catch (hookErr) {
+        process.stderr.write(`gsd: complete-task post-mutation hook warning: ${hookErr.message}\n`);
+    }
     return {
         taskId: params.taskId,
         sliceId: params.sliceId,

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

@@ -1,7 +1,10 @@
 import { clearParseCache } from "../files.js";
-import { transaction, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
+import { transaction, getMilestone, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
+import { renderAllProjections } from "../workflow-projections.js";
+import { writeManifest } from "../workflow-manifest.js";
+import { appendEvent } from "../workflow-events.js";
 function isNonEmptyString(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
@@ -142,6 +145,23 @@ export async function handlePlanMilestone(rawParams, basePath) {
     catch (err) {
         return { error: `validation failed: ${err.message}` };
     }
+    // ── State machine preconditions ─────────────────────────────────────────
+    const existingMilestone = getMilestone(params.milestoneId);
+    if (existingMilestone && (existingMilestone.status === "complete" || existingMilestone.status === "done")) {
+        return { error: `cannot re-plan milestone ${params.milestoneId}: it is already complete` };
+    }
+    // Validate depends_on: all dependencies must exist and be complete
+    if (params.dependsOn && params.dependsOn.length > 0) {
+        for (const depId of params.dependsOn) {
+            const dep = getMilestone(depId);
+            if (!dep) {
+                return { error: `depends_on references unknown milestone: ${depId}` };
+            }
+            if (dep.status !== "complete" && dep.status !== "done") {
+                return { error: `depends_on milestone ${depId} is not yet complete (status: ${dep.status})` };
+            }
+        }
+    }
     try {
         transaction(() => {
             insertMilestone({
@@ -198,6 +218,22 @@ export async function handlePlanMilestone(rawParams, basePath) {
     }
     invalidateStateCache();
     clearParseCache();
+    // ── Post-mutation hook: projections, manifest, event log ───────────────
+    try {
+        await renderAllProjections(basePath, params.milestoneId);
+        writeManifest(basePath);
+        appendEvent(basePath, {
+            cmd: "plan-milestone",
+            params: { milestoneId: params.milestoneId },
+            ts: new Date().toISOString(),
+            actor: "agent",
+            actor_name: params.actorName,
+            trigger_reason: params.triggerReason,
+        });
+    }
+    catch (hookErr) {
+        process.stderr.write(`gsd: plan-milestone post-mutation hook warning: ${hookErr.message}\n`);
+    }
     return {
         milestoneId: params.milestoneId,
         roadmapPath,