@cleocode/cleo 2026.10.4 → 2026.10.5

package/dist/cli/index.js

@@ -33,8 +33,9 @@ import {
   extractIdempotencyKeyArg,
   setDescribeMode,
   setIdempotencyKeyContext,
-  setProjectionOptOut
-} from "./chunk-ZBISIPCK.js";
+  setProjectionOptOut,
+  settleThenExit
+} from "./chunk-QKMBWYAS.js";
 import {
   resolveFieldContext,
   resolveOutputMode,
@@ -45,9 +46,9 @@ import {
 } from "./chunk-6JSJNYH2.js";
 
 // packages/cleo/src/cli/index.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { dirname as dirname3, join as join4 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { enforceNodeVersion } from "@cleocode/paths";
 
 // packages/cleo/src/cli/citty-error-envelope.ts
@@ -71,505 +72,523 @@ var COMMAND_MANIFEST = [
     exportName: "adapterCommand",
     name: "adapter",
     description: "Provider adapter management: list, show, detect, health, activate, dispose",
-    load: async () => (await import("./adapter-LVXHFBC4.js")).adapterCommand
+    load: async () => (await import("./adapter-OUQRSFZL.js")).adapterCommand
   },
   {
     exportName: "addBatchCommand",
     name: "add-batch",
     description: "Create multiple tasks in a single atomic transaction from a JSON file",
-    load: async () => (await import("./add-batch-U2DLKAQC.js")).addBatchCommand
+    load: async () => (await import("./add-batch-TSWICA5J.js")).addBatchCommand
   },
   {
     exportName: "addCommand",
     name: "add",
     description: "Create a new task (requires active session)\nFor 2+ tasks at once: cleo add-batch --file tasks.json (single transaction, atomic rollback)",
-    load: async () => (await import("./add-WUAV7LDT.js")).addCommand
+    load: async () => (await import("./add-4SRRJL4U.js")).addCommand
   },
   {
     exportName: "adminCommand",
     name: "admin",
     description: "System administration and diagnostics",
-    load: async () => (await import("./admin-I7BQYVZD.js")).adminCommand
+    load: async () => (await import("./admin-YMU55YCU.js")).adminCommand
   },
   {
     exportName: "adrCommand",
     name: "adr",
     description: "Manage and validate Architecture Decision Records in .cleo/adrs/",
-    load: async () => (await import("./adr-K2THMQBS.js")).adrCommand
+    load: async () => (await import("./adr-XESRMFMP.js")).adrCommand
   },
   {
     exportName: "agentOutputsCommand",
     name: "agent-outputs",
     description: "Agent output document management \u2014 find/search via DocsAccessor (find subcommand)",
-    load: async () => (await import("./agent-outputs-BJIYLVTU.js")).agentOutputsCommand
+    load: async () => (await import("./agent-outputs-HVJJIPS4.js")).agentOutputsCommand
   },
   {
     exportName: "agentCommand",
     name: "agent",
     description: "Agent lifecycle, credentials, and messaging",
-    load: async () => (await import("./agent-WQ6XY2DW.js")).agentCommand
+    load: async () => (await import("./agent-TAFPIYUU.js")).agentCommand
   },
   {
     exportName: "analyzeCommand",
     name: "analyze",
     description: "Task triage with leverage scoring and bottleneck detection",
-    load: async () => (await import("./analyze-PGQZWGOC.js")).analyzeCommand
+    load: async () => (await import("./analyze-YQ22QVGW.js")).analyzeCommand
   },
   {
     exportName: "archiveStatsCommand",
     name: "archive-stats",
     description: "Generate analytics and insights from archived tasks",
-    load: async () => (await import("./archive-stats-U6CYC6JM.js")).archiveStatsCommand
+    load: async () => (await import("./archive-stats-HP2KPAJU.js")).archiveStatsCommand
   },
   {
     exportName: "archiveCommand",
     name: "archive",
     description: "Archive completed tasks",
-    load: async () => (await import("./archive-5LZPF7C3.js")).archiveCommand
+    load: async () => (await import("./archive-W5XX6AH7.js")).archiveCommand
   },
   {
     exportName: "attentionCommand",
     name: "attention",
     description: "Tier-2 scope-keyed working memory \u2014 quick decaying jots (alias: jot)",
-    load: async () => (await import("./attention-SOURWCNI.js")).attentionCommand
+    load: async () => (await import("./attention-ZXZANHKC.js")).attentionCommand
   },
   {
     exportName: "auditCommand",
     name: "audit",
     description: "Git-backed audit tooling (lineage reconstruction, integrity checks). ",
-    load: async () => (await import("./audit-FO2Y4LH2.js")).auditCommand
+    load: async () => (await import("./audit-ICA2SEFN.js")).auditCommand
   },
   {
     exportName: "authCommand",
     name: "auth",
     description: "Unified credential surface: auth login (front-door provider login, alias of cleo login), auth list, auth remove, auth consent. (cleo llm list is the LLM-scoped sister command.)",
-    load: async () => (await import("./auth-ED7TAIXI.js")).authCommand
+    load: async () => (await import("./auth-DXIG5OG7.js")).authCommand
   },
   {
     exportName: "backfillCommand",
     name: "backfill",
     description: "Retroactively add acceptance criteria and verification metadata to existing tasks",
-    load: async () => (await import("./backfill-32TRAYRD.js")).backfillCommand
+    load: async () => (await import("./backfill-LBSYBWLR.js")).backfillCommand
   },
   {
     exportName: "backupInspectSubCommand",
     name: "inspect",
     description: "Inspect a bundle manifest or an exact observation in a read-only SQLite snapshot",
-    load: async () => (await import("./backup-inspect-6HPLUEI2.js")).backupInspectSubCommand
+    load: async () => (await import("./backup-inspect-PDRXI45A.js")).backupInspectSubCommand
   },
   {
     exportName: "backupRecoverSubCommand",
     name: "recover",
     description: "Recover a malformed CLEO database from snapshot \u2014 accepts any role from DB_INVENTORY (T10318)",
-    load: async () => (await import("./backup-recover-2BTYBZU2.js")).backupRecoverSubCommand
+    load: async () => (await import("./backup-recover-TVKAPERB.js")).backupRecoverSubCommand
   },
   {
     exportName: "backupCommand",
     name: "backup",
     description: "Add backup of todo files or list available backups",
-    load: async () => (await import("./backup-LEJMZJKL.js")).backupCommand
+    load: async () => (await import("./backup-NUGBZ7NA.js")).backupCommand
   },
   {
     exportName: "blockersCommand",
     name: "blockers",
     description: "Show blocked tasks and analyze blocking chains",
-    load: async () => (await import("./blockers-5JULUJTV.js")).blockersCommand
+    load: async () => (await import("./blockers-ZOPCGHDW.js")).blockersCommand
   },
   {
     exportName: "brainCommand",
     name: "brain",
     description: "Brain memory optimization operations",
-    load: async () => (await import("./brain-273N3FW4.js")).brainCommand
+    load: async () => (await import("./brain-EJOBKL4A.js")).brainCommand
   },
   {
     exportName: "briefingCommand",
     name: "briefing",
     description: "Session resume context: last handoff, current task, next tasks, bugs, blockers, epics, and memory. Use at session start to restore context.",
-    load: async () => (await import("./briefing-7H6OLECX.js")).briefingCommand
+    load: async () => (await import("./briefing-RDQJ6WHS.js")).briefingCommand
   },
   {
     exportName: "caampCommand",
     name: "caamp",
     description: "CAAMP injection management: repair markers, deduplicate blocks",
-    load: async () => (await import("./caamp-MFQVN6VU.js")).caampCommand
+    load: async () => (await import("./caamp-Z3XPKEHB.js")).caampCommand
   },
   {
     exportName: "cancelCommand",
     name: "cancel",
     description: "Cancel a task (soft terminal state; reversible via restore)",
-    load: async () => (await import("./cancel-SCMJTXZB.js")).cancelCommand
+    load: async () => (await import("./cancel-S7EHLCJN.js")).cancelCommand
   },
   {
     exportName: "cantCommand",
     name: "cant",
     description: "CANT DSL tooling",
-    load: async () => (await import("./cant-46XCUP4P.js")).cantCommand
+    load: async () => (await import("./cant-CHNN6O57.js")).cantCommand
   },
   {
     exportName: "changesetCommand",
     name: "changeset",
     description: "Author + list task-anchored changeset entries \u2014 dual-writes go to ",
-    load: async () => (await import("./changeset-32NMBGG2.js")).changesetCommand
+    load: async () => (await import("./changeset-RYPHPN2B.js")).changesetCommand
   },
   {
     exportName: "checkCommand",
     name: "check",
     description: "Validation and compliance checks",
-    load: async () => (await import("./check-RWJLBCI2.js")).checkCommand
+    load: async () => (await import("./check-DHMURGHC.js")).checkCommand
   },
   {
     exportName: "checkpointCommand",
     name: "checkpoint",
     description: "Git checkpoint for CLEO state files (commits to isolated .cleo/.git repo)",
-    load: async () => (await import("./checkpoint-37HMMKD7.js")).checkpointCommand
+    load: async () => (await import("./checkpoint-UWDFOGYQ.js")).checkpointCommand
   },
   {
     exportName: "claimCommand",
     name: "claim",
     description: "Take, renew (--renew) or override (--take-over expired, --force-claim live) your session's leased claim on a task",
-    load: async () => (await import("./claim-KPENYHIQ.js")).claimCommand
+    load: async () => (await import("./claim-IGOG2QOC.js")).claimCommand
   },
   {
     exportName: "unclaimCommand",
     name: "unclaim",
     description: "Release your session's claim lease on a task (--force-claim: another session's)",
-    load: async () => (await import("./claim-KPENYHIQ.js")).unclaimCommand
+    load: async () => (await import("./claim-IGOG2QOC.js")).unclaimCommand
   },
   {
     exportName: "classifyCommand",
     name: "classify",
     description: "Classify a task: readiness verdict (proceed|grill) + persona routing (agent, confidence)",
-    load: async () => (await import("./classify-DRVMCFQU.js")).classifyCommand
+    load: async () => (await import("./classify-MG4N7GMQ.js")).classifyCommand
   },
   {
     exportName: "cloudCommand",
     name: "cloud",
-    description: "Cleo Nexus with the device credential: status (one-call verification), whoami, devices, projects [show], activity; the encrypted vault: push, pull, restore, verify, vault, lease release.",
-    load: async () => (await import("./cloud-PPQ4O5TX.js")).cloudCommand
+    description: "Cleo Nexus with the device credential: status (one-call verification), whoami, devices, projects [show], activity; the encrypted vault: push, pull, restore, verify, vault, lease release; the local sync conflict log: conflicts [resolve <id>].",
+    load: async () => (await import("./cloud-SILYJVKO.js")).cloudCommand
   },
   {
     exportName: "codeCommand",
     name: "code",
     description: "Code analysis via tree-sitter AST",
-    load: async () => (await import("./code-Z5CTMVTD.js")).codeCommand
+    load: async () => (await import("./code-H2FQCVMW.js")).codeCommand
   },
   {
     exportName: "completeCommand",
     name: "complete",
     description: "Mark a task as completed (requires active session)",
-    load: async () => (await import("./complete-UBOCOBRB.js")).completeCommand
+    load: async () => (await import("./complete-JLX7NBI4.js")).completeCommand
   },
   {
     exportName: "complexityCommand",
     name: "complexity",
     description: "Task complexity analysis",
-    load: async () => (await import("./complexity-BV2AGQRZ.js")).complexityCommand
+    load: async () => (await import("./complexity-OKV7PVZH.js")).complexityCommand
   },
   {
     exportName: "complianceCommand",
     name: "compliance",
     description: "Monitor and report compliance metrics for orchestrator and agent outputs",
-    load: async () => (await import("./compliance-32PD5Y47.js")).complianceCommand
+    load: async () => (await import("./compliance-QMGZHJNQ.js")).complianceCommand
   },
   {
     exportName: "conduitCommand",
     name: "conduit",
     description: "Manage Conduit inter-agent messaging",
-    load: async () => (await import("./conduit-VDKCH33F.js")).conduitCommand
+    load: async () => (await import("./conduit-4H32UYEA.js")).conduitCommand
   },
   {
     exportName: "configCommand",
     name: "config",
     description: "CleoConfig SSoT registry surface (show, get, set, validate, drift-check) + legacy presets/list",
-    load: async () => (await import("./config-I72JAXK4.js")).configCommand
+    load: async () => (await import("./config-TDYOC7XO.js")).configCommand
   },
   {
     exportName: "consensusCommand",
     name: "consensus",
     description: "Validate consensus protocol compliance (alias for `cleo check protocol consensus`)",
-    load: async () => (await import("./consensus-LFILLSTK.js")).consensusCommand
+    load: async () => (await import("./consensus-4XCOFPPT.js")).consensusCommand
   },
   {
     exportName: "contextCommand",
     name: "context",
     description: "Monitor context window usage for agent safeguard system",
-    load: async () => (await import("./context-XUUVFVTP.js")).contextCommand
+    load: async () => (await import("./context-FN4YTGHD.js")).contextCommand
   },
   {
     exportName: "contributionCommand",
     name: "contribution",
     description: "Validate contribution protocol compliance (alias for `cleo check protocol contribution`)",
-    load: async () => (await import("./contribution-37NQ4N5R.js")).contributionCommand
+    load: async () => (await import("./contribution-7RWFBJLC.js")).contributionCommand
   },
   {
     exportName: "curatorCommand",
     name: "curator",
     description: "Skill curator: lifecycle transitions for agent-created skills",
-    load: async () => (await import("./curator-TFDXU2EX.js")).curatorCommand
+    load: async () => (await import("./curator-HKZJCVRL.js")).curatorCommand
   },
   {
     exportName: "currentCommand",
     name: "current",
     description: "",
-    load: async () => (await import("./current-C4SN5BWV.js")).currentCommand
+    load: async () => (await import("./current-B2NU7V3G.js")).currentCommand
   },
   {
     exportName: "daemonCommand",
     name: "daemon",
     description: "Manage the CLEO GC sidecar daemon for autonomous transcript cleanup",
-    load: async () => (await import("./daemon-DV25JQ62.js")).daemonCommand
+    load: async () => (await import("./daemon-GBD4TVCD.js")).daemonCommand
   },
   {
     exportName: "dashCommand",
     name: "dash",
     description: "Project health dashboard: status summary, phase progress, recent activity, high priority tasks. Use for overall project status.",
-    load: async () => (await import("./dash-TFU4RLQW.js")).dashCommand
+    load: async () => (await import("./dash-IGDANIE5.js")).dashCommand
   },
   {
     exportName: "decideCommand",
     name: "decide",
     description: "System One integration (typed decisions): decide config (named provider profile + API key; wizard on a terminal), decide use (switch the active profile), decide profiles (list them), decide status (reachability probe), decide ask (one debug question), decide sites (the registered decision sites), decide bench (accuracy benchmark). Unconfigured means heuristics answer.",
-    load: async () => (await import("./decide-5VPMNTSI.js")).decideCommand
+    load: async () => (await import("./decide-26SXC2V6.js")).decideCommand
   },
   {
     exportName: "decomposeCommand",
     name: "decompose",
     description: "Move a task's text acceptance criteria onto a new child so it can hold subtasks",
-    load: async () => (await import("./decompose-KOYEZNJL.js")).decomposeCommand
+    load: async () => (await import("./decompose-LQ76TEZG.js")).decomposeCommand
   },
   {
     exportName: "decompositionCommand",
     name: "decomposition",
     description: "Validate decomposition protocol compliance (alias for `cleo check protocol decomposition`)",
-    load: async () => (await import("./decomposition-7OHUFIQN.js")).decompositionCommand
+    load: async () => (await import("./decomposition-WFRWNUSJ.js")).decompositionCommand
   },
   {
     exportName: "deleteCommand",
     name: "delete",
     description: "Delete a task (soft delete to archive)",
-    load: async () => (await import("./delete-Q7YCAFY5.js")).deleteCommand
+    load: async () => (await import("./delete-T5DUQHOX.js")).deleteCommand
   },
   {
     exportName: "depsCommand",
     name: "deps",
     description: "Dependency visualization and analysis",
-    load: async () => (await import("./deps-6UZKLDGJ.js")).depsCommand
+    load: async () => (await import("./deps-UTPZJBXL.js")).depsCommand
   },
   {
     exportName: "treeCommand",
     name: "tree",
     description: "Task hierarchy tree visualization",
-    load: async () => (await import("./deps-6UZKLDGJ.js")).treeCommand
+    load: async () => (await import("./deps-UTPZJBXL.js")).treeCommand
   },
   {
     exportName: "detectDriftCommand",
     name: "detect-drift",
     description: "Detect documentation drift against TypeScript source of truth",
-    load: async () => (await import("./detect-drift-UL2JTPUK.js")).detectDriftCommand
+    load: async () => (await import("./detect-drift-TVCJOFYJ.js")).detectDriftCommand
   },
   {
     exportName: "detectCommand",
     name: "detect",
     description: "Re-detect project type and update project-context.json",
-    load: async () => (await import("./detect-FERY35UL.js")).detectCommand
+    load: async () => (await import("./detect-FFZSMVDT.js")).detectCommand
   },
   {
     exportName: "diagnosticsCommand",
     name: "diagnostics",
     description: "Autonomous self-improvement telemetry \u2014 opt-in command analytics that feed BRAIN observations",
-    load: async () => (await import("./diagnostics-TI5QAZXR.js")).diagnosticsCommand
+    load: async () => (await import("./diagnostics-ZNBKH6GX.js")).diagnosticsCommand
   },
   {
     exportName: "_llmOutputCommand",
     name: "llm-output",
     description: "Unified LLM output: task export (rich Markdown with frontmatter + body + attachments + memory refs) ",
-    load: async () => (await import("./docs-QI2PRN3T.js"))._llmOutputCommand
+    load: async () => (await import("./docs-DPPDFTWR.js"))._llmOutputCommand
   },
   {
     exportName: "docsCommand",
     name: "docs",
     description: "Canonical six-verb docs path: add, update, fetch, list, remove, publish. ",
-    load: async () => (await import("./docs-QI2PRN3T.js")).docsCommand
+    load: async () => (await import("./docs-DPPDFTWR.js")).docsCommand
   },
   {
     exportName: "doctorAcBindingsCommand",
     name: "ac-bindings",
     description: "Report evidence bindings whose acceptance criterion no longer exists (dangling ",
-    load: async () => (await import("./doctor-ac-bindings-YPMYHU2G.js")).doctorAcBindingsCommand
+    load: async () => (await import("./doctor-ac-bindings-S3IOEFP4.js")).doctorAcBindingsCommand
   },
   {
     exportName: "doctorAcceptanceDriftCommand",
     name: "acceptance-drift",
     description: "Report tasks whose acceptance criteria disagree between the JSON column and the typed rows ",
-    load: async () => (await import("./doctor-acceptance-drift-PYNFGMKB.js")).doctorAcceptanceDriftCommand
+    load: async () => (await import("./doctor-acceptance-drift-VNFKPBSQ.js")).doctorAcceptanceDriftCommand
   },
   {
     exportName: "doctorCredentialsCommand",
     name: "credentials",
     description: "Report project credentials still encrypted under the legacy path-bound key (moving the project would strand them) and agent registry keys that are not recoverable. --fix re-keys project credentials to the project's identity in place and flags unrecoverable agent keys requires_reauth. Idempotent; never deletes. Unrecoverable credentials are listed with their re-entry command.",
-    load: async () => (await import("./doctor-credentials-UZRIADKM.js")).doctorCredentialsCommand
+    load: async () => (await import("./doctor-credentials-A5H4JMTF.js")).doctorCredentialsCommand
   },
   {
     exportName: "doctorDbSubstrateCommand",
     name: "db-substrate",
     description: "Walk every DB in the inventory + report integrity, row counts, orphan dirs. ",
-    load: async () => (await import("./doctor-db-substrate-Q2TOYM2S.js")).doctorDbSubstrateCommand
+    load: async () => (await import("./doctor-db-substrate-FGCISE4Z.js")).doctorDbSubstrateCommand
   },
   {
     exportName: "doctorDepCyclesCommand",
     name: "dep-cycles",
     description: "Report task dependency cycles already stored (edges written before the T12886 cycle ",
-    load: async () => (await import("./doctor-dep-cycles-GCVYZY6F.js")).doctorDepCyclesCommand
+    load: async () => (await import("./doctor-dep-cycles-BKKKHHYG.js")).doctorDepCyclesCommand
   },
   {
     exportName: "doctorExodusResidueCommand",
     name: "exodus-residue",
     description: "Detect legacy exodus source DBs still present after a cutover (stranded residue that ",
-    load: async () => (await import("./doctor-exodus-residue-EM2AWQXP.js")).doctorExodusResidueCommand
+    load: async () => (await import("./doctor-exodus-residue-4EMRYMEQ.js")).doctorExodusResidueCommand
   },
   {
     exportName: "doctorExodusCommand",
     name: "exodus-health",
     description: "Read-only exodus health report: per-scope migration state, legacy DB sizes, completion ",
-    load: async () => (await import("./doctor-exodus-RO5SUTC2.js")).doctorExodusCommand
+    load: async () => (await import("./doctor-exodus-ND2DH2KP.js")).doctorExodusCommand
   },
   {
     exportName: "doctorFkCheckCommand",
     name: "fk-check",
     description: "Verify foreign-key integrity of the consolidated project + global cleo.db ",
-    load: async () => (await import("./doctor-fk-check-Q3FOLECE.js")).doctorFkCheckCommand
+    load: async () => (await import("./doctor-fk-check-VY3RIQV3.js")).doctorFkCheckCommand
   },
   {
     exportName: "doctorGlobalDeliveryCommand",
     name: "global-delivery",
     description: "Check that ~/.cleo, the global hub reference and every harness CLEO skill install ",
-    load: async () => (await import("./doctor-global-delivery-TNOAQ3NP.js")).doctorGlobalDeliveryCommand
+    load: async () => (await import("./doctor-global-delivery-JN6IGHUL.js")).doctorGlobalDeliveryCommand
   },
   {
     exportName: "doctorHeavyCommandHookCommand",
     name: "heavy-command-hook",
     description: "Report, per agent harness in use, whether the heavy-command hook (routes agent-run tests and ",
-    load: async () => (await import("./doctor-heavy-command-hook-IO3QAQLG.js")).doctorHeavyCommandHookCommand
+    load: async () => (await import("./doctor-heavy-command-hook-XSN44WXU.js")).doctorHeavyCommandHookCommand
   },
   {
     exportName: "doctorLegacyBackupsCommand",
     name: "legacy-backups",
     description: "Enumerate legacy *-pre-cleo.db.bak / brain.db.PRE-DUP-FIX-* / pre-untrack / rotation-overflow ",
-    load: async () => (await import("./doctor-legacy-backups-O2YH5VLS.js")).doctorLegacyBackupsCommand
+    load: async () => (await import("./doctor-legacy-backups-QAG5NHYP.js")).doctorLegacyBackupsCommand
   },
   {
     exportName: "doctorLegacyReaperCommand",
     name: "legacy-reaper",
     description: "Detect the legacy cleo-mcp-reaper user timer that kills processes by generic `MainThread` ",
-    load: async () => (await import("./doctor-legacy-reaper-VSEJEIFA.js")).doctorLegacyReaperCommand
+    load: async () => (await import("./doctor-legacy-reaper-CIRGFE6R.js")).doctorLegacyReaperCommand
   },
   {
     exportName: "doctorMalformedIdsCommand",
     name: "malformed-ids",
     description: "Report task rows whose id is not a valid task identifier \u2014 rows that `cleo list` returns ",
-    load: async () => (await import("./doctor-malformed-ids-LQ766V5K.js")).doctorMalformedIdsCommand
+    load: async () => (await import("./doctor-malformed-ids-WL7HT4TB.js")).doctorMalformedIdsCommand
   },
   {
     exportName: "doctorManifestRowsCommand",
     name: "manifest-rows",
     description: "List manifest rows whose metadata violates the stored field contract, and (read-only) rows with an invalid id, linked task id or file reference. --repair shows the plan (writes nothing); --repair --apply moves each bad field under _malformed (nothing lost) with a receipt; --rollback <receipt> undoes it.",
-    load: async () => (await import("./doctor-manifest-rows-6FQDNHLH.js")).doctorManifestRowsCommand
+    load: async () => (await import("./doctor-manifest-rows-SMQCKJ2T.js")).doctorManifestRowsCommand
   },
   {
     exportName: "doctorMemoryGuardCommand",
     name: "memory-guard",
     description: "Audit the machine-wide memory guard that bounds test runs an agent starts OUTSIDE cleo ",
-    load: async () => (await import("./doctor-memory-guard-J4PSEKB5.js")).doctorMemoryGuardCommand
+    load: async () => (await import("./doctor-memory-guard-LJDOJG76.js")).doctorMemoryGuardCommand
   },
   {
     exportName: "doctorMigrationsCommand",
     name: "migrations",
     description: "Report the migration journal of the project and global stores: row count, head, applied ",
-    load: async () => (await import("./doctor-migrations-ONOH56YM.js")).doctorMigrationsCommand
+    load: async () => (await import("./doctor-migrations-ETQPFNUP.js")).doctorMigrationsCommand
   },
   {
     exportName: "doctorNexusResidencyCommand",
     name: "nexus-residency",
     description: "Report nexus tables resident in the wrong store \u2014 graph tables orphaned in the global ",
-    load: async () => (await import("./doctor-nexus-residency-FUQAX7PV.js")).doctorNexusResidencyCommand
+    load: async () => (await import("./doctor-nexus-residency-A4JMKBEJ.js")).doctorNexusResidencyCommand
   },
   {
     exportName: "doctorProjectIdentityCommand",
     name: "project-identity",
     description: "Check .cleo/project.json, its legacy .cleo/project-id mirror and the project-info.json cache ",
-    load: async () => (await import("./doctor-project-identity-GUDK3HYX.js")).doctorProjectIdentityCommand
+    load: async () => (await import("./doctor-project-identity-FFQJ5LNX.js")).doctorProjectIdentityCommand
   },
   {
     exportName: "doctorRegistryCommand",
     name: "projects",
     description: "Machine-wide registry integrity: rebind moved projects by id, flag split identities, ",
-    load: async () => (await import("./doctor-projects-registry-TEAVHFQU.js")).doctorRegistryCommand
+    load: async () => (await import("./doctor-projects-registry-76X6VTGM.js")).doctorRegistryCommand
   },
   {
     exportName: "doctorProjectsCommand",
     name: "doctor-projects",
     description: "Probe every registered project (nexus.db) for DB + config health",
-    load: async () => (await import("./doctor-projects-7L3BNL4O.js")).doctorProjectsCommand
+    load: async () => (await import("./doctor-projects-MFUTKRHP.js")).doctorProjectsCommand
   },
   {
     exportName: "doctorReleaseReadinessCommand",
     name: "release-readiness",
     description: "Pre-flight release readiness check \u2014 lint matrix + changelog + changeset + npm OIDC + tag-trigger sanity (T10458)",
-    load: async () => (await import("./doctor-release-readiness-IEGHX6SL.js")).doctorReleaseReadinessCommand
+    load: async () => (await import("./doctor-release-readiness-QJCOPFTK.js")).doctorReleaseReadinessCommand
   },
   {
     exportName: "doctorRepairCommand",
     name: "repair",
     description: "Detect malformed CLEO databases (PRAGMA quick_check) and restore each from its ",
-    load: async () => (await import("./doctor-repair-NBONOSZU.js")).doctorRepairCommand
+    load: async () => (await import("./doctor-repair-AU76FIKY.js")).doctorRepairCommand
+  },
+  {
+    exportName: "doctorRowIdentityCommand",
+    name: "row-identity",
+    description: "Plan the from-scratch row-identity refill of a store whose identity predates the current ",
+    load: async () => (await import("./doctor-row-identity-KW6JYZQE.js")).doctorRowIdentityCommand
   },
   {
     exportName: "doctorSkillFixturesCommand",
     name: "skill-fixtures",
     description: "Find caamp test fixtures left in the real skills root (UUID-named and known fixture ",
-    load: async () => (await import("./doctor-skill-fixtures-7Y6L34A3.js")).doctorSkillFixturesCommand
+    load: async () => (await import("./doctor-skill-fixtures-G3T7JUHS.js")).doctorSkillFixturesCommand
   },
   {
     exportName: "doctorSplitBrainCommand",
     name: "split-brain",
     description: "Import rows that exist only in a diverged copy of a store (--source) into another (--target) ",
-    load: async () => (await import("./doctor-split-brain-TUKIGVHF.js")).doctorSplitBrainCommand
+    load: async () => (await import("./doctor-split-brain-FUW6L7FS.js")).doctorSplitBrainCommand
   },
   {
     exportName: "doctorSupersededStoreCommand",
     name: "superseded-store",
     description: "Report pre-dual-scope store files (.cleo/tasks.db, .cleo/brain.db) still on disk under ",
-    load: async () => (await import("./doctor-superseded-store-BHZY2B2L.js")).doctorSupersededStoreCommand
+    load: async () => (await import("./doctor-superseded-store-DUHGSBLC.js")).doctorSupersededStoreCommand
+  },
+  {
+    exportName: "doctorSyncJournalCommand",
+    name: "sync-journal",
+    description: "Plan the repair diff of the project store's suspect tables (rows written uncaptured). ",
+    load: async () => (await import("./doctor-sync-journal-SXMUIKF7.js")).doctorSyncJournalCommand
+  },
+  {
+    exportName: "doctorSyncTriggersCommand",
+    name: "sync-triggers",
+    description: "Check the project store's triggers: the suspension table, owned guard triggers, capture ",
+    load: async () => (await import("./doctor-sync-triggers-6WNJZFRM.js")).doctorSyncTriggersCommand
   },
   {
     exportName: "doctorToolLocksCommand",
     name: "tool-locks",
-    description: "Inspect the machine-wide evidence-tool semaphore: which slots are held, by which pid, ",
-    load: async () => (await import("./doctor-tool-locks-REQMIVYK.js")).doctorToolLocksCommand
+    description: "Inspect the machine-wide admission ledger: which heavy runs hold the memory budget or ",
+    load: async () => (await import("./doctor-tool-locks-66LSLUBN.js")).doctorToolLocksCommand
   },
   {
     exportName: "doctorTwinCollapseCommand",
     name: "twin-collapse",
     description: "Report the twin collapses (bare schema_meta / sticky_tags kept in step with their prefixed ",
-    load: async () => (await import("./doctor-twin-collapse-222GOSPE.js")).doctorTwinCollapseCommand
+    load: async () => (await import("./doctor-twin-collapse-AYBYBFC4.js")).doctorTwinCollapseCommand
   },
   {
     exportName: "doctorWorktreeStoresCommand",
     name: "worktree-stores",
     description: "List store files (.cleo/*.db, *.bak) stranded inside the project worktrees and report ",
-    load: async () => (await import("./doctor-worktree-stores-J7TCRVJ3.js")).doctorWorktreeStoresCommand
+    load: async () => (await import("./doctor-worktree-stores-C5XEH5OG.js")).doctorWorktreeStoresCommand
   },
   {
     exportName: "doctorCommand",
     name: "doctor",
     description: "Run system diagnostics and health checks",
-    load: async () => (await import("./doctor-AX5TICQO.js")).doctorCommand
+    load: async () => (await import("./doctor-GPENOP4N.js")).doctorCommand
   },
   {
     exportName: "doneCommand",
     name: "done",
     description: "Record every required gate from derived evidence (change set, tools, typed gates, AC links) in one write, then complete. --plan: read-only plan; writes nothing",
-    load: async () => (await import("./done-V3AOO65B.js")).doneCommand
+    load: async () => (await import("./done-R64XRZ32.js")).doneCommand
   },
   {
     exportName: "dynamicCommand",
@@ -581,103 +600,103 @@ var COMMAND_MANIFEST = [
     exportName: "orchestratorCommand",
     name: "orchestrator",
     description: "Orchestration observability: stream worker event logs",
-    load: async () => (await import("./event-EGNPGE5A.js")).orchestratorCommand
+    load: async () => (await import("./event-45KEWV5H.js")).orchestratorCommand
   },
   {
     exportName: "eventCommand",
     name: "event",
     description: "CLEO Observability event bus: append lifecycle events and tail agent logs",
-    load: async () => (await import("./event-EGNPGE5A.js")).eventCommand
+    load: async () => (await import("./event-45KEWV5H.js")).eventCommand
   },
   {
     exportName: "existsCommand",
     name: "exists",
     description: "Check if a task ID exists (exit 0=exists, 4=not found)",
-    load: async () => (await import("./exists-H4SDCBPL.js")).existsCommand
+    load: async () => (await import("./exists-BEDZS5RI.js")).existsCommand
   },
   {
     exportName: "exodusCommand",
     name: "exodus",
     description: "[TRANSITIONAL] Migrate legacy multi-DB fleet to consolidated dual-scope cleo.db (SG-DB-SUBSTRATE-V2)",
-    load: async () => (await import("./exodus-KALO3B3X.js")).exodusCommand
+    load: async () => (await import("./exodus-DUX62344.js")).exodusCommand
   },
   {
     exportName: "exportTasksCommand",
     name: "export-tasks",
     description: "Export tasks to portable .cleo-export.json package for cross-project transfer",
-    load: async () => (await import("./export-tasks-US3WBIEQ.js")).exportTasksCommand
+    load: async () => (await import("./export-tasks-CUXDZPJB.js")).exportTasksCommand
   },
   {
     exportName: "exportCommand",
     name: "export",
     description: "Export tasks to CSV, TSV, JSON, or markdown format",
-    load: async () => (await import("./export-ROFOCG4M.js")).exportCommand
+    load: async () => (await import("./export-C5PQIQ5O.js")).exportCommand
   },
   {
     exportName: "federationCommand",
     name: "federation",
     description: "Federation peer management: add, remove, list trusted peers",
-    load: async () => (await import("./federation-SUIB5QWT.js")).federationCommand
+    load: async () => (await import("./federation-ESM35EGG.js")).federationCommand
   },
   {
     exportName: "findCommand",
     name: "find",
     description: "Lexical task search; fuzzy matching requires --fuzzy",
-    load: async () => (await import("./find-YICG4BG6.js")).findCommand
+    load: async () => (await import("./find-5EUZHHQJ.js")).findCommand
   },
   {
     exportName: "focusCommand",
     name: "focus",
     description: "Single-envelope orientation for a task, epic, or saga \u2014 replaces 8 separate calls with one",
-    load: async () => (await import("./focus-TKCZPKOM.js")).focusCommand
+    load: async () => (await import("./focus-ANKAIRO5.js")).focusCommand
   },
   {
     exportName: "gatewayOpenapiSubCommand",
     name: "openapi",
     description: "Emit the OpenAPI 3.1 spec projected from the OPERATIONS registry",
-    load: async () => (await import("./gateway-H4HFDC3E.js")).gatewayOpenapiSubCommand
+    load: async () => (await import("./gateway-2GW2KTK3.js")).gatewayOpenapiSubCommand
   },
   {
     exportName: "gatewayCommand",
     name: "gateway",
     description: "REST gateway introspection (openapi spec projection)",
-    load: async () => (await import("./gateway-H4HFDC3E.js")).gatewayCommand
+    load: async () => (await import("./gateway-2GW2KTK3.js")).gatewayCommand
   },
   {
     exportName: "gcCommand",
     name: "gc",
     description: "Transcript garbage collection: manual trigger and status",
-    load: async () => (await import("./gc-5R2TUY5T.js")).gcCommand
+    load: async () => (await import("./gc-CTOQLUSA.js")).gcCommand
   },
   {
     exportName: "goCommand",
     name: "go",
     description: "SG-AUTOPILOT: run one turn of briefing\u2192sagaNext\u2192ready\u2192stage-branch\u2192ivtr loop",
-    load: async () => (await import("./go-PRQFK5YG.js")).goCommand
+    load: async () => (await import("./go-YJPNHHYT.js")).goCommand
   },
   {
     exportName: "goalCommand",
     name: "goal",
     description: "DB-persisted, per-agent, evidence-gate-aware goal loop (set/status/advance/subgoal/append).",
-    load: async () => (await import("./goal-7CZRMLHC.js")).goalCommand
+    load: async () => (await import("./goal-4GW4G77D.js")).goalCommand
   },
   {
     exportName: "gradeCommand",
     name: "grade",
     description: "Grade agent behavior for a session (requires --grade flag on session start)",
-    load: async () => (await import("./grade-PY2YRPUS.js")).gradeCommand
+    load: async () => (await import("./grade-25WSZH4X.js")).gradeCommand
   },
   {
     exportName: "graphCommand",
     name: "graph",
     description: "Project-scoped code intelligence: symbol graph, impact analysis, clusters, flows",
-    load: async () => (await import("./graph-XIXMCFKG.js")).graphCommand
+    load: async () => (await import("./graph-JUO3TMF3.js")).graphCommand
   },
   {
     exportName: "historyCommand",
     name: "history",
     description: "Completion timeline and productivity analytics",
-    load: async () => (await import("./history-EIXADPAD.js")).historyCommand
+    load: async () => (await import("./history-NACNUQTC.js")).historyCommand
   },
   {
     exportName: "hookCommand",
@@ -695,463 +714,463 @@ var COMMAND_MANIFEST = [
     exportName: "importTasksCommand",
     name: "import-tasks",
     description: "Import tasks from .cleo-export.json package with ID remapping",
-    load: async () => (await import("./import-tasks-O22FZJ4U.js")).importTasksCommand
+    load: async () => (await import("./import-tasks-FLE2RPBR.js")).importTasksCommand
   },
   {
     exportName: "importCommand",
     name: "import",
     description: "Import tasks from export package",
-    load: async () => (await import("./import-R73SO444.js")).importCommand
+    load: async () => (await import("./import-7ESGL5SS.js")).importCommand
   },
   {
     exportName: "initCommand",
     name: "init",
     description: "Initialize CLEO in a project directory",
-    load: async () => (await import("./init-IHEJDQWU.js")).initCommand
+    load: async () => (await import("./init-AN4DZ2XO.js")).initCommand
   },
   {
     exportName: "injectCommand",
     name: "inject",
     description: "Prepare tasks for external system injection",
-    load: async () => (await import("./inject-LSRVWNCP.js")).injectCommand
+    load: async () => (await import("./inject-HQWA5GWY.js")).injectCommand
   },
   {
     exportName: "installGlobalCommand",
     name: "install-global",
     description: "Run the global bootstrap manually (install templates, ~/.cleo symlink, agents, skills). Same as npm postinstall.",
-    load: async () => (await import("./install-global-4AZUCH6U.js")).installGlobalCommand
+    load: async () => (await import("./install-global-YQV4W5OG.js")).installGlobalCommand
   },
   {
     exportName: "intelligenceCommand",
     name: "intelligence",
     description: "Predictive intelligence and quality analysis",
-    load: async () => (await import("./intelligence-2OSFOGD2.js")).intelligenceCommand
+    load: async () => (await import("./intelligence-QIC4SN4X.js")).intelligenceCommand
   },
   {
     exportName: "issueCommand",
     name: "issue",
     description: "File bug reports, feature requests, or questions to CLEO GitHub repo",
-    load: async () => (await import("./issue-IIWEDNFC.js")).issueCommand
+    load: async () => (await import("./issue-P5RNMRDG.js")).issueCommand
   },
   {
     exportName: "janitorCommand",
     name: "janitor",
     description: "Orphan process reaper and stale scope/lock/debris sweep (silent, idempotent)",
-    load: async () => (await import("./janitor-GPMC7VOR.js")).janitorCommand
+    load: async () => (await import("./janitor-ZNCFQ7E3.js")).janitorCommand
   },
   {
     exportName: "labelsCommand",
     name: "labels",
     description: "List all labels (no args), or show tasks for a label (cleo labels <name>)",
-    load: async () => (await import("./labels-5NPOIQXN.js")).labelsCommand
+    load: async () => (await import("./labels-ORBM3T57.js")).labelsCommand
   },
   {
     exportName: "lifecycleCommand",
     name: "lifecycle",
     description: "RCASD-IVTR+C lifecycle pipeline management",
-    load: async () => (await import("./lifecycle-4FFS2K2T.js")).lifecycleCommand
+    load: async () => (await import("./lifecycle-MHR22TVI.js")).lifecycleCommand
   },
   {
     exportName: "listCommand",
     name: "list",
     description: "List tasks with optional filters",
-    load: async () => (await import("./list-47KEUGPQ.js")).listCommand
+    load: async () => (await import("./list-LB6GCYYU.js")).listCommand
   },
   {
     exportName: "costCommand",
     name: "cost",
     description: "Compute cumulative USD cost for an LLM session from recorded token_usage entries. ",
-    load: async () => (await import("./llm-cost-S7RS6BVA.js")).costCommand
+    load: async () => (await import("./llm-cost-MLMXEAR4.js")).costCommand
   },
   {
     exportName: "streamCommand",
     name: "stream",
     description: "Stream a single-prompt completion via LlmTransport.stream(). ",
-    load: async () => (await import("./llm-stream-24A45NTS.js")).streamCommand
+    load: async () => (await import("./llm-stream-AAEUNKRP.js")).streamCommand
   },
   {
     exportName: "llmCommand",
     name: "llm",
     description: "Manage LLM credentials, role profiles, and resolver diagnostics",
-    load: async () => (await import("./llm-G5B3I6GD.js")).llmCommand
+    load: async () => (await import("./llm-OTJWPMGI.js")).llmCommand
   },
   {
     exportName: "logCommand",
     name: "log",
     description: "View audit log entries (operations, timestamps, changes)",
-    load: async () => (await import("./log-XF6H2XSD.js")).logCommand
+    load: async () => (await import("./log-W2A5M2NA.js")).logCommand
   },
   {
     exportName: "loginCommand",
     name: "login",
-    description: "Log in to a Cleo Nexus account (cleo login nexus: device code, --api-url, --no-browser) or to an LLM provider, binding a usable profile in one step. The picker lists the Cleo Nexus account first, then the providers. After a Cleo Nexus sign-in inside an unlinked CLEO project it offers to link the project and back it up (--yes does it; a non-interactive run prints the next command); outside a project it lists your projects with the cleo cloud restore command for each. For a provider it picks an auth method (browser OAuth or API key), selects a model, binds it, and validates the binding. cleo auth login and cleo llm login resolve to this same flow. Prompts/URLs go to stderr; the result is a human line on a terminal or a JSON envelope when piped / --json.",
-    load: async () => (await import("./login-LBPLGHYG.js")).loginCommand
+    description: "Log in to a Cleo Nexus account (cleo login nexus: device code, --api-url, --no-browser) or to an LLM provider, binding a usable profile in one step. The picker lists the Cleo Nexus account first, then the providers. Without a terminal and no target, cleo login signs in to Cleo Nexus (an agent needs no extra word). After a Cleo Nexus sign-in inside an unlinked CLEO project it links the project and backs it up: a terminal is asked, --yes or a non-interactive run (an agent) does it, a restore over this copy is never done unasked, and CI only prints the next command; outside a project it lists your projects with the cleo cloud restore command for each. For a provider it picks an auth method (browser OAuth or API key), selects a model, binds it, and validates the binding. cleo auth login and cleo llm login resolve to this same flow. Prompts/URLs go to stderr; the result is a human line on a terminal or a JSON envelope when piped / --json.",
+    load: async () => (await import("./login-SIXFFZSP.js")).loginCommand
   },
   {
     exportName: "logoutCommand",
     name: "logout",
     description: "Sign out. cleo logout [nexus] signs this machine out of Cleo Nexus (the device keeps its id for the next login; --revoke burns it), confirmed by the server; cleo logout <provider> [label] removes an LLM credential exactly like cleo auth remove (the label may be omitted when the provider has one credential).",
-    load: async () => (await import("./logout-SX4JSJIV.js")).logoutCommand
+    load: async () => (await import("./logout-G3KVLQQM.js")).logoutCommand
   },
   {
     exportName: "manifestCommand",
     name: "manifest",
     description: "Manifest operations (pipeline_manifest table)",
-    load: async () => (await import("./manifest-NMCW4PIW.js")).manifestCommand
+    load: async () => (await import("./manifest-G4T6EBSI.js")).manifestCommand
   },
   {
     exportName: "mapCommand",
     name: "map",
     description: "Analyze codebase structure and return structured mapping",
-    load: async () => (await import("./map-BU72KMGF.js")).mapCommand
+    load: async () => (await import("./map-VU5M72TK.js")).mapCommand
   },
   {
     exportName: "memoryCommand",
     name: "memory",
     description: "BRAIN memory operations (patterns, learnings, decisions \u2014 use decision-store/-find for architectural decisions)",
-    load: async () => (await import("./memory-UHYIVGVM.js")).memoryCommand
+    load: async () => (await import("./memory-2E27G2G5.js")).memoryCommand
   },
   {
     exportName: "migrateAgentsV2Command",
     name: "agents-v2",
     description: "Register existing .cant agent files into signaldock.db (idempotent, conflict-safe)",
-    load: async () => (await import("./migrate-agents-v2-OO7OILZK.js")).migrateAgentsV2Command
+    load: async () => (await import("./migrate-agents-v2-A52QIYNJ.js")).migrateAgentsV2Command
   },
   {
     exportName: "migrateClaudeMemCommand",
     name: "migrate",
     description: "Data migration utilities",
-    load: async () => (await import("./migrate-claude-mem-EDNYUY3K.js")).migrateClaudeMemCommand
+    load: async () => (await import("./migrate-claude-mem-TPDW3R4Z.js")).migrateClaudeMemCommand
   },
   {
     exportName: "nextCommand",
     name: "next",
     description: "Suggest next task to work on based on priority and dependencies",
-    load: async () => (await import("./next-RZFRG5X7.js")).nextCommand
+    load: async () => (await import("./next-SVH4LIDY.js")).nextCommand
   },
   {
     exportName: "nexusCommand",
     name: "nexus",
     description: "Cross-project NEXUS operations",
-    load: async () => (await import("./nexus-4S4Z5EVU.js")).nexusCommand
+    load: async () => (await import("./nexus-XSFXN5E6.js")).nexusCommand
   },
   {
     exportName: "opsCommand",
     name: "ops",
     description: "Show available operations filtered to disclosure tier",
-    load: async () => (await import("./ops-KR7AWCG3.js")).opsCommand
+    load: async () => (await import("./ops-K6LHY5J6.js")).opsCommand
   },
   {
     exportName: "orchestrateCommand",
     name: "orchestrate",
     description: "Multi-agent orchestration commands",
-    load: async () => (await import("./orchestrate-HOYZY3VX.js")).orchestrateCommand
+    load: async () => (await import("./orchestrate-HURUCQFT.js")).orchestrateCommand
   },
   {
     exportName: "otelCommand",
     name: "otel",
     description: "Lightweight token metrics from .cleo/metrics/TOKEN_USAGE.jsonl (session-level, spawn-level events)",
-    load: async () => (await import("./otel-U7IIRBCT.js")).otelCommand
+    load: async () => (await import("./otel-JCNPVJLZ.js")).otelCommand
   },
   {
     exportName: "phaseCommand",
     name: "phase",
     description: "Project-level phase lifecycle management",
-    load: async () => (await import("./phase-NYZFHUE5.js")).phaseCommand
+    load: async () => (await import("./phase-VDFRASSO.js")).phaseCommand
   },
   {
     exportName: "pivotCommand",
     name: "pivot",
     description: "Record an audited context switch from one task to another (replaces silent reframes)",
-    load: async () => (await import("./pivot-FF2CVUZL.js")).pivotCommand
+    load: async () => (await import("./pivot-V5MSQZ7L.js")).pivotCommand
   },
   {
     exportName: "planCommand",
     name: "plan",
     description: "Task prioritization view: in-progress epics, ready tasks, blocked tasks, open bugs with scoring. Use when deciding what to work on next.",
-    load: async () => (await import("./plan-3SL2NTRV.js")).planCommand
+    load: async () => (await import("./plan-SQUGCKSM.js")).planCommand
   },
   {
     exportName: "playbookCommand",
     name: "playbook",
     description: "Playbook runtime operations (run, status, resume, list, create, validate)",
-    load: async () => (await import("./playbook-2FCBV7N3.js")).playbookCommand
+    load: async () => (await import("./playbook-L47GLDQD.js")).playbookCommand
   },
   {
     exportName: "projectCommand",
     name: "project",
     description: "Project lifecycle management (move, reroot, rename, re-register, link).",
-    load: async () => (await import("./project-WDX2TGMC.js")).projectCommand
+    load: async () => (await import("./project-YZEC7GYF.js")).projectCommand
   },
   {
     exportName: "promoteCommand",
     name: "promote",
     description: "Remove parent from task, making it root-level",
-    load: async () => (await import("./promote-YINYFBZY.js")).promoteCommand
+    load: async () => (await import("./promote-FINF4HVK.js")).promoteCommand
   },
   {
     exportName: "provenanceCommand",
     name: "provenance",
     description: "Provenance-graph maintenance: backfill, verify, repair",
-    load: async () => (await import("./provenance-C7AYD7WG.js")).provenanceCommand
+    load: async () => (await import("./provenance-YZG33JGM.js")).provenanceCommand
   },
   {
     exportName: "providerCommand",
     name: "provider",
     description: "CAAMP provider registry: list, detect, supports, hooks, inject",
-    load: async () => (await import("./provider-QLJEDQBR.js")).providerCommand
+    load: async () => (await import("./provider-23JVLLG3.js")).providerCommand
   },
   {
     exportName: "reasonCommand",
     name: "reason",
     description: "Reasoning and intelligence operations (impact, timeline)",
-    load: async () => (await import("./reason-JF5BHBM5.js")).reasonCommand
+    load: async () => (await import("./reason-FHN54O7O.js")).reasonCommand
   },
   {
     exportName: "reconcileCommand",
     name: "reconcile",
     description: "Reconcile state against external sources (release tags, schema, etc.)",
-    load: async () => (await import("./reconcile-NMISHDGX.js")).reconcileCommand
+    load: async () => (await import("./reconcile-MOM5T4AX.js")).reconcileCommand
   },
   {
     exportName: "refreshMemoryCommand",
     name: "refresh-memory",
     description: "Regenerate .cleo/memory-bridge.md from brain.db",
-    load: async () => (await import("./refresh-memory-EY5YNICV.js")).refreshMemoryCommand
+    load: async () => (await import("./refresh-memory-3OSTRAVK.js")).refreshMemoryCommand
   },
   {
     exportName: "relatesCommand",
     name: "relates",
     description: "Semantic relationship discovery and management between tasks",
-    load: async () => (await import("./relates-R3ZPICAY.js")).relatesCommand
+    load: async () => (await import("./relates-6FWUFUS2.js")).relatesCommand
   },
   {
     exportName: "releaseCommand",
     name: "release",
     description: "Release lifecycle management \u2014 4-verb pipeline: plan \u2192 open \u2192 reconcile / rollback. ",
-    load: async () => (await import("./release-4ZJTMUUT.js")).releaseCommand
+    load: async () => (await import("./release-URX6JHZ2.js")).releaseCommand
   },
   {
     exportName: "remoteCommand",
     name: "remote",
     description: "Manage .cleo/.git remotes for multi-contributor state sharing",
-    load: async () => (await import("./remote-QSONJDIK.js")).remoteCommand
+    load: async () => (await import("./remote-VIULU2T5.js")).remoteCommand
   },
   {
     exportName: "pushCommand",
     name: "push",
     description: "Push .cleo/ state to remote (operates on .cleo/.git)",
-    load: async () => (await import("./remote-QSONJDIK.js")).pushCommand
+    load: async () => (await import("./remote-VIULU2T5.js")).pushCommand
   },
   {
     exportName: "pullCommand",
     name: "pull",
     description: "Pull .cleo/ state from remote (operates on .cleo/.git)",
-    load: async () => (await import("./remote-QSONJDIK.js")).pullCommand
+    load: async () => (await import("./remote-VIULU2T5.js")).pullCommand
   },
   {
     exportName: "reorderCommand",
     name: "reorder",
     description: "Change task position within sibling group",
-    load: async () => (await import("./reorder-J3DOE7ST.js")).reorderCommand
+    load: async () => (await import("./reorder-UIPN6TQY.js")).reorderCommand
   },
   {
     exportName: "reparentCommand",
     name: "reparent",
     description: "Move task to a different parent in hierarchy",
-    load: async () => (await import("./reparent-2OUMKEZX.js")).reparentCommand
+    load: async () => (await import("./reparent-ALOWWUIU.js")).reparentCommand
   },
   {
     exportName: "reqCommand",
     name: "req",
     description: "Manage REQ-ID-addressable acceptance gates on tasks (in-task gates only). For cross-task dependency edges, use `cleo update <id> --add-depends <ids>` or `cleo update <id> --add-relates <id>:blocks` (gh-394).",
-    load: async () => (await import("./req-TZB7OFKO.js")).reqCommand
+    load: async () => (await import("./req-RH2Y3H7A.js")).reqCommand
   },
   {
     exportName: "researchCommand",
     name: "research",
     description: "Research commands and manifest operations",
-    load: async () => (await import("./research-MTD7EX45.js")).researchCommand
+    load: async () => (await import("./research-G2Y72HRC.js")).researchCommand
   },
   {
     exportName: "restoreCommand",
     name: "restore",
     description: "Restore from backup or restore tasks from terminal states (archived, cancelled, completed)",
-    load: async () => (await import("./restore-VEUOX7NF.js")).restoreCommand
+    load: async () => (await import("./restore-VBR5XNML.js")).restoreCommand
   },
   {
     exportName: "revertCommand",
     name: "revert",
     description: "Owner kill-switch: squash-revert all sentient merge commits from a receipt ID",
-    load: async () => (await import("./revert-3YF2IL5G.js")).revertCommand
+    load: async () => (await import("./revert-32LDNSGP.js")).revertCommand
   },
   {
     exportName: "roadmapCommand",
     name: "roadmap",
     description: "Generate project roadmap from task provenance \u2014 epics grouped by status with progress",
-    load: async () => (await import("./roadmap-7OOQLXKG.js")).roadmapCommand
+    load: async () => (await import("./roadmap-LFU3AG7D.js")).roadmapCommand
   },
   {
     exportName: "runCommand",
     name: "run",
     description: "Run a heavy command (tests, builds, installs) under the machine-wide resource budget: cleo run [--class test|build|full-build] [--wait] [--passthrough] -- <command...>",
-    load: async () => (await import("./run-2U5NZV5Z.js")).runCommand
+    load: async () => (await import("./run-HXRILSR7.js")).runCommand
   },
   {
     exportName: "safestopCommand",
     name: "safestop",
     description: "Graceful shutdown for agents approaching context limits",
-    load: async () => (await import("./safestop-VR4VK56D.js")).safestopCommand
+    load: async () => (await import("./safestop-Z5UC7NGQ.js")).safestopCommand
   },
   {
     exportName: "sagaCommand",
     name: "saga",
     description: "Saga management \u2014 above-Epic grouping tier (ADR-073)",
-    load: async () => (await import("./saga-SEWPIOX2.js")).sagaCommand
+    load: async () => (await import("./saga-Y6FZS6AM.js")).sagaCommand
   },
   {
     exportName: "schemaCommand",
     name: "schema",
     description: "Introspect a CLEO operation: show params, types, enums, and declared gates",
-    load: async () => (await import("./schema-C52WZ35V.js")).schemaCommand
+    load: async () => (await import("./schema-OOOKLWUE.js")).schemaCommand
   },
   {
     exportName: "selfUpdateCommand",
     name: "self-update",
     description: "Check for and install CLEO updates, then run post-update diagnostics",
-    load: async () => (await import("./self-update-GQIGUDPS.js")).selfUpdateCommand
+    load: async () => (await import("./self-update-26SOTJMH.js")).selfUpdateCommand
   },
   {
     exportName: "selfimproveCommand",
     name: "selfimprove",
     description: "Self-improvement loop \u2014 replay a canned dogfood scenario, diff vs golden, and surface ",
-    load: async () => (await import("./selfimprove-3Y5L4ECT.js")).selfimproveCommand
+    load: async () => (await import("./selfimprove-4SMOCLUV.js")).selfimproveCommand
   },
   {
     exportName: "sentientCommand",
     name: "sentient",
     description: "Manage the Tier-1 sentient autonomous loop daemon and Tier-2 proposals",
-    load: async () => (await import("./sentient-M4YMAVGV.js")).sentientCommand
+    load: async () => (await import("./sentient-RGMWR4XJ.js")).sentientCommand
   },
   {
     exportName: "sequenceCommand",
     name: "sequence",
     description: "Inspect and manage task ID sequence (show/check/repair)",
-    load: async () => (await import("./sequence-6UBMA4IF.js")).sequenceCommand
+    load: async () => (await import("./sequence-H7DSAJPF.js")).sequenceCommand
   },
   {
     exportName: "serviceCommand",
     name: "service",
     description: "Connect, list, revoke, and inspect service-vault credentials (github, google, \u2026)",
-    load: async () => (await import("./service-5R7SILZ7.js")).serviceCommand
+    load: async () => (await import("./service-EK5MGB2D.js")).serviceCommand
   },
   {
     exportName: "sessionCommand",
     name: "session",
     description: "Manage work sessions",
-    load: async () => (await import("./session-3C6AAC4Y.js")).sessionCommand
+    load: async () => (await import("./session-HYUXAQGC.js")).sessionCommand
   },
   {
     exportName: "setupCommand",
     name: "setup",
     description: "Interactive setup wizard \u2014 runs every section in canonical order (llm \u2192 system-one \u2192 models-roles \u2192 identity \u2192 sentient \u2192 project-conventions \u2192 harness \u2192 brain \u2192 integrations \u2192 telemetry \u2192 verification); system-one is optional. Use --section <name> for a single section, --non-interactive with section-specific flags to configure without prompts, --config-json for fully scripted setup, or --reset to reconfigure already-set sections.",
-    load: async () => (await import("./setup-BTUBW5PU.js")).setupCommand
+    load: async () => (await import("./setup-L3YYV53D.js")).setupCommand
   },
   {
     exportName: "showCommand",
     name: "show",
     description: "Show task details by ID. Accepts SEVERAL ids \u2014 `cleo show T1 T2 T3` returns them in one envelope and pays CLI startup once instead of per task (gh#1207). MVI-projected (id + title + status + key metadata) by default; pass --verbose / --full to receive the complete record with description, acceptance, verification, evidence, etc. (T9922)",
-    load: async () => (await import("./show-MXT2V7TF.js")).showCommand
+    load: async () => (await import("./show-364V3KY2.js")).showCommand
   },
   {
     exportName: "skillCommand",
     name: "skill",
     description: "Single-skill operations (restore, \u2026)",
-    load: async () => (await import("./skill-GFUZOU2C.js")).skillCommand
+    load: async () => (await import("./skill-F2KR6HW5.js")).skillCommand
   },
   {
     exportName: "skillsCommand",
     name: "skills",
     description: "Skill management: list, search, validate, info, install",
-    load: async () => (await import("./skills-EDWLKAF3.js")).skillsCommand
+    load: async () => (await import("./skills-FS3DCP6E.js")).skillsCommand
   },
   {
     exportName: "snapshotCommand",
     name: "snapshot",
     description: "Export/import task state snapshots for multi-contributor sharing",
-    load: async () => (await import("./snapshot-GUWMURCM.js")).snapshotCommand
+    load: async () => (await import("./snapshot-EGXEQ5PR.js")).snapshotCommand
   },
   {
     exportName: "startCommand",
     name: "start",
     description: "Start working on a task (sets it as the current task and takes your session's claim lease)",
-    load: async () => (await import("./start-QFG56RGN.js")).startCommand
+    load: async () => (await import("./start-6DXOCCKL.js")).startCommand
   },
   {
     exportName: "statsCommand",
     name: "stats",
     description: "Project statistics (counts, completion rates, velocity)",
-    load: async () => (await import("./stats-GW55P7RR.js")).statsCommand
+    load: async () => (await import("./stats-UVUQEGYC.js")).statsCommand
   },
   {
     exportName: "statusCommand",
     name: "status",
     description: "Unified config + credential + session + harness + daemon snapshot. ",
-    load: async () => (await import("./status-46HTKNRR.js")).statusCommand
+    load: async () => (await import("./status-XLKYLN42.js")).statusCommand
   },
   {
     exportName: "stickyCommand",
     name: "sticky",
     description: "Manage sticky notes - quick project-wide ephemeral captures",
-    load: async () => (await import("./sticky-2DUZOUGI.js")).stickyCommand
+    load: async () => (await import("./sticky-XZXZDCFW.js")).stickyCommand
   },
   {
     exportName: "stopCommand",
     name: "stop",
     description: "",
-    load: async () => (await import("./stop-J2QEUKHX.js")).stopCommand
+    load: async () => (await import("./stop-VNOAFWNB.js")).stopCommand
   },
   {
     exportName: "syncCommand",
     name: "sync",
     description: "External task synchronisation management",
-    load: async () => (await import("./sync-GJP2QYT5.js")).syncCommand
+    load: async () => (await import("./sync-YYPARW3A.js")).syncCommand
   },
   {
     exportName: "tasksCommand",
     name: "tasks",
     description: "Task query namespace: show, find, next, current, plan, analyze, slice",
-    load: async () => (await import("./tasks-BNXTM7PB.js")).tasksCommand
+    load: async () => (await import("./tasks-LBJC7CZV.js")).tasksCommand
   },
   {
     exportName: "telemetryCommand",
     name: "telemetry",
     description: "Manage anonymous skills-usage telemetry (enable/disable/status)",
-    load: async () => (await import("./telemetry-55Z2XJWL.js")).telemetryCommand
+    load: async () => (await import("./telemetry-CU7W5WAY.js")).telemetryCommand
   },
   {
     exportName: "templatesCommand",
     name: "templates",
     description: "TemplateManifest SSoT registry surface (list, show, install, upgrade, diff, validate)",
-    load: async () => (await import("./templates-7O77TKPV.js")).templatesCommand
+    load: async () => (await import("./templates-G42JBUY4.js")).templatesCommand
   },
   {
     exportName: "testingCommand",
     name: "testing",
     description: "Validate testing protocol compliance",
-    load: async () => (await import("./testing-37YTBNKP.js")).testingCommand
+    load: async () => (await import("./testing-HSRITHEY.js")).testingCommand
   },
   {
     exportName: "tokenCommand",
     name: "token",
     description: "Provider-aware token telemetry from tasks.db (historical, per-operation tracking)",
-    load: async () => (await import("./token-UAVJMNUI.js")).tokenCommand
+    load: async () => (await import("./token-J74E7TSU.js")).tokenCommand
   },
   {
     exportName: "transcriptCommand",
     name: "transcript",
     description: "Transcript lifecycle management: scan, extract, and prune session transcripts",
-    load: async () => (await import("./transcript-LORQTV5Z.js")).transcriptCommand
+    load: async () => (await import("./transcript-RGK7RSGQ.js")).transcriptCommand
   },
   {
     exportName: "tuiCommand",
@@ -1163,37 +1182,37 @@ var COMMAND_MANIFEST = [
     exportName: "updateCommand",
     name: "update",
     description: "Update a task. Safe under concurrent invocation \u2014 retries on SQLITE_BUSY up to 4 attempts (gh#391).",
-    load: async () => (await import("./update-NVCYV2FT.js")).updateCommand
+    load: async () => (await import("./update-2KQWA27S.js")).updateCommand
   },
   {
     exportName: "upgradeCommand",
     name: "upgrade",
     description: "Unified project maintenance (storage migration, schema repair, structural fixes, doc refresh)",
-    load: async () => (await import("./upgrade-OXJXOGEF.js")).upgradeCommand
+    load: async () => (await import("./upgrade-XRSQ4RWH.js")).upgradeCommand
   },
   {
     exportName: "verifyCommand",
     name: "verify",
     description: "View or modify verification gates for a task",
-    load: async () => (await import("./verify-LYLDHPT2.js")).verifyCommand
+    load: async () => (await import("./verify-WASRGDBA.js")).verifyCommand
   },
   {
     exportName: "webCommand",
     name: "web",
     description: "Open CLEO Studio in the browser (starts gateway on demand)",
-    load: async () => (await import("./web-QP2RP266.js")).webCommand
+    load: async () => (await import("./web-NJ3P67EU.js")).webCommand
   },
   {
     exportName: "workgraphCommand",
     name: "workgraph",
     description: "PM-Core V2 WorkGraph operations \u2014 validate, apply, plan, structure, status",
-    load: async () => (await import("./workgraph-FXBSZDQE.js")).workgraphCommand
+    load: async () => (await import("./workgraph-OHJ2VKJD.js")).workgraphCommand
   },
   {
     exportName: "worktreeCommand",
     name: "worktree",
     description: "Inspect and manage CLEO-attached git worktrees. ",
-    load: async () => (await import("./worktree-6RXAJIST.js")).worktreeCommand
+    load: async () => (await import("./worktree-FVQLORFY.js")).worktreeCommand
   }
 ];
 
@@ -1338,10 +1357,14 @@ async function validateCommandPath(command, rawArgs, label) {
     assertKnownFlags(rawArgs, schema, label);
   }
 }
+async function installRetiredHostGuard() {
+  const { installRetiredHostFetchGuard } = await import("@cleocode/core/conduit/cloud-endpoint.js");
+  installRetiredHostFetchGuard();
+}
 function lazyCommand(meta, loader) {
   let promise = null;
   const load = () => {
-    promise ??= loader();
+    promise ??= Promise.all([loader(), installRetiredHostGuard()]).then(([command]) => command);
     return promise;
   };
   const validate = async (cmd, rawArgs) => {
@@ -1349,8 +1372,8 @@ function lazyCommand(meta, loader) {
       await validateCommandPath(cmd, rawArgs, meta.name);
     } catch (err) {
       if (err instanceof UnknownFlagError) {
-        const { cliError } = await import("./renderers-64OR3IWX.js");
-        const { ExitCode } = await import("@cleocode/contracts");
+        const { cliError } = await import("./renderers-TGSW77J4.js");
+        const { ExitCode } = await import("@cleocode/contracts/exit-codes.js");
         cliError(err.message, ExitCode.VALIDATION_ERROR, {
           name: err.code,
           fix: err.fix,
@@ -1411,15 +1434,76 @@ function releaseCliThreadpoolEnv(env = process.env, startPool = startThreadPool)
   return true;
 }
 
+// packages/cleo/src/cli/lib/exit-path.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var preloaded = null;
+function preloadExitPath() {
+  preloaded ??= Promise.all([
+    import("./renderers-TGSW77J4.js"),
+    import("@cleocode/core/shutdown"),
+    import("@cleocode/core/shutdown-deadline")
+  ]).then(([renderers, shutdown, deadline]) => ({
+    cliError: renderers.cliError,
+    shutdownCliRuntime: shutdown.shutdownCliRuntime,
+    armExitBackstop: deadline.armExitBackstop,
+    formatShutdownOutcomes: deadline.formatShutdownOutcomes
+  }));
+  preloaded.catch(() => {
+  });
+  return preloaded;
+}
+function exitPath() {
+  return preloadExitPath();
+}
+function errorCode(err) {
+  return err instanceof Error && "code" in err && typeof err.code === "string" ? err.code : void 0;
+}
+function isVanishedModule(err) {
+  const code = errorCode(err);
+  return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND";
+}
+function vanishedModuleNotice(err, runningVersion, packageJsonPath = defaultPackageJson()) {
+  const installed2 = installedVersion(packageJsonPath);
+  const missing = err instanceof Error ? err.message.split("\n")[0] : String(err);
+  if (installed2 !== null && installed2 !== runningVersion) {
+    return `[cleo] CLEO was upgraded from ${runningVersion} to ${installed2} while this command ran, and the code it needed to finish is gone (${missing}). The command itself ran; check its result, and run it again if needed.
+`;
+  }
+  return `[cleo] a CLEO module is missing from the installation (${missing}). Reinstall CLEO.
+`;
+}
+function exitPathLoadFailureNotice(err, runningVersion, packageJsonPath) {
+  if (isVanishedModule(err)) return vanishedModuleNotice(err, runningVersion, packageJsonPath);
+  const code = errorCode(err);
+  const detail = err instanceof Error ? err.stack ?? err.message : String(err);
+  return `[cleo] the CLI could not load the code that finishes this command${code ? ` (${code})` : ""}:
+${detail}
+`;
+}
+function defaultPackageJson() {
+  return join(dirname(fileURLToPath(import.meta.url)), "../../package.json");
+}
+function installedVersion(packageJsonPath) {
+  try {
+    if (!existsSync(packageJsonPath)) return null;
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+
 // packages/cleo/src/cli/lib/first-run-detection.ts
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
 async function detectFirstRun() {
   const envKey = process.env["ANTHROPIC_API_KEY"];
   if (typeof envKey === "string" && envKey.length > 0) return false;
   const { getCleoPlatformPaths } = await import("@cleocode/paths");
-  const configPath = join(getCleoPlatformPaths().config, "config.json");
-  if (existsSync(configPath)) return false;
+  const configPath = join2(getCleoPlatformPaths().config, "config.json");
+  if (existsSync2(configPath)) return false;
   try {
     const { getCredentialPool } = await import("@cleocode/core/llm/credential-pool.js");
     const pool = getCredentialPool();
@@ -1460,9 +1544,9 @@ function waitForEnterOrTimeout(timeoutMs) {
 }
 async function maybePromptFirstRun() {
   try {
+    if (process.stdin.isTTY !== true) return;
     const isFirstRun = await detectFirstRun();
     if (!isFirstRun) return;
-    if (process.stdin.isTTY !== true) return;
     process.stderr.write(
       "CLEO is not configured. Run 'cleo setup' to get started. (Press Enter to skip, or wait 10s)\n"
     );
@@ -1514,10 +1598,10 @@ function resolveFormat(opts, defaults, tty) {
 }
 
 // packages/cleo/src/cli/module-resolve-fast-path.ts
-import { readFileSync, realpathSync, statSync } from "node:fs";
+import { readFileSync as readFileSync2, realpathSync, statSync } from "node:fs";
 import * as nodeModule from "node:module";
-import { basename, dirname, join as join2 } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { basename, dirname as dirname2, join as join3 } from "node:path";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
 var RELATIVE_JS_SPECIFIER = /^\.\.?\/[^?#%\\]*\.(js|mjs|cjs)$/;
 var DISABLE_ENV = "CLEO_RESOLVE_FAST_PATH";
 var NODE_FS = {
@@ -1525,10 +1609,17 @@ var NODE_FS = {
   realpath: (path) => realpathSync(path),
   readText: (path) => {
     try {
-      return readFileSync(path, "utf8");
+      return readFileSync2(path, "utf8");
     } catch {
       return void 0;
     }
+  },
+  isDirectory: (path) => {
+    try {
+      return statSync(path).isDirectory();
+    } catch {
+      return false;
+    }
   }
 };
 function declaredFormat(raw) {
@@ -1547,6 +1638,26 @@ function declaredFormat(raw) {
 function createFastResolve(fs = NODE_FS) {
   const scopeByDir = /* @__PURE__ */ new Map();
   const bareByKey = /* @__PURE__ */ new Map();
+  const bareScopeByDir = /* @__PURE__ */ new Map();
+  const bareScope = (dir) => {
+    const cached = bareScopeByDir.get(dir);
+    if (cached !== void 0) return cached;
+    let scope = dir;
+    let current = dir;
+    for (; ; ) {
+      if (fs.readText(join3(current, "package.json")) !== void 0) {
+        scope = current;
+        break;
+      }
+      if (basename(current) === "node_modules" || fs.isDirectory(join3(current, "node_modules")))
+        break;
+      const parent = dirname2(current);
+      if (parent === current) break;
+      current = parent;
+    }
+    bareScopeByDir.set(dir, scope);
+    return scope;
+  };
   const scopeFormat = (dir) => {
     const visited = [];
     let current = dir;
@@ -1559,12 +1670,12 @@ function createFastResolve(fs = NODE_FS) {
       }
       visited.push(current);
       if (basename(current) === "node_modules") break;
-      const raw = fs.readText(join2(current, "package.json"));
+      const raw = fs.readText(join3(current, "package.json"));
       if (raw !== void 0) {
         found = declaredFormat(raw);
         break;
       }
-      const parent = dirname(current);
+      const parent = dirname2(current);
       if (parent === current) break;
       current = parent;
     }
@@ -1574,13 +1685,13 @@ function createFastResolve(fs = NODE_FS) {
   const resolveRelative = (specifier, parentURL, extension) => {
     let real;
     try {
-      const path = fileURLToPath(new URL(specifier, parentURL));
+      const path = fileURLToPath2(new URL(specifier, parentURL));
       if (!fs.isFile(path)) return null;
       real = fs.realpath(path);
     } catch {
       return null;
     }
-    const format = extension === "mjs" ? "module" : extension === "cjs" ? "commonjs" : scopeFormat(dirname(real));
+    const format = extension === "mjs" ? "module" : extension === "cjs" ? "commonjs" : scopeFormat(dirname2(real));
     if (format === null) return null;
     return { url: pathToFileURL(real).href, format, shortCircuit: true };
   };
@@ -1594,7 +1705,13 @@ function createFastResolve(fs = NODE_FS) {
     }
     const bare = !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("#") && !specifier.includes(":") && !specifier.includes("\\");
     if (!bare) return nextResolve(specifier, context);
-    const key = `${specifier}\0${parentURL.slice(0, parentURL.lastIndexOf("/"))}\0${conditions.join(",")}`;
+    let parentDir;
+    try {
+      parentDir = dirname2(fileURLToPath2(parentURL));
+    } catch {
+      return nextResolve(specifier, context);
+    }
+    const key = `${specifier}\0${bareScope(parentDir)}\0${conditions.join(",")}`;
     const cached = bareByKey.get(key);
     if (cached) return cached;
     const resolved = nextResolve(specifier, context);
@@ -1650,8 +1767,8 @@ enforceNodeVersion();
 releaseCliThreadpoolEnv();
 installModuleResolveFastPath();
 function getPackageVersion() {
-  const pkgPath = join3(dirname2(fileURLToPath2(import.meta.url)), "../../package.json");
-  const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+  const pkgPath = join4(dirname3(fileURLToPath3(import.meta.url)), "../../package.json");
+  const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
   return pkg.version;
 }
 var CLI_VERSION = getPackageVersion();
@@ -1665,7 +1782,7 @@ for (const entry of COMMAND_MANIFEST) {
 subCommands["version"] = defineCommand({
   meta: { name: "version", description: "Display CLEO version" },
   async run() {
-    const { cliOutput } = await import("./renderers-64OR3IWX.js");
+    const { cliOutput } = await import("./renderers-TGSW77J4.js");
     cliOutput({ version: CLI_VERSION }, { command: "version" });
   }
 });
@@ -1737,7 +1854,7 @@ Valid modes: ${validModes.join(", ")}
     const { runCockpit } = await import("./cockpit-RZKLGYPN.js");
     let autoStart = true;
     try {
-      const { getRawConfig } = await import("@cleocode/core");
+      const { getRawConfig } = await import("@cleocode/core/config");
       const cfg = await getRawConfig();
       const { shouldAutoStartGateway } = await import("./gateway-auto-start-EDK7XI6E.js");
       autoStart = shouldAutoStartGateway(cfg);
@@ -1748,15 +1865,17 @@ Valid modes: ${validModes.join(", ")}
   }
   const isHelpOrVersion = argv.length === 0 || argv[0] === "--help" || argv[0] === "-h" || argv[0] === "--version" || argv[0] === "-V" || argv[0] === "help";
   if (argv[0] === "--version" || argv[0] === "-V") {
-    const { cliOutput } = await import("./renderers-64OR3IWX.js");
+    const { cliOutput } = await import("./renderers-TGSW77J4.js");
     cliOutput({ version: CLI_VERSION }, { command: "version" });
     return;
   }
   if (!isHelpOrVersion) {
     if (rawOpts["quiet"] === true) {
-      const { setLoggerQuiet } = await import("@cleocode/core/internal");
+      const { setLoggerQuiet } = await import("@cleocode/core/logger");
       setLoggerQuiet(true);
     }
+    const { showUpdateNotice } = await import("./update-notice-6SQ6WPQG.js");
+    showUpdateNotice({ version: CLI_VERSION, argv, quiet: rawOpts["quiet"] === true });
     await runStartupMaintenance();
   }
   if (!isHelpOrVersion) {
@@ -1823,7 +1942,7 @@ async function runMainWithLafsEnvelope(cmd, rawArgs, showUsage2) {
     const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
     const version = meta?.version;
     if (!version) {
-      const { cliError } = await import("./renderers-64OR3IWX.js");
+      const { cliError } = await import("./renderers-TGSW77J4.js");
       cliError("No version specified", 1, { name: "E_NO_VERSION" });
       process.exit(1);
     }
@@ -1833,8 +1952,12 @@ async function runMainWithLafsEnvelope(cmd, rawArgs, showUsage2) {
   }
   const { WarningCollector, withWarningCollector } = await import("@cleocode/lafs");
   const collector = new WarningCollector();
+  preloadExitPath();
   await withWarningCollector(collector, async () => {
-    const { recordProjectEncounter, setProjectMovedRefusal } = await import("@cleocode/core/internal");
+    const [{ recordProjectEncounter }, { setProjectMovedRefusal }] = await Promise.all([
+      import("@cleocode/core/paths.js"),
+      import("@cleocode/core/project-tombstone")
+    ]);
     const isDoctor = rawArgs.find((a) => !a.startsWith("-")) === "doctor";
     if (isDoctor) setProjectMovedRefusal(false);
     try {
@@ -1850,7 +1973,7 @@ async function runMainWithLafsEnvelope(cmd, rawArgs, showUsage2) {
         );
     }
     try {
-      const { heartbeatThisDevice } = await import("@cleocode/core/internal");
+      const { heartbeatThisDevice } = await import("@cleocode/core/nexus/devices");
       const outcome = await heartbeatThisDevice();
       if (process.env["CLEO_DEBUG"])
         process.stderr.write(`[cleo][debug] Device heartbeat: ${outcome}
@@ -1859,20 +1982,43 @@ async function runMainWithLafsEnvelope(cmd, rawArgs, showUsage2) {
       if (process.env["CLEO_DEBUG"])
         process.stderr.write(
           `[cleo][debug] Device heartbeat not recorded: ${error instanceof Error ? error.message : String(error)}
+`
+        );
+    }
+    try {
+      const [{ getProjectRoot }, { getCleoDirAbsolute }] = await Promise.all([
+        import("@cleocode/core/project-scope"),
+        import("@cleocode/core/paths.js")
+      ]);
+      const projectRoot = getProjectRoot();
+      if (existsSync3(join4(getCleoDirAbsolute(projectRoot), "nexus-link.json"))) {
+        const { startProjectPresenceRefresh } = await import("@cleocode/core/cloud/nexus-presence-refresh.js");
+        startProjectPresenceRefresh({ projectRoot, cliVersion: CLI_VERSION });
+      }
+    } catch (error) {
+      if (process.env["CLEO_DEBUG"])
+        process.stderr.write(
+          `[cleo][debug] Presence refresh not started: ${error instanceof Error ? error.message : String(error)}
 `
         );
     }
     try {
       await runCommand(cmd, { rawArgs });
     } catch (err) {
-      const { cliError } = await import("./renderers-64OR3IWX.js");
+      let cliError;
+      try {
+        ({ cliError } = await exitPath());
+      } catch (loadError) {
+        process.stderr.write(exitPathLoadFailureNotice(loadError, CLI_VERSION));
+        return await settleThenExit(1);
+      }
       const cittyCliError = asCittyCliError(err);
       if (cittyCliError) {
         cliError(stripAnsi(cittyCliError.message), 1, {
           name: cittyErrorCodeName(cittyCliError.code),
           fix: cittyErrorFix(cittyCliError.code)
         });
-        process.exit(1);
+        await settleThenExit(1);
       }
       const typed = asCleoErrorLike(err);
       if (typed) {
@@ -1882,14 +2028,20 @@ async function runMainWithLafsEnvelope(cmd, rawArgs, showUsage2) {
           alternatives: typed.alternatives,
           details: typed.details
         });
-        process.exit(typed.code);
+        await settleThenExit(typed.code);
       }
       const message = err instanceof Error ? err.message : String(err);
       cliError(message, 1, { name: "E_CLI_UNCAUGHT" });
-      process.exit(1);
+      await settleThenExit(1);
     } finally {
-      const { shutdownCliRuntime, armExitBackstop } = await import("@cleocode/core/internal");
-      const { formatShutdownOutcomes } = await import("@cleocode/core/shutdown-deadline");
+      let teardown;
+      try {
+        teardown = await exitPath();
+      } catch (loadError) {
+        process.stderr.write(exitPathLoadFailureNotice(loadError, CLI_VERSION));
+        process.exit(process.exitCode ?? 0);
+      }
+      const { shutdownCliRuntime, armExitBackstop, formatShutdownOutcomes } = teardown;
       const outcomes = await shutdownCliRuntime();
       const diagnostics = formatShutdownOutcomes(outcomes);
       if (diagnostics) process.stderr.write(diagnostics);
@@ -1898,19 +2050,24 @@ async function runMainWithLafsEnvelope(cmd, rawArgs, showUsage2) {
   });
 }
 async function runStartupMaintenance() {
-  const {
-    detectAndRemoveLegacyGlobalFiles,
-    detectAndRemoveStrayProjectNexus,
-    getGlobalSalt,
-    getLogger,
-    getProjectRoot,
-    isCleanupMarkerSet,
-    isMissingProjectError,
-    migrateSignaldockToConduit,
-    needsSignaldockToConduitMigration,
-    setCleanupMarker,
-    validateGlobalSalt
-  } = await import("@cleocode/core/internal");
+  const [
+    {
+      detectAndRemoveLegacyGlobalFiles,
+      detectAndRemoveStrayProjectNexus,
+      isCleanupMarkerSet,
+      setCleanupMarker
+    },
+    { getGlobalSalt, validateGlobalSalt },
+    { getLogger },
+    { getProjectRoot, isMissingProjectError },
+    { migrateSignaldockToConduit, needsSignaldockToConduitMigration }
+  ] = await Promise.all([
+    import("@cleocode/core/store/cleanup-legacy"),
+    import("@cleocode/core/store/global-salt"),
+    import("@cleocode/core/logger"),
+    import("@cleocode/core/project-scope"),
+    import("@cleocode/core/store/migrate-signaldock-to-conduit")
+  ]);
   let projectRootForCleanup = "";
   try {
     projectRootForCleanup = getProjectRoot();
@@ -1969,7 +2126,7 @@ async function runStartupMaintenance() {
 }
 async function bootstrap() {
   if (process.env["CLEO_WORKTREE_ROOT"]) {
-    const { runWithWorktreeScopeFromEnv } = await import("@cleocode/core/internal");
+    const { runWithWorktreeScopeFromEnv } = await import("@cleocode/core/paths.js");
     runWithWorktreeScopeFromEnv(() => {
       void startCli();
     });