gsd-pi 2.78.1-dev.b6a389b66 → 2.78.1-dev.d8826a445

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

@@ -0,0 +1,190 @@
+// GSD-2 + Workspace handle tests: createWorkspace and scopeMilestone
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  rmSync,
+  realpathSync,
+  symlinkSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { createWorkspace, scopeMilestone } from "../workspace.ts";
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function makeProjectDir(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-ws-test-")));
+  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+  return dir;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe("createWorkspace", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("from a project root produces mode=project and worktreeRoot=null", () => {
+    const ws = createWorkspace(projectDir);
+    assert.equal(ws.mode, "project");
+    assert.equal(ws.worktreeRoot, null);
+    assert.equal(ws.projectRoot, realpathSync(projectDir));
+  });
+
+  test("from a worktree path produces mode=worktree, worktreeRoot=realpath, projectRoot=realpath of project", () => {
+    // Construct a worktree path: <projectDir>/.gsd/worktrees/M001
+    const worktreePath = join(projectDir, ".gsd", "worktrees", "M001");
+    mkdirSync(worktreePath, { recursive: true });
+
+    const ws = createWorkspace(worktreePath);
+    assert.equal(ws.mode, "worktree");
+    assert.equal(ws.worktreeRoot, realpathSync(worktreePath));
+    assert.equal(ws.projectRoot, realpathSync(projectDir));
+  });
+
+  test("normalizes /foo and /foo/ to identical identityKey", () => {
+    const wsTrailing = createWorkspace(projectDir + "/");
+    const wsNoTrailing = createWorkspace(projectDir);
+    assert.equal(wsTrailing.identityKey, wsNoTrailing.identityKey);
+  });
+
+  test("follows symlinks — identityKey matches realpath of target", (t) => {
+    const linkPath = join(tmpdir(), `gsd-ws-link-${Date.now()}`);
+    symlinkSync(projectDir, linkPath);
+    t.after(() => {
+      try { rmSync(linkPath); } catch { /* ignore */ }
+    });
+
+    const ws = createWorkspace(linkPath);
+    assert.equal(ws.identityKey, realpathSync(projectDir));
+  });
+});
+
+describe("GsdWorkspace and MilestoneScope are frozen", () => {
+  let projectDir: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("workspace is frozen", () => {
+    const ws = createWorkspace(projectDir);
+    assert.ok(Object.isFrozen(ws), "workspace should be frozen");
+    assert.throws(() => {
+      (ws as { mode: string }).mode = "worktree";
+    }, /Cannot assign/);
+  });
+
+  test("scope is frozen", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, "M001");
+    assert.ok(Object.isFrozen(scope), "scope should be frozen");
+    assert.throws(() => {
+      (scope as { milestoneId: string }).milestoneId = "M999";
+    }, /Cannot assign/);
+  });
+
+  test("contract inside workspace is frozen", () => {
+    const ws = createWorkspace(projectDir);
+    assert.ok(Object.isFrozen(ws.contract), "contract should be frozen");
+  });
+});
+
+describe("scopeMilestone path methods", () => {
+  let projectDir: string;
+  const MID = "M001";
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+  });
+
+  afterEach(() => {
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("produces correct paths for a known milestone ID", () => {
+    const ws = createWorkspace(projectDir);
+    const scope = scopeMilestone(ws, MID);
+    const gsd = ws.contract.projectGsd;
+
+    assert.equal(scope.milestoneId, MID);
+    assert.equal(scope.contextFile(), join(gsd, "milestones", MID, `${MID}-CONTEXT.md`));
+    assert.equal(scope.roadmapFile(), join(gsd, "milestones", MID, `${MID}-ROADMAP.md`));
+    assert.equal(scope.stateFile(), join(gsd, "STATE.md"));
+    assert.equal(scope.dbPath(), ws.contract.projectDb);
+    assert.equal(scope.milestoneDir(), join(gsd, "milestones", MID));
+    assert.equal(scope.metaJson(), join(gsd, `${MID}-META.json`));
+  });
+
+  test("two scopes from same workspace + same MID produce identical paths", () => {
+    const ws = createWorkspace(projectDir);
+    const scope1 = scopeMilestone(ws, MID);
+    const scope2 = scopeMilestone(ws, MID);
+
+    assert.equal(scope1.contextFile(), scope2.contextFile());
+    assert.equal(scope1.roadmapFile(), scope2.roadmapFile());
+    assert.equal(scope1.stateFile(), scope2.stateFile());
+    assert.equal(scope1.dbPath(), scope2.dbPath());
+    assert.equal(scope1.milestoneDir(), scope2.milestoneDir());
+    assert.equal(scope1.metaJson(), scope2.metaJson());
+  });
+});
+
+describe("createWorkspace: contract.projectGsd is realpath-canonicalized when basePath is a symlink", () => {
+  let projectDir: string;
+  let linkPath: string;
+
+  beforeEach(() => {
+    projectDir = makeProjectDir();
+    linkPath = join(tmpdir(), `gsd-ws-symlink-${Date.now()}`);
+    symlinkSync(projectDir, linkPath);
+  });
+
+  afterEach(() => {
+    try { rmSync(linkPath); } catch { /* ignore */ }
+    rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test("contract.projectGsd matches realpath of projectRoot when workspace is created via symlink", () => {
+    const ws = createWorkspace(linkPath);
+
+    const canonicalProjectRoot = realpathSync(projectDir);
+
+    // identityKey must be the realpath of the canonical project root
+    assert.equal(ws.identityKey, canonicalProjectRoot);
+    assert.equal(ws.projectRoot, canonicalProjectRoot);
+
+    // contract.projectGsd must start with the canonical project root —
+    // not with the symlink path. If the bug is present, contract.projectGsd
+    // would be linkPath + "/.gsd" instead of canonicalProjectRoot + "/.gsd".
+    assert.ok(
+      ws.contract.projectGsd.startsWith(canonicalProjectRoot),
+      `contract.projectGsd ("${ws.contract.projectGsd}") must be under the realpath'd projectRoot ("${canonicalProjectRoot}"), not the symlink path`,
+    );
+  });
+
+  test("contract.projectDb matches realpath of projectRoot when workspace is created via symlink", () => {
+    const ws = createWorkspace(linkPath);
+    const canonicalProjectRoot = realpathSync(projectDir);
+
+    assert.ok(
+      ws.contract.projectDb.startsWith(canonicalProjectRoot),
+      `contract.projectDb ("${ws.contract.projectDb}") must be under the realpath'd projectRoot ("${canonicalProjectRoot}")`,
+    );
+  });
+});

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

@@ -24,38 +24,38 @@ import {
 // ─── shouldBlockQueueExecution ────────────────────────────────────────────
 
 test('shouldBlockQueueExecution: queue inactive → allow write to user source', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setQueuePhaseActive(false);
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setQueuePhaseActive(false, process.cwd());
   const r = shouldBlockQueueExecution('write', 'src/main.ts', false);
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockQueueExecution: queue active → block write to user source', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setQueuePhaseActive(true);
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setQueuePhaseActive(true, process.cwd());
   const r = shouldBlockQueueExecution('write', 'src/main.ts', true);
   assert.strictEqual(r.block, true);
   assert.ok(r.reason);
 });
 
 test('shouldBlockQueueExecution: queue active → allow write to .gsd/ path', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setQueuePhaseActive(true);
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setQueuePhaseActive(true, process.cwd());
   const r = shouldBlockQueueExecution('write', '.gsd/milestones/M001/M001-CONTEXT.md', true);
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockQueueExecution: queue active → block mutating bash', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setQueuePhaseActive(true);
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setQueuePhaseActive(true, process.cwd());
   const r = shouldBlockQueueExecution('bash', 'npm run build', true);
   assert.strictEqual(r.block, true);
   assert.ok(r.reason);
 });
 
 test('shouldBlockQueueExecution: queue active → allow read-only bash', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setQueuePhaseActive(true);
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setQueuePhaseActive(true, process.cwd());
   const r = shouldBlockQueueExecution('bash', 'git log --oneline -5', true);
   assert.strictEqual(r.block, false);
 });
@@ -63,30 +63,30 @@ test('shouldBlockQueueExecution: queue active → allow read-only bash', (t) =>
 // ─── shouldBlockPendingGate ───────────────────────────────────────────────
 
 test('shouldBlockPendingGate: no pending gate → allow any tool', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  clearPendingGate();
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  clearPendingGate(process.cwd());
   const r = shouldBlockPendingGate('write', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockPendingGate: pending gate → block write', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGate('write', 'M001');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason?.includes('depth_verification_M001'));
 });
 
 test('shouldBlockPendingGate: pending gate → allow ask_user_questions', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGate('ask_user_questions', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockPendingGate: pending gate → block read so approval question stays visible', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGate('read', 'M001');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason?.includes('already asked for user confirmation'));
@@ -95,31 +95,31 @@ test('shouldBlockPendingGate: pending gate → block read so approval question s
 // ─── shouldBlockPendingGateBash ───────────────────────────────────────────
 
 test('shouldBlockPendingGateBash: no pending gate → allow mutating bash', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  clearPendingGate();
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  clearPendingGate(process.cwd());
   const r = shouldBlockPendingGateBash('npm run build', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockPendingGateBash: pending gate → block mutating bash', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGateBash('npm run build', 'M001');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason?.includes('depth_verification_M001'));
 });
 
 test('shouldBlockPendingGateBash: pending gate → block read-only bash (cat)', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGateBash('cat README.md', 'M001');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason?.includes('already asked for user confirmation'));
 });
 
 test('shouldBlockPendingGateBash: pending gate → block read-only bash (git log)', (t) => {
-  t.after(() => clearDiscussionFlowState());
-  setPendingGate('depth_verification_M001');
+  t.after(() => clearDiscussionFlowState(process.cwd()));
+  setPendingGate('depth_verification_M001', process.cwd());
   const r = shouldBlockPendingGateBash('git log --oneline -10', 'M001');
   assert.strictEqual(r.block, true);
 });
@@ -127,26 +127,26 @@ test('shouldBlockPendingGateBash: pending gate → block read-only bash (git log
 // ─── shouldBlockContextWrite ──────────────────────────────────────────────
 
 test('shouldBlockContextWrite: non-write tool → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextWrite('read', '.gsd/milestones/M001/M001-CONTEXT.md', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockContextWrite: write to non-CONTEXT file → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextWrite('write', 'src/index.ts', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockContextWrite: write to CONTEXT.md without verification → block', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextWrite('write', '.gsd/milestones/M007/M007-CONTEXT.md', 'M007');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason);
 });
 
 test('shouldBlockContextWrite: write to CONTEXT.md after verification → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   markDepthVerified('M008');
   const r = shouldBlockContextWrite('write', '.gsd/milestones/M008/M008-CONTEXT.md', 'M008');
   assert.strictEqual(r.block, false);
@@ -155,33 +155,33 @@ test('shouldBlockContextWrite: write to CONTEXT.md after verification → allow'
 // ─── shouldBlockContextArtifactSave ───────────────────────────────────────
 
 test('shouldBlockContextArtifactSave: non-CONTEXT artifact type → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextArtifactSave('CONTEXT-DRAFT', 'M001');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockContextArtifactSave: slice-level CONTEXT → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextArtifactSave('CONTEXT', 'M001', 'S01');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockContextArtifactSave: milestone CONTEXT without verification → block', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextArtifactSave('CONTEXT', 'M009');
   assert.strictEqual(r.block, true);
   assert.ok(r.reason?.includes('M009'));
 });
 
 test('shouldBlockContextArtifactSave: milestone CONTEXT after verification → allow', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   markDepthVerified('M010');
   const r = shouldBlockContextArtifactSave('CONTEXT', 'M010');
   assert.strictEqual(r.block, false);
 });
 
 test('shouldBlockContextArtifactSave: CONTEXT with no milestoneId → block', (t) => {
-  t.after(() => clearDiscussionFlowState());
+  t.after(() => clearDiscussionFlowState(process.cwd()));
   const r = shouldBlockContextArtifactSave('CONTEXT', null);
   assert.strictEqual(r.block, true);
   assert.ok(r.reason);