gsd-pi 2.80.0-dev.2848d9009 → 2.80.0-dev.3065f7bfa

package/src/resources/extensions/gsd/tests/auto-wrapup-inflight-guard.test.ts

@@ -3,8 +3,14 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
 import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { autoSession } from "../auto-runtime-state.ts";
+import { dispatchHookUnit } from "../auto.ts";
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import { clearDiscussionFlowState, getPendingGate } from "../bootstrap/write-gate.ts";
 
 const autoTimersPath = join(import.meta.dirname, "..", "auto-timers.ts");
 const autoTimersSrc = readFileSync(autoTimersPath, "utf-8");
@@ -18,6 +24,37 @@ const runUnitSrc = readFileSync(runUnitPath, "utf-8");
 const registerHooksPath = join(import.meta.dirname, "..", "bootstrap", "register-hooks.ts");
 const registerHooksSrc = readFileSync(registerHooksPath, "utf-8");
 
+function makeHookHarness() {
+  const handlers = new Map<string, Array<(event: any, ctx: any) => Promise<any>>>();
+  const pi = {
+    on(name: string, handler: (event: any, ctx: any) => Promise<any>) {
+      const current = handlers.get(name) ?? [];
+      current.push(handler);
+      handlers.set(name, current);
+    },
+  };
+  const ctx = {
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWidget: () => {},
+    },
+    modelRegistry: {
+      setDisabledModelProviders: () => {},
+    },
+    setCompactionThresholdOverride: () => {},
+  };
+  async function emit(name: string, event: any): Promise<any> {
+    for (const handler of handlers.get(name) ?? []) {
+      const result = await handler(event, ctx);
+      if (result?.block) return result;
+    }
+    return undefined;
+  }
+  registerHooks(pi as any, []);
+  return { emit };
+}
+
 describe("#3512: gsd-auto-wrapup must not interrupt in-flight tool calls", () => {
   test("soft timeout wrapup gates triggerTurn on getInFlightToolCount() === 0", () => {
     // The soft timeout sendMessage must NOT use a hardcoded `triggerTurn: true`.
@@ -73,10 +110,65 @@ describe("#3512: gsd-auto-wrapup must not interrupt in-flight tool calls", () =>
   });
 });
 
+describe("hook dispatch session workspace root", () => {
+  test("dispatchHookUnit passes basePath explicitly to newSession", async (t) => {
+    const originalCwd = process.cwd();
+    const basePath = mkdtempSync(join(tmpdir(), "gsd-hook-cwd-"));
+    mkdirSync(join(basePath, ".gsd"), { recursive: true });
+    autoSession.reset();
+    t.after(() => {
+      try {
+        process.chdir(originalCwd);
+      } catch {
+        // best effort cleanup after cwd-sensitive dispatch tests
+      }
+      autoSession.reset();
+      rmSync(basePath, { recursive: true, force: true });
+    });
+
+    let newSessionOptions: unknown;
+    const ctx = {
+      ui: {
+        notify: () => {},
+        setStatus: () => {},
+        setWidget: () => {},
+      },
+      modelRegistry: {
+        getAvailable: () => [],
+      },
+      sessionManager: {
+        getSessionFile: () => join(basePath, "session.jsonl"),
+      },
+      newSession: async (options?: unknown) => {
+        newSessionOptions = options;
+        return { cancelled: false };
+      },
+    };
+    const pi = {
+      sendMessage: () => {},
+      setModel: async () => true,
+    };
+
+    const dispatched = await dispatchHookUnit(
+      ctx as any,
+      pi as any,
+      "review",
+      "execute-task",
+      "M001/S01/T01",
+      "review the completed unit",
+      undefined,
+      basePath,
+    );
+
+    assert.equal(dispatched, true);
+    assert.deepEqual(newSessionOptions, { workspaceRoot: basePath });
+  });
+});
+
 describe("#4276: pending/skipped tools stay visible to auto-mode hooks", () => {
   test("tool_call handler marks GSD tools in-flight before execution_start", () => {
     const startMarker = 'pi.on("tool_call", async (event, ctx) => {';
-    const endMarker = 'pi.on("tool_result", async (event) => {';
+    const endMarker = 'pi.on("tool_result", async (event, ctx) => {';
     const toolCallSection = registerHooksSrc.slice(
       registerHooksSrc.indexOf(startMarker),
       registerHooksSrc.indexOf(endMarker),
@@ -90,7 +182,7 @@ describe("#4276: pending/skipped tools stay visible to auto-mode hooks", () => {
   });
 
   test("tool_result handler clears pending tools and records queued-skip errors", () => {
-    const startMarker = 'pi.on("tool_result", async (event) => {';
+    const startMarker = 'pi.on("tool_result", async (event, ctx) => {';
     const endMarker = 'pi.on("tool_execution_start", async (event) => {';
     const toolResultSection = registerHooksSrc.slice(
       registerHooksSrc.indexOf(startMarker),
@@ -193,7 +285,7 @@ describe("#4365: tool_execution_start hook must pass toolName to markToolStart",
 });
 
 describe("deep setup approval questions pause immediately", () => {
-  test("register-hooks sets pending gate during message_update without aborting the stream", () => {
+  test("register-hooks defers the pending gate during message_update without aborting the stream", () => {
     const startMarker = 'pi.on("message_update"';
     const endMarker = 'pi.on("session_shutdown"';
     const messageUpdateSection = registerHooksSrc.slice(
@@ -210,8 +302,8 @@ describe("deep setup approval questions pause immediately", () => {
       "message_update must detect approval/question boundaries",
     );
     assert.ok(
-      messageUpdateSection.includes("approvalGateIdForUnit") && messageUpdateSection.includes("setPendingGate"),
-      "plain-text approval questions must set the durable write gate",
+      messageUpdateSection.includes("approvalGateIdForUnit") && messageUpdateSection.includes("deferApprovalGate"),
+      "plain-text approval questions must defer the durable write gate until same-turn draft persistence can finish",
     );
     assert.ok(
       messageUpdateSection.includes("getDiscussionMilestoneIdFor") && messageUpdateSection.includes('"discuss-milestone"'),
@@ -222,4 +314,74 @@ describe("deep setup approval questions pause immediately", () => {
       "message_update must NOT abort the stream — aborting eats the model's question text on external CLI providers; the pending gate set above blocks subsequent tool calls instead",
     );
   });
+
+  test("plain-text approval boundary defers durable gate until same-turn CONTEXT-DRAFT can save", async () => {
+    const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-deferred-approval-")));
+    const previousCwd = process.cwd();
+    try {
+      mkdirSync(join(base, ".gsd", "milestones", "M003"), { recursive: true });
+      process.chdir(base);
+      clearDiscussionFlowState(base);
+      autoSession.reset();
+      autoSession.basePath = base;
+      autoSession.currentUnit = {
+        type: "discuss-milestone",
+        id: "M003",
+        startedAt: Date.now(),
+      };
+
+      const { emit } = makeHookHarness();
+      await emit("message_update", {
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "Did I capture that correctly? If not, tell me what I missed." }],
+        },
+      });
+
+      assert.equal(
+        getPendingGate(base),
+        null,
+        "approval text should not install the durable pending gate until the assistant turn ends",
+      );
+
+      const draftResult = await emit("tool_call", {
+        toolCallId: "draft-save",
+        toolName: "gsd_summary_save",
+        input: {
+          milestone_id: "M003",
+          artifact_type: "CONTEXT-DRAFT",
+          content: "# M003 Draft\n",
+        },
+      });
+      assert.equal(
+        draftResult?.block,
+        undefined,
+        "same-turn CONTEXT-DRAFT persistence should remain allowed after the approval text streams",
+      );
+
+      const finalContextResult = await emit("tool_call", {
+        toolCallId: "final-context",
+        toolName: "gsd_summary_save",
+        input: {
+          milestone_id: "M003",
+          artifact_type: "CONTEXT",
+          content: "# M003 Context\n",
+        },
+      });
+      assert.equal(finalContextResult?.block, true, "final CONTEXT must still wait for approval");
+      assert.match(finalContextResult.reason, /Approval question "depth_verification_M003_confirm"/);
+
+      await emit("agent_end", { messages: [] });
+      assert.equal(
+        getPendingGate(base),
+        "depth_verification_M003_confirm",
+        "agent_end should activate the durable pending gate for the next turn",
+      );
+    } finally {
+      process.chdir(previousCwd);
+      autoSession.reset();
+      clearDiscussionFlowState(base);
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/clean-root-preflight.test.ts

@@ -131,9 +131,11 @@ test("postflightPopStash — restores stashed changes and emits info notificatio
     run('git commit -m "simulate merge"', repo);
 
     const postNotifications: Array<{ msg: string; level: string }> = [];
-    postflightPopStash(repo, "M004", preflight.stashMarker, (msg, level) => {
+    const postflight = postflightPopStash(repo, "M004", preflight.stashMarker, (msg, level) => {
       postNotifications.push({ msg, level });
     });
+    assert.equal(postflight.restored, true, "postflight must report successful restore");
+    assert.equal(postflight.needsManualRecovery, false, "successful restore must not need manual recovery");
 
     // The stashed README.md change must be restored
     const content = readFileSync(join(repo, "README.md"), "utf-8");
@@ -171,7 +173,8 @@ test("preflight + merge + postflight round-trip preserves uncommitted changes",
     run('git commit -m "feat: add feature"', repo);
 
     // Postflight: pop stash
-    postflightPopStash(repo, "M005", preflight.stashMarker, () => {});
+    const postflight = postflightPopStash(repo, "M005", preflight.stashMarker, () => {});
+    assert.equal(postflight.needsManualRecovery, false, "clean restore must not stop auto-mode");
 
     // README.md must still have our local content
     const restored = readFileSync(join(repo, "README.md"), "utf-8");
@@ -197,9 +200,12 @@ test("postflightPopStash conflict warning names the exact stash ref", () => {
     run('git commit -m "simulate conflicting merge"', repo);
 
     const notifications: Array<{ msg: string; level: string }> = [];
-    postflightPopStash(repo, "M005C", preflight.stashMarker, (msg, level) => {
+    const postflight = postflightPopStash(repo, "M005C", preflight.stashMarker, (msg, level) => {
       notifications.push({ msg, level });
     });
+    assert.equal(postflight.restored, false, "conflicted restore must report restored=false");
+    assert.equal(postflight.needsManualRecovery, true, "conflicted restore must require manual recovery");
+    assert.match(postflight.message, /failed after merge of milestone M005C/);
 
     const warning = notifications.find((n) => n.level === "warning")?.msg ?? "";
     assert.match(warning, /git stash pop stash@\{\d+\}/);
@@ -219,7 +225,8 @@ test("postflightPopStash restores the matching GSD stash, not stash@{0}", () =>
     writeFileSync(join(repo, "other.txt"), "other stash\n");
     run('git stash push --include-untracked -m "unrelated newer stash"', repo);
 
-    postflightPopStash(repo, "M006", preflight.stashMarker, () => {});
+    const postflight = postflightPopStash(repo, "M006", preflight.stashMarker, () => {});
+    assert.equal(postflight.needsManualRecovery, false, "targeted restore must not need manual recovery");
 
     const content = readFileSync(join(repo, "README.md"), "utf-8");
     assert.equal(content.replace(/\r\n/g, "\n"), "# target stash\n");
@@ -242,7 +249,8 @@ test("postflightPopStash restores the exact preflight marker when another same-m
     writeFileSync(join(repo, "same-milestone.txt"), "newer same milestone stash\n");
     run('git stash push --include-untracked -m "gsd-preflight-stash [gsd-preflight-stash:M007:other]"', repo);
 
-    postflightPopStash(repo, "M007", preflight.stashMarker, () => {});
+    const postflight = postflightPopStash(repo, "M007", preflight.stashMarker, () => {});
+    assert.equal(postflight.needsManualRecovery, false, "exact marker restore must not need manual recovery");
 
     const content = readFileSync(join(repo, "README.md"), "utf-8");
     assert.equal(content.replace(/\r\n/g, "\n"), "# target stash\n");
@@ -260,7 +268,8 @@ test("postflightPopStash falls back to milestone marker prefix when exact marker
     writeFileSync(join(repo, "README.md"), "# fallback stash\n");
     run('git stash push --include-untracked -m "gsd-preflight-stash [gsd-preflight-stash:M008:fallback]"', repo);
 
-    postflightPopStash(repo, "M008", undefined, () => {});
+    const postflight = postflightPopStash(repo, "M008", undefined, () => {});
+    assert.equal(postflight.needsManualRecovery, false, "fallback marker restore must not need manual recovery");
 
     const content = readFileSync(join(repo, "README.md"), "utf-8");
     assert.equal(content.replace(/\r\n/g, "\n"), "# fallback stash\n");

package/src/resources/extensions/gsd/tests/compaction-snapshot.test.ts

@@ -29,7 +29,8 @@ test('buildSnapshot: renders memories, exec history, and active context', () =>
     memories: [
       { id: 'MEM001', category: 'gotcha', content: 'FTS5 needs Porter tokenizer', confidence: 0.9,
         source_unit_type: null, source_unit_id: null, created_at: '', updated_at: '',
-        superseded_by: null, hit_count: 0, scope: 'project', seq: 1, tags: [], structured_fields: null },
+        superseded_by: null, hit_count: 0, scope: 'project', seq: 1, tags: [], structured_fields: null,
+        last_hit_at: null },
     ],
     execHistory: [
       {
@@ -65,6 +66,7 @@ test('buildSnapshot: enforces the byte cap with a truncation marker', () => {
     seq: i,
     tags: [] as string[],
     structured_fields: null,
+    last_hit_at: null,
   }));
   const snap = buildSnapshot(
     { generatedAt: new Date(), memories: longMemories, execHistory: [] },
@@ -121,3 +123,14 @@ test('executeResume: reports friendly empty state when no snapshot exists', () =
     cleanup(base);
   }
 });
+
+test('executeResume: returns disabled error when context_mode.enabled=false', () => {
+  const base = freshBase();
+  try {
+    const result = executeResume({}, { baseDir: base, preferences: { context_mode: { enabled: false } } });
+    assert.equal(result.isError, true);
+    assert.equal((result.details as { error?: string }).error, 'context_mode_disabled');
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/complete-milestone-excerpt.test.ts

@@ -261,3 +261,34 @@ test("#4780 closer prompt: uses excerpts + lists on-demand slice SUMMARY paths",
     `closer prompt length ${prompt.length} should be < raw summary size ${rawSize} + 20KB headroom`,
   );
 });
+
+test("complete-milestone prompt caps repeated inlined context around 20k chars", async (t) => {
+  const base = createBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  writeRoadmap(base, makeRoadmap());
+  writeSummary(base, "S01", makeFatSummary("S01"));
+  writeSummary(base, "S02", makeFatSummary("S02"));
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001 Context\n\n" + "Large milestone context body. ".repeat(1200),
+  );
+  writeFileSync(
+    join(base, ".gsd", "KNOWLEDGE.md"),
+    "# Project Knowledge\n\n## Patterns\n\n### Test Milestone shared\n" + "Large scoped knowledge body. ".repeat(1200),
+  );
+
+  const prompt = await buildCompleteMilestonePrompt("M001", "Test Milestone", base);
+  const contextStart = prompt.indexOf("## Inlined Context (preloaded");
+  const contextEnd = prompt.indexOf("## Steps", contextStart);
+  assert.ok(contextStart >= 0, "prompt should include inlined context");
+  assert.ok(contextEnd > contextStart, "prompt should include steps after inlined context");
+
+  const inlinedContext = prompt.slice(contextStart, contextEnd);
+  assert.ok(
+    inlinedContext.length <= 21_000,
+    `inlined context ${inlinedContext.length} chars should stay near the 20k cap`,
+  );
+  assert.match(inlinedContext, /\[\.\.\.truncated \d+ sections\]/);
+});

package/src/resources/extensions/gsd/tests/complete-slice-composer.test.ts

@@ -113,8 +113,9 @@ test("#4782 phase 3: buildCompleteSlicePrompt composes roadmap → plan → task
     "task summaries precede slice-summary template",
   );
 
-  // Task body inlined
-  assert.match(prompt, /Task one did the thing/);
+  // Task summary excerpt is inlined; full narrative remains on-demand.
+  assert.match(prompt, /### Task Summary: T01 \(excerpt\)/);
+  assert.doesNotMatch(prompt, /Task one did the thing/);
 });
 
 test("#4782 phase 3: buildCompleteSlicePrompt handles missing task summaries gracefully", async (t) => {

package/src/resources/extensions/gsd/tests/context-budget.test.ts

@@ -4,7 +4,7 @@
  * No I/O, no extension context, no global state.
  */
 
-import { describe, it } from "node:test";
+import { describe, it, beforeEach } from "node:test";
 import assert from "node:assert/strict";
 
 import {
@@ -16,8 +16,17 @@ import {
   computeBudgets,
   truncateAtSectionBoundary,
   resolveExecutorContextWindow,
+  _resetEmpiricalCacheForTest,
 } from "../context-budget.js";
 
+// Reset the per-provider empirical chars-per-token cache before each test.
+// The hardcoded char-ratio assertions below assume the static fallback path
+// (3.5 / 4.0 chars/token) is used. Without this guard, a prior test that
+// warms tiktoken would populate the cache and silently break these tests.
+beforeEach(() => {
+  _resetEmpiricalCacheForTest();
+});
+
 import type { TokenProvider } from "../token-counter.js";
 
 // ─── Test helpers ─────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/tests/context-store.test.ts

@@ -1,3 +1,5 @@
+// GSD-2 + context-store.test.ts — Regression coverage for DB-backed context query helpers.
+
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import {
@@ -362,7 +364,11 @@ describe("context-store: sub-5ms query timing", () => {
 
     assert.strictEqual(decisions.length, 50, `got ${decisions.length} decisions (expected 50)`);
     assert.strictEqual(requirements.length, 50, `got ${requirements.length} requirements (expected 50)`);
-    assert.ok(elapsed < 5, `query latency ${elapsed.toFixed(2)}ms should be < 5ms`);
+    const maxLatencyMs = process.env.NODE_V8_COVERAGE ? 15 : 5;
+    assert.ok(
+      elapsed < maxLatencyMs,
+      `query latency ${elapsed.toFixed(2)}ms should be < ${maxLatencyMs}ms`,
+    );
   });
 });
 

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

@@ -232,4 +232,59 @@ describe('emitCrashRecoveredUnitEnd (#3348)', () => {
       rmSync(base, { recursive: true, force: true });
     }
   });
+
+  test('emitOpenUnitEndForUnit closes the latest open start with error context', async () => {
+    const base = makeTmpBase();
+    try {
+      const { emitJournalEvent, queryJournal } = await import('../journal.ts');
+      const { emitOpenUnitEndForUnit } = await import('../crash-recovery.ts');
+
+      const firstFlowId = randomUUID();
+      const secondFlowId = randomUUID();
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: firstFlowId,
+        seq: 1,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02' },
+      });
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: firstFlowId,
+        seq: 2,
+        eventType: 'unit-end',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02', status: 'completed' },
+        causedBy: { flowId: firstFlowId, seq: 1 },
+      });
+      emitJournalEvent(base, {
+        ts: new Date().toISOString(),
+        flowId: secondFlowId,
+        seq: 3,
+        eventType: 'unit-start',
+        data: { unitType: 'execute-task', unitId: 'M008/S04/T02' },
+      });
+
+      const emitted = emitOpenUnitEndForUnit(
+        base,
+        'execute-task',
+        'M008/S04/T02',
+        'cancelled',
+        { message: 'runUnitPhase exploded', category: 'unit-exception', isTransient: false },
+      );
+
+      assert.equal(emitted, true, 'open unit should be closed');
+      const ends = queryJournal(base).filter((e) => e.eventType === 'unit-end');
+      assert.equal(ends.length, 2, 'should preserve existing end and add one new end');
+      const newEnd = ends.find((e) => e.causedBy?.flowId === secondFlowId);
+      assert.ok(newEnd, 'new end should close the latest open start');
+      assert.equal(newEnd!.data?.status, 'cancelled');
+      assert.deepEqual(newEnd!.data?.errorContext, {
+        message: 'runUnitPhase exploded',
+        category: 'unit-exception',
+        isTransient: false,
+      });
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
 });

package/src/resources/extensions/gsd/tests/crash-recovery-via-db.test.ts

@@ -30,6 +30,7 @@ import {
   isLockProcessAlive,
 } from "../crash-recovery.ts";
 import { normalizeRealPath } from "../paths.ts";
+import { writeUnitRuntimeRecord } from "../unit-runtime.ts";
 
 function makeBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-crash-recovery-"));
@@ -102,6 +103,27 @@ test("readCrashLock synthesizes LockData from a stale dead worker (no dispatches
   assert.ok(lock!.startedAt, "startedAt populated from workers.started_at");
 });
 
+test("readCrashLock falls back to latest in-flight runtime record when dispatch claim is missing", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  const projectRoot = normalizeRealPath(base);
+  const workerId = registerAutoWorker({ projectRootRealpath: projectRoot });
+  writeUnitRuntimeRecord(base, "execute-task", "M008/S04/T02", 1778069087937, {
+    phase: "dispatched",
+    lastProgressAt: 1778069087937,
+    lastProgressKind: "dispatch",
+  });
+  setWorkerPid(workerId, 99999);
+  expireWorker(workerId);
+
+  const lock = readCrashLock(base);
+  assert.ok(lock, "stale worker surfaced as a crash lock");
+  assert.equal(lock!.unitType, "execute-task");
+  assert.equal(lock!.unitId, "M008/S04/T02");
+  assert.equal(lock!.unitStartedAt, new Date(1778069087937).toISOString());
+});
+
 test("readCrashLock includes the most recent dispatch as unitType/unitId", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/custom-engine-loop-integration.test.ts

@@ -192,7 +192,11 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     resolveMilestoneFile: () => null,
     reconcileMergeState: () => "clean",
     preflightCleanRoot: () => ({ stashPushed: false, summary: "" }),
-    postflightPopStash: () => {},
+    postflightPopStash: () => ({
+      restored: true,
+      needsManualRecovery: false,
+      message: "restored",
+    }),
     getLedger: () => null,
     getProjectTotals: () => ({ cost: 0 }),
     formatCost: (c: number) => `$${c.toFixed(2)}`,