@opengsd/gsd-pi 1.4.0 → 1.5.0-dev.553dc518

package/src/resources/extensions/gsd/tests/prefs-wizard-coverage.test.ts

@@ -79,6 +79,11 @@ const PREF_SAMPLE_VALUES: Record<string, unknown> = {
   min_request_interval_ms: 250,
   stale_commit_threshold_minutes: 15,
   context_management: { enabled: true },
+  tool_call_loop_guard: {
+    enabled: true,
+    identical_args: { enabled: true, max_consecutive_calls: 4 },
+    repeated_tool: { enabled: true, default_cap: 6, repeatable_cap: 15, exempt_tools: ["ctx_execute"] },
+  },
   experimental: { rtk: true },
   codebase: { indexing: "auto" },
   slice_parallel: { enabled: true, max_workers: 2 },
@@ -182,6 +187,70 @@ test("prefs wizard save path preserves every known preference key", async () =>
   }
 });
 
+test("verification wizard prompts for per-unit cost cap and persists it (regression #1121)", async () => {
+  // Regression for #1121: the `/gsd prefs` Verification category never prompted for
+  // `per_unit_cost_cap_usd`, so the per-unit cost cap could only be set by hand-editing
+  // PREFERENCES.md. Drive the wizard into Verification, answer the cap prompt, and assert
+  // the prompt exists and the entered value is serialized + round-trips back as a number.
+  const dir = mkdtempSync(join(tmpdir(), "gsd-prefs-wizard-"));
+  const prefsPath = join(dir, "PREFERENCES.md");
+
+  const inputLabels: string[] = [];
+  let topMenuVisits = 0;
+
+  const ctx = {
+    ui: {
+      notify() {},
+      select: async (label: string, options: string[]) => {
+        if (label === "GSD Preferences") {
+          topMenuVisits += 1;
+          if (topMenuVisits === 1) {
+            const verification = options.find((o) => o.startsWith("Verification"));
+            assert.ok(verification, "wizard menu must offer a Verification category");
+            return verification;
+          }
+          return "── Save & Exit ──";
+        }
+        // verification_commands string-list sub-menu — leave it untouched
+        if (options.includes("Done")) return "Done";
+        // boolean/enum prompts within the category — keep the current value
+        if (options.includes("(keep current)")) return "(keep current)";
+        return options[options.length - 1];
+      },
+      input: async (label: string) => {
+        inputLabels.push(label);
+        if (label.includes("Per-unit cost cap")) return "12.5";
+        return null; // escape every other numeric/string prompt (no change)
+      },
+    },
+    waitForIdle: async () => {},
+    reload: async () => {},
+  } as any;
+
+  try {
+    await handlePrefsWizard(ctx, "project", {}, { pathOverride: prefsPath });
+
+    // The Verification wizard must actually ask for the per-unit cost cap.
+    assert.ok(
+      inputLabels.some((l) => l.includes("Per-unit cost cap")),
+      `Verification wizard must prompt for the per-unit cost cap; prompts seen:\n${inputLabels.join("\n")}`,
+    );
+
+    // The entered value must be serialized to PREFERENCES.md...
+    const saved = readFileSync(prefsPath, "utf-8");
+    assert.match(saved, /per_unit_cost_cap_usd:\s*12\.5(\s|$)/m);
+
+    // ...and round-trip back through the parser/validator as a number.
+    const parsed = parsePreferencesMarkdown(saved);
+    assert.notEqual(parsed, null);
+    const { errors, preferences } = validatePreferences(parsed!);
+    assert.deepEqual(errors, []);
+    assert.equal(preferences.per_unit_cost_cap_usd, 12.5);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test("category summaries expose the wizard menu surface for configured prefs", () => {
   const summaries = buildCategorySummaries(PREF_SAMPLE_VALUES);
   assert.deepEqual(
@@ -203,11 +272,14 @@ test("category summaries expose the wizard menu surface for configured prefs", (
       "timeouts",
       "uok",
       "verification",
+      "workspace",
     ],
   );
   assert.match(summaries.models, /phase/);
   assert.match(summaries.integrations, /remote: C123/);
   assert.match(summaries.verification, /1 cmd/);
+  assert.match(summaries.workspace, /mode: parent/);
+  assert.match(summaries.workspace, /1 repo/);
 });
 
 test("models wizard offers discovered models for enabled providers", async () => {
@@ -276,3 +348,78 @@ test("models wizard offers discovered models for enabled providers", async () =>
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test("workspace wizard category configures parent mode with a declared repository", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-prefs-wizard-workspace-"));
+  const prefsPath = join(dir, "PREFERENCES.md");
+  try {
+    // Drive: Workspace → parent mode → Add repository (id=frontend, path=frontend,
+    // role=ui, verification=npm test, commit policy auto) → Done → Save & Exit.
+    const selects = [
+      "Workspace       (single-repo)",       // pick the Workspace category
+      "parent",                               // promptEnum: workspace mode
+      "Add repository",                       // sub-menu
+      "(keep current)",                       // promptEnum: commit policy -> keep auto default
+      "Done",                                 // exit repo sub-menu
+      "── Save & Exit ──",                    // exit wizard
+    ];
+    const inputs = [
+      "frontend",                             // repository id
+      "frontend",                             // repository path
+      "ui",                                   // role
+      "npm test",                             // verification commands
+    ];
+    const ctx = {
+      ui: {
+        notify() {},
+        select: async () => selects.shift(),
+        input: async () => inputs.shift(),
+      },
+      waitForIdle: async () => {},
+      reload: async () => {},
+    } as any;
+
+    await handlePrefsWizard(ctx, "project", {}, { pathOverride: prefsPath });
+
+    const saved = readFileSync(prefsPath, "utf-8");
+    assert.match(saved, /mode: parent/);
+    assert.match(saved, /frontend:/);
+    assert.match(saved, /path: frontend/);
+    assert.match(saved, /role: ui/);
+    assert.match(saved, /npm test/);
+    assert.equal(selects.length, 0, "all queued selects should be consumed");
+    assert.equal(inputs.length, 0, "all queued inputs should be consumed");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("workspace wizard does not save parent mode when no repository is declared", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-prefs-wizard-workspace-empty-"));
+  const prefsPath = join(dir, "PREFERENCES.md");
+  try {
+    // parent mode with no repos added → should warn and not persist workspace.
+    const selects = [
+      "Workspace       (single-repo)",
+      "parent",
+      "Done",                                 // add nothing
+      "── Save & Exit ──",
+    ];
+    const ctx = {
+      ui: {
+        notify() {},
+        select: async () => selects.shift(),
+        input: async () => "",
+      },
+      waitForIdle: async () => {},
+      reload: async () => {},
+    } as any;
+
+    await handlePrefsWizard(ctx, "project", {}, { pathOverride: prefsPath });
+
+    const saved = readFileSync(prefsPath, "utf-8");
+    assert.doesNotMatch(saved, /mode: parent/, "parent mode must not persist without a declared repo");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

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-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");
+});

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

@@ -1,14 +1,22 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
 
 import { autoSession } from "../auto-runtime-state.ts";
 import { registerHooks } from "../bootstrap/register-hooks.ts";
 import { resetToolCallLoopGuard } from "../bootstrap/tool-call-loop-guard.ts";
+import { readUnitHarnessAbort } from "../unit-runtime.ts";
 
 type Handler = (event: any, ctx?: any) => Promise<any> | any;
 
 function makeHookHarness(): {
   emitToolCall: (toolName: string, input: Record<string, unknown>) => Promise<any>;
+  emitToolResult: (event: Record<string, unknown>) => Promise<void>;
+  emitToolExecutionEnd: (event: Record<string, unknown>) => Promise<void>;
+  emitAgentEnd: (event: Record<string, unknown>) => Promise<void>;
 } {
   const handlers = new Map<string, Handler[]>();
   const pi = {
@@ -33,9 +41,38 @@ function makeHookHarness(): {
       assert.ok(loopGuardHandler, "loop-guard tool_call handler should be registered");
       return loopGuardHandler({ toolCallId: `loop-${callId}`, toolName, input }, ctx);
     },
+    async emitToolResult(event: Record<string, unknown>): Promise<void> {
+      callId += 1;
+      for (const handler of handlers.get("tool_result") ?? []) {
+        await handler({
+          toolCallId: `result-${callId}`,
+          ...event,
+        }, ctx);
+      }
+    },
+    async emitToolExecutionEnd(event: Record<string, unknown>): Promise<void> {
+      callId += 1;
+      for (const handler of handlers.get("tool_execution_end") ?? []) {
+        await handler({
+          toolCallId: `exec-${callId}`,
+          ...event,
+        }, ctx);
+      }
+    },
+    async emitAgentEnd(event: Record<string, unknown>): Promise<void> {
+      for (const handler of handlers.get("agent_end") ?? []) {
+        await handler(event, ctx);
+      }
+    },
   };
 }
 
+function makeRuntimeBase(): string {
+  const base = join(tmpdir(), `gsd-hook-runtime-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
 test("register-hooks keeps loop-guard block reason interactive outside auto-mode", async (t) => {
   autoSession.reset();
   resetToolCallLoopGuard();
@@ -101,3 +138,241 @@ test("register-hooks rewrites loop-guard block reason for auto-mode per-tool blo
   assert.match(block.reason, /auto-mode recovery\/replan path/);
   assert.doesNotMatch(block.reason, /respond to the user in text/);
 });
+
+test("register-hooks does not record normal product tool failures as harness aborts", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "gate-evaluate", id: "M001/S01/gates+Q3", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "mcp__gsd-workflow__browser_click",
+    isError: true,
+    result: {
+      content: [{ type: "text", text: "Element not found: #submit" }],
+    },
+  });
+
+  const abort = readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt);
+  assert.equal(abort, null);
+});
+
+test("register-hooks does not classify normal gsd_uat_exec nonzero exits as harness aborts", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "run-uat", id: "M001/S01", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "gsd_uat_exec",
+    isError: true,
+    result: {
+      content: [{ type: "text", text: "gsd_exec[exec-1] runtime=bash exit=1 duration=12ms" }],
+      details: {
+        operation: "gsd_uat_exec",
+        exit_code: 1,
+        aborted: false,
+        force_resolved: false,
+      },
+    },
+  });
+
+  const abort = readUnitHarnessAbort(base, "run-uat", "M001/S01", startedAt);
+  assert.equal(abort, null);
+});
+
+test("register-hooks records exec deadline timeouts as harness aborts", async () => {
+  for (const scenario of [
+    { toolName: "gsd_exec", unitType: "gate-evaluate", unitId: "M001/S01/gates+Q3" },
+    { toolName: "gsd_uat_exec", unitType: "run-uat", unitId: "M001/S01" },
+  ]) {
+    const base = makeRuntimeBase();
+    const startedAt = Date.now();
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    autoSession.active = true;
+    autoSession.basePath = base;
+    autoSession.currentUnit = { type: scenario.unitType, id: scenario.unitId, startedAt };
+
+    try {
+      const { emitToolExecutionEnd } = makeHookHarness();
+      await emitToolExecutionEnd({
+        toolName: scenario.toolName,
+        isError: true,
+        result: {
+          content: [{ type: "text", text: "gsd_exec[exec-timeout] runtime=bash timeout duration=600000ms" }],
+          details: {
+            operation: scenario.toolName,
+            exit_code: null,
+            aborted: false,
+            force_resolved: false,
+            timed_out: true,
+          },
+        },
+      });
+
+      const abort = readUnitHarnessAbort(base, scenario.unitType, scenario.unitId, startedAt);
+      assert.equal(abort?.kind, "tool-error");
+      assert.equal(abort?.toolName, scenario.toolName);
+      assert.match(abort?.reason ?? "", /timeout/);
+    } finally {
+      autoSession.reset();
+      resetToolCallLoopGuard();
+      rmSync(base, { recursive: true, force: true });
+    }
+  }
+});
+
+test("register-hooks preserves retryable harness abort after later successful tools", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "run-uat", id: "M001/S01", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd, emitToolResult } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "mcp__gsd-workflow__browser_click",
+    isError: true,
+    result: {
+      content: [{ type: "text", text: "No such tool available: browser_click" }],
+    },
+  });
+
+  const recorded = readUnitHarnessAbort(base, "run-uat", "M001/S01", startedAt);
+  assert.equal(recorded?.kind, "tool-error");
+
+  await emitToolResult({
+    toolName: "read",
+    isError: false,
+    input: { path: "README.md" },
+    result: {
+      content: [{ type: "text", text: "file contents" }],
+    },
+  });
+  assert.equal(
+    readUnitHarnessAbort(base, "run-uat", "M001/S01", startedAt)?.kind,
+    "tool-error",
+    "successful native tool_result must not clear the harness abort",
+  );
+
+  await emitToolExecutionEnd({
+    toolName: "read",
+    isError: false,
+    result: {
+      content: [{ type: "text", text: "file contents" }],
+    },
+  });
+  assert.equal(
+    readUnitHarnessAbort(base, "run-uat", "M001/S01", startedAt)?.kind,
+    "tool-error",
+    "successful universal tool_execution_end must not clear the harness abort",
+  );
+});
+
+test("register-hooks does not record save-tool validation errors as harness aborts", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "run-uat", id: "M001/S01", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "gsd_uat_result_save",
+    isError: true,
+    result: {
+      content: [{ type: "text", text: "Error: UAT Assessment requires at least one fresh gsd_uat_exec evidence reference" }],
+      details: { operation: "save_uat_result", error: "uat_missing_fresh_evidence" },
+    },
+  });
+
+  const abort = readUnitHarnessAbort(base, "run-uat", "M001/S01", startedAt);
+  assert.equal(abort, null);
+});
+
+test("register-hooks does not record pending approval hard-blocks as harness aborts", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "gate-evaluate", id: "M001/S01/gates+Q3", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitToolExecutionEnd } = makeHookHarness();
+  await emitToolExecutionEnd({
+    toolName: "gsd_summary_save",
+    isError: true,
+    result: {
+      content: [{
+        type: "text",
+        text: 'HARD BLOCK: Discussion gate "depth:M001" has not been confirmed by the user.',
+      }],
+    },
+  });
+
+  const abort = readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt);
+  assert.equal(abort, null);
+});
+
+test("register-hooks only records agent_end turn aborts for aborted or error stop reasons", async (t) => {
+  const base = makeRuntimeBase();
+  const startedAt = Date.now();
+  autoSession.reset();
+  resetToolCallLoopGuard();
+  autoSession.active = true;
+  autoSession.basePath = base;
+  autoSession.currentUnit = { type: "gate-evaluate", id: "M001/S01/gates+Q3", startedAt };
+  t.after(() => {
+    autoSession.reset();
+    resetToolCallLoopGuard();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const { emitAgentEnd } = makeHookHarness();
+  await emitAgentEnd({
+    abortOrigin: "auto-context",
+    messages: [{ stopReason: "stop" }],
+  });
+
+  const abort = readUnitHarnessAbort(base, "gate-evaluate", "M001/S01/gates+Q3", startedAt);
+  assert.equal(abort, null);
+});