@opengsd/gsd-pi 1.0.1 → 1.0.2-dev.0ee79e5

package/src/resources/extensions/gsd/state.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Runtime state derivation from GSD workflow database and legacy files.
 // GSD Extension — State Derivation
 // DB-authoritative runtime derivation with explicit legacy filesystem fallback.
@@ -49,7 +49,6 @@ import { logWarning } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
 import { detectPendingEscalation } from './escalation.js';
 import { isTerminalMilestoneSummaryContent } from './milestone-summary-classifier.js';
-import { incrementLegacyTelemetry } from './legacy-telemetry.js';
 
 import {
   isDbAvailable,
@@ -227,9 +226,9 @@ const CACHE_TTL_MS = 100;
 let _stateCache: StateCache | null = null;
 
 // ── Telemetry counters for derive-path observability ────────────────────────
-let _telemetry = { dbDeriveCount: 0, markdownDeriveCount: 0 };
+let _telemetry = { dbDeriveCount: 0 };
 export function getDeriveTelemetry() { return { ..._telemetry }; }
-export function resetDeriveTelemetry() { _telemetry = { dbDeriveCount: 0, markdownDeriveCount: 0 }; }
+export function resetDeriveTelemetry() { _telemetry = { dbDeriveCount: 0 }; }
 
 async function loadRecentDecisions(basePath: string): Promise<string[]> {
   const decisionsPath = resolveGsdRootFile(basePath, "DECISIONS");
@@ -352,8 +351,8 @@ export interface DeriveStateOptions {
  * STATE.md is a rendered cache of this output.
  *
  * When DB is available, queries milestone/slice/task tables directly.
- * Legacy filesystem parsing is available only through an explicit opt-in for
- * tests/recovery flows; runtime must not silently infer state from markdown.
+ * Runtime must not silently infer state from markdown. Use explicit recovery
+ * or `/gsd migrate` when markdown is the intended source.
  */
 export async function deriveState(
   basePath: string,
@@ -379,21 +378,14 @@ export async function deriveState(
   const stopTimer = debugTime("derive-state-impl");
   let result: GSDState;
 
-  // DB-backed derivation is authoritative whenever the DB is open.
-  // Markdown fallback is explicit-only; runtime degrade must not infer state
-  // from ROADMAP.md, PLAN.md, SUMMARY.md, REQUIREMENTS.md, or flag files.
+  // DB-backed derivation is authoritative whenever the DB is open. Runtime
+  // degrade must not infer state from ROADMAP.md, PLAN.md, SUMMARY.md,
+  // REQUIREMENTS.md, or flag files.
   if (isDbAvailable()) {
     const stopDbTimer = debugTime("derive-state-db");
     result = await deriveStateFromDb(basePath, opts?.projectRootForReads ?? basePath);
     stopDbTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
     _telemetry.dbDeriveCount++;
-  } else if (process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK === "1") {
-    if (wasDbOpenAttempted()) {
-      logWarning("state", "DB unavailable — using explicit legacy filesystem state derivation");
-    }
-    result = await _deriveStateImpl(basePath, opts);
-    _telemetry.markdownDeriveCount++;
-    incrementLegacyTelemetry("legacy.markdownFallbackUsed");
   } else {
     if (wasDbOpenAttempted()) {
       logWarning("state", "DB unavailable — refusing implicit markdown state derivation");
@@ -405,7 +397,7 @@ export async function deriveState(
       phase: "pre-planning",
       recentDecisions: [],
       blockers: ["DB unavailable — runtime markdown state derivation is disabled"],
-      nextAction: "Open or create the canonical GSD database before deriving workflow state.",
+      nextAction: "Open or create the canonical GSD database before deriving workflow state. If this project only has markdown state, run /gsd migrate explicitly.",
       registry: [],
       requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
       progress: { milestones: { done: 0, total: 0 } },

package/src/resources/extensions/gsd/tests/artifact-validators.test.ts

@@ -1,4 +1,4 @@
-// GSD-2 — Deep planning mode artifact validator tests.
+// gsd-pi — Deep planning mode artifact validator tests.
 // Verifies validateArtifact() correctly accepts valid PROJECT.md / REQUIREMENTS.md /
 // ROADMAP.md fixtures and flags specific malformations with the expected error codes.
 

package/src/resources/extensions/gsd/tests/auto-deterministic-error-classification-4973.test.ts

@@ -1,4 +1,4 @@
-// GSD-2 + Regression tests for deterministic policy error classification (#4973)
+// gsd-pi + Regression tests for deterministic policy error classification (#4973)
 //
 // When gsd_summary_save returns context_write_blocked (a deterministic write-gate
 // rejection), the retry controller must NOT re-dispatch with escalating model tiers.

package/src/resources/extensions/gsd/tests/auto-discuss-milestone-deadlock-4973.test.ts

@@ -1,4 +1,4 @@
-// GSD-2 + Regression tests for auto-mode discuss-milestone write-gate deadlock (#4973)
+// gsd-pi + Regression tests for auto-mode discuss-milestone write-gate deadlock (#4973)
 //
 // The depth-verification write-gate in write-gate.ts:415-443 blocks
 // gsd_summary_save({artifact_type:"CONTEXT"}) until markDepthVerified() is

package/src/resources/extensions/gsd/tests/auto-loop-no-copy-artifacts.test.ts

@@ -1,4 +1,4 @@
-// gsd-2 + Phase C deletion regression: createAutoWorktree no longer copies .gsd/
+// gsd-pi + Phase C deletion regression: createAutoWorktree no longer copies .gsd/
 //
 // Verifies that createAutoWorktree on a project with a real (non-symlinked)
 // .gsd/ does NOT populate .gsd/milestones/ inside the worktree. Pre-Phase-C,

package/src/resources/extensions/gsd/tests/auto-loop-symlink-worktree.test.ts

@@ -1,4 +1,4 @@
-// gsd-2 + Symlinked .gsd worktree-loop reproduction (Phase A pt 2 follow-up to PR #5236)
+// gsd-pi + Symlinked .gsd worktree-loop reproduction (Phase A pt 2 follow-up to PR #5236)
 //
 // Regression coverage for the auto-mode loop bug observed on projects whose
 // .gsd/ is a symlink into ~/.gsd/projects/<hash>/ (the external-state layout).

package/src/resources/extensions/gsd/tests/auto-loop.test.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Auto-loop execution, dispatch, recovery, and cancellation regression tests.
 
 import test, { mock } from "node:test";
@@ -21,6 +21,7 @@ import {
   isSessionSwitchAbortGraceActive,
 } from "../auto/resolve.js";
 import { runUnit, shouldDeferUnitFailsafeTimeout } from "../auto/run-unit.js";
+import { scheduleAutoWakeup, _resetAutoWakeupsForTest } from "../auto/schedule-wakeup.js";
 import { writeUnitRuntimeRecord, readUnitRuntimeRecord } from "../unit-runtime.js";
 import { autoLoop } from "../auto/loop.js";
 import { runDispatch, runUnitPhase } from "../auto/phases.js";
@@ -53,11 +54,14 @@ async function drainMicrotasks(turns = 20): Promise<void> {
 async function waitForMicrotasks(
   condition: () => boolean,
   label: string,
-  turns = 500,
+  turns = 5000,
 ): Promise<void> {
   for (let i = 0; i < turns; i++) {
     if (condition()) return;
     await Promise.resolve();
+    if (i % 25 === 24) {
+      await new Promise<void>((resolve) => setImmediate(resolve));
+    }
   }
   assert.fail(`Timed out waiting for ${label}`);
 }
@@ -187,6 +191,61 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
   assert.deepEqual(result.event, event);
 });
 
+test("runUnit honors ScheduleWakeup by continuing the same unit session", async () => {
+  _resetPendingResolve();
+  _resetAutoWakeupsForTest();
+
+  const ctx = {
+    ...makeMockCtx(),
+    ui: {
+      notify: () => {},
+      setStatus: () => {},
+      setWorkingMessage: () => {},
+    },
+    sessionManager: {
+      getEntries: () => [],
+    },
+    modelRegistry: {
+      getProviderAuthMode: () => undefined,
+      isProviderRequestReady: () => true,
+    },
+  } as any;
+  const pi = makeMockPi();
+  const s = makeMockSession();
+  const firstEvent = makeEvent([{ role: "assistant", content: "submitted job" }]);
+  const secondEvent = makeEvent([{ role: "assistant", content: "job finished" }]);
+
+  const resultPromise = runUnit(
+    ctx,
+    pi,
+    s,
+    "execute-task",
+    "M001/S01/T01",
+    "submit external job",
+  );
+
+  await waitForMicrotasks(() => pi.calls.length === 1, "initial unit dispatch");
+  scheduleAutoWakeup({
+    basePath: s.basePath,
+    unitType: "execute-task",
+    unitId: "M001/S01/T01",
+    delayMs: 0,
+    prompt: "check external job and write the task summary if complete",
+    reason: "poll external job",
+    createdAt: Date.now(),
+  });
+  resolveAgentEnd(firstEvent);
+
+  await waitForMicrotasks(() => pi.calls.length === 2, "scheduled wakeup dispatch");
+  assert.equal((pi.calls[1] as any[])[0].content, "check external job and write the task summary if complete");
+  resolveAgentEnd(secondEvent);
+
+  const result = await resultPromise;
+  assert.equal(result.status, "completed");
+  assert.deepEqual(result.event, secondEvent);
+  assert.equal(pi.calls.length, 2);
+});
+
 test("runUnit suppresses the global working-message loader for auto dashboard runs", async () => {
   _resetPendingResolve();
   const workingMessages: unknown[] = [];
@@ -2450,8 +2509,8 @@ test("autoLoop handles verification retry by continuing loop", async (t) => {
       },
       postUnitPostVerification: async () => {
         deps.callLog.push("postUnitPostVerification");
-        // After the retry cycle completes, deactivate
-        s.active = false;
+        // After the retry cycle completes, deactivate.
+        if (verifyCallCount >= 2) s.active = false;
         return "continue" as const;
       },
     });
@@ -2622,6 +2681,62 @@ test("autoLoop pauses instead of stopping for warning-level dispatch stop", asyn
   );
 });
 
+test("autoLoop retries warning-level unhandled phase with fresh state before pausing", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+  const states = [
+    {
+      phase: "planning",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: null,
+      activeTask: null,
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    },
+    {
+      phase: "executing",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice 1" },
+      activeTask: { id: "T01" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    },
+  ];
+  const seenPhases: string[] = [];
+  let deriveCalls = 0;
+
+  const deps = makeMockDeps({
+    deriveState: async () => states[Math.min(deriveCalls++, states.length - 1)] as any,
+    resolveDispatch: async (dctx) => {
+      seenPhases.push(dctx.state.phase);
+      if (dctx.state.phase === "planning") {
+        return {
+          action: "stop" as const,
+          reason: 'Unhandled phase "planning" — run /gsd doctor to diagnose.',
+          level: "warning" as const,
+          matchedRule: "<no-match>",
+        };
+      }
+      return {
+        action: "stop" as const,
+        reason: "fresh state reached terminal stop",
+        level: "info" as const,
+      };
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.deepEqual(seenPhases, ["planning", "executing"]);
+  assert.equal(deriveCalls, 2, "unhandled warning should re-derive state once");
+  assert.equal(deps.callLog.includes("pauseAuto"), false);
+  assert.equal(deps.callLog.includes("stopAuto"), true);
+});
+
 // #2474: error-level dispatch stop should still hard-stop
 test("autoLoop hard-stops for error-level dispatch stop", async (t) => {
   _resetPendingResolve();
@@ -2654,6 +2769,41 @@ test("autoLoop hard-stops for error-level dispatch stop", async (t) => {
   );
 });
 
+test("autoLoop closes journal iteration on pre-dispatch health-gate break", async () => {
+  _resetPendingResolve();
+
+  const ctx = makeMockCtx();
+  ctx.ui.setStatus = () => {};
+  const pi = makeMockPi();
+  const s = makeLoopSession();
+  const journalEvents: Array<{ eventType: string; data?: any }> = [];
+  let pauseOptions: unknown;
+
+  const deps = makeMockDeps({
+    preDispatchHealthGate: async () => ({
+      proceed: false,
+      reason: "health gate failed",
+      fixesApplied: [],
+    }),
+    pauseAuto: async (_ctx, _pi, _errorContext, options) => {
+      pauseOptions = options;
+      deps.callLog.push("pauseAuto");
+    },
+    emitJournalEvent: (event: any) => {
+      journalEvents.push(event);
+    },
+  });
+
+  await autoLoop(ctx, pi, s, deps);
+
+  assert.equal(deps.callLog.includes("pauseAuto"), true);
+  assert.deepEqual(pauseOptions, { expectedCurrentUnit: null });
+  assert.ok(
+    journalEvents.some((event) => event.eventType === "iteration-end" && event.data?.reason === "pre-dispatch-break"),
+    "pre-dispatch break must close the started iteration",
+  );
+});
+
 test("autoLoop handles dispatch skip action by continuing", async (t) => {
   _resetPendingResolve();
 
@@ -5445,7 +5595,7 @@ test("autoLoop classifies ModelPolicyDispatchBlockedError as blocked, not a retr
   // Capture onTurnResult to assert blocked-unit identity is propagated to
   // the uokObserver. Without the fix, observedUnitType/Id are unset because
   // the throw happens inside dispatch before the success-path assignments
-  // at loop.ts:453/631/647 (#4959 / CodeRabbit Minor).
+  // at loop.ts:453/631/647 (#4959).
   const turnResults: Array<{ unitType?: string; unitId?: string; status: string }> = [];
 
   const deps = makeMockDeps({
@@ -5495,7 +5645,7 @@ test("autoLoop classifies ModelPolicyDispatchBlockedError as blocked, not a retr
 
   // Blocked-unit identity must reach uokObserver.onTurnResult — the typed
   // error already carries it, the loop must thread it into observedUnitType/Id
-  // before finishTurn is called (#4959 / CodeRabbit Minor).
+  // before finishTurn is called (#4959).
   const pausedTurn = turnResults.find(r => r.status === "paused");
   assert.ok(pausedTurn, "uokObserver should observe a paused turn for the blocked unit");
   assert.equal(pausedTurn!.unitType, "research-slice", "onTurnResult must receive the blocked unitType from the typed error");

package/src/resources/extensions/gsd/tests/auto-model-selection-tool-poisoning.test.ts

@@ -128,7 +128,7 @@ test("vacuous-truth (a): unit type with empty workflow-required tools → dispat
   try {
     // `refine-slice` is not in the getRequiredWorkflowToolsForAutoUnit switch
     // → returns []. Exercises the empty-requiredTools branch in
-    // applyModelPolicyFilter (CodeRabbit Minor: existing test used
+    // applyModelPolicyFilter (existing test used
     // gate-evaluate which has non-empty required tools and never hit this path).
     //
     // PREFERENCES with tier_models is required so resolvePreferredModelConfig
@@ -269,8 +269,8 @@ test("cross-unit poisoning: prior unit narrowing must not deny next unit's eligi
 // ─── 3a. Genuinely-impossible: tool-compatibility denial path ────────────────
 //
 // Exercises the real `getRequiredWorkflowToolsForAutoUnit` →
-// `filterToolsForProvider` path that #4959 was about (CodeRabbit Minor:
-// existing 3b test used cross-provider denial which never hit this path).
+// `filterToolsForProvider` path that #4959 was about — existing 3b test used
+// cross-provider denial which never hit this path.
 // Registers `gsd_plan_slice` as `producesImages: true`, then offers only an
 // `ollama-chat` candidate (which has `imageToolResults: false`) — the
 // workflow-required tool is incompatible with the candidate's API, so the
@@ -509,7 +509,7 @@ test("error carries deny reason fragment from applyModelPolicyFilter", async ()
   }
 });
 
-// ─── 6. Lifecycle: clearToolBaseline forces recapture (CodeRabbit Major) ─────
+// ─── 6. Lifecycle: clearToolBaseline forces recapture (#4959) ─────
 //
 // The WeakMap baseline is keyed per `pi` instance, but auto sessions are NOT
 // 1:1 with `pi` instances — a single `pi` can host multiple `/gsd auto` runs

package/src/resources/extensions/gsd/tests/auto-orchestrator.test.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Auto Orchestration module contract and ADR-015 invariant sequence tests.
 
 import test from "node:test";

package/src/resources/extensions/gsd/tests/auto-pause-double-entry-guard.test.ts

@@ -10,7 +10,8 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { pauseAuto, isAutoActive } from "../auto.ts";
+import { capturePauseAutoUnitIdentity, pauseAuto, isAutoActive } from "../auto.ts";
+import { _resetPendingResolve, _setCurrentResolve } from "../auto/resolve.ts";
 import { autoSession } from "../auto-runtime-state.ts";
 import { _isPauseOriginCancelledResult } from "../auto/phases.ts";
 
@@ -53,6 +54,32 @@ test("pauseAuto sets s.active = false synchronously before first await (blocks c
   }
 });
 
+test("pauseAuto marks paused and cancels the in-flight unit before first await", async () => {
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.currentUnit = {
+    type: "execute-task",
+    id: "M001/S01/T01",
+    startedAt: 500,
+  };
+  let cancelledResult: unknown;
+  _setCurrentResolve((result) => {
+    cancelledResult = result;
+  });
+
+  try {
+    const pausePromise = pauseAuto();
+
+    assert.equal(autoSession.paused, true);
+    assert.deepEqual(cancelledResult, { status: "cancelled" });
+
+    await pausePromise.catch(() => {});
+  } finally {
+    _resetPendingResolve();
+    autoSession.reset();
+  }
+});
+
 test("transient-abort errorContext is not classified as pause-origin cancellation", () => {
   // The phases.ts fix passes unitResult.errorContext to pauseAuto for transient aborts.
   // _isPauseOriginCancelledResult must return false when errorContext is present, ensuring
@@ -74,3 +101,77 @@ test("transient-abort errorContext is not classified as pause-origin cancellatio
     "not paused = not pause-origin regardless of errorContext",
   );
 });
+
+test("pauseAuto ignores stale pre-dispatch pause once a new unit is active", async () => {
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.currentUnit = {
+    type: "research-slice",
+    id: "M011/S05",
+    startedAt: 500,
+  };
+
+  try {
+    await pauseAuto(undefined, undefined, undefined, { expectedCurrentUnit: null });
+
+    assert.equal(autoSession.active, true);
+    assert.equal(autoSession.paused, false);
+    assert.deepEqual(autoSession.currentUnit, {
+      type: "research-slice",
+      id: "M011/S05",
+      startedAt: 500,
+    });
+  } finally {
+    autoSession.reset();
+  }
+});
+
+test("pauseAuto ignores stale pause for a superseded unit identity", async () => {
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.currentUnit = {
+    type: "research-slice",
+    id: "M011/S05",
+    startedAt: 500,
+  };
+
+  try {
+    await pauseAuto(undefined, undefined, undefined, {
+      expectedCurrentUnit: {
+        type: "plan-slice",
+        id: "M011/S04",
+        startedAt: 100,
+      },
+    });
+
+    assert.equal(autoSession.active, true);
+    assert.equal(autoSession.paused, false);
+    assert.deepEqual(autoSession.currentUnit, {
+      type: "research-slice",
+      id: "M011/S05",
+      startedAt: 500,
+    });
+  } finally {
+    autoSession.reset();
+  }
+});
+
+test("pauseAuto still pauses when the expected unit identity matches", async () => {
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.currentUnit = {
+    type: "research-slice",
+    id: "M011/S05",
+    startedAt: 500,
+  };
+  const expectedCurrentUnit = capturePauseAutoUnitIdentity();
+
+  try {
+    await pauseAuto(undefined, undefined, undefined, { expectedCurrentUnit });
+
+    assert.equal(autoSession.active, false);
+    assert.equal(autoSession.paused, true);
+  } finally {
+    autoSession.reset();
+  }
+});

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Behavior tests for auto-loop cleanup after paused provider exits.
 import { test } from "node:test";
 import assert from "node:assert/strict";

package/src/resources/extensions/gsd/tests/auto-phases-lifecycle.test.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Auto-loop phase lifecycle regression tests.
 import test from "node:test";
 import assert from "node:assert/strict";
@@ -7,7 +7,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { runFinalize } from "../auto/phases.ts";
+import { resolveDispatchRecoveryAttempts, runFinalize } from "../auto/phases.ts";
 import { AutoSession } from "../auto/session.ts";
 import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "../unit-runtime.ts";
 import { captureRootDirtySnapshot } from "../root-write-leak-guard.ts";
@@ -25,6 +25,26 @@ function initRepo(root: string): void {
   runGit(root, ["commit", "-m", "chore: init"]);
 }
 
+test("resolveDispatchRecoveryAttempts preserves cross-session recovery attempts before in-session recovery", () => {
+  const recoveryCounts = new Map<string, number>();
+
+  assert.equal(
+    resolveDispatchRecoveryAttempts(recoveryCounts, "execute-task", "M001/S01/T01"),
+    undefined,
+  );
+});
+
+test("resolveDispatchRecoveryAttempts resets after recovery ran in the current session", () => {
+  const recoveryCounts = new Map<string, number>([
+    ["execute-task/M001/S01/T01", 1],
+  ]);
+
+  assert.equal(
+    resolveDispatchRecoveryAttempts(recoveryCounts, "execute-task", "M001/S01/T01"),
+    0,
+  );
+});
+
 async function runSuccessfulFinalize(s: AutoSession) {
   const unit = s.currentUnit;
   assert.ok(unit, "test setup must provide currentUnit");

package/src/resources/extensions/gsd/tests/auto-post-unit-step-message.test.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Tests for step-mode completion messages in auto-post-unit.
 
 import test from "node:test";

package/src/resources/extensions/gsd/tests/auto-project-root-env.test.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Behavior tests for auto-mode project-root environment cleanup.
 import test from "node:test";
 import assert from "node:assert/strict";