@trycadence/cli 0.1.14-dev.0 → 0.1.18-dev.0

package/dist/cadence

@@ -1520,7 +1520,7 @@ import { createInterface } from "readline/promises";
 // package.json
 var package_default = {
   name: "@trycadence/cli",
-  version: "0.1.14-dev.0",
+  version: "0.1.18-dev.0",
   private: false,
   type: "module",
   bin: {
@@ -1554,12 +1554,15 @@ var workLogParentSelectors = ["last", "ticket-last", "session-last", "last-decis
 var changesetPrNoteSources = ["agent", "human", "system"];
 var hookScopes = ["repo", "global", "both"];
 var agentEventSources = ["codex", "claude-code", "opencode", "openrouter", "unknown"];
+var agentRunMemoryModes = ["checkpoint", "closeout"];
+var closeoutSessionActions = ["handoff", "end", "keep"];
 var defaultLeaseTtlSeconds = 15 * 60;
 var defaultCliApiBaseUrl = "https://cadenceapi.deploy.lvl8studios.com";
 var defaultCliWebBaseUrl = "https://cadence.deploy.lvl8studios.com";
 var defaultCheckpointThreshold = 3;
-var defaultCheckpointCooldownSeconds = 10 * 60;
+var defaultCheckpointCooldownSeconds = 0;
 var defaultCheckpointWorkerTimeoutMs = 10 * 60 * 1000;
+var defaultCheckpointWorkerMaxAttempts = 3;
 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;
@@ -1599,6 +1602,7 @@ var knownCommandPaths = [
   ["changesets", "notes", "put"],
   ["changesets", "notes", "apply"],
   ["agent-run", "ingest-stop"],
+  ["agent-run", "route"],
   ["agent-run", "checkpoint"],
   ["agent-run", "closeout"],
   ["agent-run", "sweep"],
@@ -2279,7 +2283,9 @@ 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 route --agent-session-key <key> --reason <missing_context|checkpoint_reroute|manual> [--event-file <path>] [--checkpoint-provider codex] [--checkpoint-model <model>] [--json]",
     "  cadence agent-run checkpoint --agent-session-key <key> [--reason <threshold|idle|manual>] [--event-file <path>] [--ticket <ticket-id>] [--session <session-id>] [--changeset <changeset-id>] [--checkpoint-provider codex] [--checkpoint-model <model>] [--log-kind <kind>] [--update-summary true|false] [--json]",
+    "  cadence agent-run closeout --agent-session-key <key> [--session-action handoff|end|keep] [--complete-ticket true|false] [--event-file <path>] [--ticket <ticket-id>] [--session <session-id>] [--changeset <changeset-id>] [--checkpoint-provider codex] [--checkpoint-model <model>] [--update-summary true|false] [--json]",
     "  cadence agent-run sweep [--idle-after-seconds <n>] [--dry-run true|false] [--json]",
     "  cadence agent-run doctor [--json]",
     "  cadence hooks install --provider codex [--scope global] [--command <command>] [--json]",
@@ -3085,15 +3091,6 @@ 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,
@@ -3248,12 +3245,59 @@ function readAgentLoopSessions(rawSessions) {
       ...recentTurns ? { recentTurns } : {},
       ...typeof record.lastCheckpointAt === "string" ? { lastCheckpointAt: record.lastCheckpointAt } : {},
       ...typeof record.lastCheckpointFingerprint === "string" ? { lastCheckpointFingerprint: record.lastCheckpointFingerprint } : {},
+      ...readAgentRunFingerprints(record.lastCheckpointFingerprints),
+      ...typeof record.lastCheckpointMode === "string" && agentRunMemoryModes.includes(record.lastCheckpointMode) ? { lastCheckpointMode: record.lastCheckpointMode } : {},
+      ...readAgentRunCoverage(record.lastCheckpointCoverage),
       ...typeof record.previousCheckpointSummary === "string" ? { previousCheckpointSummary: record.previousCheckpointSummary } : {},
+      ...typeof record.displayTitle === "string" ? { displayTitle: record.displayTitle } : {},
+      ...typeof record.displayTitleUpdatedAt === "string" ? { displayTitleUpdatedAt: record.displayTitleUpdatedAt } : {},
+      ...record.displayTitleSource === "route" ? { displayTitleSource: "route" } : {},
+      ...typeof record.displayTitleConfidence === "string" && checkpointConfidenceLevels.includes(record.displayTitleConfidence) ? { displayTitleConfidence: record.displayTitleConfidence } : {},
+      ...typeof record.displayTitleReason === "string" ? { displayTitleReason: record.displayTitleReason } : {},
       ...typeof record.lastCheckpointAuditFile === "string" ? { lastCheckpointAuditFile: record.lastCheckpointAuditFile } : {}
     };
   }
   return sessions;
 }
+function readAgentRunFingerprints(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const record = value;
+  const event = typeof record.event === "string" ? record.event : undefined;
+  const git = typeof record.git === "string" ? record.git : undefined;
+  const cadenceContext = typeof record.cadenceContext === "string" ? record.cadenceContext : undefined;
+  if (!event || !git || !cadenceContext) {
+    return {};
+  }
+  return {
+    lastCheckpointFingerprints: {
+      event,
+      git,
+      cadenceContext,
+      ...typeof record.verification === "string" ? { verification: record.verification } : {},
+      ...typeof record.coverageDebt === "string" ? { coverageDebt: record.coverageDebt } : {}
+    }
+  };
+}
+function readAgentRunCoverage(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  const record = value;
+  const coverage = {
+    outcome: record.outcome === true,
+    implementation: record.implementation === true,
+    decisions: record.decisions === true,
+    corrections: record.corrections === true,
+    verification: record.verification === true,
+    blockers: record.blockers === true,
+    scope: record.scope === true,
+    handoff: record.handoff === true,
+    hasDebt: record.hasDebt === true
+  };
+  return { lastCheckpointCoverage: coverage };
+}
 function readAgentSessionCadenceContext(record) {
   const value = record.cadenceContext;
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -3396,7 +3440,7 @@ function currentCliWorkerInvocation() {
     argsPrefix: []
   };
 }
-async function spawnAgentRunCheckpoint(args, options) {
+async function spawnAgentRunWorker(args, options) {
   const cwd = options.cwd ?? process.cwd();
   const invocation = currentCliWorkerInvocation();
   const env = {
@@ -3415,6 +3459,9 @@ async function spawnAgentRunCheckpoint(args, options) {
   });
   child.unref();
 }
+async function spawnAgentRunCheckpoint(args, options) {
+  await spawnAgentRunWorker(args, options);
+}
 function currentRecordTime(value, keys) {
   for (const key of keys) {
     const candidate = value[key];
@@ -3510,6 +3557,9 @@ function fingerprintForCheckpoint(event, options) {
   }));
 }
 function shouldSkipForCooldown(state, cooldownSeconds) {
+  if (cooldownSeconds <= 0) {
+    return false;
+  }
   if (!state.lastCheckpointAt) {
     return false;
   }
@@ -3737,6 +3787,43 @@ function parseCheckpointPlanSession(value) {
     ...reason ? { reason } : {}
   };
 }
+function cleanAgentSessionTitleText(value) {
+  const cleaned = value.replace(/\s+/g, " ").trim();
+  if (!cleaned) {
+    return;
+  }
+  const normalized = cleaned.toLowerCase();
+  const genericTitles = new Set(["agent session", "session", "work session", "cadence session", "current session"]);
+  if (genericTitles.has(normalized)) {
+    return;
+  }
+  return cleaned.length > 80 ? cleaned.slice(0, 77).trimEnd() + "..." : cleaned;
+}
+function agentSessionTitleString(record, key) {
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function parseAgentSessionTitle(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return;
+  }
+  const record = value;
+  const text = agentSessionTitleString(record, "text") ?? agentSessionTitleString(record, "title") ?? agentSessionTitleString(record, "label");
+  const cleanedText = text ? cleanAgentSessionTitleText(text) : undefined;
+  if (!cleanedText) {
+    return;
+  }
+  const confidenceValue = agentSessionTitleString(record, "confidence") ?? "medium";
+  if (!checkpointConfidenceLevels.includes(confidenceValue)) {
+    return;
+  }
+  const reason = agentSessionTitleString(record, "reason")?.replace(/\s+/g, " ").trim();
+  return {
+    text: cleanedText,
+    confidence: confidenceValue,
+    ...reason ? { reason: reason.length > 300 ? `${reason.slice(0, 297).trimEnd()}...` : reason } : {}
+  };
+}
 function parseCheckpointPlanFiles(value) {
   if (!Array.isArray(value)) {
     return [];
@@ -3756,9 +3843,6 @@ function parseCheckpointPlanFiles(value) {
     };
   });
 }
-function routeRequiresHighConfidence(route, session) {
-  return highAutonomyRouteActions.has(route.action) || session?.action === "complete_ticket";
-}
 function forceNeedsHuman(plan, reason) {
   return {
     ...plan,
@@ -3771,9 +3855,6 @@ function forceNeedsHuman(plan, 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,
@@ -3782,6 +3863,51 @@ function normalizeCheckpointPlan(plan) {
   }
   return plan;
 }
+function checkpointPlanWithRoute(plan, route, warning) {
+  return {
+    ...plan,
+    route,
+    ...route.action === "noop" ? { entries: [] } : {},
+    validationWarnings: warning ? [...plan.validationWarnings, warning] : plan.validationWarnings
+  };
+}
+function safeAutomaticRoutePlan(plan, hasCurrentContext, reason) {
+  return checkpointPlanWithRoute(plan, {
+    action: hasCurrentContext ? "current" : "noop",
+    confidence: plan.route.confidence,
+    reason
+  }, reason);
+}
+function routePlanAllowsLifecycle(plan) {
+  return checkpointRouteRequiresIntake(plan.route.action) && plan.route.confidence === "high";
+}
+function planWithCandidateSelection(original, selected, currentTicketId, candidateTicketIds) {
+  let nextPlan = selected;
+  if (nextPlan.route.action === "needs_human") {
+    nextPlan = safeAutomaticRoutePlan(nextPlan, Boolean(currentTicketId), nextPlan.route.reason ?? "Candidate routing was uncertain.");
+  } else if (checkpointRouteRequiresIntake(nextPlan.route.action) && nextPlan.route.confidence !== "high") {
+    nextPlan = safeAutomaticRoutePlan(nextPlan, Boolean(currentTicketId), "Candidate routing requires high confidence.");
+  } else if ((nextPlan.route.action === "intake_attach" || nextPlan.route.action === "switch_existing") && !nextPlan.route.targetTicketId) {
+    nextPlan = safeAutomaticRoutePlan(nextPlan, Boolean(currentTicketId), "Candidate routing to existing work requires a target ticket id.");
+  } else if ((nextPlan.route.action === "intake_attach" || nextPlan.route.action === "switch_existing") && nextPlan.route.targetTicketId && !candidateTicketIds.has(nextPlan.route.targetTicketId)) {
+    nextPlan = safeAutomaticRoutePlan(nextPlan, Boolean(currentTicketId), "Candidate routing selected a ticket outside the intake candidate list.");
+  } else if (nextPlan.route.action === "current" && !currentTicketId) {
+    nextPlan = checkpointPlanWithRoute(nextPlan, {
+      action: "noop",
+      confidence: nextPlan.route.confidence,
+      reason: nextPlan.route.reason ?? "No current Cadence context exists."
+    });
+  }
+  const summary = nextPlan.summary ?? original.summary;
+  return {
+    ...nextPlan,
+    ...summary ? { summary } : {},
+    ...nextPlan.sessionTitle ?? original.sessionTitle ? { sessionTitle: nextPlan.sessionTitle ?? original.sessionTitle } : {},
+    entries: nextPlan.entries.length ? nextPlan.entries : original.entries,
+    files: nextPlan.files.length ? nextPlan.files : original.files,
+    validationWarnings: [...original.validationWarnings, ...nextPlan.validationWarnings]
+  };
+}
 function parseCheckpointPlanRecord(record, rawText, fallbackKind) {
   if (!("route" in record)) {
     const legacy = parseCheckpointRecord(record, rawText, fallbackKind);
@@ -3805,12 +3931,14 @@ function parseCheckpointPlanRecord(record, rawText, fallbackKind) {
   const entries = Array.isArray(record.entries) ? record.entries.map(parseCheckpointPlanEntry) : [];
   const summary = checkpointPlanString(record, "summary");
   const summaryUpdate = parseCheckpointPlanSummaryUpdate(record.summaryUpdate ?? record.currentSummary);
+  const sessionTitle = parseAgentSessionTitle(record.sessionTitle ?? record.displayTitle);
   const session = parseCheckpointPlanSession(record.session);
   return normalizeCheckpointPlan({
     ...summary ? { summary } : {},
     route,
     entries,
     ...summaryUpdate ? { summaryUpdate } : {},
+    ...sessionTitle ? { sessionTitle } : {},
     ...session ? { session } : {},
     files: parseCheckpointPlanFiles(record.files),
     legacy: false,
@@ -3862,6 +3990,62 @@ function parseCheckpointPlanJson(raw, fallbackKind) {
 function checkpointRouteRequiresIntake(action) {
   return action === "intake_create" || action === "intake_attach" || action === "switch_existing";
 }
+function intakeCandidates(intake) {
+  if (!intake || typeof intake !== "object" || Array.isArray(intake)) {
+    return [];
+  }
+  const candidates = intake.candidates;
+  return Array.isArray(candidates) ? candidates.filter((candidate) => candidate && typeof candidate === "object" && !Array.isArray(candidate)) : [];
+}
+function intakeCandidateTicketId(candidate) {
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+    return;
+  }
+  const record = candidate;
+  const nestedTicket = record.ticket && typeof record.ticket === "object" && !Array.isArray(record.ticket) ? record.ticket : null;
+  const value = record.ticketId ?? nestedTicket?.id ?? record.id;
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function intakeCandidateTicketIds(intake) {
+  return new Set(intakeCandidates(intake).map(intakeCandidateTicketId).filter((id) => Boolean(id)));
+}
+function compactIntakeCandidate(candidate, index) {
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+    return { index };
+  }
+  const record = candidate;
+  const ticket = record.ticket && typeof record.ticket === "object" && !Array.isArray(record.ticket) ? record.ticket : {};
+  const ticketId = intakeCandidateTicketId(candidate);
+  const title = record.title ?? ticket.title;
+  const status = record.status ?? ticket.status;
+  const summary = record.summary ?? ticket.currentSummary ?? ticket.summary;
+  return {
+    index,
+    ...ticketId ? { ticketId } : {},
+    ...typeof title === "string" ? { title: truncateText(title, 200) } : {},
+    ...typeof status === "string" ? { status } : {},
+    ...typeof summary === "string" ? { summary: truncateText(summary, 600) } : {},
+    ...typeof record.classification === "string" ? { classification: record.classification } : {},
+    ...typeof record.reason === "string" ? { reason: truncateText(record.reason, 300) } : {},
+    ...typeof record.score === "number" ? { score: record.score } : {},
+    ...typeof record.confidence === "string" ? { confidence: record.confidence } : {}
+  };
+}
+function compactIntakeResultForRouteSelection(intake) {
+  if (!intake || typeof intake !== "object" || Array.isArray(intake)) {
+    return null;
+  }
+  const record = intake;
+  return {
+    ...typeof record.id === "string" ? { id: record.id } : {},
+    ...typeof record.status === "string" ? { status: record.status } : {},
+    ...typeof record.classification === "string" ? { classification: record.classification } : {},
+    ...typeof record.recommendedAction === "string" ? { recommendedAction: record.recommendedAction } : {},
+    ...typeof record.attachedTicketId === "string" ? { attachedTicketId: record.attachedTicketId } : {},
+    ...typeof record.convertedTicketId === "string" ? { convertedTicketId: record.convertedTicketId } : {},
+    candidates: intakeCandidates(intake).map(compactIntakeCandidate)
+  };
+}
 function checkpointPlanCompletionAllowed(event, summary) {
   const text = [
     summary,
@@ -3977,23 +4161,39 @@ function buildCheckpointTokenAccounting(event, prompt, tokenUsage) {
 function buildCheckpointPrompt(input) {
   const recentTurns = checkpointRecentTurns(input.event);
   const recentTurnsText = recentTurns.length ? formatCheckpointRecentTurns(recentTurns) : "";
+  const modeInstructions = input.mode === "closeout" ? [
+    "Mode: closeout. Produce final session memory, not an interim pulse.",
+    "Closeout should cover the completed work segment: outcome, reviewable implementation actions, decisions/corrections, verification, blockers/follow-ups, scope or attribution notes, and handoff when needed.",
+    "Write the minimum entries needed for coverage. Target 2-6 entries; avoid more than 8 by merging related facts or writing one concise session catch-up entry.",
+    "Use session.action handoff, end, or keep when appropriate. Use complete_ticket only when explicit completion evidence is present."
+  ] : [
+    "Mode: checkpoint. Produce sparse incremental memory for an active session, not a full-session closeout.",
+    "Checkpoint should commonly return route.action noop with entries [] when there is nothing durable to record.",
+    "Target 0-2 entries. Only exceed that for a blocker or failed verification. Do not repeat unchanged intent, repeated dirty workspace warnings, or routine process actions."
+  ];
   return [
-    "You are generating a compact Cadence dogfood operation plan for a hook-spawned checkpoint worker.",
+    `You are generating a compact Cadence dogfood operation plan for an agent-run ${input.mode} worker.`,
     "The model judges; the Cadence CLI validates and executes. Return JSON only. Do not call tools to mutate Cadence yourself.",
     "Preserve durable ticket purpose. Identify user intent, changed intent, corrections, decisions, rationale, implementation actions, verification, blockers, and useful notes.",
     "Do not include raw diffs, raw transcripts, terminal logs, tool streams, secrets, file contents, or model reasoning in server-bound fields.",
-    'Return this sparse JSON shape: {"summary":"short checkpoint summary","route":{"action":"current|noop|intake_create|intake_attach|switch_existing|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"}]}',
+    'Return this sparse JSON shape: {"summary":"short checkpoint summary","route":{"action":"current|noop|intake_create|intake_attach|switch_existing","confidence":"low|medium|high","reason":"short reason","request":"natural language work request when intake is needed","targetTicketId":"optional existing ticket id"},"entries":[{"kind":"intent|decision|rationale|action|verification|blocker|correction|note","summary":"short entry summary","body":"safe Cadence work-log body","under":"optional: last, ticket-last, session-last, last-decision, last-correction, last-action, or entry UUID"}],"summaryUpdate":{"update":false,"value":null,"reason":"short reason"},"session":{"action":"keep|handoff|end|complete_ticket","summary":"optional handoff or completion summary","reason":"short reason"},"files":[{"path":"relative/path.ts","kind":"added|modified|deleted|renamed|unknown"}]}',
     "Keep output sparse: omit summaryUpdate, session, and files unless needed. Use route.action noop with entries [] for filler, acknowledgements, or other turns with nothing durable to record.",
-    "Use route.action current for the same ticket. Use 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.",
+    "Use route.action current for the same ticket. Use noop when routing is ambiguous or there is nothing durable to record. Use intake_create, intake_attach, or switch_existing only when recent work clearly belongs somewhere else; the CLI will delegate those actions to agent-run route.",
     "Set route.confidence high only when the recent user/assistant context makes the route and lifecycle action clear. Lifecycle mutations require high confidence.",
     "Use note only as a last-resort context kind. Prefer intent, decision, rationale, action, verification, correction, or blocker when those fit.",
     "Each entry body should be concise narrative, not a transcript. Keep each entry under 800 characters and avoid duplicating the same fact across entries.",
     "Set summaryUpdate.update true only when the durable current work summary is missing or misleading; otherwise omit summaryUpdate or leave update false.",
     "Use session.action complete_ticket only when the context indicates completion, merge, push/PR finalization, or explicit user completion intent. Use handoff/end only when the current session should close.",
+    ...modeInstructions,
     "",
     `Ticket: ${input.ticketId}`,
     input.sessionId ? `Session: ${input.sessionId}` : "",
     input.changesetId ? `ChangeSet: ${input.changesetId}` : "",
+    input.currentWorkSummary ? `Current Work Summary:
+${truncateText(input.currentWorkSummary, 1200)}` : "",
+    input.recentWorkLog ? `Recent high-signal Work Log entries:
+${truncateText(input.recentWorkLog, 3000)}` : "",
+    input.coverage ? `Prior coverage: ${JSON.stringify(input.coverage)}` : "",
     `Agent event: ${input.event.source}/${input.event.event}`,
     input.previousCheckpointSummary ? `Previous checkpoint summary: ${input.previousCheckpointSummary}` : "",
     recentTurnsText ? `Recent user/assistant turns (most recent 3, local checkpoint context only):
@@ -4008,6 +4208,327 @@ ${truncateText(input.changedFiles, 2000)}` : "Changed files: unavailable"
   ].filter(Boolean).join(`
 `);
 }
+function buildRoutePrompt(input) {
+  const recentTurns = checkpointRecentTurns(input.event);
+  const recentTurnsText = recentTurns.length ? formatCheckpointRecentTurns(recentTurns) : "";
+  const contextText = input.savedContext?.ticketId ? `Saved Cadence context: ticket ${input.savedContext.ticketId}${input.savedContext.sessionId ? `, session ${input.savedContext.sessionId}` : ""}${input.savedContext.changesetId ? `, ChangeSet ${input.savedContext.changesetId}` : ""}` : input.currentContext?.ticketId ? `No saved agent-session context. Current active Cadence context: ticket ${input.currentContext.ticketId}${input.currentContext.sessionId ? `, session ${input.currentContext.sessionId}` : ""}${input.currentContext.changesetId ? `, ChangeSet ${input.currentContext.changesetId}` : ""}` : "No saved agent-session context and no active Cadence context was found.";
+  return [
+    "You are generating a compact Cadence dogfood routing plan for an agent-run worker.",
+    "The model judges; the Cadence CLI validates and executes. Return JSON only. Do not call tools to mutate Cadence yourself.",
+    "Decide where this agent session belongs before checkpoint memory is written.",
+    "Do not include raw diffs, raw transcripts, terminal logs, tool streams, secrets, file contents, or model reasoning in server-bound fields.",
+    'Return this sparse JSON shape: {"summary":"short routing summary","sessionTitle":{"text":"short GUI session title","confidence":"low|medium|high","reason":"why this title names the routed focus"},"route":{"action":"current|noop|intake_create|intake_attach|switch_existing","confidence":"low|medium|high","reason":"short reason","request":"natural language intake request when intake is needed","targetTicketId":"optional existing ticket id"},"entries":[{"kind":"intent|decision|rationale|action|verification|blocker|correction|note","summary":"short entry summary","body":"safe Cadence work-log body"}],"files":[{"path":"relative/path.ts","kind":"added|modified|deleted|renamed|unknown"}]}',
+    "Generate sessionTitle only when the routed focus is durable enough to name a GUI row. Omit it for noop/filler. Keep it under 80 characters and do not reuse the latest checkpoint summary as the title.",
+    "Use noop for filler, acknowledgements, setup chatter, or anything not durable enough for Cadence.",
+    "Use current only when an existing Cadence context clearly fits the recent work.",
+    "Use intake_create for a clearly durable new task without a good existing ticket.",
+    "Use intake_attach or switch_existing only when a specific targetTicketId is clearly the correct ticket.",
+    "Set confidence high only when the route is clear. Low or medium confidence lifecycle actions will be ignored by the CLI.",
+    "Use note only as a last-resort context kind. Prefer intent for new routed work.",
+    "Each entry body should be concise narrative, not a transcript. Keep each entry under 800 characters.",
+    "",
+    `Route reason: ${input.reason ?? "manual"}`,
+    contextText,
+    `Agent event: ${input.event.source}/${input.event.event}`,
+    input.previousCheckpointSummary ? `Previous checkpoint summary: ${input.previousCheckpointSummary}` : "",
+    recentTurnsText ? `Recent user/assistant turns (most recent 3, local routing context only):
+${recentTurnsText}` : input.event.lastAssistantMessage ? `Last assistant message:
+${truncateText(input.event.lastAssistantMessage, 3000)}` : "Recent turns: unavailable",
+    input.gitStatus ? `Git status --short:
+${truncateText(input.gitStatus, 2000)}` : "Git status --short: clean or unavailable",
+    input.gitDiffStat ? `Git diff --stat origin/dev...:
+${truncateText(input.gitDiffStat, 2000)}` : "Git diff stat: unavailable",
+    input.changedFiles ? `Changed files:
+${truncateText(input.changedFiles, 2000)}` : "Changed files: unavailable"
+  ].filter(Boolean).join(`
+`);
+}
+function buildRouteCandidatePrompt(input) {
+  const recentTurns = checkpointRecentTurns(input.event);
+  const recentTurnsText = recentTurns.length ? formatCheckpointRecentTurns(recentTurns) : "";
+  const intake = compactIntakeResultForRouteSelection(input.intakeResult);
+  const contextText = input.savedContext?.ticketId ? `Saved Cadence context: ticket ${input.savedContext.ticketId}${input.savedContext.sessionId ? `, session ${input.savedContext.sessionId}` : ""}${input.savedContext.changesetId ? `, ChangeSet ${input.savedContext.changesetId}` : ""}` : input.currentContext?.ticketId ? `No saved agent-session context. Current active Cadence context: ticket ${input.currentContext.ticketId}${input.currentContext.sessionId ? `, session ${input.currentContext.sessionId}` : ""}${input.currentContext.changesetId ? `, ChangeSet ${input.currentContext.changesetId}` : ""}` : "No saved agent-session context and no active Cadence context was found.";
+  return [
+    "You are resolving Cadence agent-run routing after intake returned possible existing work.",
+    "Intake is retrieval, not the final decision. The model judges; the Cadence CLI validates and executes. Return JSON only.",
+    "Choose whether this agent session should create a new ticket, attach/switch to one concrete candidate ticket, keep the current context, or no-op.",
+    "Use intake_create when the recent request is durable and the candidates are weak, adjacent, completed, or not concrete matches.",
+    "Use intake_attach or switch_existing only when one candidate ticket is clearly the same work. You must include targetTicketId from the candidate list.",
+    "Use current only when the saved/current Cadence context clearly fits the recent work.",
+    "Use noop only for filler or if the work is not durable enough for Cadence.",
+    "Do not include raw transcripts, raw diffs, terminal logs, tool streams, secrets, file contents, or model reasoning in server-bound fields.",
+    'Return this sparse JSON shape: {"summary":"short routing summary","sessionTitle":{"text":"short GUI session title","confidence":"low|medium|high","reason":"why this title names the selected routed focus"},"route":{"action":"current|noop|intake_create|intake_attach|switch_existing","confidence":"low|medium|high","reason":"short reason","request":"natural language intake request when creating","targetTicketId":"required for attach/switch"},"entries":[{"kind":"intent|decision|rationale|action|verification|blocker|correction|note","summary":"short entry summary","body":"safe Cadence work-log body"}],"files":[{"path":"relative/path.ts","kind":"added|modified|deleted|renamed|unknown"}]}',
+    "The final candidate plan owns sessionTitle. Generate it only for the selected durable focus, keep it under 80 characters, and do not reuse the latest checkpoint summary as the title.",
+    "Prefer preserving the initial plan's entries unless they are wrong for the selected ticket.",
+    "",
+    contextText,
+    `Initial route plan:
+${truncateText(JSON.stringify(input.initialPlan), 4000)}`,
+    `Intake result and candidates:
+${truncateText(JSON.stringify(intake), 6000)}`,
+    recentTurnsText ? `Recent user/assistant turns (most recent 3, local routing context only):
+${recentTurnsText}` : input.event.lastAssistantMessage ? `Last assistant message:
+${truncateText(input.event.lastAssistantMessage, 3000)}` : "Recent turns: unavailable"
+  ].filter(Boolean).join(`
+`);
+}
+function agentRunFingerprint(value) {
+  return stableHash(JSON.stringify(value));
+}
+function buildAgentRunFingerprints(input) {
+  return {
+    event: agentRunFingerprint({
+      source: input.event.source,
+      event: input.event.event,
+      agentSessionKey: input.event.agentSessionKey,
+      agentSessionId: input.event.agentSessionId,
+      threadId: input.event.threadId,
+      turnId: input.event.turnId,
+      lastAssistantMessage: input.event.lastAssistantMessage,
+      recentTurns: input.event.recentTurns,
+      payloadKeys: input.event.payloadKeys
+    }),
+    git: agentRunFingerprint({
+      status: input.gitStatus,
+      diffStat: input.gitDiffStat,
+      changedFiles: input.changedFiles
+    }),
+    cadenceContext: agentRunFingerprint({
+      ticketId: input.ticketId,
+      sessionId: input.sessionId,
+      changesetId: input.changesetId
+    }),
+    ...input.coverage?.hasDebt ? { coverageDebt: agentRunFingerprint(input.coverage) } : {}
+  };
+}
+function fingerprintsEqual(left, right) {
+  return Boolean(left && left.event === right.event && left.git === right.git && left.cadenceContext === right.cadenceContext && left.verification === right.verification && left.coverageDebt === right.coverageDebt);
+}
+function checkpointReasonBypassesFingerprintGate(reason) {
+  return reason === "manual" || reason === "idle" || reason === "ticket_switch" || reason === "closeout";
+}
+function entryText(entry) {
+  return `${entry.summary ?? ""}
+${entry.body}`.toLowerCase();
+}
+function entryReductionSummary(entry) {
+  return truncateText(entry.summary ?? checkpointEntrySummary(entry.body), 120);
+}
+function isRepeatedScopeNote(entry) {
+  const text = entryText(entry);
+  return entry.kind === "note" && (text.includes("dirty workspace") || text.includes("dirty files") || text.includes("unattributed"));
+}
+function isRepeatedNoVerificationNote(entry) {
+  const text = entryText(entry);
+  return entry.kind === "verification" && text.includes("no fresh") && (text.includes("test") || text.includes("verification"));
+}
+function isUnchangedIntent(entry) {
+  const text = entryText(entry);
+  return entry.kind === "intent" && (text.includes("remain") || text.includes("still")) && text.includes("active");
+}
+function isProcessOnlyAction(entry) {
+  if (entry.kind !== "action") {
+    return false;
+  }
+  const text = entryText(entry);
+  const processSignals = ["read ", "inspected", "looked at", "ran git status", "gathered context", "paused", "discussed", "answered"];
+  const reviewableSignals = [
+    "added",
+    "implemented",
+    "updated",
+    "changed",
+    "removed",
+    "refactored",
+    "fixed",
+    "moved",
+    "persisted",
+    "configured",
+    "wrote",
+    "split"
+  ];
+  return processSignals.some((signal) => text.includes(signal)) && !reviewableSignals.some((signal) => text.includes(signal));
+}
+function entryDedupeKey(entry) {
+  if (isRepeatedScopeNote(entry)) {
+    return "scope-note";
+  }
+  if (isRepeatedNoVerificationNote(entry)) {
+    return "no-verification";
+  }
+  if (isUnchangedIntent(entry)) {
+    return "unchanged-intent";
+  }
+  return `${entry.kind}:${entry.summary ?? checkpointEntrySummary(entry.body)}`.toLowerCase();
+}
+function mergeDecisionRationaleEntries(entries) {
+  const merged = [];
+  const records = [];
+  for (let index = 0;index < entries.length; index += 1) {
+    const entry = entries[index];
+    const next = entries[index + 1];
+    if (entry.kind === "decision" && next?.kind === "rationale") {
+      merged.push({
+        ...entry,
+        body: truncateText(`${entry.body}
+
+Rationale: ${next.body.replace(/^Rationale:\s*/i, "")}`, checkpointServerTextLimit)
+      });
+      records.push({
+        summary: entryReductionSummary(next),
+        reason: "merged_adjacent_decision_rationale"
+      });
+      index += 1;
+      continue;
+    }
+    merged.push(entry);
+  }
+  return { entries: merged, records };
+}
+function checkpointAllowsExtraEntries(entries) {
+  return entries.some((entry) => entry.kind === "blocker" || entry.kind === "verification" && /\b(fail|failed|failing|error|blocked)\b/i.test(entry.body));
+}
+function reduceCheckpointEntries(entries, mode) {
+  const dropped = [];
+  const seen = new Set;
+  const filtered = [];
+  for (const entry of entries) {
+    if (isProcessOnlyAction(entry)) {
+      dropped.push({ summary: entryReductionSummary(entry), reason: "process_only_action" });
+      continue;
+    }
+    const dedupeKey = entryDedupeKey(entry);
+    if (seen.has(dedupeKey)) {
+      dropped.push({ summary: entryReductionSummary(entry), reason: "duplicate_entry" });
+      continue;
+    }
+    seen.add(dedupeKey);
+    filtered.push(entry);
+  }
+  const merged = mergeDecisionRationaleEntries(filtered);
+  const maxEntries = mode === "closeout" ? 8 : checkpointAllowsExtraEntries(merged.entries) ? 4 : 3;
+  const capped = merged.entries.length > maxEntries;
+  const kept = capped ? merged.entries.slice(0, maxEntries) : merged.entries;
+  for (const entry of merged.entries.slice(maxEntries)) {
+    dropped.push({ summary: entryReductionSummary(entry), reason: "entry_budget" });
+  }
+  return {
+    entries: kept,
+    reduction: {
+      mode,
+      originalCount: entries.length,
+      keptCount: kept.length,
+      dropped,
+      merged: merged.records,
+      capped
+    }
+  };
+}
+function buildAgentRunCoverage(plan, mode) {
+  const entries = plan.entries;
+  const bodyText = [plan.summary ?? "", plan.session?.summary ?? "", ...entries.map((entry) => `${entry.summary ?? ""} ${entry.body}`)].join(`
+`).toLowerCase();
+  const outcome = Boolean(plan.summary || plan.session?.summary);
+  const implementation = entries.some((entry) => entry.kind === "action");
+  const decisions = entries.some((entry) => entry.kind === "decision" || entry.kind === "rationale");
+  const corrections = entries.some((entry) => entry.kind === "correction");
+  const verification = entries.some((entry) => entry.kind === "verification");
+  const blockers = entries.some((entry) => entry.kind === "blocker");
+  const scope = /\b(scope|attribut|dirty workspace|dirty files|unassigned|unattributed)\b/.test(bodyText);
+  const handoff = mode === "closeout" && Boolean(plan.session && plan.session.action !== "keep");
+  const hasDebt = mode === "closeout" && (!outcome || !implementation || !verification || !handoff);
+  return {
+    outcome,
+    implementation,
+    decisions,
+    corrections,
+    verification,
+    blockers,
+    scope,
+    handoff,
+    hasDebt
+  };
+}
+function applyCloseoutSessionDefaults(plan, sessionAction, completeTicket) {
+  const requestedAction = completeTicket ? "complete_ticket" : sessionAction;
+  const session = plan.session && (completeTicket || plan.session.action !== "complete_ticket") ? plan.session : {
+    action: requestedAction,
+    ...plan.summary ? { summary: plan.summary } : {},
+    reason: "Closeout defaults to ending or handing off the active session."
+  };
+  if (!completeTicket && session.action === "complete_ticket") {
+    return {
+      ...plan,
+      session: {
+        ...session,
+        action: sessionAction,
+        reason: "Ticket completion was not requested for this closeout."
+      }
+    };
+  }
+  return {
+    ...plan,
+    session
+  };
+}
+function parseCloseoutSessionAction(value) {
+  if (!value) {
+    return "handoff";
+  }
+  if (!closeoutSessionActions.includes(value)) {
+    throw new CliError("CLI_USAGE", "--session-action must be one of handoff, end, or keep.");
+  }
+  return value;
+}
+function checkpointModeForCommand(parsed) {
+  return parsed.command.name === "agent-run.closeout" ? "closeout" : "checkpoint";
+}
+function formatCloseoutWorkLogEvents(events) {
+  if (!Array.isArray(events)) {
+    return;
+  }
+  const entries = events.filter((event) => event && typeof event === "object").map((event) => {
+    const record = event;
+    const payload = record.payload && typeof record.payload === "object" && !Array.isArray(record.payload) ? record.payload : {};
+    const type = typeof record.type === "string" ? record.type : undefined;
+    const kind = typeof payload.entryKind === "string" ? payload.entryKind : undefined;
+    const summary = typeof payload.summary === "string" ? payload.summary : undefined;
+    const body = typeof payload.body === "string" ? payload.body : undefined;
+    if (type !== "ticket.work_log_appended" || !summary && !body) {
+      return;
+    }
+    return `- ${kind ?? "note"}: ${truncateText(summary ?? body ?? "", 180)}${body && summary ? ` \u2014 ${truncateText(body, 300)}` : ""}`;
+  }).filter((entry) => Boolean(entry)).slice(-12);
+  return entries.length ? entries.join(`
+`) : undefined;
+}
+async function readCloseoutPromptContext(input) {
+  let currentWorkSummary;
+  let recentWorkLog;
+  try {
+    const ticket = await input.client.tickets.get({
+      projectId: input.projectId,
+      ticketId: input.ticketId
+    });
+    if (ticket && typeof ticket === "object" && "currentSummary" in ticket && typeof ticket.currentSummary === "string") {
+      currentWorkSummary = ticket.currentSummary;
+    }
+  } catch {}
+  try {
+    const events = await input.client.events.list({
+      projectId: input.projectId,
+      filters: {
+        ticketId: input.ticketId,
+        ...input.sessionId ? { sessionId: input.sessionId } : {},
+        limit: 50
+      }
+    });
+    recentWorkLog = formatCloseoutWorkLogEvents(events);
+  } catch {}
+  return {
+    ...currentWorkSummary ? { currentWorkSummary } : {},
+    ...recentWorkLog ? { recentWorkLog } : {}
+  };
+}
 async function findRepoRoot(cwd) {
   const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
     cwd,
@@ -4246,6 +4767,8 @@ async function runAgentRunCommand(parsed, options) {
   switch (parsed.command.name) {
     case "agent-run.ingest-stop":
       return await runAgentRunIngestStop(parsed, options, config, meta);
+    case "agent-run.route":
+      return await runAgentRunRoute(parsed, options, config, meta);
     case "agent-run.checkpoint":
     case "agent-run.closeout":
       return await runAgentRunCheckpoint(parsed, options, config, meta);
@@ -4335,11 +4858,14 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
   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 savedCadenceContext = existingSession?.cadenceContext;
+  let cadenceContext = savedCadenceContext;
+  if (savedCadenceContext?.ticketId) {
+    try {
+      const client = await createClient(config, options);
+      cadenceContext = await readCurrentCadenceContext(client, projectId) ?? cadenceContext;
+    } catch {}
+  }
   const observedSession = {
     ...clearAgentSessionReason(existingSession ?? {
       source: normalized.source,
@@ -4364,6 +4890,124 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
       [normalized.agentSessionKey]: observedSession
     }
   };
+  if (duplicateTurn) {
+    await writeAgentLoopState(parsed, options, countedState);
+    const data2 = {
+      action: "updated",
+      reason: "duplicate_turn",
+      agentSessionKey: normalized.agentSessionKey,
+      stopCount: nextCount,
+      threshold
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  if (!savedCadenceContext?.ticketId) {
+    const eventFile2 = await writeAgentEventFile(parsed, options, normalized);
+    const lockPath2 = agentLoopLockPath(parsed, options, normalized.agentSessionKey);
+    const workerArgs2 = [
+      "agent-run",
+      "route",
+      "--agent-session-key",
+      normalized.agentSessionKey,
+      "--reason",
+      "missing_context",
+      "--event-file",
+      eventFile2,
+      "--lock",
+      lockPath2,
+      ...parsed.flags.project ? ["--project", parsed.flags.project] : [],
+      ...parsed.flags.server ? ["--server", parsed.flags.server] : []
+    ];
+    if (dryRun) {
+      await writeAgentLoopState(parsed, options, {
+        ...state,
+        sessions: {
+          ...state.sessions,
+          [normalized.agentSessionKey]: {
+            ...observedSession,
+            lastAction: "would_route",
+            lastEventFile: eventFile2
+          }
+        }
+      });
+      const data3 = {
+        action: "would_route",
+        agentSessionKey: normalized.agentSessionKey,
+        eventFile: eventFile2,
+        workerArgs: workerArgs2
+      };
+      return {
+        stdout: parsed.flags.json ? formatJson(successEnvelope(data3, meta)) : `${JSON.stringify(data3, null, 2)}
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    const lock2 = await acquireAgentLoopLock(parsed, options, normalized.agentSessionKey);
+    if (!lock2.acquired) {
+      await writeAgentLoopState(parsed, options, {
+        ...state,
+        sessions: {
+          ...state.sessions,
+          [normalized.agentSessionKey]: {
+            ...observedSession,
+            lastAction: "skipped",
+            lastReason: "lock_held"
+          }
+        }
+      });
+      const data3 = {
+        action: "skipped",
+        reason: "lock_held",
+        lockPath: lock2.lockPath,
+        agentSessionKey: normalized.agentSessionKey
+      };
+      return {
+        stdout: parsed.flags.json ? formatJson(successEnvelope(data3, meta)) : `${JSON.stringify(data3, null, 2)}
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    try {
+      await spawnAgentRunWorker(workerArgs2, options);
+    } catch (error) {
+      await releaseAgentLoopLock(lock2.lockPath);
+      throw error;
+    }
+    await writeAgentLoopState(parsed, options, {
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [normalized.agentSessionKey]: {
+          ...observedSession,
+          stopCount: 0,
+          threshold: defaultCheckpointThresholdValue(),
+          lastAction: "route_spawned",
+          lastEventFile: eventFile2,
+          lastCheckpointAt: new Date().toISOString(),
+          lastCheckpointFingerprint: fingerprintForCheckpoint(normalized, options)
+        }
+      }
+    });
+    const data2 = {
+      action: "route_spawned",
+      agentSessionKey: normalized.agentSessionKey,
+      eventFile: eventFile2,
+      lockPath: lock2.lockPath
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
   if (nextCount < threshold) {
     await writeAgentLoopState(parsed, options, countedState);
     const data2 = {
@@ -4537,9 +5181,450 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
     exitCode: 0
   };
 }
-async function runAgentRunCheckpoint(parsed, options, config, meta) {
-  const projectId = requireProjectId(config);
-  const client = await createClient(config, options);
+function objectStringId(value) {
+  return value && typeof value === "object" && "id" in value && typeof value.id === "string" ? value.id : undefined;
+}
+function objectStringTitle(value) {
+  return value && typeof value === "object" && "title" in value && typeof value.title === "string" ? cleanAgentSessionTitleText(value.title) : undefined;
+}
+function routeActionAllowsDisplayTitle(action, plan) {
+  return action === "routed" || action === "switched" || action === "current" && plan.route.confidence === "high";
+}
+function routeDisplayTitle(action, plan, selectedTicket) {
+  if (!routeActionAllowsDisplayTitle(action, plan)) {
+    return;
+  }
+  const fallbackTitle = objectStringTitle(selectedTicket);
+  const text = plan.sessionTitle?.text ?? fallbackTitle;
+  if (!text) {
+    return;
+  }
+  return {
+    text,
+    confidence: plan.sessionTitle?.confidence ?? plan.route.confidence,
+    reason: plan.sessionTitle?.reason ?? plan.route.reason ?? (fallbackTitle ? "Recent route selected this ticket." : undefined)
+  };
+}
+async function runAgentRunRoute(parsed, options, config, meta) {
+  const projectId = requireProjectId(config);
+  const client = await createClient(config, options);
+  const agentSessionKeyValue = requireOption(parsed, "agent-session-key");
+  const state = await readAgentLoopState(parsed, options);
+  const sessionState = state.sessions[agentSessionKeyValue];
+  if (!sessionState) {
+    throw new CliError("AGENT_RUN_SESSION_NOT_FOUND", "No local agent-run session state exists for --agent-session-key.", {
+      agentSessionKey: agentSessionKeyValue
+    });
+  }
+  const savedContext = sessionState.cadenceContext;
+  const currentContext = savedContext?.ticketId ? undefined : await readCurrentCadenceContext(client, projectId);
+  const eventFile = parsed.options["event-file"] ?? sessionState.lastEventFile;
+  const event = eventFile ? tryParseJsonObject(await readFile(eventFile, "utf8"), eventFile) : synthesizeAgentEventFromSession(agentSessionKeyValue, sessionState, options);
+  const checkpointSettings = await resolveCheckpointSettings(parsed, options);
+  const gitStatus = gitOutput(["status", "--short"], options);
+  const gitDiffStat = gitOutput(["diff", "--stat", "origin/dev..."], options);
+  const changedFiles = gitOutput(["diff", "--name-only", "origin/dev..."], options);
+  const prompt = buildRoutePrompt({
+    event,
+    ...parsed.options.reason ? { reason: parsed.options.reason } : {},
+    ...savedContext ? { savedContext } : {},
+    ...currentContext ? { currentContext } : {},
+    gitStatus,
+    gitDiffStat,
+    changedFiles,
+    ...sessionState.previousCheckpointSummary ? { previousCheckpointSummary: sessionState.previousCheckpointSummary } : {}
+  });
+  const promptTokenAccounting = buildCheckpointTokenAccounting(event, prompt, undefined);
+  const dryRun = parseBooleanOption(parsed.options["dry-run"], false);
+  const lockPath = parsed.options.lock;
+  if (dryRun) {
+    const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
+      version: 1,
+      mode: "route",
+      action: "would_route",
+      createdAt: new Date().toISOString(),
+      localOnly: true,
+      localOnlyReason: "Raw hook context and route prompts stay on this machine and are not uploaded to Cadence.",
+      agentSessionKey: agentSessionKeyValue,
+      ...savedContext?.ticketId ? { ticketId: savedContext.ticketId } : currentContext?.ticketId ? { ticketId: currentContext.ticketId } : {},
+      ...eventFile ? { eventFile } : {},
+      event,
+      prompt,
+      checkpointSettings,
+      tokenAccounting: promptTokenAccounting,
+      cadenceWrites: []
+    });
+    const data = {
+      action: "would_route",
+      prompt,
+      auditFile,
+      agentSessionKey: agentSessionKeyValue
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  try {
+    const codexCommand = parsed.options["codex-command"] ?? "codex";
+    const codexCwd = options.cwd ?? process.cwd();
+    const runRouteWorker = (workerPrompt, failureMessage) => {
+      const codexStartedAtMs = Date.now();
+      const codexArgs = [
+        "exec",
+        ...checkpointSettings.model ? ["-m", checkpointSettings.model] : [],
+        "--disable",
+        "hooks",
+        "--sandbox",
+        "read-only",
+        "-C",
+        codexCwd,
+        workerPrompt
+      ];
+      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 tokenAccounting2 = buildCheckpointTokenAccounting(event, workerPrompt, codexSessionTranscript?.tokenUsage);
+      if (codex.status !== 0 || codex.error) {
+        throw new CliError("AGENT_RUN_ROUTE_FAILED", failureMessage, {
+          status: codex.status,
+          stderr: truncateText(codex.stderr, 2000),
+          error: codex.error?.message
+        });
+      }
+      return { codex, codexSessionTranscript, tokenAccounting: tokenAccounting2 };
+    };
+    const initialRouteWorker = runRouteWorker(prompt, "Codex route generation failed.");
+    let routePlan = parseCheckpointPlanJson(initialRouteWorker.codex.stdout, "intent");
+    const currentTicketId = savedContext?.ticketId ?? currentContext?.ticketId;
+    const currentSessionId = savedContext?.sessionId ?? currentContext?.sessionId;
+    const currentChangesetId = savedContext?.changesetId ?? currentContext?.changesetId;
+    if (routePlan.route.action === "needs_human") {
+      routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), routePlan.route.reason ?? "Route was uncertain.");
+    } else if (checkpointRouteRequiresIntake(routePlan.route.action) && routePlan.route.confidence !== "high") {
+      routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), "Automatic routing requires high confidence.");
+    } else if ((routePlan.route.action === "intake_attach" || routePlan.route.action === "switch_existing") && !routePlan.route.targetTicketId) {
+      routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), "Automatic routing to existing work requires a target ticket id.");
+    } else if (routePlan.route.action === "current" && !currentTicketId) {
+      routePlan = checkpointPlanWithRoute(routePlan, {
+        action: "noop",
+        confidence: routePlan.route.confidence,
+        reason: routePlan.route.reason ?? "No current Cadence context exists."
+      });
+    }
+    const cadenceWrites = [];
+    const lifecycleOperations = [];
+    let targetTicketId = currentTicketId;
+    let targetSessionId = currentSessionId;
+    let targetChangesetId = currentChangesetId;
+    let intakeResult;
+    let selectedTicket;
+    let summary = routePlan.summary ?? routePlan.entries[0]?.summary ?? routePlan.route.reason ?? "Agent run route";
+    let tokenAccounting = initialRouteWorker.tokenAccounting;
+    const modelAudit = {
+      provider: checkpointSettings.provider,
+      command: codexCommand,
+      ...checkpointSettings.model ? { model: checkpointSettings.model } : {},
+      status: initialRouteWorker.codex.status,
+      stdout: initialRouteWorker.codex.stdout.trim(),
+      stderr: truncateText(initialRouteWorker.codex.stderr.trim(), 2000),
+      tokenAccounting,
+      ...initialRouteWorker.codexSessionTranscript?.tokenUsage ? { tokenUsage: initialRouteWorker.codexSessionTranscript.tokenUsage } : {},
+      ...initialRouteWorker.codexSessionTranscript ? { sessionTranscript: initialRouteWorker.codexSessionTranscript } : {}
+    };
+    const finishRoute = async (action, reason) => {
+      const checkedAt = new Date().toISOString();
+      const displayTitle = routeDisplayTitle(action, routePlan, selectedTicket);
+      const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
+        version: 1,
+        mode: "route",
+        action,
+        createdAt: checkedAt,
+        localOnly: true,
+        localOnlyReason: action === "noop" || action === "current" ? "Raw hook context, route prompts, and model output stay on this machine; no Cadence writes were needed." : "Raw hook context, route prompts, and model output stay on this machine; Cadence receives only the structured writes listed here.",
+        agentSessionKey: agentSessionKeyValue,
+        ...targetTicketId ? { ticketId: targetTicketId } : {},
+        ...targetSessionId ? { sessionId: targetSessionId } : {},
+        ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+        ...eventFile ? { eventFile } : {},
+        event,
+        prompt,
+        model: modelAudit,
+        checkpoint: routePlan,
+        route: routePlan.route,
+        ...displayTitle ? { sessionTitle: displayTitle } : {},
+        intakeResult,
+        selectedTicket,
+        lifecycleOperations,
+        cadenceWrites,
+        summary,
+        ...reason ? { reason } : {},
+        entryCount: routePlan.entries.length
+      });
+      const nextSessionState = {
+        ...sessionState,
+        stopCount: 0,
+        threshold: defaultCheckpointThresholdValue(),
+        previousCheckpointSummary: summary,
+        lastAction: action,
+        ...reason ? { lastReason: reason } : {},
+        ...eventFile ? { lastEventFile: eventFile } : {},
+        ...targetTicketId ? {
+          cadenceContext: {
+            ticketId: targetTicketId,
+            ...targetSessionId ? { sessionId: targetSessionId } : {},
+            ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+            capturedAt: checkedAt
+          }
+        } : {},
+        lastCheckpointAt: checkedAt,
+        lastCheckpointMode: "checkpoint",
+        ...displayTitle ? {
+          displayTitle: displayTitle.text,
+          displayTitleUpdatedAt: checkedAt,
+          displayTitleSource: "route",
+          displayTitleConfidence: displayTitle.confidence,
+          ...displayTitle.reason ? { displayTitleReason: displayTitle.reason } : {}
+        } : {},
+        lastCheckpointAuditFile: auditFile
+      };
+      await writeAgentLoopState(parsed, options, {
+        ...state,
+        sessions: {
+          ...state.sessions,
+          [agentSessionKeyValue]: nextSessionState
+        }
+      });
+      const data = {
+        action,
+        route: routePlan.route,
+        ...reason ? { reason } : {},
+        ...targetTicketId ? { ticketId: targetTicketId } : {},
+        summary,
+        ...displayTitle ? { sessionTitle: displayTitle } : {},
+        entryCount: routePlan.entries.length,
+        mode: "route",
+        auditFile,
+        agentSessionKey: agentSessionKeyValue,
+        ...targetSessionId ? { sessionId: targetSessionId } : {},
+        ...targetChangesetId ? { changesetId: targetChangesetId } : {}
+      };
+      return {
+        stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    };
+    if (routePlan.route.action === "noop") {
+      return await finishRoute("noop", routePlan.route.reason ?? routePlan.summary ?? "Nothing durable to route.");
+    }
+    if (routePlan.route.action === "current") {
+      return await finishRoute("current", routePlan.route.reason ?? "Kept current Cadence context.");
+    }
+    if (routePlanAllowsLifecycle(routePlan)) {
+      const intakeRequest = routePlan.route.request ?? checkpointPlanDescription(routePlan);
+      intakeResult = await client.intake.create({
+        projectId,
+        intake: {
+          request: intakeRequest,
+          ...commandMetadata()
+        }
+      });
+      lifecycleOperations.push(checkpointLifecycleOperation("intake.created", true, { request: intakeRequest, result: intakeResult }));
+      if (intakeCandidates(intakeResult).length > 0) {
+        const candidatePrompt = buildRouteCandidatePrompt({
+          event,
+          initialPlan: routePlan,
+          intakeResult,
+          ...savedContext ? { savedContext } : {},
+          ...currentContext ? { currentContext } : {}
+        });
+        const candidateWorker = runRouteWorker(candidatePrompt, "Codex route candidate selection failed.");
+        const candidatePlan = parseCheckpointPlanJson(candidateWorker.codex.stdout, "intent");
+        routePlan = planWithCandidateSelection(routePlan, candidatePlan, currentTicketId, intakeCandidateTicketIds(intakeResult));
+        summary = routePlan.summary ?? routePlan.entries[0]?.summary ?? routePlan.route.reason ?? summary;
+        tokenAccounting = candidateWorker.tokenAccounting;
+        modelAudit.candidateSelection = {
+          prompt: candidatePrompt,
+          status: candidateWorker.codex.status,
+          stdout: candidateWorker.codex.stdout.trim(),
+          stderr: truncateText(candidateWorker.codex.stderr.trim(), 2000),
+          tokenAccounting: candidateWorker.tokenAccounting,
+          ...candidateWorker.codexSessionTranscript?.tokenUsage ? { tokenUsage: candidateWorker.codexSessionTranscript.tokenUsage } : {},
+          ...candidateWorker.codexSessionTranscript ? { sessionTranscript: candidateWorker.codexSessionTranscript } : {}
+        };
+        if (routePlan.route.action === "noop") {
+          return await finishRoute("noop", routePlan.route.reason ?? routePlan.summary ?? "Candidate routing produced no durable route.");
+        }
+        if (routePlan.route.action === "current") {
+          return await finishRoute("current", routePlan.route.reason ?? "Candidate routing kept current Cadence context.");
+        }
+        if (!routePlanAllowsLifecycle(routePlan)) {
+          routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), routePlan.route.reason ?? "Candidate routing did not request an executable automatic action.");
+          return await finishRoute(routePlan.route.action, routePlan.route.reason);
+        }
+      } else if (checkpointHasConflictingIntakeResult(intakeResult, routePlan)) {
+        routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), "Intake returned conflicting duplicate, overlap, or completed-before candidates.");
+        return await finishRoute(routePlan.route.action, routePlan.route.reason);
+      }
+      if (routePlan.route.action === "intake_create") {
+        selectedTicket = await client.tickets.create({
+          projectId,
+          ticket: {
+            title: checkpointPlanTitle(routePlan),
+            description: checkpointPlanDescription(routePlan),
+            fromIntakeId: objectStringId(intakeResult),
+            ...commandMetadata()
+          }
+        });
+        lifecycleOperations.push(checkpointLifecycleOperation("ticket.created", true, { ticket: selectedTicket }));
+        targetTicketId = objectStringId(selectedTicket);
+      } else {
+        const selectedTicketId = routePlan.route.targetTicketId;
+        if (!selectedTicketId) {
+          routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), "Automatic routing to existing work requires a target ticket id.");
+          return await finishRoute(routePlan.route.action, routePlan.route.reason);
+        }
+        targetTicketId = selectedTicketId;
+        selectedTicket = await client.tickets.get({ projectId, ticketId: targetTicketId });
+        lifecycleOperations.push(checkpointLifecycleOperation("ticket.selected", true, { ticketId: targetTicketId, ticket: selectedTicket }));
+        const selectedVersion = selectedTicket && typeof selectedTicket === "object" && typeof selectedTicket.projectionVersion === "number" ? selectedTicket.projectionVersion : undefined;
+        const intakeId = objectStringId(intakeResult);
+        if (selectedVersion !== undefined && intakeId) {
+          await client.tickets.attach({
+            projectId,
+            ticketId: targetTicketId,
+            fromIntakeId: intakeId,
+            ifVersion: selectedVersion
+          });
+          lifecycleOperations.push(checkpointLifecycleOperation("intake.attached", true, { ticketId: targetTicketId, intakeId }));
+        }
+      }
+      if (!targetTicketId) {
+        routePlan = checkpointPlanWithRoute(routePlan, {
+          action: currentTicketId ? "current" : "noop",
+          confidence: routePlan.route.confidence,
+          reason: "Automatic routing did not return a target ticket."
+        });
+        return await finishRoute(routePlan.route.action, routePlan.route.reason);
+      }
+      if (currentSessionId && currentTicketId && targetTicketId !== currentTicketId) {
+        await client.sessions.end({
+          projectId,
+          sessionId: currentSessionId,
+          session: {
+            summary: routePlan.route.reason ?? summary,
+            ...commandMetadata()
+          }
+        });
+        lifecycleOperations.push(checkpointLifecycleOperation("session.ended", true, { sessionId: currentSessionId, reason: "ticket_switch" }));
+        targetSessionId = undefined;
+        targetChangesetId = undefined;
+      }
+      const startedSession = await client.sessions.start({
+        projectId,
+        session: {
+          ticketId: targetTicketId,
+          ...commandMetadata()
+        }
+      });
+      lifecycleOperations.push(checkpointLifecycleOperation("session.started", true, { ticketId: targetTicketId, session: startedSession }));
+      targetSessionId = objectStringId(startedSession);
+      if (targetSessionId) {
+        const lease = await client.sessions.leases.create({
+          projectId,
+          lease: {
+            ticketId: targetTicketId,
+            sessionId: targetSessionId,
+            expiresAt: leaseExpiresAt(defaultLeaseTtlSeconds),
+            ...commandMetadata()
+          }
+        });
+        lifecycleOperations.push(checkpointLifecycleOperation("lease.claimed", true, { ticketId: targetTicketId, sessionId: targetSessionId, lease }));
+      }
+      if (targetSessionId) {
+        try {
+          const branchName = await resolveCurrentBranch(options);
+          const changeset = await client.changesets.create({
+            projectId,
+            changeset: {
+              ticketId: targetTicketId,
+              branchName,
+              baseBranch: "dev",
+              sessionId: targetSessionId,
+              ...commandMetadata()
+            }
+          });
+          lifecycleOperations.push(checkpointLifecycleOperation("changeset.linked", true, { ticketId: targetTicketId, branchName, changeset }));
+          targetChangesetId = objectStringId(changeset);
+        } catch (error) {
+          lifecycleOperations.push(checkpointLifecycleOperation("changeset.linked", false, { error: error instanceof Error ? error.message : String(error) }));
+        }
+      }
+      for (const entry of routePlan.entries) {
+        const logEntry = {
+          entryKind: entry.kind,
+          body: entry.body,
+          summary: entry.summary ?? checkpointEntrySummary(entry.body),
+          ...targetSessionId ? { sessionId: targetSessionId } : {},
+          ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+          ...commandMetadata()
+        };
+        await client.tickets.log({
+          projectId,
+          ticketId: targetTicketId,
+          entry: logEntry
+        });
+        cadenceWrites.push({
+          type: "ticket.work_log_appended",
+          success: true,
+          ticketId: targetTicketId,
+          entry: logEntry
+        });
+      }
+      if (routePlan.files.length && targetSessionId) {
+        const filesByKind = new Map;
+        for (const file of routePlan.files) {
+          filesByKind.set(file.kind, [...filesByKind.get(file.kind) ?? [], file.path]);
+        }
+        for (const [kind, paths] of filesByKind) {
+          const filesPayload = {
+            ...targetChangesetId ? { changesetId: targetChangesetId } : {},
+            files: paths.map((path) => ({
+              path,
+              changeKind: kind
+            })),
+            ...commandMetadata()
+          };
+          await client.sessions.files({
+            projectId,
+            sessionId: targetSessionId,
+            files: filesPayload
+          });
+          lifecycleOperations.push(checkpointLifecycleOperation("session.files_attached", true, { sessionId: targetSessionId, kind, files: paths }));
+        }
+      }
+      summary = routePlan.summary ?? routePlan.entries[0]?.summary ?? routePlan.route.reason ?? "Agent run routed";
+      return await finishRoute(routePlan.route.action === "intake_create" ? "routed" : "switched");
+    }
+    routePlan = safeAutomaticRoutePlan(routePlan, Boolean(currentTicketId), "Route did not request an executable automatic action.");
+    return await finishRoute(routePlan.route.action, routePlan.route.reason);
+  } finally {
+    await releaseAgentLoopLock(lockPath);
+  }
+}
+async function runAgentRunCheckpoint(parsed, options, config, meta) {
+  const projectId = requireProjectId(config);
+  const client = await createClient(config, options);
   const agentSessionKeyValue = requireOption(parsed, "agent-session-key");
   const state = await readAgentLoopState(parsed, options);
   const sessionState = state.sessions[agentSessionKeyValue];
@@ -4579,15 +5664,36 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
   }
   const eventFile = parsed.options["event-file"] ?? sessionState.lastEventFile;
   const event = eventFile ? tryParseJsonObject(await readFile(eventFile, "utf8"), eventFile) : synthesizeAgentEventFromSession(agentSessionKeyValue, sessionState, options);
+  const mode = checkpointModeForCommand(parsed);
   const logKind = parseWorkLogEntryKind(parsed.options["log-kind"] ?? "note");
   const updateSummary = parseBooleanOption(parsed.options["update-summary"], false);
   const dryRun = parseBooleanOption(parsed.options["dry-run"], false);
+  const closeoutSessionAction = parseCloseoutSessionAction(parsed.options["session-action"]);
+  const completeTicket = parseBooleanOption(parsed.options["complete-ticket"], false);
   const lockPath = parsed.options.lock;
   const checkpointSettings = await resolveCheckpointSettings(parsed, options);
   const gitStatus = gitOutput(["status", "--short"], options);
   const gitDiffStat = gitOutput(["diff", "--stat", "origin/dev..."], options);
   const changedFiles = gitOutput(["diff", "--name-only", "origin/dev..."], options);
+  const priorCoverage = sessionState.lastCheckpointCoverage;
+  const fingerprints = buildAgentRunFingerprints({
+    event,
+    ticketId,
+    ...sessionId ? { sessionId } : {},
+    ...changesetId ? { changesetId } : {},
+    gitStatus,
+    gitDiffStat,
+    changedFiles,
+    ...priorCoverage ? { coverage: priorCoverage } : {}
+  });
+  const closeoutContext = mode === "closeout" ? await readCloseoutPromptContext({
+    client,
+    projectId,
+    ticketId,
+    ...sessionId ? { sessionId } : {}
+  }) : {};
   const prompt = buildCheckpointPrompt({
+    mode,
     event,
     ticketId,
     ...sessionId ? { sessionId } : {},
@@ -4595,12 +5701,68 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
     gitStatus,
     gitDiffStat,
     changedFiles,
-    ...sessionState.previousCheckpointSummary ? { previousCheckpointSummary: sessionState.previousCheckpointSummary } : {}
+    ...sessionState.previousCheckpointSummary ? { previousCheckpointSummary: sessionState.previousCheckpointSummary } : {},
+    ...priorCoverage ? { coverage: priorCoverage } : {},
+    ...closeoutContext
   });
   const promptTokenAccounting = buildCheckpointTokenAccounting(event, prompt, undefined);
+  if (mode === "checkpoint" && !dryRun && !priorCoverage?.hasDebt && fingerprintsEqual(sessionState.lastCheckpointFingerprints, fingerprints) && !checkpointReasonBypassesFingerprintGate(parsed.options.reason)) {
+    const checkedAt = new Date().toISOString();
+    const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
+      version: 1,
+      mode,
+      action: "skipped",
+      reason: "unchanged_fingerprints",
+      createdAt: checkedAt,
+      localOnly: true,
+      localOnlyReason: "Raw hook context and checkpoint prompts stay on this machine; unchanged fingerprints did not need a model call.",
+      agentSessionKey: agentSessionKeyValue,
+      ticketId,
+      ...sessionId ? { sessionId } : {},
+      ...changesetId ? { changesetId } : {},
+      ...eventFile ? { eventFile } : {},
+      event,
+      fingerprints,
+      cadenceWrites: []
+    });
+    await writeAgentLoopState(parsed, options, {
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [agentSessionKeyValue]: {
+          ...sessionState,
+          stopCount: 0,
+          threshold: defaultCheckpointThresholdValue(),
+          lastAction: "skipped",
+          lastReason: "unchanged_fingerprints",
+          lastCheckpointAt: checkedAt,
+          lastCheckpointMode: mode,
+          lastCheckpointFingerprints: fingerprints,
+          lastCheckpointAuditFile: auditFile
+        }
+      }
+    });
+    const data = {
+      action: "skipped",
+      reason: "unchanged_fingerprints",
+      mode,
+      ticketId,
+      auditFile,
+      agentSessionKey: agentSessionKeyValue,
+      ...sessionId ? { sessionId } : {},
+      ...changesetId ? { changesetId } : {}
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
   if (dryRun) {
     const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
       version: 1,
+      mode,
       action: "would_checkpoint",
       createdAt: new Date().toISOString(),
       localOnly: true,
@@ -4612,6 +5774,8 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
       ...eventFile ? { eventFile } : {},
       event,
       prompt,
+      fingerprints,
+      ...mode === "closeout" ? { coverage: priorCoverage ?? null } : {},
       checkpointSettings,
       tokenAccounting: promptTokenAccounting,
       cadenceWrites: []
@@ -4634,7 +5798,6 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
   }
   try {
     const codexCommand = parsed.options["codex-command"] ?? "codex";
-    const codexStartedAtMs = Date.now();
     const codexCwd = options.cwd ?? process.cwd();
     const codexArgs = [
       "exec",
@@ -4647,25 +5810,165 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
       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_CHECKPOINT_FAILED", "Codex checkpoint generation failed.", {
-        status: codex.status,
-        stderr: truncateText(codex.stderr, 2000),
-        error: codex.error?.message
+    const generationAttempts = [];
+    let codex = null;
+    let codexSessionTranscript = null;
+    let tokenAccounting = promptTokenAccounting;
+    let checkpoint = null;
+    let reductionResult = null;
+    let lastFailureReason = "Codex checkpoint generation failed.";
+    for (let attempt = 1;attempt <= defaultCheckpointWorkerMaxAttempts; attempt += 1) {
+      const codexStartedAtMs = Date.now();
+      codex = runLocalCommand(codexCommand, codexArgs, options, {
+        cwd: codexCwd,
+        env: {
+          [agentLoopSuppressEnv]: "1",
+          CADENCE_HOOK_SUPPRESS: "1"
+        },
+        timeoutMs: defaultCheckpointWorkerTimeoutMs
       });
+      codexSessionTranscript = readCodexSessionTranscript(findCodexSessionFileCreatedAfter(options, codexStartedAtMs, codexCwd));
+      tokenAccounting = buildCheckpointTokenAccounting(event, prompt, codexSessionTranscript?.tokenUsage);
+      if (codex.status !== 0 || codex.error) {
+        lastFailureReason = codex.error?.message ?? `Codex exited with status ${codex.status ?? "unknown"}.`;
+        generationAttempts.push({
+          attempt,
+          success: false,
+          status: codex.status,
+          stderr: truncateText(codex.stderr.trim(), 2000),
+          ...codex.error ? { error: codex.error.message } : {}
+        });
+        continue;
+      }
+      try {
+        let parsedCheckpoint = parseCheckpointPlanJson(codex.stdout, logKind);
+        if (mode === "closeout") {
+          parsedCheckpoint = applyCloseoutSessionDefaults(parsedCheckpoint, closeoutSessionAction, completeTicket);
+        }
+        const parsedReductionResult = reduceCheckpointEntries(parsedCheckpoint.entries, mode);
+        checkpoint = {
+          ...parsedCheckpoint,
+          entries: parsedReductionResult.entries
+        };
+        reductionResult = parsedReductionResult;
+        generationAttempts.push({
+          attempt,
+          success: true,
+          status: codex.status
+        });
+        break;
+      } catch (error) {
+        if (error instanceof CliError && error.code === "AGENT_RUN_CHECKPOINT_INVALID_PLAN") {
+          throw error;
+        }
+        lastFailureReason = error instanceof Error ? error.message : String(error);
+        generationAttempts.push({
+          attempt,
+          success: false,
+          status: codex.status,
+          error: lastFailureReason,
+          stdout: truncateText(codex.stdout.trim(), 2000),
+          stderr: truncateText(codex.stderr.trim(), 2000)
+        });
+      }
     }
-    let checkpoint = parseCheckpointPlanJson(codex.stdout, logKind);
-    let summary = checkpoint.summary ?? checkpoint.entries[0]?.summary ?? checkpoint.route.reason ?? "Agent run checkpoint";
+    if (!codex || !checkpoint || !reductionResult) {
+      const failedCodex = codex ?? { status: null, stdout: "", stderr: "" };
+      const checkedAt = new Date().toISOString();
+      const summary2 = `Checkpoint worker failed after ${generationAttempts.length} ${generationAttempts.length === 1 ? "attempt" : "attempts"}.`;
+      const route = {
+        action: "failed",
+        confidence: "high",
+        reason: lastFailureReason
+      };
+      const auditFile = await writeAgentCheckpointAuditFile(parsed, options, {
+        version: 1,
+        action: "failed",
+        reason: lastFailureReason,
+        createdAt: checkedAt,
+        localOnly: true,
+        localOnlyReason: "Raw hook context, checkpoint prompts, and model output stay on this machine; failed checkpoint attempts are recorded locally for UI visibility and retry diagnosis.",
+        agentSessionKey: agentSessionKeyValue,
+        ticketId,
+        ...sessionId ? { sessionId } : {},
+        ...changesetId ? { changesetId } : {},
+        ...eventFile ? { eventFile } : {},
+        event,
+        prompt,
+        model: {
+          provider: checkpointSettings.provider,
+          command: codexCommand,
+          ...checkpointSettings.model ? { model: checkpointSettings.model } : {},
+          status: failedCodex.status,
+          stderr: truncateText(failedCodex.stderr.trim(), 2000),
+          stdout: truncateText(failedCodex.stdout.trim(), 2000),
+          ...failedCodex.error ? { error: failedCodex.error.message } : {},
+          tokenAccounting,
+          attempts: generationAttempts,
+          ...codexSessionTranscript?.tokenUsage ? { tokenUsage: codexSessionTranscript.tokenUsage } : {},
+          ...codexSessionTranscript ? { sessionTranscript: codexSessionTranscript } : {}
+        },
+        checkpointSettings,
+        route,
+        mode,
+        fingerprints,
+        lifecycleOperations: [],
+        cadenceWrites: [],
+        summary: summary2,
+        entryCount: 0,
+        needsHuman: true
+      });
+      await writeAgentLoopState(parsed, options, {
+        ...state,
+        sessions: {
+          ...state.sessions,
+          [agentSessionKeyValue]: {
+            ...sessionState,
+            stopCount: 0,
+            threshold: defaultCheckpointThresholdValue(),
+            previousCheckpointSummary: summary2,
+            lastAction: "failed",
+            lastReason: lastFailureReason,
+            ...eventFile ? { lastEventFile: eventFile } : {},
+            cadenceContext: {
+              ticketId,
+              ...sessionId ? { sessionId } : {},
+              ...changesetId ? { changesetId } : {},
+              capturedAt: checkedAt
+            },
+            lastCheckpointAt: checkedAt,
+            lastCheckpointMode: mode,
+            lastCheckpointFingerprints: fingerprints,
+            lastCheckpointAuditFile: auditFile
+          }
+        }
+      });
+      const data = {
+        action: "failed",
+        reason: lastFailureReason,
+        ticketId,
+        summary: summary2,
+        entryCount: 0,
+        mode,
+        auditFile,
+        agentSessionKey: agentSessionKeyValue,
+        attempts: generationAttempts.length,
+        ...sessionId ? { sessionId } : {},
+        ...changesetId ? { changesetId } : {},
+        needsHuman: true
+      };
+      return {
+        stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    const completedCodex = codex;
+    let checkpointPlan = checkpoint;
+    const checkpointReductionResult = reductionResult;
+    const coverage = buildAgentRunCoverage(checkpointPlan, mode);
+    let summary = checkpointPlan.summary ?? checkpointPlan.entries[0]?.summary ?? checkpointPlan.route.reason ?? "Agent run checkpoint";
     let targetTicketId = ticketId;
     let targetSessionId = sessionId;
     let targetChangesetId = changesetId;
@@ -4677,10 +5980,11 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
       provider: checkpointSettings.provider,
       command: codexCommand,
       ...checkpointSettings.model ? { model: checkpointSettings.model } : {},
-      status: codex.status,
-      stdout: codex.stdout.trim(),
-      stderr: truncateText(codex.stderr.trim(), 2000),
+      status: completedCodex.status,
+      stdout: completedCodex.stdout.trim(),
+      stderr: truncateText(completedCodex.stderr.trim(), 2000),
       tokenAccounting,
+      attempts: generationAttempts,
       ...codexSessionTranscript?.tokenUsage ? { tokenUsage: codexSessionTranscript.tokenUsage } : {},
       ...codexSessionTranscript ? { sessionTranscript: codexSessionTranscript } : {}
     };
@@ -4691,7 +5995,7 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         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.",
+        localOnlyReason: action === "noop" || action === "needs_human" || action === "reroute" ? "Raw hook context, checkpoint prompts, and model output stay on this machine; no Cadence writes were needed." : "Raw hook context, checkpoint prompts, and model output stay on this machine; Cadence receives only the structured writes listed here.",
         agentSessionKey: agentSessionKeyValue,
         ticketId: targetTicketId,
         ...targetSessionId ? { sessionId: targetSessionId } : {},
@@ -4700,15 +6004,19 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         event,
         prompt,
         model: modelAudit,
-        checkpoint,
-        route: checkpoint.route,
+        checkpoint: checkpointPlan,
+        route: checkpointPlan.route,
+        mode,
+        fingerprints,
+        reduction: checkpointReductionResult.reduction,
+        ...mode === "closeout" ? { coverage } : {},
         ...intakeResult ? { intakeResult } : {},
         ...selectedTicket ? { selectedTicket } : {},
         lifecycleOperations,
         cadenceWrites,
         summary,
         ...reason ? { reason } : {},
-        entryCount: checkpoint.entries.length,
+        entryCount: checkpointPlan.entries.length,
         needsHuman: action === "needs_human"
       });
       await writeAgentLoopState(parsed, options, {
@@ -4730,17 +6038,21 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
               capturedAt: checkedAt
             },
             lastCheckpointAt: checkedAt,
+            lastCheckpointMode: mode,
+            lastCheckpointFingerprints: fingerprints,
+            lastCheckpointCoverage: coverage,
             lastCheckpointAuditFile: auditFile
           }
         }
       });
       const data = {
         action,
-        route: checkpoint.route,
+        route: checkpointPlan.route,
         ...reason ? { reason } : {},
         ticketId: targetTicketId,
         summary,
-        entryCount: checkpoint.entries.length,
+        entryCount: checkpointPlan.entries.length,
+        mode,
         auditFile,
         agentSessionKey: agentSessionKeyValue,
         ...targetSessionId ? { sessionId: targetSessionId } : {},
@@ -4754,124 +6066,48 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         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 (checkpointPlan.session?.action === "complete_ticket" && mode === "closeout" && !completeTicket) {
+      checkpointPlan = checkpointPlanNeedsHuman(checkpointPlan, "Closeout ticket completion requires --complete-ticket true.");
     }
-    if (checkpoint.route.action === "noop") {
-      return await finishCheckpoint("noop", checkpoint.route.reason ?? checkpoint.summary ?? "Nothing durable to record.");
+    if (checkpointPlan.session?.action === "complete_ticket" && !checkpointPlanCompletionAllowed(event, summary)) {
+      checkpointPlan = checkpointPlanNeedsHuman(checkpointPlan, "Completion requires explicit recent completion, push, PR, merge, clean branch, or verification intent.");
     }
-    if (checkpoint.route.action === "needs_human") {
-      return await finishCheckpoint("needs_human", checkpoint.route.reason ?? "Checkpoint routing needs human review.");
+    if (checkpointPlan.route.action === "noop") {
+      return await finishCheckpoint("noop", checkpointPlan.route.reason ?? checkpointPlan.summary ?? "Nothing durable to record.");
     }
-    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()
-        }
+    if (checkpointPlan.route.action === "needs_human") {
+      checkpointPlan = checkpointPlanWithRoute(checkpointPlan, {
+        action: "noop",
+        confidence: checkpointPlan.route.confidence,
+        reason: checkpointPlan.route.reason ?? "Checkpoint routing was uncertain."
       });
-      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()
-          }
+      return await finishCheckpoint("noop", checkpointPlan.route.reason);
+    }
+    if (checkpointRouteRequiresIntake(checkpointPlan.route.action)) {
+      if (checkpointPlan.route.confidence !== "high") {
+        checkpointPlan = checkpointPlanWithRoute(checkpointPlan, {
+          action: "noop",
+          confidence: checkpointPlan.route.confidence,
+          reason: "Checkpoint reroute requires high confidence."
         });
-        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) }));
-        }
+        return await finishCheckpoint("noop", checkpointPlan.route.reason);
       }
+      const routeArgs = [
+        "agent-run",
+        "route",
+        "--agent-session-key",
+        agentSessionKeyValue,
+        "--reason",
+        "checkpoint_reroute",
+        ...eventFile ? ["--event-file", eventFile] : [],
+        ...parsed.flags.project ? ["--project", parsed.flags.project] : [],
+        ...parsed.flags.server ? ["--server", parsed.flags.server] : []
+      ];
+      const rerouteResult = await finishCheckpoint("reroute", checkpointPlan.route.reason ?? "Checkpoint delegated routing to agent-run route.");
+      await spawnAgentRunWorker(routeArgs, options);
+      return rerouteResult;
     }
-    const checkpointMetadata = checkpointWorkLogMetadata(checkpointSettings, tokenAccounting);
-    for (const entry of checkpoint.entries) {
+    for (const entry of checkpointPlan.entries) {
       const logEntry = {
         entryKind: entry.kind,
         body: entry.body,
@@ -4880,7 +6116,6 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         ...entry.parentEntryId ? { parentEntryId: entry.parentEntryId } : {},
         ...targetSessionId ? { sessionId: targetSessionId } : {},
         ...targetChangesetId ? { changesetId: targetChangesetId } : {},
-        metadata: checkpointMetadata,
         ...commandMetadata()
       };
       try {
@@ -4928,9 +6163,9 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         });
       }
     }
-    if (checkpoint.files.length && targetSessionId) {
+    if (checkpointPlan.files.length && targetSessionId) {
       const filesByKind = new Map;
-      for (const file of checkpoint.files) {
+      for (const file of checkpointPlan.files) {
         filesByKind.set(file.kind, [...filesByKind.get(file.kind) ?? [], file.path]);
       }
       for (const [kind, paths] of filesByKind) {
@@ -4950,7 +6185,7 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         lifecycleOperations.push(checkpointLifecycleOperation("session.files_attached", true, { sessionId: targetSessionId, kind, files: paths }));
       }
     }
-    if ((updateSummary || checkpoint.summaryUpdate?.update) && checkpoint.summaryUpdate?.value) {
+    if ((updateSummary || checkpointPlan.summaryUpdate?.update) && checkpointPlan.summaryUpdate?.value) {
       const ticket = await client.tickets.get({ projectId, ticketId: targetTicketId });
       if (typeof ticket.projectionVersion === "number") {
         await client.tickets.update({
@@ -4958,7 +6193,7 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
           ticketId: targetTicketId,
           ifVersion: ticket.projectionVersion,
           ticket: {
-            currentSummary: checkpoint.summaryUpdate.value,
+            currentSummary: checkpointPlan.summaryUpdate.value,
             ...commandMetadata()
           }
         });
@@ -4968,36 +6203,36 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
           ticketId: targetTicketId,
           ifVersion: ticket.projectionVersion,
           ticket: {
-            currentSummary: checkpoint.summaryUpdate.value
+            currentSummary: checkpointPlan.summaryUpdate.value
           }
         });
       }
     }
-    if (checkpoint.session?.action === "handoff" || checkpoint.session?.action === "end" || checkpoint.session?.action === "complete_ticket") {
+    if (checkpointPlan.session?.action === "handoff" || checkpointPlan.session?.action === "end" || checkpointPlan.session?.action === "complete_ticket") {
       if (targetSessionId) {
         await client.sessions.end({
           projectId,
           sessionId: targetSessionId,
           session: {
-            summary: checkpoint.session.summary ?? summary,
+            summary: checkpointPlan.session.summary ?? summary,
             ...commandMetadata()
           }
         });
-        lifecycleOperations.push(checkpointLifecycleOperation("session.ended", true, { sessionId: targetSessionId, action: checkpoint.session.action }));
+        lifecycleOperations.push(checkpointLifecycleOperation("session.ended", true, { sessionId: targetSessionId, action: checkpointPlan.session.action }));
       }
     }
-    if (checkpoint.session?.action === "complete_ticket") {
+    if (checkpointPlan.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);
+        checkpointPlan = checkpointPlanNeedsHuman(checkpointPlan, "Ticket completion requires a latest ticket projection version.");
+        return await finishCheckpoint("needs_human", checkpointPlan.route.reason);
       }
       await client.tickets.complete({
         projectId,
         ticketId: targetTicketId,
         ifVersion: latestTicket.projectionVersion,
         completion: {
-          currentSummary: checkpoint.session.summary ?? checkpoint.summaryUpdate?.value ?? summary,
+          currentSummary: checkpointPlan.session.summary ?? checkpointPlan.summaryUpdate?.value ?? summary,
           ...commandMetadata()
         }
       });
@@ -5006,7 +6241,7 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         success: true,
         ticketId: targetTicketId,
         ifVersion: latestTicket.projectionVersion,
-        summary: checkpoint.session.summary ?? checkpoint.summaryUpdate?.value ?? summary
+        summary: checkpointPlan.session.summary ?? checkpointPlan.summaryUpdate?.value ?? summary
       });
     }
     return await finishCheckpoint("checkpointed");
@@ -5033,26 +6268,17 @@ async function runAgentRunSweep(parsed, options, config, 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) {
       const existingSession = nextState.sessions[staleSession.agentSessionKey];
-      const cadenceContext = existingSession?.cadenceContext ?? fallbackContext;
-      if (existingSession && cadenceContext) {
+      const hasContext = Boolean(existingSession?.cadenceContext?.ticketId);
+      if (existingSession) {
         nextState = {
           ...nextState,
           sessions: {
             ...nextState.sessions,
             [staleSession.agentSessionKey]: {
               ...existingSession,
-              cadenceContext,
               lastAction: "sweep_spawned"
             }
           }
@@ -5061,11 +6287,11 @@ async function runAgentRunSweep(parsed, options, config, meta) {
       }
       await spawnAgentRunCheckpoint([
         "agent-run",
-        "checkpoint",
+        hasContext ? "checkpoint" : "route",
         "--agent-session-key",
         staleSession.agentSessionKey,
         "--reason",
-        "idle",
+        hasContext ? "idle" : "missing_context",
         "--lock",
         agentLoopLockPath(parsed, options, staleSession.agentSessionKey),
         ...parsed.flags.project ? ["--project", parsed.flags.project] : [],
@@ -5733,7 +6959,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.checkpoint" || parsed.command.name === "agent-run.closeout" || parsed.command.name === "agent-run.sweep" || parsed.command.name === "agent-run.doctor") {
+    if (parsed.command.name === "agent-run.ingest-stop" || parsed.command.name === "agent-run.route" || parsed.command.name === "agent-run.checkpoint" || parsed.command.name === "agent-run.closeout" || parsed.command.name === "agent-run.sweep" || parsed.command.name === "agent-run.doctor") {
       return await runAgentRunCommand(parsed, options);
     }
     if (parsed.command.name === "hooks.install" || parsed.command.name === "hooks.doctor") {