@trycadence/cli 0.1.16-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.16-dev.0",
+  version: "0.1.18-dev.0",
   private: false,
   type: "module",
   bin: {
@@ -1560,8 +1560,9 @@ 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;
@@ -3090,16 +3091,6 @@ function normalizeGenericAgentEvent(input, base) {
 function agentSessionKey(source, agentSessionId) {
   return `${source}:${stableHash(agentSessionId)}`;
 }
-function checkpointWorkLogMetadata(settings, mode, tokenAccounting) {
-  return {
-    checkpoint: {
-      ...mode ? { mode } : {},
-      provider: settings.provider,
-      ...settings.model ? { model: settings.model } : {},
-      ...tokenAccounting ? { tokenAccounting } : {}
-    }
-  };
-}
 function defaultAgentLoopState() {
   return {
     version: 2,
@@ -3258,6 +3249,11 @@ function readAgentLoopSessions(rawSessions) {
       ...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 } : {}
     };
   }
@@ -3561,6 +3557,9 @@ function fingerprintForCheckpoint(event, options) {
   }));
 }
 function shouldSkipForCooldown(state, cooldownSeconds) {
+  if (cooldownSeconds <= 0) {
+    return false;
+  }
   if (!state.lastCheckpointAt) {
     return false;
   }
@@ -3788,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 [];
@@ -3845,6 +3881,33 @@ function safeAutomaticRoutePlan(plan, hasCurrentContext, 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);
@@ -3868,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,
@@ -3925,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,
@@ -4096,7 +4217,8 @@ function buildRoutePrompt(input) {
     "The model judges; the Cadence CLI validates and executes. Return JSON only. Do not call tools to mutate Cadence yourself.",
     "Decide where this agent session belongs before checkpoint memory is written.",
     "Do not include raw diffs, raw transcripts, terminal logs, tool streams, secrets, file contents, or model reasoning in server-bound fields.",
-    'Return this sparse JSON shape: {"summary":"short routing summary","route":{"action":"current|noop|intake_create|intake_attach|switch_existing","confidence":"low|medium|high","reason":"short reason","request":"natural language intake request when intake is needed","targetTicketId":"optional existing ticket id"},"entries":[{"kind":"intent|decision|rationale|action|verification|blocker|correction|note","summary":"short entry summary","body":"safe Cadence work-log body"}],"files":[{"path":"relative/path.ts","kind":"added|modified|deleted|renamed|unknown"}]}',
+    '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.",
@@ -4121,6 +4243,35 @@ ${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));
 }
@@ -5033,6 +5184,27 @@ async function runAgentRunIngestStop(parsed, options, config, meta) {
 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);
@@ -5097,37 +5269,41 @@ async function runAgentRunRoute(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",
-      ...checkpointSettings.model ? ["-m", checkpointSettings.model] : [],
-      "--disable",
-      "hooks",
-      "--sandbox",
-      "read-only",
-      "-C",
-      codexCwd,
-      prompt
-    ];
-    const codex = runLocalCommand(codexCommand, codexArgs, options, {
-      cwd: codexCwd,
-      env: {
-        [agentLoopSuppressEnv]: "1",
-        CADENCE_HOOK_SUPPRESS: "1"
-      },
-      timeoutMs: defaultCheckpointWorkerTimeoutMs
-    });
-    const codexSessionTranscript = readCodexSessionTranscript(findCodexSessionFileCreatedAfter(options, codexStartedAtMs, codexCwd));
-    const tokenAccounting = buildCheckpointTokenAccounting(event, prompt, codexSessionTranscript?.tokenUsage);
-    if (codex.status !== 0 || codex.error) {
-      throw new CliError("AGENT_RUN_ROUTE_FAILED", "Codex route generation failed.", {
-        status: codex.status,
-        stderr: truncateText(codex.stderr, 2000),
-        error: codex.error?.message
+    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
       });
-    }
-    let routePlan = parseCheckpointPlanJson(codex.stdout, "intent");
+      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;
@@ -5152,19 +5328,21 @@ async function runAgentRunRoute(parsed, options, config, meta) {
     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: codex.status,
-      stdout: codex.stdout.trim(),
-      stderr: truncateText(codex.stderr.trim(), 2000),
+      status: initialRouteWorker.codex.status,
+      stdout: initialRouteWorker.codex.stdout.trim(),
+      stderr: truncateText(initialRouteWorker.codex.stderr.trim(), 2000),
       tokenAccounting,
-      ...codexSessionTranscript?.tokenUsage ? { tokenUsage: codexSessionTranscript.tokenUsage } : {},
-      ...codexSessionTranscript ? { sessionTranscript: codexSessionTranscript } : {}
+      ...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",
@@ -5182,6 +5360,7 @@ async function runAgentRunRoute(parsed, options, config, meta) {
         model: modelAudit,
         checkpoint: routePlan,
         route: routePlan.route,
+        ...displayTitle ? { sessionTitle: displayTitle } : {},
         intakeResult,
         selectedTicket,
         lifecycleOperations,
@@ -5208,6 +5387,13 @@ async function runAgentRunRoute(parsed, options, config, meta) {
         } : {},
         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, {
@@ -5223,6 +5409,7 @@ async function runAgentRunRoute(parsed, options, config, meta) {
         ...reason ? { reason } : {},
         ...targetTicketId ? { ticketId: targetTicketId } : {},
         summary,
+        ...displayTitle ? { sessionTitle: displayTitle } : {},
         entryCount: routePlan.entries.length,
         mode: "route",
         auditFile,
@@ -5253,7 +5440,39 @@ async function runAgentRunRoute(parsed, options, config, meta) {
         }
       });
       lifecycleOperations.push(checkpointLifecycleOperation("intake.created", true, { request: intakeRequest, result: intakeResult }));
-      if (checkpointHasConflictingIntakeResult(intakeResult, routePlan)) {
+      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);
       }
@@ -5351,7 +5570,6 @@ async function runAgentRunRoute(parsed, options, config, meta) {
           lifecycleOperations.push(checkpointLifecycleOperation("changeset.linked", false, { error: error instanceof Error ? error.message : String(error) }));
         }
       }
-      const routeMetadata = checkpointWorkLogMetadata(checkpointSettings, "route", tokenAccounting);
       for (const entry of routePlan.entries) {
         const logEntry = {
           entryKind: entry.kind,
@@ -5359,7 +5577,6 @@ async function runAgentRunRoute(parsed, options, config, meta) {
           summary: entry.summary ?? checkpointEntrySummary(entry.body),
           ...targetSessionId ? { sessionId: targetSessionId } : {},
           ...targetChangesetId ? { changesetId: targetChangesetId } : {},
-          metadata: routeMetadata,
           ...commandMetadata()
         };
         await client.tickets.log({
@@ -5581,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",
@@ -5594,34 +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);
-    if (mode === "closeout") {
-      checkpoint = applyCloseoutSessionDefaults(checkpoint, closeoutSessionAction, completeTicket);
+    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 reductionResult = reduceCheckpointEntries(checkpoint.entries, mode);
-    checkpoint = {
-      ...checkpoint,
-      entries: reductionResult.entries
-    };
-    const coverage = buildAgentRunCoverage(checkpoint, mode);
-    let summary = checkpoint.summary ?? checkpoint.entries[0]?.summary ?? checkpoint.route.reason ?? "Agent run checkpoint";
+    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;
@@ -5633,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 } : {}
     };
@@ -5656,11 +6004,11 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         event,
         prompt,
         model: modelAudit,
-        checkpoint,
-        route: checkpoint.route,
+        checkpoint: checkpointPlan,
+        route: checkpointPlan.route,
         mode,
         fingerprints,
-        reduction: reductionResult.reduction,
+        reduction: checkpointReductionResult.reduction,
         ...mode === "closeout" ? { coverage } : {},
         ...intakeResult ? { intakeResult } : {},
         ...selectedTicket ? { selectedTicket } : {},
@@ -5668,7 +6016,7 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         cadenceWrites,
         summary,
         ...reason ? { reason } : {},
-        entryCount: checkpoint.entries.length,
+        entryCount: checkpointPlan.entries.length,
         needsHuman: action === "needs_human"
       });
       await writeAgentLoopState(parsed, options, {
@@ -5699,11 +6047,11 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
       });
       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,
@@ -5718,31 +6066,31 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         exitCode: 0
       };
     };
-    if (checkpoint.session?.action === "complete_ticket" && mode === "closeout" && !completeTicket) {
-      checkpoint = checkpointPlanNeedsHuman(checkpoint, "Closeout ticket completion requires --complete-ticket true.");
+    if (checkpointPlan.session?.action === "complete_ticket" && mode === "closeout" && !completeTicket) {
+      checkpointPlan = checkpointPlanNeedsHuman(checkpointPlan, "Closeout ticket completion requires --complete-ticket true.");
     }
-    if (checkpoint.session?.action === "complete_ticket" && !checkpointPlanCompletionAllowed(event, summary)) {
-      checkpoint = checkpointPlanNeedsHuman(checkpoint, "Completion requires explicit recent completion, push, PR, merge, clean branch, or verification intent.");
+    if (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 === "noop") {
-      return await finishCheckpoint("noop", checkpoint.route.reason ?? checkpoint.summary ?? "Nothing durable to record.");
+    if (checkpointPlan.route.action === "noop") {
+      return await finishCheckpoint("noop", checkpointPlan.route.reason ?? checkpointPlan.summary ?? "Nothing durable to record.");
     }
-    if (checkpoint.route.action === "needs_human") {
-      checkpoint = checkpointPlanWithRoute(checkpoint, {
+    if (checkpointPlan.route.action === "needs_human") {
+      checkpointPlan = checkpointPlanWithRoute(checkpointPlan, {
         action: "noop",
-        confidence: checkpoint.route.confidence,
-        reason: checkpoint.route.reason ?? "Checkpoint routing was uncertain."
+        confidence: checkpointPlan.route.confidence,
+        reason: checkpointPlan.route.reason ?? "Checkpoint routing was uncertain."
       });
-      return await finishCheckpoint("noop", checkpoint.route.reason);
+      return await finishCheckpoint("noop", checkpointPlan.route.reason);
     }
-    if (checkpointRouteRequiresIntake(checkpoint.route.action)) {
-      if (checkpoint.route.confidence !== "high") {
-        checkpoint = checkpointPlanWithRoute(checkpoint, {
+    if (checkpointRouteRequiresIntake(checkpointPlan.route.action)) {
+      if (checkpointPlan.route.confidence !== "high") {
+        checkpointPlan = checkpointPlanWithRoute(checkpointPlan, {
           action: "noop",
-          confidence: checkpoint.route.confidence,
+          confidence: checkpointPlan.route.confidence,
           reason: "Checkpoint reroute requires high confidence."
         });
-        return await finishCheckpoint("noop", checkpoint.route.reason);
+        return await finishCheckpoint("noop", checkpointPlan.route.reason);
       }
       const routeArgs = [
         "agent-run",
@@ -5755,12 +6103,11 @@ async function runAgentRunCheckpoint(parsed, options, config, meta) {
         ...parsed.flags.project ? ["--project", parsed.flags.project] : [],
         ...parsed.flags.server ? ["--server", parsed.flags.server] : []
       ];
-      const rerouteResult = await finishCheckpoint("reroute", checkpoint.route.reason ?? "Checkpoint delegated routing to agent-run route.");
+      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, mode, tokenAccounting);
-    for (const entry of checkpoint.entries) {
+    for (const entry of checkpointPlan.entries) {
       const logEntry = {
         entryKind: entry.kind,
         body: entry.body,
@@ -5769,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 {
@@ -5817,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) {
@@ -5839,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({
@@ -5847,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()
           }
         });
@@ -5857,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()
         }
       });
@@ -5895,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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trycadence/cli",
-  "version": "0.1.16-dev.0",
+  "version": "0.1.18-dev.0",
   "private": false,
   "type": "module",
   "bin": {