@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.4fb2d460

package/src/resources/extensions/gsd/tests/milestone-merge-transaction.test.ts

@@ -5,6 +5,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 
 import {
+  createDefaultMilestoneMergeTransaction,
   createMilestoneMergeTransaction,
   runMilestoneMergeTransaction,
 } from "../milestone-merge-transaction.js";
@@ -13,7 +14,7 @@ test("runMilestoneMergeTransaction delegates to the supplied merge runner", () =
   const calls: unknown[][] = [];
   const result = runMilestoneMergeTransaction(
     {
-      mergeMilestoneToMain: (basePath, milestoneId, roadmapContent) => {
+      mergeMilestone: (basePath, milestoneId, roadmapContent) => {
         calls.push([basePath, milestoneId, roadmapContent]);
         return { pushed: true, codeFilesChanged: true, commitMessage: "merge M001" };
       },
@@ -44,3 +45,26 @@ test("createMilestoneMergeTransaction returns a lifecycle-compatible runner", ()
     codeFilesChanged: false,
   });
 });
+
+test("createDefaultMilestoneMergeTransaction hides the legacy merge adapter behind the transaction seam", () => {
+  const calls: unknown[][] = [];
+  const runner = createDefaultMilestoneMergeTransaction(
+    (basePath, milestoneId, roadmapContent) => {
+      calls.push([basePath, milestoneId, roadmapContent]);
+      return {
+        pushed: false,
+        codeFilesChanged: true,
+        commitMessage: "merge M003",
+        prCreated: false,
+      };
+    },
+  );
+
+  assert.deepEqual(runner("/repo", "M003", "# M003"), {
+    pushed: false,
+    codeFilesChanged: true,
+    commitMessage: "merge M003",
+    prCreated: false,
+  });
+  assert.deepEqual(calls, [["/repo", "M003", "# M003"]]);
+});

package/src/resources/extensions/gsd/tests/none-mode-gates.test.ts

@@ -18,7 +18,7 @@ import { execFileSync } from "node:child_process";
 
 import { shouldUseWorktreeIsolation } from "../auto.ts";
 import { getIsolationMode } from "../preferences.ts";
-import { getActiveAutoWorktreeContext } from "../auto-worktree.ts";
+import { getActiveAutoWorktreeContext } from "../auto-worktree-session-registry.ts";
 import { invalidateAllCaches } from "../cache.ts";
 import { describe, test, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';

package/src/resources/extensions/gsd/tests/originalbase-path-comparison.test.ts

@@ -26,12 +26,12 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
+import { createAutoWorktree } from "../auto-worktree-creation.ts";
 import {
   getAutoWorktreeOriginalBase,
   _resetAutoWorktreeOriginalBaseForTests,
-  createAutoWorktree,
-  teardownAutoWorktree,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-session-registry.ts";
+import { teardownAutoWorktree } from "../auto-worktree-teardown.ts";
 import { normalizeWorktreePathForCompare } from "../worktree-root.ts";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/parallel-worker-lock-contention.test.ts

@@ -32,7 +32,7 @@ import { gsdRoot } from "../paths.ts";
 import {
   syncProjectRootToWorktree,
   syncStateToProjectRoot,
-} from "../auto-worktree.ts";
+} from "../auto-worktree-sync.ts";
 import { writeLock, readCrashLock, clearLock } from "../crash-recovery.ts";
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";

package/src/resources/extensions/gsd/tests/pending-autostart-scope.test.ts

@@ -55,8 +55,8 @@ describe("pendingAutoStart scope pinning (C1)", () => {
     assert.ok(entry.scope, "entry.scope should be set");
     assert.equal(entry.scope.milestoneId, "M001");
 
-    const expectedContext = join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md");
-    const expectedRoadmap = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const expectedContext = join(base, ".gsd", "phases", "01-m001", "01-CONTEXT.md");
+    const expectedRoadmap = join(base, ".gsd", "phases", "01-m001", "01-ROADMAP.md");
     const expectedState = join(base, ".gsd", "STATE.md");
 
     assert.equal(entry.scope.contextFile(), expectedContext);

package/src/resources/extensions/gsd/tests/phases-merge-error-stops-auto.test.ts

@@ -82,13 +82,57 @@ const ic = {
       return { ok: true, needsManualRecovery: false };
     },
     lifecycle: {
-      exitMilestone() {
+      // Mirror WorktreeLifecycle.exitMilestone's guarded-merge branch
+      // (preflight -> inner merge -> postflight). Since #1169 the closeout
+      // routes the guard through the lifecycle verb, so a non-conflict inner
+      // failure ("teardown-failed") is mapped to "merge-failed" here rather
+      // than by the caller.
+      exitMilestone(
+        milestoneId: string,
+        exitOpts: {
+          merge: boolean;
+          guardedMerge?: {
+            projectRoot: string;
+            preflightCleanRoot: (
+              basePath: string,
+              milestoneId: string,
+              notify: (message: string, level: "info" | "warning" | "error") => void,
+            ) => { blocked?: boolean; blockedReason?: string; stashPushed: boolean; stashMarker?: string };
+            postflightPopStash: (
+              basePath: string,
+              milestoneId: string,
+              stashMarker: string | undefined,
+              notify: (message: string, level: "info" | "warning" | "error") => void,
+            ) => { needsManualRecovery?: boolean };
+          };
+        },
+        exitCtx?: { notify: (message: string, level: "info" | "warning" | "error") => void },
+      ) {
+        const notify = exitCtx?.notify ?? (() => {});
+        const guarded = exitOpts.guardedMerge;
+        if (exitOpts.merge && guarded) {
+          const preflight = guarded.preflightCleanRoot(guarded.projectRoot, milestoneId, notify);
+          if (preflight.blocked) {
+            return {
+              ok: false,
+              reason: preflight.blockedReason?.startsWith("unmerged-conflicts")
+                ? "preflight-unmerged-conflicts"
+                : "preflight-dirty-overlap",
+            };
+          }
+          // Inner merge fails with a non-conflict error. The lifecycle still
+          // runs postflight stash restore on the failed-merge path, then maps
+          // the non-conflict failure to "merge-failed" (a MergeConflictError
+          // would instead map to "merge-conflict").
+          calls.push("merge");
+          const cause = new Error("remote rejected push");
+          if (preflight.stashPushed) {
+            guarded.postflightPopStash(guarded.projectRoot, milestoneId, preflight.stashMarker, notify);
+          }
+          return { ok: false, reason: "merge-failed", cause };
+        }
         calls.push("merge");
-        return {
-          ok: false,
-          reason: "teardown-failed",
-          cause: new Error("remote rejected push"),
-        };
+        return { ok: false, reason: "teardown-failed", cause: new Error("remote rejected push") };
       },
     },
     async stopAuto(_ctx: unknown, _pi: unknown, reason?: string) {

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

@@ -34,6 +34,7 @@ const BASE_VARS = {
   planTemplatePath: "C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\plan.md",
   taskPlanTemplatePath: "C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-plan.md",
   skillActivation: "Load the relevant skills.",
+  repoRegistry: "",
 };
 
 const DEFAULT_SKILL_ACTIVATION = "If a `GSD Skill Preferences` block is present in system context, use it and the `<available_skills>` catalog in your system prompt to decide which skills to load and follow for this unit, without relaxing required verification or artifact rules.";
@@ -61,6 +62,22 @@ test("plan-slice prompt: all variables substituted", () => {
   assert.ok(result.includes("S01"));
 });
 
+test("plan-slice prompt: repoRegistry block surfaces declared repositories when non-empty", () => {
+  const block = "### Declared Repositories\n\n- `frontend` (frontend/)\n- `backend` (backend/)\n\nAssign each task's `targetRepositories`";
+  const result = loadPrompt("plan-slice", { ...BASE_VARS, repoRegistry: block, commitInstruction: "Do not commit." });
+  assert.ok(result.includes("### Declared Repositories"), "declared repositories block should appear when provided");
+  assert.ok(result.includes("`frontend`"), "declared repo ids should be visible to the planner");
+  assert.ok(result.includes("targetRepositories"), "repo-assignment guidance should appear");
+});
+
+test("plan-slice prompt: empty repoRegistry leaves no orphan marker", () => {
+  const result = loadPrompt("plan-slice", { ...BASE_VARS, repoRegistry: "", commitInstruction: "Do not commit." });
+  assert.ok(!result.includes("{{repoRegistry}}"), "the repoRegistry placeholder must be substituted");
+  // The block heading only renders when repoRegistry is non-empty; the rule-9
+  // guidance text mentions "Declared Repositories" but is not a rendered block.
+  assert.ok(!result.includes("### Declared Repositories"), "single-repo prompts must not show a declared-repositories block");
+});
+
 test("plan-slice prompt: DB-backed tool names survive template substitution", () => {
   const result = loadPrompt("plan-slice", { ...BASE_VARS, commitInstruction: "Do not commit." });
   assert.ok(result.includes("gsd_plan_slice"), "gsd_plan_slice should appear in rendered prompt");

package/src/resources/extensions/gsd/tests/plan-task.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getSlice, getTask, getGateResults } from '../gsd-db.ts';
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getSlice, getTask, getSliceTasks, getGateResults } from '../gsd-db.ts';
 import { handlePlanTask } from '../tools/plan-task.ts';
 import { parseTaskPlanFile } from '../files.ts';
 
@@ -24,6 +24,26 @@ function seedParent(): void {
   insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.' });
 }
 
+function writeParentWorkspacePreferences(base: string): void {
+  mkdirSync(join(base, 'frontend', 'src'), { recursive: true });
+  mkdirSync(join(base, 'backend', 'src'), { recursive: true });
+  writeFileSync(
+    join(base, '.gsd', 'PREFERENCES.md'),
+    [
+      '---',
+      'workspace:',
+      '  mode: parent',
+      '  repositories:',
+      '    frontend:',
+      '      path: frontend',
+      '    backend:',
+      '      path: backend',
+      '---',
+    ].join('\n'),
+    'utf-8',
+  );
+}
+
 function validParams() {
   return {
     milestoneId: 'M001',
@@ -155,6 +175,32 @@ test('handlePlanTask rejects absolute task IO paths outside the active worktree'
   }
 });
 
+test('handlePlanTask rejects parent-checkout task IO paths from an active worktree', async () => {
+  const projectRoot = mkdtempSync(join(tmpdir(), 'gsd-plan-task-project-'));
+  const worktree = join(projectRoot, '.gsd', 'worktrees', 'M001');
+  mkdirSync(join(projectRoot, '.gsd'), { recursive: true });
+  mkdirSync(join(worktree, '.gsd', 'phases', '01-test'), { recursive: true });
+  openDatabase(join(projectRoot, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const parentCheckoutPath = join(projectRoot, 'src', 'index.ts');
+    const result = await handlePlanTask({
+      ...validParams(),
+      files: [parentCheckoutPath],
+      inputs: [parentCheckoutPath],
+      expectedOutput: [parentCheckoutPath],
+    }, worktree);
+
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: files contains path outside allowed repository roots/);
+    assert.match(result.error, new RegExp(worktree.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'parent-checkout paths must not persist worktree task planning');
+  } finally {
+    cleanup(projectRoot);
+  }
+});
+
 test('handlePlanTask rejects missing parent slice', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -243,3 +289,220 @@ test('handlePlanTask reruns idempotently and refreshes parse-visible state', asy
     cleanup(base);
   }
 });
+
+test('handlePlanTask persists targetRepositories for parent-workspace tasks', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      targetRepositories: ['project'],
+    }, base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    const tasks = getSliceTasks('M001', 'S02');
+    const planned = tasks.find((t) => t.id === 'T02');
+    assert.ok(planned, 'planned task should exist');
+    assert.deepEqual(planned?.target_repositories, ['project']);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask rejects non-array targetRepositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      targetRepositories: 'frontend' as unknown as string[],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: targetRepositories/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask rejects empty targetRepositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      targetRepositories: [],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: targetRepositories must include at least one repository id when provided/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'invalid target repositories must not persist');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask rejects unknown target repositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    const result = await handlePlanTask({
+      ...validParams(),
+      targetRepositories: ['frontend'],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: unknown targetRepositories:/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'unknown target repositories must not persist');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask enforces path scope to declared target repositories', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    mkdirSync(join(base, 'frontend', 'src'), { recursive: true });
+    mkdirSync(join(base, 'backend', 'src'), { recursive: true });
+    writeFileSync(
+      join(base, '.gsd', 'PREFERENCES.md'),
+      [
+        '---',
+        'workspace:',
+        '  mode: parent',
+        '  repositories:',
+        '    frontend:',
+        '      path: frontend',
+        '    backend:',
+        '      path: backend',
+        '---',
+      ].join('\n'),
+      'utf-8',
+    );
+
+    const result = await handlePlanTask({
+      ...validParams(),
+      targetRepositories: ['frontend'],
+      files: [join(base, 'backend', 'src', 'server.ts')],
+      inputs: ['app.js'],
+      expectedOutput: ['app.js'],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: files contains path outside allowed repository roots/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'invalid scoped paths must not persist');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask inherits parent slice target repositories for path scope', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    insertSlice({
+      id: 'S02',
+      milestoneId: 'M001',
+      planning: { targetRepositories: ['frontend'] },
+    });
+    writeParentWorkspacePreferences(base);
+
+    const result = await handlePlanTask({
+      ...validParams(),
+      files: [join(base, 'backend', 'src', 'server.ts')],
+      inputs: ['app.js'],
+      expectedOutput: ['app.js'],
+    }, base);
+    assert.ok('error' in result);
+    assert.match(result.error, /validation failed: files contains path outside allowed repository roots/);
+    assert.equal(getTask('M001', 'S02', 'T02'), null, 'slice-scoped invalid paths must not persist');
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask preserves stored task target repositories when omitted replan needs them for path scope', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    writeParentWorkspacePreferences(base);
+    insertSlice({
+      id: 'S02',
+      milestoneId: 'M001',
+      planning: { targetRepositories: ['frontend'] },
+    });
+    insertTask({
+      id: 'T02',
+      sliceId: 'S02',
+      milestoneId: 'M001',
+      title: 'Parent root work',
+      status: 'pending',
+      planning: { targetRepositories: ['project'] },
+    });
+
+    const rootFile = join(base, 'root-config.json');
+    const result = await handlePlanTask({
+      ...validParams(),
+      files: [rootFile],
+      inputs: [rootFile],
+      expectedOutput: [rootFile],
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.deepEqual(getTask('M001', 'S02', 'T02')?.target_repositories, ['project']);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('handlePlanTask follows the current slice target default when omitted replan paths validate there', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    seedParent();
+    writeParentWorkspacePreferences(base);
+    insertSlice({
+      id: 'S02',
+      milestoneId: 'M001',
+      planning: { targetRepositories: ['frontend'] },
+    });
+    insertTask({
+      id: 'T02',
+      sliceId: 'S02',
+      milestoneId: 'M001',
+      title: 'Child repo work',
+      status: 'pending',
+      planning: { targetRepositories: ['frontend'] },
+    });
+    insertSlice({
+      id: 'S02',
+      milestoneId: 'M001',
+      planning: { targetRepositories: ['backend'] },
+    });
+
+    const backendFile = join(base, 'backend', 'src', 'server.ts');
+    const result = await handlePlanTask({
+      ...validParams(),
+      files: [backendFile],
+      inputs: [backendFile],
+      expectedOutput: [backendFile],
+    }, base);
+
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+    assert.deepEqual(getTask('M001', 'S02', 'T02')?.target_repositories, ['backend']);
+  } finally {
+    cleanup(base);
+  }
+});

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

@@ -12,7 +12,7 @@ import assert from "node:assert/strict";
 import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { syncWorktreeStateBack } from "../auto-worktree.ts";
+import { syncGsdStateToWorktree, syncWorktreeStateBack } from "../auto-worktree-sync.ts";
 
 test("#2684: syncWorktreeStateBack does not overwrite project PREFERENCES.md", () => {
   const mainBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-main-"));
@@ -58,8 +58,6 @@ test("syncGsdStateToWorktree copies canonical PREFERENCES.md", async () => {
       "---\nversion: 1\n---\n\npost_unit_hooks:\n  - name: notify\n    command: echo done\n",
     );
 
-    // Import and call syncGsdStateToWorktree
-    const { syncGsdStateToWorktree } = await import("../auto-worktree.ts");
     syncGsdStateToWorktree(srcBase, dstBase);
 
     // Verify PREFERENCES.md was copied
@@ -93,7 +91,6 @@ test("syncGsdStateToWorktree falls back to legacy lowercase preferences.md", asy
       "---\nversion: 1\n---\n\ngit:\n  auto_push: true\n",
     );
 
-    const { syncGsdStateToWorktree } = await import("../auto-worktree.ts");
     const result = syncGsdStateToWorktree(srcBase, dstBase);
 
     const copiedEntries = readdirSync(dstGsd)