@trycadence/cli 0.1.11-dev.0 → 0.1.14-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.14-dev.0",
   private: false,
   type: "module",
   bin: {
@@ -1553,14 +1554,13 @@ 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 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 +1599,7 @@ var knownCommandPaths = [
   ["changesets", "notes", "put"],
   ["changesets", "notes", "apply"],
   ["agent-run", "ingest-stop"],
+  ["agent-run", "checkpoint"],
   ["agent-run", "closeout"],
   ["agent-run", "sweep"],
   ["agent-run", "doctor"],
@@ -2260,7 +2261,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 +2279,11 @@ 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 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 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 +2582,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 +2628,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 +3024,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 +3041,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 +3053,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 +3085,23 @@ function normalizeGenericAgentEvent(input, base) {
 function agentSessionKey(source, agentSessionId) {
   return `${source}:${stableHash(agentSessionId)}`;
 }
+function checkpointWorkLogMetadata(settings, tokenAccounting) {
+  return {
+    checkpoint: {
+      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 +3109,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 +3229,45 @@ 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 } : {}
+      ...typeof record.previousCheckpointSummary === "string" ? { previousCheckpointSummary: record.previousCheckpointSummary } : {},
+      ...typeof record.lastCheckpointAuditFile === "string" ? { lastCheckpointAuditFile: record.lastCheckpointAuditFile } : {}
     };
   }
   return sessions;
 }
+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 +3302,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 +3396,7 @@ function currentCliWorkerInvocation() {
     argsPrefix: []
   };
 }
-async function spawnAgentRunCloseout(args, options) {
+async function spawnAgentRunCheckpoint(args, options) {
   const cwd = options.cwd ?? process.cwd();
   const invocation = currentCliWorkerInvocation();
   const env = {
@@ -2910,47 +3415,88 @@ async function spawnAgentRunCloseout(args, options) {
   });
   child.unref();
 }
+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 +3504,7 @@ function fingerprintForCheckpoint(event, options) {
     source: event.source,
     event: event.event,
     lastAssistantMessage: event.lastAssistantMessage ?? "",
+    recentTurns: event.recentTurns ?? [],
     status,
     changedFiles
   }));
@@ -2972,24 +3519,106 @@ 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) {
+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;
+}
+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") {
-      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
-      };
+      return parseCheckpointRecord(parsed, trimmed, fallbackKind);
     }
   } catch {
     const start = trimmed.indexOf("{");
@@ -2998,34 +3627,378 @@ function parseCheckpointJson(raw) {
       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
-          };
+          return parseCheckpointRecord(parsed, trimmed, fallbackKind);
         }
       } catch {}
     }
   }
   return {
-    body: trimmed,
-    summary: undefined
+    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 routeRequiresHighConfidence(route, session) {
+  return highAutonomyRouteActions.has(route.action) || session?.action === "complete_ticket";
+}
+function forceNeedsHuman(plan, reason) {
+  return {
+    ...plan,
+    route: {
+      ...plan.route,
+      action: "needs_human",
+      reason
+    },
+    validationWarnings: [...plan.validationWarnings, reason]
+  };
+}
+function normalizeCheckpointPlan(plan) {
+  if (routeRequiresHighConfidence(plan.route, plan.session) && plan.route.confidence !== "high") {
+    return forceNeedsHuman(plan, "Lifecycle mutation requires high confidence.");
+  }
+  if (plan.route.action === "noop") {
+    return {
+      ...plan,
+      entries: []
+    };
+  }
+  return plan;
+}
+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) : "";
   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.",
+    "You are generating a compact Cadence dogfood operation plan for a hook-spawned checkpoint 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|needs_human","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 intake_create for clearly unrelated new work. Use intake_attach or switch_existing only when a specific existing ticket is clearly the right target. Use needs_human when routing is ambiguous.",
+    "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.",
     "",
     `Ticket: ${input.ticketId}`,
     input.sessionId ? `Session: ${input.sessionId}` : "",
     input.changesetId ? `ChangeSet: ${input.changesetId}` : "",
     `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 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...:
@@ -3058,6 +4031,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 +4060,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 +4076,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 +4099,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 +4246,17 @@ async function runAgentRunCommand(parsed, options) {
   switch (parsed.command.name) {
     case "agent-run.ingest-stop":
       return await runAgentRunIngestStop(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 +4331,15 @@ 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);
+  let cadenceContext = existingSession?.cadenceContext;
+  try {
+    const client = await createClient(config, options);
+    cadenceContext = await readCurrentCadenceContext(client, projectId) ?? cadenceContext;
+  } catch {}
   const observedSession = {
     ...clearAgentSessionReason(existingSession ?? {
       source: normalized.source,
@@ -3350,8 +4351,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,
@@ -3363,7 +4367,8 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
   if (nextCount < threshold) {
     await writeAgentLoopState(parsed, options, countedState);
     const data2 = {
-      action: "counted",
+      action: duplicateTurn ? "updated" : "counted",
+      ...duplicateTurn ? { reason: "duplicate_turn" } : {},
       agentSessionKey: normalized.agentSessionKey,
       stopCount: nextCount,
       threshold
@@ -3410,7 +4415,7 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
         [normalized.agentSessionKey]: {
           ...observedSession,
           stopCount: 0,
-          threshold: randomCheckpointThreshold(),
+          threshold: defaultCheckpointThresholdValue(),
           lastAction: "skipped",
           lastReason: "unchanged"
         }
@@ -3432,7 +4437,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 +4503,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 +4514,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 +4537,7 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
     exitCode: 0
   };
 }
-async function runAgentRunCloseout(parsed, options, config, meta) {
+async function runAgentRunCheckpoint(parsed, options, config, meta) {
   const projectId = requireProjectId(config);
   const client = await createClient(config, options);
   const agentSessionKeyValue = requireOption(parsed, "agent-session-key");
@@ -3542,16 +4548,11 @@ async function runAgentRunCloseout(parsed, options, config, meta) {
       agentSessionKey: agentSessionKeyValue
     });
   }
-  const current = await client.sessions.current({
-    projectId,
-    filters: {
-      limit: 100
-    }
-  });
-  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 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,
@@ -3582,6 +4583,7 @@ async function runAgentRunCloseout(parsed, options, config, meta) {
   const updateSummary = parseBooleanOption(parsed.options["update-summary"], false);
   const dryRun = parseBooleanOption(parsed.options["dry-run"], 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);
@@ -3595,10 +4597,29 @@ async function runAgentRunCloseout(parsed, options, config, meta) {
     changedFiles,
     ...sessionState.previousCheckpointSummary ? { previousCheckpointSummary: sessionState.previousCheckpointSummary } : {}
   });
+  const promptTokenAccounting = buildCheckpointTokenAccounting(event, prompt, undefined);
   if (dryRun) {
+    const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
+      version: 1,
+      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,
+      checkpointSettings,
+      tokenAccounting: promptTokenAccounting,
+      cadenceWrites: []
+    });
     const data = {
-      action: "would_closeout",
+      action: "would_checkpoint",
       prompt,
+      auditFile,
       ticketId,
       agentSessionKey: agentSessionKeyValue,
       ...sessionId ? { sessionId } : {},
@@ -3613,84 +4634,387 @@ 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.");
-    }
-    await client.tickets.log({
-      projectId,
-      ticketId,
-      entry: {
-        entryKind: logKind,
-        body,
+    let checkpoint = parseCheckpointPlanJson(codex.stdout, logKind);
+    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" ? "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,
+        ...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,
+            lastCheckpointAuditFile: auditFile
+          }
+        }
+      });
+      const data = {
+        action,
+        route: checkpoint.route,
+        ...reason ? { reason } : {},
+        ticketId: targetTicketId,
         summary,
-        ...sessionId ? { sessionId } : {},
-        ...changesetId ? { changesetId } : {},
+        entryCount: checkpoint.entries.length,
+        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" && !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") {
+      return await finishCheckpoint("needs_human", checkpoint.route.reason ?? "Checkpoint routing needs human review.");
+    }
+    if (checkpointRouteRequiresIntake(checkpoint.route.action)) {
+      const intakeRequest = checkpoint.route.request ?? checkpointPlanDescription(checkpoint);
+      intakeResult = await client.intake.create({
+        projectId,
+        intake: {
+          request: intakeRequest,
+          ...commandMetadata()
+        }
+      });
+      lifecycleOperations.push(checkpointLifecycleOperation("intake.created", true, { request: intakeRequest, result: intakeResult }));
+      if (checkpointHasConflictingIntakeResult(intakeResult, checkpoint)) {
+        checkpoint = checkpointPlanNeedsHuman(checkpoint, "Intake returned conflicting duplicate, overlap, or completed-before candidates.");
+        return await finishCheckpoint("needs_human", checkpoint.route.reason);
+      }
+      if (checkpoint.route.action === "intake_create") {
+        selectedTicket = await client.tickets.create({
+          projectId,
+          ticket: {
+            title: checkpointPlanTitle(checkpoint),
+            description: checkpointPlanDescription(checkpoint),
+            fromIntakeId: typeof intakeResult === "object" && intakeResult && "id" in intakeResult ? String(intakeResult.id) : undefined,
+            ...commandMetadata()
+          }
+        });
+        lifecycleOperations.push(checkpointLifecycleOperation("ticket.created", true, { ticket: selectedTicket }));
+        if (selectedTicket && typeof selectedTicket === "object" && "id" in selectedTicket) {
+          targetTicketId = String(selectedTicket.id);
+        }
+      } else {
+        if (!checkpoint.route.targetTicketId) {
+          checkpoint = checkpointPlanNeedsHuman(checkpoint, "Checkpoint route requires a target ticket id.");
+          return await finishCheckpoint("needs_human", checkpoint.route.reason);
+        }
+        targetTicketId = checkpoint.route.targetTicketId;
+        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 = intakeResult && typeof intakeResult === "object" && "id" in intakeResult ? String(intakeResult.id) : undefined;
+        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 !== ticketId && targetSessionId) {
+        await client.sessions.end({
+          projectId,
+          sessionId: targetSessionId,
+          session: {
+            summary: checkpoint.session?.summary ?? checkpoint.route.reason ?? summary,
+            ...commandMetadata()
+          }
+        });
+        lifecycleOperations.push(checkpointLifecycleOperation("session.ended", true, { sessionId: targetSessionId, 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 }));
+      if (startedSession && typeof startedSession === "object" && "id" in startedSession) {
+        targetSessionId = String(startedSession.id);
+      }
+      if (targetSessionId) {
+        const lease = await client.sessions.leases.create({
+          projectId,
+          lease: {
+            ticketId: targetTicketId,
+            sessionId: targetSessionId,
+            expiresAt: leaseExpiresAt(defaultLeaseTtlSeconds),
+            replaceOwnActiveLease: true,
+            ...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 }));
+          if (changeset && typeof changeset === "object" && "id" in changeset) {
+            targetChangesetId = String(changeset.id);
+          }
+        } catch (error) {
+          lifecycleOperations.push(checkpointLifecycleOperation("changeset.linked", false, { error: error instanceof Error ? error.message : String(error) }));
+        }
+      }
+    }
+    const checkpointMetadata = checkpointWorkLogMetadata(checkpointSettings, 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,10 +5033,35 @@ async function runAgentRunSweep(parsed, options, meta) {
     lastObservedAt: session.lastObservedAt
   }));
   if (!dryRun) {
+    const needsFallbackContext = staleSessions.some((staleSession) => !state.sessions[staleSession.agentSessionKey]?.cadenceContext);
+    let fallbackContext;
+    if (needsFallbackContext && config.projectId) {
+      try {
+        const client = await createClient(config, options);
+        fallbackContext = await readCurrentCadenceContext(client, config.projectId);
+      } catch {}
+    }
+    let nextState = state;
     for (const staleSession of staleSessions) {
-      await spawnAgentRunCloseout([
+      const existingSession = nextState.sessions[staleSession.agentSessionKey];
+      const cadenceContext = existingSession?.cadenceContext ?? fallbackContext;
+      if (existingSession && cadenceContext) {
+        nextState = {
+          ...nextState,
+          sessions: {
+            ...nextState.sessions,
+            [staleSession.agentSessionKey]: {
+              ...existingSession,
+              cadenceContext,
+              lastAction: "sweep_spawned"
+            }
+          }
+        };
+        await writeAgentLoopState(parsed, options, nextState);
+      }
+      await spawnAgentRunCheckpoint([
         "agent-run",
-        "closeout",
+        "checkpoint",
         "--agent-session-key",
         staleSession.agentSessionKey,
         "--reason",
@@ -4158,6 +5507,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 +5733,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.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") {