gsd-pi 2.79.0 → 2.80.0-dev.b62439b9f

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

@@ -1,3 +1,5 @@
+// GSD Extension — Auto recovery integration tests.
+
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, existsSync, readFileSync, rmSync, chmodSync } from "node:fs";
@@ -401,6 +403,57 @@ test("verifyExpectedArtifact plan-slice fails for plan with no tasks (#699)", (t
   assert.equal(result, false, "should fail when plan has no task entries (empty scaffold, #699)");
 });
 
+test("verifyExpectedArtifact plan-slice trusts DB tasks over legacy plan syntax", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    closeDatabase();
+    cleanup(base);
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  insertTask({ id: "T02", milestoneId: "M001", sliceId: "S01", title: "Second task", status: "pending" });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    "# S01: Slice\n\n## Tasks\n\nTask rows live in the DB; this projection intentionally has no legacy task syntax.\n",
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan\n");
+
+  const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+  assert.equal(result, true, "DB task rows plus task plan files should verify plan-slice");
+});
+
+test("verifyExpectedArtifact plan-slice still fails when a DB-backed task plan file is missing", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    closeDatabase();
+    cleanup(base);
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Milestone", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  insertTask({ id: "T02", milestoneId: "M001", sliceId: "S01", title: "Second task", status: "pending" });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  writeFileSync(
+    join(sliceDir, "S01-PLAN.md"),
+    "# S01: Slice\n\n## Tasks\n\nTask rows live in the DB; this projection intentionally has no legacy task syntax.\n",
+  );
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+
+  const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
+  assert.equal(result, false, "DB task rows must still require matching task plan files");
+});
+
 // ─── verifyExpectedArtifact: heading-style plan tasks (#1691) ─────────────
 
 test("verifyExpectedArtifact accepts plan-slice with heading-style tasks (### T01 --)", (t) => {
@@ -456,6 +509,32 @@ test("verifyExpectedArtifact accepts plan-slice with colon-style heading tasks (
   );
 });
 
+test("verifyExpectedArtifact accepts indented legacy plan-slice task markers", (t) => {
+  const base = makeTmpBase();
+  t.after(() => cleanup(base));
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+    "# S01: Test Slice",
+    "",
+    "## Tasks",
+    "",
+    "  - [ ] **T01: Implement feature** `est:1h`",
+    "",
+    "  ### T02 -- Write tests",
+  ].join("\n"));
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+  writeFileSync(join(tasksDir, "T02-PLAN.md"), "# T02 Plan");
+
+  assert.strictEqual(
+    verifyExpectedArtifact("plan-slice", "M001/S01", base),
+    true,
+    "Indented legacy task markers should be treated as completed plan-slice artifacts",
+  );
+});
+
 test("verifyExpectedArtifact execute-task rejects heading-style plan without checked checkbox (#3607)", (t) => {
   const base = makeTmpBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -24,6 +24,7 @@ import {
 } from "../../auto-worktree.ts";
 import { getSliceBranchName } from "../../worktree.ts";
 import { nativeMergeSquash } from "../../native-git-bridge.ts";
+import { drainLogs, setStderrLoggingEnabled } from "../../workflow-logger.ts";
 
 function run(cmd: string, cwd: string): string {
   // Safe: all inputs are hardcoded test strings, not user input
@@ -251,6 +252,42 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
     assert.strictEqual(typeof result.pushed, "boolean", "pushed flag remains boolean");
   });
 
+  test("external .gsd and local-only auto_push closeout without cleanup or push warnings", () => {
+    const { repo, externalState } = freshRepoWithExternalGsd();
+    const previousStderr = setStderrLoggingEnabled(false);
+    drainLogs();
+
+    try {
+      writeFileSync(
+        join(externalState, "PREFERENCES.md"),
+        "---\nversion: 1\n---\n\ngit:\n  auto_push: true\n",
+      );
+      mkdirSync(join(externalState, "milestones", "M041"), { recursive: true });
+      mkdirSync(join(externalState, "runtime", "units"), { recursive: true });
+      writeFileSync(join(externalState, "runtime", "units", "leftover.json"), "{}\n");
+
+      const wtPath = createAutoWorktree(repo, "M041");
+      addSliceToMilestone(repo, wtPath, "M041", "S01", "Local-only push", [
+        { file: "local-only.ts", content: "export const localOnly = true;\n", message: "add local only file" },
+      ]);
+
+      const roadmap = makeRoadmap("M041", "Local-only closeout", [
+        { id: "S01", title: "Local-only push" },
+      ]);
+
+      const result = mergeMilestoneToMain(repo, "M041", roadmap);
+      const logs = drainLogs();
+      const messages = logs.map((entry) => entry.message).join("\n");
+
+      assert.equal(result.pushed, false, "local-only repo should not report pushed");
+      assert.ok(!messages.includes("untracked file cleanup failed"), "external .gsd cleanup should not call git on paths outside the repo");
+      assert.ok(!messages.includes("git push failed"), "missing origin should skip auto-push instead of running git push");
+    } finally {
+      drainLogs();
+      setStderrLoggingEnabled(previousStderr);
+    }
+  });
+
   test("auto-resolve .gsd/ state file conflicts", () => {
     const repo = freshRepo();
     const wtPath = createAutoWorktree(repo, "M050");

package/src/resources/extensions/gsd/tests/integration/state-machine-live-validation.test.ts

@@ -575,7 +575,7 @@ describe("state-machine-live-validation", () => {
       assert.match((result as any).error, /verification did not pass/);
     });
 
-    test("double milestone completion returns error", async () => {
+    test("double milestone completion is idempotent", async () => {
       base = createFullFixture();
       openDatabase(join(base, ".gsd", "gsd.db"));
       insertMilestone({ id: "M001", title: "Done", status: "complete" });
@@ -583,8 +583,10 @@ describe("state-machine-live-validation", () => {
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "complete" });
 
       const result = await handleCompleteMilestone(makeMilestoneParams("M001") as any, base);
-      assert.ok("error" in result);
-      assert.match((result as any).error, /already complete/);
+      assert.ok(!("error" in result), `already-complete milestone should be accepted: ${JSON.stringify(result)}`);
+      assert.equal(result.alreadyComplete, true);
+      assert.match(result.summaryPath, /M001-SUMMARY\.md$/);
+      assert.ok(isClosedStatus(getMilestone("M001")!.status), "milestone remains closed");
     });
   });
 

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -399,6 +399,140 @@ test("runDispatch pauses when complete-milestone summary exists on disk but the
   assert.equal(stopCalls, 0, "mismatch pause should not hard-stop the loop");
 });
 
+test("runDispatch clears stuck state after Level 1 artifact recovery", async (t) => {
+  const capture = createEventCapture();
+  let invalidateCalls = 0;
+  let stopCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-plan-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01\n\n## Tasks\n\n- [ ] **T01: First task** `est:1h`\n");
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+
+  const deps = makeMockDeps(capture, {
+    invalidateAllCaches: () => { invalidateCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "plan-slice",
+      unitId: "M001/S01",
+      prompt: "plan the slice",
+      matchedRule: "planning → plan-slice",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "planning",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "plan-slice/M001/S01" },
+      { key: "plan-slice/M001/S01" },
+    ],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "continue");
+  assert.equal(invalidateCalls, 1, "Level 1 artifact recovery should invalidate caches");
+  assert.equal(stopCalls, 0, "Level 1 artifact recovery should not hard-stop");
+  assert.deepEqual(loopState.recentUnits, [], "Level 1 artifact recovery should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 0, "Level 1 artifact recovery should reset the recovery counter");
+});
+
+test("runDispatch escapes Level 2 stuck stop when artifact verifies after cache invalidation", async (t) => {
+  const capture = createEventCapture();
+  let invalidateCalls = 0;
+  let stopCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-plan-l2-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01\n\n## Tasks\n\n- [ ] **T01: First task** `est:1h`\n");
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+
+  const deps = makeMockDeps(capture, {
+    invalidateAllCaches: () => { invalidateCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "plan-slice",
+      unitId: "M001/S01",
+      prompt: "plan the slice",
+      matchedRule: "planning → plan-slice",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "planning",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "plan-slice/M001/S01" },
+      { key: "plan-slice/M001/S01" },
+    ],
+    stuckRecoveryAttempts: 1,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "continue");
+  assert.equal(invalidateCalls, 1, "Level 2 escape should invalidate caches before rechecking artifacts");
+  assert.equal(stopCalls, 0, "verified artifacts should escape Level 2 hard stop");
+  assert.deepEqual(loopState.recentUnits, [], "Level 2 artifact escape should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 0, "Level 2 artifact escape should reset the recovery counter");
+});
+
 test("runUnitPhase emits unit-start and unit-end with causedBy reference", async () => {
   const capture = createEventCapture();
 

package/src/resources/extensions/gsd/tests/legacy-component-format-telemetry.test.ts

@@ -0,0 +1,62 @@
+// Project/App: GSD-2
+// File Purpose: Verifies telemetry for legacy component formats.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { loadComponentFromAgentFile, loadComponentFromDir } from "../component-loader.js";
+import { getLegacyTelemetry, resetLegacyTelemetry } from "../legacy-telemetry.js";
+
+function makeTempDir(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-legacy-component-format-"));
+}
+
+test("legacy component telemetry counts successful skill and agent format loads", () => {
+  const dir = makeTempDir();
+  try {
+    resetLegacyTelemetry();
+
+    const modernDir = join(dir, "modern-skill");
+    mkdirSync(modernDir, { recursive: true });
+    writeFileSync(join(modernDir, "component.yaml"), `
+apiVersion: gsd/v1
+kind: skill
+metadata:
+  name: modern-skill
+  description: "Modern skill"
+spec:
+  prompt: SKILL.md
+`, "utf-8");
+    writeFileSync(join(modernDir, "SKILL.md"), "Modern content.", "utf-8");
+    assert.ok(loadComponentFromDir(modernDir, "user").component);
+    assert.equal(getLegacyTelemetry()["legacy.componentFormatUsed"], 0);
+
+    const legacySkillDir = join(dir, "legacy-skill");
+    mkdirSync(legacySkillDir, { recursive: true });
+    writeFileSync(join(legacySkillDir, "SKILL.md"), `---
+name: legacy-skill
+description: Legacy skill
+---
+Skill content.
+`, "utf-8");
+    assert.ok(loadComponentFromDir(legacySkillDir, "user").component);
+    assert.equal(getLegacyTelemetry()["legacy.componentFormatUsed"], 1);
+
+    const legacyAgentFile = join(dir, "legacy-agent.md");
+    writeFileSync(legacyAgentFile, `---
+name: legacy-agent
+description: Legacy agent
+tools: read, grep
+---
+Agent content.
+`, "utf-8");
+    assert.ok(loadComponentFromAgentFile(legacyAgentFile, "user").component);
+    assert.equal(getLegacyTelemetry()["legacy.componentFormatUsed"], 2);
+  } finally {
+    resetLegacyTelemetry();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/legacy-telemetry.test.ts

@@ -0,0 +1,144 @@
+// Project/App: GSD-2
+// File Purpose: Tests for telemetry counters guarding legacy compatibility cleanup.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  getLegacyTelemetryReport,
+  getLegacyTelemetry,
+  incrementLegacyTelemetry,
+  listLegacyTelemetryCounters,
+  persistLegacyTelemetrySnapshot,
+  resetLegacyTelemetry,
+} from "../legacy-telemetry.ts";
+import { closeDatabase } from "../gsd-db.ts";
+import { deriveState, invalidateStateCache } from "../state.ts";
+import { _resetLogs, peekLogs, setStderrLoggingEnabled } from "../workflow-logger.ts";
+
+test("legacy telemetry exposes every Phase 8 cleanup counter", () => {
+  resetLegacyTelemetry();
+
+  assert.deepEqual(listLegacyTelemetryCounters(), [
+    "legacy.markdownFallbackUsed",
+    "legacy.workflowEngineUsed",
+    "legacy.uokFallbackUsed",
+    "legacy.mcpAliasUsed",
+    "legacy.componentFormatUsed",
+    "legacy.providerDefaultUsed",
+  ]);
+  assert.equal(getLegacyTelemetry()["legacy.markdownFallbackUsed"], 0);
+});
+
+test("legacy telemetry increments positive finite amounts only", () => {
+  resetLegacyTelemetry();
+
+  incrementLegacyTelemetry("legacy.workflowEngineUsed");
+  incrementLegacyTelemetry("legacy.workflowEngineUsed", 2);
+  incrementLegacyTelemetry("legacy.workflowEngineUsed", 0);
+  incrementLegacyTelemetry("legacy.workflowEngineUsed", Number.NaN);
+
+  assert.equal(getLegacyTelemetry()["legacy.workflowEngineUsed"], 3);
+});
+
+test("legacy telemetry emits one actionable diagnostic per counter", () => {
+  const previousStderr = setStderrLoggingEnabled(false);
+  try {
+    resetLegacyTelemetry();
+    _resetLogs();
+
+    incrementLegacyTelemetry("legacy.mcpAliasUsed");
+    incrementLegacyTelemetry("legacy.mcpAliasUsed");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1);
+    assert.equal(logs[0]?.component, "migration");
+    assert.equal(logs[0]?.context?.counter, "legacy.mcpAliasUsed");
+    assert.match(logs[0]?.message ?? "", /canonical gsd_\* tool name/);
+  } finally {
+    _resetLogs();
+    resetLegacyTelemetry();
+    setStderrLoggingEnabled(previousStderr);
+  }
+});
+
+test("legacy telemetry can persist an opt-in snapshot file", () => {
+  const previousStderr = setStderrLoggingEnabled(false);
+  const previousOutput = process.env.GSD_LEGACY_TELEMETRY_FILE;
+  const base = mkdtempSync(join(tmpdir(), "gsd-legacy-telemetry-file-"));
+  const outputPath = join(base, "runtime", "legacy-telemetry.json");
+  try {
+    resetLegacyTelemetry();
+    _resetLogs();
+    process.env.GSD_LEGACY_TELEMETRY_FILE = outputPath;
+
+    incrementLegacyTelemetry("legacy.providerDefaultUsed", 2);
+
+    const report = JSON.parse(readFileSync(outputPath, "utf-8")) as ReturnType<typeof getLegacyTelemetryReport>;
+    assert.equal(typeof report.ts, "string");
+    assert.equal(report.counters["legacy.providerDefaultUsed"], 2);
+    assert.equal(report.counters["legacy.markdownFallbackUsed"], 0);
+  } finally {
+    if (previousOutput === undefined) delete process.env.GSD_LEGACY_TELEMETRY_FILE;
+    else process.env.GSD_LEGACY_TELEMETRY_FILE = previousOutput;
+    _resetLogs();
+    resetLegacyTelemetry();
+    setStderrLoggingEnabled(previousStderr);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("legacy telemetry can persist a zero-use snapshot for deletion gates", () => {
+  const previousOutput = process.env.GSD_LEGACY_TELEMETRY_FILE;
+  const base = mkdtempSync(join(tmpdir(), "gsd-legacy-zero-telemetry-"));
+  const outputPath = join(base, "legacy-telemetry.json");
+  try {
+    resetLegacyTelemetry();
+    process.env.GSD_LEGACY_TELEMETRY_FILE = outputPath;
+
+    persistLegacyTelemetrySnapshot();
+
+    const report = JSON.parse(readFileSync(outputPath, "utf-8")) as ReturnType<typeof getLegacyTelemetryReport>;
+    assert.equal(typeof report.ts, "string");
+    assert.deepEqual(report.counters, {
+      "legacy.markdownFallbackUsed": 0,
+      "legacy.workflowEngineUsed": 0,
+      "legacy.uokFallbackUsed": 0,
+      "legacy.mcpAliasUsed": 0,
+      "legacy.componentFormatUsed": 0,
+      "legacy.providerDefaultUsed": 0,
+    });
+  } finally {
+    if (previousOutput === undefined) delete process.env.GSD_LEGACY_TELEMETRY_FILE;
+    else process.env.GSD_LEGACY_TELEMETRY_FILE = previousOutput;
+    resetLegacyTelemetry();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("deriveState increments markdown fallback telemetry on explicit legacy fallback", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-legacy-telemetry-"));
+  const originalFallback = process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK;
+  try {
+    closeDatabase();
+    resetLegacyTelemetry();
+    invalidateStateCache();
+    process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK = "1";
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001: Legacy\n");
+
+    const state = await deriveState(base);
+
+    assert.equal(state.activeMilestone?.id, "M001");
+    assert.equal(getLegacyTelemetry()["legacy.markdownFallbackUsed"], 1);
+  } finally {
+    invalidateStateCache();
+    resetLegacyTelemetry();
+    if (originalFallback === undefined) delete process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK;
+    else process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK = originalFallback;
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/memory-pressure-stuck-state.test.ts

@@ -9,16 +9,36 @@ import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { decideMemoryPressure } from "../auto/workflow-kernel.ts";
+import { measureMemoryPressure } from "../auto/workflow-memory-pressure.ts";
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const loopSource = readFileSync(join(__dirname, "..", "auto", "loop.ts"), "utf-8");
 
 describe("memory pressure monitoring (#3331)", () => {
-  test("checkMemoryPressure function exists", () => {
-    assert.match(loopSource, /function checkMemoryPressure/);
+  test("measureMemoryPressure reports pressure above threshold", () => {
+    const snapshot = measureMemoryPressure({
+      threshold: 0.5,
+      deps: {
+        memoryUsage: () => ({ heapUsed: 768 * 1024 * 1024 }),
+        heapLimitBytes: () => 1024 * 1024 * 1024,
+      },
+    });
+
+    assert.equal(snapshot.pressured, true);
+    assert.equal(snapshot.heapMB, 768);
+    assert.equal(snapshot.limitMB, 1024);
   });
 
-  test("MEMORY_PRESSURE_THRESHOLD constant is defined", () => {
-    assert.match(loopSource, /MEMORY_PRESSURE_THRESHOLD\s*=\s*0\.\d+/);
+  test("measureMemoryPressure defaults to a sub-100-percent threshold", () => {
+    const snapshot = measureMemoryPressure({
+      deps: {
+        memoryUsage: () => ({ heapUsed: 3584 * 1024 * 1024 }),
+        heapLimitBytes: () => 4096 * 1024 * 1024,
+      },
+    });
+
+    assert.equal(snapshot.pressured, true);
   });
 
   test("memory check runs every MEMORY_CHECK_INTERVAL iterations", () => {
@@ -26,8 +46,16 @@ describe("memory pressure monitoring (#3331)", () => {
   });
 
   test("memory pressure triggers graceful stopAuto", () => {
-    assert.match(loopSource, /mem\.pressured/);
-    assert.match(loopSource, /Stopping gracefully to prevent OOM/);
+    const decision = decideMemoryPressure({
+      pressured: true,
+      heapMB: 3900,
+      limitMB: 4096,
+      pct: 0.95,
+      iteration: 10,
+    });
+
+    assert.equal(decision.action, "stop");
+    assert.match(decision.stopMessage, /Stopping gracefully to prevent OOM/);
   });
 });
 
@@ -55,15 +83,11 @@ describe("stuck detection persistence (#3704)", () => {
   // unit_dispatches (recentUnits) + runtime_kv (stuckRecoveryAttempts).
   // The stuck-state-via-db.test.ts suite covers the round-trip.
 
-  test("saveStuckState called in standard dev path as well as custom engine path (#4382)", () => {
-    // Count all call-sites of saveStuckState (excluding the function definition itself).
-    // After the fix, both the custom-engine path and the standard dev path must each
-    // call saveStuckState so stuckRecoveryAttempts survives session restarts.
-    const callMatches = loopSource.match(/saveStuckState\(s,\s*loopState\)/g) ?? [];
-    assert.ok(
-      callMatches.length >= 2,
-      `saveStuckState must be called in both the custom-engine path and the standard dev path ` +
-      `(found ${callMatches.length} call(s) — standard path is missing its call, #4382)`,
-    );
+  test("completeIteration centralizes stuck-state persistence for both loop paths (#4382)", () => {
+    assert.match(loopSource, /const completeIteration = \(\): void =>/);
+    assert.match(loopSource, /completeWorkflowIteration\(/);
+    assert.match(loopSource, /saveStuckState:\s*\(\)\s*=>\s*saveStuckState\(s,\s*loopState\)/);
+    assert.match(loopSource, /completeIteration,/);
+    assert.match(loopSource, /completeIteration\(\);/);
   });
 });

package/src/resources/extensions/gsd/tests/model-router.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Verifies model routing decisions and legacy provider-default telemetry.
 import test, { describe } from "node:test";
 import assert from "node:assert/strict";
 
@@ -14,6 +16,7 @@ import {
 } from "../model-router.js";
 import type { DynamicRoutingConfig, RoutingDecision, ModelCapabilities } from "../model-router.js";
 import type { ClassificationResult } from "../complexity-classifier.js";
+import { getLegacyTelemetry, resetLegacyTelemetry } from "../legacy-telemetry.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -297,16 +300,28 @@ test("cross-provider: configured primary available by bare ID wins over equivale
 // ─── resolveModelForTier (provider-agnostic tier resolution) ────────────────
 
 test("resolveModelForTier: returns canonical Anthropic model when no available models", () => {
-  assert.equal(resolveModelForTier("heavy", []), "claude-opus-4-6");
-  assert.equal(resolveModelForTier("standard", []), "claude-sonnet-4-6");
-  assert.equal(resolveModelForTier("light", []), "claude-haiku-4-5");
+  try {
+    resetLegacyTelemetry();
+    assert.equal(resolveModelForTier("heavy", []), "claude-opus-4-6");
+    assert.equal(resolveModelForTier("standard", []), "claude-sonnet-4-6");
+    assert.equal(resolveModelForTier("light", []), "claude-haiku-4-5");
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 3);
+  } finally {
+    resetLegacyTelemetry();
+  }
 });
 
 test("resolveModelForTier: returns canonical model when it is available", () => {
-  assert.equal(
-    resolveModelForTier("heavy", ["claude-opus-4-6", "claude-sonnet-4-6"]),
-    "claude-opus-4-6",
-  );
+  try {
+    resetLegacyTelemetry();
+    assert.equal(
+      resolveModelForTier("heavy", ["claude-opus-4-6", "claude-sonnet-4-6"]),
+      "claude-opus-4-6",
+    );
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 0);
+  } finally {
+    resetLegacyTelemetry();
+  }
 });
 
 test("resolveModelForTier: does not prefer canonical over cheaper same-tier model", () => {
@@ -341,11 +356,17 @@ test("resolveModelForTier: picks light-tier cross-provider model", () => {
 });
 
 test("resolveModelForTier: falls back to canonical when no tier match available", () => {
-  // Only unknown models available — getModelTier classifies unknowns as
-  // "standard", so a request for "heavy" finds no match and the canonical
-  // Anthropic ID is returned as a documented fallback.
-  const result = resolveModelForTier("heavy", ["some-custom-model"]);
-  assert.equal(result, "claude-opus-4-6");
+  try {
+    resetLegacyTelemetry();
+    // Only unknown models available — getModelTier classifies unknowns as
+    // "standard", so a request for "heavy" finds no match and the canonical
+    // Anthropic ID is returned as a documented fallback.
+    const result = resolveModelForTier("heavy", ["some-custom-model"]);
+    assert.equal(result, "claude-opus-4-6");
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 1);
+  } finally {
+    resetLegacyTelemetry();
+  }
 });
 
 test("resolveModelForTier: handles provider-prefixed available models", () => {