@trycadence/cli 0.1.11-dev.0 → 0.1.16-dev.0

package/dist/cadence

@@ -1513,13 +1513,14 @@ function createCadenceClient(options = {}) {
 // src/index.ts
 import { spawn, spawnSync } from "child_process";
 import { createHash, randomUUID } from "crypto";
+import { existsSync, readdirSync, readFileSync as readFileSyncNode, statSync } from "fs";
 import { mkdir, readFile, rm, stat, writeFile } from "fs/promises";
 import { basename, dirname, isAbsolute, join, parse } from "path";
 import { createInterface } from "readline/promises";
 // package.json
 var package_default = {
   name: "@trycadence/cli",
-  version: "0.1.11-dev.0",
+  version: "0.1.16-dev.0",
   private: false,
   type: "module",
   bin: {
@@ -1553,14 +1554,15 @@ var workLogParentSelectors = ["last", "ticket-last", "session-last", "last-decis
 var changesetPrNoteSources = ["agent", "human", "system"];
 var hookScopes = ["repo", "global", "both"];
 var agentEventSources = ["codex", "claude-code", "opencode", "openrouter", "unknown"];
-var defaultLeaseTtlSeconds = 5 * 60 * 60;
+var agentRunMemoryModes = ["checkpoint", "closeout"];
+var closeoutSessionActions = ["handoff", "end", "keep"];
+var defaultLeaseTtlSeconds = 15 * 60;
 var defaultCliApiBaseUrl = "https://cadenceapi.deploy.lvl8studios.com";
 var defaultCliWebBaseUrl = "https://cadence.deploy.lvl8studios.com";
-var defaultCheckpointThresholdMin = 3;
-var defaultCheckpointThresholdMax = 5;
+var defaultCheckpointThreshold = 3;
 var defaultCheckpointCooldownSeconds = 10 * 60;
 var defaultCheckpointWorkerTimeoutMs = 10 * 60 * 1000;
-var defaultHookCommand = "cadence agent-run ingest-stop --source codex --event stop";
+var defaultHookCommand = `/bin/sh -lc 'root=$(git rev-parse --show-toplevel 2>/dev/null) || exit 0; cd "$root" || exit 0; [ -f .cadence/config.json ] || [ -f .cadence/config.local.json ] || exit 0; exec cadence agent-run ingest-stop --source codex --event stop >/dev/null'`;
 var agentLoopSuppressEnv = "CADENCE_AGENT_EVENT_SUPPRESS";
 var credentialRefreshSkewMs = 60 * 1000;
 var credentialRefreshLockTimeoutMs = 10 * 1000;
@@ -1599,6 +1601,8 @@ var knownCommandPaths = [
   ["changesets", "notes", "put"],
   ["changesets", "notes", "apply"],
   ["agent-run", "ingest-stop"],
+  ["agent-run", "route"],
+  ["agent-run", "checkpoint"],
   ["agent-run", "closeout"],
   ["agent-run", "sweep"],
   ["agent-run", "doctor"],
@@ -2260,7 +2264,7 @@ function helpText() {
     "  cadence tickets attach <ticket-id> --from-intake <intake-id> --if-version <version> [--project <project-id>] [--json]",
     "  cadence tickets create --title <text> [--from-intake <intake-id>] [--project <project-id>] [--json]",
     "  cadence tickets update <ticket-id> --if-version <version> [--title <text>] [--description <text>] [--priority <priority>] [--status <status>] [--project <project-id>] [--json]",
-    "  cadence tickets claim <ticket-id> --session <session-id> [--actor <actor-id>] [--project <project-id>] [--json]",
+    "  cadence tickets claim <ticket-id> --session <session-id> [--actor <actor-id>] [--replace-own-active true|false] [--project <project-id>] [--json]",
     "  cadence tickets release <ticket-id> --lease <lease-id> [--project <project-id>] [--json]",
     "  cadence tickets log <ticket-id> --kind <intent|decision|rationale|action|verification|blocker|correction|note> --body <text> [--summary <text>] [--under <entry-id|ticket-last|session-last|last-decision|last-correction|last-action>] [--session <session-id>] [--changeset <changeset-id>] [--project <project-id>] [--json]",
     "  cadence tickets complete <ticket-id> --if-version <version> [--summary <summary>] [--project <project-id>] [--json]",
@@ -2278,11 +2282,13 @@ function helpText() {
     "  cadence changesets notes put [--changeset <id>|--branch current|<branch>] --title <text> --body-file <path> [--head-sha <sha>] [--base-sha <sha>] [--pr-url <url>] [--pr-number <n>] [--project <project-id>] [--json]",
     "  cadence changesets notes apply [--changeset <id>|--branch current|<branch>] --provider github --pr-number <n> --pr-url <url> [--project <project-id>] [--json]",
     "  cadence agent-run ingest-stop --source <codex|claude-code|opencode|openrouter> [--event <event>] [--threshold <n>] [--dry-run true|false] [--project <project-id>] [--json]",
-    "  cadence agent-run closeout --agent-session-key <key> [--reason <threshold|idle|manual>] [--event-file <path>] [--log-kind <kind>] [--update-summary true|false] [--json]",
+    "  cadence agent-run route --agent-session-key <key> --reason <missing_context|checkpoint_reroute|manual> [--event-file <path>] [--checkpoint-provider codex] [--checkpoint-model <model>] [--json]",
+    "  cadence agent-run checkpoint --agent-session-key <key> [--reason <threshold|idle|manual>] [--event-file <path>] [--ticket <ticket-id>] [--session <session-id>] [--changeset <changeset-id>] [--checkpoint-provider codex] [--checkpoint-model <model>] [--log-kind <kind>] [--update-summary true|false] [--json]",
+    "  cadence agent-run closeout --agent-session-key <key> [--session-action handoff|end|keep] [--complete-ticket true|false] [--event-file <path>] [--ticket <ticket-id>] [--session <session-id>] [--changeset <changeset-id>] [--checkpoint-provider codex] [--checkpoint-model <model>] [--update-summary true|false] [--json]",
     "  cadence agent-run sweep [--idle-after-seconds <n>] [--dry-run true|false] [--json]",
     "  cadence agent-run doctor [--json]",
-    "  cadence hooks install --provider codex --scope <repo|global|both> [--command <command>] [--json]",
-    "  cadence hooks doctor --provider codex --scope <repo|global|both> [--json]",
+    "  cadence hooks install --provider codex [--scope global] [--command <command>] [--json]",
+    "  cadence hooks doctor --provider codex [--scope global] [--json]",
     "  cadence events list [--project <project-id>] [--ticket <ticket-id>] [--changeset <changeset-id>] [--session <session-id>] [--json]",
     "",
     "Global flags:",
@@ -2581,6 +2587,14 @@ function truncateText(value, maxLength) {
   return `${value.slice(0, maxLength - 15)}
 [truncated]`;
 }
+function estimateTokenCount(value) {
+  const text = value.trim();
+  if (!text) {
+    return 0;
+  }
+  const pieces = text.match(/[A-Za-z0-9_]+|[^\sA-Za-z0-9_]/g) ?? [];
+  return Math.max(pieces.length, Math.ceil(text.length / 4));
+}
 function stableHash(value) {
   return createHash("sha256").update(value).digest("hex");
 }
@@ -2619,13 +2633,392 @@ function firstString(record, paths) {
   }
   return;
 }
+function readRecentAgentTurns(input) {
+  const rawTurns = input.recent_turns ?? input.recentTurns ?? input.turns;
+  if (!Array.isArray(rawTurns)) {
+    return;
+  }
+  const turns = rawTurns.map((turn) => {
+    if (!turn || typeof turn !== "object" || Array.isArray(turn)) {
+      return;
+    }
+    const record = turn;
+    const user = firstString(record, [["user"], ["prompt"], ["userPrompt"], ["request"]]);
+    const assistant = firstString(record, [["assistant"], ["response"], ["assistantResponse"], ["reply"]]);
+    const occurredAt = firstString(record, [["occurredAt"], ["occurred_at"], ["timestamp"], ["createdAt"]]);
+    if (!user && !assistant) {
+      return;
+    }
+    return {
+      ...user ? { user: truncateText(user, 6000) } : {},
+      ...assistant ? { assistant: truncateText(assistant, 6000) } : {},
+      ...occurredAt ? { occurredAt } : {}
+    };
+  }).filter((turn) => Boolean(turn));
+  return turns.length ? turns.slice(-3) : undefined;
+}
+function mergeRecentAgentTurns(existing, next) {
+  if (!next?.length) {
+    return existing?.length ? existing.slice(-3) : undefined;
+  }
+  return [...existing ?? [], ...next].slice(-3);
+}
+function stringFromCodexContent(value) {
+  if (typeof value === "string") {
+    return value.trim() || undefined;
+  }
+  if (Array.isArray(value)) {
+    const text = value.map((item) => {
+      if (typeof item === "string") {
+        return item;
+      }
+      if (item && typeof item === "object" && !Array.isArray(item)) {
+        const record = item;
+        return typeof record.text === "string" ? record.text : typeof record.content === "string" ? record.content : "";
+      }
+      return "";
+    }).join(`
+`).trim();
+    return text || undefined;
+  }
+  return;
+}
+function findCodexSessionFile(directory, agentSessionId, depth = 0) {
+  if (depth > 6 || !existsSync(directory)) {
+    return;
+  }
+  let entries;
+  try {
+    entries = readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const entryPath = join(directory, entry.name);
+    if (entry.isFile() && entry.name.endsWith(".jsonl") && entry.name.includes(agentSessionId)) {
+      return entryPath;
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const found = findCodexSessionFile(join(directory, entry.name), agentSessionId, depth + 1);
+    if (found) {
+      return found;
+    }
+  }
+  return;
+}
+function codexSessionsDirectory(options) {
+  const home = options.env?.HOME ?? process.env.HOME;
+  const codexHome = options.env?.CODEX_HOME ?? process.env.CODEX_HOME ?? (home ? join(home, ".codex") : undefined);
+  return codexHome ? join(codexHome, "sessions") : undefined;
+}
+function listCodexSessionFiles(directory, depth = 0) {
+  if (depth > 6 || !existsSync(directory)) {
+    return [];
+  }
+  let entries;
+  try {
+    entries = readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.flatMap((entry) => {
+    const entryPath = join(directory, entry.name);
+    if (entry.isDirectory()) {
+      return listCodexSessionFiles(entryPath, depth + 1);
+    }
+    if (!entry.isFile() || !entry.name.endsWith(".jsonl")) {
+      return [];
+    }
+    try {
+      return [{ path: entryPath, mtimeMs: statSync(entryPath).mtimeMs }];
+    } catch {
+      return [];
+    }
+  });
+}
+function readCodexSessionMeta(filePath) {
+  let lines;
+  try {
+    lines = readFileSyncNode(filePath, "utf8").split(`
+`).filter((line) => line.trim());
+  } catch {
+    return {};
+  }
+  for (const line of lines) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      continue;
+    }
+    const event = parsed;
+    const payload = event.payload && typeof event.payload === "object" && !Array.isArray(event.payload) ? event.payload : {};
+    if (event.type !== "session_meta") {
+      continue;
+    }
+    return {
+      ...typeof payload.id === "string" ? { id: payload.id } : {},
+      ...typeof payload.cwd === "string" ? { cwd: payload.cwd } : {},
+      ...typeof event.timestamp === "string" ? { timestamp: event.timestamp } : {}
+    };
+  }
+  return {};
+}
+function findCodexSessionFileCreatedAfter(options, startedAtMs, cwd) {
+  const sessionsDirectory = codexSessionsDirectory(options);
+  if (!sessionsDirectory) {
+    return;
+  }
+  const candidates = listCodexSessionFiles(sessionsDirectory).filter((candidate) => candidate.mtimeMs >= startedAtMs - 1000).map((candidate) => ({
+    ...candidate,
+    meta: readCodexSessionMeta(candidate.path)
+  })).filter((candidate) => !candidate.meta.cwd || candidate.meta.cwd === cwd).sort((left, right) => right.mtimeMs - left.mtimeMs);
+  return candidates[0]?.path;
+}
+function codexTranscriptTextFromPayload(payload) {
+  return stringFromCodexContent(payload.message) ?? stringFromCodexContent(payload.text) ?? stringFromCodexContent(payload.content) ?? stringFromCodexContent(payload.output) ?? undefined;
+}
+function summarizeCodexTranscriptEvent(raw, index) {
+  const payload = raw.payload && typeof raw.payload === "object" && !Array.isArray(raw.payload) ? raw.payload : {};
+  const type = typeof raw.type === "string" ? raw.type : "unknown";
+  const payloadType = typeof payload.type === "string" ? payload.type : undefined;
+  const text = codexTranscriptTextFromPayload(payload);
+  const callId = typeof payload.call_id === "string" ? payload.call_id : typeof payload.callId === "string" ? payload.callId : undefined;
+  const toolArguments = typeof payload.arguments === "string" ? payload.arguments : payload.arguments && typeof payload.arguments === "object" ? JSON.stringify(payload.arguments) : undefined;
+  const toolName = typeof payload.tool_name === "string" ? payload.tool_name : typeof payload.toolName === "string" ? payload.toolName : typeof payload.name === "string" ? payload.name : undefined;
+  return {
+    index,
+    type,
+    ...payloadType ? { payloadType } : {},
+    ...typeof raw.timestamp === "string" ? { timestamp: raw.timestamp } : {},
+    ...text ? { text: truncateText(text, 8000) } : {},
+    ...callId ? { callId } : {},
+    ...toolName ? { toolName } : {},
+    ...toolArguments ? { toolArguments: truncateText(toolArguments, 8000) } : {},
+    raw
+  };
+}
+function numberFromRecord(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function codexTokenUsageRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  return {
+    ...numberFromRecord(record, "input_tokens") !== undefined ? { inputTokens: numberFromRecord(record, "input_tokens") } : {},
+    ...numberFromRecord(record, "cached_input_tokens") !== undefined ? { cachedInputTokens: numberFromRecord(record, "cached_input_tokens") } : {},
+    ...numberFromRecord(record, "output_tokens") !== undefined ? { outputTokens: numberFromRecord(record, "output_tokens") } : {},
+    ...numberFromRecord(record, "reasoning_output_tokens") !== undefined ? { reasoningOutputTokens: numberFromRecord(record, "reasoning_output_tokens") } : {},
+    ...numberFromRecord(record, "total_tokens") !== undefined ? { totalTokens: numberFromRecord(record, "total_tokens") } : {}
+  };
+}
+function extractCodexTokenUsage(events) {
+  const tokenEvents = events.filter((event) => event.payloadType === "token_count");
+  if (!tokenEvents.length) {
+    return;
+  }
+  let total;
+  let last;
+  let modelContextWindow;
+  let updatedAt;
+  for (const event of tokenEvents) {
+    const payload = event.raw.payload && typeof event.raw.payload === "object" && !Array.isArray(event.raw.payload) ? event.raw.payload : {};
+    const info = payload.info && typeof payload.info === "object" && !Array.isArray(payload.info) ? payload.info : {};
+    const parsedTotal = codexTokenUsageRecord(info.total_token_usage);
+    const parsedLast = codexTokenUsageRecord(info.last_token_usage);
+    const parsedContextWindow = numberFromRecord(info, "model_context_window");
+    if (parsedTotal && Object.keys(parsedTotal).length) {
+      total = parsedTotal;
+    }
+    if (parsedLast && Object.keys(parsedLast).length) {
+      last = parsedLast;
+    }
+    if (parsedContextWindow !== undefined) {
+      modelContextWindow = parsedContextWindow;
+    }
+    updatedAt = event.timestamp;
+  }
+  return {
+    source: "codex_session_transcript",
+    eventCount: tokenEvents.length,
+    ...total ? { total } : {},
+    ...last ? { last } : {},
+    ...modelContextWindow !== undefined ? { modelContextWindow } : {},
+    ...updatedAt ? { updatedAt } : {}
+  };
+}
+function tokenUsageTotal(tokenUsage) {
+  return tokenUsage?.total;
+}
+function roundedRatio(numerator, denominator) {
+  if (denominator <= 0) {
+    return;
+  }
+  return Math.round(numerator / denominator * 1000) / 1000;
+}
+function readCodexSessionTranscript(filePath) {
+  if (!filePath) {
+    return;
+  }
+  let lines;
+  try {
+    lines = readFileSyncNode(filePath, "utf8").split(`
+`).filter((line) => line.trim());
+  } catch {
+    return;
+  }
+  const events = lines.flatMap((line, index) => {
+    try {
+      const parsed = JSON.parse(line);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return [];
+      }
+      return [summarizeCodexTranscriptEvent(parsed, index)];
+    } catch {
+      return [
+        {
+          index,
+          type: "unparsed",
+          text: truncateText(line, 8000),
+          raw: { line }
+        }
+      ];
+    }
+  });
+  return {
+    path: filePath,
+    fileName: basename(filePath),
+    lineCount: lines.length,
+    ...extractCodexTokenUsage(events) ? { tokenUsage: extractCodexTokenUsage(events) } : {},
+    events
+  };
+}
+function readRecentTurnsFromCodexSessionFile(filePath) {
+  let lines;
+  try {
+    lines = readFileSyncNode(filePath, "utf8").split(`
+`).filter((line) => line.trim());
+  } catch {
+    return;
+  }
+  const messages = [];
+  const pushMessage = (message) => {
+    const previous = messages[messages.length - 1];
+    if (previous?.role === message.role && previous.text === message.text) {
+      return;
+    }
+    messages.push(message);
+  };
+  for (const line of lines) {
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      continue;
+    }
+    const event = parsed;
+    const payload = event.payload && typeof event.payload === "object" && !Array.isArray(event.payload) ? event.payload : undefined;
+    if (event.type === "event_msg" && payload?.type === "user_message") {
+      const text = stringFromCodexContent(payload.message);
+      if (text) {
+        pushMessage({
+          role: "user",
+          text,
+          ...typeof event.timestamp === "string" ? { occurredAt: event.timestamp } : {}
+        });
+      }
+    }
+    if (event.type === "event_msg" && payload?.type === "agent_message") {
+      const text = stringFromCodexContent(payload.message);
+      if (text) {
+        pushMessage({
+          role: "assistant",
+          text,
+          ...typeof event.timestamp === "string" ? { occurredAt: event.timestamp } : {}
+        });
+      }
+    }
+    if (event.type === "response_item" && payload?.type === "message" && (payload.role === "user" || payload.role === "assistant")) {
+      const text = stringFromCodexContent(payload.content) ?? stringFromCodexContent(payload.message);
+      if (text) {
+        pushMessage({
+          role: payload.role,
+          text,
+          ...typeof event.timestamp === "string" ? { occurredAt: event.timestamp } : {}
+        });
+      }
+    }
+  }
+  const turns = [];
+  let pendingUser;
+  let pendingAssistantParts = [];
+  const flushPendingTurn = () => {
+    if (!pendingUser) {
+      return;
+    }
+    const assistant = pendingAssistantParts.join(`
+
+`).trim();
+    turns.push({
+      user: truncateText(pendingUser.text, 6000),
+      ...assistant ? { assistant: truncateText(assistant, 6000) } : {},
+      ...pendingUser.occurredAt ? { occurredAt: pendingUser.occurredAt } : {}
+    });
+    pendingUser = undefined;
+    pendingAssistantParts = [];
+  };
+  for (const message of messages) {
+    if (message.role === "user") {
+      flushPendingTurn();
+      pendingUser = {
+        text: message.text,
+        ...message.occurredAt ? { occurredAt: message.occurredAt } : {}
+      };
+      pendingAssistantParts = [];
+      continue;
+    }
+    if (pendingUser) {
+      if (pendingAssistantParts[pendingAssistantParts.length - 1] !== message.text) {
+        pendingAssistantParts.push(message.text);
+      }
+    } else {
+      turns.push({
+        assistant: truncateText(message.text, 6000),
+        ...message.occurredAt ? { occurredAt: message.occurredAt } : {}
+      });
+    }
+  }
+  flushPendingTurn();
+  return turns.length ? turns.slice(-3) : undefined;
+}
+function readRecentTurnsFromCodexSession(agentSessionId, options) {
+  const sessionsDirectory = codexSessionsDirectory(options);
+  if (!sessionsDirectory) {
+    return;
+  }
+  const sessionFile = findCodexSessionFile(sessionsDirectory, agentSessionId);
+  return sessionFile ? readRecentTurnsFromCodexSessionFile(sessionFile) : undefined;
+}
 function normalizeAgentEvent(input, parsed, options) {
   const source = parseAgentEventSource(parsed.options.source);
   const event = parsed.options.event ?? "stop";
   const base = normalizeAgentEventBase(input, source, event, options);
   switch (source) {
     case "codex":
-      return normalizeCodexAgentEvent(input, base);
+      return normalizeCodexAgentEvent(input, base, options);
     case "claude-code":
     case "opencode":
     case "openrouter":
@@ -2636,6 +3029,7 @@ function normalizeAgentEvent(input, parsed, options) {
 function normalizeAgentEventBase(input, source, event, options) {
   const threadId = firstString(input, [["thread_id"], ["threadId"], ["conversation_id"], ["conversationId"]]);
   const turnId = firstString(input, [["turn_id"], ["turnId"], ["id"]]);
+  const recentTurns = readRecentAgentTurns(input);
   const lastAssistantMessage = firstString(input, [
     ["last_assistant_message"],
     ["lastAssistantMessage"],
@@ -2652,10 +3046,11 @@ function normalizeAgentEventBase(input, source, event, options) {
     ...threadId ? { threadId } : {},
     ...turnId ? { turnId } : {},
     ...lastAssistantMessage ? { lastAssistantMessage: truncateText(lastAssistantMessage, 6000) } : {},
+    ...recentTurns ? { recentTurns } : {},
     payloadKeys: Object.keys(input).sort()
   };
 }
-function normalizeCodexAgentEvent(input, base) {
+function normalizeCodexAgentEvent(input, base, options) {
   const agentSessionId = firstString(input, [["session_id"], ["sessionId"], ["session", "id"]]);
   if (!agentSessionId) {
     return {
@@ -2663,10 +3058,13 @@ function normalizeCodexAgentEvent(input, base) {
       diagnosticReason: "missing_agent_session_id"
     };
   }
+  const transcriptPath = firstString(input, [["transcript_path"], ["transcriptPath"]]);
+  const recentTurns = base.recentTurns?.length ? base.recentTurns : transcriptPath ? readRecentTurnsFromCodexSessionFile(transcriptPath) : readRecentTurnsFromCodexSession(agentSessionId, options);
   return {
     ...base,
     agentSessionId,
-    agentSessionKey: agentSessionKey(base.source, agentSessionId)
+    agentSessionKey: agentSessionKey(base.source, agentSessionId),
+    ...recentTurns?.length ? { recentTurns } : {}
   };
 }
 function normalizeGenericAgentEvent(input, base) {
@@ -2692,14 +3090,24 @@ function normalizeGenericAgentEvent(input, base) {
 function agentSessionKey(source, agentSessionId) {
   return `${source}:${stableHash(agentSessionId)}`;
 }
+function checkpointWorkLogMetadata(settings, mode, tokenAccounting) {
+  return {
+    checkpoint: {
+      ...mode ? { mode } : {},
+      provider: settings.provider,
+      ...settings.model ? { model: settings.model } : {},
+      ...tokenAccounting ? { tokenAccounting } : {}
+    }
+  };
+}
 function defaultAgentLoopState() {
   return {
     version: 2,
     sessions: {}
   };
 }
-function randomCheckpointThreshold() {
-  return defaultCheckpointThresholdMin + Math.floor(Math.random() * (defaultCheckpointThresholdMax - defaultCheckpointThresholdMin + 1));
+function defaultCheckpointThresholdValue() {
+  return defaultCheckpointThreshold;
 }
 function agentLoopDirectory(parsed, options) {
   return parsed.options["state-dir"] ? isAbsolute(parsed.options["state-dir"]) ? parsed.options["state-dir"] : join(options.cwd ?? process.cwd(), parsed.options["state-dir"]) : join(options.cwd ?? process.cwd(), ".context", "cadence-agent-loop");
@@ -2707,8 +3115,81 @@ function agentLoopDirectory(parsed, options) {
 function agentLoopStatePath(parsed, options) {
   return join(agentLoopDirectory(parsed, options), "state.json");
 }
+function agentLoopSettingsPath(parsed, options) {
+  if (parsed.options["state-dir"]) {
+    return join(agentLoopDirectory(parsed, options), "settings.json");
+  }
+  return join(getConfigHome(options.env ?? process.env), "agent-run", "settings.json");
+}
+function legacyAgentLoopSettingsPath(parsed, options) {
+  return join(agentLoopDirectory(parsed, options), "settings.json");
+}
 function agentLoopLockPath(parsed, options, agentSessionKeyValue) {
-  return join(agentLoopDirectory(parsed, options), agentSessionKeyValue ? `closeout-${stableHash(agentSessionKeyValue)}.lock` : "closeout.lock");
+  return join(agentLoopDirectory(parsed, options), agentSessionKeyValue ? `checkpoint-${stableHash(agentSessionKeyValue)}.lock` : "checkpoint.lock");
+}
+function normalizeCheckpointModel(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return;
+  }
+  if (trimmed.length > 120 || /\s/.test(trimmed)) {
+    throw new CliError("CLI_USAGE", "Checkpoint model must be a non-empty model id without whitespace.");
+  }
+  return trimmed;
+}
+function defaultAgentLoopSettings() {
+  return {
+    version: 1,
+    checkpoint: {
+      provider: "codex"
+    }
+  };
+}
+async function readAgentLoopSettings(parsed, options) {
+  const filePath = agentLoopSettingsPath(parsed, options);
+  let file = Bun.file(filePath);
+  if (!await file.exists()) {
+    const legacyFilePath = legacyAgentLoopSettingsPath(parsed, options);
+    if (legacyFilePath === filePath) {
+      return defaultAgentLoopSettings();
+    }
+    file = Bun.file(legacyFilePath);
+    if (!await file.exists()) {
+      return defaultAgentLoopSettings();
+    }
+  }
+  const parsedSettings = JSON.parse(await file.text());
+  if (!parsedSettings || typeof parsedSettings !== "object" || Array.isArray(parsedSettings)) {
+    return defaultAgentLoopSettings();
+  }
+  const record = parsedSettings;
+  const checkpoint = record.checkpoint;
+  if (!checkpoint || typeof checkpoint !== "object" || Array.isArray(checkpoint)) {
+    return defaultAgentLoopSettings();
+  }
+  const checkpointRecord = checkpoint;
+  const provider = checkpointRecord.provider === "codex" ? "codex" : "codex";
+  const model = typeof checkpointRecord.model === "string" ? normalizeCheckpointModel(checkpointRecord.model) : undefined;
+  return {
+    version: 1,
+    checkpoint: {
+      provider,
+      ...model ? { model } : {},
+      ...typeof checkpointRecord.updatedAt === "string" ? { updatedAt: checkpointRecord.updatedAt } : {}
+    }
+  };
+}
+async function resolveCheckpointSettings(parsed, options) {
+  const saved = await readAgentLoopSettings(parsed, options);
+  const provider = parsed.options["checkpoint-provider"] ?? saved.checkpoint.provider;
+  if (provider !== "codex") {
+    throw new CliError("CLI_USAGE", "Only the Codex checkpoint provider is supported in this version.");
+  }
+  const model = normalizeCheckpointModel(parsed.options["checkpoint-model"] ?? parsed.options.model ?? saved.checkpoint.model);
+  return {
+    provider: "codex",
+    ...model ? { model } : {}
+  };
 }
 async function readAgentLoopState(parsed, options) {
   const filePath = agentLoopStatePath(parsed, options);
@@ -2754,24 +3235,87 @@ function readAgentLoopSessions(rawSessions) {
     const record = rawSession;
     const source = parseAgentEventSource(typeof record.source === "string" ? record.source : undefined);
     const stopCount = typeof record.stopCount === "number" && Number.isInteger(record.stopCount) && record.stopCount >= 0 ? record.stopCount : 0;
-    const threshold = typeof record.threshold === "number" && Number.isInteger(record.threshold) && record.threshold > 0 ? record.threshold : randomCheckpointThreshold();
+    const threshold = typeof record.threshold === "number" && Number.isInteger(record.threshold) && record.threshold > 0 ? record.threshold : defaultCheckpointThresholdValue();
+    const recentTurns = Array.isArray(record.recentTurns) ? readRecentAgentTurns({
+      recentTurns: record.recentTurns
+    }) : undefined;
     sessions[key] = {
       source,
       stopCount,
       threshold,
+      ...readAgentSessionCadenceContext(record),
       ...typeof record.firstObservedAt === "string" ? { firstObservedAt: record.firstObservedAt } : {},
       ...typeof record.lastObservedAt === "string" ? { lastObservedAt: record.lastObservedAt } : {},
+      ...typeof record.lastObservedTurnId === "string" ? { lastObservedTurnId: record.lastObservedTurnId } : {},
       ...typeof record.lastAction === "string" ? { lastAction: record.lastAction } : {},
       ...typeof record.lastReason === "string" ? { lastReason: record.lastReason } : {},
       ...typeof record.lastEventFile === "string" ? { lastEventFile: record.lastEventFile } : {},
       ...typeof record.lastAssistantMessage === "string" ? { lastAssistantMessage: record.lastAssistantMessage } : {},
+      ...recentTurns ? { recentTurns } : {},
       ...typeof record.lastCheckpointAt === "string" ? { lastCheckpointAt: record.lastCheckpointAt } : {},
       ...typeof record.lastCheckpointFingerprint === "string" ? { lastCheckpointFingerprint: record.lastCheckpointFingerprint } : {},
-      ...typeof record.previousCheckpointSummary === "string" ? { previousCheckpointSummary: record.previousCheckpointSummary } : {}
+      ...readAgentRunFingerprints(record.lastCheckpointFingerprints),
+      ...typeof record.lastCheckpointMode === "string" && agentRunMemoryModes.includes(record.lastCheckpointMode) ? { lastCheckpointMode: record.lastCheckpointMode } : {},
+      ...readAgentRunCoverage(record.lastCheckpointCoverage),
+      ...typeof record.previousCheckpointSummary === "string" ? { previousCheckpointSummary: record.previousCheckpointSummary } : {},
+      ...typeof record.lastCheckpointAuditFile === "string" ? { lastCheckpointAuditFile: record.lastCheckpointAuditFile } : {}
     };
   }
   return sessions;
 }
+function readAgentRunFingerprints(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const record = value;
+  const event = typeof record.event === "string" ? record.event : undefined;
+  const git = typeof record.git === "string" ? record.git : undefined;
+  const cadenceContext = typeof record.cadenceContext === "string" ? record.cadenceContext : undefined;
+  if (!event || !git || !cadenceContext) {
+    return {};
+  }
+  return {
+    lastCheckpointFingerprints: {
+      event,
+      git,
+      cadenceContext,
+      ...typeof record.verification === "string" ? { verification: record.verification } : {},
+      ...typeof record.coverageDebt === "string" ? { coverageDebt: record.coverageDebt } : {}
+    }
+  };
+}
+function readAgentRunCoverage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const record = value;
+  const coverage = {
+    outcome: record.outcome === true,
+    implementation: record.implementation === true,
+    decisions: record.decisions === true,
+    corrections: record.corrections === true,
+    verification: record.verification === true,
+    blockers: record.blockers === true,
+    scope: record.scope === true,
+    handoff: record.handoff === true,
+    hasDebt: record.hasDebt === true
+  };
+  return { lastCheckpointCoverage: coverage };
+}
+function readAgentSessionCadenceContext(record) {
+  const value = record.cadenceContext;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const contextRecord = value;
+  const cadenceContext = {
+    ...typeof contextRecord.ticketId === "string" ? { ticketId: contextRecord.ticketId } : {},
+    ...typeof contextRecord.sessionId === "string" ? { sessionId: contextRecord.sessionId } : {},
+    ...typeof contextRecord.changesetId === "string" ? { changesetId: contextRecord.changesetId } : {},
+    ...typeof contextRecord.capturedAt === "string" ? { capturedAt: contextRecord.capturedAt } : {}
+  };
+  return cadenceContext.ticketId || cadenceContext.sessionId || cadenceContext.changesetId ? { cadenceContext } : {};
+}
 function readAgentLoopDiagnostics(record) {
   return {
     ...typeof record.missingSessionIdCount === "number" && Number.isInteger(record.missingSessionIdCount) && record.missingSessionIdCount > 0 ? { missingSessionIdCount: record.missingSessionIdCount } : {},
@@ -2806,6 +3350,15 @@ async function writeAgentEventFile(parsed, options, event) {
 `);
   return filePath;
 }
+async function writeAgentCheckpointAuditFile(parsed, options, audit) {
+  const checkpointsDirectory = join(agentLoopDirectory(parsed, options), "checkpoints");
+  const fileName = `${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID()}.json`;
+  const filePath = join(checkpointsDirectory, fileName);
+  await mkdir(checkpointsDirectory, { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(audit, null, 2)}
+`);
+  return filePath;
+}
 async function removeStaleAgentLoopLock(lockPath) {
   try {
     const lockStats = await stat(lockPath);
@@ -2891,7 +3444,7 @@ function currentCliWorkerInvocation() {
     argsPrefix: []
   };
 }
-async function spawnAgentRunCloseout(args, options) {
+async function spawnAgentRunWorker(args, options) {
   const cwd = options.cwd ?? process.cwd();
   const invocation = currentCliWorkerInvocation();
   const env = {
@@ -2910,47 +3463,91 @@ async function spawnAgentRunCloseout(args, options) {
   });
   child.unref();
 }
+async function spawnAgentRunCheckpoint(args, options) {
+  await spawnAgentRunWorker(args, options);
+}
+function currentRecordTime(value, keys) {
+  for (const key of keys) {
+    const candidate = value[key];
+    if (typeof candidate !== "string") {
+      continue;
+    }
+    const time = new Date(candidate).getTime();
+    if (!Number.isNaN(time)) {
+      return time;
+    }
+  }
+  return 0;
+}
 function activeSessionFromCurrent(current) {
   const record = current && typeof current === "object" ? current : null;
   const sessions = Array.isArray(record?.sessions) ? record.sessions : [];
-  const activeSession = sessions.find((session) => {
-    if (!session || typeof session !== "object") {
-      return false;
-    }
-    const sessionRecord2 = session;
-    return sessionRecord2.status === "active" && typeof sessionRecord2.ticketId === "string";
-  });
-  if (activeSession && typeof activeSession === "object") {
-    return activeSession;
-  }
   const activeLeases = Array.isArray(record?.activeLeases) ? record.activeLeases : Array.isArray(record?.leases) ? record.leases.filter((lease) => lease && typeof lease === "object" && lease.status === "active") : [];
-  const activeLease = activeLeases.find((lease) => {
+  const activeLease = activeLeases.filter((lease) => {
     if (!lease || typeof lease !== "object") {
       return false;
     }
-    const leaseRecord2 = lease;
-    return typeof leaseRecord2.ticketId === "string";
-  });
-  if (!activeLease || typeof activeLease !== "object") {
-    return null;
+    const leaseRecord = lease;
+    return typeof leaseRecord.ticketId === "string";
+  }).map((lease) => lease).sort((left, right) => currentRecordTime(right, ["lastSeenAt", "claimedAt", "expiresAt"]) - currentRecordTime(left, ["lastSeenAt", "claimedAt", "expiresAt"]))[0];
+  if (activeLease && typeof activeLease === "object") {
+    const leaseRecord = activeLease;
+    const sessionId = typeof leaseRecord.sessionId === "string" ? leaseRecord.sessionId : undefined;
+    const matchingSession = sessions.find((session) => {
+      if (!session || typeof session !== "object") {
+        return false;
+      }
+      return sessionId && session.id === sessionId;
+    });
+    const sessionRecord = matchingSession && typeof matchingSession === "object" ? matchingSession : {};
+    return {
+      ...sessionRecord,
+      ...sessionId ? { id: sessionId } : {},
+      ticketId: leaseRecord.ticketId,
+      ...typeof leaseRecord.changesetId === "string" ? { changesetId: leaseRecord.changesetId } : typeof sessionRecord.changesetId === "string" ? { changesetId: sessionRecord.changesetId } : {},
+      status: "active"
+    };
   }
-  const leaseRecord = activeLease;
-  const sessionId = typeof leaseRecord.sessionId === "string" ? leaseRecord.sessionId : undefined;
-  const matchingSession = sessions.find((session) => {
+  const activeSessions = sessions.filter((session) => {
     if (!session || typeof session !== "object") {
       return false;
     }
-    return sessionId && session.id === sessionId;
+    const sessionRecord = session;
+    return sessionRecord.status === "active" && typeof sessionRecord.ticketId === "string";
   });
-  const sessionRecord = matchingSession && typeof matchingSession === "object" ? matchingSession : {};
+  const activeSession = activeSessions.map((session) => session).sort((left, right) => currentRecordTime(right, ["lastActivityAt", "startedAt"]) - currentRecordTime(left, ["lastActivityAt", "startedAt"]))[0];
+  if (activeSession && typeof activeSession === "object") {
+    return activeSession;
+  }
+  return null;
+}
+function cadenceContextFromCurrent(current) {
+  const activeSession = activeSessionFromCurrent(current);
+  if (!activeSession) {
+    return;
+  }
+  const ticketId = typeof activeSession.ticketId === "string" ? activeSession.ticketId : undefined;
+  const sessionId = typeof activeSession.id === "string" ? activeSession.id : undefined;
+  const changesetId = typeof activeSession.changesetId === "string" ? activeSession.changesetId : undefined;
+  if (!ticketId && !sessionId && !changesetId) {
+    return;
+  }
   return {
-    ...sessionRecord,
-    ...sessionId ? { id: sessionId } : {},
-    ticketId: leaseRecord.ticketId,
-    ...typeof leaseRecord.changesetId === "string" ? { changesetId: leaseRecord.changesetId } : typeof sessionRecord.changesetId === "string" ? { changesetId: sessionRecord.changesetId } : {},
-    status: "active"
+    ...ticketId ? { ticketId } : {},
+    ...sessionId ? { sessionId } : {},
+    ...changesetId ? { changesetId } : {},
+    capturedAt: new Date().toISOString()
   };
 }
+async function readCurrentCadenceContext(client, projectId) {
+  const current = await client.sessions.current({
+    projectId,
+    filters: {
+      limit: 100
+    }
+  });
+  return cadenceContextFromCurrent(current);
+}
 function fingerprintForCheckpoint(event, options) {
   const status = gitOutput(["status", "--short"], options);
   const changedFiles = gitOutput(["diff", "--name-only", "origin/dev..."], options);
@@ -2958,6 +3555,7 @@ function fingerprintForCheckpoint(event, options) {
     source: event.source,
     event: event.event,
     lastAssistantMessage: event.lastAssistantMessage ?? "",
+    recentTurns: event.recentTurns ?? [],
     status,
     changedFiles
   }));
@@ -2972,60 +3570,548 @@ function shouldSkipForCooldown(state, cooldownSeconds) {
 function synthesizeAgentEventFromSession(agentSessionKeyValue, session, options) {
   return {
     source: session.source,
-    event: "closeout",
+    event: "checkpoint",
     workspacePath: options.cwd ?? process.cwd(),
     occurredAt: new Date().toISOString(),
     agentSessionKey: agentSessionKeyValue,
     ...session.lastAssistantMessage ? { lastAssistantMessage: session.lastAssistantMessage } : {},
+    ...session.recentTurns?.length ? { recentTurns: session.recentTurns } : {},
     payloadKeys: []
   };
 }
-function parseCheckpointJson(raw) {
-  const trimmed = raw.trim();
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (parsed && typeof parsed === "object") {
-      const record = parsed;
-      return {
-        body: typeof record.body === "string" && record.body.trim() ? record.body.trim() : trimmed,
-        summary: typeof record.summary === "string" && record.summary.trim() ? record.summary.trim() : undefined
-      };
-    }
-  } catch {
-    const start = trimmed.indexOf("{");
-    const end = trimmed.lastIndexOf("}");
-    if (start >= 0 && end > start) {
-      try {
-        const parsed = JSON.parse(trimmed.slice(start, end + 1));
-        if (parsed && typeof parsed === "object") {
-          const record = parsed;
-          return {
-            body: typeof record.body === "string" && record.body.trim() ? record.body.trim() : trimmed,
-            summary: typeof record.summary === "string" && record.summary.trim() ? record.summary.trim() : undefined
-          };
-        }
-      } catch {}
+var checkpointRouteActions = ["current", "noop", "intake_create", "intake_attach", "switch_existing", "needs_human"];
+var checkpointConfidenceLevels = ["low", "medium", "high"];
+var checkpointSessionActions = ["keep", "handoff", "end", "complete_ticket"];
+var highAutonomyRouteActions = new Set(["intake_create", "intake_attach", "switch_existing"]);
+var checkpointServerTextLimit = 1200;
+function checkpointEntrySummary(body) {
+  return truncateText(body.replace(/\s+/g, " ").trim(), 500);
+}
+function checkpointString(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
     }
   }
-  return {
-    body: trimmed,
-    summary: undefined
-  };
+  return;
 }
-function buildCheckpointPrompt(input) {
-  return [
-    "You are generating a concise Cadence checkpoint for an active coding session.",
-    "Do not include raw diffs, raw transcripts, terminal logs, tool streams, secrets, or model reasoning.",
-    'Return JSON only with this shape: {"summary":"one short current work summary","body":"checkpoint body suitable for a Cadence ticket work log"}.',
-    "The body should mention what changed, decisions made, verification if known, and the next risk or next step. Keep it under 1200 characters.",
-    "",
+function parseCheckpointParent(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return {};
+  }
+  try {
+    return parseWorkLogParent(value.trim());
+  } catch {
+    return {};
+  }
+}
+function parseCheckpointEntry(value, fallbackKind) {
+  if (typeof value === "string" && value.trim()) {
+    const body2 = value.trim();
+    return {
+      kind: fallbackKind,
+      body: body2,
+      summary: checkpointEntrySummary(body2)
+    };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  const body = checkpointString(record, ["body", "text", "content"]);
+  if (!body) {
+    return;
+  }
+  let kind = fallbackKind;
+  const rawKind = checkpointString(record, ["kind", "entryKind", "type"]);
+  if (rawKind && workLogEntryKinds.includes(rawKind)) {
+    kind = rawKind;
+  }
+  const parent = parseCheckpointParent(record.under ?? record.parent ?? record.parentSelector ?? record.parentEntryId);
+  const summary = checkpointString(record, ["summary", "title"]);
+  return {
+    kind,
+    body,
+    summary: summary ?? checkpointEntrySummary(body),
+    ...parent
+  };
+}
+function parseCheckpointSummaryUpdate(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  const update = record.update === true;
+  const summary = checkpointString(record, ["value", "summary", "currentSummary"]);
+  const reason = checkpointString(record, ["reason"]);
+  return {
+    update,
+    ...summary ? { value: summary } : {},
+    ...reason ? { reason } : {}
+  };
+}
+function parseCheckpointRecord(record, rawText, fallbackKind) {
+  const rawEntries = Array.isArray(record.entries) ? record.entries : [];
+  const entries = rawEntries.map((entry) => parseCheckpointEntry(entry, fallbackKind)).filter((entry) => Boolean(entry));
+  const legacyBody = checkpointString(record, ["body"]);
+  const summary = checkpointString(record, ["summary"]);
+  const parsedEntries = entries.length > 0 ? entries : legacyBody ? [parseCheckpointEntry({ kind: fallbackKind, body: legacyBody, summary }, fallbackKind)].filter((entry) => Boolean(entry)) : [];
+  const currentSummary = parseCheckpointSummaryUpdate(record.currentSummary);
+  return {
+    summary: summary ?? parsedEntries[0]?.summary ?? checkpointEntrySummary(rawText),
+    entries: parsedEntries,
+    ...currentSummary ? { currentSummary } : {}
+  };
+}
+function parseCheckpointJson(raw, fallbackKind) {
+  const trimmed = raw.trim();
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object") {
+      return parseCheckpointRecord(parsed, trimmed, fallbackKind);
+    }
+  } catch {
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      try {
+        const parsed = JSON.parse(trimmed.slice(start, end + 1));
+        if (parsed && typeof parsed === "object") {
+          return parseCheckpointRecord(parsed, trimmed, fallbackKind);
+        }
+      } catch {}
+    }
+  }
+  return {
+    summary: checkpointEntrySummary(trimmed),
+    entries: trimmed ? [
+      {
+        kind: fallbackKind,
+        body: trimmed,
+        summary: checkpointEntrySummary(trimmed)
+      }
+    ] : []
+  };
+}
+function checkpointValidationError(message, details) {
+  return new CliError("AGENT_RUN_CHECKPOINT_INVALID_PLAN", message, details);
+}
+function checkpointPlanString(record, key, limit = checkpointServerTextLimit) {
+  const value = record[key];
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return;
+  }
+  if (trimmed.length > limit) {
+    throw checkpointValidationError(`Checkpoint plan field "${key}" is too long.`, { key, limit });
+  }
+  return trimmed;
+}
+function parseCheckpointRoute(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw checkpointValidationError("Checkpoint plan requires route.");
+  }
+  const record = value;
+  const actionValue = checkpointPlanString(record, "action", 80);
+  const confidenceValue = checkpointPlanString(record, "confidence", 20) ?? "medium";
+  if (!actionValue || !checkpointRouteActions.includes(actionValue)) {
+    throw checkpointValidationError("Checkpoint plan route.action is invalid.", { action: actionValue });
+  }
+  if (!checkpointConfidenceLevels.includes(confidenceValue)) {
+    throw checkpointValidationError("Checkpoint plan route.confidence is invalid.", { confidence: confidenceValue });
+  }
+  const reason = checkpointPlanString(record, "reason");
+  const request = checkpointPlanString(record, "request");
+  const targetTicketId = checkpointPlanString(record, "targetTicketId", 100);
+  return {
+    action: actionValue,
+    confidence: confidenceValue,
+    ...reason ? { reason } : {},
+    ...request ? { request } : {},
+    ...targetTicketId ? { targetTicketId } : {}
+  };
+}
+function parseCheckpointPlanEntry(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw checkpointValidationError("Checkpoint plan entries must be objects.");
+  }
+  const record = value;
+  const rawKind = checkpointPlanString(record, "kind", 40) ?? checkpointPlanString(record, "entryKind", 40) ?? checkpointPlanString(record, "type", 40);
+  const body = checkpointPlanString(record, "body") ?? checkpointPlanString(record, "text") ?? checkpointPlanString(record, "content");
+  if (!rawKind || !workLogEntryKinds.includes(rawKind)) {
+    throw checkpointValidationError("Checkpoint plan entry kind is invalid.", { kind: rawKind });
+  }
+  if (!body) {
+    throw checkpointValidationError("Checkpoint plan entry body is required.");
+  }
+  const parent = parseCheckpointParent(record.under ?? record.parent ?? record.parentSelector ?? record.parentEntryId);
+  const summary = checkpointPlanString(record, "summary", 300) ?? checkpointPlanString(record, "title", 300);
+  return {
+    kind: rawKind,
+    body,
+    summary: summary ?? checkpointEntrySummary(body),
+    ...parent
+  };
+}
+function parseCheckpointPlanSummaryUpdate(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  const update = record.update === true;
+  const summary = checkpointPlanString(record, "value") ?? checkpointPlanString(record, "summary") ?? checkpointPlanString(record, "currentSummary");
+  const reason = checkpointPlanString(record, "reason");
+  return {
+    update,
+    ...summary ? { value: summary } : {},
+    ...reason ? { reason } : {}
+  };
+}
+function parseCheckpointPlanSession(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  const action = checkpointPlanString(record, "action", 40) ?? "keep";
+  if (!checkpointSessionActions.includes(action)) {
+    throw checkpointValidationError("Checkpoint plan session.action is invalid.", { action });
+  }
+  const summary = checkpointPlanString(record, "summary");
+  const reason = checkpointPlanString(record, "reason");
+  return {
+    action,
+    ...summary ? { summary } : {},
+    ...reason ? { reason } : {}
+  };
+}
+function parseCheckpointPlanFiles(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) {
+      throw checkpointValidationError("Checkpoint plan files must be objects.");
+    }
+    const record = item;
+    const path = checkpointPlanString(record, "path", 500);
+    if (!path || isAbsolute(path) || path.split("/").includes("..")) {
+      throw checkpointValidationError("Checkpoint plan file path must be a safe relative path.", { path });
+    }
+    return {
+      path,
+      kind: parseSessionFileChangeKind(checkpointPlanString(record, "kind", 40) ?? checkpointPlanString(record, "changeKind", 40))
+    };
+  });
+}
+function forceNeedsHuman(plan, reason) {
+  return {
+    ...plan,
+    route: {
+      ...plan.route,
+      action: "needs_human",
+      reason
+    },
+    validationWarnings: [...plan.validationWarnings, reason]
+  };
+}
+function normalizeCheckpointPlan(plan) {
+  if (plan.route.action === "noop") {
+    return {
+      ...plan,
+      entries: []
+    };
+  }
+  return plan;
+}
+function checkpointPlanWithRoute(plan, route, warning) {
+  return {
+    ...plan,
+    route,
+    ...route.action === "noop" ? { entries: [] } : {},
+    validationWarnings: warning ? [...plan.validationWarnings, warning] : plan.validationWarnings
+  };
+}
+function safeAutomaticRoutePlan(plan, hasCurrentContext, reason) {
+  return checkpointPlanWithRoute(plan, {
+    action: hasCurrentContext ? "current" : "noop",
+    confidence: plan.route.confidence,
+    reason
+  }, reason);
+}
+function routePlanAllowsLifecycle(plan) {
+  return checkpointRouteRequiresIntake(plan.route.action) && plan.route.confidence === "high";
+}
+function parseCheckpointPlanRecord(record, rawText, fallbackKind) {
+  if (!("route" in record)) {
+    const legacy = parseCheckpointRecord(record, rawText, fallbackKind);
+    const reason = legacy.currentSummary?.reason ?? legacy.summary;
+    const route2 = {
+      action: legacy.entries.length ? "current" : "noop",
+      confidence: "high",
+      ...reason ? { reason } : {}
+    };
+    return normalizeCheckpointPlan({
+      ...legacy.summary ? { summary: legacy.summary } : {},
+      route: route2,
+      entries: legacy.entries,
+      ...legacy.currentSummary ? { summaryUpdate: legacy.currentSummary } : {},
+      files: [],
+      legacy: true,
+      validationWarnings: []
+    });
+  }
+  const route = parseCheckpointRoute(record.route);
+  const entries = Array.isArray(record.entries) ? record.entries.map(parseCheckpointPlanEntry) : [];
+  const summary = checkpointPlanString(record, "summary");
+  const summaryUpdate = parseCheckpointPlanSummaryUpdate(record.summaryUpdate ?? record.currentSummary);
+  const session = parseCheckpointPlanSession(record.session);
+  return normalizeCheckpointPlan({
+    ...summary ? { summary } : {},
+    route,
+    entries,
+    ...summaryUpdate ? { summaryUpdate } : {},
+    ...session ? { session } : {},
+    files: parseCheckpointPlanFiles(record.files),
+    legacy: false,
+    validationWarnings: []
+  });
+}
+function parseCheckpointPlanJson(raw, fallbackKind) {
+  const trimmed = raw.trim();
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parseCheckpointPlanRecord(parsed, trimmed, fallbackKind);
+    }
+  } catch (error) {
+    if (error instanceof CliError) {
+      throw error;
+    }
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      try {
+        const parsed = JSON.parse(trimmed.slice(start, end + 1));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          return parseCheckpointPlanRecord(parsed, trimmed, fallbackKind);
+        }
+      } catch (innerError) {
+        if (innerError instanceof CliError) {
+          throw innerError;
+        }
+      }
+    }
+  }
+  const legacy = parseCheckpointJson(trimmed, fallbackKind);
+  const reason = legacy.currentSummary?.reason ?? legacy.summary;
+  return normalizeCheckpointPlan({
+    ...legacy.summary ? { summary: legacy.summary } : {},
+    route: {
+      action: legacy.entries.length ? "current" : "noop",
+      confidence: "high",
+      ...reason ? { reason } : {}
+    },
+    entries: legacy.entries,
+    ...legacy.currentSummary ? { summaryUpdate: legacy.currentSummary } : {},
+    files: [],
+    legacy: true,
+    validationWarnings: []
+  });
+}
+function checkpointRouteRequiresIntake(action) {
+  return action === "intake_create" || action === "intake_attach" || action === "switch_existing";
+}
+function checkpointPlanCompletionAllowed(event, summary) {
+  const text = [
+    summary,
+    event.lastAssistantMessage ?? "",
+    ...(event.recentTurns ?? []).flatMap((turn) => [turn.user ?? "", turn.assistant ?? ""])
+  ].join(`
+`).toLowerCase();
+  return /\b(done|complete|completed|finish|finished|close|closed|ship|shipped|push|pushed|pr|pull request|merged|clean branch|verified)\b/.test(text);
+}
+function checkpointPlanTitle(plan) {
+  const intent = plan.entries.find((entry) => entry.kind === "intent");
+  return truncateText(intent?.summary ?? plan.summary ?? plan.route.request ?? "Checkpoint routed work", 120);
+}
+function checkpointPlanDescription(plan) {
+  return truncateText(plan.route.request ?? plan.summary ?? plan.route.reason ?? checkpointPlanTitle(plan), 1000);
+}
+function checkpointHasConflictingIntakeResult(intake, plan) {
+  if (!intake || typeof intake !== "object" || Array.isArray(intake)) {
+    return false;
+  }
+  const record = intake;
+  const classification = typeof record.classification === "string" ? record.classification : undefined;
+  const candidates = Array.isArray(record.candidates) ? record.candidates.filter((candidate) => candidate && typeof candidate === "object") : [];
+  if (plan.route.action === "intake_create" && classification && classification !== "new") {
+    return true;
+  }
+  if ((plan.route.action === "intake_attach" || plan.route.action === "switch_existing") && plan.route.targetTicketId && candidates.length > 0) {
+    return !candidates.some((candidate) => {
+      const candidateRecord = candidate;
+      return candidateRecord.id === plan.route.targetTicketId || candidateRecord.ticketId === plan.route.targetTicketId;
+    });
+  }
+  return false;
+}
+function checkpointPlanNeedsHuman(plan, reason) {
+  return forceNeedsHuman(plan, reason);
+}
+function checkpointLifecycleOperation(type, success, details = {}) {
+  return {
+    type,
+    success,
+    ...details
+  };
+}
+function checkpointRecentTurns(event) {
+  return event.recentTurns?.length ? event.recentTurns.slice(-3) : [];
+}
+function formatCheckpointRecentTurns(turns) {
+  return turns.map((turn, index) => [
+    `Turn ${index + 1}${turn.occurredAt ? ` (${turn.occurredAt})` : ""}:`,
+    turn.user ? `User:
+${truncateText(turn.user, 3000)}` : "User: unavailable",
+    turn.assistant ? `Assistant:
+${truncateText(turn.assistant, 3000)}` : "Assistant: unavailable"
+  ].join(`
+`)).join(`
+
+`);
+}
+function checkpointCapturedContextTokenCounts(event) {
+  const turns = checkpointRecentTurns(event);
+  if (!turns.length) {
+    const fallbackText = event.lastAssistantMessage ? truncateText(event.lastAssistantMessage, 3000) : "";
+    const fallbackTokens = fallbackText ? estimateTokenCount(fallbackText) : 0;
+    return {
+      mode: fallbackText ? "last_assistant_message" : "unavailable",
+      turnCount: 0,
+      userPromptTokens: 0,
+      assistantResponseTokens: fallbackTokens,
+      totalTokens: fallbackTokens
+    };
+  }
+  const userPromptTokens = turns.reduce((total, turn) => total + (turn.user ? estimateTokenCount(truncateText(turn.user, 3000)) : 0), 0);
+  const assistantResponseTokens = turns.reduce((total, turn) => total + (turn.assistant ? estimateTokenCount(truncateText(turn.assistant, 3000)) : 0), 0);
+  return {
+    mode: "recent_turns",
+    turnCount: turns.length,
+    userPromptTokens,
+    assistantResponseTokens,
+    totalTokens: estimateTokenCount(formatCheckpointRecentTurns(turns))
+  };
+}
+function buildCheckpointTokenAccounting(event, prompt, tokenUsage) {
+  const capturedContext = checkpointCapturedContextTokenCounts(event);
+  const explicitCheckpointPromptTokens = estimateTokenCount(prompt);
+  const explicitCadenceOverheadTokens = Math.max(0, explicitCheckpointPromptTokens - capturedContext.totalTokens);
+  const reported = tokenUsageTotal(tokenUsage);
+  const reportedInputTokens = reported?.inputTokens;
+  const reportedCadenceOverheadTokens = typeof reportedInputTokens === "number" ? Math.max(0, reportedInputTokens - capturedContext.totalTokens) : undefined;
+  return {
+    source: "codex_token_count_plus_local_estimates",
+    estimator: "cadence-simple-estimate-v1",
+    capturedContext,
+    explicitCheckpointPromptTokens,
+    explicitCadenceOverheadTokens,
+    explicitCadenceOverheadRatio: roundedRatio(explicitCadenceOverheadTokens, Math.max(1, capturedContext.totalTokens)),
+    ...reported ? {
+      reported: {
+        ...reported.inputTokens !== undefined ? { inputTokens: reported.inputTokens } : {},
+        ...reported.cachedInputTokens !== undefined ? { cachedInputTokens: reported.cachedInputTokens } : {},
+        ...reported.outputTokens !== undefined ? { outputTokens: reported.outputTokens } : {},
+        ...reported.reasoningOutputTokens !== undefined ? { reasoningOutputTokens: reported.reasoningOutputTokens } : {},
+        ...reported.totalTokens !== undefined ? { totalTokens: reported.totalTokens } : {},
+        ...tokenUsage?.modelContextWindow !== undefined ? { modelContextWindow: tokenUsage.modelContextWindow } : {}
+      }
+    } : {},
+    ...reportedCadenceOverheadTokens !== undefined ? {
+      reportedCadenceOverheadTokens,
+      reportedCadenceOverheadRatio: roundedRatio(reportedCadenceOverheadTokens, Math.max(1, capturedContext.totalTokens))
+    } : {}
+  };
+}
+function buildCheckpointPrompt(input) {
+  const recentTurns = checkpointRecentTurns(input.event);
+  const recentTurnsText = recentTurns.length ? formatCheckpointRecentTurns(recentTurns) : "";
+  const modeInstructions = input.mode === "closeout" ? [
+    "Mode: closeout. Produce final session memory, not an interim pulse.",
+    "Closeout should cover the completed work segment: outcome, reviewable implementation actions, decisions/corrections, verification, blockers/follow-ups, scope or attribution notes, and handoff when needed.",
+    "Write the minimum entries needed for coverage. Target 2-6 entries; avoid more than 8 by merging related facts or writing one concise session catch-up entry.",
+    "Use session.action handoff, end, or keep when appropriate. Use complete_ticket only when explicit completion evidence is present."
+  ] : [
+    "Mode: checkpoint. Produce sparse incremental memory for an active session, not a full-session closeout.",
+    "Checkpoint should commonly return route.action noop with entries [] when there is nothing durable to record.",
+    "Target 0-2 entries. Only exceed that for a blocker or failed verification. Do not repeat unchanged intent, repeated dirty workspace warnings, or routine process actions."
+  ];
+  return [
+    `You are generating a compact Cadence dogfood operation plan for an agent-run ${input.mode} worker.`,
+    "The model judges; the Cadence CLI validates and executes. Return JSON only. Do not call tools to mutate Cadence yourself.",
+    "Preserve durable ticket purpose. Identify user intent, changed intent, corrections, decisions, rationale, implementation actions, verification, blockers, and useful notes.",
+    "Do not include raw diffs, raw transcripts, terminal logs, tool streams, secrets, file contents, or model reasoning in server-bound fields.",
+    'Return this sparse JSON shape: {"summary":"short checkpoint summary","route":{"action":"current|noop|intake_create|intake_attach|switch_existing","confidence":"low|medium|high","reason":"short reason","request":"natural language work request when intake is needed","targetTicketId":"optional existing ticket id"},"entries":[{"kind":"intent|decision|rationale|action|verification|blocker|correction|note","summary":"short entry summary","body":"safe Cadence work-log body","under":"optional: last, ticket-last, session-last, last-decision, last-correction, last-action, or entry UUID"}],"summaryUpdate":{"update":false,"value":null,"reason":"short reason"},"session":{"action":"keep|handoff|end|complete_ticket","summary":"optional handoff or completion summary","reason":"short reason"},"files":[{"path":"relative/path.ts","kind":"added|modified|deleted|renamed|unknown"}]}',
+    "Keep output sparse: omit summaryUpdate, session, and files unless needed. Use route.action noop with entries [] for filler, acknowledgements, or other turns with nothing durable to record.",
+    "Use route.action current for the same ticket. Use noop when routing is ambiguous or there is nothing durable to record. Use intake_create, intake_attach, or switch_existing only when recent work clearly belongs somewhere else; the CLI will delegate those actions to agent-run route.",
+    "Set route.confidence high only when the recent user/assistant context makes the route and lifecycle action clear. Lifecycle mutations require high confidence.",
+    "Use note only as a last-resort context kind. Prefer intent, decision, rationale, action, verification, correction, or blocker when those fit.",
+    "Each entry body should be concise narrative, not a transcript. Keep each entry under 800 characters and avoid duplicating the same fact across entries.",
+    "Set summaryUpdate.update true only when the durable current work summary is missing or misleading; otherwise omit summaryUpdate or leave update false.",
+    "Use session.action complete_ticket only when the context indicates completion, merge, push/PR finalization, or explicit user completion intent. Use handoff/end only when the current session should close.",
+    ...modeInstructions,
+    "",
     `Ticket: ${input.ticketId}`,
     input.sessionId ? `Session: ${input.sessionId}` : "",
     input.changesetId ? `ChangeSet: ${input.changesetId}` : "",
+    input.currentWorkSummary ? `Current Work Summary:
+${truncateText(input.currentWorkSummary, 1200)}` : "",
+    input.recentWorkLog ? `Recent high-signal Work Log entries:
+${truncateText(input.recentWorkLog, 3000)}` : "",
+    input.coverage ? `Prior coverage: ${JSON.stringify(input.coverage)}` : "",
+    `Agent event: ${input.event.source}/${input.event.event}`,
+    input.previousCheckpointSummary ? `Previous checkpoint summary: ${input.previousCheckpointSummary}` : "",
+    recentTurnsText ? `Recent user/assistant turns (most recent 3, local checkpoint context only):
+${recentTurnsText}` : input.event.lastAssistantMessage ? `Last assistant message:
+${truncateText(input.event.lastAssistantMessage, 3000)}` : "Recent turns: unavailable",
+    input.gitStatus ? `Git status --short:
+${truncateText(input.gitStatus, 2000)}` : "Git status --short: clean or unavailable",
+    input.gitDiffStat ? `Git diff --stat origin/dev...:
+${truncateText(input.gitDiffStat, 2000)}` : "Git diff stat: unavailable",
+    input.changedFiles ? `Changed files:
+${truncateText(input.changedFiles, 2000)}` : "Changed files: unavailable"
+  ].filter(Boolean).join(`
+`);
+}
+function buildRoutePrompt(input) {
+  const recentTurns = checkpointRecentTurns(input.event);
+  const recentTurnsText = recentTurns.length ? formatCheckpointRecentTurns(recentTurns) : "";
+  const contextText = input.savedContext?.ticketId ? `Saved Cadence context: ticket ${input.savedContext.ticketId}${input.savedContext.sessionId ? `, session ${input.savedContext.sessionId}` : ""}${input.savedContext.changesetId ? `, ChangeSet ${input.savedContext.changesetId}` : ""}` : input.currentContext?.ticketId ? `No saved agent-session context. Current active Cadence context: ticket ${input.currentContext.ticketId}${input.currentContext.sessionId ? `, session ${input.currentContext.sessionId}` : ""}${input.currentContext.changesetId ? `, ChangeSet ${input.currentContext.changesetId}` : ""}` : "No saved agent-session context and no active Cadence context was found.";
+  return [
+    "You are generating a compact Cadence dogfood routing plan for an agent-run worker.",
+    "The model judges; the Cadence CLI validates and executes. Return JSON only. Do not call tools to mutate Cadence yourself.",
+    "Decide where this agent session belongs before checkpoint memory is written.",
+    "Do not include raw diffs, raw transcripts, terminal logs, tool streams, secrets, file contents, or model reasoning in server-bound fields.",
+    'Return this sparse JSON shape: {"summary":"short routing summary","route":{"action":"current|noop|intake_create|intake_attach|switch_existing","confidence":"low|medium|high","reason":"short reason","request":"natural language intake request when intake is needed","targetTicketId":"optional existing ticket id"},"entries":[{"kind":"intent|decision|rationale|action|verification|blocker|correction|note","summary":"short entry summary","body":"safe Cadence work-log body"}],"files":[{"path":"relative/path.ts","kind":"added|modified|deleted|renamed|unknown"}]}',
+    "Use noop for filler, acknowledgements, setup chatter, or anything not durable enough for Cadence.",
+    "Use current only when an existing Cadence context clearly fits the recent work.",
+    "Use intake_create for a clearly durable new task without a good existing ticket.",
+    "Use intake_attach or switch_existing only when a specific targetTicketId is clearly the correct ticket.",
+    "Set confidence high only when the route is clear. Low or medium confidence lifecycle actions will be ignored by the CLI.",
+    "Use note only as a last-resort context kind. Prefer intent for new routed work.",
+    "Each entry body should be concise narrative, not a transcript. Keep each entry under 800 characters.",
+    "",
+    `Route reason: ${input.reason ?? "manual"}`,
+    contextText,
     `Agent event: ${input.event.source}/${input.event.event}`,
     input.previousCheckpointSummary ? `Previous checkpoint summary: ${input.previousCheckpointSummary}` : "",
-    input.event.lastAssistantMessage ? `Last assistant message:
-${truncateText(input.event.lastAssistantMessage, 3000)}` : "Last assistant message: unavailable",
+    recentTurnsText ? `Recent user/assistant turns (most recent 3, local routing context only):
+${recentTurnsText}` : input.event.lastAssistantMessage ? `Last assistant message:
+${truncateText(input.event.lastAssistantMessage, 3000)}` : "Recent turns: unavailable",
     input.gitStatus ? `Git status --short:
 ${truncateText(input.gitStatus, 2000)}` : "Git status --short: clean or unavailable",
     input.gitDiffStat ? `Git diff --stat origin/dev...:
@@ -3035,6 +4121,263 @@ ${truncateText(input.changedFiles, 2000)}` : "Changed files: unavailable"
   ].filter(Boolean).join(`
 `);
 }
+function agentRunFingerprint(value) {
+  return stableHash(JSON.stringify(value));
+}
+function buildAgentRunFingerprints(input) {
+  return {
+    event: agentRunFingerprint({
+      source: input.event.source,
+      event: input.event.event,
+      agentSessionKey: input.event.agentSessionKey,
+      agentSessionId: input.event.agentSessionId,
+      threadId: input.event.threadId,
+      turnId: input.event.turnId,
+      lastAssistantMessage: input.event.lastAssistantMessage,
+      recentTurns: input.event.recentTurns,
+      payloadKeys: input.event.payloadKeys
+    }),
+    git: agentRunFingerprint({
+      status: input.gitStatus,
+      diffStat: input.gitDiffStat,
+      changedFiles: input.changedFiles
+    }),
+    cadenceContext: agentRunFingerprint({
+      ticketId: input.ticketId,
+      sessionId: input.sessionId,
+      changesetId: input.changesetId
+    }),
+    ...input.coverage?.hasDebt ? { coverageDebt: agentRunFingerprint(input.coverage) } : {}
+  };
+}
+function fingerprintsEqual(left, right) {
+  return Boolean(left && left.event === right.event && left.git === right.git && left.cadenceContext === right.cadenceContext && left.verification === right.verification && left.coverageDebt === right.coverageDebt);
+}
+function checkpointReasonBypassesFingerprintGate(reason) {
+  return reason === "manual" || reason === "idle" || reason === "ticket_switch" || reason === "closeout";
+}
+function entryText(entry) {
+  return `${entry.summary ?? ""}
+${entry.body}`.toLowerCase();
+}
+function entryReductionSummary(entry) {
+  return truncateText(entry.summary ?? checkpointEntrySummary(entry.body), 120);
+}
+function isRepeatedScopeNote(entry) {
+  const text = entryText(entry);
+  return entry.kind === "note" && (text.includes("dirty workspace") || text.includes("dirty files") || text.includes("unattributed"));
+}
+function isRepeatedNoVerificationNote(entry) {
+  const text = entryText(entry);
+  return entry.kind === "verification" && text.includes("no fresh") && (text.includes("test") || text.includes("verification"));
+}
+function isUnchangedIntent(entry) {
+  const text = entryText(entry);
+  return entry.kind === "intent" && (text.includes("remain") || text.includes("still")) && text.includes("active");
+}
+function isProcessOnlyAction(entry) {
+  if (entry.kind !== "action") {
+    return false;
+  }
+  const text = entryText(entry);
+  const processSignals = ["read ", "inspected", "looked at", "ran git status", "gathered context", "paused", "discussed", "answered"];
+  const reviewableSignals = [
+    "added",
+    "implemented",
+    "updated",
+    "changed",
+    "removed",
+    "refactored",
+    "fixed",
+    "moved",
+    "persisted",
+    "configured",
+    "wrote",
+    "split"
+  ];
+  return processSignals.some((signal) => text.includes(signal)) && !reviewableSignals.some((signal) => text.includes(signal));
+}
+function entryDedupeKey(entry) {
+  if (isRepeatedScopeNote(entry)) {
+    return "scope-note";
+  }
+  if (isRepeatedNoVerificationNote(entry)) {
+    return "no-verification";
+  }
+  if (isUnchangedIntent(entry)) {
+    return "unchanged-intent";
+  }
+  return `${entry.kind}:${entry.summary ?? checkpointEntrySummary(entry.body)}`.toLowerCase();
+}
+function mergeDecisionRationaleEntries(entries) {
+  const merged = [];
+  const records = [];
+  for (let index = 0;index < entries.length; index += 1) {
+    const entry = entries[index];
+    const next = entries[index + 1];
+    if (entry.kind === "decision" && next?.kind === "rationale") {
+      merged.push({
+        ...entry,
+        body: truncateText(`${entry.body}
+
+Rationale: ${next.body.replace(/^Rationale:\s*/i, "")}`, checkpointServerTextLimit)
+      });
+      records.push({
+        summary: entryReductionSummary(next),
+        reason: "merged_adjacent_decision_rationale"
+      });
+      index += 1;
+      continue;
+    }
+    merged.push(entry);
+  }
+  return { entries: merged, records };
+}
+function checkpointAllowsExtraEntries(entries) {
+  return entries.some((entry) => entry.kind === "blocker" || entry.kind === "verification" && /\b(fail|failed|failing|error|blocked)\b/i.test(entry.body));
+}
+function reduceCheckpointEntries(entries, mode) {
+  const dropped = [];
+  const seen = new Set;
+  const filtered = [];
+  for (const entry of entries) {
+    if (isProcessOnlyAction(entry)) {
+      dropped.push({ summary: entryReductionSummary(entry), reason: "process_only_action" });
+      continue;
+    }
+    const dedupeKey = entryDedupeKey(entry);
+    if (seen.has(dedupeKey)) {
+      dropped.push({ summary: entryReductionSummary(entry), reason: "duplicate_entry" });
+      continue;
+    }
+    seen.add(dedupeKey);
+    filtered.push(entry);
+  }
+  const merged = mergeDecisionRationaleEntries(filtered);
+  const maxEntries = mode === "closeout" ? 8 : checkpointAllowsExtraEntries(merged.entries) ? 4 : 3;
+  const capped = merged.entries.length > maxEntries;
+  const kept = capped ? merged.entries.slice(0, maxEntries) : merged.entries;
+  for (const entry of merged.entries.slice(maxEntries)) {
+    dropped.push({ summary: entryReductionSummary(entry), reason: "entry_budget" });
+  }
+  return {
+    entries: kept,
+    reduction: {
+      mode,
+      originalCount: entries.length,
+      keptCount: kept.length,
+      dropped,
+      merged: merged.records,
+      capped
+    }
+  };
+}
+function buildAgentRunCoverage(plan, mode) {
+  const entries = plan.entries;
+  const bodyText = [plan.summary ?? "", plan.session?.summary ?? "", ...entries.map((entry) => `${entry.summary ?? ""} ${entry.body}`)].join(`
+`).toLowerCase();
+  const outcome = Boolean(plan.summary || plan.session?.summary);
+  const implementation = entries.some((entry) => entry.kind === "action");
+  const decisions = entries.some((entry) => entry.kind === "decision" || entry.kind === "rationale");
+  const corrections = entries.some((entry) => entry.kind === "correction");
+  const verification = entries.some((entry) => entry.kind === "verification");
+  const blockers = entries.some((entry) => entry.kind === "blocker");
+  const scope = /\b(scope|attribut|dirty workspace|dirty files|unassigned|unattributed)\b/.test(bodyText);
+  const handoff = mode === "closeout" && Boolean(plan.session && plan.session.action !== "keep");
+  const hasDebt = mode === "closeout" && (!outcome || !implementation || !verification || !handoff);
+  return {
+    outcome,
+    implementation,
+    decisions,
+    corrections,
+    verification,
+    blockers,
+    scope,
+    handoff,
+    hasDebt
+  };
+}
+function applyCloseoutSessionDefaults(plan, sessionAction, completeTicket) {
+  const requestedAction = completeTicket ? "complete_ticket" : sessionAction;
+  const session = plan.session && (completeTicket || plan.session.action !== "complete_ticket") ? plan.session : {
+    action: requestedAction,
+    ...plan.summary ? { summary: plan.summary } : {},
+    reason: "Closeout defaults to ending or handing off the active session."
+  };
+  if (!completeTicket && session.action === "complete_ticket") {
+    return {
+      ...plan,
+      session: {
+        ...session,
+        action: sessionAction,
+        reason: "Ticket completion was not requested for this closeout."
+      }
+    };
+  }
+  return {
+    ...plan,
+    session
+  };
+}
+function parseCloseoutSessionAction(value) {
+  if (!value) {
+    return "handoff";
+  }
+  if (!closeoutSessionActions.includes(value)) {
+    throw new CliError("CLI_USAGE", "--session-action must be one of handoff, end, or keep.");
+  }
+  return value;
+}
+function checkpointModeForCommand(parsed) {
+  return parsed.command.name === "agent-run.closeout" ? "closeout" : "checkpoint";
+}
+function formatCloseoutWorkLogEvents(events) {
+  if (!Array.isArray(events)) {
+    return;
+  }
+  const entries = events.filter((event) => event && typeof event === "object").map((event) => {
+    const record = event;
+    const payload = record.payload && typeof record.payload === "object" && !Array.isArray(record.payload) ? record.payload : {};
+    const type = typeof record.type === "string" ? record.type : undefined;
+    const kind = typeof payload.entryKind === "string" ? payload.entryKind : undefined;
+    const summary = typeof payload.summary === "string" ? payload.summary : undefined;
+    const body = typeof payload.body === "string" ? payload.body : undefined;
+    if (type !== "ticket.work_log_appended" || !summary && !body) {
+      return;
+    }
+    return `- ${kind ?? "note"}: ${truncateText(summary ?? body ?? "", 180)}${body && summary ? ` \u2014 ${truncateText(body, 300)}` : ""}`;
+  }).filter((entry) => Boolean(entry)).slice(-12);
+  return entries.length ? entries.join(`
+`) : undefined;
+}
+async function readCloseoutPromptContext(input) {
+  let currentWorkSummary;
+  let recentWorkLog;
+  try {
+    const ticket = await input.client.tickets.get({
+      projectId: input.projectId,
+      ticketId: input.ticketId
+    });
+    if (ticket && typeof ticket === "object" && "currentSummary" in ticket && typeof ticket.currentSummary === "string") {
+      currentWorkSummary = ticket.currentSummary;
+    }
+  } catch {}
+  try {
+    const events = await input.client.events.list({
+      projectId: input.projectId,
+      filters: {
+        ticketId: input.ticketId,
+        ...input.sessionId ? { sessionId: input.sessionId } : {},
+        limit: 50
+      }
+    });
+    recentWorkLog = formatCloseoutWorkLogEvents(events);
+  } catch {}
+  return {
+    ...currentWorkSummary ? { currentWorkSummary } : {},
+    ...recentWorkLog ? { recentWorkLog } : {}
+  };
+}
 async function findRepoRoot(cwd) {
   const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
     cwd,
@@ -3058,6 +4401,22 @@ function codexHookEntry(command) {
     ]
   };
 }
+function codexHookCommands(entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    return [];
+  }
+  const record = entry;
+  const directCommand = typeof record.command === "string" ? [record.command] : [];
+  const handlers = Array.isArray(record.hooks) ? record.hooks : [];
+  const handlerCommands = handlers.flatMap((handler) => {
+    if (!handler || typeof handler !== "object" || Array.isArray(handler)) {
+      return [];
+    }
+    const command = handler.command;
+    return typeof command === "string" ? [command] : [];
+  });
+  return [...directCommand, ...handlerCommands];
+}
 async function readJsonObjectFile(filePath) {
   const file = Bun.file(filePath);
   if (!await file.exists()) {
@@ -3071,8 +4430,9 @@ async function installCodexHookFile(filePath, command) {
   const hooks = hooksValue && typeof hooksValue === "object" && !Array.isArray(hooksValue) ? hooksValue : {};
   const stopValue = hooks.Stop;
   const stopHooks = Array.isArray(stopValue) ? stopValue : [];
-  const alreadyInstalled = stopHooks.some((entry) => JSON.stringify(entry).includes(command));
-  const nextStopHooks = alreadyInstalled ? stopHooks : [...stopHooks, codexHookEntry(command)];
+  const alreadyInstalled = stopHooks.some((entry) => codexHookCommands(entry).includes(command));
+  const cadenceHookIndexes = stopHooks.map((entry, index) => codexHookCommands(entry).some((entryCommand) => entryCommand.includes("agent-run ingest-stop --source codex --event stop")) ? index : -1).filter((index) => index >= 0);
+  const nextStopHooks = alreadyInstalled ? stopHooks : cadenceHookIndexes.length ? stopHooks.map((entry, index) => index === cadenceHookIndexes[0] ? codexHookEntry(command) : entry).filter((_, index) => !cadenceHookIndexes.slice(1).includes(index)) : [...stopHooks, codexHookEntry(command)];
   const nextConfig = {
     ...existing,
     hooks: {
@@ -3086,7 +4446,8 @@ async function installCodexHookFile(filePath, command) {
   return {
     path: filePath,
     installed: !alreadyInstalled,
-    alreadyInstalled
+    alreadyInstalled,
+    updated: !alreadyInstalled && cadenceHookIndexes.length > 0
   };
 }
 async function codexHookPaths(scope, options) {
@@ -3108,7 +4469,7 @@ async function codexHookInstalled(filePath, command) {
   const existing = await readJsonObjectFile(filePath);
   const hooks = existing.hooks;
   const stopHooks = hooks && typeof hooks === "object" && !Array.isArray(hooks) && Array.isArray(hooks.Stop) ? hooks.Stop : [];
-  return stopHooks.some((entry) => JSON.stringify(entry).includes(command));
+  return stopHooks.some((entry) => codexHookCommands(entry).includes(command));
 }
 async function runStatus(parsed, options) {
   const config = await resolveCliConfig(parsed.flags, options);
@@ -3255,14 +4616,19 @@ async function runAgentRunCommand(parsed, options) {
   switch (parsed.command.name) {
     case "agent-run.ingest-stop":
       return await runAgentRunIngestStop(parsed, options, config, meta);
+    case "agent-run.route":
+      return await runAgentRunRoute(parsed, options, config, meta);
+    case "agent-run.checkpoint":
     case "agent-run.closeout":
-      return await runAgentRunCloseout(parsed, options, config, meta);
+      return await runAgentRunCheckpoint(parsed, options, config, meta);
     case "agent-run.sweep":
-      return await runAgentRunSweep(parsed, options, meta);
+      return await runAgentRunSweep(parsed, options, config, meta);
     case "agent-run.doctor": {
       const state = await readAgentLoopState(parsed, options);
+      const settings = await readAgentLoopSettings(parsed, options);
       const data = {
         action: "doctor",
+        settings,
         state,
         sessionCount: Object.keys(state.sessions).length,
         pendingSessions: Object.entries(state.sessions).filter(([, session]) => session.stopCount > 0).map(([agentSessionKeyValue, session]) => ({
@@ -3337,8 +4703,18 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
   const dryRun = parseBooleanOption(parsed.options["dry-run"], false);
   const existingSession = state.sessions[normalized.agentSessionKey];
   const now = new Date().toISOString();
-  const threshold = forcedThreshold ?? existingSession?.threshold ?? randomCheckpointThreshold();
-  const nextCount = (existingSession?.stopCount ?? 0) + 1;
+  const threshold = forcedThreshold ?? existingSession?.threshold ?? defaultCheckpointThresholdValue();
+  const duplicateTurn = Boolean(normalized.turnId && existingSession?.lastObservedTurnId === normalized.turnId);
+  const nextCount = (existingSession?.stopCount ?? 0) + (duplicateTurn ? 0 : 1);
+  const recentTurns = mergeRecentAgentTurns(existingSession?.recentTurns, normalized.recentTurns);
+  const savedCadenceContext = existingSession?.cadenceContext;
+  let cadenceContext = savedCadenceContext;
+  if (savedCadenceContext?.ticketId) {
+    try {
+      const client = await createClient(config, options);
+      cadenceContext = await readCurrentCadenceContext(client, projectId) ?? cadenceContext;
+    } catch {}
+  }
   const observedSession = {
     ...clearAgentSessionReason(existingSession ?? {
       source: normalized.source,
@@ -3350,8 +4726,11 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
     threshold,
     firstObservedAt: existingSession?.firstObservedAt ?? now,
     lastObservedAt: now,
+    ...normalized.turnId ? { lastObservedTurnId: normalized.turnId } : {},
     lastAction: "counted",
-    ...normalized.lastAssistantMessage ? { lastAssistantMessage: normalized.lastAssistantMessage } : {}
+    ...cadenceContext ? { cadenceContext } : {},
+    ...normalized.lastAssistantMessage ? { lastAssistantMessage: normalized.lastAssistantMessage } : {},
+    ...recentTurns ? { recentTurns } : {}
   };
   const countedState = {
     ...state,
@@ -3360,10 +4739,11 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
       [normalized.agentSessionKey]: observedSession
     }
   };
-  if (nextCount < threshold) {
+  if (duplicateTurn) {
     await writeAgentLoopState(parsed, options, countedState);
     const data2 = {
-      action: "counted",
+      action: "updated",
+      reason: "duplicate_turn",
       agentSessionKey: normalized.agentSessionKey,
       stopCount: nextCount,
       threshold
@@ -3375,10 +4755,128 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
       exitCode: 0
     };
   }
-  if (shouldSkipForCooldown(observedSession, cooldownSeconds)) {
-    await writeAgentLoopState(parsed, options, {
-      ...state,
-      sessions: {
+  if (!savedCadenceContext?.ticketId) {
+    const eventFile2 = await writeAgentEventFile(parsed, options, normalized);
+    const lockPath2 = agentLoopLockPath(parsed, options, normalized.agentSessionKey);
+    const workerArgs2 = [
+      "agent-run",
+      "route",
+      "--agent-session-key",
+      normalized.agentSessionKey,
+      "--reason",
+      "missing_context",
+      "--event-file",
+      eventFile2,
+      "--lock",
+      lockPath2,
+      ...parsed.flags.project ? ["--project", parsed.flags.project] : [],
+      ...parsed.flags.server ? ["--server", parsed.flags.server] : []
+    ];
+    if (dryRun) {
+      await writeAgentLoopState(parsed, options, {
+        ...state,
+        sessions: {
+          ...state.sessions,
+          [normalized.agentSessionKey]: {
+            ...observedSession,
+            lastAction: "would_route",
+            lastEventFile: eventFile2
+          }
+        }
+      });
+      const data3 = {
+        action: "would_route",
+        agentSessionKey: normalized.agentSessionKey,
+        eventFile: eventFile2,
+        workerArgs: workerArgs2
+      };
+      return {
+        stdout: parsed.flags.json ? formatJson(successEnvelope(data3, meta)) : `${JSON.stringify(data3, null, 2)}
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    const lock2 = await acquireAgentLoopLock(parsed, options, normalized.agentSessionKey);
+    if (!lock2.acquired) {
+      await writeAgentLoopState(parsed, options, {
+        ...state,
+        sessions: {
+          ...state.sessions,
+          [normalized.agentSessionKey]: {
+            ...observedSession,
+            lastAction: "skipped",
+            lastReason: "lock_held"
+          }
+        }
+      });
+      const data3 = {
+        action: "skipped",
+        reason: "lock_held",
+        lockPath: lock2.lockPath,
+        agentSessionKey: normalized.agentSessionKey
+      };
+      return {
+        stdout: parsed.flags.json ? formatJson(successEnvelope(data3, meta)) : `${JSON.stringify(data3, null, 2)}
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    try {
+      await spawnAgentRunWorker(workerArgs2, options);
+    } catch (error) {
+      await releaseAgentLoopLock(lock2.lockPath);
+      throw error;
+    }
+    await writeAgentLoopState(parsed, options, {
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [normalized.agentSessionKey]: {
+          ...observedSession,
+          stopCount: 0,
+          threshold: defaultCheckpointThresholdValue(),
+          lastAction: "route_spawned",
+          lastEventFile: eventFile2,
+          lastCheckpointAt: new Date().toISOString(),
+          lastCheckpointFingerprint: fingerprintForCheckpoint(normalized, options)
+        }
+      }
+    });
+    const data2 = {
+      action: "route_spawned",
+      agentSessionKey: normalized.agentSessionKey,
+      eventFile: eventFile2,
+      lockPath: lock2.lockPath
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  if (nextCount < threshold) {
+    await writeAgentLoopState(parsed, options, countedState);
+    const data2 = {
+      action: duplicateTurn ? "updated" : "counted",
+      ...duplicateTurn ? { reason: "duplicate_turn" } : {},
+      agentSessionKey: normalized.agentSessionKey,
+      stopCount: nextCount,
+      threshold
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  if (shouldSkipForCooldown(observedSession, cooldownSeconds)) {
+    await writeAgentLoopState(parsed, options, {
+      ...state,
+      sessions: {
         ...state.sessions,
         [normalized.agentSessionKey]: {
           ...observedSession,
@@ -3410,7 +4908,7 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
         [normalized.agentSessionKey]: {
           ...observedSession,
           stopCount: 0,
-          threshold: randomCheckpointThreshold(),
+          threshold: defaultCheckpointThresholdValue(),
           lastAction: "skipped",
           lastReason: "unchanged"
         }
@@ -3432,7 +4930,7 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
   const lockPath = agentLoopLockPath(parsed, options, normalized.agentSessionKey);
   const workerArgs = [
     "agent-run",
-    "closeout",
+    "checkpoint",
     "--agent-session-key",
     normalized.agentSessionKey,
     "--reason",
@@ -3498,7 +4996,7 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
     };
   }
   try {
-    await spawnAgentRunCloseout(workerArgs, options);
+    await spawnAgentRunCheckpoint(workerArgs, options);
   } catch (error) {
     await releaseAgentLoopLock(lock.lockPath);
     throw error;
@@ -3509,8 +5007,9 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
       ...state.sessions,
       [normalized.agentSessionKey]: {
         ...observedSession,
+        ...cadenceContext ? { cadenceContext } : {},
         stopCount: 0,
-        threshold: randomCheckpointThreshold(),
+        threshold: defaultCheckpointThresholdValue(),
         lastAction: "spawned",
         lastEventFile: eventFile,
         lastCheckpointAt: new Date().toISOString(),
@@ -3531,7 +5030,10 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
     exitCode: 0
   };
 }
-async function runAgentRunCloseout(parsed, options, config, meta) {
+function objectStringId(value) {
+  return value && typeof value === "object" && "id" in value && typeof value.id === "string" ? value.id : undefined;
+}
+async function runAgentRunRoute(parsed, options, config, meta) {
   const projectId = requireProjectId(config);
   const client = await createClient(config, options);
   const agentSessionKeyValue = requireOption(parsed, "agent-session-key");
@@ -3542,16 +5044,383 @@ async function runAgentRunCloseout(parsed, options, config, meta) {
       agentSessionKey: agentSessionKeyValue
     });
   }
-  const current = await client.sessions.current({
-    projectId,
-    filters: {
-      limit: 100
-    }
+  const savedContext = sessionState.cadenceContext;
+  const currentContext = savedContext?.ticketId ? undefined : await readCurrentCadenceContext(client, projectId);
+  const eventFile = parsed.options["event-file"] ?? sessionState.lastEventFile;
+  const event = eventFile ? tryParseJsonObject(await readFile(eventFile, "utf8"), eventFile) : synthesizeAgentEventFromSession(agentSessionKeyValue, sessionState, options);
+  const checkpointSettings = await resolveCheckpointSettings(parsed, options);
+  const gitStatus = gitOutput(["status", "--short"], options);
+  const gitDiffStat = gitOutput(["diff", "--stat", "origin/dev..."], options);
+  const changedFiles = gitOutput(["diff", "--name-only", "origin/dev..."], options);
+  const prompt = buildRoutePrompt({
+    event,
+    ...parsed.options.reason ? { reason: parsed.options.reason } : {},
+    ...savedContext ? { savedContext } : {},
+    ...currentContext ? { currentContext } : {},
+    gitStatus,
+    gitDiffStat,
+    changedFiles,
+    ...sessionState.previousCheckpointSummary ? { previousCheckpointSummary: sessionState.previousCheckpointSummary } : {}
   });
-  const currentSession = activeSessionFromCurrent(current);
-  const ticketId = parsed.options.ticket ?? (currentSession && typeof currentSession.ticketId === "string" ? currentSession.ticketId : undefined);
-  const sessionId = parsed.options.session ?? (currentSession && typeof currentSession.id === "string" ? currentSession.id : undefined);
-  const changesetId = parsed.options.changeset ?? (currentSession && typeof currentSession.changesetId === "string" ? currentSession.changesetId : undefined);
+  const promptTokenAccounting = buildCheckpointTokenAccounting(event, prompt, undefined);
+  const dryRun = parseBooleanOption(parsed.options["dry-run"], false);
+  const lockPath = parsed.options.lock;
+  if (dryRun) {
+    const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
+      version: 1,
+      mode: "route",
+      action: "would_route",
+      createdAt: new Date().toISOString(),
+      localOnly: true,
+      localOnlyReason: "Raw hook context and route prompts stay on this machine and are not uploaded to Cadence.",
+      agentSessionKey: agentSessionKeyValue,
+      ...savedContext?.ticketId ? { ticketId: savedContext.ticketId } : currentContext?.ticketId ? { ticketId: currentContext.ticketId } : {},
+      ...eventFile ? { eventFile } : {},
+      event,
+      prompt,
+      checkpointSettings,
+      tokenAccounting: promptTokenAccounting,
+      cadenceWrites: []
+    });
+    const data = {
+      action: "would_route",
+      prompt,
+      auditFile,
+      agentSessionKey: agentSessionKeyValue
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  try {
+    const codexCommand = parsed.options["codex-command"] ?? "codex";
+    const codexStartedAtMs = Date.now();
+    const codexCwd = options.cwd ?? process.cwd();
+    const codexArgs = [
+      "exec",
+      ...checkpointSettings.model ? ["-m", checkpointSettings.model] : [],
+      "--disable",
+      "hooks",
+      "--sandbox",
+      "read-only",
+      "-C",
+      codexCwd,
+      prompt
+    ];
+    const codex = runLocalCommand(codexCommand, codexArgs, options, {
+      cwd: codexCwd,
+      env: {
+        [agentLoopSuppressEnv]: "1",
+        CADENCE_HOOK_SUPPRESS: "1"
+      },
+      timeoutMs: defaultCheckpointWorkerTimeoutMs
+    });
+    const codexSessionTranscript = readCodexSessionTranscript(findCodexSessionFileCreatedAfter(options, codexStartedAtMs, codexCwd));
+    const tokenAccounting = buildCheckpointTokenAccounting(event, prompt, codexSessionTranscript?.tokenUsage);
+    if (codex.status !== 0 || codex.error) {
+      throw new CliError("AGENT_RUN_ROUTE_FAILED", "Codex route generation failed.", {
+        status: codex.status,
+        stderr: truncateText(codex.stderr, 2000),
+        error: codex.error?.message
+      });
+    }
+    let routePlan = parseCheckpointPlanJson(codex.stdout, "intent");
+    const currentTicketId = savedContext?.ticketId ?? currentContext?.ticketId;
+    const currentSessionId = savedContext?.sessionId ?? currentContext?.sessionId;
+    const currentChangesetId = savedContext?.changesetId ?? currentContext?.changesetId;
+    if (routePlan.route.action === "needs_human") {
+      routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), routePlan.route.reason ?? "Route was uncertain.");
+    } else if (checkpointRouteRequiresIntake(routePlan.route.action) && routePlan.route.confidence !== "high") {
+      routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), "Automatic routing requires high confidence.");
+    } else if ((routePlan.route.action === "intake_attach" || routePlan.route.action === "switch_existing") && !routePlan.route.targetTicketId) {
+      routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), "Automatic routing to existing work requires a target ticket id.");
+    } else if (routePlan.route.action === "current" && !currentTicketId) {
+      routePlan = checkpointPlanWithRoute(routePlan, {
+        action: "noop",
+        confidence: routePlan.route.confidence,
+        reason: routePlan.route.reason ?? "No current Cadence context exists."
+      });
+    }
+    const cadenceWrites = [];
+    const lifecycleOperations = [];
+    let targetTicketId = currentTicketId;
+    let targetSessionId = currentSessionId;
+    let targetChangesetId = currentChangesetId;
+    let intakeResult;
+    let selectedTicket;
+    let summary = routePlan.summary ?? routePlan.entries[0]?.summary ?? routePlan.route.reason ?? "Agent run route";
+    const modelAudit = {
+      provider: checkpointSettings.provider,
+      command: codexCommand,
+      ...checkpointSettings.model ? { model: checkpointSettings.model } : {},
+      status: codex.status,
+      stdout: codex.stdout.trim(),
+      stderr: truncateText(codex.stderr.trim(), 2000),
+      tokenAccounting,
+      ...codexSessionTranscript?.tokenUsage ? { tokenUsage: codexSessionTranscript.tokenUsage } : {},
+      ...codexSessionTranscript ? { sessionTranscript: codexSessionTranscript } : {}
+    };
+    const finishRoute = async (action, reason) => {
+      const checkedAt = new Date().toISOString();
+      const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
+        version: 1,
+        mode: "route",
+        action,
+        createdAt: checkedAt,
+        localOnly: true,
+        localOnlyReason: action === "noop" || action === "current" ? "Raw hook context, route prompts, and model output stay on this machine; no Cadence writes were needed." : "Raw hook context, route prompts, and model output stay on this machine; Cadence receives only the structured writes listed here.",
+        agentSessionKey: agentSessionKeyValue,
+        ...targetTicketId ? { ticketId: targetTicketId } : {},
+        ...targetSessionId ? { sessionId: targetSessionId } : {},
+        ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+        ...eventFile ? { eventFile } : {},
+        event,
+        prompt,
+        model: modelAudit,
+        checkpoint: routePlan,
+        route: routePlan.route,
+        intakeResult,
+        selectedTicket,
+        lifecycleOperations,
+        cadenceWrites,
+        summary,
+        ...reason ? { reason } : {},
+        entryCount: routePlan.entries.length
+      });
+      const nextSessionState = {
+        ...sessionState,
+        stopCount: 0,
+        threshold: defaultCheckpointThresholdValue(),
+        previousCheckpointSummary: summary,
+        lastAction: action,
+        ...reason ? { lastReason: reason } : {},
+        ...eventFile ? { lastEventFile: eventFile } : {},
+        ...targetTicketId ? {
+          cadenceContext: {
+            ticketId: targetTicketId,
+            ...targetSessionId ? { sessionId: targetSessionId } : {},
+            ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+            capturedAt: checkedAt
+          }
+        } : {},
+        lastCheckpointAt: checkedAt,
+        lastCheckpointMode: "checkpoint",
+        lastCheckpointAuditFile: auditFile
+      };
+      await writeAgentLoopState(parsed, options, {
+        ...state,
+        sessions: {
+          ...state.sessions,
+          [agentSessionKeyValue]: nextSessionState
+        }
+      });
+      const data = {
+        action,
+        route: routePlan.route,
+        ...reason ? { reason } : {},
+        ...targetTicketId ? { ticketId: targetTicketId } : {},
+        summary,
+        entryCount: routePlan.entries.length,
+        mode: "route",
+        auditFile,
+        agentSessionKey: agentSessionKeyValue,
+        ...targetSessionId ? { sessionId: targetSessionId } : {},
+        ...targetChangesetId ? { changesetId: targetChangesetId } : {}
+      };
+      return {
+        stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    };
+    if (routePlan.route.action === "noop") {
+      return await finishRoute("noop", routePlan.route.reason ?? routePlan.summary ?? "Nothing durable to route.");
+    }
+    if (routePlan.route.action === "current") {
+      return await finishRoute("current", routePlan.route.reason ?? "Kept current Cadence context.");
+    }
+    if (routePlanAllowsLifecycle(routePlan)) {
+      const intakeRequest = routePlan.route.request ?? checkpointPlanDescription(routePlan);
+      intakeResult = await client.intake.create({
+        projectId,
+        intake: {
+          request: intakeRequest,
+          ...commandMetadata()
+        }
+      });
+      lifecycleOperations.push(checkpointLifecycleOperation("intake.created", true, { request: intakeRequest, result: intakeResult }));
+      if (checkpointHasConflictingIntakeResult(intakeResult, routePlan)) {
+        routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), "Intake returned conflicting duplicate, overlap, or completed-before candidates.");
+        return await finishRoute(routePlan.route.action, routePlan.route.reason);
+      }
+      if (routePlan.route.action === "intake_create") {
+        selectedTicket = await client.tickets.create({
+          projectId,
+          ticket: {
+            title: checkpointPlanTitle(routePlan),
+            description: checkpointPlanDescription(routePlan),
+            fromIntakeId: objectStringId(intakeResult),
+            ...commandMetadata()
+          }
+        });
+        lifecycleOperations.push(checkpointLifecycleOperation("ticket.created", true, { ticket: selectedTicket }));
+        targetTicketId = objectStringId(selectedTicket);
+      } else {
+        const selectedTicketId = routePlan.route.targetTicketId;
+        if (!selectedTicketId) {
+          routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), "Automatic routing to existing work requires a target ticket id.");
+          return await finishRoute(routePlan.route.action, routePlan.route.reason);
+        }
+        targetTicketId = selectedTicketId;
+        selectedTicket = await client.tickets.get({ projectId, ticketId: targetTicketId });
+        lifecycleOperations.push(checkpointLifecycleOperation("ticket.selected", true, { ticketId: targetTicketId, ticket: selectedTicket }));
+        const selectedVersion = selectedTicket && typeof selectedTicket === "object" && typeof selectedTicket.projectionVersion === "number" ? selectedTicket.projectionVersion : undefined;
+        const intakeId = objectStringId(intakeResult);
+        if (selectedVersion !== undefined && intakeId) {
+          await client.tickets.attach({
+            projectId,
+            ticketId: targetTicketId,
+            fromIntakeId: intakeId,
+            ifVersion: selectedVersion
+          });
+          lifecycleOperations.push(checkpointLifecycleOperation("intake.attached", true, { ticketId: targetTicketId, intakeId }));
+        }
+      }
+      if (!targetTicketId) {
+        routePlan = checkpointPlanWithRoute(routePlan, {
+          action: currentTicketId ? "current" : "noop",
+          confidence: routePlan.route.confidence,
+          reason: "Automatic routing did not return a target ticket."
+        });
+        return await finishRoute(routePlan.route.action, routePlan.route.reason);
+      }
+      if (currentSessionId && currentTicketId && targetTicketId !== currentTicketId) {
+        await client.sessions.end({
+          projectId,
+          sessionId: currentSessionId,
+          session: {
+            summary: routePlan.route.reason ?? summary,
+            ...commandMetadata()
+          }
+        });
+        lifecycleOperations.push(checkpointLifecycleOperation("session.ended", true, { sessionId: currentSessionId, reason: "ticket_switch" }));
+        targetSessionId = undefined;
+        targetChangesetId = undefined;
+      }
+      const startedSession = await client.sessions.start({
+        projectId,
+        session: {
+          ticketId: targetTicketId,
+          ...commandMetadata()
+        }
+      });
+      lifecycleOperations.push(checkpointLifecycleOperation("session.started", true, { ticketId: targetTicketId, session: startedSession }));
+      targetSessionId = objectStringId(startedSession);
+      if (targetSessionId) {
+        const lease = await client.sessions.leases.create({
+          projectId,
+          lease: {
+            ticketId: targetTicketId,
+            sessionId: targetSessionId,
+            expiresAt: leaseExpiresAt(defaultLeaseTtlSeconds),
+            ...commandMetadata()
+          }
+        });
+        lifecycleOperations.push(checkpointLifecycleOperation("lease.claimed", true, { ticketId: targetTicketId, sessionId: targetSessionId, lease }));
+      }
+      if (targetSessionId) {
+        try {
+          const branchName = await resolveCurrentBranch(options);
+          const changeset = await client.changesets.create({
+            projectId,
+            changeset: {
+              ticketId: targetTicketId,
+              branchName,
+              baseBranch: "dev",
+              sessionId: targetSessionId,
+              ...commandMetadata()
+            }
+          });
+          lifecycleOperations.push(checkpointLifecycleOperation("changeset.linked", true, { ticketId: targetTicketId, branchName, changeset }));
+          targetChangesetId = objectStringId(changeset);
+        } catch (error) {
+          lifecycleOperations.push(checkpointLifecycleOperation("changeset.linked", false, { error: error instanceof Error ? error.message : String(error) }));
+        }
+      }
+      const routeMetadata = checkpointWorkLogMetadata(checkpointSettings, "route", tokenAccounting);
+      for (const entry of routePlan.entries) {
+        const logEntry = {
+          entryKind: entry.kind,
+          body: entry.body,
+          summary: entry.summary ?? checkpointEntrySummary(entry.body),
+          ...targetSessionId ? { sessionId: targetSessionId } : {},
+          ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+          metadata: routeMetadata,
+          ...commandMetadata()
+        };
+        await client.tickets.log({
+          projectId,
+          ticketId: targetTicketId,
+          entry: logEntry
+        });
+        cadenceWrites.push({
+          type: "ticket.work_log_appended",
+          success: true,
+          ticketId: targetTicketId,
+          entry: logEntry
+        });
+      }
+      if (routePlan.files.length && targetSessionId) {
+        const filesByKind = new Map;
+        for (const file of routePlan.files) {
+          filesByKind.set(file.kind, [...filesByKind.get(file.kind) ?? [], file.path]);
+        }
+        for (const [kind, paths] of filesByKind) {
+          const filesPayload = {
+            ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+            files: paths.map((path) => ({
+              path,
+              changeKind: kind
+            })),
+            ...commandMetadata()
+          };
+          await client.sessions.files({
+            projectId,
+            sessionId: targetSessionId,
+            files: filesPayload
+          });
+          lifecycleOperations.push(checkpointLifecycleOperation("session.files_attached", true, { sessionId: targetSessionId, kind, files: paths }));
+        }
+      }
+      summary = routePlan.summary ?? routePlan.entries[0]?.summary ?? routePlan.route.reason ?? "Agent run routed";
+      return await finishRoute(routePlan.route.action === "intake_create" ? "routed" : "switched");
+    }
+    routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), "Route did not request an executable automatic action.");
+    return await finishRoute(routePlan.route.action, routePlan.route.reason);
+  } finally {
+    await releaseAgentLoopLock(lockPath);
+  }
+}
+async function runAgentRunCheckpoint(parsed, options, config, meta) {
+  const projectId = requireProjectId(config);
+  const client = await createClient(config, options);
+  const agentSessionKeyValue = requireOption(parsed, "agent-session-key");
+  const state = await readAgentLoopState(parsed, options);
+  const sessionState = state.sessions[agentSessionKeyValue];
+  if (!sessionState) {
+    throw new CliError("AGENT_RUN_SESSION_NOT_FOUND", "No local agent-run session state exists for --agent-session-key.", {
+      agentSessionKey: agentSessionKeyValue
+    });
+  }
+  const savedContext = sessionState.cadenceContext;
+  const currentContext = parsed.options.ticket || savedContext?.ticketId ? undefined : await readCurrentCadenceContext(client, projectId);
+  const ticketId = parsed.options.ticket ?? savedContext?.ticketId ?? currentContext?.ticketId;
+  const sessionId = parsed.options.session ?? savedContext?.sessionId ?? currentContext?.sessionId;
+  const changesetId = parsed.options.changeset ?? savedContext?.changesetId ?? currentContext?.changesetId;
   if (!ticketId) {
     await writeAgentLoopState(parsed, options, {
       ...state,
@@ -3578,14 +5447,36 @@ async function runAgentRunCloseout(parsed, options, config, meta) {
   }
   const eventFile = parsed.options["event-file"] ?? sessionState.lastEventFile;
   const event = eventFile ? tryParseJsonObject(await readFile(eventFile, "utf8"), eventFile) : synthesizeAgentEventFromSession(agentSessionKeyValue, sessionState, options);
+  const mode = checkpointModeForCommand(parsed);
   const logKind = parseWorkLogEntryKind(parsed.options["log-kind"] ?? "note");
   const updateSummary = parseBooleanOption(parsed.options["update-summary"], false);
   const dryRun = parseBooleanOption(parsed.options["dry-run"], false);
+  const closeoutSessionAction = parseCloseoutSessionAction(parsed.options["session-action"]);
+  const completeTicket = parseBooleanOption(parsed.options["complete-ticket"], false);
   const lockPath = parsed.options.lock;
+  const checkpointSettings = await resolveCheckpointSettings(parsed, options);
   const gitStatus = gitOutput(["status", "--short"], options);
   const gitDiffStat = gitOutput(["diff", "--stat", "origin/dev..."], options);
   const changedFiles = gitOutput(["diff", "--name-only", "origin/dev..."], options);
+  const priorCoverage = sessionState.lastCheckpointCoverage;
+  const fingerprints = buildAgentRunFingerprints({
+    event,
+    ticketId,
+    ...sessionId ? { sessionId } : {},
+    ...changesetId ? { changesetId } : {},
+    gitStatus,
+    gitDiffStat,
+    changedFiles,
+    ...priorCoverage ? { coverage: priorCoverage } : {}
+  });
+  const closeoutContext = mode === "closeout" ? await readCloseoutPromptContext({
+    client,
+    projectId,
+    ticketId,
+    ...sessionId ? { sessionId } : {}
+  }) : {};
   const prompt = buildCheckpointPrompt({
+    mode,
     event,
     ticketId,
     ...sessionId ? { sessionId } : {},
@@ -3593,12 +5484,89 @@ async function runAgentRunCloseout(parsed, options, config, meta) {
     gitStatus,
     gitDiffStat,
     changedFiles,
-    ...sessionState.previousCheckpointSummary ? { previousCheckpointSummary: sessionState.previousCheckpointSummary } : {}
+    ...sessionState.previousCheckpointSummary ? { previousCheckpointSummary: sessionState.previousCheckpointSummary } : {},
+    ...priorCoverage ? { coverage: priorCoverage } : {},
+    ...closeoutContext
   });
+  const promptTokenAccounting = buildCheckpointTokenAccounting(event, prompt, undefined);
+  if (mode === "checkpoint" && !dryRun && !priorCoverage?.hasDebt && fingerprintsEqual(sessionState.lastCheckpointFingerprints, fingerprints) && !checkpointReasonBypassesFingerprintGate(parsed.options.reason)) {
+    const checkedAt = new Date().toISOString();
+    const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
+      version: 1,
+      mode,
+      action: "skipped",
+      reason: "unchanged_fingerprints",
+      createdAt: checkedAt,
+      localOnly: true,
+      localOnlyReason: "Raw hook context and checkpoint prompts stay on this machine; unchanged fingerprints did not need a model call.",
+      agentSessionKey: agentSessionKeyValue,
+      ticketId,
+      ...sessionId ? { sessionId } : {},
+      ...changesetId ? { changesetId } : {},
+      ...eventFile ? { eventFile } : {},
+      event,
+      fingerprints,
+      cadenceWrites: []
+    });
+    await writeAgentLoopState(parsed, options, {
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [agentSessionKeyValue]: {
+          ...sessionState,
+          stopCount: 0,
+          threshold: defaultCheckpointThresholdValue(),
+          lastAction: "skipped",
+          lastReason: "unchanged_fingerprints",
+          lastCheckpointAt: checkedAt,
+          lastCheckpointMode: mode,
+          lastCheckpointFingerprints: fingerprints,
+          lastCheckpointAuditFile: auditFile
+        }
+      }
+    });
+    const data = {
+      action: "skipped",
+      reason: "unchanged_fingerprints",
+      mode,
+      ticketId,
+      auditFile,
+      agentSessionKey: agentSessionKeyValue,
+      ...sessionId ? { sessionId } : {},
+      ...changesetId ? { changesetId } : {}
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
   if (dryRun) {
+    const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
+      version: 1,
+      mode,
+      action: "would_checkpoint",
+      createdAt: new Date().toISOString(),
+      localOnly: true,
+      localOnlyReason: "Raw hook context and checkpoint prompts stay on this machine and are not uploaded to Cadence.",
+      agentSessionKey: agentSessionKeyValue,
+      ticketId,
+      ...sessionId ? { sessionId } : {},
+      ...changesetId ? { changesetId } : {},
+      ...eventFile ? { eventFile } : {},
+      event,
+      prompt,
+      fingerprints,
+      ...mode === "closeout" ? { coverage: priorCoverage ?? null } : {},
+      checkpointSettings,
+      tokenAccounting: promptTokenAccounting,
+      cadenceWrites: []
+    });
     const data = {
-      action: "would_closeout",
+      action: "would_checkpoint",
       prompt,
+      auditFile,
       ticketId,
       agentSessionKey: agentSessionKeyValue,
       ...sessionId ? { sessionId } : {},
@@ -3613,84 +5581,329 @@ async function runAgentRunCloseout(parsed, options, config, meta) {
   }
   try {
     const codexCommand = parsed.options["codex-command"] ?? "codex";
-    const codex = runLocalCommand(codexCommand, ["exec", "--disable", "hooks", "--sandbox", "read-only", "-C", options.cwd ?? process.cwd(), prompt], options, {
-      cwd: options.cwd ?? process.cwd(),
+    const codexStartedAtMs = Date.now();
+    const codexCwd = options.cwd ?? process.cwd();
+    const codexArgs = [
+      "exec",
+      ...checkpointSettings.model ? ["-m", checkpointSettings.model] : [],
+      "--disable",
+      "hooks",
+      "--sandbox",
+      "read-only",
+      "-C",
+      codexCwd,
+      prompt
+    ];
+    const codex = runLocalCommand(codexCommand, codexArgs, options, {
+      cwd: codexCwd,
       env: {
         [agentLoopSuppressEnv]: "1",
         CADENCE_HOOK_SUPPRESS: "1"
       },
       timeoutMs: defaultCheckpointWorkerTimeoutMs
     });
+    const codexSessionTranscript = readCodexSessionTranscript(findCodexSessionFileCreatedAfter(options, codexStartedAtMs, codexCwd));
+    const tokenAccounting = buildCheckpointTokenAccounting(event, prompt, codexSessionTranscript?.tokenUsage);
     if (codex.status !== 0 || codex.error) {
-      throw new CliError("AGENT_RUN_CLOSEOUT_FAILED", "Codex closeout generation failed.", {
+      throw new CliError("AGENT_RUN_CHECKPOINT_FAILED", "Codex checkpoint generation failed.", {
         status: codex.status,
         stderr: truncateText(codex.stderr, 2000),
         error: codex.error?.message
       });
     }
-    const checkpoint = parseCheckpointJson(codex.stdout);
-    const body = checkpoint.body.trim();
-    const summary = checkpoint.summary ?? truncateText(body.replace(/\s+/g, " "), 500);
-    if (!body) {
-      throw new CliError("AGENT_RUN_CLOSEOUT_FAILED", "Codex closeout generation returned an empty checkpoint.");
+    let checkpoint = parseCheckpointPlanJson(codex.stdout, logKind);
+    if (mode === "closeout") {
+      checkpoint = applyCloseoutSessionDefaults(checkpoint, closeoutSessionAction, completeTicket);
     }
-    await client.tickets.log({
-      projectId,
-      ticketId,
-      entry: {
-        entryKind: logKind,
-        body,
+    const reductionResult = reduceCheckpointEntries(checkpoint.entries, mode);
+    checkpoint = {
+      ...checkpoint,
+      entries: reductionResult.entries
+    };
+    const coverage = buildAgentRunCoverage(checkpoint, mode);
+    let summary = checkpoint.summary ?? checkpoint.entries[0]?.summary ?? checkpoint.route.reason ?? "Agent run checkpoint";
+    let targetTicketId = ticketId;
+    let targetSessionId = sessionId;
+    let targetChangesetId = changesetId;
+    const cadenceWrites = [];
+    const lifecycleOperations = [];
+    let intakeResult;
+    let selectedTicket;
+    const modelAudit = {
+      provider: checkpointSettings.provider,
+      command: codexCommand,
+      ...checkpointSettings.model ? { model: checkpointSettings.model } : {},
+      status: codex.status,
+      stdout: codex.stdout.trim(),
+      stderr: truncateText(codex.stderr.trim(), 2000),
+      tokenAccounting,
+      ...codexSessionTranscript?.tokenUsage ? { tokenUsage: codexSessionTranscript.tokenUsage } : {},
+      ...codexSessionTranscript ? { sessionTranscript: codexSessionTranscript } : {}
+    };
+    const finishCheckpoint = async (action, reason) => {
+      const checkedAt = new Date().toISOString();
+      const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
+        version: 1,
+        action,
+        createdAt: checkedAt,
+        localOnly: true,
+        localOnlyReason: action === "noop" || action === "needs_human" || action === "reroute" ? "Raw hook context, checkpoint prompts, and model output stay on this machine; no Cadence writes were needed." : "Raw hook context, checkpoint prompts, and model output stay on this machine; Cadence receives only the structured writes listed here.",
+        agentSessionKey: agentSessionKeyValue,
+        ticketId: targetTicketId,
+        ...targetSessionId ? { sessionId: targetSessionId } : {},
+        ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+        ...eventFile ? { eventFile } : {},
+        event,
+        prompt,
+        model: modelAudit,
+        checkpoint,
+        route: checkpoint.route,
+        mode,
+        fingerprints,
+        reduction: reductionResult.reduction,
+        ...mode === "closeout" ? { coverage } : {},
+        ...intakeResult ? { intakeResult } : {},
+        ...selectedTicket ? { selectedTicket } : {},
+        lifecycleOperations,
+        cadenceWrites,
+        summary,
+        ...reason ? { reason } : {},
+        entryCount: checkpoint.entries.length,
+        needsHuman: action === "needs_human"
+      });
+      await writeAgentLoopState(parsed, options, {
+        ...state,
+        sessions: {
+          ...state.sessions,
+          [agentSessionKeyValue]: {
+            ...sessionState,
+            stopCount: 0,
+            threshold: defaultCheckpointThresholdValue(),
+            previousCheckpointSummary: summary,
+            lastAction: action,
+            ...reason ? { lastReason: reason } : {},
+            ...eventFile ? { lastEventFile: eventFile } : {},
+            cadenceContext: {
+              ticketId: targetTicketId,
+              ...targetSessionId ? { sessionId: targetSessionId } : {},
+              ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+              capturedAt: checkedAt
+            },
+            lastCheckpointAt: checkedAt,
+            lastCheckpointMode: mode,
+            lastCheckpointFingerprints: fingerprints,
+            lastCheckpointCoverage: coverage,
+            lastCheckpointAuditFile: auditFile
+          }
+        }
+      });
+      const data = {
+        action,
+        route: checkpoint.route,
+        ...reason ? { reason } : {},
+        ticketId: targetTicketId,
         summary,
-        ...sessionId ? { sessionId } : {},
-        ...changesetId ? { changesetId } : {},
+        entryCount: checkpoint.entries.length,
+        mode,
+        auditFile,
+        agentSessionKey: agentSessionKeyValue,
+        ...targetSessionId ? { sessionId: targetSessionId } : {},
+        ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+        ...action === "needs_human" ? { needsHuman: true } : {}
+      };
+      return {
+        stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    };
+    if (checkpoint.session?.action === "complete_ticket" && mode === "closeout" && !completeTicket) {
+      checkpoint = checkpointPlanNeedsHuman(checkpoint, "Closeout ticket completion requires --complete-ticket true.");
+    }
+    if (checkpoint.session?.action === "complete_ticket" && !checkpointPlanCompletionAllowed(event, summary)) {
+      checkpoint = checkpointPlanNeedsHuman(checkpoint, "Completion requires explicit recent completion, push, PR, merge, clean branch, or verification intent.");
+    }
+    if (checkpoint.route.action === "noop") {
+      return await finishCheckpoint("noop", checkpoint.route.reason ?? checkpoint.summary ?? "Nothing durable to record.");
+    }
+    if (checkpoint.route.action === "needs_human") {
+      checkpoint = checkpointPlanWithRoute(checkpoint, {
+        action: "noop",
+        confidence: checkpoint.route.confidence,
+        reason: checkpoint.route.reason ?? "Checkpoint routing was uncertain."
+      });
+      return await finishCheckpoint("noop", checkpoint.route.reason);
+    }
+    if (checkpointRouteRequiresIntake(checkpoint.route.action)) {
+      if (checkpoint.route.confidence !== "high") {
+        checkpoint = checkpointPlanWithRoute(checkpoint, {
+          action: "noop",
+          confidence: checkpoint.route.confidence,
+          reason: "Checkpoint reroute requires high confidence."
+        });
+        return await finishCheckpoint("noop", checkpoint.route.reason);
+      }
+      const routeArgs = [
+        "agent-run",
+        "route",
+        "--agent-session-key",
+        agentSessionKeyValue,
+        "--reason",
+        "checkpoint_reroute",
+        ...eventFile ? ["--event-file", eventFile] : [],
+        ...parsed.flags.project ? ["--project", parsed.flags.project] : [],
+        ...parsed.flags.server ? ["--server", parsed.flags.server] : []
+      ];
+      const rerouteResult = await finishCheckpoint("reroute", checkpoint.route.reason ?? "Checkpoint delegated routing to agent-run route.");
+      await spawnAgentRunWorker(routeArgs, options);
+      return rerouteResult;
+    }
+    const checkpointMetadata = checkpointWorkLogMetadata(checkpointSettings, mode, tokenAccounting);
+    for (const entry of checkpoint.entries) {
+      const logEntry = {
+        entryKind: entry.kind,
+        body: entry.body,
+        summary: entry.summary ?? checkpointEntrySummary(entry.body),
+        ...entry.parentSelector ? { parentSelector: entry.parentSelector } : {},
+        ...entry.parentEntryId ? { parentEntryId: entry.parentEntryId } : {},
+        ...targetSessionId ? { sessionId: targetSessionId } : {},
+        ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+        metadata: checkpointMetadata,
         ...commandMetadata()
+      };
+      try {
+        await client.tickets.log({
+          projectId,
+          ticketId: targetTicketId,
+          entry: logEntry
+        });
+        cadenceWrites.push({
+          type: "ticket.work_log_appended",
+          success: true,
+          ticketId: targetTicketId,
+          entry: logEntry
+        });
+      } catch (error) {
+        if (!entry.parentSelector && !entry.parentEntryId) {
+          cadenceWrites.push({
+            type: "ticket.work_log_appended",
+            success: false,
+            ticketId: targetTicketId,
+            entry: logEntry,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          throw error;
+        }
+        const { parentSelector: _parentSelector, parentEntryId: _parentEntryId, ...entryWithoutParent } = logEntry;
+        cadenceWrites.push({
+          type: "ticket.work_log_appended",
+          success: false,
+          ticketId: targetTicketId,
+          entry: logEntry,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        await client.tickets.log({
+          projectId,
+          ticketId: targetTicketId,
+          entry: entryWithoutParent
+        });
+        cadenceWrites.push({
+          type: "ticket.work_log_appended",
+          success: true,
+          ticketId: targetTicketId,
+          entry: entryWithoutParent,
+          fallback: "removed unresolved parent reference"
+        });
       }
-    });
-    if (updateSummary) {
-      const ticket = await client.tickets.get({ projectId, ticketId });
+    }
+    if (checkpoint.files.length && targetSessionId) {
+      const filesByKind = new Map;
+      for (const file of checkpoint.files) {
+        filesByKind.set(file.kind, [...filesByKind.get(file.kind) ?? [], file.path]);
+      }
+      for (const [kind, paths] of filesByKind) {
+        const filesPayload = {
+          ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+          files: paths.map((path) => ({
+            path,
+            changeKind: kind
+          })),
+          ...commandMetadata()
+        };
+        await client.sessions.files({
+          projectId,
+          sessionId: targetSessionId,
+          files: filesPayload
+        });
+        lifecycleOperations.push(checkpointLifecycleOperation("session.files_attached", true, { sessionId: targetSessionId, kind, files: paths }));
+      }
+    }
+    if ((updateSummary || checkpoint.summaryUpdate?.update) && checkpoint.summaryUpdate?.value) {
+      const ticket = await client.tickets.get({ projectId, ticketId: targetTicketId });
       if (typeof ticket.projectionVersion === "number") {
         await client.tickets.update({
           projectId,
-          ticketId,
+          ticketId: targetTicketId,
           ifVersion: ticket.projectionVersion,
           ticket: {
-            currentSummary: summary,
+            currentSummary: checkpoint.summaryUpdate.value,
             ...commandMetadata()
           }
         });
+        cadenceWrites.push({
+          type: "ticket.updated",
+          success: true,
+          ticketId: targetTicketId,
+          ifVersion: ticket.projectionVersion,
+          ticket: {
+            currentSummary: checkpoint.summaryUpdate.value
+          }
+        });
       }
     }
-    await writeAgentLoopState(parsed, options, {
-      ...state,
-      sessions: {
-        ...state.sessions,
-        [agentSessionKeyValue]: {
-          ...sessionState,
-          previousCheckpointSummary: summary,
-          lastAction: "closed_out",
-          ...eventFile ? { lastEventFile: eventFile } : {}
-        }
+    if (checkpoint.session?.action === "handoff" || checkpoint.session?.action === "end" || checkpoint.session?.action === "complete_ticket") {
+      if (targetSessionId) {
+        await client.sessions.end({
+          projectId,
+          sessionId: targetSessionId,
+          session: {
+            summary: checkpoint.session.summary ?? summary,
+            ...commandMetadata()
+          }
+        });
+        lifecycleOperations.push(checkpointLifecycleOperation("session.ended", true, { sessionId: targetSessionId, action: checkpoint.session.action }));
       }
-    });
-    const data = {
-      action: "closed_out",
-      ticketId,
-      summary,
-      agentSessionKey: agentSessionKeyValue,
-      ...sessionId ? { sessionId } : {},
-      ...changesetId ? { changesetId } : {}
-    };
-    return {
-      stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
-`,
-      stderr: "",
-      exitCode: 0
-    };
+    }
+    if (checkpoint.session?.action === "complete_ticket") {
+      const latestTicket = await client.tickets.get({ projectId, ticketId: targetTicketId });
+      if (typeof latestTicket.projectionVersion !== "number") {
+        checkpoint = checkpointPlanNeedsHuman(checkpoint, "Ticket completion requires a latest ticket projection version.");
+        return await finishCheckpoint("needs_human", checkpoint.route.reason);
+      }
+      await client.tickets.complete({
+        projectId,
+        ticketId: targetTicketId,
+        ifVersion: latestTicket.projectionVersion,
+        completion: {
+          currentSummary: checkpoint.session.summary ?? checkpoint.summaryUpdate?.value ?? summary,
+          ...commandMetadata()
+        }
+      });
+      cadenceWrites.push({
+        type: "ticket.completed",
+        success: true,
+        ticketId: targetTicketId,
+        ifVersion: latestTicket.projectionVersion,
+        summary: checkpoint.session.summary ?? checkpoint.summaryUpdate?.value ?? summary
+      });
+    }
+    return await finishCheckpoint("checkpointed");
   } finally {
     await releaseAgentLoopLock(lockPath);
   }
 }
-async function runAgentRunSweep(parsed, options, meta) {
+async function runAgentRunSweep(parsed, options, config, meta) {
   const state = await readAgentLoopState(parsed, options);
   const idleAfterSeconds = parsePositiveInteger(parsed.options["idle-after-seconds"], "--idle-after-seconds") ?? 5 * 60;
   const dryRun = parseBooleanOption(parsed.options["dry-run"], false);
@@ -3709,14 +5922,30 @@ async function runAgentRunSweep(parsed, options, meta) {
     lastObservedAt: session.lastObservedAt
   }));
   if (!dryRun) {
+    let nextState = state;
     for (const staleSession of staleSessions) {
-      await spawnAgentRunCloseout([
+      const existingSession = nextState.sessions[staleSession.agentSessionKey];
+      const hasContext = Boolean(existingSession?.cadenceContext?.ticketId);
+      if (existingSession) {
+        nextState = {
+          ...nextState,
+          sessions: {
+            ...nextState.sessions,
+            [staleSession.agentSessionKey]: {
+              ...existingSession,
+              lastAction: "sweep_spawned"
+            }
+          }
+        };
+        await writeAgentLoopState(parsed, options, nextState);
+      }
+      await spawnAgentRunCheckpoint([
         "agent-run",
-        "closeout",
+        hasContext ? "checkpoint" : "route",
         "--agent-session-key",
         staleSession.agentSessionKey,
         "--reason",
-        "idle",
+        hasContext ? "idle" : "missing_context",
         "--lock",
         agentLoopLockPath(parsed, options, staleSession.agentSessionKey),
         ...parsed.flags.project ? ["--project", parsed.flags.project] : [],
@@ -4158,6 +6387,7 @@ async function runIntakeCommand(parsed, options) {
           ...parsed.options.changeset ? { changesetId: parsed.options.changeset } : {},
           ...parsed.options.actor ? { actorId: parsed.options.actor } : {},
           expiresAt: leaseExpiresAt(parsePositiveInteger(parsed.options["ttl-seconds"], "--ttl-seconds") ?? defaultLeaseTtlSeconds),
+          ...parseBooleanOption(parsed.options["replace-own-active"], false) ? { replaceOwnActiveLease: true } : {},
           ...commandMetadata()
         }
       });
@@ -4383,7 +6613,7 @@ async function runCli(argv, options = {}) {
     if (parsed.command.name === "projects.list") {
       return await runProjectCommand(parsed, options);
     }
-    if (parsed.command.name === "agent-run.ingest-stop" || parsed.command.name === "agent-run.closeout" || parsed.command.name === "agent-run.sweep" || parsed.command.name === "agent-run.doctor") {
+    if (parsed.command.name === "agent-run.ingest-stop" || parsed.command.name === "agent-run.route" || parsed.command.name === "agent-run.checkpoint" || parsed.command.name === "agent-run.closeout" || parsed.command.name === "agent-run.sweep" || parsed.command.name === "agent-run.doctor") {
       return await runAgentRunCommand(parsed, options);
     }
     if (parsed.command.name === "hooks.install" || parsed.command.name === "hooks.doctor") {