gsd-pi 2.65.0 → 2.66.0-dev.e159299

package/src/resources/extensions/gsd/tests/worktree-main-branch.test.ts

@@ -0,0 +1,20 @@
+/**
+ * Regression test for #3461: createAutoWorktree must use git.main_branch
+ * preference when META.json integration branch is absent.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+test("auto-worktree.ts includes main_branch preference in startPoint fallback (#3461)", () => {
+  const src = readFileSync(
+    join(import.meta.dirname, "..", "auto-worktree.ts"),
+    "utf-8",
+  );
+  // The fix adds gitPrefs?.main_branch to the startPoint fallback chain
+  assert.ok(
+    src.includes("gitPrefs?.main_branch") || src.includes("prefs.main_branch"),
+    "createAutoWorktree must check git.main_branch preference before falling back to nativeDetectMainBranch",
+  );
+});

package/src/resources/extensions/gsd/tests/worktree-sync-milestones.test.ts

@@ -221,7 +221,8 @@ describe('worktree-sync-milestones', async () => {
 
     try {
       // Build worktree milestone structure with slice-level and task-level files
-      const wtSliceDir = join(wtBase, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+      // Use M002 as the milestone to sync, M001 as the "current" being merged (skipped)
+      const wtSliceDir = join(wtBase, '.gsd', 'milestones', 'M002', 'slices', 'S01');
       const wtTasksDir = join(wtSliceDir, 'tasks');
       mkdirSync(wtTasksDir, { recursive: true });
       writeFileSync(join(wtSliceDir, 'S01-SUMMARY.md'), '# S01 Summary');
@@ -229,11 +230,12 @@ describe('worktree-sync-milestones', async () => {
       writeFileSync(join(wtTasksDir, 'T02-SUMMARY.md'), '# T02 Summary');
 
       // Main project root starts with only the milestone directory (no slices yet)
-      mkdirSync(join(mainBase, '.gsd', 'milestones', 'M001'), { recursive: true });
+      mkdirSync(join(mainBase, '.gsd', 'milestones', 'M002'), { recursive: true });
 
+      // Pass M001 as milestoneId (the one being merged/skipped), M002 should still sync
       const { synced } = syncWorktreeStateBack(mainBase, wtBase, 'M001');
 
-      const mainSliceDir = join(mainBase, '.gsd', 'milestones', 'M001', 'slices', 'S01');
+      const mainSliceDir = join(mainBase, '.gsd', 'milestones', 'M002', 'slices', 'S01');
       const mainTasksDir = join(mainSliceDir, 'tasks');
 
       assert.ok(
@@ -341,16 +343,16 @@ describe('worktree-sync-milestones', async () => {
         'M002 missing in main before sync',
       );
 
-      // Sync with milestoneId = M001 (the current milestone)
+      // Sync with milestoneId = M001 (the current milestone being merged — skipped)
       const { synced } = syncWorktreeStateBack(mainBase, wtBase, 'M001');
 
-      // M001 should be synced (current milestone — always synced)
+      // M001 should be SKIPPED (current milestone being merged — #3641)
       assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'M001', 'M001-SUMMARY.md')),
-        'M001 SUMMARY synced to main',
+        !existsSync(join(mainBase, '.gsd', 'milestones', 'M001', 'M001-SUMMARY.md')),
+        'M001 SUMMARY NOT synced (current milestone skipped to prevent merge conflicts)',
       );
 
-      // M002 should ALSO be synced (next milestone — the fix)
+      // M002 should be synced (other milestone — not skipped)
       assert.ok(
         existsSync(join(mainBase, '.gsd', 'milestones', 'M002-abc123', 'M002-abc123-CONTEXT.md')),
         'M002 CONTEXT synced to main (next-milestone fix)',
@@ -407,20 +409,17 @@ describe('worktree-sync-milestones', async () => {
       writeFileSync(join(wtBase, '.gsd', 'REQUIREMENTS.md'), '# Requirements\n## R001-R089\n## R090 — SCIM\n## R091 — WebAuthn');
       writeFileSync(join(wtBase, '.gsd', 'PROJECT.md'), '# Project\nMilestones: M001-M007');
 
-      // Sync with milestoneId = M006 (the completing milestone)
+      // Sync with milestoneId = M006 (the completing milestone — skipped by sync)
       const { synced } = syncWorktreeStateBack(mainBase, wtBase, 'M006-589wvh');
 
-      // Verify M006 artifacts synced
-      assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'M006-589wvh', 'M006-589wvh-SUMMARY.md')),
-        'M006 SUMMARY synced',
-      );
+      // M006 is the current milestone being merged — it should be SKIPPED (#3641)
+      // Its files are already in the milestone branch and would conflict with squash merge.
       assert.ok(
-        existsSync(join(mainBase, '.gsd', 'milestones', 'M006-589wvh', 'slices', 'S01', 'S01-SUMMARY.md')),
-        'M006 S01 SUMMARY synced',
+        !existsSync(join(mainBase, '.gsd', 'milestones', 'M006-589wvh', 'M006-589wvh-SUMMARY.md')),
+        'M006 SUMMARY NOT synced (current milestone skipped)',
       );
 
-      // Verify M007 artifacts synced (the critical fix)
+      // Verify M007 artifacts synced (the critical fix — other milestones still sync)
       assert.ok(
         existsSync(join(mainBase, '.gsd', 'milestones', 'M007-wortc8', 'M007-wortc8-CONTEXT.md')),
         'M007 CONTEXT synced to main (next-milestone)',

package/src/resources/extensions/gsd/tests/worktree-sync-tasks.test.ts

@@ -47,7 +47,8 @@ function writeFile(dir: string, relativePath: string, content: string): void {
 test("syncWorktreeStateBack copies task summaries from tasks/ subdirectory (#1678)", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const mid = "M001";
+  const currentMid = "M000"; // milestone being merged (skipped by sync)
+  const mid = "M001";        // other milestone that should be synced
 
   try {
     // Set up worktree with milestone, slice, and task files
@@ -64,8 +65,8 @@ test("syncWorktreeStateBack copies task summaries from tasks/ subdirectory (#167
     // Set up main with empty .gsd
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    // Run sync
-    const result = syncWorktreeStateBack(mainBase, wtBase, mid);
+    // Run sync — currentMid is skipped, mid (M001) should be synced
+    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
 
     // Verify milestone-level files synced
     assert.ok(
@@ -126,7 +127,8 @@ test("syncWorktreeStateBack copies task summaries from tasks/ subdirectory (#167
 test("syncWorktreeStateBack handles multiple slices with tasks (#1678)", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const mid = "M002";
+  const currentMid = "M000"; // milestone being merged (skipped)
+  const mid = "M002";        // other milestone that should be synced
 
   try {
     // Set up two slices with tasks
@@ -139,7 +141,7 @@ test("syncWorktreeStateBack handles multiple slices with tasks (#1678)", () => {
 
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    const result = syncWorktreeStateBack(mainBase, wtBase, mid);
+    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
 
     // All task summaries from both slices should be synced
     assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`)));
@@ -160,7 +162,8 @@ test("syncWorktreeStateBack handles multiple slices with tasks (#1678)", () => {
 test("syncWorktreeStateBack handles slices without tasks/ directory", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const mid = "M003";
+  const currentMid = "M000"; // milestone being merged (skipped)
+  const mid = "M003";        // other milestone that should be synced
 
   try {
     // Slice with no tasks/ subdirectory (legitimate case: pre-planning)
@@ -168,7 +171,7 @@ test("syncWorktreeStateBack handles slices without tasks/ directory", () => {
 
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    const result = syncWorktreeStateBack(mainBase, wtBase, mid);
+    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
 
     // Should sync the slice file without errors
     assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/S01-RESEARCH.md`)));
@@ -183,7 +186,8 @@ test("syncWorktreeStateBack handles slices without tasks/ directory", () => {
 test("syncWorktreeStateBack ignores non-md files in tasks/", () => {
   const mainBase = makeTempDir("main");
   const wtBase = makeTempDir("wt");
-  const mid = "M004";
+  const currentMid = "M000"; // milestone being merged (skipped)
+  const mid = "M004";        // other milestone that should be synced
 
   try {
     writeFile(wtBase, `.gsd/milestones/${mid}/slices/S01/S01-PLAN.md`, "# Plan\n");
@@ -194,7 +198,7 @@ test("syncWorktreeStateBack ignores non-md files in tasks/", () => {
 
     mkdirSync(join(mainBase, ".gsd"), { recursive: true });
 
-    const result = syncWorktreeStateBack(mainBase, wtBase, mid);
+    const result = syncWorktreeStateBack(mainBase, wtBase, currentMid);
 
     // Only .md files should be synced
     assert.ok(existsSync(join(mainBase, `.gsd/milestones/${mid}/slices/S01/tasks/T01-SUMMARY.md`)));

package/src/resources/extensions/gsd/tests/worktree.test.ts

@@ -14,9 +14,11 @@ import {
   resolveProjectRoot,
   setActiveMilestoneId,
   SLICE_BRANCH_RE,
+  _resetServiceCache,
 } from "../worktree.ts";
 import { readIntegrationBranch } from "../git-service.ts";
 import { _resetHasChangesCache } from "../native-git-bridge.ts";
+import { _clearGsdRootCache } from "../paths.ts";
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 
@@ -165,15 +167,30 @@ describe('worktree', async () => {
     run("git checkout -b my-feature", repo);
     captureIntegrationBranch(repo, "M001");
 
-    // Without milestone set, getMainBranch returns "main"
-    setActiveMilestoneId(repo, null);
-    assert.deepStrictEqual(getMainBranch(repo), "main",
-      "getMainBranch returns main without milestone set");
-
-    // With milestone set, getMainBranch returns feature branch
-    setActiveMilestoneId(repo, "M001");
-    assert.deepStrictEqual(getMainBranch(repo), "my-feature",
-      "getMainBranch returns integration branch with milestone set");
+    // Isolate from user's global preferences (which may have git.main_branch set).
+    // Reset caches so getService() creates a fresh instance with empty preferences.
+    const originalHome = process.env.HOME;
+    const fakeHome = mkdtempSync(join(tmpdir(), "gsd-fake-home-"));
+    process.env.HOME = fakeHome;
+    _clearGsdRootCache();
+    _resetServiceCache();
+
+    try {
+      // Without milestone set, getMainBranch returns "main"
+      setActiveMilestoneId(repo, null);
+      assert.deepStrictEqual(getMainBranch(repo), "main",
+        "getMainBranch returns main without milestone set");
+
+      // With milestone set, getMainBranch returns feature branch
+      setActiveMilestoneId(repo, "M001");
+      assert.deepStrictEqual(getMainBranch(repo), "my-feature",
+        "getMainBranch returns integration branch with milestone set");
+    } finally {
+      process.env.HOME = originalHome;
+      _clearGsdRootCache();
+      _resetServiceCache();
+      rmSync(fakeHome, { recursive: true, force: true });
+    }
 
     rmSync(repo, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/write-gate.test.ts

@@ -12,6 +12,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {
+  isDepthConfirmationAnswer,
   shouldBlockContextWrite,
   isDepthVerified,
   isQueuePhaseActive,
@@ -117,9 +118,9 @@ test('write-gate: regex does not match slice context files (S01-CONTEXT.md)', ()
   assert.strictEqual(result.block, false, 'S01-CONTEXT.md should not be blocked');
 });
 
-// ─── Scenario 7: Error message contains actionable instruction ──
+// ─── Scenario 7: Error message contains actionable instruction and anti-bypass language ──
 
-test('write-gate: blocked reason contains depth_verification keyword', () => {
+test('write-gate: blocked reason contains depth_verification keyword and anti-bypass language', () => {
   const result = shouldBlockContextWrite(
     'write',
     '.gsd/milestones/M999/M999-CONTEXT.md',
@@ -129,6 +130,8 @@ test('write-gate: blocked reason contains depth_verification keyword', () => {
   assert.strictEqual(result.block, true);
   assert.ok(result.reason!.includes('depth_verification'), 'reason should mention depth_verification question id');
   assert.ok(result.reason!.includes('ask_user_questions'), 'reason should mention ask_user_questions tool');
+  assert.ok(result.reason!.includes('MUST NOT'), 'reason should include anti-bypass language');
+  assert.ok(result.reason!.includes('(Recommended)'), 'reason should specify the required confirmation option');
 });
 
 // ─── Scenario 8: Queue mode blocks CONTEXT.md write without depth verification ──
@@ -191,3 +194,125 @@ test('write-gate: markDepthVerified unblocks queue-mode writes when milestoneId
 
   clearDiscussionFlowState();
 });
+
+// ─── Standard options fixture used across depth confirmation tests ──
+
+const STANDARD_OPTIONS = [
+  { label: 'Yes, you got it (Recommended)' },
+  { label: 'Not quite — let me clarify' },
+];
+
+// ─── Scenario 11: accepts first option (confirmation) with structural validation ──
+
+test('write-gate: isDepthConfirmationAnswer accepts first option with options present', () => {
+  assert.strictEqual(
+    isDepthConfirmationAnswer('Yes, you got it (Recommended)', STANDARD_OPTIONS),
+    true,
+    'should accept exact match of first option label',
+  );
+});
+
+// ─── Scenario 12: rejects second option (decline) ──
+
+test('write-gate: isDepthConfirmationAnswer rejects decline option', () => {
+  assert.strictEqual(
+    isDepthConfirmationAnswer('Not quite — let me clarify', STANDARD_OPTIONS),
+    false,
+    'should reject the clarification option',
+  );
+});
+
+// ─── Scenario 13: rejects "None of the above" ──
+
+test('write-gate: isDepthConfirmationAnswer rejects None of the above', () => {
+  assert.strictEqual(
+    isDepthConfirmationAnswer('None of the above', STANDARD_OPTIONS),
+    false,
+    'should reject None of the above',
+  );
+});
+
+// ─── Scenario 14: rejects garbage/empty input ──
+
+test('write-gate: isDepthConfirmationAnswer rejects garbage and edge cases', () => {
+  assert.strictEqual(isDepthConfirmationAnswer('discord', STANDARD_OPTIONS), false, 'garbage string');
+  assert.strictEqual(isDepthConfirmationAnswer('', STANDARD_OPTIONS), false, 'empty string');
+  assert.strictEqual(isDepthConfirmationAnswer(undefined, STANDARD_OPTIONS), false, 'undefined');
+  assert.strictEqual(isDepthConfirmationAnswer(null, STANDARD_OPTIONS), false, 'null');
+  assert.strictEqual(isDepthConfirmationAnswer(42, STANDARD_OPTIONS), false, 'number');
+});
+
+// ─── Scenario 15: handles array-wrapped selection ──
+
+test('write-gate: isDepthConfirmationAnswer handles array-wrapped selected value', () => {
+  assert.strictEqual(
+    isDepthConfirmationAnswer(['Yes, you got it (Recommended)'], STANDARD_OPTIONS),
+    true,
+    'should accept array-wrapped confirmation',
+  );
+  assert.strictEqual(
+    isDepthConfirmationAnswer(['Not quite — let me clarify'], STANDARD_OPTIONS),
+    false,
+    'should reject array-wrapped decline',
+  );
+  assert.strictEqual(
+    isDepthConfirmationAnswer([], STANDARD_OPTIONS),
+    false,
+    'should reject empty array',
+  );
+});
+
+// ─── Scenario 16: rejects free-form "Other" text that contains "(Recommended)" ──
+
+test('write-gate: isDepthConfirmationAnswer rejects free-form text containing Recommended', () => {
+  assert.strictEqual(
+    isDepthConfirmationAnswer('I think this is fine (Recommended)', STANDARD_OPTIONS),
+    false,
+    'free-form text with (Recommended) substring must not unlock gate',
+  );
+  assert.strictEqual(
+    isDepthConfirmationAnswer('(Recommended)', STANDARD_OPTIONS),
+    false,
+    'bare (Recommended) string must not unlock gate',
+  );
+});
+
+// ─── Scenario 17: works with changed label text (decoupled from specific copy) ──
+
+test('write-gate: isDepthConfirmationAnswer works with different label text', () => {
+  const customOptions = [
+    { label: 'Looks good, proceed' },
+    { label: 'Needs more discussion' },
+  ];
+  assert.strictEqual(
+    isDepthConfirmationAnswer('Looks good, proceed', customOptions),
+    true,
+    'should accept first option regardless of label text',
+  );
+  assert.strictEqual(
+    isDepthConfirmationAnswer('Needs more discussion', customOptions),
+    false,
+    'should reject second option',
+  );
+  // Old label should NOT work with new options
+  assert.strictEqual(
+    isDepthConfirmationAnswer('Yes, you got it (Recommended)', customOptions),
+    false,
+    'old label text should not match new options',
+  );
+});
+
+// ─── Scenario 18: fallback when options not available ──
+
+test('write-gate: isDepthConfirmationAnswer falls back to (Recommended) match without options', () => {
+  assert.strictEqual(
+    isDepthConfirmationAnswer('Yes, you got it (Recommended)'),
+    true,
+    'should accept via fallback when no options provided',
+  );
+  assert.strictEqual(
+    isDepthConfirmationAnswer('Not quite — let me clarify'),
+    false,
+    'should reject non-Recommended via fallback',
+  );
+});

package/src/resources/extensions/gsd/tests/zero-slice-roadmap-guided.test.ts

@@ -0,0 +1,19 @@
+/**
+ * Regression test for #3441: guided flow must treat a roadmap with zero
+ * parseable slices the same as no roadmap — offer "Create roadmap" not "Go auto".
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+test("guided-flow checks roadmap slice count before offering auto (#3441)", () => {
+  const src = readFileSync(
+    join(import.meta.dirname, "..", "guided-flow.ts"),
+    "utf-8",
+  );
+  assert.ok(
+    src.includes("roadmapHasSlices") || src.includes("parseRoadmapSlices"),
+    "Guided flow must parse roadmap for slices before deciding which options to show",
+  );
+});

package/src/resources/extensions/gsd/tools/complete-milestone.ts

@@ -23,7 +23,7 @@ import { invalidateStateCache } from "../state.js";
 import { renderAllProjections, stripIdPrefix } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-import { logWarning } from "../workflow-logger.js";
+import { logWarning, logError } from "../workflow-logger.js";
 
 export interface CompleteMilestoneParams {
   milestoneId: string;
@@ -218,9 +218,19 @@ export async function handleCompleteMilestone(
   clearParseCache();
 
   // ── Post-mutation hook: projections, manifest, event log ───────────────
+  // Separate try/catch per step so a projection failure doesn't prevent
+  // the event log entry (critical for worktree reconciliation).
   try {
     await renderAllProjections(basePath, params.milestoneId);
+  } catch (projErr) {
+    logWarning("tool", `complete-milestone projection warning: ${(projErr as Error).message}`);
+  }
+  try {
     writeManifest(basePath);
+  } catch (mfErr) {
+    logWarning("tool", `complete-milestone manifest warning: ${(mfErr as Error).message}`);
+  }
+  try {
     appendEvent(basePath, {
       cmd: "complete-milestone",
       params: { milestoneId: params.milestoneId },
@@ -229,8 +239,8 @@ export async function handleCompleteMilestone(
       actor_name: params.actorName,
       trigger_reason: params.triggerReason,
     });
-  } catch (hookErr) {
-    logWarning("tool", `complete-milestone post-mutation hook warning: ${(hookErr as Error).message}`);
+  } catch (eventErr) {
+    logError("tool", `complete-milestone event log FAILED — completion invisible to reconciliation`, { error: (eventErr as Error).message });
   }
 
   return {

package/src/resources/extensions/gsd/tools/complete-slice.ts

@@ -30,7 +30,7 @@ import { renderRoadmapCheckboxes } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-import { logWarning } from "../workflow-logger.js";
+import { logWarning, logError } from "../workflow-logger.js";
 
 export interface CompleteSliceResult {
   sliceId: string;
@@ -233,8 +233,18 @@ export async function handleCompleteSlice(
     return { error: ownershipErr };
   }
 
+  // ── Verification content gate (#3580) ──────────────────────────────────
+  // Reject completion when the provided verification/UAT clearly indicates
+  // the slice is blocked or failed. Prevents prompt regressions from
+  // silently advancing blocked slices.
+  const BLOCKED_SIGNALS = /\b(status:\s*blocked|verification_result:\s*failed|slice is blocked|cannot complete|verification failed)\b/i;
+  if (BLOCKED_SIGNALS.test(params.verification || "") || BLOCKED_SIGNALS.test(params.uatContent || "")) {
+    return { error: `slice verification indicates blocked/failed state — do not complete a slice that has not passed verification. Address the blockers and re-verify first.` };
+  }
+
   // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
   const completedAt = new Date().toISOString();
+  const originalSliceStatus = getSlice(params.milestoneId, params.sliceId)?.status ?? "pending";
   let guardError: string | null = null;
 
   transaction(() => {
@@ -268,8 +278,8 @@ export async function handleCompleteSlice(
     }
 
     // All guards passed — perform writes
-    insertMilestone({ id: params.milestoneId });
-    insertSlice({ id: params.sliceId, milestoneId: params.milestoneId });
+    insertMilestone({ id: params.milestoneId, title: params.milestoneId });
+    insertSlice({ id: params.sliceId, milestoneId: params.milestoneId, title: params.sliceId });
     updateSliceStatus(params.milestoneId, params.sliceId, "complete", completedAt);
   });
 
@@ -312,7 +322,7 @@ export async function handleCompleteSlice(
   } catch (renderErr) {
     // Disk render failed — roll back DB status so state stays consistent
     logWarning("tool", `complete_slice — disk render failed for ${params.milestoneId}/${params.sliceId}, rolling back DB status`, { error: (renderErr as Error).message });
-    updateSliceStatus(params.milestoneId, params.sliceId, 'pending');
+    updateSliceStatus(params.milestoneId, params.sliceId, originalSliceStatus);
     invalidateStateCache();
     return { error: `disk render failed: ${(renderErr as Error).message}` };
   }
@@ -326,9 +336,19 @@ export async function handleCompleteSlice(
   clearParseCache();
 
   // ── Post-mutation hook: projections, manifest, event log ───────────────
+  // Separate try/catch per step so a projection failure doesn't prevent
+  // the event log entry (critical for worktree reconciliation).
   try {
     await renderAllProjections(basePath, params.milestoneId);
+  } catch (projErr) {
+    logWarning("tool", `complete-slice projection warning for ${params.milestoneId}/${params.sliceId}: ${(projErr as Error).message}`);
+  }
+  try {
     writeManifest(basePath);
+  } catch (mfErr) {
+    logWarning("tool", `complete-slice manifest warning: ${(mfErr as Error).message}`);
+  }
+  try {
     appendEvent(basePath, {
       cmd: "complete-slice",
       params: { milestoneId: params.milestoneId, sliceId: params.sliceId },
@@ -337,8 +357,8 @@ export async function handleCompleteSlice(
       actor_name: params.actorName,
       trigger_reason: params.triggerReason,
     });
-  } catch (hookErr) {
-    logWarning("tool", `complete-slice post-mutation hook failed for ${params.milestoneId}/${params.sliceId}`, { error: (hookErr as Error).message });
+  } catch (eventErr) {
+    logError("tool", `complete-slice event log FAILED — completion invisible to reconciliation`, { error: (eventErr as Error).message });
   }
 
   return {

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -33,7 +33,7 @@ import { renderPlanCheckboxes } from "../markdown-renderer.js";
 import { renderAllProjections, renderSummaryContent } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
-import { logWarning } from "../workflow-logger.js";
+import { logWarning, logError } from "../workflow-logger.js";
 
 export interface CompleteTaskResult {
   taskId: string;
@@ -44,6 +44,18 @@ export interface CompleteTaskResult {
 
 import type { TaskRow } from "../gsd-db.js";
 
+/**
+ * Normalize a list parameter that may arrive as a string (newline-delimited
+ * bullet list from the LLM) into a string array (#3361).
+ */
+function normalizeListParam(value: unknown): string[] {
+  if (Array.isArray(value)) return value.map(String);
+  if (typeof value === "string" && value.trim()) {
+    return value.split(/\n/).map(s => s.replace(/^[\s\-*•]+/, "").trim()).filter(Boolean);
+  }
+  return [];
+}
+
 /**
  * Build a TaskRow-shaped object from CompleteTaskParams so the unified
  * renderSummaryContent() can be used at completion time (#2720).
@@ -63,8 +75,8 @@ function paramsToTaskRow(params: CompleteTaskParams, completedAt: string): TaskR
     blocker_discovered: params.blockerDiscovered ?? false,
     deviations: params.deviations ?? "",
     known_issues: params.knownIssues ?? "",
-    key_files: params.keyFiles ?? [],
-    key_decisions: params.keyDecisions ?? [],
+    key_files: normalizeListParam(params.keyFiles),
+    key_decisions: normalizeListParam(params.keyDecisions),
     full_summary_md: "",
     description: "",
     estimate: "",
@@ -140,8 +152,8 @@ export async function handleCompleteTask(
     }
 
     // All guards passed — perform writes
-    insertMilestone({ id: params.milestoneId });
-    insertSlice({ id: params.sliceId, milestoneId: params.milestoneId });
+    insertMilestone({ id: params.milestoneId, title: params.milestoneId });
+    insertSlice({ id: params.sliceId, milestoneId: params.milestoneId, title: params.sliceId });
     insertTask({
       id: params.taskId,
       sliceId: params.sliceId,
@@ -230,9 +242,19 @@ export async function handleCompleteTask(
   clearParseCache();
 
   // ── Post-mutation hook: projections, manifest, event log ───────────────
+  // Separate try/catch per step so a projection failure doesn't prevent
+  // the event log entry (critical for worktree reconciliation).
   try {
     await renderAllProjections(basePath, params.milestoneId);
+  } catch (projErr) {
+    logWarning("tool", `complete-task projection warning: ${(projErr as Error).message}`);
+  }
+  try {
     writeManifest(basePath);
+  } catch (mfErr) {
+    logWarning("tool", `complete-task manifest warning: ${(mfErr as Error).message}`);
+  }
+  try {
     appendEvent(basePath, {
       cmd: "complete-task",
       params: { milestoneId: params.milestoneId, sliceId: params.sliceId, taskId: params.taskId },
@@ -241,8 +263,8 @@ export async function handleCompleteTask(
       actor_name: params.actorName,
       trigger_reason: params.triggerReason,
     });
-  } catch (hookErr) {
-    logWarning("tool", `complete-task post-mutation hook warning: ${(hookErr as Error).message}`);
+  } catch (eventErr) {
+    logError("tool", `complete-task event log FAILED — completion invisible to reconciliation`, { error: (eventErr as Error).message });
   }
 
   return {

package/src/resources/extensions/gsd/tools/plan-milestone.ts

@@ -48,13 +48,13 @@ export interface PlanMilestoneParams {
   keyRisks?: Array<{ risk: string; whyItMatters: string }>;
   /** @optional — defaults to [] when omitted */
   proofStrategy?: Array<{ riskOrUnknown: string; retireIn: string; whatWillBeProven: string }>;
-  /** @optional — defaults to "Not provided." when omitted */
+  /** @optional — defaults to "" when omitted */
   verificationContract?: string;
-  /** @optional — defaults to "Not provided." when omitted */
+  /** @optional — defaults to "" when omitted */
   verificationIntegration?: string;
-  /** @optional — defaults to "Not provided." when omitted */
+  /** @optional — defaults to "" when omitted */
   verificationOperational?: string;
-  /** @optional — defaults to "Not provided." when omitted */
+  /** @optional — defaults to "" when omitted */
   verificationUat?: string;
   /** @optional — defaults to [] when omitted */
   definitionOfDone?: string[];
@@ -168,10 +168,10 @@ function validateParams(params: PlanMilestoneParams): PlanMilestoneParams {
     successCriteria: params.successCriteria ? validateStringArray(params.successCriteria, "successCriteria") : [],
     keyRisks: params.keyRisks ? validateRiskEntries(params.keyRisks) : [],
     proofStrategy: params.proofStrategy ? validateProofStrategy(params.proofStrategy) : [],
-    verificationContract: params.verificationContract ?? "Not provided.",
-    verificationIntegration: params.verificationIntegration ?? "Not provided.",
-    verificationOperational: params.verificationOperational ?? "Not provided.",
-    verificationUat: params.verificationUat ?? "Not provided.",
+    verificationContract: params.verificationContract ?? "",
+    verificationIntegration: params.verificationIntegration ?? "",
+    verificationOperational: params.verificationOperational ?? "",
+    verificationUat: params.verificationUat ?? "",
     definitionOfDone: params.definitionOfDone ? validateStringArray(params.definitionOfDone, "definitionOfDone") : [],
     requirementCoverage: params.requirementCoverage ?? "Not provided.",
     boundaryMapMarkdown: params.boundaryMapMarkdown ?? "Not provided.",
@@ -256,7 +256,8 @@ export async function handlePlanMilestone(
         boundaryMapMarkdown: params.boundaryMapMarkdown,
       });
 
-      for (const slice of params.slices) {
+      for (let i = 0; i < params.slices.length; i++) {
+        const slice = params.slices[i]!;
         // Preserve completed/done status on re-plan (#2558).
         // Without this, a re-plan after milestone transition would reset
         // already-completed slices back to "pending".
@@ -272,6 +273,7 @@ export async function handlePlanMilestone(
           risk: slice.risk,
           depends: slice.depends,
           demo: slice.demo,
+          sequence: i + 1, // Preserve agent-ordered sequence (#3356)
         });
         upsertSlicePlanning(params.milestoneId, slice.sliceId, {
           goal: slice.goal,