halfcycle 0.7.1 → 0.8.0

package/bin/bin.bundle.mjs

@@ -5,14 +5,10 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// dist/guard-origin.js
-var DEFAULT_GUARD_ORIGIN = "https://guard.halfcycle.ai";
-function resolveGuardOrigin(env) {
-  const configured = env["GUARD_SERVICE_URL"]?.trim();
-  if (configured)
-    return { origin: configured.replace(/\/+$/, ""), source: "environment" };
-  return { origin: DEFAULT_GUARD_ORIGIN, source: "default" };
-}
+// dist/request-shapes.js
+import { appendFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -3052,13 +3048,13 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     }
     return propValues;
   });
-  const isObject2 = isObject;
+  const isObject3 = isObject;
   const catchall = def.catchall;
   let value;
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject2(input)) {
+    if (!isObject3(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -3185,7 +3181,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     return (payload, ctx) => fn(shape, payload, ctx);
   };
   let fastpass;
-  const isObject2 = isObject;
+  const isObject3 = isObject;
   const jit = !globalConfig.jitless;
   const allowsEval2 = allowsEval;
   const fastEnabled = jit && allowsEval2.value;
@@ -3194,7 +3190,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject2(input)) {
+    if (!isObject3(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -15050,6 +15046,7 @@ var SIGN_IN_COMMAND = '"npx halfcycle"';
 var HOOK_REMEDY = `Run ${SIGN_IN_COMMAND} in the project folder to sign in.`;
 
 // ../core/dist/task-plan.js
+var TASK_PLAN_FILE = "docs/build-records/task-plan.json";
 var AGENT_NAME_MAX = 32;
 var TASK_PLAN_TASKS_MAX = 500;
 var TASK_PLAN_ID_MAX = 64;
@@ -15262,6 +15259,262 @@ var WORKER_REPORT_LINES = Object.freeze({
   clear: () => "The report is complete and names the commit it is about."
 });
 
+// ../core/dist/request-shape.js
+var REQUEST_SHAPES_DIR_NAME = "debug";
+var REQUEST_SHAPES_SWITCH_FILENAME = "request-shapes.on";
+var REQUEST_SHAPES_LOG_FILENAME = "request-shapes.jsonl";
+var REQUEST_SHAPE_MAX_DEPTH = 8;
+var REQUEST_SHAPE_MAX_ARRAY_SHAPES = 10;
+var REQUEST_SHAPE_MAX_KEY_LENGTH = 64;
+var REQUEST_SHAPE_MAX_LINE_BYTES = 16 * 1024;
+var KEY_NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
+var PATH_WORD = /^[a-z-]+$/;
+function byteLength(text) {
+  return new TextEncoder().encode(text).length;
+}
+function keyOf(key) {
+  return key.length <= REQUEST_SHAPE_MAX_KEY_LENGTH && KEY_NAME.test(key) ? key : "<key>";
+}
+function shapeOfValue(value, depth) {
+  if (value === null)
+    return "null";
+  if (typeof value === "string")
+    return "string";
+  if (typeof value === "number")
+    return "number";
+  if (typeof value === "boolean")
+    return "boolean";
+  if (depth > REQUEST_SHAPE_MAX_DEPTH)
+    return "\u2026";
+  if (Array.isArray(value)) {
+    const seen = [];
+    for (const element of value) {
+      if (seen.length >= REQUEST_SHAPE_MAX_ARRAY_SHAPES)
+        break;
+      const shape = shapeOfValue(element, depth + 1);
+      if (!seen.includes(shape))
+        seen.push(shape);
+    }
+    return `[${seen.join("|")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0)
+      return "{}";
+    return `{ ${entries.map(([k, v]) => `${keyOf(k)}: ${shapeOfValue(v, depth + 1)}`).join(", ")} }`;
+  }
+  return "null";
+}
+function requestShapeOf(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return `text ${byteLength(body)} bytes`;
+  }
+  return shapeOfValue(parsed, 1);
+}
+function requestPathShapeOf(pathname) {
+  return pathname.split("/").map((segment) => segment === "" || PATH_WORD.test(segment) ? segment : ":x").join("/");
+}
+function distinct(names) {
+  const out = [];
+  for (const name of names)
+    if (!out.includes(name))
+      out.push(name);
+  return out;
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isRequestLike(value) {
+  return isObject2(value) && !(value instanceof URL) && typeof value["url"] === "string" && typeof value["method"] === "string";
+}
+function headerNamesOf(headers) {
+  if (!isObject2(headers))
+    return [];
+  const names = [];
+  if (Array.isArray(headers)) {
+    for (const pair of headers)
+      if (Array.isArray(pair) && typeof pair[0] === "string")
+        names.push(pair[0].toLowerCase());
+    return names;
+  }
+  const forEach = headers["forEach"];
+  if (typeof forEach === "function") {
+    forEach.call(headers, (_value, key) => {
+      if (typeof key === "string")
+        names.push(key.toLowerCase());
+    });
+    return names;
+  }
+  return Object.keys(headers).map((k) => k.toLowerCase());
+}
+function bytesShape(bytes) {
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return `text ${bytes.byteLength} bytes`;
+  }
+  return requestShapeOf(text);
+}
+function bodyShapeOf(body) {
+  if (body === void 0 || body === null)
+    return null;
+  if (typeof body === "string")
+    return requestShapeOf(body);
+  if (body instanceof URLSearchParams)
+    return `text ${byteLength(body.toString())} bytes`;
+  if (body instanceof ArrayBuffer)
+    return bytesShape(new Uint8Array(body));
+  if (ArrayBuffer.isView(body))
+    return bytesShape(new Uint8Array(body.buffer, body.byteOffset, body.byteLength));
+  if (isObject2(body) && typeof body["size"] === "number" && typeof body["arrayBuffer"] === "function") {
+    return `text ${body["size"]} bytes`;
+  }
+  return "stream";
+}
+function requestLineOf(input, init) {
+  const request = isRequestLike(input) ? input : void 0;
+  const address = request !== void 0 ? request.url : input instanceof URL ? input.href : String(input);
+  let url2;
+  try {
+    url2 = new URL(address);
+  } catch {
+    url2 = void 0;
+  }
+  const options = isObject2(init) ? init : {};
+  const method = (typeof options["method"] === "string" ? options["method"] : request?.method ?? "GET").toUpperCase();
+  const headers = distinct([
+    ...request !== void 0 ? headerNamesOf(request.headers) : [],
+    ...headerNamesOf(options["headers"])
+  ]);
+  const shape = options["body"] !== void 0 && options["body"] !== null ? bodyShapeOf(options["body"]) : request !== void 0 && request.body !== null && request.body !== void 0 ? "stream" : null;
+  return {
+    method,
+    host: url2?.host ?? "",
+    path: url2 !== void 0 ? requestPathShapeOf(url2.pathname) : ":x",
+    query: url2 !== void 0 ? distinct([...url2.searchParams.keys()]) : [],
+    headers,
+    shape
+  };
+}
+function requestShapeLineText(line2) {
+  const ordered = (shape) => JSON.stringify({
+    at: line2.at,
+    process: line2.process,
+    method: line2.method,
+    host: line2.host,
+    path: line2.path,
+    query: line2.query,
+    headers: line2.headers,
+    shape,
+    status: line2.status
+  });
+  const whole = ordered(line2.shape);
+  if (byteLength(whole) <= REQUEST_SHAPE_MAX_LINE_BYTES || line2.shape === null)
+    return whole;
+  const room = REQUEST_SHAPE_MAX_LINE_BYTES - byteLength(ordered("")) - byteLength("\u2026");
+  if (room <= 0)
+    return ordered("\u2026");
+  let end = Math.min(line2.shape.length, room);
+  for (let over = byteLength(line2.shape.slice(0, end)) - room; over > 0; over = byteLength(line2.shape.slice(0, end)) - room) {
+    end -= over;
+  }
+  const prefix = line2.shape.slice(0, Math.max(0, end));
+  const cut = Math.max(prefix.lastIndexOf(", "), prefix.lastIndexOf("|"));
+  return ordered(`${cut > 0 ? prefix.slice(0, cut) : ""}\u2026`);
+}
+
+// dist/request-shapes.js
+var RUNNER_VERB_NAMES = [
+  "ci",
+  "refresh-credential",
+  "observe",
+  "time",
+  "prove",
+  "pace",
+  "statusline",
+  "check-connection",
+  "mcp-headers",
+  "resolve-engagement",
+  "capture"
+];
+var RUNNER_HOOK_NAMES = [
+  "post-tool-use",
+  "stop",
+  "subagent-stop",
+  "pre-tool-use",
+  "user-prompt-submit",
+  "user-prompt-findings"
+];
+var folder = join(homedir(), HALFCYCLE_DIR_NAME, REQUEST_SHAPES_DIR_NAME);
+var logPath = join(folder, REQUEST_SHAPES_LOG_FILENAME);
+var switchedOn = existsSync(join(folder, REQUEST_SHAPES_SWITCH_FILENAME));
+function processName() {
+  const [verb, hook] = process.argv.slice(2);
+  if (verb === "hook" && hook !== void 0 && RUNNER_HOOK_NAMES.includes(hook))
+    return `runner hook ${hook}`;
+  if (verb !== void 0 && verb !== "hook" && RUNNER_VERB_NAMES.includes(verb))
+    return `runner ${verb}`;
+  return "runner other";
+}
+function write(call, status) {
+  if (call === void 0)
+    return;
+  try {
+    const text = requestShapeLineText({ at: (/* @__PURE__ */ new Date()).toISOString(), process: processName(), ...call, status });
+    appendFileSync(logPath, `${text}
+`, { mode: 384 });
+  } catch {
+  }
+}
+function describe3(args2) {
+  try {
+    return requestLineOf(args2[0], args2[1]);
+  } catch {
+    return void 0;
+  }
+}
+function recordChildRequest(address, headerNames, exitedOk) {
+  if (!switchedOn)
+    return;
+  const call = describe3([address, { method: "GET", headers: headerNames.map((name) => [name, ""]) }]);
+  write(call, exitedOk ? "child-ok" : "child-failed");
+}
+if (switchedOn) {
+  const original = globalThis.fetch;
+  if (typeof original === "function") {
+    globalThis.fetch = function recordedFetch(...args2) {
+      const call = describe3(args2);
+      let answer;
+      try {
+        answer = original.apply(this, args2);
+      } catch (err) {
+        write(call, "unreachable");
+        throw err;
+      }
+      return answer.then((res) => {
+        write(call, res.status);
+        return res;
+      }, (err) => {
+        write(call, "unreachable");
+        throw err;
+      });
+    };
+  }
+}
+
+// dist/guard-origin.js
+var DEFAULT_GUARD_ORIGIN = "https://guard.halfcycle.ai";
+function resolveGuardOrigin(env) {
+  const configured = env["GUARD_SERVICE_URL"]?.trim();
+  if (configured)
+    return { origin: configured.replace(/\/+$/, ""), source: "environment" };
+  return { origin: DEFAULT_GUARD_ORIGIN, source: "default" };
+}
+
 // dist/control-origin.js
 var DEFAULT_CONTROL_ORIGIN = "https://control.halfcycle.ai";
 function resolveControlOrigin(env) {
@@ -18842,6 +19095,10 @@ var limitHeldSchema = external_exports.object({
   raiseBy: external_exports.number().int().nonnegative(),
   working: external_exports.number().int().nonnegative()
 }).strict();
+var paceUsageSchema = external_exports.object({
+  used: external_exports.number().int().nonnegative(),
+  limit: external_exports.number().int().positive()
+}).strict();
 var paceRunResultSchema = external_exports.discriminatedUnion("outcome", [
   external_exports.object({
     outcome: external_exports.literal("paced"),
@@ -18853,7 +19110,8 @@ var paceRunResultSchema = external_exports.discriminatedUnion("outcome", [
     keepFreePercent: keepFreePercentSchema.optional(),
     suggestion: paceSuggestionSchema.optional(),
     limit: external_exports.literal("reached").optional(),
-    limitHeld: limitHeldSchema.optional()
+    limitHeld: limitHeldSchema.optional(),
+    usage: paceUsageSchema.optional()
   }).strict(),
   external_exports.object({ outcome: external_exports.literal("not-paced"), reason: external_exports.enum(PACE_NOT_PACED_REASONS) }).strict()
 ]);
@@ -19232,6 +19490,7 @@ var relayedChoicesFileSchema = external_exports.object({
 }).strict();
 
 // ../events/dist/tier-figures.js
+var ROUTING_FILENAME = "routing.json";
 var routingRecordSchema = external_exports.object({
   phase: external_exports.string().min(1).max(200),
   cheapStarted: external_exports.array(external_exports.string().min(1).max(200)).max(2e3)
@@ -19784,7 +20043,7 @@ async function attempt(url2, token, request, fetchFn, retry) {
 
 // dist/git.js
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync } from "node:fs";
 import { relative } from "node:path";
 var COLOR_AWARE_SUBCOMMANDS = /* @__PURE__ */ new Set(["diff", "show", "log"]);
 function spawnGit(args2, cwd, timeoutMs, extra) {
@@ -19801,7 +20060,7 @@ function spawnGit(args2, cwd, timeoutMs, extra) {
 function git(args2, cwd, timeoutMs, extra) {
   const result = spawnGit(args2, cwd, timeoutMs, extra);
   if (result.error) {
-    const missing = result.error.code === "ENOENT" && existsSync(cwd);
+    const missing = result.error.code === "ENOENT" && existsSync2(cwd);
     return { ok: false, message: `git error: ${result.error.message}`, ...missing ? { gitMissing: true } : {} };
   }
   if (result.status !== 0) {
@@ -20315,14 +20574,14 @@ function stripComments(code) {
 function extractSqlWrites(diffContent) {
   const writes = [];
   const seen = /* @__PURE__ */ new Set();
-  const push = (write) => {
-    if (!write)
+  const push = (write2) => {
+    if (!write2)
       return;
-    const key = `${write.kind}:${write.table}`;
+    const key = `${write2.kind}:${write2.table}`;
     if (seen.has(key))
       return;
     seen.add(key);
-    writes.push(write);
+    writes.push(write2);
   };
   for (const line2 of diffContent.split("\n")) {
     if (isRemovedLine(line2) || isContextLine(line2) || isDiffHeader(line2))
@@ -20633,7 +20892,7 @@ function detectBlastRadiusMarkers(filePath, diffContent) {
 
 // dist/extract/numeric-columns.js
 import { readFileSync as readFileSync2, readdirSync } from "node:fs";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 function extractNumericColumns(diffContent, context = {}) {
   const addedLines = [];
   for (const line2 of diffContent.split("\n")) {
@@ -20700,12 +20959,12 @@ function walkForRegistrations(dir, repoRoot, acc) {
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.has(entry.name))
         continue;
-      walkForRegistrations(join(dir, entry.name), repoRoot, acc);
+      walkForRegistrations(join2(dir, entry.name), repoRoot, acc);
       continue;
     }
     if (!entry.isFile())
       continue;
-    const absPath = join(dir, entry.name);
+    const absPath = join2(dir, entry.name);
     if (!isCodeFile(absPath))
       continue;
     let content;
@@ -20847,13 +21106,13 @@ function resolveWireFields(lines2, decls) {
 }
 
 // dist/fixtures-manifest.js
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, renameSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join as join3 } from "node:path";
 function manifestPath(repoRoot) {
-  return join2(repoRoot, "test", "fixtures", "captured", "manifest.json");
+  return join3(repoRoot, "test", "fixtures", "captured", "manifest.json");
 }
 function fixturePath(repoRoot, provider, slug) {
-  return join2(repoRoot, "test", "fixtures", "captured", provider, `${slug}.json`);
+  return join3(repoRoot, "test", "fixtures", "captured", provider, `${slug}.json`);
 }
 function loadManifest(repoRoot) {
   if (!repoRoot)
@@ -20886,7 +21145,7 @@ function upsertManifest(repoRoot, entry) {
 }
 function removeFixtureIfExists(path) {
   try {
-    if (existsSync2(path))
+    if (existsSync3(path))
       unlinkSync(path);
   } catch {
   }
@@ -21134,7 +21393,7 @@ function toAstShapes(markers) {
 
 // dist/extract/context.js
 import { readFileSync as readFileSync4, readdirSync as readdirSync2 } from "node:fs";
-import { join as join3, relative as relative2, sep } from "node:path";
+import { join as join4, relative as relative2, sep } from "node:path";
 var EXCLUDED_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -21168,7 +21427,7 @@ function walk(dir, repoRoot, acc) {
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS2.has(entry.name))
         continue;
-      walk(join3(dir, entry.name), repoRoot, acc);
+      walk(join4(dir, entry.name), repoRoot, acc);
       continue;
     }
     if (!entry.isFile())
@@ -21176,7 +21435,7 @@ function walk(dir, repoRoot, acc) {
     const kind = classifyFile(entry.name);
     if (!kind)
       continue;
-    const absPath = join3(dir, entry.name);
+    const absPath = join4(dir, entry.name);
     let content;
     try {
       content = readFileSync4(absPath, "utf-8");
@@ -21199,9 +21458,9 @@ function loadChangeSetContext(repoRoot) {
 }
 
 // dist/telemetry/emit.js
-import { appendFileSync, mkdirSync as mkdirSync2 } from "node:fs";
-import { join as join4, dirname as dirname2 } from "node:path";
-import { homedir } from "node:os";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { join as join5, dirname as dirname2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
 import { randomUUID } from "node:crypto";
 var TELEMETRY_TIMEOUT_MS = 5e3;
 async function emitTelemetry(run, config2, logger, fetchFn = globalThis.fetch) {
@@ -21211,23 +21470,23 @@ async function emitTelemetry(run, config2, logger, fetchFn = globalThis.fetch) {
   }
 }
 function localLogPath(run, config2) {
-  const logDir = config2.guardEvalLogDir ?? join4(homedir(), ".halfcycle", "guard-eval-log");
+  const logDir = config2.guardEvalLogDir ?? join5(homedir2(), ".halfcycle", "guard-eval-log");
   const phase = run.phase;
   const fileName = phase === void 0 || phase === "" ? "unphased.jsonl" : `${renderPhaseSegment(phase)}.jsonl`;
-  return join4(logDir, fileName);
+  return join5(logDir, fileName);
 }
 function appendToLocalLog(run, config2, logger) {
-  let logPath;
+  let logPath2;
   try {
-    logPath = localLogPath(run, config2);
+    logPath2 = localLogPath(run, config2);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     logger.warn(`[Halfcycle telemetry] Phase name refused, nothing written (dropped): ${msg}`);
     return;
   }
   try {
-    mkdirSync2(dirname2(logPath), { recursive: true });
-    appendFileSync(logPath, JSON.stringify(run) + "\n", "utf-8");
+    mkdirSync2(dirname2(logPath2), { recursive: true });
+    appendFileSync2(logPath2, JSON.stringify(run) + "\n", "utf-8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     logger.warn(`[Halfcycle telemetry] Local guard-eval log write failed (dropped): ${msg}`);
@@ -21536,21 +21795,21 @@ function projectFolder(env = process.env) {
 }
 
 // dist/credential-store.js
-import { chmodSync, existsSync as existsSync3, readFileSync as readFileSync6, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2, realpathSync } from "node:fs";
-import { homedir as homedir2, platform } from "node:os";
-import { dirname as dirname3, join as join5 } from "node:path";
+import { chmodSync, existsSync as existsSync4, readFileSync as readFileSync6, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2, realpathSync } from "node:fs";
+import { homedir as homedir3, platform } from "node:os";
+import { dirname as dirname3, join as join6 } from "node:path";
 var REFRESHED_TOKEN_KEYS = ["HALFCYCLE_TOKEN", "GUARD_SERVICE_TOKEN"];
 var TOKEN_READ_KEY = "GUARD_SERVICE_TOKEN";
 function composeEngagementEnvPath(engagementId, home) {
-  return join5(home ?? homedir2(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, ENGAGEMENT_ENV_FILENAME);
+  return join6(home ?? homedir3(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, ENGAGEMENT_ENV_FILENAME);
 }
 function hasNotThisAccountMarker(engagementId, home) {
-  return existsSync3(join5(home ?? homedir2(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, NOT_THIS_ACCOUNT_MARKER_FILENAME));
+  return existsSync4(join6(home ?? homedir3(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, NOT_THIS_ACCOUNT_MARKER_FILENAME));
 }
 function readAccountCredential(controlOrigin, home) {
   let raw;
   try {
-    raw = readFileSync6(join5(home ?? homedir2(), HALFCYCLE_DIR_NAME, ACCOUNT_STORE_FILENAME), "utf-8");
+    raw = readFileSync6(join6(home ?? homedir3(), HALFCYCLE_DIR_NAME, ACCOUNT_STORE_FILENAME), "utf-8");
   } catch {
     return void 0;
   }
@@ -21602,7 +21861,7 @@ function writeRefreshedToken(opts) {
     existing = null;
   }
   const body = reconcileEnvText(existing, { HALFCYCLE_TOKEN: opts.token, GUARD_SERVICE_TOKEN: opts.token }, REFRESHED_TOKEN_KEYS);
-  const temp = join5(dirname3(declaredReal), `.${ENGAGEMENT_ENV_FILENAME}.${process.pid}.tmp`);
+  const temp = join6(dirname3(declaredReal), `.${ENGAGEMENT_ENV_FILENAME}.${process.pid}.tmp`);
   try {
     writeFileSync2(temp, body, { mode: 384 });
     if (platform() !== "win32")
@@ -21703,15 +21962,15 @@ async function refreshEngagementCredential(opts) {
   const minted = await mintThroughJoin(controlOrigin, opts.engagementId, accountCredential, opts.fetchFn ?? globalThis.fetch);
   if (!minted.ok)
     return minted;
-  const write = writeRefreshedToken({
+  const write2 = writeRefreshedToken({
     envFilePath,
     engagementId: opts.engagementId,
     token: minted.token,
     home: opts.home
   });
-  if (!write.written) {
+  if (!write2.written) {
     const warn = opts.warn ?? ((message) => process.stderr.write(message));
-    warn(`[Halfcycle] This engagement's credential was renewed for this run only \u2014 ${write.reason}.
+    warn(`[Halfcycle] This engagement's credential was renewed for this run only \u2014 ${write2.reason}.
 `);
   }
   return minted;
@@ -21740,9 +21999,9 @@ async function evaluateWithRefresh(opts) {
 
 // dist/hooks/marker.js
 import { createHash } from "node:crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, readdirSync as readdirSync3, rmdirSync, statSync } from "node:fs";
+import { existsSync as existsSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync3, unlinkSync as unlinkSync3, readdirSync as readdirSync3, rmdirSync, statSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 var MARKER_TTL_MS = 24 * 60 * 60 * 1e3;
 var MARKER_PREFIX = "halfcycle-session-";
 var MARKER_SUFFIX = ".ref";
@@ -21756,18 +22015,21 @@ var FINDINGS_ID = new RegExp(FINDINGS_ID_SOURCE);
 function findingsPath(sessionId) {
   if (typeof sessionId !== "string" || !FINDINGS_ID.test(sessionId))
     return null;
-  return join6(markerDir(), `${FINDINGS_PREFIX}${sessionId}${FINDINGS_SUFFIX}`);
+  return join7(markerDir(), `${FINDINGS_PREFIX}${sessionId}${FINDINGS_SUFFIX}`);
 }
 var HELD_STEP_PREFIX = "halfcycle-held-";
 var ALLOW_PREFIX = "halfcycle-allow-";
+var STEP_NUMBERS_PREFIX = "halfcycle-step-numbers-";
 var ALLOW_ONCE_SUFFIX = ".json";
+var STEP_NUMBERS_LOCK_SUFFIX = ".lock";
 function allowOncePaths(sessionId, dir) {
   if (typeof sessionId !== "string" || !FINDINGS_ID.test(sessionId))
     return null;
   const base = dir ?? markerDir();
   return {
-    held: join6(base, `${HELD_STEP_PREFIX}${sessionId}${ALLOW_ONCE_SUFFIX}`),
-    allow: join6(base, `${ALLOW_PREFIX}${sessionId}${ALLOW_ONCE_SUFFIX}`)
+    held: join7(base, `${HELD_STEP_PREFIX}${sessionId}${ALLOW_ONCE_SUFFIX}`),
+    allow: join7(base, `${ALLOW_PREFIX}${sessionId}${ALLOW_ONCE_SUFFIX}`),
+    numbers: join7(base, `${STEP_NUMBERS_PREFIX}${sessionId}${ALLOW_ONCE_SUFFIX}`)
   };
 }
 function markerDir() {
@@ -21783,16 +22045,16 @@ function markerFileName(repoRoot, sessionId) {
   return `${MARKER_PREFIX}${key}${MARKER_SUFFIX}`;
 }
 function markerPath(repoRoot, sessionId) {
-  return join6(markerDir(), markerFileName(repoRoot, sessionId));
+  return join7(markerDir(), markerFileName(repoRoot, sessionId));
 }
 function dedupePath(repoRoot, sessionId) {
   const hash2 = repoHash(repoRoot);
   const key = sessionId && sessionId.length > 0 ? `${hash2}-${sessionId}` : hash2;
-  return join6(markerDir(), `${MARKER_PREFIX}${key}${DEDUPE_SUFFIX}`);
+  return join7(markerDir(), `${MARKER_PREFIX}${key}${DEDUPE_SUFFIX}`);
 }
 function readMarker(repoRoot, sessionId) {
   const path = markerPath(repoRoot, sessionId);
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return null;
   try {
     return readFileSync7(path, "utf-8").trim() || null;
@@ -21803,7 +22065,7 @@ function readMarker(repoRoot, sessionId) {
 function deleteMarker(repoRoot, sessionId) {
   for (const path of [markerPath(repoRoot, sessionId), dedupePath(repoRoot, sessionId)]) {
     try {
-      if (existsSync4(path))
+      if (existsSync5(path))
         unlinkSync3(path);
     } catch {
     }
@@ -21820,11 +22082,11 @@ var SESSION_NOTICE_SUFFIX = {
   "pre-tool-use-unreadable": ".pretool-unreadable",
   "outside-own-copy-unknown": ".owncopy-unknown"
 };
-function firstNoticeThisSession(notice, folder, sessionId, dir = markerDir()) {
+function firstNoticeThisSession(notice, folder2, sessionId, dir = markerDir()) {
   if (!sessionId)
     return true;
   const suffix = SESSION_NOTICE_SUFFIX[notice];
-  const path = join6(dir, `${MARKER_PREFIX}${repoHash(folder)}-${sessionId}${suffix}`);
+  const path = join7(dir, `${MARKER_PREFIX}${repoHash(folder2)}-${sessionId}${suffix}`);
   try {
     writeFileSync3(path, "", { encoding: "utf-8", flag: "wx" });
     return true;
@@ -21832,18 +22094,18 @@ function firstNoticeThisSession(notice, folder, sessionId, dir = markerDir()) {
     return err.code !== "EEXIST";
   }
 }
-function warnOnceThisSession(notice, folder, sessionId) {
+function warnOnceThisSession(notice, folder2, sessionId) {
   return (message) => {
-    if (firstNoticeThisSession(notice, folder, sessionId))
+    if (firstNoticeThisSession(notice, folder2, sessionId))
       process.stderr.write(message);
   };
 }
-function firstNoRepoNoticeThisSession(folder, sessionId) {
-  return firstNoticeThisSession("no-repository", folder, sessionId);
+function firstNoRepoNoticeThisSession(folder2, sessionId) {
+  return firstNoticeThisSession("no-repository", folder2, sessionId);
 }
 function readDedupe(repoRoot, sessionId) {
   const path = dedupePath(repoRoot, sessionId);
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync7(path, "utf-8"));
@@ -21891,7 +22153,7 @@ function orphanSweep(repoRoot, refKnown, keepSessionId, now = Date.now(), livene
       continue;
     if (name === keepName)
       continue;
-    const full = join6(dir, name);
+    const full = join7(dir, name);
     let unusable = false;
     try {
       const ref = readFileSync7(full, "utf-8").trim();
@@ -21928,7 +22190,9 @@ function sweepSessionFiles(keepSessionId, now) {
     [FINDINGS_PREFIX, FINDINGS_SUFFIX],
     [OWN_WORK_PREFIX, OWN_WORK_SUFFIX],
     [HELD_STEP_PREFIX, ALLOW_ONCE_SUFFIX],
-    [ALLOW_PREFIX, ALLOW_ONCE_SUFFIX]
+    [ALLOW_PREFIX, ALLOW_ONCE_SUFFIX],
+    [STEP_NUMBERS_PREFIX, ALLOW_ONCE_SUFFIX],
+    [STEP_NUMBERS_PREFIX, `${ALLOW_ONCE_SUFFIX}${STEP_NUMBERS_LOCK_SUFFIX}`]
   ];
   for (const name of names) {
     for (const [prefix, suffix] of kinds) {
@@ -21936,7 +22200,7 @@ function sweepSessionFiles(keepSessionId, now) {
         continue;
       if (keepSessionId !== void 0 && name === `${prefix}${keepSessionId}${suffix}`)
         continue;
-      const full = join6(dir, name);
+      const full = join7(dir, name);
       try {
         if (now - statSync(full).mtimeMs > MARKER_TTL_MS)
           unlinkSync3(full);
@@ -21945,13 +22209,13 @@ function sweepSessionFiles(keepSessionId, now) {
     }
   }
 }
-function observeThrottlePath(folder) {
-  return join6(markerDir(), `${MARKER_PREFIX}${repoHash(folder)}.observe-throttle`);
+function observeThrottlePath(folder2) {
+  return join7(markerDir(), `${MARKER_PREFIX}${repoHash(folder2)}.observe-throttle`);
 }
-function observeNoticesPath(folder, sessionId) {
+function observeNoticesPath(folder2, sessionId) {
   if (!sessionId)
     return null;
-  return join6(markerDir(), `${MARKER_PREFIX}${repoHash(folder)}-${sessionId}.observe-said`);
+  return join7(markerDir(), `${MARKER_PREFIX}${repoHash(folder2)}-${sessionId}.observe-said`);
 }
 var LIVENESS_SUFFIX = ".live";
 var LIVENESS_NO_REPOSITORY_KEY = "norepository";
@@ -22005,7 +22269,7 @@ function sweepLiveness(common, now) {
     const parsed = parseLivenessFileName(name);
     if (parsed === null || !keys.has(parsed.key))
       continue;
-    const full = join6(dir, name);
+    const full = join7(dir, name);
     try {
       if (now - statSync(full).mtimeMs > MARKER_TTL_MS) {
         unlinkSync3(full);
@@ -22016,22 +22280,22 @@ function sweepLiveness(common, now) {
   }
 }
 function removeLivenessIndexEntry(dir, sessionId, name) {
-  const folder = join6(dir, livenessIndexDirName(sessionId));
+  const folder2 = join7(dir, livenessIndexDirName(sessionId));
   try {
-    unlinkSync3(join6(folder, name));
+    unlinkSync3(join7(folder2, name));
   } catch {
     return;
   }
   try {
-    rmdirSync(folder);
+    rmdirSync(folder2);
   } catch {
   }
 }
 
 // dist/seat-configuration.js
-import { existsSync as existsSync5, readFileSync as readFileSync8, realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join7, relative as relative3, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync6, readFileSync as readFileSync8, realpathSync as realpathSync2 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join8, relative as relative3, resolve as resolve2 } from "node:path";
 function gatherSeatConfiguration(repoRoot, read = readSeatConfiguration, profile = AGENT_PROFILES["claude-code"]) {
   try {
     const facts = read(repoRoot, profile);
@@ -22046,7 +22310,7 @@ function gatherSeatConfiguration(repoRoot, read = readSeatConfiguration, profile
 function readSeatConfiguration(repoRoot, profile = AGENT_PROFILES["claude-code"]) {
   const given = profile.projectRoot === "git-toplevel" ? resolve2(repoRoot) : resolve2(process.env["CLAUDE_PROJECT_DIR"] || process.cwd());
   const projectDir = realpathSync2.native(given);
-  const home = homedir3();
+  const home = homedir4();
   let realHome = home;
   try {
     realHome = realpathSync2.native(home);
@@ -22067,7 +22331,7 @@ function isPlainObject3(value) {
 function readSettingsFile(projectDir, rel, ours) {
   let raw;
   try {
-    raw = readFileSync8(join7(projectDir, rel), "utf-8");
+    raw = readFileSync8(join8(projectDir, rel), "utf-8");
   } catch (err) {
     const code = err.code;
     const state = code === "ENOENT" || code === "ENOTDIR" ? "absent" : "unreadable";
@@ -22139,7 +22403,7 @@ function readPathStates(projectDir, repoRoot, wiringPaths) {
   const status = getWiringStatus(wiringPaths, projectDir);
   if (!status.ok)
     return unknown2();
-  const mapped = mapWiringStatus(status.value, prefix, wiringPaths, (rel) => existsSync5(join7(projectDir, rel)));
+  const mapped = mapWiringStatus(status.value, prefix, wiringPaths, (rel) => existsSync6(join8(projectDir, rel)));
   return mapped ?? unknown2();
 }
 function mapWiringStatus(output, prefix, paths, onDisk) {
@@ -22182,28 +22446,28 @@ function mapWiringStatus(output, prefix, paths, onDisk) {
 
 // dist/time-record.js
 import { createHash as createHash3 } from "node:crypto";
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, readdirSync as readdirSync6, readFileSync as readFileSync14, renameSync as renameSync5, unlinkSync as unlinkSync4, writeFileSync as writeFileSync7 } from "node:fs";
-import { homedir as homedir7 } from "node:os";
-import { dirname as dirname4, join as join10 } from "node:path";
+import { appendFileSync as appendFileSync3, closeSync as closeSync3, fstatSync as fstatSync2, mkdirSync as mkdirSync6, openSync as openSync3, readdirSync as readdirSync6, readFileSync as readFileSync15, readSync as readSync3, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import { homedir as homedir8 } from "node:os";
+import { dirname as dirname4, join as join11 } from "node:path";
 
 // dist/codex-usage.js
 import { closeSync, fstatSync, lstatSync, openSync, readdirSync as readdirSync4, readFileSync as readFileSync9, readSync, realpathSync as realpathSync3 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { basename, isAbsolute, join as join8, relative as relative4, resolve as resolve3, sep as sep2 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { basename, isAbsolute, join as join9, relative as relative4, resolve as resolve3, sep as sep2 } from "node:path";
 var CODEX_WINDOW_FRESH_MS = 10 * 60 * 1e3;
 var CODEX_DAYS_BACK = 7;
 var CODEX_FILES_MAX = 20;
 var CODEX_TAIL_BYTES = 256 * 1024;
 var CODEX_SAME_RESET_SECONDS = 60;
 var ROLLOUT_NAME = /^rollout-.+\.jsonl$/;
-function codexHomeOf(env = process.env, home = homedir4()) {
+function codexHomeOf(env = process.env, home = homedir5()) {
   const set2 = env["CODEX_HOME"];
-  const folder = typeof set2 === "string" && set2 !== "" ? set2 : join8(home, ".codex");
-  if (folder === "~")
+  const folder2 = typeof set2 === "string" && set2 !== "" ? set2 : join9(home, ".codex");
+  if (folder2 === "~")
     return resolve3(home);
-  if (folder.startsWith("~/") || folder.startsWith("~\\"))
-    return resolve3(join8(home, folder.slice(2)));
-  return resolve3(folder);
+  if (folder2.startsWith("~/") || folder2.startsWith("~\\"))
+    return resolve3(join9(home, folder2.slice(2)));
+  return resolve3(folder2);
 }
 function objectOf(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) ? v : null;
@@ -22287,20 +22551,20 @@ function dayFolders(sessions, now) {
   const out = [];
   for (let back = 0; back < CODEX_DAYS_BACK; back++) {
     const d = new Date(now.getFullYear(), now.getMonth(), now.getDate() - back);
-    out.push(join8(sessions, String(d.getFullYear()), twoDigits(d.getMonth() + 1), twoDigits(d.getDate())));
+    out.push(join9(sessions, String(d.getFullYear()), twoDigits(d.getMonth() + 1), twoDigits(d.getDate())));
   }
   return out;
 }
 function recentRollouts(sessions, now) {
   const found2 = [];
-  for (const folder of dayFolders(sessions, now)) {
+  for (const folder2 of dayFolders(sessions, now)) {
     try {
-      if (!lstatSync(folder).isDirectory())
+      if (!lstatSync(folder2).isDirectory())
         continue;
-      for (const name of readdirSync4(folder)) {
+      for (const name of readdirSync4(folder2)) {
         if (!ROLLOUT_NAME.test(name))
           continue;
-        const path = join8(folder, name);
+        const path = join9(folder2, name);
         try {
           const st = lstatSync(path);
           if (!st.isFile())
@@ -22319,7 +22583,7 @@ function recentRollouts(sessions, now) {
 function readCodexWindows(codexHome, now) {
   try {
     const candidates = [];
-    for (const path of recentRollouts(join8(codexHome, "sessions"), now)) {
+    for (const path of recentRollouts(join9(codexHome, "sessions"), now)) {
       try {
         candidates.push(...newestWindowsIn(path, now));
       } catch {
@@ -22349,7 +22613,7 @@ function isCodexSessionFile(path, codexHome) {
       return false;
     if (!lstatSync(path).isFile())
       return false;
-    const rel = relative4(realpathSync3(join8(codexHome, "sessions")), realpathSync3(path));
+    const rel = relative4(realpathSync3(join9(codexHome, "sessions")), realpathSync3(path));
     return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep2}`) && !isAbsolute(rel);
   } catch {
     return false;
@@ -22444,18 +22708,18 @@ function firstLine(text) {
   const line2 = text.split("\n", 1)[0]?.replace(/[ \t\r]+$/, "") ?? "";
   return line2 === "" ? null : line2;
 }
-function whichCopy(folder, deps = {}) {
+function whichCopy(folder2, deps = {}) {
   try {
     const rules = deps.rules ?? machineRules();
     const p = pathsFor(rules);
     const files = deps.files ?? DISK_FILES;
     const realpath = deps.realpath ?? ((x) => realpathSync4.native(x));
     const oneForm = rules === "windows" ? (x) => x.toLowerCase() : (x) => x;
-    if (!p.isAbsolute(folder))
+    if (!p.isAbsolute(folder2))
       return null;
-    if (files.kind(p.resolve(folder)) !== "folder")
+    if (files.kind(p.resolve(folder2)) !== "folder")
       return null;
-    let dir = realpath(p.resolve(folder));
+    let dir = realpath(p.resolve(folder2));
     for (; ; ) {
       const dotGit = p.join(dir, ".git");
       const found2 = files.kind(dotGit);
@@ -22530,7 +22794,7 @@ function copyHolding(file2, deps = {}) {
 
 // dist/observed.js
 import { readFileSync as readFileSync11, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function emptyTally() {
   return { added: 0, changed: 0, removed: 0, testFilesAdded: 0 };
 }
@@ -22662,9 +22926,9 @@ async function attemptObservation(opts) {
     return { outcome: "not-sent", reason: "refused" };
   return answer.data.outcome === "kept" ? { outcome: "kept" } : { outcome: "recorded", answer: answer.data };
 }
-function readThrottle(folder) {
+function readThrottle(folder2) {
   try {
-    const parsed = JSON.parse(readFileSync11(observeThrottlePath(folder), "utf-8"));
+    const parsed = JSON.parse(readFileSync11(observeThrottlePath(folder2), "utf-8"));
     if (typeof parsed !== "object" || parsed === null)
       return null;
     const { attemptedAt, accepted } = parsed;
@@ -22677,9 +22941,9 @@ function readThrottle(folder) {
     return null;
   }
 }
-function writeThrottle(folder, state) {
+function writeThrottle(folder2, state) {
   try {
-    writeFileSync4(observeThrottlePath(folder), JSON.stringify(state), "utf-8");
+    writeFileSync4(observeThrottlePath(folder2), JSON.stringify(state), "utf-8");
   } catch {
   }
 }
@@ -22700,9 +22964,9 @@ function locate(cwd) {
   const read = repoRoot === null ? null : headCommit(repoRoot);
   return { repoRoot, folder: repoRoot ?? cwd, head: read !== null && read.ok ? read.value : null };
 }
-function recordAttempt(folder, prior, head, at, attempt2) {
+function recordAttempt(folder2, prior, head, at, attempt2) {
   const accepted = (attempt2.outcome === "recorded" || attempt2.outcome === "kept") && head !== null ? { head, at } : prior?.accepted ?? null;
-  writeThrottle(folder, { attemptedAt: at, accepted });
+  writeThrottle(folder2, { attemptedAt: at, accepted });
 }
 async function runObserve(deps = {}) {
   let result;
@@ -22731,7 +22995,7 @@ async function runObserve(deps = {}) {
 }
 function readLocalSystemDescription(repoRoot) {
   try {
-    const raw = JSON.parse(readFileSync11(join9(repoRoot, SYSTEM_DESCRIPTION_REL), "utf-8"));
+    const raw = JSON.parse(readFileSync11(join10(repoRoot, SYSTEM_DESCRIPTION_REL), "utf-8"));
     const checked = checkSystemDescription(raw);
     return checked.ok ? checked.description : null;
   } catch {
@@ -22905,23 +23169,23 @@ function writeSaid(path, state) {
 function reasonsOf(entry) {
   return entry.said.filter((task) => task.whyOutsidePlan !== void 0).map((task) => `${task.title}\0${task.whyOutsidePlan}`);
 }
-function noticesFor(attempt2, folder, sessionId) {
+function noticesFor(attempt2, folder2, sessionId) {
   if (attempt2.outcome === "not-sent") {
     if (attempt2.reason === "start-not-here") {
-      return firstNoticeThisSession("observe-no-start-here", folder, sessionId) ? [R1_START_NOT_HERE] : [];
+      return firstNoticeThisSession("observe-no-start-here", folder2, sessionId) ? [R1_START_NOT_HERE] : [];
     }
     if (attempt2.reason === "start-not-on-branch") {
-      return firstNoticeThisSession("observe-not-on-branch", folder, sessionId) ? [R2_START_NOT_ON_BRANCH] : [];
+      return firstNoticeThisSession("observe-not-on-branch", folder2, sessionId) ? [R2_START_NOT_ON_BRANCH] : [];
     }
     if (attempt2.reason === "cannot-count" && attempt2.phase !== void 0) {
-      return firstNoticeThisSession("observe-no-start-recorded", folder, sessionId) ? [r3NoStartRecorded(attempt2.phase)] : [];
+      return firstNoticeThisSession("observe-no-start-recorded", folder2, sessionId) ? [r3NoStartRecorded(attempt2.phase)] : [];
     }
     return [];
   }
   if (attempt2.outcome === "kept")
     return [];
   const { notInPlan, outside } = attempt2.answer;
-  const path = observeNoticesPath(folder, sessionId);
+  const path = observeNoticesPath(folder2, sessionId);
   const prior = readSaid(path);
   const notices = [];
   const parts = {};
@@ -22949,7 +23213,7 @@ function noticesFor(attempt2, folder, sessionId) {
 // dist/pacing.js
 import { createHash as createHash2 } from "node:crypto";
 import { closeSync as closeSync2, mkdirSync as mkdirSync3, openSync as openSync2, readdirSync as readdirSync5, readFileSync as readFileSync12, readSync as readSync2, realpathSync as realpathSync5, renameSync as renameSync3, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import nodePath from "node:path";
 var DEFAULT_CONFIG_FOLDER_NAME = ".claude";
 var CODEX_DEFAULT_FOLDER_NAME = ".codex";
@@ -22967,10 +23231,10 @@ function hookInputForRule(input, rule) {
     delete copy["rollout_path"];
   return copy;
 }
-function normaliseFolder(folder, input = {}) {
+function normaliseFolder(folder2, input = {}) {
   const p = input.path ?? nodePath;
-  const home = input.home ?? homedir5();
-  let f = folder;
+  const home = input.home ?? homedir6();
+  let f = folder2;
   if (f === "~")
     f = home;
   else if (f.startsWith("~/") || f.startsWith("~\\"))
@@ -22984,7 +23248,7 @@ function configFolderKey(input = {}) {
     const codexHome = env["CODEX_HOME"];
     if (typeof codexHome === "string" && codexHome !== "")
       return normaliseFolder(codexHome, input);
-    return normaliseFolder(p.join(input.home ?? homedir5(), CODEX_DEFAULT_FOLDER_NAME), input);
+    return normaliseFolder(p.join(input.home ?? homedir6(), CODEX_DEFAULT_FOLDER_NAME), input);
   }
   const fromEnv = env["CLAUDE_CONFIG_DIR"];
   if (typeof fromEnv === "string" && fromEnv !== "")
@@ -22993,7 +23257,7 @@ function configFolderKey(input = {}) {
   if (typeof transcript === "string" && transcript !== "") {
     return normaliseFolder(p.dirname(p.dirname(p.dirname(normaliseFolder(transcript, input)))), input);
   }
-  return normaliseFolder(p.join(input.home ?? homedir5(), DEFAULT_CONFIG_FOLDER_NAME), input);
+  return normaliseFolder(p.join(input.home ?? homedir6(), DEFAULT_CONFIG_FOLDER_NAME), input);
 }
 function recordsFolderOf(key, path = nodePath) {
   return path.join(key, RECORDS_FOLDER_NAME);
@@ -23013,7 +23277,7 @@ var PACING_DIR_NAME = "pacing";
 var LEARNED_FILENAME = "learned.json";
 var REPORTED_FILENAME = "reported.json";
 function pacingDir(home) {
-  return nodePath.join(home ?? homedir5(), HALFCYCLE_DIR_NAME, PACING_DIR_NAME);
+  return nodePath.join(home ?? homedir6(), HALFCYCLE_DIR_NAME, PACING_DIR_NAME);
 }
 function readJsonObject(path) {
   try {
@@ -23435,7 +23699,7 @@ function resolvedRecords(key, path) {
   }
 }
 function timeLogTranscripts(home) {
-  const engagements = nodePath.join(home ?? homedir5(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME);
+  const engagements = nodePath.join(home ?? homedir6(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME);
   const out = [];
   for (const e of dirents(engagements)) {
     if (!e.isDirectory())
@@ -23454,7 +23718,7 @@ function timeLogTranscripts(home) {
 }
 function teacherOf(key, deps = {}) {
   const path = deps.path ?? nodePath;
-  const home = deps.home ?? homedir5();
+  const home = deps.home ?? homedir6();
   const ours = resolvedRecords(key, path);
   if (ours === null)
     return { shared: false, teaches: () => false };
@@ -23624,13 +23888,13 @@ function knownWindowOf(learned, reported, now) {
 
 // dist/phase-limit.js
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync13, renameSync as renameSync4, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import nodePath2 from "node:path";
 var PHASE_USAGE_FILENAME = "phase-usage.json";
 function phaseLimitDir(engagementId, home) {
   if (!isEngagementId(engagementId))
     return null;
-  return nodePath2.join(home ?? homedir6(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, PACING_DIR_NAME);
+  return nodePath2.join(home ?? homedir7(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, PACING_DIR_NAME);
 }
 function readJsonFile(path) {
   try {
@@ -23678,16 +23942,14 @@ function readPhaseUsage(dir, phase, openedAt = null) {
     return 0;
   return parsed.data.tokens;
 }
+function readPhaseUsageFile(dir) {
+  const parsed = phaseUsageFileSchema.safeParse(readJsonFile(nodePath2.join(dir, PHASE_USAGE_FILENAME)));
+  return parsed.success ? parsed.data : null;
+}
 function writePhaseUsage(dir, file2) {
   if (!phaseUsageFileSchema.safeParse(file2).success)
-    return;
-  writeWhole(nodePath2.join(dir, PHASE_USAGE_FILENAME), file2);
-}
-function phaseTokensOf(buckets) {
-  let total = 0;
-  for (const b of buckets)
-    total += b.inputTokens + b.outputTokens + b.cacheWriteTokens + b.cacheReadTokens;
-  return Math.max(0, Math.round(total));
+    return false;
+  return writeWhole(nodePath2.join(dir, PHASE_USAGE_FILENAME), file2);
 }
 function roundTokens(n) {
   return Math.max(LIMIT_ROUND_TOKENS, Math.round(n / LIMIT_ROUND_TOKENS) * LIMIT_ROUND_TOKENS);
@@ -23865,6 +24127,164 @@ function setLimit(file2, limit, multiple, used, by, at) {
   };
 }
 
+// dist/scan-lock.js
+import { spawn } from "node:child_process";
+import { linkSync, mkdirSync as mkdirSync5, readFileSync as readFileSync14, renameSync as renameSync5, unlinkSync as unlinkSync4, writeFileSync as writeFileSync7 } from "node:fs";
+import nodePath3 from "node:path";
+var SCAN_LOCK_FILENAME = "scan.lock";
+var SCAN_LOCK_STALE_MS = 15 * 60 * 1e3;
+var SCAN_LOCK_POLL_MS = 100;
+function scanLockPath(home) {
+  return nodePath3.join(pacingDir(home), SCAN_LOCK_FILENAME);
+}
+function readLockBody(path) {
+  let text;
+  try {
+    text = readFileSync14(path, "utf-8");
+  } catch (err) {
+    return err.code === "ENOENT" ? "missing" : null;
+  }
+  try {
+    const v = JSON.parse(text);
+    return typeof v["pid"] === "number" && typeof v["at"] === "number" ? { pid: v["pid"], at: v["at"] } : null;
+  } catch {
+    return null;
+  }
+}
+function processAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function isStale(body, staleMs, deps) {
+  if (body === null)
+    return true;
+  const now = (deps.clock ?? Date.now)();
+  if (Math.abs(now - body.at) > staleMs)
+    return true;
+  return !(deps.alive ?? processAlive)(body.pid);
+}
+function writeLock(path, pid, deps, flag) {
+  writeFileSync7(path, JSON.stringify({ pid, at: (deps.clock ?? Date.now)() }), { flag, mode: 384 });
+}
+function tryTakeScanLock(deps = {}) {
+  return tryTakeLockFile(scanLockPath(deps.home), SCAN_LOCK_STALE_MS, deps);
+}
+function tryTakeLockFile(path, staleMs, deps = {}) {
+  const pid = deps.pid ?? process.pid;
+  try {
+    mkdirSync5(nodePath3.dirname(path), { recursive: true, mode: 448 });
+  } catch {
+    return false;
+  }
+  for (let attempt2 = 0; attempt2 < 2; attempt2++) {
+    try {
+      writeLock(path, pid, deps, "wx");
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        return false;
+    }
+    const seen = readLockBody(path);
+    if (seen === "missing")
+      continue;
+    if (!isStale(seen, staleMs, deps))
+      return false;
+    const aside = `${path}.${String(pid)}.${String((deps.clock ?? Date.now)())}.stale`;
+    try {
+      renameSync5(path, aside);
+    } catch {
+      continue;
+    }
+    const taken = readLockBody(aside);
+    const same = taken !== "missing" && (seen === null ? taken === null : taken !== null && taken.pid === seen.pid && taken.at === seen.at);
+    if (!same && taken !== "missing" && !isStale(taken, staleMs, deps)) {
+      try {
+        linkSync(aside, path);
+      } catch {
+      }
+      try {
+        unlinkSync4(aside);
+      } catch {
+      }
+      return false;
+    }
+    try {
+      unlinkSync4(aside);
+    } catch {
+    }
+  }
+  return false;
+}
+function releaseLockFile(path, pid = process.pid) {
+  const body = readLockBody(path);
+  if (body === "missing" || body === null || body.pid !== pid)
+    return;
+  try {
+    unlinkSync4(path);
+  } catch {
+  }
+}
+function releaseScanLock(deps = {}) {
+  releaseLockFile(scanLockPath(deps.home), deps.pid ?? process.pid);
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function scanUnderLock(key, deps = {}, waitMs = 0) {
+  const clock = deps.clock ?? Date.now;
+  const giveUpAt = clock() + waitMs;
+  while (!tryTakeScanLock(deps)) {
+    if (clock() >= giveUpAt)
+      return null;
+    sleepSync(SCAN_LOCK_POLL_MS);
+  }
+  try {
+    return scanRecords(key, deps);
+  } finally {
+    releaseScanLock(deps);
+  }
+}
+var spawnDetachedReal = (command, args2) => {
+  const child = spawn(command, [...args2], { detached: true, stdio: "ignore", windowsHide: true });
+  child.on("error", () => void 0);
+  child.unref();
+  return child.pid;
+};
+function startScanChild(key, binaryPath, deps = {}) {
+  if (!tryTakeScanLock(deps))
+    return false;
+  let childPid;
+  try {
+    childPid = (deps.spawnDetached ?? spawnDetachedReal)(deps.nodePath ?? process.execPath, [
+      binaryPath,
+      "pace",
+      "--scan",
+      "--config-folder",
+      key,
+      "--lock-held"
+    ]);
+  } catch {
+    childPid = void 0;
+  }
+  if (childPid === void 0) {
+    releaseScanLock(deps);
+    return false;
+  }
+  try {
+    writeLock(scanLockPath(deps.home), childPid, deps, "w");
+  } catch {
+    releaseScanLock(deps);
+    return false;
+  }
+  return true;
+}
+
 // dist/time-record.js
 var TIME_EVENT_KINDS = ["action", "asked", "edit", "turn-end", "lock-wait-start", "lock-wait-end"];
 function isLockWaitEvent(event) {
@@ -23878,25 +24298,25 @@ function inputString(input, key) {
   const value = input[key];
   return typeof value === "string" && value !== "" ? value : null;
 }
-function readBranch(folder, deps = {}) {
-  const copy = whichCopy(folder, deps);
+function readBranch(folder2, deps = {}) {
+  const copy = whichCopy(folder2, deps);
   return copy === null ? null : copyBranch(copy, deps);
 }
 function timeLogPath(engagementId, home) {
   if (!isEngagementId(engagementId))
     return null;
-  return join10(home ?? homedir7(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, TIME_LOG_DIR_NAME, TIME_LOG_FILENAME);
+  return join11(home ?? homedir8(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, TIME_LOG_DIR_NAME, TIME_LOG_FILENAME);
 }
 function timeEventLine(event, input, deps = {}) {
   const at = (deps.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
-  const folder = inputString(input, "cwd") ?? (deps.cwd ?? (() => process.cwd()))();
+  const folder2 = inputString(input, "cwd") ?? (deps.cwd ?? (() => process.cwd()))();
   return {
     at,
     event,
     session: inputString(input, "session_id"),
     agent: inputString(input, "agent_id"),
-    folder,
-    branch: readBranch(folder),
+    folder: folder2,
+    branch: readBranch(folder2),
     transcript: inputString(input, "transcript_path"),
     toolUse: inputString(input, "tool_use_id"),
     rollout: inputString(input, "rollout_path")
@@ -23914,12 +24334,12 @@ function recordTimeEvent(event, input, deps = {}) {
     const text = `${JSON.stringify(line2)}
 `;
     try {
-      appendFileSync2(path, text, { mode: 384 });
+      appendFileSync3(path, text, { mode: 384 });
     } catch (err) {
       if (err.code !== "ENOENT")
         return;
-      mkdirSync5(dirname4(path), { recursive: true, mode: 448 });
-      appendFileSync2(path, text, { mode: 384 });
+      mkdirSync6(dirname4(path), { recursive: true, mode: 448 });
+      appendFileSync3(path, text, { mode: 384 });
     }
   } catch {
   }
@@ -23978,7 +24398,7 @@ function readSessionTimeLines(sessionId, deps = {}) {
     if (path === null)
       return [];
     const needle = JSON.stringify(sessionId);
-    const kept = readFileSync14(path, "utf-8").split("\n").filter((raw) => raw.includes(needle));
+    const kept = readFileSync15(path, "utf-8").split("\n").filter((raw) => raw.includes(needle));
     return parseTimeLog(kept.join("\n")).filter((line2) => line2.session === sessionId);
   } catch {
     return [];
@@ -24005,8 +24425,8 @@ function separatorOf(path) {
 function subagentsFolderOf(transcript) {
   if (!transcript.endsWith(".jsonl") || transcript.length === ".jsonl".length)
     return null;
-  const sep7 = separatorOf(transcript);
-  return `${transcript.slice(0, -".jsonl".length)}${sep7}subagents`;
+  const sep8 = separatorOf(transcript);
+  return `${transcript.slice(0, -".jsonl".length)}${sep8}subagents`;
 }
 function subagentRecordName(agentId) {
   return /^[A-Za-z0-9_-]+$/.test(agentId) ? `agent-${agentId}.jsonl` : null;
@@ -24014,12 +24434,12 @@ function subagentRecordName(agentId) {
 function subagentRecordPath(transcript, agentId) {
   if (transcript === null)
     return null;
-  const folder = subagentsFolderOf(transcript);
+  const folder2 = subagentsFolderOf(transcript);
   const name = subagentRecordName(agentId);
-  return folder === null || name === null ? null : `${folder}${separatorOf(transcript)}${name}`;
+  return folder2 === null || name === null ? null : `${folder2}${separatorOf(transcript)}${name}`;
 }
-function folderParts(folder) {
-  return folder.split(/[\\/]+/).filter((part, i) => part !== "" || i === 0);
+function folderParts(folder2) {
+  return folder2.split(/[\\/]+/).filter((part, i) => part !== "" || i === 0);
 }
 function folderHolds(outer, inner) {
   const o = folderParts(outer);
@@ -24072,15 +24492,52 @@ function buildLanes(events, taskIds) {
   });
 }
 var UNREADABLE2 = { readable: false, lines: [] };
-function viewRecord(path, deps) {
-  if (path === null)
-    return UNREADABLE2;
-  let text;
-  try {
-    text = (deps.readFile ?? ((p) => readFileSync14(p, "utf-8")))(path);
-  } catch {
-    return UNREADABLE2;
+function plainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : null;
+}
+var USAGE_KEYS = ["input_tokens", "output_tokens", "cache_creation_input_tokens", "cache_read_input_tokens"];
+function reducedLine(o) {
+  const out = { type: o["type"] };
+  if (typeof o["timestamp"] === "string")
+    out["timestamp"] = o["timestamp"];
+  if (typeof o["gitBranch"] === "string")
+    out["gitBranch"] = o["gitBranch"];
+  if ("toolUseResult" in o)
+    out["toolUseResult"] = true;
+  if (o["isApiErrorMessage"] === true)
+    out["isApiErrorMessage"] = true;
+  if (typeof o["error"] === "string")
+    out["error"] = o["error"];
+  const message = plainObject(o["message"]);
+  if (message !== null) {
+    const m = {};
+    if (typeof message["id"] === "string")
+      m["id"] = message["id"];
+    if (typeof message["model"] === "string")
+      m["model"] = message["model"];
+    const usage = plainObject(message["usage"]);
+    if (usage !== null) {
+      const u = {};
+      for (const key of USAGE_KEYS)
+        if (key in usage)
+          u[key] = usage[key];
+      m["usage"] = u;
+    }
+    const content = message["content"];
+    if (Array.isArray(content) && content.some((block) => plainObject(block)?.["type"] === "tool_result"))
+      m["content"] = [{ type: "tool_result" }];
+    out["message"] = m;
   }
+  return out;
+}
+function recordLineOfValue(value) {
+  const o = plainObject(value);
+  if (o === null || typeof o["type"] !== "string")
+    return null;
+  const t = typeof o["timestamp"] === "string" ? Date.parse(o["timestamp"]) : NaN;
+  return { value: o, t: Number.isNaN(t) ? null : t };
+}
+function recordLinesOf(text) {
   const lines2 = [];
   for (const raw of text.split("\n")) {
     if (raw.trim() === "")
@@ -24091,29 +24548,129 @@ function viewRecord(path, deps) {
     } catch {
       continue;
     }
-    if (typeof value !== "object" || value === null || Array.isArray(value))
+    const o = plainObject(value);
+    if (o === null || typeof o["type"] !== "string")
       continue;
-    const o = value;
-    if (typeof o["type"] !== "string")
-      continue;
-    const t = typeof o["timestamp"] === "string" ? Date.parse(o["timestamp"]) : NaN;
-    lines2.push({ value: o, t: Number.isNaN(t) ? null : t });
+    lines2.push(recordLineOfValue(reducedLine(o)));
+  }
+  return lines2;
+}
+function viewRecord(path, deps) {
+  let text;
+  try {
+    text = (deps.readFile ?? ((p) => readFileSync15(p, "utf-8")))(path);
+  } catch {
+    return UNREADABLE2;
   }
+  const lines2 = recordLinesOf(text);
   return lines2.length === 0 ? UNREADABLE2 : { readable: true, lines: lines2 };
 }
+function readFileFrom(path, offset) {
+  const fd = openSync3(path, "r");
+  try {
+    const size = fstatSync2(fd).size;
+    if (size < offset)
+      return null;
+    const buf = Buffer.alloc(size - offset);
+    let got = 0;
+    while (got < buf.length) {
+      const n = readSync3(fd, buf, got, buf.length - got, offset + got);
+      if (n === 0)
+        break;
+      got += n;
+    }
+    return buf.subarray(0, got);
+  } finally {
+    closeSync3(fd);
+  }
+}
+function readFromOf(deps) {
+  if (deps.readFrom !== void 0)
+    return deps.readFrom;
+  const readFile = deps.readFile;
+  if (readFile === void 0)
+    return readFileFrom;
+  return (path, offset) => {
+    const bytes = Buffer.from(readFile(path), "utf-8");
+    return bytes.length < offset ? null : bytes.subarray(offset);
+  };
+}
+function viewRecordFrom(path, deps, offsets) {
+  const readFrom = readFromOf(deps);
+  const stored = offsets.files.get(path);
+  let start = stored?.offset ?? 0;
+  let prior = stored?.lines ?? [];
+  let bytes;
+  try {
+    bytes = readFrom(path, start);
+    if (bytes === null && start > 0) {
+      start = 0;
+      prior = [];
+      bytes = readFrom(path, 0);
+    }
+  } catch {
+    return UNREADABLE2;
+  }
+  if (bytes === null)
+    return UNREADABLE2;
+  const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const end = buf.lastIndexOf(10) + 1;
+  const fresh = end === 0 ? [] : recordLinesOf(buf.subarray(0, end).toString("utf-8"));
+  const values = [...prior, ...fresh.map((l) => l.value)];
+  offsets.files.set(path, { offset: start + end, lines: values });
+  const lines2 = values.map((v) => recordLineOfValue(v));
+  return lines2.length === 0 ? UNREADABLE2 : { readable: true, lines: lines2 };
+}
+var viewsOfOffsets = /* @__PURE__ */ new WeakMap();
 function recordReader(deps) {
-  const cache2 = /* @__PURE__ */ new Map();
+  let cache2 = /* @__PURE__ */ new Map();
+  if (deps.offsets !== void 0) {
+    cache2 = viewsOfOffsets.get(deps.offsets) ?? /* @__PURE__ */ new Map();
+    viewsOfOffsets.set(deps.offsets, cache2);
+  }
   return (path) => {
     if (path === null)
       return UNREADABLE2;
     const hit = cache2.get(path);
     if (hit !== void 0)
       return hit;
-    const view = viewRecord(path, deps);
+    const view = deps.offsets === void 0 ? viewRecord(path, deps) : viewRecordFrom(path, deps, deps.offsets);
     cache2.set(path, view);
     return view;
   };
 }
+var TIME_READ_OFFSETS_FILENAME = "read-offsets.json";
+function loadReadOffsets(dir, phase, openedAt) {
+  const fresh = { phase, openedAt, files: /* @__PURE__ */ new Map() };
+  try {
+    const o = plainObject(JSON.parse(readFileSync15(join11(dir, TIME_READ_OFFSETS_FILENAME), "utf-8")));
+    if (o === null || o["phase"] !== phase || o["openedAt"] !== openedAt)
+      return fresh;
+    const files = plainObject(o["files"]);
+    if (files === null)
+      return fresh;
+    const out = /* @__PURE__ */ new Map();
+    for (const [path, entry] of Object.entries(files)) {
+      const e = plainObject(entry);
+      const offset = e?.["offset"];
+      const lines2 = e?.["lines"];
+      if (typeof offset !== "number" || !Number.isSafeInteger(offset) || offset < 0 || !Array.isArray(lines2))
+        return fresh;
+      if (!lines2.every((line2) => recordLineOfValue(line2) !== null))
+        return fresh;
+      out.set(path, { offset, lines: lines2.map((line2) => reducedLine(line2)) });
+    }
+    return { phase, openedAt, files: out };
+  } catch {
+    return fresh;
+  }
+}
+function saveReadOffsets(dir, offsets) {
+  try {
+    writeJsonFile(join11(dir, TIME_READ_OFFSETS_FILENAME), { phase: offsets.phase, openedAt: offsets.openedAt, files: Object.fromEntries(offsets.files) });
+  } catch {
+  }
+}
 function isPrompt(line2) {
   const o = line2.value;
   if (o["type"] !== "user" || line2.t === null || "toolUseResult" in o)
@@ -24304,23 +24861,76 @@ function tokensOf(usage) {
   }
   return out;
 }
-function builderTaskOf(own, t) {
+var TIME_SETTLED_FILENAME = "settled.json";
+function taskNamedIn(text, taskIds) {
+  let named = null;
+  for (const id of new Set(taskIds)) {
+    if (id === "")
+      continue;
+    const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    if (!new RegExp(`(?<![A-Za-z0-9_-])${escaped}(?![A-Za-z0-9_-])`).test(text))
+      continue;
+    if (named !== null)
+      return null;
+    named = id;
+  }
+  return named;
+}
+function spawnDescriptionOf(recordPath, deps) {
+  if (!recordPath.endsWith(".jsonl"))
+    return null;
+  try {
+    const text = (deps.readFile ?? ((p) => readFileSync15(p, "utf-8")))(`${recordPath.slice(0, -".jsonl".length)}.meta.json`);
+    const value = JSON.parse(text);
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+      return null;
+    const description = value["description"];
+    return typeof description === "string" ? description : null;
+  } catch {
+    return null;
+  }
+}
+function sameFolder(a, b) {
+  const pa = folderParts(a);
+  const pb = folderParts(b);
+  return pa.length === pb.length && pa.every((part, k) => part === pb[k]);
+}
+function nextTaskOf(own, t) {
   let next;
-  let last;
   for (const lane of own) {
     if (lane.task === null)
       continue;
-    const times = lane.events.map((e) => msOf(e.at));
-    const after = times.find((at) => at > t);
+    const after = lane.events.map((e) => msOf(e.at)).find((at) => at > t);
     if (after !== void 0 && (next === void 0 || after < next.t))
       next = { task: lane.task, t: after };
-    const before = lastAtOrBefore(times, t);
+  }
+  return next?.task ?? null;
+}
+function lastTaskOf(own, t) {
+  let last;
+  for (const lane of own) {
+    if (lane.task === null)
+      continue;
+    const before = lastAtOrBefore(lane.events.map((e) => msOf(e.at)), t);
     if (before !== void 0 && (last === void 0 || before >= last.t))
       last = { task: lane.task, t: before };
   }
-  return next?.task ?? last?.task ?? null;
+  return last?.task ?? null;
+}
+function nextTaskInFolderOf(lanes, folder2, t) {
+  let next;
+  for (const lane of lanes) {
+    if (lane.task === null)
+      continue;
+    for (const e of lane.events) {
+      const at = msOf(e.at);
+      if (at > t && sameFolder(e.folder, folder2) && (next === void 0 || at < next.t))
+        next = { task: lane.task, t: at };
+    }
+  }
+  return next?.task ?? null;
 }
-function readUsage(lanes, window, deps = {}, models) {
+function readUsage(lanes, window, deps = {}, models, settling = {}) {
   const from = Date.parse(window.from);
   const to = window.to === void 0 || window.to === null ? Infinity : Date.parse(window.to);
   const inWindow = (t) => t >= from && t <= to;
@@ -24336,7 +24946,29 @@ function readUsage(lanes, window, deps = {}, models) {
     return buckets.get(key) ?? buckets.set(key, { source, task, readable, messages: 0, inputTokens: 0, outputTokens: 0, cacheWriteTokens: 0, cacheReadTokens: 0 }).get(key);
   };
   const seen = /* @__PURE__ */ new Set();
-  const count = (path, view, taskAt, builderTaskAt = () => null) => {
+  const held = /* @__PURE__ */ new Set();
+  const settled2 = settling.settled ?? /* @__PURE__ */ new Map();
+  const final = settling.final === true;
+  const figureIds = /* @__PURE__ */ new Set();
+  const addToFigure = (view) => {
+    const figure = settling.figure;
+    if (figure === void 0)
+      return;
+    for (const line2 of view.lines) {
+      if (line2.value["type"] !== "assistant" || line2.t === null || !inWindow(line2.t))
+        continue;
+      const message = plainObject(line2.value["message"]);
+      const id = message?.["id"];
+      if (typeof id !== "string" || id === "" || figureIds.has(id))
+        continue;
+      const tokens = tokensOf(message["usage"]);
+      if (tokens === null)
+        continue;
+      figureIds.add(id);
+      figure.claudeCode += tokens[0] + tokens[1] + tokens[2] + tokens[3];
+    }
+  };
+  const count = (path, view, taskAt) => {
     const source = recordSourceOf(path);
     for (const line2 of view.lines) {
       const o = line2.value;
@@ -24346,19 +24978,22 @@ function readUsage(lanes, window, deps = {}, models) {
       if (typeof message !== "object" || message === null)
         continue;
       const id = message["id"];
-      if (typeof id !== "string" || id === "" || seen.has(id))
+      if (typeof id !== "string" || id === "" || seen.has(id) || held.has(id))
         continue;
       const tokens = tokensOf(message["usage"]);
       if (tokens === null)
         continue;
+      const task = taskAt(line2, id);
+      if (task === void 0) {
+        held.add(id);
+        continue;
+      }
       seen.add(id);
-      const task = taskAt(line2);
       const bucket = bucketFor(source, task, true);
       bucket.messages += 1;
       const model = message["model"];
-      const modelTask = models === void 0 ? null : task ?? builderTaskAt(line2);
-      if (models !== void 0 && modelTask !== null && isTalliedModel(model)) {
-        const ofTask = models.get(modelTask) ?? models.set(modelTask, /* @__PURE__ */ new Map()).get(modelTask);
+      if (models !== void 0 && task !== null && isTalliedModel(model)) {
+        const ofTask = models.get(task) ?? models.set(task, /* @__PURE__ */ new Map()).get(task);
         ofTask.set(model, (ofTask.get(model) ?? 0) + 1);
       }
       bucket.inputTokens += tokens[0];
@@ -24369,42 +25004,77 @@ function readUsage(lanes, window, deps = {}, models) {
   };
   for (const main2 of mains) {
     const view = read(main2);
+    addToFigure(view);
     if (view.readable) {
+      let coordinatingFrom = Infinity;
+      for (const lane of lanes) {
+        if (lane.agent === MAIN_AGENT || lane.transcript !== main2)
+          continue;
+        for (const e of lane.events)
+          coordinatingFrom = Math.min(coordinatingFrom, msOf(e.at));
+      }
       count(main2, view, (line2) => {
+        if (line2.t >= coordinatingFrom)
+          return null;
         const branch = line2.value["gitBranch"];
         return taskOfBranch(typeof branch === "string" ? branch : null, window.taskIds);
       });
     }
-    const folder = subagentsFolderOf(main2);
-    if (folder === null)
+    const folder2 = subagentsFolderOf(main2);
+    if (folder2 === null)
       continue;
     let names;
     try {
-      names = listDir(folder).filter((name) => /^agent-[A-Za-z0-9_-]+\.jsonl$/.test(name)).sort();
+      names = listDir(folder2).filter((name) => /^agent-[A-Za-z0-9_-]+\.jsonl$/.test(name)).sort();
     } catch {
       continue;
     }
     for (const name of names) {
-      const path = `${folder}${separatorOf(main2)}${name}`;
+      const path = `${folder2}${separatorOf(main2)}${name}`;
       const view2 = read(path);
+      addToFigure(view2);
       if (!view2.readable)
         continue;
       const agent = name.slice("agent-".length, -".jsonl".length);
       const own = active.filter((lane) => lane.agent === agent && lane.transcript === main2);
       if (own.length === 0)
         continue;
-      count(path, view2, (line2) => {
+      const ownAll = lanes.filter((lane) => lane.agent === agent && lane.transcript === main2);
+      let description;
+      count(path, view2, (line2, id) => {
+        const t = line2.t;
         let best;
-        for (const lane of own) {
-          const latest = lastAtOrBefore(lane.events.map((e) => msOf(e.at)), line2.t);
+        for (const lane2 of own) {
+          const latest = lastAtOrBefore(lane2.events.map((e) => msOf(e.at)), t);
           if (latest !== void 0 && (best === void 0 || latest >= best.t))
-            best = { lane, t: latest };
+            best = { lane: lane2, t: latest };
+        }
+        const lane = best?.lane ?? [...own].sort((a, b) => msOf(a.events[0].at) - msOf(b.events[0].at))[0];
+        if (lane.task !== null)
+          return lane.task;
+        if (settled2.has(id)) {
+          const task2 = settled2.get(id);
+          return task2 !== null && window.taskIds.includes(task2) ? task2 : null;
+        }
+        const next = nextTaskOf(ownAll, t);
+        if (next !== null)
+          return next;
+        if (!final)
+          return void 0;
+        const before = lane.events.filter((e) => msOf(e.at) <= t);
+        const folder3 = (before[before.length - 1] ?? lane.events[0]).folder;
+        let task = nextTaskInFolderOf(lanes, folder3, t);
+        if (task === null) {
+          if (description === void 0)
+            description = spawnDescriptionOf(path, deps);
+          if (description !== null)
+            task = taskNamedIn(description, window.taskIds);
         }
-        if (best !== void 0)
-          return best.lane.task;
-        const first = [...own].sort((a, b) => msOf(a.events[0].at) - msOf(b.events[0].at))[0];
-        return first?.task ?? null;
-      }, (line2) => builderTaskOf(own, line2.t));
+        if (task === null)
+          task = lastTaskOf(ownAll, t);
+        settled2.set(id, task);
+        return task;
+      });
     }
   }
   const codexLanes = active.filter((lane) => lane.rollout !== null && lane.transcript === null);
@@ -24426,6 +25096,8 @@ function readUsage(lanes, window, deps = {}, models) {
           best = { lane, t: latest };
       }
       const bucket = bucketFor(source, (best?.lane ?? first)?.task ?? null, true);
+      if (settling.figure !== void 0)
+        settling.figure.codex += step.inputTokens + step.outputTokens + step.cacheWriteTokens + step.cacheReadTokens;
       bucket.messages += 1;
       bucket.inputTokens += step.inputTokens;
       bucket.outputTokens += step.outputTokens;
@@ -24446,13 +25118,13 @@ var PHASE_MODELS_FILENAME = "phase-models.json";
 function phaseModelsPath(engagementId, home) {
   if (!isEngagementId(engagementId))
     return null;
-  return join10(home ?? homedir7(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, PACING_DIR_NAME, PHASE_MODELS_FILENAME);
+  return join11(home ?? homedir8(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, PACING_DIR_NAME, PHASE_MODELS_FILENAME);
 }
 function writePhaseModels(path, phase, openedAt, tally) {
   try {
     let tasks = {};
     try {
-      const prior = phaseModelsFileSchema.safeParse(JSON.parse(readFileSync14(path, "utf-8")));
+      const prior = phaseModelsFileSchema.safeParse(JSON.parse(readFileSync15(path, "utf-8")));
       if (prior.success && prior.data.phase === phase && prior.data.openedAt === openedAt)
         tasks = prior.data.tasks;
     } catch {
@@ -24480,14 +25152,14 @@ function timeLogDir(engagementId, home) {
   return path === null ? null : dirname4(path);
 }
 function writeJsonFile(path, value) {
-  mkdirSync5(dirname4(path), { recursive: true, mode: 448 });
+  mkdirSync6(dirname4(path), { recursive: true, mode: 448 });
   const tmp = `${path}.${process.pid}.tmp`;
-  writeFileSync7(tmp, JSON.stringify(value), { mode: 384 });
-  renameSync5(tmp, path);
+  writeFileSync8(tmp, JSON.stringify(value), { mode: 384 });
+  renameSync6(tmp, path);
 }
 function readAttemptedAt(dir) {
   try {
-    const parsed = JSON.parse(readFileSync14(join10(dir, TIME_THROTTLE_FILENAME), "utf-8"));
+    const parsed = JSON.parse(readFileSync15(join11(dir, TIME_THROTTLE_FILENAME), "utf-8"));
     return typeof parsed.attemptedAt === "number" ? parsed.attemptedAt : null;
   } catch {
     return null;
@@ -24495,7 +25167,7 @@ function readAttemptedAt(dir) {
 }
 function writeAttemptedAt(dir, at) {
   try {
-    writeJsonFile(join10(dir, TIME_THROTTLE_FILENAME), { attemptedAt: at });
+    writeJsonFile(join11(dir, TIME_THROTTLE_FILENAME), { attemptedAt: at });
   } catch {
   }
 }
@@ -24513,7 +25185,7 @@ function stringRecord(value) {
 function readTimeCursor(dir, phase, openedAt) {
   const fresh = { phase, openedAt, sentThrough: null, sentIds: {}, usage: {} };
   try {
-    const o = JSON.parse(readFileSync14(join10(dir, TIME_CURSOR_FILENAME), "utf-8"));
+    const o = JSON.parse(readFileSync15(join11(dir, TIME_CURSOR_FILENAME), "utf-8"));
     if (o["phase"] !== phase || o["openedAt"] !== openedAt)
       return fresh;
     const sentThrough = o["sentThrough"];
@@ -24526,6 +25198,29 @@ function readTimeCursor(dir, phase, openedAt) {
     return fresh;
   }
 }
+function readSettled(dir, phase, openedAt) {
+  const out = /* @__PURE__ */ new Map();
+  try {
+    const o = JSON.parse(readFileSync15(join11(dir, TIME_SETTLED_FILENAME), "utf-8"));
+    if (o["phase"] !== phase || o["openedAt"] !== openedAt)
+      return out;
+    const tasks = o["tasks"];
+    if (typeof tasks !== "object" || tasks === null || Array.isArray(tasks))
+      return out;
+    for (const [id, task] of Object.entries(tasks)) {
+      if (task === null || typeof task === "string")
+        out.set(id, task);
+    }
+  } catch {
+  }
+  return out;
+}
+function writeSettled(dir, phase, openedAt, settled2) {
+  try {
+    writeJsonFile(join11(dir, TIME_SETTLED_FILENAME), { phase, openedAt, tasks: Object.fromEntries(settled2) });
+  } catch {
+  }
+}
 function usageKey(bucket) {
   return `${bucket.source}\0${bucket.task ?? ""}`;
 }
@@ -24612,33 +25307,33 @@ var PRUNE_SETTLE_MS = 50;
 async function pruneTimeLog(path, openedAt) {
   const aside = `${path}.prune-${process.pid}`;
   try {
-    renameSync5(path, aside);
+    renameSync6(path, aside);
   } catch {
     return;
   }
   let text = "";
   let written = false;
   try {
-    text = readFileSync14(aside, "utf-8");
+    text = readFileSync15(aside, "utf-8");
     const { kept } = prunedTimeLog(text, openedAt);
     if (kept !== "")
-      appendFileSync2(path, kept, { mode: 384 });
+      appendFileSync3(path, kept, { mode: 384 });
     written = true;
     let seen = Buffer.byteLength(text, "utf-8");
     for (; ; ) {
-      await new Promise((resolve11) => setTimeout(resolve11, PRUNE_SETTLE_MS));
-      const after = readFileSync14(aside);
+      await new Promise((resolve12) => setTimeout(resolve12, PRUNE_SETTLE_MS));
+      const after = readFileSync15(aside);
       if (after.length <= seen)
         break;
-      appendFileSync2(path, after.subarray(seen), { mode: 384 });
+      appendFileSync3(path, after.subarray(seen), { mode: 384 });
       seen = after.length;
     }
-    unlinkSync4(aside);
+    unlinkSync5(aside);
   } catch {
     try {
       if (!written) {
-        appendFileSync2(path, readFileSync14(aside, "utf-8"), { mode: 384 });
-        unlinkSync4(aside);
+        appendFileSync3(path, readFileSync15(aside, "utf-8"), { mode: 384 });
+        unlinkSync5(aside);
       }
     } catch {
     }
@@ -24653,7 +25348,17 @@ function conflictReason(body) {
   const error51 = body.error;
   return error51 === "basis-moved" || error51 === "phase-closed" ? error51 : null;
 }
-async function attemptTimeRecord(config2, controlOrigin, deps = {}) {
+async function attemptTimeRecord(config2, controlOrigin, deps = {}, options = {}) {
+  return (await attemptAndTell(config2, controlOrigin, deps, options)).result;
+}
+async function attemptAndTell(config2, controlOrigin, deps, options) {
+  let wroteFigure = false;
+  const result = await attemptOnce(config2, controlOrigin, deps, options, () => {
+    wroteFigure = true;
+  });
+  return { result, wroteFigure };
+}
+async function attemptOnce(config2, controlOrigin, deps, options, onFigureWritten) {
   const fetchFn = deps.fetchFn ?? globalThis.fetch;
   const base = `${controlOrigin}/engagements/${encodeURIComponent(config2.guardEngagementId)}/time`;
   const authorization = `Bearer ${config2.guardServiceToken}`;
@@ -24671,25 +25376,38 @@ async function attemptTimeRecord(config2, controlOrigin, deps = {}) {
   const basis = parsedBasis.data;
   if (basis.outcome === "nothing-to-record")
     return { outcome: "not-sent", reason: "nothing-to-record" };
-  const logPath = join10(dir, TIME_LOG_FILENAME);
+  const logPath2 = join11(dir, TIME_LOG_FILENAME);
   let text = "";
   try {
-    text = readFileSync14(logPath, "utf-8");
+    text = readFileSync15(logPath2, "utf-8");
   } catch {
     text = "";
   }
   const lanes = buildLanes(parseTimeLog(text), basis.taskIds);
-  const intervals = buildIntervals(lanes, deps);
+  const offsets = loadReadOffsets(dir, basis.phase, basis.openedAt);
+  const readDeps = { ...deps, offsets };
+  const intervals = buildIntervals(lanes, readDeps);
   const models = /* @__PURE__ */ new Map();
-  const usage = readUsage(lanes, { from: basis.openedAt, taskIds: basis.taskIds }, deps, models);
+  const settled2 = readSettled(dir, basis.phase, basis.openedAt);
+  const figure = { claudeCode: 0, codex: 0 };
+  const final = options.final === true;
+  const usage = readUsage(lanes, { from: basis.openedAt, taskIds: basis.taskIds }, readDeps, models, { final, settled: settled2, figure });
+  saveReadOffsets(dir, offsets);
+  const routing = routingFilePath(config2.guardEngagementId, deps.home);
+  if (routing !== null)
+    addCheapStarted(routing, basis.phase, tasksBuiltIn(lanes, usage, { from: basis.openedAt, taskIds: basis.taskIds }));
+  if (final)
+    writeSettled(dir, basis.phase, basis.openedAt, settled2);
   const limitDir = phaseLimitDir(config2.guardEngagementId, deps.home);
   if (limitDir !== null) {
-    writePhaseUsage(limitDir, {
+    const wrote = writePhaseUsage(limitDir, {
       phase: basis.phase,
       openedAt: basis.openedAt,
-      tokens: phaseTokensOf(usage),
+      tokens: figureOf(figure, options.agent),
       at: new Date((deps.now ?? Date.now)()).toISOString()
     });
+    if (wrote)
+      onFigureWritten();
   }
   const modelsPath = phaseModelsPath(config2.guardEngagementId, deps.home);
   if (modelsPath !== null)
@@ -24698,7 +25416,7 @@ async function attemptTimeRecord(config2, controlOrigin, deps = {}) {
   const selected = selectTimeReport(cursor, intervals, usage);
   if (selected.intervals.length === 0 && selected.usage.length === 0) {
     if (wouldPrune(text, basis.openedAt))
-      await pruneTimeLog(logPath, basis.openedAt);
+      await pruneTimeLog(logPath2, basis.openedAt);
     return { outcome: "recorded" };
   }
   const report = { phase: basis.phase, openedAt: basis.openedAt, ...selected };
@@ -24714,14 +25432,14 @@ async function attemptTimeRecord(config2, controlOrigin, deps = {}) {
   if (!timeReportResultSchema.safeParse(sent.body).success)
     return { outcome: "not-sent", reason: "refused" };
   try {
-    writeJsonFile(join10(dir, TIME_CURSOR_FILENAME), advanceTimeCursor(cursor, selected));
+    writeJsonFile(join11(dir, TIME_CURSOR_FILENAME), advanceTimeCursor(cursor, selected));
   } catch {
   }
   if (wouldPrune(text, basis.openedAt))
-    await pruneTimeLog(logPath, basis.openedAt);
+    await pruneTimeLog(logPath2, basis.openedAt);
   return { outcome: "recorded" };
 }
-async function runTimeVerb(deps = {}) {
+async function runTimeVerb(deps = {}, options = {}) {
   let result;
   try {
     const env = deps.env ?? process.env;
@@ -24731,14 +25449,14 @@ async function runTimeVerb(deps = {}) {
       result = { outcome: "not-sent", reason: "not-configured" };
     } else {
       writeAttemptedAt(dir, (deps.now ?? Date.now)());
-      result = await attemptTimeRecord(configured.config, readControlOrigin(env).origin, deps);
+      result = await attemptTimeRecord(configured.config, readControlOrigin(env).origin, deps, options);
     }
   } catch {
     result = { outcome: "not-sent", reason: "unreachable" };
   }
   return timeRunResultSchema.parse(result);
 }
-async function sendTimeRecord(deps = {}) {
+async function sendTimeRecord(deps = {}, options = {}) {
   try {
     const env = deps.env ?? process.env;
     const configured = readConfig(env);
@@ -24749,17 +25467,170 @@ async function sendTimeRecord(deps = {}) {
       return;
     const now = (deps.now ?? Date.now)();
     const last = readAttemptedAt(dir);
-    if (last !== null && now - last < TIME_MIN_INTERVAL_MS && now >= last)
-      return;
-    writeAttemptedAt(dir, now);
-    await attemptTimeRecord(configured.config, readControlOrigin(env).origin, deps);
+    let wroteFigure = false;
+    if (!(last !== null && now - last < TIME_MIN_INTERVAL_MS && now >= last)) {
+      writeAttemptedAt(dir, now);
+      wroteFigure = (await attemptAndTell(configured.config, readControlOrigin(env).origin, deps, { agent: options.agent })).wroteFigure;
+    }
+    if (!wroteFigure)
+      recountPhaseUsage(configured.config, deps, options);
+  } catch {
+  }
+}
+function recountPhaseUsage(config2, deps = {}, options = {}) {
+  try {
+    const limitDir = phaseLimitDir(config2.guardEngagementId, deps.home);
+    const dir = timeLogDir(config2.guardEngagementId, deps.home);
+    if (limitDir === null || dir === null)
+      return false;
+    const last = readPhaseUsageFile(limitDir);
+    if (last === null)
+      return false;
+    let text = "";
+    try {
+      text = readFileSync15(join11(dir, TIME_LOG_FILENAME), "utf-8");
+    } catch {
+      text = "";
+    }
+    const lanes = buildLanes(parseTimeLog(text), []);
+    const offsets = loadReadOffsets(dir, last.phase, last.openedAt);
+    const figure = { claudeCode: 0, codex: 0 };
+    readUsage(lanes, { from: last.openedAt, taskIds: [] }, { ...deps, offsets }, void 0, { figure });
+    saveReadOffsets(dir, offsets);
+    return writePhaseUsage(limitDir, {
+      phase: last.phase,
+      openedAt: last.openedAt,
+      tokens: figureOf(figure, options.agent),
+      at: new Date((deps.now ?? Date.now)()).toISOString()
+    });
+  } catch {
+    return false;
+  }
+}
+function figureOf(figure, agent) {
+  return Math.max(0, Math.round(agent === "codex" ? figure.codex : figure.claudeCode));
+}
+var ROUTING_LOCK_FILENAME = "routing.lock";
+var ROUTING_LOCK_GIVE_UP_MS = 50;
+var ROUTING_LOCK_STALE_MS = 5 * 1e3;
+var ROUTING_LOCK_POLL_MS = 2;
+function routingFilePath(engagementId, home) {
+  if (!isEngagementId(engagementId))
+    return null;
+  return join11(home ?? homedir8(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, ROUTING_FILENAME);
+}
+function sleepSync2(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function addCheapStarted(path, phase, tasks, giveUpMs = ROUTING_LOCK_GIVE_UP_MS) {
+  if (tasks.length === 0)
+    return true;
+  try {
+    const lock = join11(dirname4(path), ROUTING_LOCK_FILENAME);
+    const giveUpAt = Date.now() + giveUpMs;
+    while (!tryTakeLockFile(lock, ROUTING_LOCK_STALE_MS)) {
+      if (Date.now() >= giveUpAt)
+        return false;
+      sleepSync2(ROUTING_LOCK_POLL_MS);
+    }
+    try {
+      let started = [];
+      try {
+        const parsed = routingRecordSchema.safeParse(JSON.parse(readFileSync15(path, "utf-8")));
+        if (parsed.success && parsed.data.phase === phase)
+          started = [...parsed.data.cheapStarted];
+      } catch {
+        started = [];
+      }
+      const added = tasks.filter((t, i) => !started.includes(t) && tasks.indexOf(t) === i);
+      if (added.length === 0)
+        return true;
+      const record2 = { phase, cheapStarted: [...started, ...added] };
+      if (!routingRecordSchema.safeParse(record2).success)
+        return false;
+      writeJsonFile(path, record2);
+      return true;
+    } finally {
+      releaseLockFile(lock);
+    }
+  } catch {
+    return false;
+  }
+}
+function recordSpawnedTask(toolInput, deps) {
+  try {
+    if (typeof toolInput !== "object" || toolInput === null || Array.isArray(toolInput))
+      return null;
+    const engagementId = readConfig(deps.env ?? process.env).config?.guardEngagementId;
+    if (engagementId === void 0)
+      return null;
+    const path = routingFilePath(engagementId, deps.home);
+    if (path === null)
+      return null;
+    const parsed = taskPlanSchema.safeParse(JSON.parse(readFileSync15(join11(deps.projectDir, TASK_PLAN_FILE), "utf-8")));
+    if (!parsed.success)
+      return null;
+    const plan = parsed.data;
+    const ids = plan.tasks.map((t) => t.id);
+    const textOf = (key) => {
+      const v = toolInput[key];
+      return typeof v === "string" ? v : null;
+    };
+    const description = textOf("description");
+    const prompt = textOf("prompt");
+    const named = (description === null ? null : taskNamedIn(description, ids)) ?? (prompt === null ? null : taskNamedIn(prompt, ids));
+    if (named === null)
+      return null;
+    const task = plan.tasks.find((t) => t.id === named);
+    if (task === void 0 || task.kind !== "build" || task.cheapFirst !== true)
+      return null;
+    return addCheapStarted(path, plan.phase, [named]) ? named : null;
   } catch {
+    return null;
+  }
+}
+function tasksBuiltIn(lanes, usage, window) {
+  const from = Date.parse(window.from);
+  const to = window.to === void 0 || window.to === null ? Infinity : Date.parse(window.to);
+  const inWindow = (t) => t >= from && t <= to;
+  const out = [];
+  const add = (task) => {
+    if (task !== null && window.taskIds.includes(task) && !out.includes(task))
+      out.push(task);
+  };
+  for (const bucket of usage)
+    if (bucket.messages > 0)
+      add(bucket.task);
+  for (const lane of lanes) {
+    if (lane.task === null)
+      continue;
+    const times = lane.events.map((e) => msOf(e.at)).filter(inWindow);
+    if (times.length === 0)
+      continue;
+    const codex = lane.rollout !== null && lane.transcript === null;
+    if (lane.agent !== MAIN_AGENT || codex) {
+      add(lane.task);
+      continue;
+    }
+    let coordinatingFrom = Infinity;
+    for (const other of lanes) {
+      if (other.agent === MAIN_AGENT)
+        continue;
+      const sameSession = lane.session !== null ? other.session === lane.session : lane.transcript !== null && other.transcript === lane.transcript;
+      if (!sameSession)
+        continue;
+      for (const e of other.events)
+        coordinatingFrom = Math.min(coordinatingFrom, msOf(e.at));
+    }
+    if (times.some((t) => t < coordinatingFrom))
+      add(lane.task);
   }
+  return out;
 }
 
 // dist/own-work.js
-import { appendFileSync as appendFileSync3, lstatSync as lstatSync2, readFileSync as readFileSync15, realpathSync as realpathSync6 } from "node:fs";
-import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute2, join as join11, relative as relative5, resolve as resolve4, sep as sep3 } from "node:path";
+import { appendFileSync as appendFileSync4, lstatSync as lstatSync2, readFileSync as readFileSync16, realpathSync as realpathSync6 } from "node:fs";
+import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute2, join as join12, relative as relative5, resolve as resolve4, sep as sep3 } from "node:path";
 
 // dist/risky/types.js
 var RISKY_ACTION_TYPES = [
@@ -24793,7 +25664,7 @@ function ownWorkFileName(sessionId) {
 function ownWorkPath(sessionId, dir) {
   if (typeof sessionId !== "string" || !livenessIdOk(sessionId))
     return null;
-  return join11(dir ?? markerDir(), ownWorkFileName(sessionId));
+  return join12(dir ?? markerDir(), ownWorkFileName(sessionId));
 }
 function inputString2(input, key) {
   if (typeof input !== "object" || input === null)
@@ -24811,7 +25682,7 @@ function append(sessionId, line2, dir) {
   const path = ownWorkPath(sessionId, dir);
   if (path === null)
     return;
-  appendFileSync3(path, `${JSON.stringify(line2)}
+  appendFileSync4(path, `${JSON.stringify(line2)}
 `, { mode: 384 });
 }
 function recordOwnShell(input, at, deps = {}) {
@@ -24857,7 +25728,7 @@ function readOwnWork(sessionId, dir) {
     const path = ownWorkPath(sessionId, dir);
     if (path === null)
       return [];
-    return parseOwnWork(readFileSync15(path, "utf-8"));
+    return parseOwnWork(readFileSync16(path, "utf-8"));
   } catch {
     return [];
   }
@@ -24892,7 +25763,7 @@ function realPathOf(path) {
   let at = resolve4(path);
   for (; ; ) {
     try {
-      return join11(realpathSync6.native(at), ...missing.reverse());
+      return join12(realpathSync6.native(at), ...missing.reverse());
     } catch {
       const parent = dirname5(at);
       if (parent === at)
@@ -24952,7 +25823,7 @@ function ownChangedFiles(repoRoot, files, sessionId, deps = {}) {
   };
   const root = resolve4(repoRoot);
   return files.filter((rel) => {
-    const abs = join11(root, rel);
+    const abs = join12(root, rel);
     if (edited.has(realPathOf(abs)))
       return true;
     if (windows.length === 0)
@@ -24966,7 +25837,7 @@ function ownChangedFiles(repoRoot, files, sessionId, deps = {}) {
 
 // dist/hooks/findings.js
 import { createHash as createHash4, randomUUID as randomUUID2 } from "node:crypto";
-import { closeSync as closeSync3, existsSync as existsSync6, openSync as openSync3, readFileSync as readFileSync16, renameSync as renameSync6, statSync as statSync4, unlinkSync as unlinkSync5, writeFileSync as writeFileSync8 } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync7, openSync as openSync4, readFileSync as readFileSync17, renameSync as renameSync7, statSync as statSync4, unlinkSync as unlinkSync6, writeFileSync as writeFileSync9 } from "node:fs";
 function findingKey(firing) {
   return createHash4("sha256").update(`${firing.guardId}
 ${firing.path ?? ""}
@@ -25009,7 +25880,7 @@ function readFindings(sessionId) {
     return null;
   const session = sessionId;
   try {
-    const parsed = JSON.parse(readFileSync16(path, "utf-8"));
+    const parsed = JSON.parse(readFileSync17(path, "utf-8"));
     if (parsed["version"] !== 1 || !Array.isArray(parsed["findings"]))
       return emptyFindings(session);
     const findings = [];
@@ -25029,12 +25900,12 @@ function writeFindings(file2) {
     return;
   const temp = `${path.slice(0, -".json".length)}.${process.pid}.tmp.json`;
   try {
-    writeFileSync8(temp, `${JSON.stringify(file2)}
+    writeFileSync9(temp, `${JSON.stringify(file2)}
 `, { mode: 384 });
-    renameSync6(temp, path);
+    renameSync7(temp, path);
   } catch {
     try {
-      unlinkSync5(temp);
+      unlinkSync6(temp);
     } catch {
     }
   }
@@ -25050,7 +25921,7 @@ function pause(ms) {
 function takeOverStaleLock(lock) {
   const aside = `${lock}.${process.pid}.${randomUUID2()}.stale`;
   try {
-    renameSync6(lock, aside);
+    renameSync7(lock, aside);
   } catch {
     return false;
   }
@@ -25062,17 +25933,17 @@ function takeOverStaleLock(lock) {
   }
   if (!staleIndeed) {
     try {
-      renameSync6(aside, lock);
+      renameSync7(aside, lock);
     } catch {
       try {
-        unlinkSync5(aside);
+        unlinkSync6(aside);
       } catch {
       }
     }
     return false;
   }
   try {
-    unlinkSync5(aside);
+    unlinkSync6(aside);
   } catch {
   }
   return true;
@@ -25085,7 +25956,7 @@ function withFindingsLock(sessionId, body, waitMs = FINDINGS_LOCK_WAIT_MS) {
   const deadline = Date.now() + waitMs;
   for (; ; ) {
     try {
-      closeSync3(openSync3(lock, "wx", 384));
+      closeSync4(openSync4(lock, "wx", 384));
       break;
     } catch (err) {
       if (err.code !== "EEXIST")
@@ -25107,31 +25978,31 @@ function withFindingsLock(sessionId, body, waitMs = FINDINGS_LOCK_WAIT_MS) {
     return body();
   } finally {
     try {
-      unlinkSync5(lock);
+      unlinkSync6(lock);
     } catch {
     }
   }
 }
-function takeUndelivered(file2, folder) {
+function takeUndelivered(file2, folder2) {
   const taken = [];
   const findings = file2.findings.map((f) => {
-    if (f.delivered || folder !== null && f.folder !== folder)
+    if (f.delivered || folder2 !== null && f.folder !== folder2)
       return f;
     taken.push(f);
     return { ...f, delivered: true };
   });
   return { file: { ...file2, findings }, taken };
 }
-function deliverFindings(sessionId, folder) {
+function deliverFindings(sessionId, folder2) {
   const path = findingsPath(sessionId);
-  if (path === null || !existsSync6(path))
+  if (path === null || !existsSync7(path))
     return [];
   try {
     const taken = withFindingsLock(sessionId, () => {
       const before = readFindings(sessionId);
       if (before === null)
         return [];
-      const { file: file2, taken: given } = takeUndelivered(before, folder);
+      const { file: file2, taken: given } = takeUndelivered(before, folder2);
       if (given.length > 0)
         writeFindings(file2);
       return given;
@@ -25141,11 +26012,11 @@ function deliverFindings(sessionId, folder) {
     return [];
   }
 }
-function turnEndBookkeeping(file2, folder, outcome, topLevel, now) {
+function turnEndBookkeeping(file2, folder2, outcome, topLevel, now) {
   const recorded = [...file2.findings];
   const firing = /* @__PURE__ */ new Map();
   const notRun = new Set(outcome.kind === "evaluated" ? outcome.notRun : []);
-  const observed = (f) => f.folder === folder && !notRun.has(f.patternRef);
+  const observed = (f) => f.folder === folder2 && !notRun.has(f.patternRef);
   if (outcome.kind === "evaluated") {
     for (const g of outcome.fired) {
       if (g.severity === "block")
@@ -25161,13 +26032,13 @@ function turnEndBookkeeping(file2, folder, outcome, topLevel, now) {
     const closes = observed(f) && (outcome.kind === "no-own-changes" || outcome.kind === "evaluated" && !firing.has(f.key));
     (closes ? removed : kept).push(f);
   }
-  const known = new Set(kept.filter((f) => f.folder === folder).map((f) => f.key));
+  const known = new Set(kept.filter((f) => f.folder === folder2).map((f) => f.key));
   for (const [key, g] of firing) {
     if (known.has(key))
       continue;
     kept.push({
       key,
-      folder,
+      folder: folder2,
       guardId: g.guardId,
       patternRef: g.patternRef,
       severity: g.severity,
@@ -25362,7 +26233,7 @@ function patchHeaderPaths(patch) {
 }
 
 // dist/hooks/post-tool-use.js
-import { isAbsolute as isAbsolute3, join as join12, relative as relative6, resolve as resolve5, sep as sep4 } from "node:path";
+import { isAbsolute as isAbsolute3, join as join13, relative as relative6, resolve as resolve5, sep as sep4 } from "node:path";
 var HANDLED_EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
 async function runPostToolUse(readSeat = readSeatConfiguration, profile = AGENT_PROFILES["claude-code"]) {
   const reply = hookReply("PostToolUse", profile);
@@ -25549,7 +26420,7 @@ function insideRepository(path, repoRoot) {
   const rel = relative6(realPathOf(repoRoot), realPathOf(path));
   if (rel === "" || rel === ".." || rel.startsWith(`..${sep4}`) || isAbsolute3(rel))
     return null;
-  return join12(repoRoot, rel);
+  return join13(repoRoot, rel);
 }
 function actOnEnvelope2(envelope, reply) {
   const notRun = notRunReport(envelope.notRun);
@@ -25572,17 +26443,17 @@ ${guardLines}${notRunBlock}`);
   }
 }
 function readStdin() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve11(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("end", () => resolve12(Buffer.concat(chunks).toString("utf-8")));
     process.stdin.on("error", reject);
   });
 }
 
 // dist/liveness.js
-import { closeSync as closeSync4, mkdtempSync, openSync as openSync4, readdirSync as readdirSync7, readFileSync as readFileSync17, renameSync as renameSync7, rmSync as rmSync2, statSync as statSync5, unlinkSync as unlinkSync6, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join13 } from "node:path";
+import { closeSync as closeSync5, mkdtempSync, openSync as openSync5, readdirSync as readdirSync7, readFileSync as readFileSync18, renameSync as renameSync8, rmSync as rmSync2, statSync as statSync5, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join14 } from "node:path";
 var LIVE_WINDOW_MS = 10 * 60 * 1e3;
 function field(input, key) {
   if (typeof input !== "object" || input === null)
@@ -25591,10 +26462,10 @@ function field(input, key) {
   return typeof v === "string" && v !== "" ? v : null;
 }
 function indexEntry(dir, sessionId, name) {
-  const folder = join13(dir, livenessIndexDirName(sessionId));
+  const folder2 = join14(dir, livenessIndexDirName(sessionId));
   for (let attempt2 = 0; attempt2 < 3; attempt2++) {
     try {
-      closeSync4(openSync4(join13(folder, name), "a", 384));
+      closeSync5(openSync5(join14(folder2, name), "a", 384));
       return true;
     } catch (err) {
       if (err.code !== "ENOENT")
@@ -25602,13 +26473,13 @@ function indexEntry(dir, sessionId, name) {
     }
     let tmp = null;
     try {
-      tmp = mkdtempSync(`${folder}.`);
+      tmp = mkdtempSync(`${folder2}.`);
       for (const existing of readdirSync7(dir)) {
         if (parseLivenessFileName(existing)?.sessionId === sessionId)
-          closeSync4(openSync4(join13(tmp, existing), "a", 384));
+          closeSync5(openSync5(join14(tmp, existing), "a", 384));
       }
-      closeSync4(openSync4(join13(tmp, name), "a", 384));
-      renameSync7(tmp, folder);
+      closeSync5(openSync5(join14(tmp, name), "a", 384));
+      renameSync8(tmp, folder2);
       return true;
     } catch {
       if (tmp !== null)
@@ -25633,18 +26504,18 @@ function recordLiveness(input, deps = {}) {
     const name = livenessFileName(livenessKey(copy?.common ?? null), sessionId, agentId);
     if (!indexEntry(dir, sessionId, name))
       return null;
-    const path = join13(dir, name);
+    const path = join14(dir, name);
     const text = `${cwd}
 ${copy?.top ?? ""}
 `;
     try {
-      writeFileSync9(path, text, { encoding: "utf-8", flag: "wx", mode: 384 });
+      writeFileSync10(path, text, { encoding: "utf-8", flag: "wx", mode: 384 });
       return { firstSeen: true };
     } catch (err) {
       if (err.code !== "EEXIST")
         return null;
     }
-    writeFileSync9(path, text, { encoding: "utf-8", mode: 384 });
+    writeFileSync10(path, text, { encoding: "utf-8", mode: 384 });
     return { firstSeen: false };
   } catch {
     return null;
@@ -25663,7 +26534,7 @@ function clearLiveness(input, deps = {}) {
       if (p === null || p.sessionId !== sessionId || p.agentId !== agentId)
         continue;
       try {
-        unlinkSync6(join13(dir, name));
+        unlinkSync7(join14(dir, name));
         removed += 1;
       } catch {
       }
@@ -25676,7 +26547,7 @@ function clearLiveness(input, deps = {}) {
 }
 function topOf(path) {
   try {
-    const top = readFileSync17(path, "utf-8").split("\n")[1] ?? "";
+    const top = readFileSync18(path, "utf-8").split("\n")[1] ?? "";
     return top === "" ? null : top;
   } catch {
     return null;
@@ -25698,7 +26569,7 @@ function readLiveness(sessionId, cwd, deps = {}) {
       const p = parseLivenessFileName(name);
       if (p === null || p.key !== key || p.sessionId !== sessionId)
         continue;
-      const full = join13(dir, name);
+      const full = join14(dir, name);
       let seenAt;
       try {
         seenAt = statSync5(full).mtimeMs;
@@ -25744,168 +26615,8 @@ import nodePath5 from "node:path";
 
 // dist/pace-verb.js
 import { mkdirSync as mkdirSync7, readdirSync as readdirSync8, readFileSync as readFileSync19, renameSync as renameSync9, statSync as statSync6, writeFileSync as writeFileSync11 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir9 } from "node:os";
 import nodePath4 from "node:path";
-
-// dist/scan-lock.js
-import { spawn } from "node:child_process";
-import { linkSync, mkdirSync as mkdirSync6, readFileSync as readFileSync18, renameSync as renameSync8, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "node:fs";
-import nodePath3 from "node:path";
-var SCAN_LOCK_FILENAME = "scan.lock";
-var SCAN_LOCK_STALE_MS = 15 * 60 * 1e3;
-var SCAN_LOCK_POLL_MS = 100;
-function scanLockPath(home) {
-  return nodePath3.join(pacingDir(home), SCAN_LOCK_FILENAME);
-}
-function readLockBody(path) {
-  let text;
-  try {
-    text = readFileSync18(path, "utf-8");
-  } catch (err) {
-    return err.code === "ENOENT" ? "missing" : null;
-  }
-  try {
-    const v = JSON.parse(text);
-    return typeof v["pid"] === "number" && typeof v["at"] === "number" ? { pid: v["pid"], at: v["at"] } : null;
-  } catch {
-    return null;
-  }
-}
-function processAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
-  }
-}
-function isStale(body, staleMs, deps) {
-  if (body === null)
-    return true;
-  const now = (deps.clock ?? Date.now)();
-  if (Math.abs(now - body.at) > staleMs)
-    return true;
-  return !(deps.alive ?? processAlive)(body.pid);
-}
-function writeLock(path, pid, deps, flag) {
-  writeFileSync10(path, JSON.stringify({ pid, at: (deps.clock ?? Date.now)() }), { flag, mode: 384 });
-}
-function tryTakeScanLock(deps = {}) {
-  return tryTakeLockFile(scanLockPath(deps.home), SCAN_LOCK_STALE_MS, deps);
-}
-function tryTakeLockFile(path, staleMs, deps = {}) {
-  const pid = deps.pid ?? process.pid;
-  try {
-    mkdirSync6(nodePath3.dirname(path), { recursive: true, mode: 448 });
-  } catch {
-    return false;
-  }
-  for (let attempt2 = 0; attempt2 < 2; attempt2++) {
-    try {
-      writeLock(path, pid, deps, "wx");
-      return true;
-    } catch (err) {
-      if (err.code !== "EEXIST")
-        return false;
-    }
-    const seen = readLockBody(path);
-    if (seen === "missing")
-      continue;
-    if (!isStale(seen, staleMs, deps))
-      return false;
-    const aside = `${path}.${String(pid)}.${String((deps.clock ?? Date.now)())}.stale`;
-    try {
-      renameSync8(path, aside);
-    } catch {
-      continue;
-    }
-    const taken = readLockBody(aside);
-    const same = taken !== "missing" && (seen === null ? taken === null : taken !== null && taken.pid === seen.pid && taken.at === seen.at);
-    if (!same && taken !== "missing" && !isStale(taken, staleMs, deps)) {
-      try {
-        linkSync(aside, path);
-      } catch {
-      }
-      try {
-        unlinkSync7(aside);
-      } catch {
-      }
-      return false;
-    }
-    try {
-      unlinkSync7(aside);
-    } catch {
-    }
-  }
-  return false;
-}
-function releaseLockFile(path, pid = process.pid) {
-  const body = readLockBody(path);
-  if (body === "missing" || body === null || body.pid !== pid)
-    return;
-  try {
-    unlinkSync7(path);
-  } catch {
-  }
-}
-function releaseScanLock(deps = {}) {
-  releaseLockFile(scanLockPath(deps.home), deps.pid ?? process.pid);
-}
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-function scanUnderLock(key, deps = {}, waitMs = 0) {
-  const clock = deps.clock ?? Date.now;
-  const giveUpAt = clock() + waitMs;
-  while (!tryTakeScanLock(deps)) {
-    if (clock() >= giveUpAt)
-      return null;
-    sleepSync(SCAN_LOCK_POLL_MS);
-  }
-  try {
-    return scanRecords(key, deps);
-  } finally {
-    releaseScanLock(deps);
-  }
-}
-var spawnDetachedReal = (command, args2) => {
-  const child = spawn(command, [...args2], { detached: true, stdio: "ignore", windowsHide: true });
-  child.on("error", () => void 0);
-  child.unref();
-  return child.pid;
-};
-function startScanChild(key, binaryPath, deps = {}) {
-  if (!tryTakeScanLock(deps))
-    return false;
-  let childPid;
-  try {
-    childPid = (deps.spawnDetached ?? spawnDetachedReal)(deps.nodePath ?? process.execPath, [
-      binaryPath,
-      "pace",
-      "--scan",
-      "--config-folder",
-      key,
-      "--lock-held"
-    ]);
-  } catch {
-    childPid = void 0;
-  }
-  if (childPid === void 0) {
-    releaseScanLock(deps);
-    return false;
-  }
-  try {
-    writeLock(scanLockPath(deps.home), childPid, deps, "w");
-  } catch {
-    releaseScanLock(deps);
-    return false;
-  }
-  return true;
-}
-
-// dist/pace-verb.js
 var PACE_DEFAULT_TASK_MINUTES = 30;
 var PACE_DURATION_ROUND_MINUTES = 10;
 var PACE_WINDOW_MINUTES = 300;
@@ -26027,7 +26738,7 @@ function suggestPace(input) {
 function enginePacingDir(engagementId, home) {
   if (!isEngagementId(engagementId))
     return null;
-  return nodePath4.join(home ?? homedir8(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, PACING_DIR_NAME);
+  return nodePath4.join(home ?? homedir9(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, PACING_DIR_NAME);
 }
 function readBuildNumber(engagementId, home) {
   const dir = enginePacingDir(engagementId, home);
@@ -26085,7 +26796,7 @@ var USAGE = "Usage: halfcycle-runner pace [--agent claude-code|codex] [--start <
 function parsePaceArgs(args2) {
   let scan = false;
   let lockHeld = false;
-  let folder = null;
+  let folder2 = null;
   let phase = null;
   let agents = null;
   let agent = null;
@@ -26103,8 +26814,8 @@ function parsePaceArgs(args2) {
     else if (a === "--lock-held")
       lockHeld = true;
     else if (a === "--config-folder") {
-      folder = value();
-      if (folder === null)
+      folder2 = value();
+      if (folder2 === null)
         return { kind: "usage", message: USAGE };
     } else if (a === "--start") {
       phase = value();
@@ -26125,9 +26836,9 @@ function parsePaceArgs(args2) {
   if (scan) {
     if (phase !== null || agents !== null || agent !== null)
       return { kind: "usage", message: USAGE };
-    return { kind: "scan", folder, lockHeld };
+    return { kind: "scan", folder: folder2, lockHeld };
   }
-  if (folder !== null || lockHeld)
+  if (folder2 !== null || lockHeld)
     return { kind: "usage", message: USAGE };
   if (phase === null)
     return agents === null ? { kind: "now", agent: agent ?? "claude-code" } : { kind: "usage", message: USAGE };
@@ -26210,7 +26921,7 @@ async function runPaceVerb(args2, deps = {}) {
         ...deps.home === void 0 ? {} : { home: deps.home },
         now: () => now.getTime(),
         ...deps.fetchFn === void 0 ? {} : { fetchFn: deps.fetchFn }
-      });
+      }, { agent: parsed.agent });
     } catch {
     }
     const remembered = readPaceStateFile(pacingDir2).basis;
@@ -26298,6 +27009,7 @@ async function runPaceVerb(args2, deps = {}) {
       ...decision.until !== null ? { until: decision.until.toISOString() } : {},
       keepFreePercent,
       ...suggestion !== void 0 ? { suggestion } : {},
+      ...limitFile !== null ? { usage: { used: readPhaseUsage(pacingDir2, limitFile.phase), limit: limitFile.limit } } : {},
       ...atLimit ? {
         limit: "reached",
         limitHeld: {
@@ -26445,10 +27157,10 @@ async function paceAtTurnEnd(input, reply, deps = {}) {
     const basis = read !== null ? { phase: read.phase, keepFreePercent: read.keepFreePercent } : stored.basis;
     if (basis === null)
       return;
-    const write = deps.writeState ?? writePaceState;
+    const write2 = deps.writeState ?? writePaceState;
     if (basis.phase === null) {
       if (before !== null || read !== null)
-        write(dir, key, null, read !== null ? basis : null);
+        write2(dir, key, null, read !== null ? basis : null);
       return;
     }
     const working = liveCount(readLiveness(field2(input, "session_id"), field2(input, "cwd") ?? process.cwd(), deps.liveness));
@@ -26475,7 +27187,8 @@ async function paceAtTurnEnd(input, reply, deps = {}) {
       }
     }
     const reported = readReportedAccount(key, { home: deps.home });
-    const number4 = buildNumberFor(engagementId, basis.phase, deps.home)?.number ?? CAREFUL_START_AGENTS;
+    const build = buildNumberFor(engagementId, basis.phase, deps.home);
+    const number4 = build?.number ?? CAREFUL_START_AGENTS;
     const decision = paceOf({ number: number4, keepFreePercent: basis.keepFreePercent, learned, reported, now });
     const settled2 = {
       pace: decision.pace,
@@ -26489,9 +27202,9 @@ async function paceAtTurnEnd(input, reply, deps = {}) {
     };
     const told = before === null || before.told === void 0 ? before : { ...before, ...before.told };
     const text = paceChangeText(told, settled2, working, now, basis.keepFreePercent);
-    const offer = text === null ? offerText(settled2, learned, reported, now, basis.keepFreePercent) : null;
+    const offer = text === null && build !== null ? offerText(settled2, learned, reported, now, basis.keepFreePercent) : null;
     const after = offer === null ? settled2 : { ...settled2, offeredFor: offeredForNow(settled2.offeredFor, offer.resetsAt, now) };
-    write(dir, key, after, read !== null ? basis : null);
+    write2(dir, key, after, read !== null ? basis : null);
     if (text !== null)
       reply.notice(text);
     else if (offer !== null)
@@ -26542,7 +27255,7 @@ function pruneStarts(file2, nowMs) {
   }
   return out;
 }
-function sleepSync2(ms) {
+function sleepSync3(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 function underStartsLock(dir, giveUpMs, fn) {
@@ -26551,7 +27264,7 @@ function underStartsLock(dir, giveUpMs, fn) {
   while (!tryTakeLockFile(lock, PACE_STARTS_LOCK_STALE_MS)) {
     if (Date.now() >= giveUpAt)
       return void 0;
-    sleepSync2(STARTS_LOCK_POLL_MS);
+    sleepSync3(STARTS_LOCK_POLL_MS);
   }
   try {
     return fn();
@@ -26646,9 +27359,9 @@ function paceHoldText(input, toolInput, deps = {}) {
 }
 
 // dist/risky/facts.js
-import { existsSync as existsSync7, lstatSync as lstatSync3, readdirSync as readdirSync9, readFileSync as readFileSync21, realpathSync as realpathSync7, statSync as statSync7 } from "node:fs";
-import { homedir as homedir9, tmpdir as tmpdir2 } from "node:os";
-import { basename as pathBasename, dirname as dirname6, isAbsolute as isAbsolute4, join as join14, relative as relative7, resolve as resolve6, sep as sep5 } from "node:path";
+import { existsSync as existsSync8, lstatSync as lstatSync3, readdirSync as readdirSync9, readFileSync as readFileSync21, realpathSync as realpathSync7, statSync as statSync7 } from "node:fs";
+import { homedir as homedir10, tmpdir as tmpdir2 } from "node:os";
+import { basename as pathBasename, dirname as dirname6, isAbsolute as isAbsolute4, join as join15, relative as relative7, resolve as resolve6, sep as sep5 } from "node:path";
 
 // dist/risky/shell.js
 var MAX_DEPTH = 8;
@@ -27828,7 +28541,7 @@ function readLine(commands, vars, gitEnv, savedTrusted) {
     }
     vars.enter(own);
     const simple = expandCommand(raw, vars);
-    const folder = folderIn(simple);
+    const folder2 = folderIn(simple);
     for (const m of recogniseSimple(simple)) {
       const trusted = m.type === "shrink-record" && m.change.kind === "saved" && !savedTrusted ? { ...m, change: { kind: "emptied" } } : m;
       let shown2 = trusted;
@@ -27844,7 +28557,7 @@ function readLine(commands, vars, gitEnv, savedTrusted) {
       }
       matches.push({
         ...shown2,
-        ...folder === void 0 ? {} : { folder },
+        ...folder2 === void 0 ? {} : { folder: folder2 },
         ...made.size === 0 ? {} : { made: new Map(made) },
         ...madeInChain.size === 0 ? {} : { madeInChain: new Set(madeInChain) },
         ...removedInChain.size === 0 ? {} : { removedInChain: new Set(removedInChain) },
@@ -27852,9 +28565,9 @@ function readLine(commands, vars, gitEnv, savedTrusted) {
         ...vars.stoppedIf.length === 0 ? {} : { stoppedIf: [...vars.stoppedIf] }
       });
     }
-    if (surelyRuns(simple, own) && (folder === void 0 || folder.known)) {
+    if (surelyRuns(simple, own) && (folder2 === void 0 || folder2.known)) {
       for (const p of pathsMade(simple)) {
-        const key = madeKey(folder?.dirs ?? [], p.word);
+        const key = madeKey(folder2?.dirs ?? [], p.word);
         made.set(key, p.by);
         if (simple.next === "&&")
           madeInChain.add(key);
@@ -27862,12 +28575,12 @@ function readLine(commands, vars, gitEnv, savedTrusted) {
       if (simple.next === "&&" && simple.words[0]?.text === "rmdir") {
         for (const w of simple.words.slice(1))
           if (w.literal && !w.text.startsWith("-"))
-            removedInChain.add(madeKey(folder?.dirs ?? [], w));
+            removedInChain.add(madeKey(folder2?.dirs ?? [], w));
       }
     }
     const nextCmd = commands[i + 1];
     const asJoined = simple.next !== void 0 && (nextCmd === void 0 || scopeKey(nextCmd) !== scopeKey(simple)) ? { ...simple, next: void 0 } : simple;
-    const after = folderAfter(folder, asJoined, own);
+    const after = folderAfter(folder2, asJoined, own);
     folders.set(scopeKey(simple), after);
     vars.guard = chainCds === null ? null : [...chainCds];
     vars.update(raw, own);
@@ -28860,7 +29573,7 @@ var Env = class {
   constructor(ctx) {
     this.projectDir = realOrSelf(resolve6(ctx.projectDir));
     this.cwd = realOrSelf(resolve6(this.projectDir, ctx.cwd));
-    this.home = realOrSelf(resolve6(ctx.home ?? homedir9()));
+    this.home = realOrSelf(resolve6(ctx.home ?? homedir10()));
     this.timeoutMs = ctx.gitTimeoutMs ?? FACTS_GIT_TIMEOUT_MS;
     this.tempDir = realOrSelf(resolve6(ctx.tempDir ?? tmpdir2()));
     const roots = ctx.tempRoots ?? [this.tempDir, tmpdir2(), ...TEMP_ROOTS];
@@ -28884,7 +29597,7 @@ var Env = class {
       return this.description;
     this.description = null;
     try {
-      const raw = JSON.parse(readFileSync21(join14(repoRoot, SYSTEM_DESCRIPTION_REL), "utf-8"));
+      const raw = JSON.parse(readFileSync21(join15(repoRoot, SYSTEM_DESCRIPTION_REL), "utf-8"));
       const checked = checkSystemDescription(raw);
       if (checked.ok)
         this.description = checked.description;
@@ -28948,18 +29661,18 @@ function resolveHome(text, home, base) {
   if (text === "~")
     return home;
   if (text.startsWith("~/"))
-    return join14(home, text.slice(2));
+    return join15(home, text.slice(2));
   return resolve6(base, text);
 }
 function realTarget(abs) {
   const parent = dirname6(abs);
   if (parent === abs)
     return abs;
-  return join14(realOrSelf(parent), pathBasename(abs));
+  return join15(realOrSelf(parent), pathBasename(abs));
 }
 function wordPath(word, base, env) {
   if (word.temp !== void 0) {
-    const root = word.temp.base === "mktemp" ? join14(env.tempDir, ".halfcycle-mktemp-new") : env.tempDir;
+    const root = word.temp.base === "mktemp" ? join15(env.tempDir, ".halfcycle-mktemp-new") : env.tempDir;
     return resolve6(`${root}${word.temp.suffix}`);
   }
   return word.literal ? resolveHome(word.text, env.home, base) : null;
@@ -29105,7 +29818,7 @@ function globPath(abs) {
     const next = [];
     if (!/[*?[]/.test(segment)) {
       for (const c of current)
-        next.push(join14(c, segment));
+        next.push(join15(c, segment));
     } else {
       const re = segmentPattern(segment);
       for (const c of current) {
@@ -29119,7 +29832,7 @@ function globPath(abs) {
           if (n.startsWith(".") && !segment.startsWith("."))
             continue;
           if (re.test(n))
-            next.push(join14(c, n));
+            next.push(join15(c, n));
         }
       }
     }
@@ -29247,7 +29960,7 @@ function findKeeps(filter, roots, repoRoot) {
   const names = filter.names.map((n) => findPattern(n.pattern, n.fold, false));
   const excluded = filter.excluded.map((p) => findPattern(p, false, true));
   const steps = (rel) => {
-    const abs = join14(repoRoot, rel);
+    const abs = join15(repoRoot, rel);
     const out = [];
     for (const r of roots) {
       if (!isInside(abs, r.abs))
@@ -29304,11 +30017,11 @@ function walkRoots(ignoredFolders, specs) {
   const under2 = (child, parent) => parent === "." || child === parent || child.startsWith(`${parent}/`);
   const roots = /* @__PURE__ */ new Set();
   for (const raw of ignoredFolders) {
-    const folder = raw.replace(/\/+$/, "");
+    const folder2 = raw.replace(/\/+$/, "");
     for (const spec of specs) {
-      if (under2(folder, spec))
-        roots.add(folder);
-      else if (under2(spec, folder))
+      if (under2(folder2, spec))
+        roots.add(folder2);
+      else if (under2(spec, folder2))
         roots.add(spec);
     }
   }
@@ -29319,9 +30032,9 @@ function credentialFilesIn(folders, repoRoot, deadline, skip) {
   const out = [];
   const stack = [];
   for (const f of folders) {
-    if (isDirectory(join14(repoRoot, f)))
+    if (isDirectory(join15(repoRoot, f)))
       stack.push(f);
-    else if (pathExists(join14(repoRoot, f)) && isCredentialPath(f))
+    else if (pathExists(join15(repoRoot, f)) && isCredentialPath(f))
       out.push(f);
   }
   let seen = 0;
@@ -29329,7 +30042,7 @@ function credentialFilesIn(folders, repoRoot, deadline, skip) {
     const rel = stack.pop();
     let entries;
     try {
-      entries = readdirSync9(join14(repoRoot, rel), { withFileTypes: true });
+      entries = readdirSync9(join15(repoRoot, rel), { withFileTypes: true });
     } catch {
       continue;
     }
@@ -29487,7 +30200,7 @@ function closeFoldsAll(targets, env) {
       return false;
     let at = root;
     for (const seg of rel.split("/")) {
-      at = join14(at, seg);
+      at = join15(at, seg);
       try {
         if (lstatSync3(at).isSymbolicLink())
           return false;
@@ -29720,7 +30433,7 @@ function worktreeFiles(m, where, env) {
   if (path === null)
     return null;
   const abs = realOrSelf(path);
-  if (!existsSync7(abs))
+  if (!existsSync8(abs))
     return [];
   const top = env.repoRoot(abs);
   if (top === null)
@@ -30070,7 +30783,7 @@ function publishFacts(m, env) {
   const start = startFolder(m, env);
   if (start !== null && PACKAGE_JSON_PROGRAMS.has(m.program)) {
     try {
-      const pkg = JSON.parse(readFileSync21(join14(start, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync21(join15(start, "package.json"), "utf-8"));
       if (typeof pkg["name"] === "string" && typeof pkg["version"] === "string" && pkg["name"] !== "" && pkg["version"] !== "") {
         name = pkg["name"];
         version2 = pkg["version"];
@@ -30189,17 +30902,17 @@ function recordFileAt(abs, env) {
   const row = recordPatternFor(rel);
   return row !== void 0 && row.shrinkAsked !== false ? { abs, root, rel } : null;
 }
-function recordFilesUnder(folder, env) {
-  const root = recordRoot(folder, env);
+function recordFilesUnder(folder2, env) {
+  const root = recordRoot(folder2, env);
   if (root === null)
     return [];
-  const relFolder = toSlash(relative7(root, folder));
+  const relFolder = toSlash(relative7(root, folder2));
   const starts = /* @__PURE__ */ new Set();
   for (const { pattern } of PROJECT_RECORD_PATTERNS) {
     if (relFolder === "" || patternOwns(relFolder, pattern))
-      starts.add(join14(root, pattern));
+      starts.add(join15(root, pattern));
     else if (patternOwns(pattern, relFolder))
-      starts.add(folder);
+      starts.add(folder2);
   }
   const out = [];
   const stack = [...starts];
@@ -30223,7 +30936,7 @@ function recordFilesUnder(folder, env) {
         continue;
       }
       for (const n of names)
-        stack.push(join14(p, n));
+        stack.push(join15(p, n));
     } else if (st.isFile()) {
       const r = recordFileAt(p, env);
       if (r !== null)
@@ -30306,7 +31019,11 @@ var PERSON_HOLD_LINE = "Halfcycle paused a risky step before it ran. Nothing cha
 var HELD_STEP_OPENER = "The step was: ";
 var PRECAUTION_OPENER = "It was stopped as a precaution: ";
 var ALLOW_REPLY = "allow";
-var HOLD_AGENT_INSTRUCTION = `If the step is not needed, carry on without it; there is no need to mention it. If it is needed, ask the person in chat, in one plain sentence, whether to run it, and tell them to reply "${ALLOW_REPLY}" to run it once, or anything else to skip it. Do not try it again until they answer.`;
+function holdAgentInstruction(stepNumber) {
+  const reply = stepNumber === null ? ALLOW_REPLY : `${ALLOW_REPLY} ${String(stepNumber)}`;
+  return `If the step is not needed, carry on without it; there is no need to mention it. If it is needed, ask the person in chat, in one plain sentence, whether to run it, and tell them to reply "${reply}" to run it once, or anything else to skip it. Do not try it again until they answer.`;
+}
+var HOLD_AGENT_INSTRUCTION = holdAgentInstruction(null);
 var NOTHING_LOST_ON_NO = "Nothing is lost if you say no.";
 var IF_YES = "If you say yes, ";
 var DESCRIBED_TOOLS = /* @__PURE__ */ new Set(["Bash", "Agent"]);
@@ -30342,6 +31059,9 @@ function questionFor(facts, description) {
   const shown2 = staked.slice(0, MAX_LISTED).map((f) => `${whatOf(f)} ${IF_YES}${lostOf(f)}`);
   return `${PAUSED_OPENER.trimEnd().slice(0, -1)}. ${shown2.join(" ")}${moreLine(staked.length - shown2.length)} ${reason} ${NOTHING_LOST_ON_NO}`;
 }
+function heldAgentText(held, stepNumber) {
+  return `${held.facts} ${holdAgentInstruction(stepNumber)}`;
+}
 function refusalFor(facts, description) {
   const staked = orderedStaked(facts);
   if (staked.length === 0)
@@ -30352,9 +31072,11 @@ function refusalFor(facts, description) {
   return heldStep(steps, description, shown2.map(whyOf).join("; "));
 }
 function heldStep(steps, description, why) {
+  const facts = `${HELD_STEP_OPENER}${steps}. ${reasonSentence(description)} ${PRECAUTION_OPENER}${why}.`;
   return {
     person: PERSON_HOLD_LINE,
-    agent: `${HELD_STEP_OPENER}${steps}. ${reasonSentence(description)} ${PRECAUTION_OPENER}${why}. ${HOLD_AGENT_INSTRUCTION}`,
+    agent: `${facts} ${HOLD_AGENT_INSTRUCTION}`,
+    facts,
     step: steps
   };
 }
@@ -30769,14 +31491,85 @@ function isOneCall(call) {
 
 // dist/risky/allow-once.js
 import { createHash as createHash5 } from "node:crypto";
-import { appendFileSync as appendFileSync4, readFileSync as readFileSync22, renameSync as renameSync11, unlinkSync as unlinkSync9, writeFileSync as writeFileSync13 } from "node:fs";
+import { appendFileSync as appendFileSync5, readFileSync as readFileSync22, realpathSync as realpathSync8, renameSync as renameSync11, statSync as statSync8, unlinkSync as unlinkSync9, writeFileSync as writeFileSync13 } from "node:fs";
+import { isAbsolute as isAbsolute5, relative as relative8, resolve as resolve7, sep as sep6 } from "node:path";
 var ALLOW_ONCE_MS = 5 * 60 * 1e3;
 var HELD_STEP_MAX_AGE_MS = 60 * 60 * 1e3;
+var NUMBERS_WAIT_MS = 50;
+var NUMBERS_LOCK_STALE_MS = 5e3;
+var NUMBERS_LOCK_POLL_MS = 2;
+var COPY_GIT_TIMEOUT_MS = 3e3;
+var ALLOW_NUMBER = new RegExp(`^${ALLOW_REPLY}(?: +([0-9]{1,4}))?$`);
 var STEP_MAX_LENGTH = 1e3;
-function isAllowReply(prompt) {
-  return typeof prompt === "string" && prompt.trim().toLowerCase() === ALLOW_REPLY;
+function allowReplyOf(prompt) {
+  if (typeof prompt !== "string")
+    return null;
+  const m = ALLOW_NUMBER.exec(prompt.trim().toLowerCase());
+  if (m === null)
+    return null;
+  return { number: m[1] === void 0 ? null : Number(m[1]) };
+}
+var FOLDER_WORD = String.raw`(?:([^\s'"$\x60\\~*?\[{()<>|&;\-][^\s'"$\x60\\~*?\[{()<>|&;]*)|'([^'"$\x60\\\-][^'"$\x60\\]*)'|"([^'"$\x60\\\-][^'"$\x60\\]*)")`;
+var CD_PREFIX = new RegExp(String.raw`^\s*cd[ \t]+${FOLDER_WORD}[ \t]*(?:&&|;)`);
+var GIT_C_PREFIX = new RegExp(String.raw`^\s*git[ \t]+-C[ \t]+${FOLDER_WORD}[ \t]+`);
+function folderPrefixOf(command) {
+  const cd = CD_PREFIX.exec(command);
+  if (cd !== null) {
+    const rest = command.slice(cd[0].length).replace(/^\s+/, "");
+    const commands = commandsOf(rest);
+    if (commands === null || commands.some((c) => FOLDER_CHANGERS.has(c.words[0]?.text ?? "")))
+      return null;
+    return { folder: folderOf(cd), command: rest };
+  }
+  const gitC = GIT_C_PREFIX.exec(command);
+  if (gitC !== null) {
+    const compared = `git ${command.slice(gitC[0].length)}`;
+    const commands = commandsOf(compared);
+    if (commands === null || commands.filter((c) => c.scope === void 0).length !== 1)
+      return null;
+    return { folder: folderOf(gitC), command: compared };
+  }
+  return null;
+}
+function commandsOf(text) {
+  try {
+    return splitCommand(text);
+  } catch {
+    return null;
+  }
 }
-function stepKey(input, staked) {
+function folderOf(m) {
+  return m[1] ?? m[2] ?? m[3] ?? "";
+}
+function actingFolderOf(toolName, cwd, rest) {
+  const command = rest["command"];
+  if (toolName !== "Bash" || typeof command !== "string")
+    return cwd;
+  const prefix = folderPrefixOf(command);
+  if (prefix === null)
+    return cwd;
+  if (!isAbsolute5(prefix.folder) && !isAbsolute5(cwd))
+    return cwd;
+  const named = isAbsolute5(prefix.folder) ? prefix.folder : resolve7(cwd, prefix.folder);
+  if (!isFolder2(named))
+    return cwd;
+  rest["command"] = prefix.command;
+  return named;
+}
+function copyOf(folder2, timeoutMs) {
+  if (folder2 === "")
+    return { top: "", within: "" };
+  const real = realOrSelf2(folder2);
+  let top = real;
+  if (isFolder2(real)) {
+    const r = readGitForFacts(["rev-parse", "--show-toplevel"], real, timeoutMs);
+    if (r.ok && r.value.trim() !== "")
+      top = realOrSelf2(r.value.trim());
+  }
+  const within2 = relative8(top, real).split(sep6).join("/");
+  return { top, within: within2 };
+}
+function stepKey(input, staked, deps = {}) {
   const toolName = input["tool_name"];
   const toolInput = input["tool_input"];
   if (typeof toolName !== "string" || toolName === "")
@@ -30787,7 +31580,17 @@ function stepKey(input, staked) {
   if (DESCRIBED_TOOLS.has(toolName))
     delete rest["description"];
   const cwd = typeof input["cwd"] === "string" ? input["cwd"] : "";
-  return createHash5("sha256").update(canonical([toolName, cwd, rest, staked])).digest("hex");
+  const acting = actingFolderOf(toolName, cwd, rest);
+  const { top, within: within2 } = copyOf(acting, deps.gitTimeoutMs ?? COPY_GIT_TIMEOUT_MS);
+  const facts = staked.map(withoutMatch);
+  return createHash5("sha256").update(canonical([toolName, top, within2, rest, facts])).digest("hex");
+}
+function withoutMatch(fact) {
+  if (typeof fact !== "object" || fact === null || Array.isArray(fact))
+    return fact;
+  const { match: _match, ...others } = fact;
+  void _match;
+  return others;
 }
 function canonical(value) {
   if (Array.isArray(value))
@@ -30798,37 +31601,166 @@ function canonical(value) {
   }
   return JSON.stringify(value) ?? "null";
 }
-function recordHeld(sessionId, key, deps = {}, step = null) {
+function isFolder2(path) {
+  try {
+    return statSync8(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function realOrSelf2(path) {
+  try {
+    return realpathSync8(path);
+  } catch {
+    return path;
+  }
+}
+function numberStep(sessionId, key, deps = {}) {
+  const paths = allowOncePaths(sessionId, deps.dir);
+  if (paths === null)
+    return null;
+  const lock = `${paths.numbers}${STEP_NUMBERS_LOCK_SUFFIX}`;
+  const giveUpAt = Date.now() + NUMBERS_WAIT_MS;
+  while (!tryTakeLockFile(lock, NUMBERS_LOCK_STALE_MS)) {
+    if (Date.now() >= giveUpAt)
+      return null;
+    sleepSync4(NUMBERS_LOCK_POLL_MS);
+  }
+  try {
+    const numbers = readNumbers(paths.numbers);
+    if (numbers === null)
+      return null;
+    const kept = numbers.steps.get(key);
+    if (kept !== void 0)
+      return kept;
+    const n = numbers.next;
+    const steps = new Map(numbers.steps).set(key, n);
+    return writeNumbers(paths.numbers, { next: n + 1, steps }) ? n : null;
+  } catch {
+    return null;
+  } finally {
+    releaseLockFile(lock);
+  }
+}
+function numberKept(path, key) {
+  try {
+    return readNumbers(path)?.steps.get(key) ?? null;
+  } catch {
+    return null;
+  }
+}
+function readNumbers(path) {
+  let text;
+  try {
+    text = readFileSync22(path, "utf8");
+  } catch (err) {
+    return err.code === "ENOENT" ? { next: 1, steps: /* @__PURE__ */ new Map() } : null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return null;
+  const o = parsed;
+  const next = o["next"];
+  const steps = o["steps"];
+  if (!isWholeNumber2(next) || typeof steps !== "object" || steps === null || Array.isArray(steps))
+    return null;
+  const out = /* @__PURE__ */ new Map();
+  for (const [k, v] of Object.entries(steps)) {
+    if (!/^[0-9a-f]{64}$/.test(k) || !isWholeNumber2(v) || v >= next)
+      return null;
+    out.set(k, v);
+  }
+  return { next, steps: out };
+}
+function writeNumbers(path, numbers) {
+  const body = JSON.stringify({ next: numbers.next, steps: Object.fromEntries(numbers.steps) });
+  return writeWhole2(path, body);
+}
+function isWholeNumber2(v) {
+  return typeof v === "number" && Number.isSafeInteger(v) && v >= 1;
+}
+function sleepSync4(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function recordHeld(sessionId, key, deps = {}, step = null, stepNumber = null) {
   const paths = allowOncePaths(sessionId, deps.dir);
   if (paths === null)
     return;
-  const record2 = { version: 1, session: sessionId, key, at: nowOf(deps), ...isStep(step) ? { step } : {} };
+  const record2 = {
+    version: 1,
+    session: sessionId,
+    key,
+    at: nowOf(deps),
+    ...isStep(step) ? { step } : {},
+    ...isWholeNumber2(stepNumber) ? { number: stepNumber } : {}
+  };
   try {
-    appendFileSync4(paths.held, `${JSON.stringify(record2)}
+    appendFileSync5(paths.held, `${JSON.stringify(record2)}
 `, { mode: 384 });
   } catch {
     return;
   }
 }
-function armAllowStep(sessionId, deps = {}) {
+function armAllowStep(sessionId, deps = {}, stepNumber = null) {
+  const none = (outcome) => ({ outcome, step: null, paused: [] });
   try {
     const paths = allowOncePaths(sessionId, deps.dir);
     if (paths === null)
-      return { outcome: "nothing-held", step: null };
+      return none(stepNumber === null ? "nothing-held" : "not-paused");
+    const session = sessionId;
     const now = nowOf(deps);
-    const held = claimHeld(paths.held, sessionId, now);
-    const keys = [...new Set(held.map((r) => r.key))];
-    if (keys.length === 0)
-      return { outcome: "nothing-held", step: null };
-    if (keys.length > 1)
-      return { outcome: "several-held", step: null };
-    const step = held[held.length - 1].step ?? null;
-    const saved = writeRecord(paths.allow, { version: 1, session: sessionId, key: keys[0], at: now });
-    return saved ? { outcome: "armed", step } : { outcome: "not-saved", step: null };
+    const held = claimHeld(paths.held, session, now);
+    const steps = distinctSteps(held, paths.numbers);
+    const arm = (key, step) => {
+      const saved = writeRecord(paths.allow, { version: 1, session, key, at: now });
+      if (!saved) {
+        writeBack(paths.held, held);
+        return none("not-saved");
+      }
+      writeBack(paths.held, held.filter((r) => r.key !== key));
+      return { outcome: "armed", step, paused: [] };
+    };
+    if (stepNumber !== null) {
+      const named = steps.find((s) => s.number === stepNumber);
+      if (named === void 0) {
+        writeBack(paths.held, held);
+        return none("not-paused");
+      }
+      return arm(named.key, named.step);
+    }
+    if (steps.length === 0)
+      return none("nothing-held");
+    if (steps.length === 1)
+      return arm(steps[0].key, steps[0].step);
+    writeBack(paths.held, held);
+    const paused = steps.map((s) => ({ number: s.number ?? numberStep(session, s.key, deps), step: s.step })).sort((a, b) => (a.number ?? Number.MAX_SAFE_INTEGER) - (b.number ?? Number.MAX_SAFE_INTEGER));
+    return { outcome: "several-held", step: null, paused };
   } catch {
-    return { outcome: "not-saved", step: null };
+    return none("not-saved");
   }
 }
+function distinctSteps(held, numbersPath) {
+  const order = [];
+  const latest = /* @__PURE__ */ new Map();
+  const numbered = /* @__PURE__ */ new Map();
+  for (const r of held) {
+    if (!latest.has(r.key))
+      order.push(r.key);
+    latest.set(r.key, r);
+    if (r.number !== void 0)
+      numbered.set(r.key, r.number);
+  }
+  return order.map((key) => ({
+    key,
+    number: numbered.get(key) ?? numberKept(numbersPath, key),
+    step: latest.get(key).step ?? null
+  }));
+}
 function claimHeld(path, session, now) {
   const claimed = `${path}.${process.pid}.${now}.claim`;
   try {
@@ -30851,6 +31783,16 @@ function claimHeld(path, session, now) {
   }
   return records;
 }
+function writeBack(path, records) {
+  if (records.length === 0)
+    return;
+  try {
+    appendFileSync5(path, records.map((r) => `${JSON.stringify(r)}
+`).join(""), { mode: 384 });
+  } catch {
+    return;
+  }
+}
 function isStep(v) {
   return typeof v === "string" && v !== "" && v.length <= STEP_MAX_LENGTH;
 }
@@ -30905,12 +31847,23 @@ function parseRecord(text, session) {
   if (typeof r["at"] !== "number")
     return null;
   const step = r["step"];
-  return { version: 1, session, key: r["key"], at: r["at"], ...isStep(step) ? { step } : {} };
+  const n = r["number"];
+  return {
+    version: 1,
+    session,
+    key: r["key"],
+    at: r["at"],
+    ...isStep(step) ? { step } : {},
+    ...isWholeNumber2(n) ? { number: n } : {}
+  };
 }
 function writeRecord(path, record2) {
+  return writeWhole2(path, JSON.stringify(record2));
+}
+function writeWhole2(path, body) {
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
   try {
-    writeFileSync13(tmp, JSON.stringify(record2), { mode: 384 });
+    writeFileSync13(tmp, body, { mode: 384 });
     renameSync11(tmp, path);
     return true;
   } catch {
@@ -31008,7 +31961,7 @@ function decideAutonomous(facts, mayPublishNow) {
 
 // dist/risky/own-copy.js
 import { readFileSync as readFileSync23 } from "node:fs";
-import { join as join15, posix as posix2, win32 as win322 } from "node:path";
+import { join as join16, posix as posix2, win32 as win322 } from "node:path";
 var OWN_COPY_START_TOOL = "Agent";
 var OWN_COPY_WRITE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
 var OWN_COPY_ISOLATION = "worktree";
@@ -31069,7 +32022,7 @@ function typeCanChangeFiles(subagentType, deps) {
     return true;
   if (AGENT_FILE_NAME.test(type)) {
     for (const base of [deps.projectDir, deps.home]) {
-      const text = readOr(deps, join15(base, ".claude", "agents", `${type}.md`));
+      const text = readOr(deps, join16(base, ".claude", "agents", `${type}.md`));
       if (text === null)
         continue;
       const tools = frontmatterTools(text);
@@ -31175,31 +32128,31 @@ function judgeChange(input, call, deps) {
 
 // dist/risky/save.js
 import { randomBytes } from "node:crypto";
-import { chmodSync as chmodSync2, constants as fsConstants, copyFileSync, lstatSync as lstatSync4, mkdirSync as mkdirSync9, readdirSync as readdirSync10, readFileSync as readFileSync24, readlinkSync, realpathSync as realpathSync8, renameSync as renameSync12, rmSync as rmSync3, statSync as statSync8, symlinkSync, writeFileSync as writeFileSync14 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { dirname as dirname7, isAbsolute as isAbsolute5, join as join16, resolve as resolve7 } from "node:path";
+import { chmodSync as chmodSync2, constants as fsConstants, copyFileSync, lstatSync as lstatSync4, mkdirSync as mkdirSync9, readdirSync as readdirSync10, readFileSync as readFileSync24, readlinkSync, realpathSync as realpathSync9, renameSync as renameSync12, rmSync as rmSync3, statSync as statSync9, symlinkSync, writeFileSync as writeFileSync14 } from "node:fs";
+import { homedir as homedir11 } from "node:os";
+import { dirname as dirname7, isAbsolute as isAbsolute6, join as join17, resolve as resolve8 } from "node:path";
 var SAVE_LIMIT_BYTES = 2e8;
 var SAVE_BUDGET_MS = 5e3;
 function notSaved(reason) {
   return { saved: false, reason };
 }
-function savedFolderOf(engagementId, home = homedir10()) {
+function savedFolderOf(engagementId, home = homedir11()) {
   if (!isEngagementId(engagementId))
     return null;
-  return join16(home, HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, SAVED_DIR_NAME);
+  return join17(home, HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, SAVED_DIR_NAME);
 }
 function saveFirst(staked, ctx) {
   const now = ctx.now ?? Date.now;
   const deadline = now() + (ctx.budgetMs ?? SAVE_BUDGET_MS);
-  const folder = savedFolderOf(ctx.engagementId, ctx.home);
-  if (folder === null)
+  const folder2 = savedFolderOf(ctx.engagementId, ctx.home);
+  if (folder2 === null)
     return notSaved(AUTONOMY_SAVE_FAILED_REASON);
   const plan = planOf(staked);
   if (!plan.ok)
     return notSaved(plan.reason);
   const g = new SaveGit(plan.root, deadline, now);
   const top = g.run(["rev-parse", "--show-toplevel"]);
-  if (!top.ok || realOrSelf2(top.value.trim()) !== plan.root)
+  if (!top.ok || realOrSelf3(top.value.trim()) !== plan.root)
     return notSaved(AUTONOMY_SAVE_NOT_COVERED_REASON);
   const head = g.run(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"]);
   const headCommit2 = head.ok ? head.value.trim() : "";
@@ -31214,23 +32167,23 @@ function saveFirst(staked, ctx) {
     return notSaved(found2.reason);
   let saveDir = null;
   try {
-    const id = freshId(folder, ctx.newId);
+    const id = freshId(folder2, ctx.newId);
     if (id === null)
       return notSaved(AUTONOMY_SAVE_FAILED_REASON);
-    saveDir = join16(folder, id);
+    saveDir = join17(folder2, id);
     const repository = repositoryOf(g);
     if (repository === null)
       return failed(saveDir);
-    writeFileSync14(join16(saveDir, SAVED_REPOSITORY_FILE_NAME), `${repository}
+    writeFileSync14(join17(saveDir, SAVED_REPOSITORY_FILE_NAME), `${repository}
 `, { mode: 384 });
-    const privateIndex = join16(saveDir, PRIVATE_INDEX_NAME);
+    const privateIndex = join17(saveDir, PRIVATE_INDEX_NAME);
     const commit = saveCommit(id, headCommit2, found2.tracked, plan.lines, privateIndex, g, now());
     rmSync3(privateIndex, { force: true });
     if (commit === null)
       return failed(saveDir);
-    const copiesDir = join16(saveDir, SAVED_COPIES_DIR_NAME);
+    const copiesDir = join17(saveDir, SAVED_COPIES_DIR_NAME);
     for (const rel of found2.copies) {
-      if (now() > deadline || !copyOne(join16(plan.root, rel), join16(copiesDir, rel)))
+      if (now() > deadline || !copyOne(join17(plan.root, rel), join17(copiesDir, rel)))
         return failed(saveDir);
     }
     const description = savedSchema.safeParse({
@@ -31246,7 +32199,7 @@ function saveFirst(staked, ctx) {
     });
     if (!description.success)
       return failed(saveDir);
-    const file2 = join16(saveDir, SAVED_FILE_NAME);
+    const file2 = join17(saveDir, SAVED_FILE_NAME);
     writeFileSync14(`${file2}.part`, `${JSON.stringify(description.data, null, 2)}
 `, { mode: 384 });
     renameSync12(`${file2}.part`, file2);
@@ -31277,7 +32230,7 @@ function planOf(staked) {
     const t = f.save;
     if (t === void 0)
       return { ok: false, reason: f.cannotTell === void 0 ? AUTONOMY_SAVE_NOT_COVERED_REASON : AUTONOMY_COULD_NOT_TELL_REASON };
-    const r = realOrSelf2(resolve7(t.repoRoot));
+    const r = realOrSelf3(resolve8(t.repoRoot));
     if (root === null)
       root = r;
     else if (root !== r)
@@ -31296,7 +32249,7 @@ function planOf(staked) {
 function isInsideRel(p) {
   if (p === ".")
     return true;
-  if (p === "" || isAbsolute5(p) || p.includes("\\"))
+  if (p === "" || isAbsolute6(p) || p.includes("\\"))
     return false;
   return p.split("/").every((s) => s !== "" && s !== "." && s !== "..");
 }
@@ -31326,7 +32279,7 @@ function filesOf(plan, g, deadline) {
     trackedAll.add(path);
     if (!reached(path, plan.specs))
       continue;
-    const st = lstatOrNull(join16(plan.root, path));
+    const st = lstatOrNull(join17(plan.root, path));
     if (st !== null && (st.isFile() || st.isSymbolicLink()))
       tracked.add(path);
   }
@@ -31338,7 +32291,7 @@ function filesOf(plan, g, deadline) {
     const rel = stack.pop();
     if (rel === ".git")
       continue;
-    const abs = rel === "." ? plan.root : join16(plan.root, rel);
+    const abs = rel === "." ? plan.root : join17(plan.root, rel);
     const st = lstatOrNull(abs);
     if (st === null)
       continue;
@@ -31376,13 +32329,13 @@ function copyOne(src, dst) {
   }
   copyFileSync(src, dst, fsConstants.COPYFILE_EXCL | fsConstants.COPYFILE_FICLONE);
   chmodSync2(dst, st.mode & 4095);
-  return statSync8(dst).size === st.size;
+  return statSync9(dst).size === st.size;
 }
 function saveCommit(id, head, tracked, lines2, privateIndex, g, at) {
   const indexPath = g.run(["rev-parse", "--git-path", "index"]);
   if (!indexPath.ok)
     return null;
-  const projectIndex = resolve7(g.root, indexPath.value.trim());
+  const projectIndex = resolve8(g.root, indexPath.value.trim());
   const env = commitEnv(privateIndex, at);
   if (lstatOrNull(projectIndex) !== null)
     copyFileSync(projectIndex, privateIndex);
@@ -31444,14 +32397,14 @@ var SaveGit = class {
     });
   }
 };
-function freshId(folder, newId) {
-  mkdirSync9(folder, { recursive: true, mode: 448 });
+function freshId(folder2, newId) {
+  mkdirSync9(folder2, { recursive: true, mode: 448 });
   for (let i = 0; i < 5; i++) {
     const id = newId?.() ?? defaultId();
     if (!savedIdSchema.safeParse(id).success)
       return null;
     try {
-      mkdirSync9(join16(folder, id), { mode: 448 });
+      mkdirSync9(join17(folder2, id), { mode: 448 });
       return id;
     } catch (e) {
       if (e.code !== "EEXIST")
@@ -31472,19 +32425,19 @@ function repositoryOf(g) {
   if (!r.ok)
     return null;
   const dir = r.value.trim();
-  return dir === "" ? null : realOrSelf2(resolve7(g.root, dir));
+  return dir === "" ? null : realOrSelf3(resolve8(g.root, dir));
 }
 function markedRepository(dir) {
   try {
-    const text = readFileSync24(join16(dir, SAVED_REPOSITORY_FILE_NAME), "utf-8").trim();
+    const text = readFileSync24(join17(dir, SAVED_REPOSITORY_FILE_NAME), "utf-8").trim();
     return text === "" ? null : text;
   } catch {
     return null;
   }
 }
 function pruneSaves(root, engagementId, ctx = {}) {
-  const folder = savedFolderOf(engagementId, ctx.home);
-  if (folder === null)
+  const folder2 = savedFolderOf(engagementId, ctx.home);
+  if (folder2 === null)
     return;
   const now = ctx.now ?? Date.now;
   const g = new SaveGit(root, ctx.deadline ?? now() + SAVE_BUDGET_MS, now);
@@ -31501,7 +32454,7 @@ function pruneSaves(root, engagementId, ctx = {}) {
   const repository = repositoryOf(g);
   let names = [];
   try {
-    names = readdirSync10(folder);
+    names = readdirSync10(folder2);
   } catch {
     names = [];
   }
@@ -31510,7 +32463,7 @@ function pruneSaves(root, engagementId, ctx = {}) {
     if (!savedIdSchema.safeParse(id).success)
       continue;
     here.add(id);
-    const dir = join16(folder, id);
+    const dir = join17(folder2, id);
     const st = lstatOrNull(dir);
     const answer = savedPruneAnswer({
       refMadeAt: refs.get(id) ?? null,
@@ -31539,9 +32492,9 @@ function lstatOrNull(p) {
     return null;
   }
 }
-function realOrSelf2(p) {
+function realOrSelf3(p) {
   try {
-    return realpathSync8(p);
+    return realpathSync9(p);
   } catch {
     return p;
   }
@@ -31550,12 +32503,12 @@ function realOrSelf2(p) {
 // dist/autonomy-state.js
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { chmodSync as chmodSync3, mkdirSync as mkdirSync10, readFileSync as readFileSync25, renameSync as renameSync13, rmSync as rmSync4, writeFileSync as writeFileSync15 } from "node:fs";
-import { homedir as homedir11, platform as platform2 } from "node:os";
-import { dirname as dirname8, join as join17 } from "node:path";
+import { homedir as homedir12, platform as platform2 } from "node:os";
+import { dirname as dirname8, join as join18 } from "node:path";
 var AUTONOMY_STATE_FILENAME = "autonomy.json";
 var AUTONOMY_STATE_DEADLINE_MS = 1500;
 function autonomyStateFilePath(engagementId, home) {
-  return join17(home ?? homedir11(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, AUTONOMY_STATE_FILENAME);
+  return join18(home ?? homedir12(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, AUTONOMY_STATE_FILENAME);
 }
 function readCachedAutonomy(engagementId, nowMs, home) {
   if (!isEngagementId(engagementId))
@@ -31583,6 +32536,7 @@ function confirmMayPublishNow(opts) {
       timeout: opts.timeoutMs,
       windowsHide: true
     });
+    recordChildRequest(url2, ["Authorization"], r.status === 0);
     if (r.status !== 0 || typeof r.stdout !== "string")
       return false;
     const parsed = autonomyStateSchema.safeParse(JSON.parse(r.stdout));
@@ -31607,7 +32561,7 @@ function deleteAutonomyStateFile(engagementId, home) {
 }
 function writeAutonomyStateFile(engagementId, file2, home) {
   const target = autonomyStateFilePath(engagementId, home);
-  const temp = join17(dirname8(target), `.${AUTONOMY_STATE_FILENAME}.${process.pid}.tmp`);
+  const temp = join18(dirname8(target), `.${AUTONOMY_STATE_FILENAME}.${process.pid}.tmp`);
   try {
     mkdirSync10(dirname8(target), { recursive: true, mode: 448 });
     writeFileSync15(temp, `${JSON.stringify(file2)}
@@ -31669,7 +32623,7 @@ async function cacheAutonomySetting(opts) {
 }
 
 // dist/risky/patch-calls.js
-import { isAbsolute as isAbsolute6, resolve as resolve8 } from "node:path";
+import { isAbsolute as isAbsolute7, resolve as resolve9 } from "node:path";
 var SHELL_TOOL = "Bash";
 function toolCallsOf(input, profile) {
   const toolName = input["tool_name"];
@@ -31692,7 +32646,7 @@ function toolCallsOf(input, profile) {
   const ops = patchOperations(command);
   if (ops === null || ops.length === 0)
     return null;
-  const cwd = typeof input["cwd"] === "string" && isAbsolute6(input["cwd"]) ? input["cwd"] : null;
+  const cwd = typeof input["cwd"] === "string" && isAbsolute7(input["cwd"]) ? input["cwd"] : null;
   const calls = [];
   for (const op of ops) {
     const made = callsFor(op, cwd);
@@ -31730,9 +32684,9 @@ function callsFor(op, cwd) {
   }
 }
 function placed(path, cwd) {
-  if (isAbsolute6(path))
-    return resolve8(path);
-  return cwd === null ? null : resolve8(cwd, path);
+  if (isAbsolute7(path))
+    return resolve9(path);
+  return cwd === null ? null : resolve9(cwd, path);
 }
 function shellWord(text) {
   return `'${text.split("'").join("'\\''")}'`;
@@ -31740,7 +32694,7 @@ function shellWord(text) {
 
 // dist/hooks/pre-tool-use.js
 import { performance } from "node:perf_hooks";
-import { homedir as homedir12 } from "node:os";
+import { homedir as homedir13 } from "node:os";
 var UNREADABLE_INPUT_NOTICE = "Halfcycle could not read what the coding agent was about to do, so that step went ahead without being checked for anything that cannot be undone. If this keeps happening, update Halfcycle.";
 var PRE_TOOL_USE_LIMIT_MS = (HALFCYCLE_HOOK_WIRING.find((e) => e.event === "PreToolUse")?.timeout ?? 10) * 1e3;
 var AUTONOMY_REPLY_MARGIN_MS = 1e3;
@@ -31811,6 +32765,11 @@ function runPreToolUse(deps) {
         if (held !== null)
           return `${preToolUseReplyText("refuse", held)}
 `;
+        recordSpawnedTask(call.toolInput, {
+          projectDir: projectDirOf(deps),
+          ...deps.env === void 0 ? {} : { env: deps.env },
+          ...deps.home === void 0 ? {} : { home: deps.home }
+        });
       }
       return own.kind === "unknown" ? ownCopyNotice(input, deps) : "";
     }
@@ -31819,16 +32778,19 @@ function runPreToolUse(deps) {
       return `${preToolUseReplyText("ask", answer.question)}
 `;
     }
+    let agentText = answer.refusal.agent;
     if (allowableByTyping(call, answer.staked)) {
-      const key = stepKey(input, answer.staked);
+      const key = stepKey(input, answer.staked, deps.gitTimeoutMs === void 0 ? {} : { gitTimeoutMs: deps.gitTimeoutMs });
       if (key !== null) {
         const allowOnce = { ...deps.liveness?.dir === void 0 ? {} : { dir: deps.liveness.dir }, now: () => at.getTime() };
         if (spendAllow(input["session_id"], key, allowOnce))
           return "";
-        recordHeld(input["session_id"], key, allowOnce, answer.refusal.step);
+        const stepNumber = numberStep(input["session_id"], key, allowOnce);
+        recordHeld(input["session_id"], key, allowOnce, answer.refusal.step, stepNumber);
+        agentText = heldAgentText(answer.refusal, stepNumber);
       }
     }
-    return `${preToolUseReplyText("refuse", answer.refusal.person, answer.refusal.agent)}
+    return `${preToolUseReplyText("refuse", answer.refusal.person, agentText)}
 `;
   } catch {
     return "";
@@ -31956,7 +32918,7 @@ function ownCopyOf(input, call, deps) {
     const walk2 = deps.walk ?? deps.liveness?.walk;
     return judgeOwnCopy(input, call, {
       projectDir: projectDirOf(deps),
-      home: deps.home ?? homedir12(),
+      home: deps.home ?? homedir13(),
       ...walk2 === void 0 ? {} : { walk: walk2 },
       ...deps.liveness === void 0 ? {} : { liveness: deps.liveness }
     });
@@ -31965,8 +32927,8 @@ function ownCopyOf(input, call, deps) {
   }
 }
 function ownCopyNotice(input, deps) {
-  const folder = stringOf(input, "cwd") ?? projectDirOf(deps);
-  return firstNoticeThisSession("outside-own-copy-unknown", folder, stringOf(input, "session_id"), deps.liveness?.dir) ? `${preToolUseNoticeText(OWN_COPY_UNKNOWN_NOTICE)}
+  const folder2 = stringOf(input, "cwd") ?? projectDirOf(deps);
+  return firstNoticeThisSession("outside-own-copy-unknown", folder2, stringOf(input, "session_id"), deps.liveness?.dir) ? `${preToolUseNoticeText(OWN_COPY_UNKNOWN_NOTICE)}
 ` : "";
 }
 function parseObject2(text) {
@@ -31983,14 +32945,14 @@ function stringOf(input, key) {
 }
 function unreadable(deps, input) {
   const session = (input === null ? void 0 : stringOf(input, "session_id")) ?? /"session_id"\s*:\s*"([^"\\]+)"/.exec(deps.input)?.[1];
-  const folder = (input === null ? void 0 : stringOf(input, "cwd")) ?? projectDirOf(deps);
-  return firstNoticeThisSession("pre-tool-use-unreadable", folder, session) ? `${preToolUseNoticeText(UNREADABLE_INPUT_NOTICE)}
+  const folder2 = (input === null ? void 0 : stringOf(input, "cwd")) ?? projectDirOf(deps);
+  return firstNoticeThisSession("pre-tool-use-unreadable", folder2, session) ? `${preToolUseNoticeText(UNREADABLE_INPUT_NOTICE)}
 ` : "";
 }
 
 // dist/hooks/session-diff.js
 import { unlinkSync as unlinkSync10 } from "node:fs";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 var STOP_HOOK_EVENT = {
   stop: "Stop",
   "subagent-stop": "SubagentStop"
@@ -32042,7 +33004,7 @@ async function evaluateSession(input, kind, reply, readSeat, profile) {
   }
   const repoRoot = repoRootResult.value;
   const sessionId = input.session_id;
-  const folder = realPathOf(repoRoot);
+  const folder2 = realPathOf(repoRoot);
   orphanSweep(repoRoot, (ref) => refExists(ref, repoRoot), sessionId, Date.now(), whichCopy(process.cwd())?.common ?? null);
   const base = resolveDiffBase2(repoRoot, sessionId);
   const diffBase = base.kind;
@@ -32055,12 +33017,12 @@ async function evaluateSession(input, kind, reply, readSeat, profile) {
   const candidates = ownEditedFiles(repoRoot, sessionId).filter((relPath) => !tracked.has(relPath));
   const untracked = getUntrackedFiles(repoRoot, candidates);
   const created = untracked.ok ? untracked.value.filter((relPath) => !tracked.has(relPath)) : [];
-  const getDiff = (relPath) => tracked.has(relPath) ? collected.getDiff(relPath) : getSingleFileDiff(join18(repoRoot, relPath), repoRoot);
+  const getDiff = (relPath) => tracked.has(relPath) ? collected.getDiff(relPath) : getSingleFileDiff(join19(repoRoot, relPath), repoRoot);
   const { evaluated } = partitionInstallerOutput(collected.files);
   const { evaluated: createdEvaluated } = partitionInstallerOutput(created);
   const changedFiles2 = [...ownChangedFiles(repoRoot, evaluated, sessionId), ...createdEvaluated];
   if (changedFiles2.length === 0) {
-    queueTurnEnd(keepBooks(sessionId, folder, { kind: "no-own-changes" }, kind === "stop"), reply);
+    queueTurnEnd(keepBooks(sessionId, folder2, { kind: "no-own-changes" }, kind === "stop"), reply);
     return;
   }
   const fileDiffEntries = changedFiles2.map((relPath) => ({
@@ -32071,7 +33033,7 @@ async function evaluateSession(input, kind, reply, readSeat, profile) {
   const digest = digestChangeState(baseKey, fileDiffEntries);
   const prior = readDedupe(repoRoot, sessionId);
   if (prior && prior.base === baseKey && prior.digest === digest) {
-    queueTurnEnd(keepBooks(sessionId, folder, { kind: "unchanged" }, kind === "stop"), reply);
+    queueTurnEnd(keepBooks(sessionId, folder2, { kind: "unchanged" }, kind === "stop"), reply);
     return;
   }
   const context = loadChangeSetContext(repoRoot);
@@ -32151,12 +33113,12 @@ async function evaluateSession(input, kind, reply, readSeat, profile) {
     warn: (msg) => process.stderr.write(msg + "\n")
   });
   writeDedupe(repoRoot, sessionId, { base: baseKey, digest });
-  actOnEnvelope3(clientResult.envelope, kind, input.stop_hook_active === true, reply, sessionId, folder);
+  actOnEnvelope3(clientResult.envelope, kind, input.stop_hook_active === true, reply, sessionId, folder2);
 }
-function keepBooks(sessionId, folder, outcome, topLevel) {
+function keepBooks(sessionId, folder2, outcome, topLevel) {
   const books = () => {
     const before = readFindings(sessionId);
-    const { file: file2, news } = turnEndBookkeeping(before ?? emptyFindings(""), folder, outcome, topLevel, /* @__PURE__ */ new Date());
+    const { file: file2, news } = turnEndBookkeeping(before ?? emptyFindings(""), folder2, outcome, topLevel, /* @__PURE__ */ new Date());
     if (before !== null && JSON.stringify(before) !== JSON.stringify(file2)) {
       if (file2.findings.length > 0)
         writeFindings(file2);
@@ -32181,7 +33143,7 @@ function queueTurnEnd(words, reply) {
   if (words !== null)
     reply.notice(words);
 }
-function actOnEnvelope3(envelope, kind, neverBlock, reply, sessionId, folder) {
+function actOnEnvelope3(envelope, kind, neverBlock, reply, sessionId, folder2) {
   const notRun = notRunMessage((envelope.notRun ?? []).map((n) => n.reason));
   const outcome = {
     kind: "evaluated",
@@ -32190,7 +33152,7 @@ function actOnEnvelope3(envelope, kind, neverBlock, reply, sessionId, folder) {
   };
   const topLevel = kind === "stop";
   if (envelope.blocking && !neverBlock) {
-    keepBooks(sessionId, folder, outcome, false);
+    keepBooks(sessionId, folder2, outcome, false);
     const reason = blockReason(envelope.guardsFired.map((g) => g.explanation));
     reply.block(notRun ? `${reason}
 ${notRun}` : reason, stoppedMessage(blockingExplanations(envelope.guardsFired)));
@@ -32198,7 +33160,7 @@ ${notRun}` : reason, stoppedMessage(blockingExplanations(envelope.guardsFired)))
   if (envelope.blocking && neverBlock) {
     reply.notice(couldNotFixMessage(blockingExplanations(envelope.guardsFired)));
   }
-  queueTurnEnd(keepBooks(sessionId, folder, outcome, topLevel), reply);
+  queueTurnEnd(keepBooks(sessionId, folder2, outcome, topLevel), reply);
   if (notRun)
     reply.notice(notRun);
 }
@@ -32219,9 +33181,9 @@ async function readHookStdin() {
   }
 }
 function readStdin2() {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     if (process.stdin.isTTY) {
-      resolve11("");
+      resolve12("");
       return;
     }
     const chunks = [];
@@ -32231,7 +33193,7 @@ function readStdin2() {
         return;
       settled2 = true;
       clearTimeout(timer);
-      resolve11(Buffer.concat(chunks).toString("utf-8"));
+      resolve12(Buffer.concat(chunks).toString("utf-8"));
     };
     const timer = setTimeout(done, HOOK_STDIN_GRACE_MS);
     process.stdin.on("data", (chunk) => chunks.push(chunk));
@@ -32258,19 +33220,19 @@ async function runStop(observeDeps = {}, timeDeps = {}, paceDeps = {}, profile =
   recordTimeEvent("turn-end", input);
   await runSessionDiff(input, "stop", readSeatConfiguration, async (reply) => {
     await observeChanges(input.session_id, reply, observeDeps);
-    await sendTimeRecord(timeDeps);
+    await sendTimeRecord(timeDeps, { agent: profile.id });
     await paceAtTurnEnd(input, reply, { configFolder: profile.configFolder, ...paceDeps });
   }, profile);
 }
 
 // dist/relayed-choices.js
 import { mkdirSync as mkdirSync11, readFileSync as readFileSync26, renameSync as renameSync14, rmSync as rmSync5, writeFileSync as writeFileSync16 } from "node:fs";
-import { homedir as homedir13 } from "node:os";
-import { dirname as dirname9, join as join19 } from "node:path";
+import { homedir as homedir14 } from "node:os";
+import { dirname as dirname9, join as join20 } from "node:path";
 function relayedChoicesFilePath(engagementId, home) {
   if (!isEngagementId(engagementId))
     return null;
-  return join19(home ?? homedir13(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, PACING_DIR_NAME, RELAYED_CHOICES_FILENAME);
+  return join20(home ?? homedir14(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, PACING_DIR_NAME, RELAYED_CHOICES_FILENAME);
 }
 function readRelayedChoices(engagementId, phase, home) {
   const path = relayedChoicesFilePath(engagementId, home);
@@ -32306,7 +33268,7 @@ function recordRelayedChoice(opts) {
   });
   if (!file2.success)
     return false;
-  const temp = join19(dirname9(target), `.${RELAYED_CHOICES_FILENAME}.${process.pid}.tmp`);
+  const temp = join20(dirname9(target), `.${RELAYED_CHOICES_FILENAME}.${process.pid}.tmp`);
   try {
     mkdirSync11(dirname9(target), { recursive: true, mode: 448 });
     writeFileSync16(temp, `${JSON.stringify(file2.data)}
@@ -32535,19 +33497,19 @@ function matchReviewPhraseShape(shape, reviews) {
 
 // dist/hooks/shown-record.js
 import { chmodSync as chmodSync4, readFileSync as readFileSync27, renameSync as renameSync15, unlinkSync as unlinkSync11, writeFileSync as writeFileSync17 } from "node:fs";
-import { homedir as homedir14, platform as platform3 } from "node:os";
-import { join as join20 } from "node:path";
+import { homedir as homedir15, platform as platform3 } from "node:os";
+import { join as join21 } from "node:path";
 function recordDir(engagementId, home) {
   if (!isEngagementId(engagementId))
     return null;
-  return join20(home ?? homedir14(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId);
+  return join21(home ?? homedir15(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId);
 }
 function readShownRecord(engagementId, home) {
   const dir = recordDir(engagementId, home);
   if (dir === null)
     return { entries: [], reviews: [] };
   try {
-    return parseShownRecord(readFileSync27(join20(dir, SHOWN_PLANS_FILENAME), "utf-8"));
+    return parseShownRecord(readFileSync27(join21(dir, SHOWN_PLANS_FILENAME), "utf-8"));
   } catch {
     return { entries: [], reviews: [] };
   }
@@ -32568,7 +33530,7 @@ function moveListedReviewForward(engagementId, home, listed, reviewVersion, deci
     const dir = recordDir(engagementId, home);
     if (dir === null)
       return false;
-    const path = join20(dir, SHOWN_PLANS_FILENAME);
+    const path = join21(dir, SHOWN_PLANS_FILENAME);
     const current = parseShownRecord(readFileSync27(path, "utf-8"));
     const at = current.reviews.findIndex((r) => r.phase === listed.phase && r.shownAt === listed.shownAt && r.reviewVersion === listed.reviewVersion);
     if (at === -1)
@@ -32576,7 +33538,7 @@ function moveListedReviewForward(engagementId, home, listed, reviewVersion, deci
     const acts = new Map(decided.map((d) => [d.part, d.act]));
     const reviews = current.reviews.map((review, i) => i === at ? { ...review, reviewVersion, parts: review.parts.map((p) => movedPart(p, acts.get(p.part))) } : review);
     const body = serialiseShownRecord({ entries: current.entries, reviews });
-    temp = join20(dir, `.${SHOWN_PLANS_FILENAME}.${process.pid}.tmp`);
+    temp = join21(dir, `.${SHOWN_PLANS_FILENAME}.${process.pid}.tmp`);
     writeFileSync17(temp, body, { mode: 384 });
     if (platform3() !== "win32")
       chmodSync4(temp, 384);
@@ -32960,8 +33922,16 @@ function allowArmedLine(step = null) {
 function allowNothingHeldLine() {
   return line(`${NOTHING_ALLOWED}: no step is paused in this session.`);
 }
-function allowSeveralHeldLine() {
-  return `${NOTHING_ALLOWED}: more than one step was paused, so Halfcycle could not tell which one you meant. Nothing ran. When your agent tries the step again, type ${ALLOW_REPLY} once more. ${SHOW_AS_WRITTEN}`;
+var UNNAMED_PAUSED_STEP = "a paused step";
+function allowSeveralHeldLine(paused) {
+  const listed = paused.filter((p) => p.number !== null).map((p) => `${ALLOW_REPLY} ${String(p.number)} for ${p.step ?? UNNAMED_PAUSED_STEP}`).join("; ");
+  if (listed === "") {
+    return `${NOTHING_ALLOWED}: more than one step is paused, and Halfcycle could not number them on this computer. Nothing ran. ${SHOW_AS_WRITTEN}`;
+  }
+  return `${NOTHING_ALLOWED}: more than one step is paused. Type ${ALLOW_REPLY} and the step's number to run that one once: ${listed}. Nothing ran. ${SHOW_AS_WRITTEN}`;
+}
+function allowNotPausedLine(stepNumber) {
+  return line(`${NOTHING_ALLOWED}: step ${String(stepNumber)} is not paused in this session.`);
 }
 function allowNotAttendedLine() {
   return line(`${NOTHING_ALLOWED}: a paused step can be allowed by typing only when a person types it into an open session.`);
@@ -33047,8 +34017,8 @@ function waitLineForAnswer(context, answer) {
   }
 }
 var PACE_NOTHING_CHANGED_OPENING = "Nothing changed";
-function paceAnswerLine(text, agent) {
-  return agent === "claude-code" ? line(text) : codexLine(text);
+function paceAnswerLine(text, _agent) {
+  return codexLine(text);
 }
 function paceNumberDoneText(n, more) {
   const head = `Done. This build now runs up to ${paceAgentsOf(n)} at once.`;
@@ -33156,8 +34126,9 @@ async function decideLine(opts) {
   const review = { recognised: false };
   try {
     const prompt = promptOf(opts.input);
-    if (isAllowReply(prompt))
-      return `${decideAllow(opts)}
+    const allowReply = allowReplyOf(prompt);
+    if (allowReply !== null)
+      return `${decideAllow(allowReply.number, opts)}
 `;
     const autonomyShape = autonomyPhraseShape(prompt);
     if (autonomyShape !== null) {
@@ -33210,21 +34181,23 @@ async function decideLine(opts) {
 `;
   }
 }
-function decideAllow(opts) {
+function decideAllow(stepNumber, opts) {
   const env = opts.env ?? process.env;
   if ((opts.agent ?? "claude-code") === "claude-code" && !readSessionAttended(env))
     return allowNotAttendedLine();
-  const { outcome, step } = armAllowStep(sessionIdOf(opts.input), {
+  const { outcome, step, paused } = armAllowStep(sessionIdOf(opts.input), {
     ...opts.tempDir === void 0 ? {} : { dir: opts.tempDir },
     ...opts.now === void 0 ? {} : { now: opts.now }
-  });
+  }, stepNumber);
   switch (outcome) {
     case "armed":
       return allowArmedLine(step);
     case "nothing-held":
       return allowNothingHeldLine();
+    case "not-paused":
+      return allowNotPausedLine(stepNumber ?? 0);
     case "several-held":
-      return allowSeveralHeldLine();
+      return allowSeveralHeldLine(paused);
     case "not-saved":
       return allowNotSavedLine();
     default: {
@@ -33751,14 +34724,14 @@ function runUserPromptFindings(opts) {
 }
 
 // dist/resolve-engagement.js
-import { existsSync as existsSync8, readFileSync as readFileSync28, realpathSync as realpathSync9 } from "node:fs";
-import { join as join21, sep as sep6 } from "node:path";
-import { homedir as homedir15 } from "node:os";
+import { existsSync as existsSync9, readFileSync as readFileSync28, realpathSync as realpathSync10 } from "node:fs";
+import { join as join22, sep as sep7 } from "node:path";
+import { homedir as homedir16 } from "node:os";
 function defaultRegistryPath() {
-  return join21(homedir15(), ".halfcycle", "registry.json");
+  return join22(homedir16(), ".halfcycle", "registry.json");
 }
 function readRegistry(registryPath = defaultRegistryPath()) {
-  if (!existsSync8(registryPath))
+  if (!existsSync9(registryPath))
     return {};
   try {
     const parsed = JSON.parse(readFileSync28(registryPath, "utf-8"));
@@ -33776,7 +34749,7 @@ function readRegistry(registryPath = defaultRegistryPath()) {
 }
 function canonicalise(p) {
   try {
-    return realpathSync9(p);
+    return realpathSync10(p);
   } catch {
     return p;
   }
@@ -33797,7 +34770,7 @@ function resolveEngagement(cwd, registry2) {
 function isSelfOrAncestor(ancestor, target) {
   if (ancestor === target)
     return true;
-  const withSep = ancestor.endsWith(sep6) ? ancestor : ancestor + sep6;
+  const withSep = ancestor.endsWith(sep7) ? ancestor : ancestor + sep7;
   return target.startsWith(withSep);
 }
 function runResolveEngagement(cwd, registryPath) {
@@ -33810,12 +34783,12 @@ function runResolveEngagement(cwd, registryPath) {
 
 // dist/refresh-credential.js
 import { readFileSync as readFileSync30 } from "node:fs";
-import { resolve as resolve10 } from "node:path";
+import { resolve as resolve11 } from "node:path";
 
 // dist/mcp-headers.js
 import { readFileSync as readFileSync29 } from "node:fs";
-import { homedir as homedir16 } from "node:os";
-import { dirname as dirname10, resolve as resolve9 } from "node:path";
+import { homedir as homedir17 } from "node:os";
+import { dirname as dirname10, resolve as resolve10 } from "node:path";
 var URL_FLAG = "--url";
 function urlFromArguments(rest) {
   const at = [];
@@ -33842,12 +34815,12 @@ function headerLine(bearer, clientVersion) {
 }
 function projectRootFromBinary(binaryPath) {
   const depth = VENDORED_BIN_REL.split("/").length - 1;
-  return resolve9(dirname10(binaryPath), ...Array(depth).fill(".."));
+  return resolve10(dirname10(binaryPath), ...Array(depth).fill(".."));
 }
 function readPinnedVersion(root) {
   let raw;
   try {
-    raw = readFileSync29(resolve9(root, BUNDLE_PIN_REL), "utf-8");
+    raw = readFileSync29(resolve10(root, BUNDLE_PIN_REL), "utf-8");
   } catch {
     return void 0;
   }
@@ -33889,7 +34862,7 @@ function sentences(lines2) {
 }
 function badIdSentence(root) {
   return sentences([
-    `${resolve9(root, BUNDLE_PIN_REL)} names an engagement id that is not a Halfcycle project id,`,
+    `${resolve10(root, BUNDLE_PIN_REL)} names an engagement id that is not a Halfcycle project id,`,
     'so no credential was read. Delete that file and run "npx halfcycle" again: this repository',
     "is then set up as a new Halfcycle project."
   ]);
@@ -33903,7 +34876,7 @@ function storeProblemSentence(problem, root, home, engagementId) {
       ]);
     case "no-id":
       return sentences([
-        `${resolve9(root, BUNDLE_PIN_REL)} names no engagement id.`,
+        `${resolve10(root, BUNDLE_PIN_REL)} names no engagement id.`,
         'run "npx halfcycle" here to rewrite it.'
       ]);
     case "bad-id":
@@ -33920,7 +34893,7 @@ function storeProblemSentence(problem, root, home, engagementId) {
     case "no-credential":
       return sentences([
         `this machine holds no credential for engagement ${engagementId ?? ""}.`,
-        `run "npx halfcycle" in this repository \u2014 it will sign you in through your browser if needed, and write the credential to ${resolve9(home, HALFCYCLE_DIR_NAME)}, outside this repository.`
+        `run "npx halfcycle" in this repository \u2014 it will sign you in through your browser if needed, and write the credential to ${resolve10(home, HALFCYCLE_DIR_NAME)}, outside this repository.`
       ]);
   }
 }
@@ -33943,7 +34916,7 @@ async function refreshWithinDeadline(source, opts, writeErr) {
 }
 async function chooseBearer(opts) {
   const writeErr = opts.writeErr ?? defaultWriteErr;
-  const home = opts.home ?? homedir16();
+  const home = opts.home ?? homedir17();
   const root = projectRootFromBinary(opts.binaryPath);
   const environmentToken = opts.environmentTokenFirst ? readEnvironmentToken() : void 0;
   const store = resolveStore(root, home);
@@ -34086,8 +35059,8 @@ async function refreshCredentialToken(opts) {
     source
   });
   if (!refreshed.ok) {
-    const write = opts?.write ?? ((text) => process.stdout.write(text));
-    write(credentialRenewalFailedMessage(refreshed.remedy));
+    const write2 = opts?.write ?? ((text) => process.stdout.write(text));
+    write2(credentialRenewalFailedMessage(refreshed.remedy));
     return { token: void 0 };
   }
   return { token: refreshed.token };
@@ -34109,7 +35082,7 @@ var SESSION_START_PROBE_ATTEMPTS = 2;
 function registeredMcpUrl(projectRoot) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync30(resolve10(projectRoot, MCP_REGISTRATION_REL), "utf-8"));
+    parsed = JSON.parse(readFileSync30(resolve11(projectRoot, MCP_REGISTRATION_REL), "utf-8"));
   } catch {
     return void 0;
   }
@@ -34358,7 +35331,7 @@ async function runRefreshCredential(opts) {
 import { fileURLToPath } from "node:url";
 
 // dist/capture.js
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync18, mkdirSync as mkdirSync12, existsSync as existsSync9 } from "node:fs";
+import { readFileSync as readFileSync31, writeFileSync as writeFileSync18, mkdirSync as mkdirSync12, existsSync as existsSync10 } from "node:fs";
 import { dirname as dirname11 } from "node:path";
 function runCapture(provider, endpoint, opts = {}) {
   const repoRoot = opts.repoRoot ?? process.cwd();
@@ -34440,8 +35413,8 @@ function relativeFixturePath(repoRoot, fixture) {
 import { spawn as spawn2, spawnSync as spawnSync3 } from "node:child_process";
 import { createHash as createHash6, randomUUID as randomUUID3 } from "node:crypto";
 import { createWriteStream, mkdirSync as mkdirSync13, readdirSync as readdirSync11, readFileSync as readFileSync32, renameSync as renameSync16, unlinkSync as unlinkSync12, writeFileSync as writeFileSync19 } from "node:fs";
-import { homedir as homedir17 } from "node:os";
-import { dirname as dirname12, join as join22 } from "node:path";
+import { homedir as homedir18 } from "node:os";
+import { dirname as dirname12, join as join23 } from "node:path";
 
 // dist/test-counts.js
 function sum(values) {
@@ -34550,7 +35523,7 @@ function isProofTestPath(path) {
 function testRunsDir(engagementId, home) {
   if (!isEngagementId(engagementId))
     return null;
-  return join22(home ?? homedir17(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, TEST_RUNS_DIR_NAME);
+  return join23(home ?? homedir18(), HALFCYCLE_DIR_NAME, ENGAGEMENTS_DIR_NAME, engagementId, TEST_RUNS_DIR_NAME);
 }
 function commandIdOf(command) {
   return createHash6("sha256").update(command, "utf8").digest("hex").slice(0, 16);
@@ -34646,7 +35619,7 @@ function subjectKey(subject) {
 }
 function keptCheckPath(dir, subject, label) {
   const key = createHash6("sha256").update(JSON.stringify([...subjectKey(subject), label]), "utf8").digest("hex");
-  return join22(dir, COMMANDS_DIR_NAME, `${key.slice(0, 32)}.json`);
+  return join23(dir, COMMANDS_DIR_NAME, `${key.slice(0, 32)}.json`);
 }
 function readKeptCheck(dir, subject, label) {
   try {
@@ -34661,18 +35634,18 @@ function readKeptCheck(dir, subject, label) {
   }
 }
 function queuePath(dir, runId) {
-  return join22(dir, QUEUE_DIR_NAME, `${runId}.json`);
+  return join23(dir, QUEUE_DIR_NAME, `${runId}.json`);
 }
 function readQueue(dir) {
   let names;
   try {
-    names = readdirSync11(join22(dir, QUEUE_DIR_NAME)).filter((n) => n.endsWith(".json"));
+    names = readdirSync11(join23(dir, QUEUE_DIR_NAME)).filter((n) => n.endsWith(".json"));
   } catch {
     return [];
   }
   const reports = [];
   for (const name of names) {
-    const path = join22(dir, QUEUE_DIR_NAME, name);
+    const path = join23(dir, QUEUE_DIR_NAME, name);
     let parsed = null;
     try {
       parsed = testRunReportSchema.safeParse(JSON.parse(readFileSync32(path, "utf-8")));
@@ -34745,17 +35718,17 @@ function killTree(child, platform4, signal) {
     }
   }
 }
-function runCommand(command, repoRoot, logPath, env, deps) {
+function runCommand(command, repoRoot, logPath2, env, deps) {
   const platform4 = deps.platform ?? process.platform;
   const out = deps.stdout ?? process.stdout;
   const err = deps.stderr ?? process.stderr;
   const deadline = deps.deadlineMs ?? PROVE_RUN_DEADLINE_MS;
   const childEnv = { ...env };
   delete childEnv[SERVICE_TOKEN_VAR];
-  mkdirSync13(dirname12(logPath), { recursive: true, mode: 448 });
-  const log = createWriteStream(logPath, { mode: 384 });
+  mkdirSync13(dirname12(logPath2), { recursive: true, mode: 448 });
+  const log = createWriteStream(logPath2, { mode: 384 });
   const began = process.hrtime.bigint();
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     let timedOut = false;
     let started = true;
     let settled2 = false;
@@ -34790,7 +35763,7 @@ function runCommand(command, repoRoot, logPath, env, deps) {
       process.off("SIGINT", onSignal);
       process.off("SIGTERM", onSignal);
       const durationMs = Number((process.hrtime.bigint() - began) / 1000000n);
-      log.end(() => resolve11({ exitCode: timedOut || !started ? null : code, timedOut, started, durationMs }));
+      log.end(() => resolve12({ exitCode: timedOut || !started ? null : code, timedOut, started, durationMs }));
     };
     child.on("error", (e) => {
       started = false;
@@ -34912,13 +35885,13 @@ ${PROVE_USAGE}`);
   if (request.when === "before" && changedOutsideTests > 0)
     say(lateBeforeLine(changedOutsideTests));
   const runId = randomUUID3();
-  const logPath = join22(dir, `${runId}.log`);
+  const logPath2 = join23(dir, `${runId}.log`);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const deadline = deps.deadlineMs ?? PROVE_RUN_DEADLINE_MS;
-  const end = await runCommand(command, repoRoot, logPath, env, deps);
+  const end = await runCommand(command, repoRoot, logPath2, env, deps);
   let output = "";
   try {
-    output = readFileSync32(logPath, "utf-8");
+    output = readFileSync32(logPath2, "utf-8");
   } catch {
     output = "";
   }
@@ -34962,7 +35935,7 @@ ${PROVE_USAGE}`);
     sendLine = mine.outcome === "recorded" ? RECORDED_LINE : mine.outcome === "kept" ? NOT_SENT_YET_LINE : refusedLine(mine.refusal);
   }
   say(`${line2} ${sendLine}`);
-  say(`Its output is kept on this computer at ${logPath}`);
+  say(`Its output is kept on this computer at ${logPath2}`);
   return 0;
 }
 
@@ -35030,14 +36003,14 @@ function personCommandEnv(env) {
   }
   return out;
 }
-var runOwnCommandReal = (command, input, env) => new Promise((resolve11) => {
+var runOwnCommandReal = (command, input, env) => new Promise((resolve12) => {
   let out = "";
   let settled2 = false;
   const done = (v) => {
     if (settled2)
       return;
     settled2 = true;
-    resolve11(v);
+    resolve12(v);
   };
   try {
     const child = spawn3(command, {
@@ -35185,7 +36158,7 @@ async function main() {
   if (cmd === "time") {
     let line2;
     try {
-      line2 = JSON.stringify(await runTimeVerb());
+      line2 = JSON.stringify(await runTimeVerb({}, { final: args.slice(1).includes("--final") }));
     } catch {
       line2 = JSON.stringify({ outcome: "not-sent", reason: "unreachable" });
     }
@@ -35351,7 +36324,7 @@ function unknownCommand(name = args.join(" ")) {
          halfcycle-runner mcp-headers [--url <address>]
          halfcycle-runner observe
          halfcycle-runner observe --change <sortingId>
-         halfcycle-runner time
+         halfcycle-runner time [--final]
          halfcycle-runner prove <phase> <task> --label <label> --before|--after [-- <command>]
          halfcycle-runner pace [--start <phase> [--agents <n>]]
          halfcycle-runner pace --scan [--config-folder <dir>]
@@ -35362,10 +36335,10 @@ function unknownCommand(name = args.join(" ")) {
   process.exit(1);
 }
 function readStdin3() {
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const chunks = [];
     process.stdin.on("data", (chunk) => chunks.push(chunk));
-    process.stdin.on("end", () => resolve11(Buffer.concat(chunks).toString("utf-8")));
+    process.stdin.on("end", () => resolve12(Buffer.concat(chunks).toString("utf-8")));
     process.stdin.on("error", reject);
   });
 }