@trycadence/cli 0.1.7 → 0.1.10-dev.0

package/dist/cadence

@@ -1511,7 +1511,7 @@ function createCadenceClient(options = {}) {
 }
 
 // src/index.ts
-import { spawnSync } from "child_process";
+import { spawn, spawnSync } from "child_process";
 import { createHash, randomUUID } from "crypto";
 import { mkdir, readFile, rm, stat, writeFile } from "fs/promises";
 import { basename, dirname, isAbsolute, join, parse } from "path";
@@ -1522,9 +1522,17 @@ var sessionFileChangeKinds = ["added", "modified", "deleted", "renamed", "unknow
 var workLogEntryKinds = ["intent", "decision", "rationale", "action", "verification", "blocker", "correction", "note"];
 var workLogParentSelectors = ["last", "ticket-last", "session-last", "last-decision", "last-correction", "last-action"];
 var changesetPrNoteSources = ["agent", "human", "system"];
+var hookScopes = ["repo", "global", "both"];
+var agentEventSources = ["codex", "claude-code", "opencode", "openrouter", "unknown"];
 var defaultLeaseTtlSeconds = 5 * 60 * 60;
 var defaultCliApiBaseUrl = "https://cadenceapi.deploy.lvl8studios.com";
 var defaultCliWebBaseUrl = "https://cadence.deploy.lvl8studios.com";
+var defaultCheckpointThresholdMin = 3;
+var defaultCheckpointThresholdMax = 5;
+var defaultCheckpointCooldownSeconds = 10 * 60;
+var defaultCheckpointWorkerTimeoutMs = 10 * 60 * 1000;
+var defaultHookCommand = "cadence agent-run ingest-stop --source codex --event stop";
+var agentLoopSuppressEnv = "CADENCE_AGENT_EVENT_SUPPRESS";
 var credentialRefreshSkewMs = 60 * 1000;
 var credentialRefreshLockTimeoutMs = 10 * 1000;
 var credentialRefreshLockStaleMs = 60 * 1000;
@@ -1560,6 +1568,12 @@ var knownCommandPaths = [
   ["changesets", "notes", "get"],
   ["changesets", "notes", "put"],
   ["changesets", "notes", "apply"],
+  ["agent-run", "ingest-stop"],
+  ["agent-run", "closeout"],
+  ["agent-run", "sweep"],
+  ["agent-run", "doctor"],
+  ["hooks", "doctor"],
+  ["hooks", "install"],
   ["sessions", "start"],
   ["sessions", "end"],
   ["sessions", "files"],
@@ -1578,7 +1592,6 @@ var knownCommandPaths = [
   ["events", "list"],
   ["work", "overview"],
   ["projects", "list"],
-  ["projects", "use"],
   ["init"],
   ["status"],
   ["help"]
@@ -1827,39 +1840,6 @@ async function findRepoCadenceDirectory(cwd) {
     current = parent;
   }
 }
-async function findRepoConfigDirectory(cwd) {
-  let current = cwd;
-  while (true) {
-    const repoConfig = join(current, ".cadence", "config.json");
-    if (await Bun.file(repoConfig).exists()) {
-      return join(current, ".cadence");
-    }
-    const parent = dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function resolveGitRootFromCommand(cwd) {
-  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
-    cwd,
-    encoding: "utf8"
-  });
-  if (result.status !== 0) {
-    return null;
-  }
-  return result.stdout.trim() || null;
-}
-async function repoConfigPathForWrite(options) {
-  const cwd = options.cwd ?? process.cwd();
-  const existingConfigDirectory = await findRepoConfigDirectory(cwd);
-  if (existingConfigDirectory) {
-    return join(existingConfigDirectory, "config.json");
-  }
-  const gitRoot = options.resolveGitRoot ? await options.resolveGitRoot() : resolveGitRootFromCommand(cwd);
-  return join(gitRoot ?? cwd, ".cadence", "config.json");
-}
 function getConfigHome(env) {
   return env.CADENCE_CONFIG_HOME ?? (env.HOME ? join(env.HOME, ".config", "cadence") : join(parse(process.cwd()).root, ".config", "cadence"));
 }
@@ -1944,6 +1924,77 @@ function isInteractive(options) {
 function getCliWebBaseUrl(config, parsed, options) {
   return parsed.options["web-base-url"] ?? options.env?.CADENCE_WEB_BASE_URL ?? process.env.CADENCE_WEB_BASE_URL ?? config.webBaseUrl;
 }
+function normalizeBaseUrl(value, label) {
+  try {
+    return new URL(value).toString().replace(/\/$/, "");
+  } catch {
+    throw new CliError("CLI_USAGE", `${label} must be a valid URL.`);
+  }
+}
+function cliConfigDiscoveryUrl(webBaseUrl) {
+  return new URL("/cli/config", webBaseUrl).toString();
+}
+function hasExplicitWebBaseUrl(parsed, options) {
+  return Boolean(parsed.options["web-base-url"] ?? options.env?.CADENCE_WEB_BASE_URL ?? process.env.CADENCE_WEB_BASE_URL);
+}
+async function discoverApiBaseUrlFromWeb(webBaseUrl, options) {
+  const configUrl = cliConfigDiscoveryUrl(webBaseUrl);
+  const requestFetch = options.fetch ?? fetch;
+  let response;
+  try {
+    response = await requestFetch(configUrl, {
+      headers: {
+        accept: "application/json"
+      }
+    });
+  } catch (error) {
+    throw new CliError("WEB_CONFIG_DISCOVERY_FAILED", "Could not discover Cadence API URL from the web app.", {
+      webBaseUrl,
+      configUrl,
+      cause: error instanceof Error ? error.message : String(error)
+    });
+  }
+  if (!response.ok) {
+    throw new CliError("WEB_CONFIG_DISCOVERY_FAILED", "Could not discover Cadence API URL from the web app.", {
+      webBaseUrl,
+      configUrl,
+      status: response.status
+    });
+  }
+  const parsed = await response.json();
+  const apiBaseUrl = parsed && typeof parsed === "object" ? parsed.apiBaseUrl : undefined;
+  if (typeof apiBaseUrl !== "string") {
+    throw new CliError("WEB_CONFIG_DISCOVERY_FAILED", "Cadence web app returned invalid CLI configuration.", {
+      webBaseUrl,
+      configUrl
+    });
+  }
+  return normalizeBaseUrl(apiBaseUrl, "Discovered API base URL");
+}
+async function resolveAuthLoginConfig(config, parsed, options) {
+  const webBaseUrl = normalizeBaseUrl(getCliWebBaseUrl(config, parsed, options), "--web-base-url");
+  if (parsed.flags.server && !hasExplicitWebBaseUrl(parsed, options)) {
+    return {
+      ...config,
+      webBaseUrl
+    };
+  }
+  try {
+    return {
+      ...config,
+      server: await discoverApiBaseUrlFromWeb(webBaseUrl, options),
+      webBaseUrl
+    };
+  } catch (error) {
+    if (hasExplicitWebBaseUrl(parsed, options)) {
+      throw error;
+    }
+    return {
+      ...config,
+      webBaseUrl
+    };
+  }
+}
 function deriveWebBaseUrl(server) {
   try {
     const url = new URL(server);
@@ -2163,7 +2214,6 @@ function helpText() {
     "  cadence actors ensure-workspace-agent --agent-kind <kind> [--workspace-name <name>] [--workspace-ref <ref>] [--display-name <name>] [--project <project-id>] [--json]",
     "  cadence status [--project <project-id>] [--json]",
     "  cadence projects list [--json]",
-    "  cadence projects use <project-id|org/project> [--server <url>] [--json]",
     "  cadence work overview [--project <project-id>] [--json]",
     "  cadence tickets get <ticket-id> [--project <project-id>] [--json]",
     "  cadence tickets list [--project <project-id>] [--status <status>] [--json]",
@@ -2188,10 +2238,16 @@ function helpText() {
     "  cadence changesets notes get [--changeset <id>|--branch current|<branch>] [--project <project-id>] [--json]",
     "  cadence changesets notes put [--changeset <id>|--branch current|<branch>] --title <text> --body-file <path> [--head-sha <sha>] [--base-sha <sha>] [--pr-url <url>] [--pr-number <n>] [--project <project-id>] [--json]",
     "  cadence changesets notes apply [--changeset <id>|--branch current|<branch>] --provider github --pr-number <n> --pr-url <url> [--project <project-id>] [--json]",
+    "  cadence agent-run ingest-stop --source <codex|claude-code|opencode|openrouter> [--event <event>] [--threshold <n>] [--dry-run true|false] [--project <project-id>] [--json]",
+    "  cadence agent-run closeout --agent-session-key <key> [--reason <threshold|idle|manual>] [--event-file <path>] [--log-kind <kind>] [--update-summary true|false] [--json]",
+    "  cadence agent-run sweep [--idle-after-seconds <n>] [--dry-run true|false] [--json]",
+    "  cadence agent-run doctor [--json]",
+    "  cadence hooks install --provider codex --scope <repo|global|both> [--command <command>] [--json]",
+    "  cadence hooks doctor --provider codex --scope <repo|global|both> [--json]",
     "  cadence events list [--project <project-id>] [--ticket <ticket-id>] [--changeset <changeset-id>] [--session <session-id>] [--json]",
     "",
     "Global flags:",
-    "  --project <id|org/project> Cadence project ID or org/project slug",
+    "  --project <id>       Cadence project ID or org/project slug",
     "  --server <url>       Cadence API server override",
     "  --json               Print stable JSON envelope",
     "",
@@ -2448,6 +2504,572 @@ async function readBodyFile(path, options) {
   const resolvedPath = isAbsolute(path) ? path : join(options.cwd ?? process.cwd(), path);
   return readFile(resolvedPath, "utf8");
 }
+function parseHookScope(value) {
+  if (!value) {
+    return "repo";
+  }
+  if (hookScopes.includes(value)) {
+    return value;
+  }
+  throw new CliError("CLI_USAGE", "--scope must be one of repo, global, or both.");
+}
+function parseAgentEventSource(value) {
+  if (!value) {
+    return "unknown";
+  }
+  if (agentEventSources.includes(value)) {
+    return value;
+  }
+  throw new CliError("CLI_USAGE", "--source must be one of codex, claude-code, opencode, openrouter, or unknown.");
+}
+function parseBooleanOption(value, defaultValue) {
+  if (!value) {
+    return defaultValue;
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  throw new CliError("CLI_USAGE", "Boolean options must be true or false.");
+}
+function truncateText(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength - 15)}
+[truncated]`;
+}
+function stableHash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+async function readStdin(options) {
+  if (options.readStdin) {
+    return await options.readStdin();
+  }
+  return await Bun.stdin.text();
+}
+function tryParseJsonObject(source, label) {
+  if (!source.trim()) {
+    return {};
+  }
+  const parsed = JSON.parse(source);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliError("CLI_USAGE", `${label} must be a JSON object.`);
+  }
+  return parsed;
+}
+function readNestedString(record, path) {
+  let value = record;
+  for (const key of path) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return;
+    }
+    value = value[key];
+  }
+  return typeof value === "string" ? value : undefined;
+}
+function firstString(record, paths) {
+  for (const path of paths) {
+    const value = readNestedString(record, path);
+    if (value?.trim()) {
+      return value.trim();
+    }
+  }
+  return;
+}
+function normalizeAgentEvent(input, parsed, options) {
+  const source = parseAgentEventSource(parsed.options.source);
+  const event = parsed.options.event ?? "stop";
+  const base = normalizeAgentEventBase(input, source, event, options);
+  switch (source) {
+    case "codex":
+      return normalizeCodexAgentEvent(input, base);
+    case "claude-code":
+    case "opencode":
+    case "openrouter":
+    case "unknown":
+      return normalizeGenericAgentEvent(input, base);
+  }
+}
+function normalizeAgentEventBase(input, source, event, options) {
+  const threadId = firstString(input, [["thread_id"], ["threadId"], ["conversation_id"], ["conversationId"]]);
+  const turnId = firstString(input, [["turn_id"], ["turnId"], ["id"]]);
+  const lastAssistantMessage = firstString(input, [
+    ["last_assistant_message"],
+    ["lastAssistantMessage"],
+    ["assistant_response"],
+    ["assistantResponse"],
+    ["message", "content"],
+    ["lastMessage", "content"]
+  ]);
+  return {
+    source,
+    event,
+    workspacePath: options.cwd ?? process.cwd(),
+    occurredAt: new Date().toISOString(),
+    ...threadId ? { threadId } : {},
+    ...turnId ? { turnId } : {},
+    ...lastAssistantMessage ? { lastAssistantMessage: truncateText(lastAssistantMessage, 6000) } : {},
+    payloadKeys: Object.keys(input).sort()
+  };
+}
+function normalizeCodexAgentEvent(input, base) {
+  const agentSessionId = firstString(input, [["session_id"], ["sessionId"], ["session", "id"]]);
+  if (!agentSessionId) {
+    return {
+      ...base,
+      diagnosticReason: "missing_agent_session_id"
+    };
+  }
+  return {
+    ...base,
+    agentSessionId,
+    agentSessionKey: agentSessionKey(base.source, agentSessionId)
+  };
+}
+function normalizeGenericAgentEvent(input, base) {
+  const agentSessionId = firstString(input, [
+    ["agent_session_id"],
+    ["agentSessionId"],
+    ["session_id"],
+    ["sessionId"],
+    ["session", "id"]
+  ]);
+  if (!agentSessionId) {
+    return {
+      ...base,
+      diagnosticReason: "missing_agent_session_id"
+    };
+  }
+  return {
+    ...base,
+    agentSessionId,
+    agentSessionKey: agentSessionKey(base.source, agentSessionId)
+  };
+}
+function agentSessionKey(source, agentSessionId) {
+  return `${source}:${stableHash(agentSessionId)}`;
+}
+function defaultAgentLoopState() {
+  return {
+    version: 2,
+    sessions: {}
+  };
+}
+function randomCheckpointThreshold() {
+  return defaultCheckpointThresholdMin + Math.floor(Math.random() * (defaultCheckpointThresholdMax - defaultCheckpointThresholdMin + 1));
+}
+function agentLoopDirectory(parsed, options) {
+  return parsed.options["state-dir"] ? isAbsolute(parsed.options["state-dir"]) ? parsed.options["state-dir"] : join(options.cwd ?? process.cwd(), parsed.options["state-dir"]) : join(options.cwd ?? process.cwd(), ".context", "cadence-agent-loop");
+}
+function agentLoopStatePath(parsed, options) {
+  return join(agentLoopDirectory(parsed, options), "state.json");
+}
+function agentLoopLockPath(parsed, options, agentSessionKeyValue) {
+  return join(agentLoopDirectory(parsed, options), agentSessionKeyValue ? `closeout-${stableHash(agentSessionKeyValue)}.lock` : "closeout.lock");
+}
+async function readAgentLoopState(parsed, options) {
+  const filePath = agentLoopStatePath(parsed, options);
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    return defaultAgentLoopState();
+  }
+  const parsedState = JSON.parse(await file.text());
+  if (!parsedState || typeof parsedState !== "object" || Array.isArray(parsedState)) {
+    return defaultAgentLoopState();
+  }
+  const record = parsedState;
+  if (record.version === 2) {
+    return {
+      version: 2,
+      sessions: readAgentLoopSessions(record.sessions),
+      ...record.diagnostics && typeof record.diagnostics === "object" && !Array.isArray(record.diagnostics) ? { diagnostics: readAgentLoopDiagnostics(record.diagnostics) } : {}
+    };
+  }
+  return {
+    version: 2,
+    sessions: {},
+    diagnostics: {
+      migratedLegacyRepoCounter: "stopCount" in record
+    }
+  };
+}
+async function writeAgentLoopState(parsed, options, state) {
+  const filePath = agentLoopStatePath(parsed, options);
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(state, null, 2)}
+`);
+}
+function readAgentLoopSessions(rawSessions) {
+  const sessions = {};
+  if (!rawSessions || typeof rawSessions !== "object" || Array.isArray(rawSessions)) {
+    return sessions;
+  }
+  for (const [key, rawSession] of Object.entries(rawSessions)) {
+    if (!rawSession || typeof rawSession !== "object" || Array.isArray(rawSession)) {
+      continue;
+    }
+    const record = rawSession;
+    const source = parseAgentEventSource(typeof record.source === "string" ? record.source : undefined);
+    const stopCount = typeof record.stopCount === "number" && Number.isInteger(record.stopCount) && record.stopCount >= 0 ? record.stopCount : 0;
+    const threshold = typeof record.threshold === "number" && Number.isInteger(record.threshold) && record.threshold > 0 ? record.threshold : randomCheckpointThreshold();
+    sessions[key] = {
+      source,
+      stopCount,
+      threshold,
+      ...typeof record.firstObservedAt === "string" ? { firstObservedAt: record.firstObservedAt } : {},
+      ...typeof record.lastObservedAt === "string" ? { lastObservedAt: record.lastObservedAt } : {},
+      ...typeof record.lastAction === "string" ? { lastAction: record.lastAction } : {},
+      ...typeof record.lastReason === "string" ? { lastReason: record.lastReason } : {},
+      ...typeof record.lastEventFile === "string" ? { lastEventFile: record.lastEventFile } : {},
+      ...typeof record.lastAssistantMessage === "string" ? { lastAssistantMessage: record.lastAssistantMessage } : {},
+      ...typeof record.lastCheckpointAt === "string" ? { lastCheckpointAt: record.lastCheckpointAt } : {},
+      ...typeof record.lastCheckpointFingerprint === "string" ? { lastCheckpointFingerprint: record.lastCheckpointFingerprint } : {},
+      ...typeof record.previousCheckpointSummary === "string" ? { previousCheckpointSummary: record.previousCheckpointSummary } : {}
+    };
+  }
+  return sessions;
+}
+function readAgentLoopDiagnostics(record) {
+  return {
+    ...typeof record.missingSessionIdCount === "number" && Number.isInteger(record.missingSessionIdCount) && record.missingSessionIdCount > 0 ? { missingSessionIdCount: record.missingSessionIdCount } : {},
+    ...typeof record.lastMissingSessionIdAt === "string" ? { lastMissingSessionIdAt: record.lastMissingSessionIdAt } : {},
+    ...typeof record.lastMissingSessionIdSource === "string" ? { lastMissingSessionIdSource: parseAgentEventSource(record.lastMissingSessionIdSource) } : {},
+    ...Array.isArray(record.lastMissingSessionIdPayloadKeys) ? { lastMissingSessionIdPayloadKeys: record.lastMissingSessionIdPayloadKeys.filter((key) => typeof key === "string") } : {},
+    ...typeof record.migratedLegacyRepoCounter === "boolean" ? { migratedLegacyRepoCounter: record.migratedLegacyRepoCounter } : {}
+  };
+}
+function recordMissingAgentSessionId(state, event) {
+  return {
+    ...state,
+    diagnostics: {
+      ...state.diagnostics ?? {},
+      missingSessionIdCount: (state.diagnostics?.missingSessionIdCount ?? 0) + 1,
+      lastMissingSessionIdAt: new Date().toISOString(),
+      lastMissingSessionIdSource: event.source,
+      lastMissingSessionIdPayloadKeys: event.payloadKeys
+    }
+  };
+}
+function clearAgentSessionReason(state) {
+  const { lastReason: _lastReason, ...stateWithoutReason } = state;
+  return stateWithoutReason;
+}
+async function writeAgentEventFile(parsed, options, event) {
+  const eventsDirectory = join(agentLoopDirectory(parsed, options), "events");
+  const fileName = `${new Date().toISOString().replace(/[:.]/g, "-")}-${randomUUID()}.json`;
+  const filePath = join(eventsDirectory, fileName);
+  await mkdir(eventsDirectory, { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(event, null, 2)}
+`);
+  return filePath;
+}
+async function removeStaleAgentLoopLock(lockPath) {
+  try {
+    const lockStats = await stat(lockPath);
+    if (Date.now() - lockStats.mtimeMs < defaultCheckpointWorkerTimeoutMs) {
+      return false;
+    }
+    await rm(lockPath, { recursive: true, force: true });
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function acquireAgentLoopLock(parsed, options, agentSessionKeyValue) {
+  const lockPath = agentLoopLockPath(parsed, options, agentSessionKeyValue);
+  await mkdir(dirname(lockPath), { recursive: true });
+  try {
+    await mkdir(lockPath);
+    await writeFile(join(lockPath, "holder.json"), `${JSON.stringify({ pid: process.pid, acquiredAt: new Date().toISOString() }, null, 2)}
+`);
+    return { acquired: true, lockPath };
+  } catch (error) {
+    if (!error || typeof error !== "object" || !("code" in error) || error.code !== "EEXIST") {
+      throw error;
+    }
+    if (await removeStaleAgentLoopLock(lockPath)) {
+      await mkdir(lockPath);
+      await writeFile(join(lockPath, "holder.json"), `${JSON.stringify({ pid: process.pid, acquiredAt: new Date().toISOString(), recoveredStale: true }, null, 2)}
+`);
+      return { acquired: true, lockPath };
+    }
+    return { acquired: false, lockPath };
+  }
+}
+async function releaseAgentLoopLock(lockPath) {
+  if (lockPath) {
+    await rm(lockPath, { recursive: true, force: true });
+  }
+}
+function runLocalCommand(command, args, options, commandOptions = {}) {
+  if (options.runCommand) {
+    return options.runCommand(command, args, commandOptions);
+  }
+  const result = spawnSync(command, [...args], {
+    cwd: commandOptions.cwd,
+    env: {
+      ...process.env,
+      ...commandOptions.env ?? {}
+    },
+    encoding: "utf8",
+    timeout: commandOptions.timeoutMs,
+    maxBuffer: 1024 * 1024
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    ...result.error ? { error: result.error } : {}
+  };
+}
+function gitOutput(args, options) {
+  const result = runLocalCommand("git", args, options, {
+    cwd: options.cwd ?? process.cwd(),
+    timeoutMs: 1e4
+  });
+  if (result.status !== 0) {
+    return "";
+  }
+  return result.stdout.trim();
+}
+function currentCliWorkerInvocation() {
+  const scriptPath = Bun.argv[1];
+  if (scriptPath) {
+    return {
+      command: process.execPath,
+      argsPrefix: [scriptPath]
+    };
+  }
+  return {
+    command: "cadence",
+    argsPrefix: []
+  };
+}
+async function spawnAgentRunCloseout(args, options) {
+  const cwd = options.cwd ?? process.cwd();
+  const invocation = currentCliWorkerInvocation();
+  const env = {
+    ...process.env,
+    [agentLoopSuppressEnv]: "1"
+  };
+  if (options.spawnDetached) {
+    await options.spawnDetached(invocation.command, [...invocation.argsPrefix, ...args], { cwd, env });
+    return;
+  }
+  const child = spawn(invocation.command, [...invocation.argsPrefix, ...args], {
+    cwd,
+    env,
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+}
+function activeSessionFromCurrent(current) {
+  const record = current && typeof current === "object" ? current : null;
+  const sessions = Array.isArray(record?.sessions) ? record.sessions : [];
+  const activeSession = sessions.find((session) => {
+    if (!session || typeof session !== "object") {
+      return false;
+    }
+    const sessionRecord2 = session;
+    return sessionRecord2.status === "active" && typeof sessionRecord2.ticketId === "string";
+  });
+  if (activeSession && typeof activeSession === "object") {
+    return activeSession;
+  }
+  const activeLeases = Array.isArray(record?.activeLeases) ? record.activeLeases : Array.isArray(record?.leases) ? record.leases.filter((lease) => lease && typeof lease === "object" && lease.status === "active") : [];
+  const activeLease = activeLeases.find((lease) => {
+    if (!lease || typeof lease !== "object") {
+      return false;
+    }
+    const leaseRecord2 = lease;
+    return typeof leaseRecord2.ticketId === "string";
+  });
+  if (!activeLease || typeof activeLease !== "object") {
+    return null;
+  }
+  const leaseRecord = activeLease;
+  const sessionId = typeof leaseRecord.sessionId === "string" ? leaseRecord.sessionId : undefined;
+  const matchingSession = sessions.find((session) => {
+    if (!session || typeof session !== "object") {
+      return false;
+    }
+    return sessionId && session.id === sessionId;
+  });
+  const sessionRecord = matchingSession && typeof matchingSession === "object" ? matchingSession : {};
+  return {
+    ...sessionRecord,
+    ...sessionId ? { id: sessionId } : {},
+    ticketId: leaseRecord.ticketId,
+    ...typeof leaseRecord.changesetId === "string" ? { changesetId: leaseRecord.changesetId } : typeof sessionRecord.changesetId === "string" ? { changesetId: sessionRecord.changesetId } : {},
+    status: "active"
+  };
+}
+function fingerprintForCheckpoint(event, options) {
+  const status = gitOutput(["status", "--short"], options);
+  const changedFiles = gitOutput(["diff", "--name-only", "origin/dev..."], options);
+  return stableHash(JSON.stringify({
+    source: event.source,
+    event: event.event,
+    lastAssistantMessage: event.lastAssistantMessage ?? "",
+    status,
+    changedFiles
+  }));
+}
+function shouldSkipForCooldown(state, cooldownSeconds) {
+  if (!state.lastCheckpointAt) {
+    return false;
+  }
+  const lastCheckpointMs = new Date(state.lastCheckpointAt).getTime();
+  return !Number.isNaN(lastCheckpointMs) && Date.now() - lastCheckpointMs < cooldownSeconds * 1000;
+}
+function synthesizeAgentEventFromSession(agentSessionKeyValue, session, options) {
+  return {
+    source: session.source,
+    event: "closeout",
+    workspacePath: options.cwd ?? process.cwd(),
+    occurredAt: new Date().toISOString(),
+    agentSessionKey: agentSessionKeyValue,
+    ...session.lastAssistantMessage ? { lastAssistantMessage: session.lastAssistantMessage } : {},
+    payloadKeys: []
+  };
+}
+function parseCheckpointJson(raw) {
+  const trimmed = raw.trim();
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (parsed && typeof parsed === "object") {
+      const record = parsed;
+      return {
+        body: typeof record.body === "string" && record.body.trim() ? record.body.trim() : trimmed,
+        summary: typeof record.summary === "string" && record.summary.trim() ? record.summary.trim() : undefined
+      };
+    }
+  } catch {
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      try {
+        const parsed = JSON.parse(trimmed.slice(start, end + 1));
+        if (parsed && typeof parsed === "object") {
+          const record = parsed;
+          return {
+            body: typeof record.body === "string" && record.body.trim() ? record.body.trim() : trimmed,
+            summary: typeof record.summary === "string" && record.summary.trim() ? record.summary.trim() : undefined
+          };
+        }
+      } catch {}
+    }
+  }
+  return {
+    body: trimmed,
+    summary: undefined
+  };
+}
+function buildCheckpointPrompt(input) {
+  return [
+    "You are generating a concise Cadence checkpoint for an active coding session.",
+    "Do not include raw diffs, raw transcripts, terminal logs, tool streams, secrets, or model reasoning.",
+    'Return JSON only with this shape: {"summary":"one short current work summary","body":"checkpoint body suitable for a Cadence ticket work log"}.',
+    "The body should mention what changed, decisions made, verification if known, and the next risk or next step. Keep it under 1200 characters.",
+    "",
+    `Ticket: ${input.ticketId}`,
+    input.sessionId ? `Session: ${input.sessionId}` : "",
+    input.changesetId ? `ChangeSet: ${input.changesetId}` : "",
+    `Agent event: ${input.event.source}/${input.event.event}`,
+    input.previousCheckpointSummary ? `Previous checkpoint summary: ${input.previousCheckpointSummary}` : "",
+    input.event.lastAssistantMessage ? `Last assistant message:
+${truncateText(input.event.lastAssistantMessage, 3000)}` : "Last assistant message: unavailable",
+    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(`
+`);
+}
+async function findRepoRoot(cwd) {
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd,
+    encoding: "utf8"
+  });
+  if (result.status === 0 && result.stdout.trim()) {
+    return result.stdout.trim();
+  }
+  const cadenceDirectory = await findRepoCadenceDirectory(cwd);
+  return cadenceDirectory ? dirname(cadenceDirectory) : cwd;
+}
+function codexHookEntry(command) {
+  return {
+    hooks: [
+      {
+        type: "command",
+        command,
+        timeout: 5,
+        statusMessage: "Checking Cadence checkpoint"
+      }
+    ]
+  };
+}
+async function readJsonObjectFile(filePath) {
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    return {};
+  }
+  return tryParseJsonObject(await file.text(), filePath);
+}
+async function installCodexHookFile(filePath, command) {
+  const existing = await readJsonObjectFile(filePath);
+  const hooksValue = existing.hooks;
+  const hooks = hooksValue && typeof hooksValue === "object" && !Array.isArray(hooksValue) ? hooksValue : {};
+  const stopValue = hooks.Stop;
+  const stopHooks = Array.isArray(stopValue) ? stopValue : [];
+  const alreadyInstalled = stopHooks.some((entry) => JSON.stringify(entry).includes(command));
+  const nextStopHooks = alreadyInstalled ? stopHooks : [...stopHooks, codexHookEntry(command)];
+  const nextConfig = {
+    ...existing,
+    hooks: {
+      ...hooks,
+      Stop: nextStopHooks
+    }
+  };
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(nextConfig, null, 2)}
+`);
+  return {
+    path: filePath,
+    installed: !alreadyInstalled,
+    alreadyInstalled
+  };
+}
+async function codexHookPaths(scope, options) {
+  const cwd = options.cwd ?? process.cwd();
+  const paths = [];
+  if (scope === "repo" || scope === "both") {
+    paths.push(join(await findRepoRoot(cwd), ".codex", "hooks.json"));
+  }
+  if (scope === "global" || scope === "both") {
+    const home = options.env?.HOME ?? process.env.HOME;
+    if (!home) {
+      throw new CliError("CONFIG_ERROR", "HOME is required for global hook installation.");
+    }
+    paths.push(join(home, ".codex", "hooks.json"));
+  }
+  return paths;
+}
+async function codexHookInstalled(filePath, command) {
+  const existing = await readJsonObjectFile(filePath);
+  const hooks = existing.hooks;
+  const stopHooks = hooks && typeof hooks === "object" && !Array.isArray(hooks) && Array.isArray(hooks.Stop) ? hooks.Stop : [];
+  return stopHooks.some((entry) => JSON.stringify(entry).includes(command));
+}
 async function runStatus(parsed, options) {
   const config = await resolveCliConfig(parsed.flags, options);
   const store = getCredentialStore(options);
@@ -2477,21 +3099,8 @@ async function runStatus(parsed, options) {
       exitCode: 0
     };
   }
-  const projectLabel = config.projectId ?? "not configured";
-  const profileLabel = config.profile ?? "default";
-  const credentialLabel = credential ? "configured" : "not configured";
   return {
-    stdout: [
-      `Cadence API: ${health.ok ? "ok" : "unavailable"} at ${config.server}`,
-      `Cadence web: ${webBaseUrl}`,
-      `Profile: ${profileLabel}`,
-      `Project: ${projectLabel}`,
-      `Credential: ${credentialLabel}`,
-      `Repo config: ${config.repoConfigPath ?? "not found"}`,
-      `Local config: ${config.localConfigPath ?? "not found"}`,
-      `Global config: ${config.globalConfigPath}`
-    ].join(`
-`) + `
+    stdout: `Cadence API ${health.ok ? "ok" : "unavailable"} at ${config.server}
 `,
     stderr: "",
     exitCode: 0
@@ -2499,7 +3108,7 @@ async function runStatus(parsed, options) {
 }
 async function runInit(parsed, options) {
   const cwd = options.cwd ?? process.cwd();
-  const repoConfigPath = await repoConfigPathForWrite(options);
+  const repoConfigPath = join(cwd, ".cadence", "config.json");
   const config = await resolveCliConfig(parsed.flags, {
     ...options,
     cwd
@@ -2557,15 +3166,6 @@ async function resolveProjectReference(projectReference, client) {
     projectSlug
   });
 }
-async function resolveRequiredProject(config, client) {
-  return await resolveProjectReference(requireProjectId(config), client);
-}
-function configWithProject(config, project) {
-  return {
-    ...config,
-    projectId: project.id
-  };
-}
 function formatProjectChoice(project, index) {
   const slug = project.orgSlug && project.projectSlug ? `${project.orgSlug}/${project.projectSlug}` : project.id;
   const name = project.name ? ` ${project.name}` : "";
@@ -2608,17 +3208,579 @@ async function selectProject(parsed, client, options) {
   }
   return matching;
 }
+async function runAgentRunCommand(parsed, options) {
+  const config = await resolveCliConfig(parsed.flags, options);
+  const projectId = config.projectId;
+  const meta = commandMeta(parsed, config);
+  switch (parsed.command.name) {
+    case "agent-run.ingest-stop":
+      return await runAgentRunIngestStop(parsed, options, config, meta);
+    case "agent-run.closeout":
+      return await runAgentRunCloseout(parsed, options, config, meta);
+    case "agent-run.sweep":
+      return await runAgentRunSweep(parsed, options, meta);
+    case "agent-run.doctor": {
+      const state = await readAgentLoopState(parsed, options);
+      const data = {
+        action: "doctor",
+        state,
+        sessionCount: Object.keys(state.sessions).length,
+        pendingSessions: Object.entries(state.sessions).filter(([, session]) => session.stopCount > 0).map(([agentSessionKeyValue, session]) => ({
+          agentSessionKey: agentSessionKeyValue,
+          source: session.source,
+          stopCount: session.stopCount,
+          threshold: session.threshold,
+          lastObservedAt: session.lastObservedAt,
+          lastAction: session.lastAction
+        }))
+      };
+      return {
+        stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+        stderr: "",
+        exitCode: 0
+      };
+    }
+    default:
+      throw new CliError("CLI_USAGE", `Unknown command: ${parsed.command.path.join(" ")}`);
+  }
+}
+async function runAgentRunIngestStop(parsed, options, config, meta) {
+  const suppressed = options.env?.[agentLoopSuppressEnv] === "1" || options.env?.CADENCE_HOOK_SUPPRESS === "1" || options.env?.CADENCE_STOP_HOOK_SUPPRESS === "1" || process.env[agentLoopSuppressEnv] === "1" || process.env.CADENCE_HOOK_SUPPRESS === "1" || process.env.CADENCE_STOP_HOOK_SUPPRESS === "1";
+  if (suppressed) {
+    const data2 = {
+      action: "skipped",
+      reason: "suppressed"
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const rawInput = await readStdin(options);
+  const normalized = normalizeAgentEvent(tryParseJsonObject(rawInput, "agent event input"), parsed, options);
+  const projectId = config.projectId;
+  if (!projectId) {
+    const data2 = {
+      action: "skipped",
+      reason: "no_project",
+      event: normalized
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const state = await readAgentLoopState(parsed, options);
+  if (!normalized.agentSessionKey) {
+    const nextState = recordMissingAgentSessionId(state, normalized);
+    await writeAgentLoopState(parsed, options, nextState);
+    const data2 = {
+      action: "skipped",
+      reason: normalized.diagnosticReason ?? "missing_agent_session_id",
+      event: normalized,
+      diagnostics: nextState.diagnostics
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const forcedThreshold = parsePositiveInteger(parsed.options.threshold, "--threshold");
+  const cooldownSeconds = parsePositiveInteger(parsed.options["cooldown-seconds"], "--cooldown-seconds") ?? defaultCheckpointCooldownSeconds;
+  const dryRun = parseBooleanOption(parsed.options["dry-run"], false);
+  const existingSession = state.sessions[normalized.agentSessionKey];
+  const now = new Date().toISOString();
+  const threshold = forcedThreshold ?? existingSession?.threshold ?? randomCheckpointThreshold();
+  const nextCount = (existingSession?.stopCount ?? 0) + 1;
+  const observedSession = {
+    ...clearAgentSessionReason(existingSession ?? {
+      source: normalized.source,
+      stopCount: 0,
+      threshold
+    }),
+    source: normalized.source,
+    stopCount: nextCount,
+    threshold,
+    firstObservedAt: existingSession?.firstObservedAt ?? now,
+    lastObservedAt: now,
+    lastAction: "counted",
+    ...normalized.lastAssistantMessage ? { lastAssistantMessage: normalized.lastAssistantMessage } : {}
+  };
+  const countedState = {
+    ...state,
+    sessions: {
+      ...state.sessions,
+      [normalized.agentSessionKey]: observedSession
+    }
+  };
+  if (nextCount < threshold) {
+    await writeAgentLoopState(parsed, options, countedState);
+    const data2 = {
+      action: "counted",
+      agentSessionKey: normalized.agentSessionKey,
+      stopCount: nextCount,
+      threshold
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  if (shouldSkipForCooldown(observedSession, cooldownSeconds)) {
+    await writeAgentLoopState(parsed, options, {
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [normalized.agentSessionKey]: {
+          ...observedSession,
+          lastAction: "skipped",
+          lastReason: "cooldown"
+        }
+      }
+    });
+    const data2 = {
+      action: "skipped",
+      reason: "cooldown",
+      agentSessionKey: normalized.agentSessionKey,
+      stopCount: nextCount,
+      threshold
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const fingerprint = fingerprintForCheckpoint(normalized, options);
+  if (observedSession.lastCheckpointFingerprint && observedSession.lastCheckpointFingerprint === fingerprint) {
+    await writeAgentLoopState(parsed, options, {
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [normalized.agentSessionKey]: {
+          ...observedSession,
+          stopCount: 0,
+          threshold: randomCheckpointThreshold(),
+          lastAction: "skipped",
+          lastReason: "unchanged"
+        }
+      }
+    });
+    const data2 = {
+      action: "skipped",
+      reason: "unchanged",
+      agentSessionKey: normalized.agentSessionKey
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const eventFile = await writeAgentEventFile(parsed, options, normalized);
+  const lockPath = agentLoopLockPath(parsed, options, normalized.agentSessionKey);
+  const workerArgs = [
+    "agent-run",
+    "closeout",
+    "--agent-session-key",
+    normalized.agentSessionKey,
+    "--reason",
+    "threshold",
+    "--event-file",
+    eventFile,
+    "--lock",
+    lockPath,
+    ...parsed.options["log-kind"] ? ["--log-kind", parsed.options["log-kind"]] : [],
+    ...parsed.options["update-summary"] ? ["--update-summary", parsed.options["update-summary"]] : [],
+    ...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_spawn",
+          lastEventFile: eventFile
+        }
+      }
+    });
+    const data2 = {
+      action: "would_spawn",
+      agentSessionKey: normalized.agentSessionKey,
+      eventFile,
+      workerArgs
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const lock = await acquireAgentLoopLock(parsed, options, normalized.agentSessionKey);
+  if (!lock.acquired) {
+    await writeAgentLoopState(parsed, options, {
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [normalized.agentSessionKey]: {
+          ...observedSession,
+          lastAction: "skipped",
+          lastReason: "lock_held"
+        }
+      }
+    });
+    const data2 = {
+      action: "skipped",
+      reason: "lock_held",
+      lockPath: lock.lockPath,
+      agentSessionKey: normalized.agentSessionKey
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data2, meta)) : `${JSON.stringify(data2, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  try {
+    await spawnAgentRunCloseout(workerArgs, options);
+  } catch (error) {
+    await releaseAgentLoopLock(lock.lockPath);
+    throw error;
+  }
+  await writeAgentLoopState(parsed, options, {
+    ...state,
+    sessions: {
+      ...state.sessions,
+      [normalized.agentSessionKey]: {
+        ...observedSession,
+        stopCount: 0,
+        threshold: randomCheckpointThreshold(),
+        lastAction: "spawned",
+        lastEventFile: eventFile,
+        lastCheckpointAt: new Date().toISOString(),
+        lastCheckpointFingerprint: fingerprint
+      }
+    }
+  });
+  const data = {
+    action: "spawned",
+    agentSessionKey: normalized.agentSessionKey,
+    eventFile,
+    lockPath: lock.lockPath
+  };
+  return {
+    stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+    stderr: "",
+    exitCode: 0
+  };
+}
+async function runAgentRunCloseout(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 current = await client.sessions.current({
+    projectId,
+    filters: {
+      limit: 100
+    }
+  });
+  const currentSession = activeSessionFromCurrent(current);
+  const ticketId = parsed.options.ticket ?? (currentSession && typeof currentSession.ticketId === "string" ? currentSession.ticketId : undefined);
+  const sessionId = parsed.options.session ?? (currentSession && typeof currentSession.id === "string" ? currentSession.id : undefined);
+  const changesetId = parsed.options.changeset ?? (currentSession && typeof currentSession.changesetId === "string" ? currentSession.changesetId : undefined);
+  if (!ticketId) {
+    await writeAgentLoopState(parsed, options, {
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [agentSessionKeyValue]: {
+          ...sessionState,
+          lastAction: "skipped",
+          lastReason: "no_active_ticket"
+        }
+      }
+    });
+    const data = {
+      action: "skipped",
+      reason: "no_active_ticket",
+      agentSessionKey: agentSessionKeyValue
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  const eventFile = parsed.options["event-file"] ?? sessionState.lastEventFile;
+  const event = eventFile ? tryParseJsonObject(await readFile(eventFile, "utf8"), eventFile) : synthesizeAgentEventFromSession(agentSessionKeyValue, sessionState, options);
+  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 lockPath = parsed.options.lock;
+  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 = buildCheckpointPrompt({
+    event,
+    ticketId,
+    ...sessionId ? { sessionId } : {},
+    ...changesetId ? { changesetId } : {},
+    gitStatus,
+    gitDiffStat,
+    changedFiles,
+    ...sessionState.previousCheckpointSummary ? { previousCheckpointSummary: sessionState.previousCheckpointSummary } : {}
+  });
+  if (dryRun) {
+    const data = {
+      action: "would_closeout",
+      prompt,
+      ticketId,
+      agentSessionKey: agentSessionKeyValue,
+      ...sessionId ? { sessionId } : {},
+      ...changesetId ? { changesetId } : {}
+    };
+    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 codex = runLocalCommand(codexCommand, ["exec", "--disable", "hooks", "--sandbox", "read-only", "-C", options.cwd ?? process.cwd(), prompt], options, {
+      cwd: options.cwd ?? process.cwd(),
+      env: {
+        [agentLoopSuppressEnv]: "1",
+        CADENCE_HOOK_SUPPRESS: "1"
+      },
+      timeoutMs: defaultCheckpointWorkerTimeoutMs
+    });
+    if (codex.status !== 0 || codex.error) {
+      throw new CliError("AGENT_RUN_CLOSEOUT_FAILED", "Codex closeout generation failed.", {
+        status: codex.status,
+        stderr: truncateText(codex.stderr, 2000),
+        error: codex.error?.message
+      });
+    }
+    const checkpoint = parseCheckpointJson(codex.stdout);
+    const body = checkpoint.body.trim();
+    const summary = checkpoint.summary ?? truncateText(body.replace(/\s+/g, " "), 500);
+    if (!body) {
+      throw new CliError("AGENT_RUN_CLOSEOUT_FAILED", "Codex closeout generation returned an empty checkpoint.");
+    }
+    await client.tickets.log({
+      projectId,
+      ticketId,
+      entry: {
+        entryKind: logKind,
+        body,
+        summary,
+        ...sessionId ? { sessionId } : {},
+        ...changesetId ? { changesetId } : {},
+        ...commandMetadata()
+      }
+    });
+    if (updateSummary) {
+      const ticket = await client.tickets.get({ projectId, ticketId });
+      if (typeof ticket.projectionVersion === "number") {
+        await client.tickets.update({
+          projectId,
+          ticketId,
+          ifVersion: ticket.projectionVersion,
+          ticket: {
+            currentSummary: summary,
+            ...commandMetadata()
+          }
+        });
+      }
+    }
+    await writeAgentLoopState(parsed, options, {
+      ...state,
+      sessions: {
+        ...state.sessions,
+        [agentSessionKeyValue]: {
+          ...sessionState,
+          previousCheckpointSummary: summary,
+          lastAction: "closed_out",
+          ...eventFile ? { lastEventFile: eventFile } : {}
+        }
+      }
+    });
+    const data = {
+      action: "closed_out",
+      ticketId,
+      summary,
+      agentSessionKey: agentSessionKeyValue,
+      ...sessionId ? { sessionId } : {},
+      ...changesetId ? { changesetId } : {}
+    };
+    return {
+      stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+      stderr: "",
+      exitCode: 0
+    };
+  } finally {
+    await releaseAgentLoopLock(lockPath);
+  }
+}
+async function runAgentRunSweep(parsed, options, meta) {
+  const state = await readAgentLoopState(parsed, options);
+  const idleAfterSeconds = parsePositiveInteger(parsed.options["idle-after-seconds"], "--idle-after-seconds") ?? 5 * 60;
+  const dryRun = parseBooleanOption(parsed.options["dry-run"], false);
+  const nowMs = Date.now();
+  const staleSessions = Object.entries(state.sessions).filter(([, session]) => {
+    if (session.stopCount <= 0 || !session.lastObservedAt) {
+      return false;
+    }
+    const lastObservedMs = new Date(session.lastObservedAt).getTime();
+    return !Number.isNaN(lastObservedMs) && nowMs - lastObservedMs >= idleAfterSeconds * 1000;
+  }).map(([agentSessionKeyValue, session]) => ({
+    agentSessionKey: agentSessionKeyValue,
+    source: session.source,
+    stopCount: session.stopCount,
+    threshold: session.threshold,
+    lastObservedAt: session.lastObservedAt
+  }));
+  if (!dryRun) {
+    for (const staleSession of staleSessions) {
+      await spawnAgentRunCloseout([
+        "agent-run",
+        "closeout",
+        "--agent-session-key",
+        staleSession.agentSessionKey,
+        "--reason",
+        "idle",
+        "--lock",
+        agentLoopLockPath(parsed, options, staleSession.agentSessionKey),
+        ...parsed.flags.project ? ["--project", parsed.flags.project] : [],
+        ...parsed.flags.server ? ["--server", parsed.flags.server] : []
+      ], options);
+    }
+  }
+  const data = {
+    action: dryRun ? "would_sweep" : "swept",
+    idleAfterSeconds,
+    staleSessions
+  };
+  return {
+    stdout: parsed.flags.json ? formatJson(successEnvelope(data, meta)) : `${JSON.stringify(data, null, 2)}
+`,
+    stderr: "",
+    exitCode: 0
+  };
+}
+async function runHooksCommand(parsed, options) {
+  const config = await resolveCliConfig(parsed.flags, options);
+  const meta = commandMeta(parsed, config);
+  let data;
+  switch (parsed.command.name) {
+    case "hooks.install":
+      {
+        const provider = parsed.options.provider ?? "codex";
+        if (provider !== "codex") {
+          throw new CliError("CLI_USAGE", "Only --provider codex is supported for hook installation in this version.");
+        }
+        const scope = parseHookScope(parsed.options.scope);
+        const command = parsed.options.command ?? defaultHookCommand;
+        const paths = await codexHookPaths(scope, options);
+        const results = [];
+        for (const filePath of paths) {
+          results.push(await installCodexHookFile(filePath, command));
+        }
+        data = {
+          provider,
+          scope,
+          command,
+          results,
+          trustRequired: "Open Codex /hooks and trust the Cadence hook before it can run."
+        };
+      }
+      break;
+    case "hooks.doctor":
+      {
+        const provider = parsed.options.provider ?? "codex";
+        if (provider !== "codex") {
+          throw new CliError("CLI_USAGE", "Only --provider codex is supported for hook doctor in this version.");
+        }
+        const scope = parseHookScope(parsed.options.scope);
+        const command = parsed.options.command ?? defaultHookCommand;
+        const paths = await codexHookPaths(scope, options);
+        const codexVersion = runLocalCommand("codex", ["--version"], options, {
+          cwd: options.cwd ?? process.cwd(),
+          timeoutMs: 1e4
+        });
+        data = {
+          provider,
+          scope,
+          command,
+          codexAvailable: codexVersion.status === 0,
+          codexVersion: codexVersion.status === 0 ? codexVersion.stdout.trim() : null,
+          hooks: await Promise.all(paths.map(async (filePath) => ({
+            path: filePath,
+            exists: await Bun.file(filePath).exists(),
+            installed: await codexHookInstalled(filePath, command)
+          })))
+        };
+      }
+      break;
+    default:
+      throw new CliError("CLI_USAGE", `Unknown command: ${parsed.command.path.join(" ")}`);
+  }
+  if (parsed.flags.json) {
+    return {
+      stdout: formatJson(successEnvelope(data, meta)),
+      stderr: "",
+      exitCode: 0
+    };
+  }
+  return {
+    stdout: `${JSON.stringify(data, null, 2)}
+`,
+    stderr: "",
+    exitCode: 0
+  };
+}
 async function runAuthCommand(parsed, options) {
   const config = await resolveCliConfig(parsed.flags, options);
   const store = getCredentialStore(options);
-  const meta = commandMeta(parsed, config);
+  let meta = commandMeta(parsed, config);
   let data;
   switch (parsed.command.name) {
     case "auth.login":
       {
-        const client = await createClient(config, options, false);
+        const loginConfig = await resolveAuthLoginConfig(config, parsed, options);
+        meta = commandMeta(parsed, loginConfig);
+        const client = await createClient(loginConfig, options, false);
+        const loginBaseUrl = loginConfig.webBaseUrl;
         const challenge = await client.auth.cli.start({
-          loginBaseUrl: getCliWebBaseUrl(config, parsed, options)
+          loginBaseUrl
         });
         if (parsed.flags.json || !isInteractive(options)) {
           throw new CliError("HUMAN_AUTH_REQUIRED", "Cadence login must be completed by a human in the browser.", {
@@ -2650,20 +3812,15 @@ async function runAuthCommand(parsed, options) {
         if (poll.status === "denied") {
           throw new CliError("AUTH_LOGIN_DENIED", "Cadence browser login was denied.");
         }
-        await writeStoredCredential(store, config.server, poll.credential);
-        await mergeConfigFile(config.globalConfigPath, { server: config.server });
+        await writeStoredCredential(store, loginConfig.server, poll.credential);
+        await mergeConfigFile(loginConfig.globalConfigPath, { server: loginConfig.server, webBaseUrl: loginBaseUrl });
         await writeInteractiveStatus("Cadence CLI login approved. Credential stored.", options);
-        const projectConfigured = Boolean(config.projectId);
-        if (!projectConfigured) {
-          await writeInteractiveStatus("No Cadence project is configured for this repo. Run cadence init to choose one.", options);
-        }
         data = {
-          server: config.server,
+          server: loginConfig.server,
+          webBaseUrl: loginBaseUrl,
           credentialStored: true,
-          projectConfigured,
-          globalConfigPath: config.globalConfigPath,
-          loginUrl: challenge.loginUrl,
-          ...!projectConfigured ? { nextCommand: "cadence init" } : {}
+          globalConfigPath: loginConfig.globalConfigPath,
+          loginUrl: challenge.loginUrl
         };
       }
       break;
@@ -2710,11 +3867,9 @@ async function runAuthCommand(parsed, options) {
 }
 async function runReadCommand(parsed, options) {
   const config = await resolveCliConfig(parsed.flags, options);
+  const projectId = requireProjectId(config);
   const client = await createClient(config, options);
-  const project = await resolveRequiredProject(config, client);
-  const resolvedConfig = configWithProject(config, project);
-  const projectId = project.id;
-  const meta = commandMeta(parsed, resolvedConfig);
+  const meta = commandMeta(parsed, config);
   let data;
   switch (parsed.command.name) {
     case "events.list":
@@ -2816,47 +3971,18 @@ async function runReadCommand(parsed, options) {
 async function runProjectCommand(parsed, options) {
   const config = await resolveCliConfig(parsed.flags, options);
   const client = await createClient(config, options);
+  const meta = commandMeta(parsed, config);
   let data;
-  let outputConfig = config;
   switch (parsed.command.name) {
     case "projects.list":
       data = await client.projects.list();
       break;
-    case "projects.use":
-      {
-        const project = await resolveProjectReference(requireArg(parsed, 0, "<project-id|org/project>"), client);
-        const repoConfigPath = await repoConfigPathForWrite(options);
-        const updates = {
-          projectId: project.id,
-          ...parsed.flags.server ? { server: parsed.flags.server } : {}
-        };
-        await mergeConfigFile(repoConfigPath, updates);
-        outputConfig = configWithProject(config, project);
-        data = {
-          repoConfigPath,
-          projectId: project.id,
-          project,
-          ...parsed.flags.server ? { server: parsed.flags.server } : {}
-        };
-      }
-      break;
     default:
       throw new CliError("CLI_USAGE", `Unknown command: ${parsed.command.path.join(" ")}`);
   }
   if (parsed.flags.json) {
     return {
-      stdout: formatJson(successEnvelope(data, commandMeta(parsed, outputConfig))),
-      stderr: "",
-      exitCode: 0
-    };
-  }
-  if (parsed.command.name === "projects.use") {
-    const project = data;
-    const slug = project.project?.orgSlug && project.project.projectSlug ? `${project.project.orgSlug}/${project.project.projectSlug}` : project.projectId;
-    const name = project.project?.name ? ` (${project.project.name})` : "";
-    return {
-      stdout: `Using Cadence project ${slug}${name}.
-`,
+      stdout: formatJson(successEnvelope(data, meta)),
       stderr: "",
       exitCode: 0
     };
@@ -2871,13 +3997,11 @@ async function runProjectCommand(parsed, options) {
 async function runActorCommand(parsed, options) {
   const config = await resolveCliConfig(parsed.flags, options);
   const client = await createClient(config, options);
-  const project = await resolveRequiredProject(config, client);
-  const resolvedConfig = configWithProject(config, project);
-  const meta = commandMeta(parsed, resolvedConfig);
+  const meta = commandMeta(parsed, config);
   let data;
   switch (parsed.command.name) {
     case "actors.ensure-workspace-agent":
-      data = await ensureWorkspaceAgentIdentity(parsed, resolvedConfig, client, options);
+      data = await ensureWorkspaceAgentIdentity(parsed, config, client, options);
       break;
     default:
       throw new CliError("CLI_USAGE", `Unknown command: ${parsed.command.path.join(" ")}`);
@@ -2898,11 +4022,9 @@ async function runActorCommand(parsed, options) {
 }
 async function runIntakeCommand(parsed, options) {
   const config = await resolveCliConfig(parsed.flags, options);
+  const projectId = requireProjectId(config);
   const client = await createClient(config, options);
-  const project = await resolveRequiredProject(config, client);
-  const resolvedConfig = configWithProject(config, project);
-  const projectId = project.id;
-  const meta = commandMeta(parsed, resolvedConfig);
+  const meta = commandMeta(parsed, config);
   let data;
   const ifVersion = () => parseRequiredPositiveInteger(requireOption(parsed, "if-version"), "--if-version");
   switch (parsed.command.name) {
@@ -3199,9 +4321,15 @@ async function runCli(argv, options = {}) {
     if (parsed.command.name === "events.list" || parsed.command.name === "work.overview" || parsed.command.name === "tickets.get" || parsed.command.name === "tickets.list" || parsed.command.name === "sessions.current" || parsed.command.name === "changesets.get" || parsed.command.name === "changesets.context" || parsed.command.name === "changesets.current" || parsed.command.name === "changesets.list" || parsed.command.name === "changesets.notes.get") {
       return await runReadCommand(parsed, options);
     }
-    if (parsed.command.name === "projects.list" || parsed.command.name === "projects.use") {
+    if (parsed.command.name === "projects.list") {
       return await runProjectCommand(parsed, options);
     }
+    if (parsed.command.name === "agent-run.ingest-stop" || parsed.command.name === "agent-run.closeout" || parsed.command.name === "agent-run.sweep" || parsed.command.name === "agent-run.doctor") {
+      return await runAgentRunCommand(parsed, options);
+    }
+    if (parsed.command.name === "hooks.install" || parsed.command.name === "hooks.doctor") {
+      return await runHooksCommand(parsed, options);
+    }
     if (parsed.command.name === "intake" || parsed.command.name === "intake.dismiss" || parsed.command.name === "tickets.attach" || parsed.command.name === "tickets.create" || parsed.command.name === "tickets.update" || parsed.command.name === "tickets.claim" || parsed.command.name === "tickets.release" || parsed.command.name === "tickets.log" || parsed.command.name === "tickets.complete" || parsed.command.name === "sessions.start" || parsed.command.name === "sessions.end" || parsed.command.name === "sessions.files" || parsed.command.name === "changesets.create" || parsed.command.name === "changesets.notes.put" || parsed.command.name === "changesets.notes.apply") {
       return await runIntakeCommand(parsed, options);
     }