@opengsd/gsd-pi 1.2.0-dev.84c56d87 → 1.2.0-dev.9ad8ae33

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -200,6 +200,74 @@ test("parseRoadmapSlices: checkbox slices with pipe characters do not switch to
   assert.deepEqual(slices[2]?.depends, ["S01", "S02"]);
 });
 
+test("parseRoadmapSlices: demo markdown table does not switch checkbox roadmap to table mode (#721)", () => {
+  const checkboxWithDemoTable = [
+    "# M004: Demo Table Repro",
+    "",
+    "## Slices",
+    "",
+    "- [x] **S01: First** `risk:low` `depends:[]`",
+    "  > After this: cli can render examples:",
+    "| Example | Meaning |",
+    "| --- | --- |",
+    "| S01 | Not a roadmap row |",
+    "- [ ] **S02: Second** `risk:medium` `depends:[S01]`",
+    "  > After this: cat file | sort returns stable output.",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(checkboxWithDemoTable);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.title, "First");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.deepEqual(slices[1]?.depends, ["S01"]);
+});
+
+test("parseRoadmapSlices: table preceded by intro prose still parsed as table (#722)", () => {
+  const tableWithIntro = [
+    "# M005: Intro Before Table",
+    "",
+    "## Slices",
+    "",
+    "This milestone is broken into the following slices:",
+    "",
+    "| Slice | Title | Risk | Status |",
+    "| --- | --- | --- | --- |",
+    "| S01 | Foundation | Low | [x] Done |",
+    "| S02 | Core | High | [ ] Pending |",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(tableWithIntro);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.done, false);
+});
+
+test("parseRoadmapSlices: table without markdown separator row still parsed as table (#722)", () => {
+  const tableWithoutSeparator = [
+    "# M006: No Separator",
+    "",
+    "## Slices",
+    "",
+    "| Slice | Title | Risk | Status |",
+    "| S01 | Foundation | Low | [x] Done |",
+    "| S02 | Core | High | [ ] Pending |",
+    "",
+  ].join("\n");
+
+  const slices = parseRoadmapSlices(tableWithoutSeparator);
+  assert.equal(slices.length, 2);
+  assert.equal(slices[0]?.id, "S01");
+  assert.equal(slices[0]?.done, true);
+  assert.equal(slices[1]?.id, "S02");
+  assert.equal(slices[1]?.done, false);
+});
+
 // --- Prose slice header completion marker tests (#1803) ---
 
 test("parseRoadmapSlices: prose headers with ✓ marker detected as done", () => {

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -6,7 +6,11 @@ import assert from "node:assert/strict";
 
 import { classifyFailure } from "../recovery-classification.js";
 import { reconcileBeforeDispatch } from "../state-reconciliation.js";
-import { compileUnitContextContract, compileUnitToolContract } from "../tool-contract.js";
+import {
+  compileUnitContextContract,
+  compileUnitToolContract,
+  getUnitWorkflowDispatchReadinessError,
+} from "../tool-contract.js";
 import { shouldBlockAutoUnitToolCall } from "../auto-unit-tool-scope.js";
 import type { GSDState } from "../types.js";
 
@@ -87,6 +91,20 @@ test("Tool Contract compiles known Unit prompt and tool policy", () => {
   });
 });
 
+test("Tool Contract derives dispatch readiness from Unit workflow tools", () => {
+  const error = getUnitWorkflowDispatchReadinessError({
+    provider: "claude-code",
+    unitType: "plan-slice",
+    projectRoot: "/tmp/project",
+    env: { GSD_WORKFLOW_MCP_COMMAND: "node" },
+    surface: "auto-mode",
+    authMode: "externalCli",
+    baseUrl: "local://claude-code",
+  });
+
+  assert.equal(error, null);
+});
+
 test("Unit Context Contract exposes prompt context without workflow tool surface", () => {
   const result = compileUnitContextContract("execute-task");
 

package/src/resources/extensions/gsd/tests/teardown-chdir-failure-clears-registry.test.ts

@@ -159,4 +159,21 @@ describe("teardown chdir failure clears registry", () => {
     assert.strictEqual(getAutoWorktreeOriginalBase(), null, "registry null after successful teardown");
     assert.strictEqual(getActiveAutoWorktreeContext(), null, "context null after successful teardown");
   });
+
+  test("teardown survives when current working directory was deleted", () => {
+    repoDir = createTempRepo();
+    seedMilestone(repoDir, "M003");
+
+    const worktreePath = createAutoWorktree(repoDir, "M003");
+    process.chdir(worktreePath);
+    rmSync(worktreePath, { recursive: true, force: true });
+
+    assert.doesNotThrow(
+      () => teardownAutoWorktree(repoDir, "M003"),
+      "teardownAutoWorktree should not call process.cwd() unguarded from a deleted cwd",
+    );
+
+    assert.strictEqual(getAutoWorktreeOriginalBase(), null, "registry null after deleted-cwd teardown");
+    assert.strictEqual(getActiveAutoWorktreeContext(), null, "context null after deleted-cwd teardown");
+  });
 });

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -18,6 +18,7 @@ test("buildMinimalGsdToolSet preserves non-GSD tools and replaces broad GSD surf
     "read",
     "browser_open",
     "gsd_plan_milestone",
+    "gsd_plan_slice",
     "gsd_task_complete",
     "gsd_exec",
     "gsd_exec_search",
@@ -648,6 +649,46 @@ test("buildMinimalAutoGsdToolSet resolves MCP-scoped gsd_memory_query and gsd_ca
   );
 });
 
+// ── Regression #627: auto-mode cannot run plan-milestone because gsd_plan_slice is missing ──
+// gsd_plan_slice is in AUTO_UNIT_SCOPED_TOOLS["plan-milestone"] (via unit-tool-contracts).
+// buildMinimalAutoGsdToolSet must expose it when unitType is "plan-milestone".
+
+test("buildMinimalAutoGsdToolSet includes gsd_plan_slice for plan-milestone (regression #627)", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "gsd_plan_milestone",
+    "gsd_plan_slice",
+    "gsd_milestone_status",
+    "gsd_checkpoint_db",
+    "memory_query",
+    "capture_thought",
+  ], "plan-milestone");
+
+  assert.ok(
+    result.includes("gsd_plan_slice"),
+    "gsd_plan_slice must be included in plan-milestone auto-mode tool set",
+  );
+});
+
+test("buildMinimalAutoGsdToolSet resolves MCP-scoped gsd_plan_slice for plan-milestone when subprocess only registers prefixed variant (regression #627)", () => {
+  const result = buildMinimalAutoGsdToolSet([
+    "bash",
+    "read",
+    "mcp__gsd-workflow__gsd_plan_milestone",
+    "mcp__gsd-workflow__gsd_plan_slice",
+    "mcp__gsd-workflow__gsd_milestone_status",
+    "mcp__gsd-workflow__gsd_checkpoint_db",
+    "mcp__gsd-workflow__memory_query",
+    "mcp__gsd-workflow__capture_thought",
+  ], "plan-milestone");
+
+  assert.ok(
+    result.includes("mcp__gsd-workflow__gsd_plan_slice"),
+    "mcp__gsd-workflow__gsd_plan_slice must be included when only the MCP-scoped variant is available",
+  );
+});
+
 test("applyUnitSkillVisibility sets manifest or clears for wildcard", () => {
   const calls: Array<string[] | undefined> = [];
   applyUnitSkillVisibility({

package/src/resources/extensions/gsd/tests/tool-unavailable-retry.test.ts

@@ -0,0 +1,33 @@
+/**
+ * Regression test for MCP tool-availability race.
+ *
+ * When the MCP workflow server is still connecting, tool calls fail with
+ * "No such tool available". The bounded retry counter on AutoSession
+ * (toolUnavailableRetries) prevents infinite re-dispatch loops by capping
+ * retries at 3 with escalating delay, then pausing auto-mode.
+ */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { AutoSession } from "../auto/session.ts";
+
+describe("toolUnavailableRetries on AutoSession", () => {
+  test("defaults to 0", () => {
+    const s = new AutoSession();
+    assert.equal(s.toolUnavailableRetries, 0);
+  });
+
+  test("is cleared on reset()", () => {
+    const s = new AutoSession();
+    s.toolUnavailableRetries = 2;
+    s.reset();
+    assert.equal(s.toolUnavailableRetries, 0);
+  });
+
+  test("accumulates across assignments (simulates retry increments)", () => {
+    const s = new AutoSession();
+    s.toolUnavailableRetries = 1;
+    s.toolUnavailableRetries = 2;
+    s.toolUnavailableRetries = 3;
+    assert.equal(s.toolUnavailableRetries, 3);
+  });
+});

package/src/resources/extensions/gsd/tests/transport-gate-double-complete.test.ts

@@ -0,0 +1,139 @@
+// gsd-pi — Regression tests for the centralized transport gate and
+// milestone double-complete guard (auto-dispatch.ts + phases.ts).
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolveDispatch } from "../auto-dispatch.ts";
+import { openDatabase, closeDatabase, insertMilestone, getMilestone } from "../gsd-db.ts";
+import { isClosedStatus } from "../status-guards.ts";
+import { getWorkflowTransportSupportError } from "../workflow-mcp.ts";
+
+// ── transport gate: getWorkflowTransportSupportError blocks missing tools ────
+
+test("getWorkflowTransportSupportError blocks when required non-surface tools are missing", () => {
+  const err = getWorkflowTransportSupportError(
+    "claude-code",
+    ["custom_non_surface_tool"],
+    {
+      projectRoot: process.cwd(),
+      surface: "auto-mode",
+      unitType: "execute-task",
+      authMode: "externalCli",
+      baseUrl: "local://claude-code",
+      activeTools: ["some_other_tool"],
+    },
+  );
+  assert.ok(err, "should return an error when required non-surface tools are missing from activeTools");
+  assert.match(err, /cannot run/i);
+});
+
+test("getWorkflowTransportSupportError passes for non-MCP transport", () => {
+  const err = getWorkflowTransportSupportError(
+    "claude-code",
+    ["custom_non_surface_tool"],
+    {
+      projectRoot: process.cwd(),
+      surface: "auto-mode",
+      unitType: "execute-task",
+      authMode: "apiKey",
+      baseUrl: "https://api.anthropic.com",
+      activeTools: [],
+    },
+  );
+  assert.equal(err, null, "non-MCP transport should not be blocked");
+});
+
+test("resolveDispatch allows dispatch when MCP tools are available", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-transport-pass-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+  const action = await resolveDispatch({
+    basePath: base,
+    mid: "M001",
+    midTitle: "Test",
+    state: {
+      phase: "executing",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      activeTask: { id: "M001/S01/T01", title: "Task", status: "pending" },
+      registry: [],
+      blockers: [],
+    } as any,
+    prefs: undefined,
+    // No transport gate deps → no MCP check → dispatch should go through
+  });
+
+  assert.equal(action.action, "dispatch");
+});
+
+// ── double-complete guard: isClosedStatus prevents duplicate closeout ────────
+
+test("isClosedStatus detects complete milestone status", () => {
+  assert.equal(isClosedStatus("complete"), true);
+  assert.equal(isClosedStatus("done"), true);
+  assert.equal(isClosedStatus("skipped"), true);
+  assert.equal(isClosedStatus("closed"), true);
+  assert.equal(isClosedStatus("active"), false);
+  assert.equal(isClosedStatus("pending"), false);
+  assert.equal(isClosedStatus(""), false);
+});
+
+test("getMilestone + isClosedStatus guards against double-complete dispatch", (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-double-complete-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+  // resolveDispatch itself checks for closed milestones at the top
+  // (before any dispatch rule fires), which is the same guard used
+  // by the phases.ts double-complete check.
+  const milestone = getMilestone("M001");
+  assert.ok(milestone, "milestone should exist in DB");
+  assert.equal(isClosedStatus(milestone.status), true, "closed milestone must be detected");
+});
+
+test("resolveDispatch stops on closed milestone before dispatching", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-closed-milestone-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  insertMilestone({ id: "M001", title: "Test", status: "complete" });
+
+  const action = await resolveDispatch({
+    basePath: base,
+    mid: "M001",
+    midTitle: "Test",
+    state: {
+      phase: "complete",
+      activeMilestone: { id: "M001", title: "Test", status: "complete" },
+      activeSlice: null,
+      activeTask: null,
+      registry: [],
+      blockers: [],
+    } as any,
+    prefs: undefined,
+  });
+
+  assert.equal(action.action, "stop");
+  assert.match(action.reason ?? "", /closed/i);
+});

package/src/resources/extensions/gsd/tests/uat-policy.test.ts

@@ -3,6 +3,7 @@ import assert from "node:assert/strict";
 
 import {
   classifyUatContent,
+  classifyUatContentForRun,
   getDeclaredUatType,
   getUatBrowserToolSupportError,
   isPartialEligibleUatType,
@@ -24,6 +25,92 @@ describe("uat-policy", () => {
     assert.equal(getDeclaredUatType("# UAT\n\nCheck generated files."), "artifact-driven");
   });
 
+  it("parses a bare keyword under ## UAT Type (M006/S01 agent format drift)", () => {
+    const content = [
+      "# S01 UAT",
+      "",
+      "## UAT Type",
+      "browser-executable",
+      "",
+      "## Preconditions",
+      "- Run `node tests/browser/search-uat.mjs` (it starts its own server on an ephemeral port; do not start serve-static separately).",
+    ].join("\n");
+    assert.equal(getDeclaredUatType(content), "browser-executable");
+    assert.equal(shouldEscalateArtifactUatToBrowser(content), false);
+  });
+
+  it("promotes browser-executable UAT when slice context names test:uat but UAT only documents test:server (M007/S01)", () => {
+    const uatFile = [
+      "# S01 UAT",
+      "",
+      "## UAT Type",
+      "- UAT mode: browser-executable",
+      "",
+      "## Preconditions",
+      "- Start the dev/local verification server with `npm run test:server`.",
+      "- Open the app at the localhost URL printed by the server.",
+    ].join("\n");
+    const sliceContext = [
+      "Fresh slice-level verification ran via `gsd_exec` with `npm run test:uat` and passed.",
+      "The run produced PASS with browser diagnostics consoleErrors=0.",
+    ].join("\n");
+
+    assert.equal(classifyUatContentForRun(uatFile, sliceContext).effectiveType, "runtime-executable");
+    assert.equal(classifyUatContentForRun(uatFile).effectiveType, "browser-executable");
+  });
+
+  it("promotes browser-executable UAT to runtime-executable when a self-contained harness is named (M006/S01)", () => {
+    const content = [
+      "# S01 UAT",
+      "",
+      "## UAT Type",
+      "- UAT mode: browser-executable",
+      "",
+      "## Preconditions",
+      "- Start the local app server with `npm run start`.",
+      "- Open the app at `http://127.0.0.1:4173`.",
+      "",
+      "## Evidence",
+      "- Fresh closeout verification command: `node --check app.js && node --check tests/browser/search-uat.mjs && npm run test:uat`",
+    ].join("\n");
+
+    assert.equal(resolveEffectiveUatType(content), "runtime-executable");
+    assert.deepEqual(classifyUatContent(content), {
+      declaredType: "browser-executable",
+      modeDeclared: true,
+      effectiveType: "runtime-executable",
+      browserRequired: false,
+      shouldDispatchByDefault: true,
+    });
+  });
+
+  it("parses a UAT mode line case-insensitively with bold markers", () => {
+    const content = [
+      "## UAT Type",
+      "- **UAT Mode:** Runtime-Executable (npx playwright test)",
+    ].join("\n");
+    assert.equal(getDeclaredUatType(content), "runtime-executable");
+  });
+
+  it("does not parse prose in the section as a mode declaration", () => {
+    const content = [
+      "## UAT Type",
+      "- Why this mode is sufficient: static checks cover the schema.",
+    ].join("\n");
+    assert.equal(getDeclaredUatType(content), "artifact-driven");
+  });
+
+  it("treats an explicit UAT mode line with an unrecognised value as undeclared", () => {
+    const content = [
+      "## UAT Type",
+      "- UAT mode: manual-spot-check",
+      "- browser-executable would also work",
+    ].join("\n");
+    // The explicit declaration wins (and fails to parse) — the stray keyword
+    // bullet below it must not be promoted to the declared mode.
+    assert.equal(getDeclaredUatType(content), "artifact-driven");
+  });
+
   it("escalates artifact-driven UAT to browser-executable when the spec requires browser work", () => {
     const content = [
       "## UAT Type",
@@ -38,6 +125,7 @@ describe("uat-policy", () => {
     assert.equal(shouldDispatchUatForContent(content, undefined), true);
     assert.deepEqual(classifyUatContent(content), {
       declaredType: "artifact-driven",
+      modeDeclared: true,
       effectiveType: "browser-executable",
       browserRequired: true,
       shouldDispatchByDefault: true,

package/src/resources/extensions/gsd/tests/unit-context-composer.test.ts

@@ -11,6 +11,7 @@ import {
   composeContractedUnitContext,
   composeContextModeInstructions,
   composeInlinedContext,
+  composeToolSurfaceInstructions,
   composeUnitContext,
   manifestBudgetChars,
   type ArtifactResolver,
@@ -203,6 +204,49 @@ test("Context Mode composer: workflow-preferences and research-decision render n
   );
 });
 
+test("Tool Surface composer: run-uat forbids gsd_exec and Bash", () => {
+  const out = composeToolSurfaceInstructions("run-uat", { renderMode: "standalone" });
+  assert.match(out, /^## Tool Surface/);
+  assert.match(out, /Do not call `gsd_exec`/);
+  assert.match(out, /`Bash`/);
+  assert.match(out, /`gsd_uat_exec`/);
+  assert.match(out, /`gsd_save_gate_result`/);
+  assert.match(out, /`gsd_summary_save`/);
+});
+
+test("Tool Surface composer: complete-slice steers verification to gsd_exec", () => {
+  const out = composeToolSurfaceInstructions("complete-slice", { renderMode: "standalone" });
+  assert.match(out, /`gsd_exec`/);
+  assert.match(out, /not direct `bash`/);
+  assert.match(out, /`gsd_uat_result_save`/);
+});
+
+test("Tool Surface composer: planning units restrict writes to .gsd", () => {
+  const out = composeToolSurfaceInstructions("discuss-milestone", { renderMode: "standalone" });
+  assert.match(out, /restricted to `\.gsd\/\*\*`/);
+  assert.match(out, /`ask_user_questions`/);
+});
+
+test("Tool Surface composer: planning-dispatch lists allowed subagents", () => {
+  const out = composeToolSurfaceInstructions("plan-slice", { renderMode: "standalone" });
+  assert.match(out, /\*\*scout\*\*/);
+  assert.match(out, /\*\*planner\*\*/);
+});
+
+test("Tool Surface composer: execute-task warns against slice/milestone closeout tools", () => {
+  const out = composeToolSurfaceInstructions("execute-task", { renderMode: "nested" });
+  assert.match(out, /^Tool surface: /);
+  assert.match(out, /`gsd_task_complete`/);
+  assert.match(out, /Do not call `gsd_slice_complete`/);
+});
+
+test("Tool Surface composer: unknown unit renders empty block", () => {
+  assert.strictEqual(
+    composeToolSurfaceInstructions("never-dispatched", { renderMode: "standalone" }),
+    "",
+  );
+});
+
 // ─── Integration: migrated buildReassessRoadmapPrompt ─────────────────────
 
 function makeFixtureBase(): string {

package/src/resources/extensions/gsd/tests/uok-audit-unified.test.ts

@@ -4,6 +4,7 @@ import { mkdtempSync, readFileSync, rmSync, existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { emitJournalEvent } from "../journal.ts";
+import { appendEvent } from "../workflow-events.ts";
 import { saveActivityLog } from "../activity-log.ts";
 import { initMetrics, resetMetrics, snapshotUnitMetrics } from "../metrics.ts";
 import { setLogBasePath, logWarning } from "../workflow-logger.ts";
@@ -38,6 +39,12 @@ test("unified audit plane bridges journal/activity/metrics/workflow logger into
       eventType: "iteration-start",
       data: { turnId: "turn-123", unitId: "M001/S01/T01" },
     });
+    appendEvent(basePath, {
+      cmd: "complete-task",
+      params: { milestoneId: "M001", sliceId: "S01", taskId: "T01" },
+      ts: new Date().toISOString(),
+      actor: "agent",
+    });
 
     const activityCtx = makeMockContext([
       { type: "message", message: { role: "assistant", content: [{ type: "text", text: "hello" }] } },
@@ -73,6 +80,7 @@ test("unified audit plane bridges journal/activity/metrics/workflow logger into
     const events = readAuditEvents(basePath);
     const types = new Set(events.map((event) => String(event.type ?? "")));
     assert.ok(types.has("journal-iteration-start"));
+    assert.ok(types.has("workflow-event-complete_task"));
     assert.ok(types.has("activity-log-saved"));
     assert.ok(types.has("unit-metrics-snapshot"));
     assert.ok(types.has("workflow-log-warn"));

package/src/resources/extensions/gsd/tests/verification-verdict.test.ts

@@ -24,6 +24,8 @@ test("execute-task fails closed when no host-owned checks are discovered", () =>
   assert.equal(verdict.reason, "no-host-checks");
   assert.equal(verdict.retryable, false);
   assert.match(verdict.failureContext, /No runnable host-owned verification command/);
+  assert.match(verdict.failureContext, /\.gsd\/PREFERENCES\.md/);
+  assert.match(verdict.failureContext, /\/gsd next/);
 });
 
 test("execute-task passes when non-runnable task-plan prose is the verification source", () => {

package/src/resources/extensions/gsd/tests/workflow-events.test.ts

@@ -13,6 +13,7 @@ import {
   compactMilestoneEvents,
   type WorkflowEvent,
 } from '../workflow-events.ts';
+import { workflowEventLogPath } from '../workflow-event-ledger.ts';
 
 function tempDir(): string {
   return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-events-'));
@@ -38,6 +39,24 @@ test('workflow-events: appendEvent creates .gsd dir and event-log.jsonl', () =>
   }
 });
 
+test('workflow-events: appendEvent from canonical worktree writes project ledger', () => {
+  const base = tempDir();
+  try {
+    const worktree = path.join(base, '.gsd-worktrees', 'M001');
+    fs.mkdirSync(worktree, { recursive: true });
+
+    appendEvent(worktree, makeEvent('complete-task', { milestoneId: 'M001', taskId: 'T01' }));
+
+    const projectLog = path.join(base, '.gsd', 'event-log.jsonl');
+    const worktreeLog = path.join(worktree, '.gsd', 'event-log.jsonl');
+    assert.ok(fs.existsSync(projectLog), 'project event ledger should exist');
+    assert.equal(fs.existsSync(worktreeLog), false, 'worktree-local event log should not be the append target');
+    assert.equal(workflowEventLogPath(worktree), projectLog);
+  } finally {
+    cleanupDir(base);
+  }
+});
+
 test('workflow-events: appendEvent writes valid JSON line', () => {
   const base = tempDir();
   try {

package/src/resources/extensions/gsd/tests/workflow-reconcile.test.ts

@@ -89,3 +89,23 @@ test("resolveConflict(pick=main) rewrites the worktree log durably", () => {
   const second = reconcileWorktreeLogs(main, worktree);
   assert.equal(second.conflicts.length, 0, "reconcile should stay clean after choosing main");
 });
+
+test("reconcileWorktreeLogs treats canonical worktree project-ledger appends as already durable", () => {
+  const root = mkdtempSync(join(tmpdir(), "workflow-reconcile-canonical-"));
+  const main = join(root, "main");
+  const worktree = join(main, ".gsd-worktrees", "M001");
+  mkdirSync(worktree, { recursive: true });
+  tmpDirs.push(root);
+
+  appendEvent(worktree, {
+    cmd: "complete-task",
+    params: { milestoneId: "M001", sliceId: "S01", taskId: "T01" },
+    ts: "2026-01-01T00:00:00.000Z",
+    actor: "agent",
+  });
+
+  const result = reconcileWorktreeLogs(main, worktree);
+
+  assert.equal(result.autoMerged, 0, "project-ledger append should not replay the root log");
+  assert.equal(result.conflicts.length, 0, "missing worktree shard is not a conflict");
+});