@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/tests/reassess-handler.test.ts

@@ -19,9 +19,9 @@ import { handleReassessRoadmap } from '../tools/reassess-roadmap.ts';
 
 function makeTmpBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-reassess-'));
-  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01'), { recursive: true });
-  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02'), { recursive: true });
-  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S03'), { recursive: true });
+  mkdirSync(join(base, '.gsd', 'phases', '01-test'), { recursive: true });
+  mkdirSync(join(base, '.gsd', 'phases', '01-test'), { recursive: true });
+  mkdirSync(join(base, '.gsd', 'phases', '01-test', 'slices', 'S03'), { recursive: true });
   return base;
 }
 
@@ -162,7 +162,7 @@ test('handleReassessRoadmap succeeds when modifying only pending slices', async
     assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
 
     // Verify assessments row exists in DB
-    const assessmentPath = join('.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-ASSESSMENT.md');
+    const assessmentPath = join('.gsd', 'phases', '01-test', '01-01-ASSESSMENT.md');
     const assessment = getAssessment(assessmentPath);
     assert.ok(assessment, 'assessment row should exist in DB');
     assert.equal(assessment['milestone_id'], 'M001');
@@ -193,13 +193,14 @@ test('handleReassessRoadmap succeeds when modifying only pending slices', async
     assert.equal(s01?.status, 'complete');
 
     // Verify ROADMAP.md re-rendered on disk
-    const roadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+    // Flat-phase renderer writes NN-ROADMAP.md (01-ROADMAP.md for M001)
+    const roadmapPath = join(base, '.gsd', 'phases', '01-test', '01-ROADMAP.md');
     assert.ok(existsSync(roadmapPath), 'ROADMAP.md should be rendered to disk');
     const roadmapContent = readFileSync(roadmapPath, 'utf-8');
     assert.ok(roadmapContent.includes('Updated Slice Two'), 'ROADMAP.md should contain updated S02 title');
 
     // Verify ASSESSMENT.md exists on disk
-    const assessmentDiskPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-ASSESSMENT.md');
+    const assessmentDiskPath = join(base, '.gsd', 'phases', '01-test', '01-01-ASSESSMENT.md');
     assert.ok(existsSync(assessmentDiskPath), 'ASSESSMENT.md should be rendered to disk');
     const assessmentContent = readFileSync(assessmentDiskPath, 'utf-8');
     assert.ok(assessmentContent.includes('confirmed'), 'ASSESSMENT.md should contain verdict');
@@ -340,7 +341,7 @@ test('handleReassessRoadmap invalidates stale milestone-validation when roadmap
     insertSlice({ id: 'S04', milestoneId: 'M001', title: 'Slice Four', status: 'complete', demo: 'Demo' });
 
     // Insert milestone-validation assessment with needs-remediation verdict (stale)
-    const validationPath = join('.gsd', 'milestones', 'M001', 'M001-VALIDATION.md');
+    const validationPath = join('.gsd', 'phases', '01-test', 'M001-VALIDATION.md');
     insertAssessment({
       path: validationPath,
       milestoneId: 'M001',
@@ -404,7 +405,7 @@ test('handleReassessRoadmap does NOT invalidate validation when no roadmap struc
     insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Slice Two', status: 'pending', demo: 'Demo' });
 
     // Insert milestone-validation assessment with pass verdict
-    const validationPath = join('.gsd', 'milestones', 'M001', 'M001-VALIDATION.md');
+    const validationPath = join('.gsd', 'phases', '01-test', 'M001-VALIDATION.md');
     insertAssessment({
       path: validationPath,
       milestoneId: 'M001',

package/src/resources/extensions/gsd/tests/recovery-verify-logs.test.ts

@@ -227,7 +227,7 @@ test("plan-slice verify-fail logs a recovery warning when the tasks dir is missi
   }
 });
 
-test("plan-slice verify-fail logs a recovery warning when an individual task plan file is missing", () => {
+test("plan-slice verify-fail logs a recovery warning when an individual task artifact is missing", () => {
   const base = createFixtureBase("gsd-recovery-logs-taskplan-");
   try {
     const dir = sliceDir(base, "M001", "S01");
@@ -236,17 +236,17 @@ test("plan-slice verify-fail logs a recovery warning when an individual task pla
       "# S01: Has task\n\n## Tasks\n\n- [ ] **T01: A** `est:15m`\n",
       "utf-8",
     );
-    // Create the tasks dir but NOT the T01-PLAN.md file inside it.
+    // Create the tasks dir but NOT any T01 task artifact inside it.
     mkdirSync(join(dir, "tasks"), { recursive: true });
 
     const { result, logs } = verifyAndCaptureLogs("plan-slice", "M001/S01", base);
 
-    assert.equal(result, false, "a missing task plan file must fail verification");
+    assert.equal(result, false, "a missing task artifact must fail verification");
     const recovery = findRecovery(logs);
     assert.ok(recovery, "a recovery warning must be logged");
     assert.match(
       recovery!.message,
-      /verify-fail plan-slice M001\/S01: task plan missing .*T01-PLAN\.md/u,
+      /verify-fail plan-slice M001\/S01: task artifact missing for T01/u,
     );
   } finally {
     rmSync(base, { recursive: true, force: true });

package/src/resources/extensions/gsd/tests/redact-secrets.test.ts

@@ -0,0 +1,56 @@
+// redact-secrets.test.ts
+// Verifies secret-shaped substrings are replaced while benign text and JSON
+// structure are preserved.
+//
+// Fake secrets are assembled from fragments at runtime so external secret
+// scanners (GitGuardian) and the repo secret-scan never see a literal
+// secret-shaped string in this source file — the runtime value still matches
+// the redaction patterns, which is what the test exercises.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { redactSecrets } from "../redact-secrets.js";
+
+const PLACEHOLDER = "«redacted»";
+
+// Fragment-built fakes (never a full secret literal in source).
+const FAKE = {
+  github: "gh" + "p_" + "A".repeat(36), // GitHub PAT shape: ghp_ + 36 chars
+  aws: "AKIA" + "IOSFODNN7EXAMPL0", // AWS access key id shape: AKIA + 16 chars
+  anthropic: "sk-" + "ant-" + "x".repeat(28), // Anthropic key shape
+  bearer: "sk-" + "b".repeat(24), // generic sk- token
+};
+
+test("redacts a Bearer authorization token", () => {
+  const out = redactSecrets(`Authorization: Bearer ${FAKE.bearer}`);
+  assert.ok(out.includes("Authorization:"), "keeps the label context");
+  assert.ok(out.includes(PLACEHOLDER), "redacts the token");
+  assert.ok(!out.includes(FAKE.bearer), "raw token is gone");
+});
+
+test("redacts key=value style secrets", () => {
+  const anth = redactSecrets(`ANTHROPIC_API_KEY="${FAKE.anthropic}"`);
+  assert.ok(anth.includes(PLACEHOLDER) && !anth.includes(FAKE.anthropic));
+  const gh = redactSecrets(`"token": "${FAKE.github}"`);
+  assert.ok(gh.includes(PLACEHOLDER) && !gh.includes(FAKE.github));
+});
+
+test("redacts an AWS access key id", () => {
+  const out = redactSecrets(`aws key ${FAKE.aws} in output`);
+  assert.ok(out.includes(PLACEHOLDER) && !out.includes(FAKE.aws));
+});
+
+test("leaves benign text mentioning 'token' untouched", () => {
+  const line = "The token is passed to the next unit for processing.";
+  assert.equal(redactSecrets(line), line);
+});
+
+test("redacting a JSON string keeps it valid JSON", () => {
+  const original = JSON.stringify({ msg: "using key=SECRETVALUE here", auth: FAKE.github });
+  const redacted = redactSecrets(original);
+  // Must still parse.
+  const parsed = JSON.parse(redacted) as { msg: string; auth: string };
+  // The bare GitHub token is redacted; the non-keyword "key=..." stays (no false structure break).
+  assert.ok(!redacted.includes(FAKE.github));
+  assert.equal(parsed.auth, PLACEHOLDER);
+});

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -19,6 +19,7 @@ import {
   resetWriteGateState,
   setPendingGate,
   shouldBlockContextArtifactSave,
+  shouldBlockContextWrite,
 } from "../bootstrap/write-gate.ts";
 import { classifyCommand } from "../safety/destructive-guard.ts";
 import { toRoundResultResponse } from "../../remote-questions/manager.ts";
@@ -201,9 +202,82 @@ test("register-hooks unlocks milestone depth verification from question id witho
   );
 });
 
+test("register-hooks canonicalizes lower-case milestone ids in depth-verification question ids", async (t) => {
+  const dir = makeTempDir("lowercase-mid");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState(dir);
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<void> | void) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi, []);
+
+  const questionId = "depth_verification_m001_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Do you agree?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Needs adjustment" },
+      ],
+    },
+  ];
+
+  await armDepthGate(handlers, "ask_user_questions", questions);
+  assert.equal(getPendingGate(), questionId);
+
+  for (const handler of handlers.get("tool_result") ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: {
+        response: {
+          answers: {
+            [questionId]: { selected: "Yes, you got it (Recommended)" },
+          },
+        },
+      },
+    });
+  }
+
+  assert.equal(getPendingGate(), null, "confirming lower-case m001 gate should clear pending state");
+  assert.deepEqual(
+    loadWriteGateSnapshot(dir).verifiedDepthMilestones,
+    ["M001"],
+    "verified milestone id should be stored canonically",
+  );
+  assert.equal(
+    shouldBlockContextWrite(
+      "write",
+      ".gsd/milestones/M001/M001-CONTEXT.md",
+      null,
+      false,
+      dir,
+    ).block,
+    false,
+    "lower-case question id should unlock the matching upper-case CONTEXT.md path",
+  );
+});
+
 test("register-hooks persists first structured question round for new milestone re-entry", async (t) => {
   const dir = makeTempDir("question-draft");
-  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
   const originalCwd = process.cwd();
   process.chdir(dir);
   resetWriteGateState(dir);
@@ -274,9 +348,10 @@ test("register-hooks persists first structured question round for new milestone
     }, ctx);
   }
 
-  const milestoneDir = join(dir, ".gsd", "milestones", "M004");
-  const draftPath = join(milestoneDir, "M004-CONTEXT-DRAFT.md");
-  const discussionPath = join(milestoneDir, "M004-DISCUSSION.md");
+  // Flat-phase: ensureMilestoneShell creates phases/04-new-milestone-m004/ for M004
+  const milestoneDir = join(dir, ".gsd", "phases", "04-new-milestone-m004");
+  const draftPath = join(milestoneDir, "04-CONTEXT-DRAFT.md");
+  const discussionPath = join(milestoneDir, "04-DISCUSSION.md");
 
   assert.equal(existsSync(draftPath), true, "first answer round should create a resumable context draft");
   assert.equal(existsSync(discussionPath), true, "first answer round should create a discussion log");
@@ -895,6 +970,93 @@ test("register-hooks agent_end does not re-arm deferred gate after workflow MCP
   });
 });
 
+test("register-hooks message_update uses in-memory write-gate snapshot instead of disk reconcile", async (t) => {
+  const dir = makeTempDir("message-update-memory-snapshot");
+  const originalCwd = process.cwd();
+  const originalEnv = process.env.GSD_PERSIST_WRITE_GATE_STATE;
+  process.chdir(dir);
+  process.env.GSD_PERSIST_WRITE_GATE_STATE = "1";
+  resetWriteGateState(dir);
+  clearPendingAutoStart(dir);
+
+  const gateId = "depth_verification_M012_confirm";
+  const statePath = join(dir, ".gsd", "runtime", "write-gate-state.json");
+
+  t.after(() => {
+    try {
+      resetWriteGateState(dir);
+      clearPendingAutoStart(dir);
+    } finally {
+      if (originalEnv === undefined) {
+        delete process.env.GSD_PERSIST_WRITE_GATE_STATE;
+      } else {
+        process.env.GSD_PERSIST_WRITE_GATE_STATE = originalEnv;
+      }
+      process.chdir(originalCwd);
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<any> | any>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<any> | any) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  const notices: Array<{ text: string; level: string }> = [];
+  const ctx = {
+    cwd: dir,
+    ui: { notify: (text: string, level: string) => notices.push({ text, level }) },
+  } as any;
+
+  registerHooks(pi, []);
+  setPendingAutoStart(dir, {
+    basePath: dir,
+    milestoneId: "M012",
+    ctx,
+    pi: { sendMessage: () => undefined } as any,
+  });
+
+  mkdirSync(join(dir, ".gsd", "runtime"), { recursive: true });
+  writeFileSync(statePath, JSON.stringify({
+    verifiedDepthMilestones: ["M012"],
+    verifiedApprovalGates: [gateId],
+    activeQueuePhase: false,
+    pendingGateId: null,
+  }, null, 2), "utf-8");
+
+  const approvalMessage = {
+    role: "assistant",
+    content: [
+      { type: "text", text: "Here is the milestone plan.\n\nDid I capture the project correctly?" },
+    ],
+  };
+
+  for (const handler of handlers.get("message_update") ?? []) {
+    await handler({ message: approvalMessage }, ctx);
+  }
+
+  assert.equal(
+    notices.some((n) => /discuss-milestone M012 is waiting for your approval - pausing/.test(n.text)),
+    true,
+    "streaming hook must not suppress the pause from a disk-only verification",
+  );
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M012", null, dir).block,
+    true,
+    "streaming hook must not reconcile disk-only verification into the in-memory snapshot",
+  );
+
+  for (const handler of handlers.get("agent_end") ?? []) {
+    await handler({ messages: [] }, ctx);
+  }
+
+  assert.equal(getPendingGate(dir), null, "agent_end still reconciles disk and suppresses durable re-arm");
+});
+
 // ── External-engine post-hoc gate replay (write-gate two-process sync) ──────
 // On claude-code-cli, pi ingests the SDK turn's tool blocks after the workflow
 // MCP child already executed them. The depth gate can therefore arrive at

package/src/resources/extensions/gsd/tests/register-hooks-flat-phase-migration.test.ts

@@ -0,0 +1,73 @@
+// Project/App: gsd-pi
+// File Purpose: Verifies session bootstrap fails closed when flat-phase migration cannot complete.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
+
+type HookHandler = (event: unknown, ctx: any) => Promise<void> | void;
+
+function createSessionStartHandler(): HookHandler {
+  const handlers = new Map<string, HookHandler>();
+  const pi = {
+    on(event: string, handler: HookHandler) {
+      handlers.set(event, handler);
+    },
+  };
+
+  registerHooks(pi as any, []);
+  const sessionStart = handlers.get("session_start");
+  assert.ok(sessionStart, "session_start handler should be registered");
+  return sessionStart;
+}
+
+function makeContext(basePath: string) {
+  return {
+    cwd: basePath,
+    hasUI: false,
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWidget: () => {},
+      setWorkingMessage: () => {},
+      onTerminalInput: () => () => {},
+    },
+    model: null,
+    modelRegistry: {
+      setDisabledModelProviders: () => {},
+    },
+    sessionManager: {
+      getSessionId: () => null,
+    },
+    setCompactionThresholdOverride: () => {},
+  };
+}
+
+test("session_start rejects when required flat-phase migration fails", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-bootstrap-flat-migration-"));
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001: Foundation\n", "utf-8");
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Foundation", status: "active" });
+  closeDatabase();
+
+  writeFileSync(join(base, ".gsd-backups"), "not a directory\n", "utf-8");
+
+  const sessionStart = createSessionStartHandler();
+
+  await assert.rejects(
+    () => Promise.resolve(sessionStart({}, makeContext(base))),
+    /flat-phase migration/,
+  );
+  assert.ok(existsSync(join(base, ".gsd", "milestones", "M001")), "legacy layout should remain for recovery");
+});