gsd-pi 2.41.0 → 2.42.0-dev.1df898f

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

@@ -652,6 +652,116 @@ console.log('\n=== parsePlan: new-format task entries with Files and Verify subl
   assertTrue(p.tasks[0].description.includes('Why: because we need typed plan entries'), 'Why line accumulates into description');
 }
 
+console.log('\n=== parsePlan: heading-style task entries (### T01 -- Title) ===');
+{
+  const content = `# S11: Heading Style
+
+**Goal:** Test heading-style task parsing.
+**Demo:** Parser handles heading-style task entries.
+
+## Tasks
+
+### T01 -- Implement feature
+
+- Why: the feature is needed
+- Files: \`src/feature.ts\`
+- Verify: npm test
+
+### T02 -- Write tests \`est:1h\`
+
+Some description for the second task.
+`;
+
+  const p = parsePlan(content);
+  assertEq(p.tasks.length, 2, 'heading-style task count');
+  assertEq(p.tasks[0].id, 'T01', 'heading T01 id');
+  assertEq(p.tasks[0].title, 'Implement feature', 'heading T01 title');
+  assertEq(p.tasks[0].done, false, 'heading T01 not done (headings have no checkbox)');
+  assertEq(p.tasks[0].files![0], 'src/feature.ts', 'heading T01 files extracted');
+  assertEq(p.tasks[0].verify, 'npm test', 'heading T01 verify extracted');
+  assertEq(p.tasks[1].id, 'T02', 'heading T02 id');
+  assertEq(p.tasks[1].title, 'Write tests', 'heading T02 title');
+  assertEq(p.tasks[1].estimate, '1h', 'heading T02 estimate');
+  assertTrue(p.tasks[1].description.includes('Some description'), 'heading T02 description');
+}
+
+console.log('\n=== parsePlan: heading-style with colon separator (### T01: Title) ===');
+{
+  const content = `# S12: Heading Colon Style
+
+**Goal:** Test colon-separated heading tasks.
+**Demo:** Parser handles colon separator.
+
+## Tasks
+
+### T01: Setup project
+  Basic project setup steps.
+
+### T02: Add CI pipeline \`est:30m\`
+  Configure CI.
+`;
+
+  const p = parsePlan(content);
+  assertEq(p.tasks.length, 2, 'colon heading task count');
+  assertEq(p.tasks[0].id, 'T01', 'colon heading T01 id');
+  assertEq(p.tasks[0].title, 'Setup project', 'colon heading T01 title');
+  assertEq(p.tasks[1].id, 'T02', 'colon heading T02 id');
+  assertEq(p.tasks[1].title, 'Add CI pipeline', 'colon heading T02 title');
+  assertEq(p.tasks[1].estimate, '30m', 'colon heading T02 estimate');
+}
+
+console.log('\n=== parsePlan: heading-style with em-dash separator (### T01 — Title) ===');
+{
+  const content = `# S13: Em-Dash Style
+
+**Goal:** Test em-dash separated heading tasks.
+**Demo:** Parser handles em-dash separator.
+
+## Tasks
+
+### T01 — Build the widget
+
+Widget description.
+`;
+
+  const p = parsePlan(content);
+  assertEq(p.tasks.length, 1, 'em-dash heading task count');
+  assertEq(p.tasks[0].id, 'T01', 'em-dash heading T01 id');
+  assertEq(p.tasks[0].title, 'Build the widget', 'em-dash heading T01 title');
+}
+
+console.log('\n=== parsePlan: mixed checkbox and heading-style tasks ===');
+{
+  const content = `# S14: Mixed Format
+
+**Goal:** Test mixed formats.
+**Demo:** Parser handles both styles in one plan.
+
+## Tasks
+
+- [ ] **T01: Checkbox task** \`est:20m\`
+  A checkbox-style task.
+
+### T02 -- Heading task \`est:15m\`
+
+A heading-style task.
+
+- [x] **T03: Done checkbox task** \`est:10m\`
+  Already completed.
+`;
+
+  const p = parsePlan(content);
+  assertEq(p.tasks.length, 3, 'mixed format task count');
+  assertEq(p.tasks[0].id, 'T01', 'mixed T01 id');
+  assertEq(p.tasks[0].done, false, 'mixed T01 not done');
+  assertEq(p.tasks[1].id, 'T02', 'mixed T02 id');
+  assertEq(p.tasks[1].title, 'Heading task', 'mixed T02 title');
+  assertEq(p.tasks[1].estimate, '15m', 'mixed T02 estimate');
+  assertEq(p.tasks[1].done, false, 'mixed T02 not done (heading style)');
+  assertEq(p.tasks[2].id, 'T03', 'mixed T03 id');
+  assertEq(p.tasks[2].done, true, 'mixed T03 done');
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // parseSummary tests
 // ═══════════════════════════════════════════════════════════════════════════

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

@@ -249,19 +249,41 @@ test("all wizard fields together produce no errors", () => {
 
 // ── Hook config ──────────────────────────────────────────────────────────────
 
-test("post-unit hook max_cycles clamping", () => {
-  assert.equal(Math.max(1, Math.min(10, Math.round(15))), 10);
-  assert.equal(Math.max(1, Math.min(10, Math.round(0))), 1);
-  assert.equal(Math.max(1, Math.min(10, Math.round(-5))), 1);
-  assert.equal(Math.max(1, Math.min(10, Math.round(3))), 3);
+test("post-unit hook max_cycles clamping via validatePreferences", () => {
+  const base = { name: "h", after: ["execute-task"], prompt: "do something" };
+
+  const { preferences: p1 } = validatePreferences({ post_unit_hooks: [{ ...base, max_cycles: 15 }] } as any);
+  assert.equal(p1.post_unit_hooks![0].max_cycles, 10, "clamps to 10");
+
+  const { preferences: p2 } = validatePreferences({ post_unit_hooks: [{ ...base, max_cycles: 0 }] } as any);
+  assert.equal(p2.post_unit_hooks![0].max_cycles, 1, "clamps to 1");
+
+  const { preferences: p3 } = validatePreferences({ post_unit_hooks: [{ ...base, max_cycles: -5 }] } as any);
+  assert.equal(p3.post_unit_hooks![0].max_cycles, 1, "negative clamps to 1");
+
+  const { preferences: p4 } = validatePreferences({ post_unit_hooks: [{ ...base, max_cycles: 3 }] } as any);
+  assert.equal(p4.post_unit_hooks![0].max_cycles, 3, "valid value passes through");
 });
 
-test("pre-dispatch hook action validation", () => {
-  const valid = new Set(["modify", "skip", "replace"]);
-  assert.ok(valid.has("modify"));
-  assert.ok(valid.has("skip"));
-  assert.ok(valid.has("replace"));
-  assert.ok(!valid.has("delete"));
+test("pre-dispatch hook action validation via validatePreferences", () => {
+  const base = { name: "h", before: ["execute-task"] };
+
+  const { preferences, errors: e1 } = validatePreferences({
+    pre_dispatch_hooks: [{ ...base, action: "skip" }],
+  } as any);
+  assert.equal(e1.length, 0);
+  assert.equal(preferences.pre_dispatch_hooks![0].action, "skip");
+
+  const { preferences: p2, errors: e2 } = validatePreferences({
+    pre_dispatch_hooks: [{ ...base, action: "modify", prepend: "note: " }],
+  } as any);
+  assert.equal(e2.length, 0);
+  assert.equal(p2.pre_dispatch_hooks![0].action, "modify");
+
+  const { errors: e3 } = validatePreferences({
+    pre_dispatch_hooks: [{ ...base, action: "delete" }],
+  } as any);
+  assert.ok(e3.some(e => e.includes("invalid action")));
 });
 
 // ── Model config parsing ─────────────────────────────────────────────────────
@@ -269,8 +291,8 @@ test("pre-dispatch hook action validation", () => {
 test("parses OpenRouter model config with org/model IDs and fallbacks", () => {
   const content = `---\nversion: 1\nmodels:\n  research:\n    model: moonshotai/kimi-k2.5\n    fallbacks:\n      - qwen/qwen3.5-397b-a17b\n  planning:\n    model: deepseek/deepseek-r1-0528\n    fallbacks:\n      - moonshotai/kimi-k2.5\n      - deepseek/deepseek-v3.2\n  execution:\n    model: qwen/qwen3-coder\n    fallbacks:\n      - qwen/qwen3-coder-next\n---\n`;
   const prefs = parsePreferencesMarkdown(content);
-  assert.ok(prefs);
-  const models = prefs.models as GSDModelConfigV2;
+  assert.notEqual(prefs, null);
+  const models = prefs!.models as GSDModelConfigV2;
   const research = models.research as GSDPhaseModelConfig;
   assert.equal(research.model, "moonshotai/kimi-k2.5");
   assert.deepEqual(research.fallbacks, ["qwen/qwen3.5-397b-a17b"]);
@@ -281,8 +303,8 @@ test("parses OpenRouter model config with org/model IDs and fallbacks", () => {
 test("parses model IDs with colons (OpenRouter :free, :exacto)", () => {
   const content = `---\nmodels:\n  execution:\n    model: qwen/qwen3-coder\n    fallbacks:\n      - qwen/qwen3-coder:free\n      - qwen/qwen3-coder:exacto\n---\n`;
   const prefs = parsePreferencesMarkdown(content);
-  assert.ok(prefs);
-  const models = prefs.models as GSDModelConfigV2;
+  assert.notEqual(prefs, null);
+  const models = prefs!.models as GSDModelConfigV2;
   const execution = models.execution as GSDPhaseModelConfig;
   assert.deepEqual(execution.fallbacks, ["qwen/qwen3-coder:free", "qwen/qwen3-coder:exacto"]);
 });
@@ -290,8 +312,8 @@ test("parses model IDs with colons (OpenRouter :free, :exacto)", () => {
 test("parses legacy string-per-phase model config", () => {
   const content = `---\nmodels:\n  research: claude-opus-4-6\n  execution: claude-sonnet-4-6\n---\n`;
   const prefs = parsePreferencesMarkdown(content);
-  assert.ok(prefs);
-  const models = prefs.models as GSDModelConfigV2;
+  assert.notEqual(prefs, null);
+  const models = prefs!.models as GSDModelConfigV2;
   assert.equal(models.research, "claude-opus-4-6");
   assert.equal(models.execution, "claude-sonnet-4-6");
 });
@@ -299,8 +321,8 @@ test("parses legacy string-per-phase model config", () => {
 test("strips inline YAML comments from values", () => {
   const content = `---\nmodels:\n  execution:\n    model: qwen/qwen3-coder  # fast\n    fallbacks:\n      - minimax/minimax-m2.5  # backup\n---\n`;
   const prefs = parsePreferencesMarkdown(content);
-  assert.ok(prefs);
-  const models = prefs.models as GSDModelConfigV2;
+  assert.notEqual(prefs, null);
+  const models = prefs!.models as GSDModelConfigV2;
   const execution = models.execution as GSDPhaseModelConfig;
   assert.equal(execution.model, "qwen/qwen3-coder");
   assert.deepEqual(execution.fallbacks, ["minimax/minimax-m2.5"]);
@@ -309,8 +331,8 @@ test("strips inline YAML comments from values", () => {
 test("handles Windows CRLF line endings", () => {
   const content = "---\r\nmodels:\r\n  execution:\r\n    model: qwen/qwen3-coder\r\n---\r\n";
   const prefs = parsePreferencesMarkdown(content);
-  assert.ok(prefs);
-  const models = prefs.models as GSDModelConfigV2;
+  assert.notEqual(prefs, null);
+  const models = prefs!.models as GSDModelConfigV2;
   const execution = models.execution as GSDPhaseModelConfig;
   assert.equal(execution.model, "qwen/qwen3-coder");
 });
@@ -318,8 +340,8 @@ test("handles Windows CRLF line endings", () => {
 test("handles model config with explicit provider field", () => {
   const content = `---\nmodels:\n  execution:\n    model: claude-opus-4-6\n    provider: bedrock\n    fallbacks:\n      - claude-sonnet-4-6\n---\n`;
   const prefs = parsePreferencesMarkdown(content);
-  assert.ok(prefs);
-  const models = prefs.models as GSDModelConfigV2;
+  assert.notEqual(prefs, null);
+  const models = prefs!.models as GSDModelConfigV2;
   const execution = models.execution as GSDPhaseModelConfig;
   assert.equal(execution.model, "claude-opus-4-6");
   assert.equal(execution.provider, "bedrock");
@@ -327,6 +349,6 @@ test("handles model config with explicit provider field", () => {
 
 test("handles empty models config", () => {
   const prefs = parsePreferencesMarkdown("---\nversion: 1\n---\n");
-  assert.ok(prefs);
-  assert.equal(prefs.models, undefined);
+  assert.notEqual(prefs, null);
+  assert.equal(prefs!.models, undefined);
 });

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

@@ -43,6 +43,7 @@ console.log('\n=== prompt-db: scoped decisions from DB ===');
       choice: `choice ${i}`,
       rationale: `rationale ${i}`,
       revisable: 'yes',
+      made_by: 'agent',
       superseded_by: null,
     });
   }
@@ -201,6 +202,7 @@ console.log('\n=== prompt-db: scoped filtering reduces content ===');
       choice: `choice ${i}`,
       rationale: `rationale ${i} with additional context`,
       revisable: 'yes',
+      made_by: 'agent',
       superseded_by: null,
     });
   }
@@ -269,7 +271,7 @@ console.log('\n=== prompt-db: DB helpers wrapper format matches expected pattern
   insertDecision({
     id: 'D001', when_context: 'M001/S01', scope: 'architecture',
     decision: 'use SQLite', choice: 'better-sqlite3', rationale: 'fast',
-    revisable: 'yes', superseded_by: null,
+    revisable: 'yes', made_by: 'agent', superseded_by: null,
   });
 
   insertRequirement({

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { repoIdentity, externalGsdRoot, ensureGsdSymlink, validateProjectId, readRepoMeta } from "../repo-identity.ts";
+import { repoIdentity, externalGsdRoot, ensureGsdSymlink, validateProjectId, readRepoMeta, isInheritedRepo } from "../repo-identity.ts";
 import { createTestContext } from "./test-helpers.ts";
 
 const { assertEq, assertTrue, report } = createTestContext();
@@ -118,6 +118,66 @@ async function main(): Promise<void> {
       delete process.env.GSD_PROJECT_ID;
     }
 
+    console.log("\n=== isInheritedRepo detects subdirectory of parent repo without .gsd (#1639) ===");
+    {
+      const parentRepo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-inherited-parent-")));
+      run("git init -b main", parentRepo);
+      run('git config user.name "Pi Test"', parentRepo);
+      run('git config user.email "pi@example.com"', parentRepo);
+      writeFileSync(join(parentRepo, "README.md"), "# Parent\n", "utf-8");
+      run("git add README.md", parentRepo);
+      run('git commit -m "init"', parentRepo);
+
+      // Create a subdirectory — no .gsd at parent
+      const subdir = join(parentRepo, "newproject");
+      mkdirSync(subdir, { recursive: true });
+      assertTrue(isInheritedRepo(subdir), "subdirectory of parent repo without .gsd is inherited");
+
+      // After adding .gsd at parent, subdirectory is a legitimate child
+      mkdirSync(join(parentRepo, ".gsd"), { recursive: true });
+      assertTrue(!isInheritedRepo(subdir), "subdirectory of parent repo WITH .gsd is NOT inherited");
+
+      // The git root itself is never inherited
+      assertTrue(!isInheritedRepo(parentRepo), "git root is not inherited");
+
+      // A standalone repo (not a subdir) is not inherited
+      const standaloneRepo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-inherited-standalone-")));
+      run("git init -b main", standaloneRepo);
+      run('git config user.name "Pi Test"', standaloneRepo);
+      run('git config user.email "pi@example.com"', standaloneRepo);
+      assertTrue(!isInheritedRepo(standaloneRepo), "standalone repo is not inherited");
+
+      rmSync(parentRepo, { recursive: true, force: true });
+      rmSync(standaloneRepo, { recursive: true, force: true });
+    }
+
+    console.log("\n=== subdirectory of parent repo gets unique identity after git init (#1639) ===");
+    {
+      const parentRepo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-identity-parent-")));
+      run("git init -b main", parentRepo);
+      run('git config user.name "Pi Test"', parentRepo);
+      run('git config user.email "pi@example.com"', parentRepo);
+      run('git remote add origin git@github.com:example/parent-project.git', parentRepo);
+      writeFileSync(join(parentRepo, "README.md"), "# Parent\n", "utf-8");
+      run("git add README.md", parentRepo);
+      run('git commit -m "init"', parentRepo);
+
+      const subdir = join(parentRepo, "childproject");
+      mkdirSync(subdir, { recursive: true });
+
+      // Before git init, subdirectory shares parent's identity
+      const parentIdentity = repoIdentity(parentRepo);
+      const subdirIdentityBefore = repoIdentity(subdir);
+      assertEq(subdirIdentityBefore, parentIdentity, "subdirectory shares parent identity before its own git init");
+
+      // After git init, subdirectory gets its own identity
+      run("git init -b main", subdir);
+      const subdirIdentityAfter = repoIdentity(subdir);
+      assertTrue(subdirIdentityAfter !== parentIdentity, "subdirectory gets unique identity after git init");
+
+      rmSync(parentRepo, { recursive: true, force: true });
+    }
+
     console.log("\n=== validateProjectId rejects invalid values ===");
     for (const invalid of ["has spaces", "path/traversal", "dot..dot", "back\\slash"]) {
       assertTrue(!validateProjectId(invalid), `validateProjectId rejects invalid value: "${invalid}"`);

package/src/resources/extensions/gsd/tests/routing-history.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -37,12 +37,9 @@ test("recordOutcome tracks success and failure counts", () => {
     recordOutcome("execute-task", "standard", true);
     recordOutcome("execute-task", "standard", false);
 
-    const history = getRoutingHistory();
-    assert.ok(history);
-    const pattern = history.patterns["execute-task"];
-    assert.ok(pattern);
-    assert.equal(pattern.standard.success, 2);
-    assert.equal(pattern.standard.fail, 1);
+    const history = getRoutingHistory()!;
+    assert.equal(history.patterns["execute-task"].standard.success, 2);
+    assert.equal(history.patterns["execute-task"].standard.fail, 1);
   } finally {
     cleanup(dir);
   }
@@ -54,9 +51,7 @@ test("recordOutcome tracks tag-specific patterns", () => {
     initRoutingHistory(dir);
     recordOutcome("execute-task", "light", true, ["docs"]);
 
-    const history = getRoutingHistory();
-    assert.ok(history);
-    assert.ok(history.patterns["execute-task:docs"]);
+    const history = getRoutingHistory()!;
     assert.equal(history.patterns["execute-task:docs"].light.success, 1);
   } finally {
     cleanup(dir);
@@ -72,8 +67,7 @@ test("recordOutcome applies rolling window", () => {
       recordOutcome("execute-task", "standard", true);
     }
 
-    const history = getRoutingHistory();
-    assert.ok(history);
+    const history = getRoutingHistory()!;
     const total = history.patterns["execute-task"].standard.success +
                   history.patterns["execute-task"].standard.fail;
     assert.ok(total <= 50, `total ${total} should be <= 50`);
@@ -161,8 +155,7 @@ test("recordFeedback stores feedback entries", () => {
     initRoutingHistory(dir);
     recordFeedback("execute-task", "M001/S01/T01", "standard", "over");
 
-    const history = getRoutingHistory();
-    assert.ok(history);
+    const history = getRoutingHistory()!;
     assert.equal(history.feedback.length, 1);
     assert.equal(history.feedback[0].rating, "over");
     assert.equal(history.feedback[0].tier, "standard");
@@ -177,8 +170,7 @@ test("recordFeedback 'under' increases failure count at tier", () => {
     initRoutingHistory(dir);
     recordFeedback("execute-task", "M001/S01/T01", "light", "under");
 
-    const history = getRoutingHistory();
-    assert.ok(history);
+    const history = getRoutingHistory()!;
     // "under" adds 2 (FEEDBACK_WEIGHT) failures
     assert.equal(history.patterns["execute-task"].light.fail, 2);
   } finally {
@@ -192,8 +184,7 @@ test("recordFeedback 'over' increases success count at lower tier", () => {
     initRoutingHistory(dir);
     recordFeedback("execute-task", "M001/S01/T01", "standard", "over");
 
-    const history = getRoutingHistory();
-    assert.ok(history);
+    const history = getRoutingHistory()!;
     // "over" at standard → adds 2 successes at light
     assert.equal(history.patterns["execute-task"].light.success, 2);
   } finally {
@@ -210,8 +201,7 @@ test("clearRoutingHistory resets all data", () => {
     recordOutcome("execute-task", "light", true);
     clearRoutingHistory(dir);
 
-    const history = getRoutingHistory();
-    assert.ok(history);
+    const history = getRoutingHistory()!;
     assert.deepEqual(history.patterns, {});
     assert.deepEqual(history.feedback, []);
   } finally {
@@ -231,8 +221,7 @@ test("routing history persists to disk and reloads", () => {
 
     // Reload from disk
     initRoutingHistory(dir);
-    const history = getRoutingHistory();
-    assert.ok(history);
+    const history = getRoutingHistory()!;
     assert.equal(history.patterns["execute-task"].standard.success, 2);
   } finally {
     cleanup(dir);