gsd-pi 2.75.0 → 2.76.0

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

@@ -997,3 +997,38 @@ test("dependency-audit: subdirectory package.json does not trigger audit", () =>
   assert.equal(npmAuditCalled, false, "subdirectory dependency files should not trigger audit");
   assert.deepStrictEqual(result, []);
 });
+
+// ─── Python normalization (regression: #4416) ────────────────────────────────
+// Verification commands using python3/python must succeed even when only the
+// alternate interpreter name is available. The gate rewrites the command via
+// normalizePythonCommand before spawning — tested here end-to-end on this host.
+
+describe("verification-gate: python normalization (#4416)", () => {
+  let tmp: string;
+  beforeEach(() => { tmp = makeTempDir("vg-python"); });
+  afterEach(() => { rmSync(tmp, { recursive: true, force: true }); });
+
+  test("python3 --version command succeeds on this host (gate uses normalized invocation)", () => {
+    // This test verifies that runVerificationGate can execute a python command
+    // without hard-failing due to interpreter name mismatch. On hosts where
+    // python3 is available it runs directly; on hosts where only python or py
+    // exists, normalizePythonCommand rewrites the token before spawnSync.
+    const result = runVerificationGate({
+      cwd: tmp,
+      preferenceCommands: ["python3 --version"],
+    });
+    assert.equal(typeof result.passed, "boolean");
+    assert.equal(result.checks.length, 1);
+    assert.ok(result.checks[0].durationMs >= 0);
+  });
+
+  test("python --version command produces a VerificationResult (not a crash)", () => {
+    const result = runVerificationGate({
+      cwd: tmp,
+      preferenceCommands: ["python --version"],
+    });
+    assert.equal(typeof result.passed, "boolean");
+    assert.equal(result.checks.length, 1);
+    assert.ok(result.checks[0].durationMs >= 0);
+  });
+});

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

@@ -0,0 +1,113 @@
+// gsd-2 — Regression tests for workflow-install path containment and ext fallback.
+
+import { describe, it, afterEach, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync } from "node:fs";
+import { join, sep as pathSep } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  installPlugin,
+  uninstallPlugin,
+  projectInstallDir,
+  type FetchedContent,
+  type InstallTarget,
+} from "../workflow-install.ts";
+import { parseWorkflowOverridesOnly } from "../commands/handlers/workflow.ts";
+
+const tmpDirs: string[] = [];
+let savedGsdHome: string | undefined;
+
+function makeTmpBase(): string {
+  const dir = mkdtempSync(join(tmpdir(), "wf-install-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+beforeEach(() => {
+  savedGsdHome = process.env.GSD_HOME;
+  process.env.GSD_HOME = makeTmpBase();
+});
+
+afterEach(() => {
+  if (savedGsdHome === undefined) delete process.env.GSD_HOME;
+  else process.env.GSD_HOME = savedGsdHome;
+  for (const d of tmpDirs) {
+    try { rmSync(d, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 }); } catch { /* ignore */ }
+  }
+  tmpDirs.length = 0;
+});
+
+function fakeFetched(content: string, ext: ".yaml" | ".md" = ".yaml"): FetchedContent {
+  return {
+    url: `https://example.test/raw/foo${ext}`,
+    filename: `foo${ext}`,
+    ext,
+    content,
+    sha256: "deadbeef",
+  };
+}
+
+describe("workflow-install path containment", () => {
+  it("installPlugin rejects names with path separators", () => {
+    const base = makeTmpBase();
+    const target: InstallTarget = { dir: projectInstallDir(base), scope: "project" };
+    const fetched = fakeFetched("name: ok\nsteps: []\n");
+    assert.throws(() => installPlugin(target, fetched, "../evil"), /Invalid plugin name/);
+    assert.throws(() => installPlugin(target, fetched, "evil/nested"), /Invalid plugin name/);
+    assert.throws(() => installPlugin(target, fetched, ".."), /Invalid plugin name/);
+  });
+
+  it("uninstallPlugin rejects names with path separators", () => {
+    const base = makeTmpBase();
+    assert.throws(() => uninstallPlugin(base, "../evil"), /Invalid plugin name/);
+    assert.throws(() => uninstallPlugin(base, "evil/nested"), /Invalid plugin name/);
+  });
+
+  it("installPlugin writes a safe name into the target dir", () => {
+    const base = makeTmpBase();
+    const target: InstallTarget = { dir: projectInstallDir(base), scope: "project" };
+    const fetched = fakeFetched("name: ok\nsteps: []\n");
+    const result = installPlugin(target, fetched, "safe-name");
+    assert.ok(result.path.startsWith(target.dir + pathSep) || result.path === join(target.dir, "safe-name.yaml"));
+    assert.ok(existsSync(result.path));
+  });
+
+  it("uninstallPlugin ignores provenance entries whose filename escapes the dir", () => {
+    const base = makeTmpBase();
+    const target: InstallTarget = { dir: projectInstallDir(base), scope: "project" };
+    mkdirSync(target.dir, { recursive: true });
+    // Seed a malicious provenance record.
+    const bogus = {
+      "hijack": {
+        source: "https://example.test/x",
+        installedAt: new Date().toISOString(),
+        sha256: "0",
+        filename: "../../etc/passwd",
+      },
+    };
+    writeFileSync(join(target.dir, ".installed.json"), JSON.stringify(bogus), "utf-8");
+    assert.throws(() => uninstallPlugin(base, "hijack"), /Invalid plugin name|Refusing to operate outside/);
+  });
+});
+
+describe("parseWorkflowOverridesOnly", () => {
+  it("keeps all k=v pairs when no name prefix is present", () => {
+    const ov = parseWorkflowOverridesOnly("target=src/foo.ts newName=bar");
+    assert.equal(ov.target, "src/foo.ts");
+    assert.equal(ov.newName, "bar");
+  });
+
+  it("does not drop the first argument", () => {
+    const ov = parseWorkflowOverridesOnly("a=1 b=2");
+    assert.equal(ov.a, "1");
+    assert.equal(ov.b, "2");
+  });
+
+  it("ignores tokens without `=`", () => {
+    const ov = parseWorkflowOverridesOnly("a=1 bareword b=2");
+    assert.equal(ov.a, "1");
+    assert.equal(ov.b, "2");
+    assert.equal(Object.keys(ov).length, 2);
+  });
+});

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

@@ -88,15 +88,24 @@ test("runFinalize drains and surfaces logger buffer via ctx.ui.notify", () => {
 });
 
 test("runFinalize timeout branches drain the buffer to prevent bleed", () => {
-  // Both timeout branches null out s.currentUnit — they should also drain
-  // so accumulated logs for the timed-out unit don't leak into the next.
+  // Both timeout branches route through failClosedOnFinalizeTimeout; that
+  // helper must drain the buffer so timed-out unit logs do not bleed into
+  // the next unit.
   const runFinalizeIdx = phasesSrc.indexOf("export async function runFinalize");
   const finalizeBody = phasesSrc.slice(runFinalizeIdx);
-  const drainCallCount =
-    (finalizeBody.match(/drainLogs\(\)/g) ?? []).length;
+  const timeoutHelperCalls =
+    (finalizeBody.match(/failClosedOnFinalizeTimeout\(/g) ?? []).length;
   assert.ok(
-    drainCallCount >= 2,
-    `runFinalize timeout branches should each call drainLogs() (found ${drainCallCount}, expected >= 2)`,
+    timeoutHelperCalls >= 2,
+    `runFinalize timeout branches should each route through failClosedOnFinalizeTimeout() (found ${timeoutHelperCalls}, expected >= 2)`,
+  );
+
+  const helperMatch = phasesSrc.match(
+    /async function failClosedOnFinalizeTimeout[\s\S]*?drainLogs\(\)/,
+  );
+  assert.ok(
+    helperMatch,
+    "failClosedOnFinalizeTimeout should drain the logger buffer before returning",
   );
 });
 

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

@@ -441,13 +441,13 @@ test("usesWorkflowMcpTransport matches local externalCli providers", () => {
   assert.equal(usesWorkflowMcpTransport("oauth", "local://custom"), false);
 });
 
-test("supportsStructuredQuestions disables structured ask flow on workflow MCP transports", () => {
+test("supportsStructuredQuestions stays enabled on workflow MCP transports when ask_user_questions is available", () => {
   assert.equal(
     supportsStructuredQuestions(["ask_user_questions"], {
       authMode: "externalCli",
       baseUrl: "local://claude-code",
     }),
-    false,
+    true,
   );
   assert.equal(
     supportsStructuredQuestions(["ask_user_questions"], {

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

@@ -0,0 +1,310 @@
+/**
+ * workflow-plugins.test.ts — Tests for the unified plugin discovery & resolution.
+ *
+ * Verifies precedence (project > global > bundled), both YAML and markdown
+ * formats, mode defaults, invalid-file handling, and legacy compat with
+ * `.gsd/workflow-defs/`.
+ */
+
+import { describe, it, afterEach, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  rmSync,
+  mkdirSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  discoverPlugins,
+  resolvePlugin,
+  listPluginsFormatted,
+  formatPluginInfo,
+} from "../workflow-plugins.ts";
+
+// ─── Test setup ──────────────────────────────────────────────────────────
+
+const tmpDirs: string[] = [];
+let savedGsdHome: string | undefined;
+
+function makeTmpBase(): string {
+  const dir = mkdtempSync(join(tmpdir(), "wf-plugins-test-"));
+  tmpDirs.push(dir);
+  return dir;
+}
+
+beforeEach(() => {
+  savedGsdHome = process.env.GSD_HOME;
+  const fakeHome = makeTmpBase();
+  process.env.GSD_HOME = fakeHome;
+});
+
+afterEach(() => {
+  if (savedGsdHome === undefined) {
+    delete process.env.GSD_HOME;
+  } else {
+    process.env.GSD_HOME = savedGsdHome;
+  }
+  for (const d of tmpDirs) {
+    try { rmSync(d, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 }); } catch { /* non-fatal */ }
+  }
+  tmpDirs.length = 0;
+});
+
+function writeFile(path: string, content: string): void {
+  mkdirSync(join(path, "..").replace(/[^/]+$/, ""), { recursive: true });
+  writeFileSync(path, content, "utf-8");
+}
+
+function writeProjectPlugin(basePath: string, filename: string, content: string): void {
+  const dir = join(basePath, ".gsd", "workflows");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, filename), content, "utf-8");
+}
+
+function writeGlobalPlugin(filename: string, content: string): void {
+  const dir = join(process.env.GSD_HOME!, "workflows");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, filename), content, "utf-8");
+}
+
+function writeLegacyDef(basePath: string, filename: string, content: string): void {
+  const dir = join(basePath, ".gsd", "workflow-defs");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, filename), content, "utf-8");
+}
+
+const SIMPLE_YAML = `
+version: 1
+name: sample
+description: A sample YAML plugin
+steps:
+  - id: s1
+    name: Step 1
+    prompt: Do the thing
+`;
+
+const SIMPLE_ONESHOT_YAML = `
+version: 1
+name: oneshot-sample
+mode: oneshot
+description: A oneshot yaml plugin
+steps:
+  - id: only
+    name: Only
+    prompt: Just do it
+`;
+
+const SIMPLE_MD = `# Sample MD Plugin
+
+<template_meta>
+name: sample-md
+version: 1
+mode: markdown-phase
+artifact_dir: .gsd/workflows/samples/
+</template_meta>
+
+<phases>
+1. one
+2. two
+</phases>
+`;
+
+const ONESHOT_MD = `# Oneshot MD Plugin
+
+<template_meta>
+name: oneshot-md
+version: 1
+mode: oneshot
+</template_meta>
+`;
+
+// ─── Bundled discovery ───────────────────────────────────────────────────
+
+describe("discoverPlugins: bundled tier", () => {
+  it("discovers the 8+ bundled templates", () => {
+    const base = makeTmpBase();
+    const plugins = discoverPlugins(base);
+    for (const id of ["bugfix", "hotfix", "spike", "full-project"]) {
+      assert.ok(plugins.has(id), `bundled plugin "${id}" should be discovered`);
+    }
+    assert.equal(plugins.get("bugfix")!.source, "bundled");
+    assert.equal(plugins.get("bugfix")!.format, "md");
+  });
+
+  it("bundled templates have valid mode values", () => {
+    const base = makeTmpBase();
+    const plugins = discoverPlugins(base);
+    const bugfix = plugins.get("bugfix")!;
+    assert.equal(bugfix.meta.mode, "markdown-phase");
+    const fullProject = plugins.get("full-project")!;
+    assert.equal(fullProject.meta.mode, "auto-milestone");
+  });
+});
+
+// ─── Project / Global / Bundled precedence ───────────────────────────────
+
+describe("discoverPlugins: precedence", () => {
+  it("project overrides bundled", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "bugfix.md", `# Overridden\n\n<template_meta>\nname: bugfix-override\nmode: markdown-phase\n</template_meta>`);
+    const plugins = discoverPlugins(base);
+    const bugfix = plugins.get("bugfix")!;
+    assert.equal(bugfix.source, "project");
+    assert.ok(bugfix.path.includes(".gsd/workflows/bugfix.md"));
+  });
+
+  it("global overrides bundled when project is absent", () => {
+    const base = makeTmpBase();
+    writeGlobalPlugin("bugfix.md", `# Global\n\n<template_meta>\nname: bugfix-global\nmode: markdown-phase\n</template_meta>`);
+    const plugins = discoverPlugins(base);
+    const bugfix = plugins.get("bugfix")!;
+    assert.equal(bugfix.source, "global");
+  });
+
+  it("project overrides global", () => {
+    const base = makeTmpBase();
+    writeGlobalPlugin("foo.yaml", SIMPLE_YAML);
+    writeProjectPlugin(base, "foo.yaml", SIMPLE_YAML.replace("sample", "foo"));
+    const plugins = discoverPlugins(base);
+    assert.equal(plugins.get("foo")!.source, "project");
+  });
+});
+
+// ─── YAML + MD format handling ───────────────────────────────────────────
+
+describe("discoverPlugins: formats", () => {
+  it("loads a project YAML plugin with default mode yaml-step", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "sample.yaml", SIMPLE_YAML);
+    const plugins = discoverPlugins(base);
+    const p = plugins.get("sample")!;
+    assert.equal(p.format, "yaml");
+    assert.equal(p.meta.mode, "yaml-step");
+    assert.equal(p.meta.displayName, "sample");
+  });
+
+  it("respects mode: oneshot in YAML", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "oneshot-sample.yaml", SIMPLE_ONESHOT_YAML);
+    const plugins = discoverPlugins(base);
+    assert.equal(plugins.get("oneshot-sample")!.meta.mode, "oneshot");
+  });
+
+  it("loads a project MD plugin with default mode markdown-phase", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "simple-md.md", `# Plain\n\n<template_meta>\nname: plain\n</template_meta>`);
+    const plugins = discoverPlugins(base);
+    assert.equal(plugins.get("simple-md")!.meta.mode, "markdown-phase");
+  });
+
+  it("respects mode: oneshot in MD", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "oneshot-md.md", ONESHOT_MD);
+    const plugins = discoverPlugins(base);
+    assert.equal(plugins.get("oneshot-md")!.meta.mode, "oneshot");
+  });
+
+  it("parses phases from MD <phases> block", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "sample-md.md", SIMPLE_MD);
+    const plugins = discoverPlugins(base);
+    const p = plugins.get("sample-md")!;
+    assert.deepEqual(p.meta.phases, ["one", "two"]);
+  });
+});
+
+// ─── Error handling ──────────────────────────────────────────────────────
+
+describe("discoverPlugins: error handling", () => {
+  it("invalid YAML surfaces as an entry with an error, doesn't crash", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "broken.yaml", "this: is: not: valid: yaml:\n  - x\n    - y");
+    const plugins = discoverPlugins(base);
+    const p = plugins.get("broken");
+    assert.ok(p, "broken plugin should still appear");
+    if (p!.error) {
+      assert.match(p!.error, /parse|object/i);
+    }
+  });
+
+  it("ignores subdirectories under .gsd/workflows/ (artifact dirs)", () => {
+    const base = makeTmpBase();
+    // Create a subdir — simulates `/gsd start bugfix` artifact dir
+    mkdirSync(join(base, ".gsd", "workflows", "bugfixes", "250101-1-slug"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "workflows", "bugfixes", "250101-1-slug", "STATE.json"), "{}", "utf-8");
+    const plugins = discoverPlugins(base);
+    assert.ok(!plugins.has("bugfixes"), "should not pick up subdir as a plugin");
+  });
+});
+
+// ─── resolvePlugin ───────────────────────────────────────────────────────
+
+describe("resolvePlugin", () => {
+  it("returns the plugin by name", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "foo.yaml", SIMPLE_YAML);
+    const p = resolvePlugin(base, "foo");
+    assert.ok(p);
+    assert.equal(p!.name, "foo");
+  });
+
+  it("returns null for unknown names", () => {
+    const base = makeTmpBase();
+    assert.equal(resolvePlugin(base, "nonexistent-plugin-xyz"), null);
+  });
+
+  it("resolves bundled templates", () => {
+    const base = makeTmpBase();
+    const p = resolvePlugin(base, "bugfix");
+    assert.ok(p);
+    assert.equal(p!.source, "bundled");
+  });
+});
+
+// ─── Legacy fallback ─────────────────────────────────────────────────────
+
+describe("discoverPlugins: legacy .gsd/workflow-defs/", () => {
+  it("still discovers legacy YAML definitions", () => {
+    const base = makeTmpBase();
+    writeLegacyDef(base, "legacy.yaml", SIMPLE_YAML);
+    const plugins = discoverPlugins(base);
+    assert.ok(plugins.has("legacy"), "legacy definition should be discovered");
+    assert.equal(plugins.get("legacy")!.format, "yaml");
+  });
+
+  it("new .gsd/workflows/ overrides legacy .gsd/workflow-defs/", () => {
+    const base = makeTmpBase();
+    writeLegacyDef(base, "dup.yaml", SIMPLE_YAML);
+    writeProjectPlugin(base, "dup.yaml", SIMPLE_YAML);
+    const plugins = discoverPlugins(base);
+    const p = plugins.get("dup")!;
+    assert.ok(p.path.includes(".gsd/workflows/dup.yaml"));
+  });
+});
+
+// ─── Display ─────────────────────────────────────────────────────────────
+
+describe("listPluginsFormatted", () => {
+  it("produces output grouped by mode with bundled templates", () => {
+    const base = makeTmpBase();
+    const out = listPluginsFormatted(base);
+    assert.match(out, /Workflow Plugins/);
+    assert.match(out, /\[markdown-phase\]/);
+    assert.match(out, /bugfix/);
+  });
+});
+
+describe("formatPluginInfo", () => {
+  it("formats YAML plugin info", () => {
+    const base = makeTmpBase();
+    writeProjectPlugin(base, "foo.yaml", SIMPLE_YAML);
+    const p = resolvePlugin(base, "foo")!;
+    const info = formatPluginInfo(p);
+    assert.match(info, /Plugin:/);
+    assert.match(info, /Mode:\s+yaml-step/);
+    assert.match(info, /Source:\s+project/);
+  });
+});

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

@@ -28,6 +28,8 @@ function makeSlice(overrides: Partial<SliceRow> = {}): SliceRow {
     completed_at: null,
     sequence: 1,
     replan_triggered_at: null,
+    is_sketch: 0,
+    sketch_scope: '',
     ...overrides,
   };
 }
@@ -59,6 +61,11 @@ function makeTask(overrides: Partial<TaskRow> = {}): TaskRow {
     expected_output: [],
     observability_impact: '',
     sequence: 1,
+    blocker_source: '',
+    escalation_pending: 0,
+    escalation_awaiting_review: 0,
+    escalation_artifact_path: null,
+    escalation_override_applied_at: null,
     ...overrides,
   };
 }

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

@@ -36,8 +36,14 @@ console.log('\n── Registry Loading ──');
   for (const [id, entry] of Object.entries(registry.templates)) {
     assert.ok(typeof entry.name === 'string' && entry.name.length > 0, `${id}: name should be non-empty string`);
     assert.ok(typeof entry.description === 'string' && entry.description.length > 0, `${id}: description should be non-empty`);
-    assert.ok(typeof entry.file === 'string' && entry.file.endsWith('.md'), `${id}: file should be a .md path`);
-    assert.ok(Array.isArray(entry.phases) && entry.phases.length > 0, `${id}: phases should be non-empty array`);
+    assert.ok(typeof entry.file === 'string' && (entry.file.endsWith('.md') || entry.file.endsWith('.yaml') || entry.file.endsWith('.yml')), `${id}: file should be a .md or .yaml path`);
+    // Phases are only required for phased modes (markdown-phase, auto-milestone).
+    const isPhased = !entry.mode || entry.mode === 'markdown-phase' || entry.mode === 'auto-milestone';
+    if (isPhased) {
+      assert.ok(Array.isArray(entry.phases) && entry.phases.length > 0, `${id}: phases should be non-empty array for phased mode`);
+    } else {
+      assert.ok(Array.isArray(entry.phases), `${id}: phases should be an array (may be empty for ${entry.mode})`);
+    }
     assert.ok(Array.isArray(entry.triggers) && entry.triggers.length > 0, `${id}: triggers should be non-empty array`);
   }
 }

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

@@ -11,6 +11,7 @@ import {
   _getAdapter,
   insertGateRow,
 } from "../gsd-db.ts";
+import { markDepthVerified, clearDiscussionFlowState } from "../bootstrap/write-gate.ts";
 import {
   executeCompleteMilestone,
   executePlanMilestone,
@@ -645,3 +646,99 @@ test("executeReplanSlice rewrites pending tasks and renders replan artifacts", a
     cleanup(base);
   }
 });
+
+test("executeSummarySave removes sibling CONTEXT-DRAFT when writing milestone CONTEXT (#4442)", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+    markDepthVerified("M001", base);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    const draftPath = join(milestoneDir, "M001-CONTEXT-DRAFT.md");
+    writeFileSync(draftPath, "# Draft\n\nincremental notes");
+    assert.ok(existsSync(draftPath), "precondition: draft exists");
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      milestone_id: "M001",
+      artifact_type: "CONTEXT",
+      content: "# Context\n\nfinal discussion output",
+    }, base));
+
+    assert.equal(result.details.operation, "save_summary");
+    assert.equal(result.details.artifact_type, "CONTEXT");
+
+    const contextPath = join(milestoneDir, "M001-CONTEXT.md");
+    assert.ok(existsSync(contextPath), "CONTEXT.md should be written");
+    assert.equal(
+      existsSync(draftPath),
+      false,
+      "CONTEXT-DRAFT.md should be removed after final CONTEXT.md is written",
+    );
+  } finally {
+    clearDiscussionFlowState();
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave removes sibling CONTEXT-DRAFT when writing slice CONTEXT (#4442)", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(sliceDir, { recursive: true });
+    const draftPath = join(sliceDir, "S01-CONTEXT-DRAFT.md");
+    writeFileSync(draftPath, "# Slice Draft\n\nincremental slice notes");
+    assert.ok(existsSync(draftPath), "precondition: slice draft exists");
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      milestone_id: "M001",
+      slice_id: "S01",
+      artifact_type: "CONTEXT",
+      content: "# Slice Context\n\nfinal slice output",
+    }, base));
+
+    assert.equal(result.details.operation, "save_summary");
+    assert.equal(result.details.artifact_type, "CONTEXT");
+
+    const contextPath = join(sliceDir, "S01-CONTEXT.md");
+    assert.ok(existsSync(contextPath), "slice CONTEXT.md should be written");
+    assert.equal(
+      existsSync(draftPath),
+      false,
+      "slice CONTEXT-DRAFT.md should be removed after final CONTEXT.md is written",
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});
+
+test("executeSummarySave leaves sibling CONTEXT-DRAFT intact for non-CONTEXT artifacts (#4442)", async () => {
+  const base = makeTmpBase();
+  try {
+    openTestDb(base);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    const draftPath = join(milestoneDir, "M001-CONTEXT-DRAFT.md");
+    writeFileSync(draftPath, "# Draft\n\nstill in progress");
+
+    const result = await inProjectDir(base, () => executeSummarySave({
+      milestone_id: "M001",
+      artifact_type: "RESEARCH",
+      content: "# Research\n\nresearch notes",
+    }, base));
+
+    assert.equal(result.details.artifact_type, "RESEARCH");
+    assert.ok(
+      existsSync(draftPath),
+      "CONTEXT-DRAFT.md must survive RESEARCH/SUMMARY/ASSESSMENT writes",
+    );
+  } finally {
+    closeDatabase();
+    cleanup(base);
+  }
+});

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

@@ -49,6 +49,7 @@ function makeDeps(
     loadEffectiveGSDPreferences: () => ({ preferences: { git: {} } }),
     invalidateAllCaches: () => {},
     captureIntegrationBranch: () => {},
+    enterBranchModeForMilestone: () => {},
     ...overrides,
   };
   return deps;
@@ -127,7 +128,7 @@ describe("worktree journal events", () => {
 
   test("enterMilestone emits worktree-skip when isolation disabled", () => {
     const s = makeSession({ basePath: tmp, originalBasePath: tmp });
-    const deps = makeDeps({ shouldUseWorktreeIsolation: () => false });
+    const deps = makeDeps({ shouldUseWorktreeIsolation: () => false, getIsolationMode: () => "none" });
     const resolver = new WorktreeResolver(s, deps);
 
     resolver.enterMilestone("M001", makeNotifyCtx());