gsd-pi 2.82.0-dev.9d5798940 → 2.82.0-dev.dfbc5f58f

package/src/resources/extensions/gsd/tests/pre-execution-checks.test.ts

@@ -9,6 +9,7 @@
  *   2. File path consistency — files exist vs prior expected_output
  *   3. Task ordering — detect impossible read-before-create
  *   4. Interface contracts — contradictory function signatures
+ *   5. Verify commands — reject unsafe or non-runnable task verification
  */
 
 import { describe, test, mock } from "node:test";
@@ -22,6 +23,7 @@ import {
   checkFilePathConsistency,
   checkTaskOrdering,
   checkInterfaceContracts,
+  checkVerificationCommands,
   runPreExecutionChecks,
   normalizeFilePath,
   type PreExecutionResult,
@@ -812,6 +814,33 @@ function process(a: number): number
   });
 });
 
+describe("checkVerificationCommands", () => {
+  test("accepts pipe-free pytest Verify command", () => {
+    const results = checkVerificationCommands([
+      createTask({
+        id: "T01",
+        verify: "python3 -m pytest tests/ -q --tb=short",
+      }),
+    ]);
+
+    assert.deepEqual(results, []);
+  });
+
+  test("rejects piped pytest Verify command", () => {
+    const results = checkVerificationCommands([
+      createTask({
+        id: "T01",
+        verify: "python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5",
+      }),
+    ]);
+
+    assert.equal(results.length, 1);
+    assert.equal(results[0]?.category, "tool");
+    assert.equal(results[0]?.blocking, true);
+    assert.match(results[0]?.message ?? "", /shell control syntax/);
+  });
+});
+
 // ─── runPreExecutionChecks Integration Tests ─────────────────────────────────
 
 describe("runPreExecutionChecks", () => {
@@ -847,6 +876,30 @@ describe("runPreExecutionChecks", () => {
     }
   });
 
+  test("returns fail status for unsafe Verify command before execution", async () => {
+    tempDir = join(tmpdir(), `pre-exec-test-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+
+    try {
+      const tasks = [
+        createTask({
+          id: "T01",
+          verify: "python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5",
+        }),
+      ];
+
+      const result = await runPreExecutionChecks(tasks, tempDir);
+
+      assert.equal(result.status, "fail");
+      assert.equal(result.checks.length, 1);
+      assert.equal(result.checks[0]?.category, "tool");
+      assert.equal(result.checks[0]?.blocking, true);
+      assert.match(result.checks[0]?.message ?? "", /Unsafe or non-runnable Verify command/);
+    } finally {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
   test("returns fail status when blocking failure exists", async () => {
     tempDir = join(tmpdir(), `pre-exec-test-${Date.now()}`);
     mkdirSync(tempDir, { recursive: true });

package/src/resources/extensions/gsd/tests/prompt-loader.test.ts

@@ -0,0 +1,23 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { loadPrompt } from "../prompt-loader.ts";
+
+test("loadPrompt reports missing template variables with balanced braces", () => {
+  assert.throws(
+    () => loadPrompt("guided-discuss-milestone", {
+      milestoneId: "M001",
+      milestoneTitle: "Missing working directory",
+      structuredQuestionsAvailable: "false",
+      fastPathInstruction: "",
+      inlinedTemplates: "context template",
+      commitInstruction: "Do not commit during this test.",
+    }),
+    (error) => {
+      assert.ok(error instanceof Error);
+      assert.match(error.message, /template declares \{\{workingDirectory\}\} but no value was provided/);
+      assert.doesNotMatch(error.message, /\{\{workingDirectory\}\}\}/);
+      return true;
+    },
+  );
+});

package/src/resources/extensions/gsd/tests/start-auto-detached.test.ts

@@ -99,19 +99,49 @@ test("auto bootstrap validates blocked directories before touching .gsd migratio
 
 test("fresh start registers the auto worker before bootstrap enters worktree flow (#5405)", () => {
   const autoSrc = readGsdFile("auto.ts");
+  const autoStartSrc = readGsdFile("auto-start.ts");
   const startAutoIdx = autoSrc.indexOf("export async function startAuto(");
   const startAutoBody = autoSrc.slice(startAutoIdx);
+  const bootstrapIdx = autoStartSrc.indexOf("export async function bootstrapAutoSession(");
+  const bootstrapBody = autoStartSrc.slice(bootstrapIdx);
 
-  const preBootstrapRegisterIdx = startAutoBody.indexOf("registerAutoWorkerForSession(s, base);");
   const bootstrapCallIdx = startAutoBody.indexOf("const ready = await bootstrapAutoSession(");
+  const preBootstrapBody = startAutoBody.slice(0, bootstrapCallIdx);
+  const preBootstrapRegisterIdx = preBootstrapBody.lastIndexOf("registerAutoWorkerForSession(s, base);");
+  const resumeSectionIdx = startAutoBody.indexOf("if (s.paused) {");
+  const freshStartSectionIdx = startAutoBody.indexOf("// ── Fresh start path — delegated to auto-start.ts ──");
+  const resumeBody = startAutoBody.slice(resumeSectionIdx, freshStartSectionIdx);
+  const resumeDbOpenIdx = resumeBody.indexOf("await openProjectDbIfPresent(base);");
+  const resumeRegisterIdx = resumeBody.indexOf("registerAutoWorkerForSession(s, base);");
+  const resumeEnterMilestoneIdx = resumeBody.indexOf("buildLifecycle().enterMilestone");
+  const dbOpenIdx = bootstrapBody.indexOf("await openProjectDbIfPresent(base);");
+  const bootstrapRegisterIdx = bootstrapBody.indexOf("registerAutoWorkerForSession(base);");
+  const enterMilestoneIdx = bootstrapBody.indexOf("buildLifecycle().enterMilestone");
 
   assert.ok(startAutoIdx > -1, "startAuto should exist");
   assert.ok(preBootstrapRegisterIdx > -1, "startAuto should register worker before bootstrap");
   assert.ok(bootstrapCallIdx > -1, "startAuto should call bootstrapAutoSession");
+  assert.ok(resumeSectionIdx > -1, "startAuto should have resume milestone entry flow");
+  assert.ok(freshStartSectionIdx > resumeSectionIdx, "resume assertions should be scoped before fresh start");
+  assert.ok(resumeDbOpenIdx > -1, "resume should open DB before milestone entry");
+  assert.ok(resumeRegisterIdx > -1, "resume should register worker before milestone entry");
+  assert.ok(resumeEnterMilestoneIdx > -1, "resume should enter milestones through lifecycle");
+  assert.ok(bootstrapIdx > -1, "bootstrapAutoSession should exist");
+  assert.ok(dbOpenIdx > -1, "bootstrap should open the project DB");
+  assert.ok(bootstrapRegisterIdx > -1, "bootstrap should register worker after DB open");
+  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter milestones through lifecycle");
   assert.ok(
     preBootstrapRegisterIdx < bootstrapCallIdx,
     "worker registration must happen before bootstrap so enterMilestone can claim milestone leases on first entry",
   );
+  assert.ok(
+    dbOpenIdx < bootstrapRegisterIdx && bootstrapRegisterIdx < enterMilestoneIdx,
+    "bootstrap must open DB and register worker before first enterMilestone",
+  );
+  assert.ok(
+    resumeDbOpenIdx < resumeRegisterIdx && resumeRegisterIdx < resumeEnterMilestoneIdx,
+    "resume must open DB and register worker before first enterMilestone",
+  );
 });
 
 test("startAutoDetached reports failures asynchronously (#3733)", () => {

package/src/resources/extensions/gsd/tests/stuck-state-via-db.test.ts

@@ -19,10 +19,11 @@ import {
   closeDatabase,
   insertMilestone,
 } from "../gsd-db.ts";
-import { registerAutoWorker } from "../db/auto-workers.ts";
+import { registerAutoWorker, markWorkerCrashed } from "../db/auto-workers.ts";
 import { claimMilestoneLease } from "../db/milestone-leases.ts";
 import {
   recordDispatchClaim,
+  markFailed,
   markCanceled,
   getRecentUnitKeysForWorker,
   getRecentUnitKeysForProjectRoot,
@@ -75,6 +76,7 @@ test("getRecentUnitKeysForProjectRoot restores compound keys used by stuck detec
   t.after(() => cleanup(base));
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "T", status: "active" });
+  insertMilestone({ id: "M002", title: "Crashed", status: "active" });
   const worker = registerAutoWorker({ projectRootRealpath: base });
   const lease = claimMilestoneLease(worker, "M001");
   assert.equal(lease.ok, true);
@@ -95,7 +97,29 @@ test("getRecentUnitKeysForProjectRoot restores compound keys used by stuck detec
     markCanceled(claim.dispatchId, "pause");
   }
 
-  const window = getRecentUnitKeysForProjectRoot(base, 20);
+  const crashedWorker = registerAutoWorker({ projectRootRealpath: base });
+  const crashedLease = claimMilestoneLease(crashedWorker, "M002");
+  assert.equal(crashedLease.ok, true);
+  if (!crashedLease.ok) return;
+
+  for (let i = 0; i < 3; i++) {
+    const claim = recordDispatchClaim({
+      traceId: `crashed-${i}`,
+      workerId: crashedWorker,
+      milestoneLeaseToken: crashedLease.token,
+      milestoneId: "M002",
+      sliceId: "S01",
+      taskId: "T01",
+      unitType: "execute-task",
+      unitId: "M002/S01/T01",
+    });
+    assert.equal(claim.ok, true);
+    if (!claim.ok) return;
+    markFailed(claim.dispatchId, { errorSummary: "worker crashed" });
+  }
+  markWorkerCrashed(crashedWorker);
+
+  const window = getRecentUnitKeysForProjectRoot(base, 3);
   assert.deepEqual(window.map(w => w.key), [
     "complete-slice/M001/S01",
     "complete-slice/M001/S01",

package/src/resources/extensions/gsd/tests/summary-render-parity.test.ts

@@ -175,13 +175,17 @@ const verificationEvidence = [
   );
 }
 
-// Test 11: empty key_files renders YAML placeholder, not empty array
+// Test 11: empty key_files renders an empty YAML list, not a sentinel path
 {
   const noFiles = { ...taskRow, key_files: [] };
   const output = renderSummaryContent(noFiles, SLICE_ID, MILESTONE_ID);
   assertTrue(
-    output.includes("key_files:\n  - (none)"),
-    "empty key_files must render as YAML list with (none) placeholder",
+    output.includes("key_files: []"),
+    "empty key_files must render as an empty YAML list",
+  );
+  assertTrue(
+    !output.includes("key_files:\n  - (none)"),
+    "empty key_files must not render (none) as a path-like list item",
   );
 }
 

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

@@ -22,7 +22,7 @@ import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { discoverCommands, runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, isLikelyCommand } from "../verification-gate.ts";
+import { discoverCommands, runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, isLikelyCommand, validateVerificationCommand } from "../verification-gate.ts";
 import type { CaptureRuntimeErrorsOptions, DependencyAuditOptions } from "../verification-gate.ts";
 import { validatePreferences } from "../preferences.ts";
 
@@ -215,6 +215,102 @@ describe("verification-gate: discovery", () => {
     assert.equal(result.source, "task-plan");
     assert.deepStrictEqual(result.commands, ["npm run test"]);
   });
+
+  test("taskPlanVerify rejects piped pytest command", () => {
+    const result = discoverCommands({
+      taskPlanVerify: "python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5",
+      cwd: tmp,
+    });
+    assert.equal(result.source, "none");
+    assert.deepStrictEqual(result.commands, []);
+  });
+
+  test("Python project with tests discovers pytest when package.json is absent", () => {
+    mkdirSync(join(tmp, "tests"));
+    writeFileSync(join(tmp, "tests", "test_sample.py"), "def test_sample():\n    assert True\n");
+    writeFileSync(
+      join(tmp, "pyproject.toml"),
+      `[project]
+name = "sample"
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+`,
+    );
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "python-project");
+    assert.deepStrictEqual(result.commands, ["python3 -m pytest"]);
+  });
+
+  test("Python project with nested Python test file discovers pytest", () => {
+    mkdirSync(join(tmp, "tests", "unit"), { recursive: true });
+    writeFileSync(join(tmp, "tests", "unit", "sample_test.py"), "def test_sample():\n    assert True\n");
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "python-project");
+    assert.deepStrictEqual(result.commands, ["python3 -m pytest"]);
+  });
+
+  test("Python project with pytest.ini discovers pytest", () => {
+    writeFileSync(join(tmp, "pytest.ini"), "[pytest]\npythonpath = .\n");
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "python-project");
+    assert.deepStrictEqual(result.commands, ["python3 -m pytest"]);
+  });
+
+  test("Python project with explicit pyproject pytest marker discovers pytest", () => {
+    writeFileSync(
+      join(tmp, "pyproject.toml"),
+      `[tool.pytest]
+pythonpath = ["."]
+`,
+    );
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "python-project");
+    assert.deepStrictEqual(result.commands, ["python3 -m pytest"]);
+  });
+
+  test("Python project markers without pytest evidence do not discover pytest", () => {
+    mkdirSync(join(tmp, "tests"));
+    writeFileSync(join(tmp, "tests", "README.md"), "# tests\n");
+    writeFileSync(
+      join(tmp, "pyproject.toml"),
+      `[project]
+name = "sample"
+dependencies = ["pytest-cov"]
+`,
+    );
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "none");
+    assert.deepStrictEqual(result.commands, []);
+  });
+
+  test("Python project with setup.cfg alone does not discover pytest", () => {
+    writeFileSync(join(tmp, "setup.cfg"), "[tool:pytest]\npythonpath = .\n");
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "none");
+    assert.deepStrictEqual(result.commands, []);
+  });
+
+  test("Python project with tox.ini alone does not discover pytest", () => {
+    writeFileSync(join(tmp, "tox.ini"), "[pytest]\npythonpath = .\n");
+
+    const result = discoverCommands({ cwd: tmp });
+
+    assert.equal(result.source, "none");
+    assert.deepStrictEqual(result.commands, []);
+  });
 });
 
 // ─── Execution Tests ─────────────────────────────────────────────────────────
@@ -445,6 +541,10 @@ test("isLikelyCommand: prose descriptions are rejected", () => {
   assert.equal(isLikelyCommand("Build succeeds without errors or warnings"), false);
 });
 
+test("isLikelyCommand: non-ASCII prose descriptions are rejected", () => {
+  assert.equal(isLikelyCommand("所有 命令 输出 一行 JSONL go test ./... 通过"), false);
+});
+
 test("isLikelyCommand: empty or whitespace-only strings are rejected", () => {
   assert.equal(isLikelyCommand(""), false);
   assert.equal(isLikelyCommand("   "), false);
@@ -455,6 +555,15 @@ test("isLikelyCommand: short lowercase tokens without flags are accepted (could
   assert.equal(isLikelyCommand("mycheck"), true);
 });
 
+test("validateVerificationCommand rejects shell control syntax", () => {
+  assert.deepEqual(validateVerificationCommand("python3 -m pytest tests/ -q --tb=short").ok, true);
+  const result = validateVerificationCommand("python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5");
+  assert.equal(result.ok, false);
+  if (!result.ok) {
+    assert.match(result.reason, /shell control syntax/);
+  }
+});
+
 // ─── Additional Preference Validation Tests (T02) ──────────────────────────
 
 test("verification-gate: verification_commands produces no unknown-key warnings", () => {

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

@@ -375,7 +375,7 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
               estimate: "10m",
               files: ["src/resources/extensions/gsd/workflow-mcp.ts"],
               verify: "node --test",
-              inputs: ["M001-ROADMAP.md"],
+              inputs: [".gsd/milestones/M001/M001-ROADMAP.md"],
               expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
             },
           ],

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

@@ -4,7 +4,10 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { measureMemoryPressure } from "../auto/workflow-memory-pressure.ts";
+import {
+  measureMemoryPressure,
+  shouldCheckMemoryPressure,
+} from "../auto/workflow-memory-pressure.ts";
 
 const mb = 1024 * 1024;
 
@@ -69,3 +72,20 @@ test("measureMemoryPressure falls back when heap limit cannot be read", () => {
     pct: 0.25,
   });
 });
+
+test("shouldCheckMemoryPressure covers the first auto-mode iteration", () => {
+  assert.equal(shouldCheckMemoryPressure(1, 5), true);
+  assert.equal(shouldCheckMemoryPressure(2, 5), false);
+  assert.equal(shouldCheckMemoryPressure(5, 5), true);
+});
+
+test("shouldCheckMemoryPressure rejects invalid intervals", () => {
+  assert.throws(
+    () => shouldCheckMemoryPressure(1, 0),
+    /positive integer/,
+  );
+  assert.throws(
+    () => shouldCheckMemoryPressure(1, 1.5),
+    /positive integer/,
+  );
+});

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

@@ -246,7 +246,7 @@ test("executePlanSlice writes task planning state and rendered plan artifacts",
           estimate: "15m",
           files: ["src/resources/extensions/gsd/tools/workflow-tool-executors.ts"],
           verify: "node --test",
-          inputs: ["ROADMAP.md"],
+          inputs: [".gsd/milestones/M001/M001-ROADMAP.md"],
           expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
         },
       ],

package/src/resources/extensions/gsd/tests/worktree-git-pathspec.test.ts

@@ -0,0 +1,39 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { _gitPathspecForWorktreePath } from "../auto-worktree.ts";
+
+function run(cmd: string, args: string[], cwd: string): string {
+  return execFileSync(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+describe("worktree git pathspec", () => {
+  test("skips external GSD bookkeeping directories outside the git work-tree", () => {
+    const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-pathspec-")));
+    const repo = join(root, "project");
+    const externalGsd = join(root, ".gsd", "projects", "abc123");
+
+    try {
+      mkdirSync(repo, { recursive: true });
+      mkdirSync(join(externalGsd, "milestones", "M002-wa00fm"), { recursive: true });
+      mkdirSync(join(externalGsd, "runtime", "units"), { recursive: true });
+      run("git", ["init"], repo);
+      writeFileSync(join(repo, "README.md"), "# test\n");
+
+      assert.equal(
+        _gitPathspecForWorktreePath(repo, join(externalGsd, "milestones", "M002-wa00fm")),
+        null,
+      );
+      assert.equal(
+        _gitPathspecForWorktreePath(repo, join(externalGsd, "runtime", "units")),
+        null,
+      );
+    } finally {
+      if (existsSync(root)) rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -158,6 +158,13 @@ test('planning-dispatch: allows subagent dispatch (delegated recon/planner durin
   assert.strictEqual(r.block, false);
 });
 
+test('planning-dispatch: allows markdown agent filenames after identity normalization', () => {
+  const agentClasses = extractSubagentAgentClasses({ agent: 'scout.md' });
+  assert.deepEqual(agentClasses, ['scout']);
+  const r = shouldBlockPlanningUnit('subagent', '', BASE, 'plan-slice', PLANNING_DISPATCH, agentClasses);
+  assert.strictEqual(r.block, false);
+});
+
 test('planning-dispatch: allows task dispatch (delegated recon/planner during slice planning)', () => {
   const r = shouldBlockPlanningUnit('task', '', BASE, 'plan-slice', PLANNING_DISPATCH, ['planner']);
   assert.strictEqual(r.block, false);

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

@@ -38,9 +38,9 @@ export interface CompleteMilestoneParams {
   definitionOfDoneResults?: string;
   /** @optional — empty/omitted renders as "Not provided." */
   requirementOutcomes?: string;
-  /** @optional — empty/omitted renders as "(none)" */
+  /** @optional — empty/omitted renders as an empty frontmatter list */
   keyDecisions?: string[];
-  /** @optional — empty/omitted renders as "(none)" */
+  /** @optional — empty/omitted renders as an empty frontmatter list */
   keyFiles?: string[];
   /** @optional — empty/omitted renders as "(none)" */
   lessonsLearned?: string[];
@@ -70,12 +70,12 @@ function renderMilestoneSummaryMarkdown(params: CompleteMilestoneParams, complet
   const lessonsLearned = params.lessonsLearned ?? [];
 
   const keyDecisionsYaml = keyDecisions.length > 0
-    ? keyDecisions.map(d => `  - ${d}`).join("\n")
-    : "  - (none)";
+    ? `\n${keyDecisions.map(d => `  - ${d}`).join("\n")}`
+    : " []";
 
   const keyFilesYaml = keyFiles.length > 0
-    ? keyFiles.map(f => `  - ${f}`).join("\n")
-    : "  - (none)";
+    ? `\n${keyFiles.map(f => `  - ${f}`).join("\n")}`
+    : " []";
 
   const lessonsYaml = lessonsLearned.length > 0
     ? lessonsLearned.map(l => `  - ${l}`).join("\n")
@@ -86,10 +86,8 @@ id: ${params.milestoneId}
 title: "${displayTitle}"
 status: complete
 completed_at: ${completedAt}
-key_decisions:
-${keyDecisionsYaml}
-key_files:
-${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
+key_files:${keyFilesYaml}
 lessons_learned:
 ${lessonsYaml}
 ---

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

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

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

@@ -1,6 +1,6 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
-import { isNonEmptyString, validateStringArray } from "../validation.js";
+import { isNonEmptyString, validateStringArray, validateTitle } from "../validation.js";
 import {
   transaction,
   getMilestone,
@@ -148,6 +148,8 @@ function validateSlices(value: unknown): PlanMilestoneSliceInput[] {
     if (seen.has(sliceId)) throw new Error(`slices[${index}].sliceId must be unique`);
     seen.add(sliceId);
     if (!isNonEmptyString(title)) throw new Error(`slices[${index}].title must be a non-empty string`);
+    const titleIssue = validateTitle(title);
+    if (titleIssue) throw new Error(`slices[${index}].title is invalid: ${titleIssue}`);
     if (!isNonEmptyString(risk)) throw new Error(`slices[${index}].risk must be a non-empty string`);
     if (!Array.isArray(depends) || depends.some((item) => !isNonEmptyString(item))) {
       throw new Error(`slices[${index}].depends must be an array of non-empty strings`);
@@ -190,6 +192,8 @@ function validateParams(params: PlanMilestoneParams): PlanMilestoneParams {
   if (!isNonEmptyString(params?.milestoneId)) throw new Error("milestoneId is required");
   if (!isNonEmptyString(params?.title)) throw new Error("title is required");
   if (!isNonEmptyString(params?.vision)) throw new Error("vision is required");
+  const milestoneTitleIssue = validateTitle(params.title);
+  if (milestoneTitleIssue) throw new Error(`title is invalid: ${milestoneTitleIssue}`);
 
   return {
     ...params,