@cleocode/cleo 2026.9.26 → 2026.10.2

package/dist/cli/index.js

@@ -1425,6 +1425,10 @@ function extractIdempotencyKeyArg(argv) {
   let idempotencyKey;
   for (let i = 0; i < argv.length; i++) {
     const token = argv[i];
+    if (token === "--") {
+      sanitized.push(...argv.slice(i));
+      break;
+    }
     if (token === "--idempotency-key") {
       const next = argv[i + 1];
       if (next !== void 0 && !next.startsWith("--")) {
@@ -17759,6 +17763,326 @@ var init_adr_073_saga = __esm({
   }
 });
 
+// packages/contracts/src/invariants/sync-write-invariants.ts
+function checkPending(task) {
+  return { task, reason: "the post-apply check is not implemented yet (T12344 item)" };
+}
+function rulePending(task) {
+  return { task, reason: "the typed merge-rule registry does not define it yet (T12344 item)" };
+}
+function trigger(id, tables, triggers, inventory, reason) {
+  return { id, class: "trigger-covered", tables, sites: [], triggers, inventory, reason };
+}
+function pac(id, item, task, tables, footprint, reason) {
+  return {
+    id,
+    class: "post-apply-check",
+    tables,
+    sites: [],
+    check: { footprint },
+    inventory: [item],
+    pending: checkPending(task),
+    reason
+  };
+}
+function rule(id, task, table, columns, inventory, reason, tables = [table]) {
+  return {
+    id,
+    class: "monotonic-merge-rule",
+    tables,
+    sites: [],
+    mergeRule: { table, columns },
+    inventory,
+    pending: rulePending(task),
+    reason
+  };
+}
+var SYNC_WRITE_INVARIANTS;
+var init_sync_write_invariants = __esm({
+  "packages/contracts/src/invariants/sync-write-invariants.ts"() {
+    "use strict";
+    SYNC_WRITE_INVARIANTS = Object.freeze([
+      // §3.6.2: RAISE guards and UNIQUE indexes a migration creates on synced tables.
+      trigger(
+        "task.parent.no-cycle",
+        ["tasks_tasks"],
+        ["tasks_tasks_parent_cycle_guard_insert", "tasks_tasks_parent_cycle_guard_update"],
+        ["V10", "V11"],
+        "the parent chain is acyclic (the INSERT variant misses a self-parent, \xA73.6.3 item 2)"
+      ),
+      trigger(
+        "task.parent.type-matrix",
+        ["tasks_tasks"],
+        ["tasks_tasks_parent_type_matrix_insert", "tasks_tasks_parent_type_matrix_update"],
+        ["X1"],
+        "parent/child type matrix; weaker than TypeScript (\xA73.6.3 item 1), the rest is PAC-01"
+      ),
+      trigger(
+        "task.status.pipeline-consistency",
+        ["tasks_tasks"],
+        ["trg_tasks_tasks_status_pipeline_insert", "trg_tasks_tasks_status_pipeline_update"],
+        ["V19", "C21"],
+        "T877: status and pipeline_stage agree on one row"
+      ),
+      trigger(
+        "task.relation.non-containment",
+        ["tasks_task_relations"],
+        ["tasks_task_relations_non_containment_insert", "tasks_task_relations_non_containment_update"],
+        ["V31"],
+        "no relation between a parent and its child, on relation writes only (\xA73.6.3 item 4)"
+      ),
+      trigger(
+        "task.ac.child-target",
+        ["tasks_task_acceptance_criteria"],
+        ["tasks_task_acceptance_child_target_insert", "tasks_task_acceptance_child_target_update"],
+        ["C28"],
+        "a child_task AC targets a direct child, on AC writes only (\xA73.6.3 item 4)"
+      ),
+      trigger(
+        "session.handoff.append-only",
+        ["tasks_session_handoff_entries"],
+        ["trg_tasks_session_handoff_no_update"],
+        ["H2"],
+        "handoff entries are never updated"
+      ),
+      trigger(
+        "task.claim.lease-iso",
+        ["tasks_tasks"],
+        ["tasks_tasks_lease_iso_insert", "tasks_tasks_lease_iso_update"],
+        [],
+        "claim lease timestamps are ISO-8601 (t12736)"
+      ),
+      trigger(
+        "task.ac-binding.unique",
+        ["tasks_evidence_ac_bindings"],
+        ["uq_tasks_evidence_ac_bindings_atom_ac_type"],
+        ["C31"],
+        "one binding per (evidence atom, AC, binding type)"
+      ),
+      trigger(
+        "release.version.unique",
+        ["tasks_releases"],
+        ["uq_tasks_releases_version"],
+        ["REL-1"],
+        "one release row per version"
+      ),
+      trigger(
+        "selfimprove.dhq.one-open",
+        ["selfimprove_dhq"],
+        ["ux_selfimprove_dhq_open"],
+        ["D49"],
+        "at most one open DHQ entry per question_hash"
+      ),
+      trigger(
+        "account.one-active-per-provider",
+        ["accounts"],
+        ["ux_accounts_active_provider"],
+        ["A40"],
+        "at most one active account per provider (partial UNIQUE)"
+      ),
+      // §3.6.5: post-apply check families (T12344 items).
+      pac(
+        "task.tree.shape",
+        "PAC-01",
+        "T12922",
+        ["tasks_tasks"],
+        ["rows with a changed parent_id or type", "their direct children and ancestor chain"],
+        "saga\u2192epic\u2192task\u2192subtask matrix, non-saga has a parent, depth \u2264 3, no self-parent"
+      ),
+      pac(
+        "task.terminal-parent.live-children",
+        "PAC-02",
+        "T12923",
+        ["tasks_tasks"],
+        ["rows whose status, stage or parent changed", "their parent and siblings"],
+        "no terminal parent with a live child; epic stage \u2265 children; rollup re-evaluated"
+      ),
+      pac(
+        "task.dependency.graph",
+        "PAC-03",
+        "T12924",
+        ["tasks_task_dependencies", "tasks_tasks"],
+        ["dependency edges inserted in the page", "reachability from each depends_on"],
+        "dependencies are acyclic, with no self-edge"
+      ),
+      pac(
+        "task.done.evidence",
+        "PAC-04",
+        "T12925",
+        ["tasks_tasks", "tasks_task_acceptance_criteria", "tasks_evidence_ac_bindings"],
+        ["done rows in the page", "their AC rows, bindings, acceptance_json and verification_json"],
+        "a done task has passed verification and every AC bound or waived"
+      ),
+      pac(
+        "task.ac.integrity",
+        "PAC-05",
+        "T12926",
+        ["tasks_tasks", "tasks_task_acceptance_criteria", "tasks_evidence_ac_bindings"],
+        ["tasks whose AC rows, bindings, acceptance_json, parent_id or relations changed"],
+        "acceptance_json \u21D4 AC rows, child_task ACs match children, bindings resolve"
+      ),
+      pac(
+        "lifecycle.rows",
+        "PAC-06",
+        "T12927",
+        ["tasks_lifecycle_pipelines", "tasks_lifecycle_stages", "tasks_tasks"],
+        ["lifecycle pipeline, stage and gate rows in the page", "the owning task row"],
+        "one pipeline per task, one stage row per name, pipeline_stage \u2265 completed stages"
+      ),
+      pac(
+        "derived.mirrors",
+        "PAC-07",
+        "T12928",
+        ["tasks_task_labels", "brain_sticky_tags", "docs_wikilinks", "tasks_tasks"],
+        ["owning rows whose JSON or junction changed"],
+        "junction tables equal their JSON source"
+      ),
+      pac(
+        "session.goal.singletons",
+        "PAC-08",
+        "T12929",
+        ["tasks_sessions", "tasks_task_work_history", "tasks_goal"],
+        ["session rows whose status, scope or chain changed", "work-history rows per session"],
+        "one active session per scope, reciprocal chain, one open interval, one live goal"
+      ),
+      pac(
+        "audit.uniqueness",
+        "PAC-09",
+        "T12930",
+        ["tasks_audit_log"],
+        ["audit rows with a non-null idempotency key", "rollback audit rows"],
+        "idempotency keys are unique across replicas; at most one rollback per receipt"
+      ),
+      pac(
+        "identity.collisions",
+        "PAC-10",
+        "T12931",
+        ["tasks_tasks", "tasks_sessions", "brain_observations", "docs_attachments"],
+        ["inserted rows", "the natural key's index"],
+        "display-id and natural-key clashes become an alias or re-mint (T12341)"
+      ),
+      pac(
+        "dedupe.at-most-one",
+        "PAC-11",
+        "T12932",
+        ["brain_decisions", "brain_learnings", "tasks_external_task_links"],
+        ["inserted rows grouped by the natural key"],
+        "duplicates created on two devices are merged"
+      ),
+      pac(
+        "ref.soft-orphans",
+        "PAC-12",
+        "T12933",
+        ["brain_memory_links", "brain_page_edges", "docs_attachment_refs", "tasks_task_commits"],
+        ["reference columns of the rows in the page", "their targets"],
+        "cross-DB and polymorphic references resolve"
+      ),
+      pac(
+        "supersession.graph",
+        "PAC-13",
+        "T12934",
+        ["brain_decisions", "docs_attachments", "tasks_architecture_decisions"],
+        ["rows whose supersession columns changed", "a chain walk"],
+        "supersession chains are acyclic with at most one successor"
+      ),
+      pac(
+        "derived.counters",
+        "PAC-14",
+        "T12935",
+        ["docs_attachments", "conduit_attachments", "docs_pipeline_manifest"],
+        ["the owning rows"],
+        "derived counters and cross-column facts agree with their rows"
+      ),
+      pac(
+        "apply.preconditions",
+        "PAC-15",
+        "T12936",
+        ["tasks_tasks"],
+        ["the whole page"],
+        "no apply while the local twin collapse has failed; restore is a re-baseline"
+      ),
+      // §3.6.6: typed merge rules (T12344).
+      rule(
+        "task.status.absorbing",
+        "T12937",
+        "tasks_tasks",
+        ["status", "completed_at", "cancelled_at", "cancellation_reason", "pipeline_stage"],
+        ["V18", "V20", "C22", "P40", "P46", "P47"],
+        "done, cancelled and archived are absorbing; leaving them needs an explicit op"
+      ),
+      rule(
+        "task.pipeline-stage.max",
+        "T12938",
+        "tasks_tasks",
+        ["pipeline_stage"],
+        ["V21", "C20", "P01", "F3"],
+        "pipeline_stage is the maximum by STAGE_ORDER, except an explicit restore"
+      ),
+      rule(
+        "task.verification.frozen-on-done",
+        "T12939",
+        "tasks_tasks",
+        ["verification_json"],
+        ["C01", "C02", "C03", "C17"],
+        "verification is frozen once done; otherwise merged per gate"
+      ),
+      rule(
+        "session.status.terminal",
+        "T12940",
+        "tasks_sessions",
+        ["status", "ended_at"],
+        ["S7", "S8", "S9", "S10", "S11", "S17", "S18", "SC2", "N1", "SK5", "P32"],
+        "ended and orphaned are terminal except on an explicit resume"
+      ),
+      rule("audit.immutable", "T12941", "tasks_audit_log", ["*"], ["SA3"], "audit rows are immutable", [
+        "tasks_audit_log",
+        "audit_log"
+      ]),
+      rule(
+        "sticky.status.one-way",
+        "T12942",
+        "brain_sticky_notes",
+        ["status", "converted_to_json"],
+        ["SK2", "SK3", "B24"],
+        "active\u2192{converted, archived} is one-way; converted_to_json is write-once"
+      ),
+      rule(
+        "release.status.absorbing",
+        "T12943",
+        "tasks_releases",
+        ["status"],
+        ["REL-2", "REL-3", "REL-4", "REL-5", "REL-6", "REL-7", "REL-8"],
+        "shipped release statuses are absorbing"
+      ),
+      rule(
+        "playbook.approval.once",
+        "T12944",
+        "tasks_playbook_approvals",
+        ["status"],
+        ["PB-1", "PB-4", "PB-7", "P33"],
+        "an approval goes pending\u2192decided once"
+      ),
+      rule(
+        "docs.lifecycle.transitions",
+        "T12945",
+        "docs_attachments",
+        ["lifecycle_status"],
+        ["D04", "D05", "D31", "D32", "D39", "D50"],
+        "superseded is sticky; lifecycle transitions follow a matrix"
+      ),
+      // §3.6.0 identity-layer rows.
+      {
+        id: "identity.local-minting",
+        class: "identity-layer",
+        tables: ["tasks_tasks", "tasks_sessions"],
+        sites: [],
+        inventory: ["V12", "B07", "B12"],
+        reason: "ids minted from local state (display ids, integer PKs, device-derived ids) collide across replicas; T12341 uids and re-minting own it, no validator port can"
+      }
+    ]);
+  }
+});
+
 // packages/contracts/src/invariants/index.ts
 function buildKey(invariant) {
   return `${invariant.adr}.${invariant.code}`;
@@ -17802,6 +18126,7 @@ var init_invariants = __esm({
     init_adr_056_release();
     init_adr_070_orchestration();
     init_adr_073_saga();
+    init_sync_write_invariants();
     INVARIANTS_REGISTRY = buildRegistry();
   }
 });
@@ -20673,7 +20998,7 @@ var init_render2 = __esm({
 function isResourceGrant(r) {
   return r.deferred === false;
 }
-var RESOURCE_CLASSES, RESOURCE_DEFERRED_CODE, RESOURCE_BACKPRESSURE_CODE, DEFAULT_RESOURCE_RETRY_AFTER_MS;
+var RESOURCE_CLASSES, RESOURCE_DEFERRED_CODE, RUN_COMMAND_FAILED_CODE, RUN_DEFERRED_EXIT_CODE, RESOURCE_BACKPRESSURE_CODE, DEFAULT_RESOURCE_RETRY_AFTER_MS;
 var init_resource_governor = __esm({
   "packages/contracts/src/resource-governor.ts"() {
     "use strict";
@@ -20688,6 +21013,8 @@ var init_resource_governor = __esm({
       "background-autonomous"
     ]);
     RESOURCE_DEFERRED_CODE = "E_RESOURCE_DEFERRED";
+    RUN_COMMAND_FAILED_CODE = "E_COMMAND_FAILED";
+    RUN_DEFERRED_EXIT_CODE = 75;
     RESOURCE_BACKPRESSURE_CODE = "E_RESOURCE_BACKPRESSURE";
     DEFAULT_RESOURCE_RETRY_AFTER_MS = 2e3;
   }
@@ -21624,11 +21951,11 @@ var init_taxonomy = __esm({
        * @throws TaxonomyError when any tag is not canonical.
        */
       validateOrThrow(tags, context) {
-        const invalid = this.validate(tags);
-        if (invalid.length > 0) {
+        const invalid2 = this.validate(tags);
+        if (invalid2.length > 0) {
           throw new TaxonomyError(
-            `${context}: unknown tags [${invalid.join(", ")}]. Use canonical tags. Run 'cleo taxonomy list' to see all valid tags.`,
-            invalid
+            `${context}: unknown tags [${invalid2.join(", ")}]. Use canonical tags. Run 'cleo taxonomy list' to see all valid tags.`,
+            invalid2
           );
         }
       }
@@ -22759,8 +23086,37 @@ var init_nexus_account = __esm({
       "E_NEXUS_BUSY",
       /** Several accounts hold a device credential on one origin and none was named. */
       "E_NEXUS_ACCOUNT_AMBIGUOUS",
-      /** An option that needs device credentials (`--read-only`) without `CLEO_NEXUS_DEVICE=1`. */
-      "E_NEXUS_DEVICE_REQUIRED"
+      /** An option that needs device credentials (`--read-only`) with `CLEO_NEXUS_DEVICE=0`. */
+      "E_NEXUS_DEVICE_REQUIRED",
+      /** `.cleo/nexus-link.json` is in a format this CLEO cannot update (written by a newer CLEO). */
+      "E_NEXUS_LINK_FILE_UNSUPPORTED",
+      // Cloud vault (encrypted snapshots, T12336 / T12337 / T12338).
+      /** Another device holds this stream's write lease (`--force` takes it and labels a fork). */
+      "E_NEXUS_VAULT_LEASE_HELD",
+      /** Another device pushed a newer snapshot than this machine last pushed or restored: pull first. */
+      "E_NEXUS_VAULT_BEHIND",
+      /** Local data changed since the last push or restore; pulling would overwrite it. */
+      "E_NEXUS_VAULT_LOCAL_CHANGES",
+      /** A snapshot's counts or hashes do not match its manifest; nothing was activated. */
+      "E_NEXUS_VAULT_VERIFY_FAILED",
+      /** The account encryption key could not be obtained for this device. */
+      "E_NEXUS_VAULT_KEY_UNAVAILABLE",
+      /** The project is not linked to Cleo Nexus (`cleo project link`). */
+      "E_NEXUS_VAULT_NOT_LINKED",
+      /** The cloud holds no snapshot to restore. */
+      "E_NEXUS_VAULT_EMPTY",
+      /** The server refused the snapshot (lineage or regression check). */
+      "E_NEXUS_VAULT_REFUSED",
+      /**
+       * The stream moved past what this CLEO's vault writes (T13034): it takes only checkpoint/v3
+       * snapshots (the server's `E_STREAM_VERSION`), or it holds data of a newer sync schema.
+       * Pull, restore and verify still work; nothing was written.
+       */
+      "E_NEXUS_VAULT_STREAM_UPGRADED",
+      /** Another CLEO process is writing to the store a restore would replace. */
+      "E_NEXUS_VAULT_STORE_BUSY",
+      /** A project restore target already holds a different project. */
+      "E_NEXUS_VAULT_TARGET_OCCUPIED"
     ];
     nexusAccountUserSchema = z25.object({
       id: z25.string(),
@@ -22782,6 +23138,415 @@ var init_nexus_account = __esm({
   }
 });
 
+// packages/contracts/src/nexus-cloud.ts
+import { z as z26 } from "zod";
+var NEXUS_DEVICE_STATES, NEXUS_CLOUD_PROFILES, NEXUS_DEVICE_LIST_STATES, NEXUS_PAGE_LIMIT_MAX, NEXUS_CLOUD_MAX_PAGES, NEXUS_PRESENCE_FRESH_SECONDS, NEXUS_DEVICE_STATE_UNKNOWN, isoTime, profile, deviceState, nexusCloudCredentialSchema, nexusCloudDeviceSchema, nexusCloudOrganizationSchema, nexusCloudUserSchema, nexusCloudWhoamiSchema, nexusCloudDevicePageSchema, nexusCloudPresenceSchema, nexusCloudReplicaSchema, nexusCloudDeviceCountsSchema, projectFields, nexusCloudProjectListItemSchema, nexusCloudProjectPageSchema, nexusCloudProjectDetailSchema, nexusCloudReplicaPageSchema, NEXUS_STATUS_CHECK_IDS, NEXUS_STATUS_VERDICTS, CLOUD_STATUS_VERDICTS, knownCheckId, nexusCloudStatusCheckSchema, nexusCloudStatusSchema, NEXUS_UNAUTHENTICATED_REASONS, NEXUS_FORBIDDEN_REASONS, NEXUS_REVOKED_REASONS, LOGIN, COMPROMISED, DEVICE_REVOKED, SESSION_EXPIRED_LOGIN, SERVER_REFUSED, NEXUS_REVOKED_REASON_ERRORS, NEXUS_UNAUTHENTICATED_ERRORS, NEXUS_FORBIDDEN_ERRORS, NEXUS_CONFLICT_ERRORS, NEXUS_UNREACHABLE_ERROR;
+var init_nexus_cloud = __esm({
+  "packages/contracts/src/nexus-cloud.ts"() {
+    "use strict";
+    NEXUS_DEVICE_STATES = ["active", "signed-out", "revoked"];
+    NEXUS_CLOUD_PROFILES = ["device", "read-only"];
+    NEXUS_DEVICE_LIST_STATES = ["active", "signed-out", "revoked", "all"];
+    NEXUS_PAGE_LIMIT_MAX = 200;
+    NEXUS_CLOUD_MAX_PAGES = 25;
+    NEXUS_PRESENCE_FRESH_SECONDS = 86400;
+    NEXUS_DEVICE_STATE_UNKNOWN = "unknown";
+    isoTime = z26.iso.datetime({ offset: true });
+    profile = z26.enum(NEXUS_CLOUD_PROFILES).nullable().catch(null);
+    deviceState = z26.enum([...NEXUS_DEVICE_STATES, NEXUS_DEVICE_STATE_UNKNOWN]).catch(NEXUS_DEVICE_STATE_UNKNOWN);
+    nexusCloudCredentialSchema = z26.object({
+      kind: z26.enum(["device", "session"]),
+      credentialId: z26.string().nullable().optional(),
+      profile: profile.optional(),
+      scopes: z26.array(z26.string()).default([]),
+      createdAt: isoTime.nullable().optional(),
+      lastUsedAt: isoTime.nullable().optional(),
+      /** When the credential expires if it is not used again; null for sessions. */
+      idleExpiresAt: isoTime.nullable().optional()
+    });
+    nexusCloudDeviceSchema = z26.object({
+      deviceId: z26.string(),
+      name: z26.string(),
+      platform: z26.string().optional(),
+      arch: z26.string().nullable().optional(),
+      cliVersion: z26.string().nullable().optional(),
+      createdAt: isoTime.optional(),
+      lastSeenAt: isoTime.nullable().optional(),
+      state: deviceState,
+      signedOutAt: isoTime.nullable().optional(),
+      /** Base64 device certificate; null until the device holds a key grant. */
+      certificate: z26.string().nullable().optional(),
+      /** The current credential's profile, or null with none (signed out or revoked). */
+      profile: profile.optional(),
+      /** True for the device whose credential made this request. */
+      current: z26.boolean().default(false),
+      projects: z26.number().int().nonnegative().optional(),
+      replicas: z26.number().int().nonnegative().optional(),
+      lastSyncAt: isoTime.nullable().optional(),
+      lastPresenceAt: isoTime.nullable().optional()
+    });
+    nexusCloudOrganizationSchema = z26.object({
+      id: z26.string(),
+      name: z26.string(),
+      slug: z26.string().nullable().optional(),
+      role: z26.string().optional(),
+      personal: z26.boolean().optional()
+    });
+    nexusCloudUserSchema = z26.object({
+      id: z26.string(),
+      email: z26.string(),
+      name: z26.string().nullable().optional()
+    });
+    nexusCloudWhoamiSchema = z26.object({
+      serverTime: isoTime.optional(),
+      user: nexusCloudUserSchema,
+      organizations: z26.array(nexusCloudOrganizationSchema).default([]),
+      credential: nexusCloudCredentialSchema,
+      /** The calling device; null for a session caller. */
+      device: nexusCloudDeviceSchema.nullable()
+    });
+    nexusCloudDevicePageSchema = z26.object({
+      devices: z26.array(nexusCloudDeviceSchema),
+      nextCursor: z26.string().max(512).nullable().default(null),
+      truncated: z26.boolean().default(false)
+    });
+    nexusCloudPresenceSchema = z26.looseObject({
+      observedAt: isoTime.optional(),
+      sync: z26.object({ enabled: z26.boolean() }).optional()
+    });
+    nexusCloudReplicaSchema = z26.object({
+      projectId: z26.string(),
+      replicaId: z26.string(),
+      deviceId: z26.string(),
+      deviceName: z26.string(),
+      deviceState: deviceState.optional(),
+      attachedAt: isoTime.optional(),
+      lastSyncAt: isoTime.nullable(),
+      presence: nexusCloudPresenceSchema.nullable(),
+      presenceAt: isoTime.nullable()
+    });
+    nexusCloudDeviceCountsSchema = z26.object({
+      active: z26.number().int().nonnegative(),
+      total: z26.number().int().nonnegative()
+    });
+    projectFields = {
+      projectId: z26.string(),
+      label: z26.string().nullable(),
+      organizationId: z26.string(),
+      organizationName: z26.string().optional(),
+      remoteUrl: z26.string().nullable().optional(),
+      createdAt: isoTime.optional()
+    };
+    nexusCloudProjectListItemSchema = z26.object({
+      ...projectFields,
+      role: z26.string(),
+      streamId: z26.string().optional(),
+      headSeq: z26.number().int().nonnegative().nullable().optional(),
+      openConflicts: z26.number().int().nonnegative().optional(),
+      replicas: z26.array(nexusCloudReplicaSchema).default([]),
+      devices: nexusCloudDeviceCountsSchema.optional(),
+      replicaCount: z26.number().int().nonnegative().optional(),
+      lastSyncAt: isoTime.nullable().optional(),
+      lastPresenceAt: isoTime.nullable().optional(),
+      /** This project's replica list was cut at 50 (T12858). */
+      replicasTruncated: z26.boolean().default(false)
+    });
+    nexusCloudProjectPageSchema = z26.object({
+      projects: z26.array(nexusCloudProjectListItemSchema),
+      nextCursor: z26.string().max(512).nullable().default(null),
+      /** Anything in the page was cut (the project list or a replica list). */
+      truncated: z26.boolean().default(false),
+      /** The project list itself was cut at 1000 (T12858). */
+      projectsTruncated: z26.boolean().default(false)
+    });
+    nexusCloudProjectDetailSchema = z26.object({
+      project: z26.object({ ...projectFields, deletedAt: isoTime.nullable().optional() }),
+      role: z26.string(),
+      canTrash: z26.boolean().optional(),
+      openConflicts: z26.number().int().nonnegative(),
+      /** At most 50, oldest attachment first. */
+      replicas: z26.array(nexusCloudReplicaSchema),
+      devices: nexusCloudDeviceCountsSchema,
+      replicaCount: z26.number().int().nonnegative().optional(),
+      lastSyncAt: isoTime.nullable().optional(),
+      /** `replicas` was cut at 50. */
+      truncated: z26.boolean().default(false),
+      stream: z26.object({
+        streamId: z26.string(),
+        headSeq: z26.number().int().nonnegative(),
+        headCheckpointId: z26.string().nullable()
+      }).nullable()
+    });
+    nexusCloudReplicaPageSchema = z26.object({
+      replicas: z26.array(nexusCloudReplicaSchema),
+      devices: nexusCloudDeviceCountsSchema.optional(),
+      nextCursor: z26.string().max(512).nullable().default(null),
+      truncated: z26.boolean().default(false)
+    });
+    NEXUS_STATUS_CHECK_IDS = [
+      "credential.valid",
+      "device.registered",
+      "device.active",
+      "device.certified",
+      "project.registered",
+      "project.writable",
+      "replica.attached",
+      "presence.fresh",
+      "replica.synced",
+      "conflicts.none"
+    ];
+    NEXUS_STATUS_VERDICTS = ["ok", "attention", "not-linked", "not-registered"];
+    CLOUD_STATUS_VERDICTS = [...NEXUS_STATUS_VERDICTS, "not-signed-in"];
+    knownCheckId = z26.enum(NEXUS_STATUS_CHECK_IDS);
+    nexusCloudStatusCheckSchema = z26.object({
+      id: z26.enum(NEXUS_STATUS_CHECK_IDS),
+      ok: z26.boolean(),
+      required: z26.boolean(),
+      detail: z26.string()
+    });
+    nexusCloudStatusSchema = z26.object({
+      serverTime: isoTime.optional(),
+      apiVersion: z26.string().optional(),
+      user: nexusCloudUserSchema,
+      credential: nexusCloudCredentialSchema,
+      device: nexusCloudDeviceSchema.nullable(),
+      project: z26.object({
+        projectId: z26.string(),
+        registered: z26.boolean(),
+        organizationId: z26.string().nullable(),
+        organizationName: z26.string().nullable(),
+        role: z26.string().nullable()
+      }).nullable(),
+      replica: z26.object({
+        replicaId: z26.string(),
+        attached: z26.boolean(),
+        attachedElsewhere: z26.boolean(),
+        attachedAt: isoTime.nullable(),
+        lastSyncAt: isoTime.nullable(),
+        presenceAt: isoTime.nullable(),
+        lastReplicaSeq: z26.number().int().nonnegative().nullable().optional()
+      }).nullable(),
+      stream: z26.object({
+        streamId: z26.string(),
+        headSeq: z26.number().int().nonnegative(),
+        headCheckpointId: z26.string().nullable(),
+        openConflicts: z26.number().int().nonnegative(),
+        devices: nexusCloudDeviceCountsSchema
+      }).nullable(),
+      /** Check ids added by a newer server are dropped, never a parse failure. */
+      checks: z26.array(nexusCloudStatusCheckSchema.extend({ id: z26.string() })).transform(
+        (list) => list.flatMap((c) => {
+          const id = knownCheckId.safeParse(c.id);
+          return id.success ? [{ ...c, id: id.data }] : [];
+        })
+      ),
+      /** A verdict added by a newer server reads as `attention`: never `ok` by accident. */
+      verdict: z26.enum(NEXUS_STATUS_VERDICTS).catch("attention")
+    });
+    NEXUS_UNAUTHENTICATED_REASONS = [
+      "missing",
+      "invalid",
+      "credential-revoked",
+      "credential-expired",
+      "device-signed-out",
+      "device-revoked",
+      "session-bearer-retired",
+      "session-used"
+    ];
+    NEXUS_FORBIDDEN_REASONS = [
+      "insufficient-scope",
+      "session-required",
+      "device-required",
+      "device-mismatch",
+      "not-self",
+      "project-role",
+      "route-undeclared",
+      "bearer-session-required",
+      "session-not-fresh",
+      "device-limit",
+      "device-flow-session-required",
+      "device-not-enrolled"
+    ];
+    NEXUS_REVOKED_REASONS = ["signed-out", "revoked", "rotated", "reenrolled"];
+    LOGIN = "run `cleo login nexus`";
+    COMPROMISED = {
+      code: "E_NEXUS_CREDENTIAL_COMPROMISED",
+      message: "this device's credential was replaced or revoked elsewhere, possibly used from another machine",
+      fix: "revoke this device on cleocode.dev and sign in again with `cleo login nexus`"
+    };
+    DEVICE_REVOKED = {
+      code: "E_NEXUS_DEVICE_REVOKED",
+      message: "this device was revoked",
+      fix: "run `cleo login nexus` to enrol this machine as a new device"
+    };
+    SESSION_EXPIRED_LOGIN = {
+      code: "E_NEXUS_SESSION_EXPIRED",
+      message: "the session is too old for this request",
+      fix: "run `cleo login nexus` (needs a browser: on a headless machine a human must complete the login)"
+    };
+    SERVER_REFUSED = {
+      code: "E_NEXUS_REQUEST_FAILED",
+      message: null,
+      fix: null
+    };
+    NEXUS_REVOKED_REASON_ERRORS = {
+      reenrolled: {
+        code: "E_NEXUS_NOT_SIGNED_IN",
+        message: "this device's credential was replaced by a newer login of the same device",
+        fix: LOGIN
+      },
+      "signed-out": {
+        code: "E_NEXUS_NOT_SIGNED_IN",
+        message: "this device was signed out and later signed in again with another credential",
+        fix: LOGIN
+      },
+      revoked: DEVICE_REVOKED,
+      rotated: COMPROMISED
+    };
+    NEXUS_UNAUTHENTICATED_ERRORS = {
+      missing: {
+        code: "E_NEXUS_NOT_SIGNED_IN",
+        message: "not signed in to Cleo Nexus (the credential is missing or invalid)",
+        fix: LOGIN
+      },
+      invalid: {
+        code: "E_NEXUS_NOT_SIGNED_IN",
+        message: "not signed in to Cleo Nexus (the credential is missing or invalid)",
+        fix: LOGIN
+      },
+      // Resolved by `details.revokedReason` through NEXUS_REVOKED_REASON_ERRORS.
+      "credential-revoked": COMPROMISED,
+      "credential-expired": {
+        code: "E_NEXUS_SESSION_EXPIRED",
+        message: "the device credential expired after 90 days without use",
+        fix: LOGIN
+      },
+      "device-signed-out": {
+        code: "E_NEXUS_DEVICE_SIGNED_OUT",
+        message: "this device was signed out",
+        fix: LOGIN
+      },
+      "device-revoked": DEVICE_REVOKED,
+      "session-bearer-retired": {
+        code: "E_NEXUS_SESSION_EXPIRED",
+        message: "bearer sessions are no longer accepted",
+        fix: "run `cleo login nexus` with the current CLI"
+      },
+      "session-used": {
+        code: "E_NEXUS_SESSION_EXPIRED",
+        message: "the 9.24 session was already used by another enrolment",
+        fix: LOGIN
+      }
+    };
+    NEXUS_FORBIDDEN_ERRORS = {
+      "insufficient-scope": {
+        code: "E_NEXUS_INSUFFICIENT_SCOPE",
+        message: "this device's credential lacks the scope for that request",
+        fix: "run `cleo login nexus` without --read-only to enrol with the full device profile"
+      },
+      "session-required": SERVER_REFUSED,
+      "device-required": SERVER_REFUSED,
+      "device-mismatch": SERVER_REFUSED,
+      "not-self": SERVER_REFUSED,
+      "project-role": SERVER_REFUSED,
+      "route-undeclared": SERVER_REFUSED,
+      "bearer-session-required": SESSION_EXPIRED_LOGIN,
+      "session-not-fresh": SESSION_EXPIRED_LOGIN,
+      "device-limit": {
+        code: "E_NEXUS_REQUEST_FAILED",
+        message: "the account has reached its device limit",
+        fix: "revoke unused devices on cleocode.dev, then retry"
+      },
+      "device-flow-session-required": {
+        code: "E_NEXUS_SESSION_EXPIRED",
+        message: "this session was not issued to the CLI by `cleo login nexus`, so it cannot enrol a device",
+        fix: SESSION_EXPIRED_LOGIN.fix
+      },
+      "device-not-enrolled": {
+        code: "E_NEXUS_NOT_SIGNED_IN",
+        message: "this device is not enrolled with Cleo Nexus",
+        fix: LOGIN
+      }
+    };
+    NEXUS_CONFLICT_ERRORS = {
+      "replica-copied": {
+        code: "E_NEXUS_REPLICA_COPIED",
+        message: "this project store is attached from another device (a copied store)",
+        fix: null
+      },
+      "rotation-conflict": COMPROMISED
+    };
+    NEXUS_UNREACHABLE_ERROR = {
+      code: "E_NEXUS_UNREACHABLE",
+      message: null,
+      fix: "check your network and retry"
+    };
+  }
+});
+
+// packages/contracts/src/nexus-vault.ts
+import { z as z27 } from "zod";
+var isoTime2, uuid, nexusUserKeysSchema, nexusProjectKeysSchema, NEXUS_VAULT_LEASE_ROLE, nexusLeaseSchema, nexusLeaseAcquireSchema, nexusStreamHeadSchema, nexusActivityEventSchema, nexusActivityPageSchema;
+var init_nexus_vault = __esm({
+  "packages/contracts/src/nexus-vault.ts"() {
+    "use strict";
+    isoTime2 = z27.iso.datetime({ offset: true });
+    uuid = z27.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+    nexusUserKeysSchema = z27.looseObject({
+      keyVersion: z27.number().int().positive(),
+      masterKeyVerifier: z27.string()
+    });
+    nexusProjectKeysSchema = z27.looseObject({
+      keys: z27.array(
+        z27.looseObject({ wrappedProjectKey: z27.string(), keyVersion: z27.number().int().positive() })
+      )
+    });
+    NEXUS_VAULT_LEASE_ROLE = "writer";
+    nexusLeaseSchema = z27.looseObject({
+      streamId: z27.string(),
+      role: z27.string(),
+      replicaId: uuid,
+      expiresAt: isoTime2,
+      forkedFromReplicaId: uuid.nullable().optional()
+    });
+    nexusLeaseAcquireSchema = z27.looseObject({ lease: nexusLeaseSchema });
+    nexusStreamHeadSchema = z27.looseObject({
+      streamId: z27.string(),
+      kind: z27.string().optional(),
+      headSeq: z27.number().int().nonnegative(),
+      headCheckpointId: z27.string().nullable(),
+      /**
+       * The highest segment `schemaVersion` the stream holds (the server raises it on every append).
+       * Absent from an older server.
+       */
+      maxSchemaVersion: z27.number().int().nonnegative().optional()
+    });
+    nexusActivityEventSchema = z27.looseObject({
+      id: z27.union([z27.string(), z27.number()]),
+      at: isoTime2,
+      actorUserId: z27.string().nullable().optional(),
+      actorDeviceId: z27.string().nullable().optional(),
+      requestId: z27.string().nullable().optional(),
+      action: z27.string(),
+      target: z27.string().nullable().optional(),
+      detail: z27.unknown().optional()
+    });
+    nexusActivityPageSchema = z27.looseObject({
+      events: z27.array(nexusActivityEventSchema),
+      nextBefore: z27.union([z27.string(), z27.number()]).nullable().optional()
+    });
+  }
+});
+
+// packages/contracts/src/sync-schema.ts
+var SYNC_SCHEMA_VERSION;
+var init_sync_schema = __esm({
+  "packages/contracts/src/sync-schema.ts"() {
+    "use strict";
+    SYNC_SCHEMA_VERSION = 2;
+  }
+});
+
 // packages/contracts/src/task-id.ts
 function isTaskId(value) {
   return typeof value === "string" && TASK_ID_REGEX.test(value);
@@ -22849,6 +23614,7 @@ __export(src_exports, {
   CHANNEL_BOUNDARY_REGISTRY: () => CHANNEL_BOUNDARY_REGISTRY,
   CLEO_CONFIG_MANIFEST: () => CLEO_CONFIG_MANIFEST,
   CLI_CATEGORY_ORDER: () => CLI_CATEGORY_ORDER,
+  CLOUD_STATUS_VERDICTS: () => CLOUD_STATUS_VERDICTS,
   COLLECTION_IDENTITY_FIELDS: () => COLLECTION_IDENTITY_FIELDS,
   COLLECTION_KEYS: () => COLLECTION_KEYS,
   CONFIG_MANIFEST_ENTRIES: () => CONFIG_MANIFEST_ENTRIES,
@@ -22963,10 +23729,28 @@ __export(src_exports, {
   MonitorResponseSchema: () => MonitorResponseSchema,
   NEXUS_ACCOUNT_ERROR_CODES: () => NEXUS_ACCOUNT_ERROR_CODES,
   NEXUS_CLI_CLIENT_ID: () => NEXUS_CLI_CLIENT_ID,
+  NEXUS_CLOUD_MAX_PAGES: () => NEXUS_CLOUD_MAX_PAGES,
+  NEXUS_CLOUD_PROFILES: () => NEXUS_CLOUD_PROFILES,
+  NEXUS_CONFLICT_ERRORS: () => NEXUS_CONFLICT_ERRORS,
   NEXUS_DEFAULT_API_URL: () => NEXUS_DEFAULT_API_URL,
+  NEXUS_DEVICE_LIST_STATES: () => NEXUS_DEVICE_LIST_STATES,
+  NEXUS_DEVICE_STATES: () => NEXUS_DEVICE_STATES,
+  NEXUS_DEVICE_STATE_UNKNOWN: () => NEXUS_DEVICE_STATE_UNKNOWN,
   NEXUS_FLEET_SCHEMA_VERSION: () => NEXUS_FLEET_SCHEMA_VERSION,
+  NEXUS_FORBIDDEN_ERRORS: () => NEXUS_FORBIDDEN_ERRORS,
+  NEXUS_FORBIDDEN_REASONS: () => NEXUS_FORBIDDEN_REASONS,
   NEXUS_LOGIN_TARGET: () => NEXUS_LOGIN_TARGET,
+  NEXUS_PAGE_LIMIT_MAX: () => NEXUS_PAGE_LIMIT_MAX,
+  NEXUS_PRESENCE_FRESH_SECONDS: () => NEXUS_PRESENCE_FRESH_SECONDS,
+  NEXUS_REVOKED_REASONS: () => NEXUS_REVOKED_REASONS,
+  NEXUS_REVOKED_REASON_ERRORS: () => NEXUS_REVOKED_REASON_ERRORS,
   NEXUS_SCOPE_MAP: () => NEXUS_SCOPE_MAP,
+  NEXUS_STATUS_CHECK_IDS: () => NEXUS_STATUS_CHECK_IDS,
+  NEXUS_STATUS_VERDICTS: () => NEXUS_STATUS_VERDICTS,
+  NEXUS_UNAUTHENTICATED_ERRORS: () => NEXUS_UNAUTHENTICATED_ERRORS,
+  NEXUS_UNAUTHENTICATED_REASONS: () => NEXUS_UNAUTHENTICATED_REASONS,
+  NEXUS_UNREACHABLE_ERROR: () => NEXUS_UNREACHABLE_ERROR,
+  NEXUS_VAULT_LEASE_ROLE: () => NEXUS_VAULT_LEASE_ROLE,
   OPEN_SYSTEM_KEY_PREFIXES: () => OPEN_SYSTEM_KEY_PREFIXES,
   OPERATIONS: () => OPERATIONS,
   OPERATION_RESULT_SCHEMAS: () => OPERATION_RESULT_SCHEMAS,
@@ -23012,6 +23796,8 @@ __export(src_exports, {
   RESOURCE_CLASSES: () => RESOURCE_CLASSES,
   RESOURCE_DEFERRED_CODE: () => RESOURCE_DEFERRED_CODE,
   ROLE_SYSTEM_IDS: () => ROLE_SYSTEM_IDS,
+  RUN_COMMAND_FAILED_CODE: () => RUN_COMMAND_FAILED_CODE,
+  RUN_DEFERRED_EXIT_CODE: () => RUN_DEFERRED_EXIT_CODE,
   RateCheckRequestSchema: () => RateCheckRequestSchema,
   RateResultResponseSchema: () => RateResultResponseSchema,
   ReleaseChannelSchema: () => ReleaseChannelSchema,
@@ -23047,6 +23833,8 @@ __export(src_exports, {
   SUPERVISOR_IPC_PROTOCOL_VERSION: () => SUPERVISOR_IPC_PROTOCOL_VERSION,
   SUPERVISOR_IPC_REQUEST_KINDS: () => SUPERVISOR_IPC_REQUEST_KINDS,
   SUPERVISOR_IPC_RESPONSE_KINDS: () => SUPERVISOR_IPC_RESPONSE_KINDS,
+  SYNC_SCHEMA_VERSION: () => SYNC_SCHEMA_VERSION,
+  SYNC_WRITE_INVARIANTS: () => SYNC_WRITE_INVARIANTS,
   SYSTEM_ROLE_MAP: () => SYSTEM_ROLE_MAP,
   SessionView: () => SessionView,
   SpawnRequestSchema: () => SpawnRequestSchema,
@@ -23246,6 +24034,28 @@ __export(src_exports, {
   nexusAccountMeSchema: () => nexusAccountMeSchema,
   nexusAccountOrganizationSchema: () => nexusAccountOrganizationSchema,
   nexusAccountUserSchema: () => nexusAccountUserSchema,
+  nexusActivityEventSchema: () => nexusActivityEventSchema,
+  nexusActivityPageSchema: () => nexusActivityPageSchema,
+  nexusCloudCredentialSchema: () => nexusCloudCredentialSchema,
+  nexusCloudDeviceCountsSchema: () => nexusCloudDeviceCountsSchema,
+  nexusCloudDevicePageSchema: () => nexusCloudDevicePageSchema,
+  nexusCloudDeviceSchema: () => nexusCloudDeviceSchema,
+  nexusCloudOrganizationSchema: () => nexusCloudOrganizationSchema,
+  nexusCloudPresenceSchema: () => nexusCloudPresenceSchema,
+  nexusCloudProjectDetailSchema: () => nexusCloudProjectDetailSchema,
+  nexusCloudProjectListItemSchema: () => nexusCloudProjectListItemSchema,
+  nexusCloudProjectPageSchema: () => nexusCloudProjectPageSchema,
+  nexusCloudReplicaPageSchema: () => nexusCloudReplicaPageSchema,
+  nexusCloudReplicaSchema: () => nexusCloudReplicaSchema,
+  nexusCloudStatusCheckSchema: () => nexusCloudStatusCheckSchema,
+  nexusCloudStatusSchema: () => nexusCloudStatusSchema,
+  nexusCloudUserSchema: () => nexusCloudUserSchema,
+  nexusCloudWhoamiSchema: () => nexusCloudWhoamiSchema,
+  nexusLeaseAcquireSchema: () => nexusLeaseAcquireSchema,
+  nexusLeaseSchema: () => nexusLeaseSchema,
+  nexusProjectKeysSchema: () => nexusProjectKeysSchema,
+  nexusStreamHeadSchema: () => nexusStreamHeadSchema,
+  nexusUserKeysSchema: () => nexusUserKeysSchema,
   normalizeError: () => normalizeError,
   noteAtomSchema: () => noteAtomSchema,
   noulDecisionAnswerSchema: () => noulDecisionAnswerSchema,
@@ -23426,6 +24236,9 @@ var init_src2 = __esm({
     init_decide();
     init_decide_sites();
     init_nexus_account();
+    init_nexus_cloud();
+    init_nexus_vault();
+    init_sync_schema();
     init_task_id();
   }
 });
@@ -24281,7 +25094,7 @@ function humanProgress(text) {
 function isHumanOutput() {
   return humanEnabled();
 }
-function cliError(message, code, details, meta) {
+function cliError(message, code, details, meta, options) {
   const ctx = getFormatContext();
   const outputMode = getOutputMode();
   if (outputMode === "silent") {
@@ -24323,6 +25136,11 @@ function cliError(message, code, details, meta) {
     error: errorObj,
     meta: errorMeta
   };
+  if (options?.stderr === true) {
+    process.stderr.write(`${JSON.stringify(envelope)}
+`);
+    return;
+  }
   process.stdout.write(JSON.stringify(envelope) + "\n");
 }
 var renderers;
@@ -36353,7 +37171,7 @@ function parseAgenticNode(raw, base, index) {
     inputs = acc;
   }
   const context_files = parseStringArray(raw.context_files, `nodes[${index}].context_files`);
-  const profile = parseOptionalNonEmptyString(raw.profile, `nodes[${index}].profile`);
+  const profile2 = parseOptionalNonEmptyString(raw.profile, `nodes[${index}].profile`);
   const model = parseOptionalNonEmptyString(raw.model, `nodes[${index}].model`);
   const provider = parseOptionalNonEmptyString(raw.provider, `nodes[${index}].provider`);
   const allowed_skills = parseStringArray(raw.allowed_skills, `nodes[${index}].allowed_skills`);
@@ -36366,7 +37184,7 @@ function parseAgenticNode(raw, base, index) {
     role,
     inputs,
     ...context_files !== void 0 ? { context_files } : {},
-    ...profile !== void 0 ? { profile } : {},
+    ...profile2 !== void 0 ? { profile: profile2 } : {},
     ...model !== void 0 ? { model } : {},
     ...provider !== void 0 ? { provider } : {},
     ...allowed_skills !== void 0 ? { allowed_skills } : {},
@@ -36915,21 +37733,21 @@ var init_migrate_e4 = __esm({
 
 // packages/playbooks/src/policy.ts
 function evaluatePolicy(command, rules = DEFAULT_POLICY_RULES) {
-  for (const rule of rules) {
-    if (rule.action === "require-human" && rule.pattern.test(command)) {
+  for (const rule2 of rules) {
+    if (rule2.action === "require-human" && rule2.pattern.test(command)) {
       return {
         action: "require-human",
-        reason: rule.reason,
-        matchedPattern: rule.pattern.source
+        reason: rule2.reason,
+        matchedPattern: rule2.pattern.source
       };
     }
   }
-  for (const rule of rules) {
-    if (rule.action === "auto-approve" && rule.pattern.test(command)) {
+  for (const rule2 of rules) {
+    if (rule2.action === "auto-approve" && rule2.pattern.test(command)) {
       return {
         action: "auto-approve",
-        reason: rule.reason,
-        matchedPattern: rule.pattern.source
+        reason: rule2.reason,
+        matchedPattern: rule2.pattern.source
       };
     }
   }
@@ -37504,9 +38322,9 @@ function auditContractViolation(projectRoot, runId, nodeId, field, key, playbook
   } catch {
   }
 }
-function handleContractErrorHandler(playbook, trigger, _message) {
+function handleContractErrorHandler(playbook, trigger2, _message) {
   if (!playbook.error_handlers) return null;
-  const handler = playbook.error_handlers.find((h) => h.on === trigger);
+  const handler = playbook.error_handlers.find((h) => h.on === trigger2);
   return handler?.action ?? null;
 }
 function iterationCapFor(node, runtimeDefault) {
@@ -38029,8 +38847,8 @@ async function loadPlaybookByName(name) {
     return null;
   }
   try {
-    const { getProjectRoot: getProjectRoot75 } = await import("@cleocode/core/internal");
-    const projectRoot = __playbookRuntimeOverrides.projectRoot ?? getProjectRoot75();
+    const { getProjectRoot: getProjectRoot76 } = await import("@cleocode/core/internal");
+    const projectRoot = __playbookRuntimeOverrides.projectRoot ?? getProjectRoot76();
     const resolved = resolvePlaybook(name, {
       projectRoot,
       globalPlaybooksDir: __playbookRuntimeOverrides.globalPlaybooksDir,
@@ -38075,7 +38893,7 @@ async function buildDefaultDispatcher() {
   if (__playbookRuntimeOverrides.dispatcher) return __playbookRuntimeOverrides.dispatcher;
   const { orchestrateSpawnExecute: orchestrateSpawnExecute2 } = await import("@cleocode/runtime/gateway");
   const {
-    getProjectRoot: getProjectRoot75,
+    getProjectRoot: getProjectRoot76,
     createToolGuard,
     runSkillNodeOrSpawn,
     maybeCreatePiRunner,
@@ -38083,7 +38901,7 @@ async function buildDefaultDispatcher() {
     hasCantbookProfilePin,
     DEFAULT_DETERMINISTIC_DENIED_COMMANDS
   } = await import("@cleocode/core/internal");
-  const projectRoot = getProjectRoot75();
+  const projectRoot = getProjectRoot76();
   const tools = createToolGuard({
     allowedRoots: [projectRoot],
     deniedCommands: DEFAULT_DETERMINISTIC_DENIED_COMMANDS,
@@ -38176,12 +38994,12 @@ async function buildDefaultDeterministicRunner() {
     return void 0;
   }
   const {
-    getProjectRoot: getProjectRoot75,
+    getProjectRoot: getProjectRoot76,
     createToolGuard,
     createGuardedDeterministicRunner,
     DEFAULT_DETERMINISTIC_DENIED_COMMANDS
   } = await import("@cleocode/core/internal");
-  const projectRoot = getProjectRoot75();
+  const projectRoot = getProjectRoot76();
   const tools = createToolGuard({
     allowedRoots: [projectRoot],
     deniedCommands: DEFAULT_DETERMINISTIC_DENIED_COMMANDS,
@@ -38339,8 +39157,8 @@ var init_playbook2 = __esm({
             projectRoot = __playbookRuntimeOverrides.projectRoot;
           } else {
             try {
-              const { getProjectRoot: getProjectRoot75 } = await import("@cleocode/core/internal");
-              projectRoot = getProjectRoot75();
+              const { getProjectRoot: getProjectRoot76 } = await import("@cleocode/core/internal");
+              projectRoot = getProjectRoot76();
             } catch {
               projectRoot = void 0;
             }
@@ -38405,14 +39223,14 @@ var init_playbook2 = __esm({
         const deterministicRunner = await buildDefaultDeterministicRunner();
         let result;
         try {
-          const { getProjectRoot: getProjectRoot75 } = await import("@cleocode/core/internal");
+          const { getProjectRoot: getProjectRoot76 } = await import("@cleocode/core/internal");
           const opts = {
             db,
             playbook: parsed.definition,
             playbookHash: parsed.sourceHash,
             initialContext,
             dispatcher,
-            projectRoot: getProjectRoot75()
+            projectRoot: getProjectRoot76()
           };
           if (deterministicRunner !== void 0) opts.deterministicRunner = deterministicRunner;
           if (__playbookRuntimeOverrides.approvalSecret !== void 0) {
@@ -38871,16 +39689,16 @@ async function orchestrateClassify(request, context, projectRoot, taskId) {
   }
   try {
     const { getCleoCantWorkflowsDir } = await import("@cleocode/core/internal");
-    const { readFileSync: readFileSync22, readdirSync: readdirSync3, existsSync: existsSync22 } = await import("node:fs");
-    const { join: join40 } = await import("node:path");
+    const { readFileSync: readFileSync23, readdirSync: readdirSync4, existsSync: existsSync22 } = await import("node:fs");
+    const { join: join41 } = await import("node:path");
     const workflowsDir = getCleoCantWorkflowsDir();
     const combined = `${request} ${context ?? ""}`.toLowerCase();
     const matches = [];
     if (existsSync22(workflowsDir)) {
-      const files = readdirSync3(workflowsDir).filter((f) => f.endsWith(".cant"));
+      const files = readdirSync4(workflowsDir).filter((f) => f.endsWith(".cant"));
       for (const file of files) {
         try {
-          const src = readFileSync22(join40(workflowsDir, file), "utf-8");
+          const src = readFileSync23(join41(workflowsDir, file), "utf-8");
           const teamMatch = /^team\s+(\S+):/m.exec(src);
           if (!teamMatch) continue;
           const teamName = teamMatch[1];
@@ -38895,12 +39713,12 @@ async function orchestrateClassify(request, context, projectRoot, taskId) {
         }
       }
     }
-    const localCantDir = join40(projectRoot, CLEO_DIR_NAME2, WORKFLOWS_SUBDIR);
+    const localCantDir = join41(projectRoot, CLEO_DIR_NAME2, WORKFLOWS_SUBDIR);
     if (existsSync22(localCantDir)) {
-      const files = readdirSync3(localCantDir).filter((f) => f.endsWith(".cant"));
+      const files = readdirSync4(localCantDir).filter((f) => f.endsWith(".cant"));
       for (const file of files) {
         try {
-          const src = readFileSync22(join40(localCantDir, file), "utf-8");
+          const src = readFileSync23(join41(localCantDir, file), "utf-8");
           const teamMatch = /^team\s+(\S+):/m.exec(src);
           if (!teamMatch) continue;
           const teamName = teamMatch[1];
@@ -45751,11 +46569,11 @@ var init_security = __esm({
 });
 
 // packages/cleo/src/dispatch/middleware/sanitizer.ts
-function createSanitizer(getProjectRoot75) {
+function createSanitizer(getProjectRoot76) {
   return async (req, next) => {
     if (req.params) {
       try {
-        const root = getProjectRoot75 ? getProjectRoot75() : void 0;
+        const root = getProjectRoot76 ? getProjectRoot76() : void 0;
         req.params = sanitizeParams(req.params, root, {
           domain: req.domain,
           operation: req.operation
@@ -45857,14 +46675,14 @@ var init_session_resolver = __esm({
 });
 
 // packages/cleo/src/dispatch/middleware/store-write-guard.ts
-function createStoreWriteGuard(getProjectRoot75) {
+function createStoreWriteGuard(getProjectRoot76) {
   return async (req, next) => {
     if (req.gateway !== "mutate" || ALLOWED_WHILE_READ_ONLY.has(`${req.domain}.${req.operation}`)) {
       return next();
     }
     let projectRoot;
     try {
-      projectRoot = getProjectRoot75();
+      projectRoot = getProjectRoot76();
     } catch {
       return next();
     }
@@ -47610,8 +48428,8 @@ var init_agent_outputs = __esm({
 });
 
 // packages/cleo/src/cli/commands/agent-profile-status.ts
-function computeProfileStatus(profile, validation) {
-  if (profile === null) return "none";
+function computeProfileStatus(profile2, validation) {
+  if (profile2 === null) return "none";
   if (validation === null) return "loaded (unvalidated)";
   if (validation.valid) return "validated";
   return `invalid (${validation.errors.length} errors)`;
@@ -47714,9 +48532,9 @@ var init_agent = __esm({
             isActive: true
           });
           const { existsSync: existsSync22, mkdirSync: mkdirSync7, writeFileSync: writeFileSync8 } = await import("node:fs");
-          const { join: join40 } = await import("node:path");
-          const cantDir = join40(CLEO_DIR_NAME3, AGENTS_SUBDIR);
-          const cantPath = join40(cantDir, `${agentId}.cant`);
+          const { join: join41 } = await import("node:path");
+          const cantDir = join41(CLEO_DIR_NAME3, AGENTS_SUBDIR);
+          const cantPath = join41(cantDir, `${agentId}.cant`);
           let cantScaffolded = false;
           if (!existsSync22(cantPath)) {
             mkdirSync7(cantDir, { recursive: true });
@@ -47897,8 +48715,8 @@ agent ${agentId}:
         try {
           const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
           const { createRuntime } = await import("@cleocode/runtime");
-          const { existsSync: existsSync22, readFileSync: readFileSync22 } = await import("node:fs");
-          const { join: join40 } = await import("node:path");
+          const { existsSync: existsSync22, readFileSync: readFileSync23 } = await import("node:fs");
+          const { join: join41 } = await import("node:path");
           await openCleoDb("project");
           const registry = new AgentRegistryAccessor(getProjectRoot25());
           const credential = await registry.get(args.agentId);
@@ -47916,16 +48734,16 @@ agent ${agentId}:
             process.exitCode = 1;
             return;
           }
-          let profile = null;
+          let profile2 = null;
           let cantValidation = null;
-          const cantPath = args.cant ?? join40(CLEO_DIR_NAME3, AGENTS_SUBDIR, `${args.agentId}.cant`);
+          const cantPath = args.cant ?? join41(CLEO_DIR_NAME3, AGENTS_SUBDIR, `${args.agentId}.cant`);
           if (existsSync22(cantPath)) {
-            profile = readFileSync22(cantPath, "utf-8");
+            profile2 = readFileSync23(cantPath, "utf-8");
             try {
               const cantModule = await import("@cleocode/cant");
               const validate = "validate" in cantModule ? cantModule.validate : null;
               if (validate) {
-                const result = validate(profile);
+                const result = validate(profile2);
                 cantValidation = {
                   valid: result.valid,
                   errors: result.diagnostics?.map((d) => d.message) ?? []
@@ -47968,7 +48786,7 @@ agent ${agentId}:
                 transport: runtime.transport.name,
                 // Surfaced for operator visibility only — see
                 // computeProfileStatus tsdoc for the four possible values.
-                profile: computeProfileStatus(profile, cantValidation),
+                profile: computeProfileStatus(profile2, cantValidation),
                 services: {
                   poller: "running",
                   heartbeat: runtime.heartbeat ? "running" : "disabled",
@@ -48444,7 +49262,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
           const { createRuntime } = await import("@cleocode/runtime");
           const { existsSync: existsSync22 } = await import("node:fs");
-          const { join: join40 } = await import("node:path");
+          const { join: join41 } = await import("node:path");
           await openCleoDb("project");
           const registry = new AgentRegistryAccessor(getProjectRoot25());
           const credential = await registry.get(args.agentId);
@@ -48461,7 +49279,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           }
           await registry.update(args.agentId, { isActive: true });
           await registry.markUsed(args.agentId);
-          const cantPath = join40(CLEO_DIR_NAME3, AGENTS_SUBDIR, `${args.agentId}.cant`);
+          const cantPath = join41(CLEO_DIR_NAME3, AGENTS_SUBDIR, `${args.agentId}.cant`);
           const hasProfile = existsSync22(cantPath);
           const runtime = await createRuntime(registry, {
             agentId: args.agentId,
@@ -49412,8 +50230,8 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
             process.exitCode = 4;
             return;
           }
-          const { join: join40 } = await import("node:path");
-          const personaPath = join40(resolvedDir, "persona.cant");
+          const { join: join41 } = await import("node:path");
+          const personaPath = join41(resolvedDir, "persona.cant");
           if (!existsSync22(personaPath)) {
             cliOutput(
               {
@@ -49453,15 +50271,15 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
             return;
           }
           const archiveStats = statSync3(archivePath);
-          const { readdirSync: readdirSync3 } = await import("node:fs");
+          const { readdirSync: readdirSync4 } = await import("node:fs");
           let fileCount = 0;
           const countFiles = (dirPath) => {
-            const entries = readdirSync3(dirPath, { withFileTypes: true });
+            const entries = readdirSync4(dirPath, { withFileTypes: true });
             for (const entry of entries) {
               if (entry.isFile()) {
                 fileCount++;
               } else if (entry.isDirectory()) {
-                countFiles(join40(dirPath, entry.name));
+                countFiles(join41(dirPath, entry.name));
               }
             }
           };
@@ -49709,17 +50527,17 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
       },
       async run({ args }) {
         try {
-          const { existsSync: existsSync22, readFileSync: readFileSync22, mkdirSync: mkdirSync7 } = await import("node:fs");
-          const { resolve: resolve13, join: join40 } = await import("node:path");
+          const { existsSync: existsSync22, readFileSync: readFileSync23, mkdirSync: mkdirSync7 } = await import("node:fs");
+          const { resolve: resolve13, join: join41 } = await import("node:path");
           const specPath = resolve13(args.spec);
           if (!existsSync22(specPath)) {
             cliError(`spec file not found: ${specPath}`, 4, { name: "E_NOT_FOUND" });
             process.exitCode = 4;
             return;
           }
-          const specContent = readFileSync22(specPath, "utf-8");
+          const specContent = readFileSync23(specPath, "utf-8");
           const projectRoot = getProjectRoot25();
-          const outputDir = args["output-dir"] ? resolve13(args["output-dir"]) : join40(projectRoot, ".cleo", "cant", "agents");
+          const outputDir = args["output-dir"] ? resolve13(args["output-dir"]) : join41(projectRoot, ".cleo", "cant", "agents");
           mkdirSync7(outputDir, { recursive: true });
           if (args["dry-run"]) {
             cliOutput(
@@ -50647,15 +51465,24 @@ function nexusApiUrlArg(args) {
 function failNexus(err, operation) {
   const code = err instanceof Error && "code" in err && typeof err.code === "string" ? err.code : void 0;
   const fix = err instanceof Error && "fix" in err && typeof err.fix === "string" ? err.fix : void 0;
-  const exitCode = code === "E_NEXUS_INVALID_API_URL" || code === "E_NEXUS_INVALID_LABEL" || code === "E_NEXUS_DEVICE_REQUIRED" ? 6 : 1;
+  const exitCode = code === "E_NEXUS_INVALID_API_URL" || code === "E_NEXUS_INVALID_LABEL" || code === "E_NEXUS_DEVICE_REQUIRED" || code === "E_VALIDATION" ? 6 : VAULT_REFUSAL_EXIT_CODES[code ?? ""] ?? 1;
+  const details = err instanceof Error && "publicDetails" in err && typeof err.publicDetails === "object" && err.publicDetails ? err.publicDetails : void 0;
   cliError(
     err instanceof Error ? err.message : String(err),
     exitCode,
-    { name: code ?? "E_NEXUS_REQUEST_FAILED", ...fix ? { fix } : {} },
+    {
+      name: code ?? "E_NEXUS_REQUEST_FAILED",
+      ...fix ? { fix } : {},
+      ...details ? { details } : {}
+    },
     { operation }
   );
   process.exit(exitCode);
 }
+function writeNexusWarnings(warnings) {
+  for (const warning of warnings) process.stderr.write(`warning: ${warning}
+`);
+}
 function emitNexusResult(data, summary, command, operation) {
   if (isHumanOutput()) humanLine(summary);
   else cliOutput(data, { command, operation });
@@ -50670,9 +51497,11 @@ async function runNexusLogin(args, openBrowser2) {
     "@cleocode/core/cloud/nexus-device.js"
   );
   const noBrowser = negatedFlag(args, "browser");
+  let codeShown = false;
   const hooks2 = {
     apiUrl: nexusApiUrlArg(args),
     onCode: (code) => {
+      codeShown = true;
       writeDeviceCodePrompt(code, SERVICE_NAME);
       if (!noBrowser) openBrowser2(code.verificationUriComplete ?? code.verificationUri);
     },
@@ -50687,7 +51516,7 @@ async function runNexusLogin(args, openBrowser2) {
       ),
       {
         code: "E_NEXUS_DEVICE_REQUIRED",
-        fix: "set CLEO_NEXUS_DEVICE=1 to enrol a read-only device, or log in without --read-only"
+        fix: "unset CLEO_NEXUS_DEVICE (=0 turns device credentials off) to enrol a read-only device, or log in without --read-only"
       }
     );
   }
@@ -50703,15 +51532,43 @@ async function runNexusLogin(args, openBrowser2) {
         readOnly,
         ...name !== void 0 ? { name } : {}
       });
+      if (!readOnly) {
+        const { attachNexusGlobalStore } = await import(
+          /* webpackIgnore: true */
+          "@cleocode/core/cloud/nexus-home.js"
+        );
+        try {
+          const global = await attachNexusGlobalStore({ apiUrl: hooks2.apiUrl });
+          result = { ...result, warnings: [...result.warnings, ...global.warnings] };
+        } catch (err) {
+          result = {
+            ...result,
+            warnings: [
+              ...result.warnings,
+              `signed in, but attaching this device's global store failed (${err instanceof Error ? err.message : String(err)}); run \`cleo login nexus\` again`
+            ]
+          };
+        }
+      }
     } else {
       if (name !== void 0) {
         process.stderr.write(
-          "warning: --name needs device credentials (CLEO_NEXUS_DEVICE=1); ignored\n"
+          "warning: --name needs device credentials, which CLEO_NEXUS_DEVICE=0 turns off; ignored\n"
+        );
+      }
+      const { NEXUS_TEST_BEARER_ENV, W_NEXUS_TEST_BEARER_IGNORED } = await import(
+        /* webpackIgnore: true */
+        "@cleocode/core/cloud/nexus-enrol.js"
+      );
+      if ((process.env[NEXUS_TEST_BEARER_ENV]?.trim() ?? "") !== "") {
+        process.stderr.write(
+          `warning: ${W_NEXUS_TEST_BEARER_IGNORED}: ${NEXUS_TEST_BEARER_ENV} needs device credentials, which CLEO_NEXUS_DEVICE turns off; ignored
+`
         );
       }
       result = await loginToNexus(hooks2);
     }
-    writeDeviceCodeApproved(SERVICE_NAME);
+    if (codeShown) writeDeviceCodeApproved(SERVICE_NAME);
     for (const warning of result.warnings) process.stderr.write(`warning: ${warning}
 `);
     return result;
@@ -50721,15 +51578,51 @@ async function runNexusLogin(args, openBrowser2) {
   }
 }
 function nexusLoginSummary(r) {
-  const who = r.user?.email ?? "your account";
+  const who2 = r.user?.email ?? "your account";
   const org = r.organization ? ` (${r.organization.name})` : "";
   const device = r.device ? ` This machine is device ${r.device.deviceId}${r.device.name ? ` (${r.device.name})` : ""}, profile ${r.device.profile ?? "unknown"}.` : "";
-  return `Signed in to ${r.apiUrl} as ${who}${org}.${device}`;
+  return `Signed in to ${r.apiUrl} as ${who2}${org}.${device}`;
+}
+function nexusDeviceLogoutSummary(r) {
+  const count = (o) => r.devices.filter((d) => d.outcome === o).length;
+  const confirmed = count("confirmed");
+  const open2 = r.devices.length - confirmed;
+  const what = r.action === "revoke" ? "Revoke" : "Sign-out";
+  if (r.devices.length === 0 && r.session === null) {
+    return r.warnings.length > 0 ? `${what} on ${r.apiUrl}: nothing was sent (see warnings).` : `Not signed in to ${r.apiUrl}; nothing to do.`;
+  }
+  const parts = [];
+  if (r.devices.length > 0)
+    parts.push(`${confirmed} of ${r.devices.length} device request(s) confirmed`);
+  if (open2 > 0) parts.push(`${open2} NOT confirmed (see warnings)`);
+  if (r.session !== null) parts.push(`9.24 session ${r.session.revocation}`);
+  const notConfirmed = open2 > 0 || r.devices.length > 0 && confirmed === 0 || r.session?.revocation === "failed";
+  const lead = notConfirmed ? `${what} NOT fully confirmed on` : `${what} confirmed on`;
+  return `${lead} ${r.apiUrl}: ${parts.join("; ")}.`;
+}
+async function runNexusDeviceLogout(args) {
+  let result;
+  try {
+    const { logoutNexusDevice } = await import(
+      /* webpackIgnore: true */
+      "@cleocode/core/cloud/nexus-logout.js"
+    );
+    result = await logoutNexusDevice({
+      apiUrl: nexusApiUrlArg(args),
+      revoke: args["revoke"] === true
+    });
+  } catch (err) {
+    failNexus(err, "logout.run");
+  }
+  for (const warning of result.warnings) process.stderr.write(`warning: ${warning}
+`);
+  emitNexusResult(result, nexusDeviceLogoutSummary(result), "logout", "logout.run");
 }
-var SERVICE_NAME, NEXUS_API_URL_ARG;
+var SERVICE_NAME, NEXUS_API_URL_ARG, VAULT_REFUSAL_EXIT_CODES;
 var init_nexus_account_cli = __esm({
   "packages/cleo/src/cli/lib/nexus-account-cli.ts"() {
     "use strict";
+    init_src2();
     init_renderers();
     init_device_code_prompt();
     init_negated_flag();
@@ -50738,6 +51631,14 @@ var init_nexus_account_cli = __esm({
       type: "string",
       description: "Cleo Nexus API URL (default: $CLEO_NEXUS_API_URL, else https://api.cleocode.dev; staging: https://api.staging.cleocode.dev)."
     };
+    VAULT_REFUSAL_EXIT_CODES = {
+      E_NEXUS_VAULT_LEASE_HELD: 7 /* LOCK_TIMEOUT */,
+      E_NEXUS_VAULT_STORE_BUSY: 7 /* LOCK_TIMEOUT */,
+      E_NEXUS_VAULT_BEHIND: 23 /* VERSION_CONFLICT */,
+      E_NEXUS_VAULT_LOCAL_CHANGES: 21 /* CONCURRENT_MODIFICATION */,
+      E_NEXUS_VAULT_VERIFY_FAILED: 20 /* CHECKSUM_MISMATCH */,
+      E_NEXUS_VAULT_TARGET_OCCUPIED: 22 /* ID_COLLISION */
+    };
   }
 });
 
@@ -51071,13 +51972,13 @@ function _errorResult(code, message, meta) {
 }
 async function runLlmLogin(provider, opts) {
   const meta = { operation: "llm.login", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
-  const profile = await getProviderProfile(provider);
-  const oauthMode = profile?.oauth?.mode;
+  const profile2 = await getProviderProfile(provider);
+  const oauthMode = profile2?.oauth?.mode;
   if (provider === "kimi-code" || oauthMode === "device-code") {
     return _runKimiCodeLogin(opts, meta);
   }
   if (oauthMode === "pkce") {
-    return _runPkceLogin(profile.name, profile.oauth, opts, meta);
+    return _runPkceLogin(profile2.name, profile2.oauth, opts, meta);
   }
   return _errorResult(
     "E_NOT_IMPLEMENTED",
@@ -51615,11 +52516,11 @@ var init_login = __esm({
       },
       "read-only": {
         type: "boolean",
-        description: "nexus with CLEO_NEXUS_DEVICE=1: enrol this machine with the read-only device profile (account, devices and project reads only). Refused without CLEO_NEXUS_DEVICE=1."
+        description: "nexus: enrol this machine with the read-only device profile (account, devices and project reads only). Refused with CLEO_NEXUS_DEVICE=0."
       },
       name: {
         type: "string",
-        description: "nexus with CLEO_NEXUS_DEVICE=1: device name shown on cleocode.dev (default: OS, arch and a short id; never the hostname)."
+        description: "nexus: device name shown on cleocode.dev (default: OS, arch and a short id; never the hostname). Ignored with CLEO_NEXUS_DEVICE=0."
       },
       auth: {
         type: "string",
@@ -52925,14 +53826,14 @@ var init_backup = __esm({
           return;
         }
         const { exportPortableBundle, PortableBundleError } = await import("@cleocode/core/store/portable-bundle.js");
-        const { getProjectRoot: getProjectRoot75 } = await import("@cleocode/core");
+        const { getProjectRoot: getProjectRoot76 } = await import("@cleocode/core");
         const passphrase = args.encrypt === true ? await resolvePassphrase() : void 0;
         if (args.encrypt === true && passphrase === void 0) return;
         const encSuffix = args.encrypt === true ? "enc." : "";
         try {
           const result = await exportPortableBundle({
             scope,
-            projectRoot: scope === "project" || scope === "all" ? getProjectRoot75() : void 0,
+            projectRoot: scope === "project" || scope === "all" ? getProjectRoot76() : void 0,
             outputPath: args.out ?? `./${args.name}.${encSuffix}cleobundle.tar.gz`,
             encrypt: args.encrypt === true,
             passphrase,
@@ -52989,12 +53890,12 @@ var init_backup = __esm({
           );
           return;
         }
-        const { getProjectRoot: getProjectRoot75, getCleoHome: getCleoHome8, getCleoVersion } = await import("@cleocode/core");
+        const { getProjectRoot: getProjectRoot76, getCleoHome: getCleoHome8, getCleoVersion } = await import("@cleocode/core");
         const { BundleError, cleanupStaging, unpackBundle } = await import("@cleocode/core/store/backup-unpack.js");
         const { regenerateConfigJson, regenerateProjectContextJson, regenerateProjectInfoJson } = await import("@cleocode/core/store/regenerators.js");
         const { regenerateAndCompare } = await import("@cleocode/core/store/restore-json-merge.js");
         const { buildConflictReport, writeConflictReport } = await import("@cleocode/core/store/restore-conflict-report.js");
-        const projectRoot = getProjectRoot75();
+        const projectRoot = getProjectRoot76();
         const { assertOwnerStoreRewriteConfirmed } = await import("@cleocode/core/store/worktree-isolation-guard.js");
         try {
           assertOwnerStoreRewriteConfirmed("backup import", path2.join(projectRoot, ".cleo"), {
@@ -54887,7 +55788,7 @@ var init_check3 = __esm({
       async run({ args }) {
         const { spawnSync: spawnSync2 } = await import("node:child_process");
         const { existsSync: existsSync22 } = await import("node:fs");
-        const { join: join40, resolve: resolve13 } = await import("node:path");
+        const { join: join41, resolve: resolve13 } = await import("node:path");
         const strict = Boolean(args.strict);
         const jsonOnly = Boolean(args.json);
         const repoRoot = resolve13(process.cwd());
@@ -55195,13 +56096,48 @@ var init_check3 = __esm({
             task: "T12663",
             script: "scripts/lint-model-call-sites.mjs",
             description: "Every model call site is a registered decision site (ratchet)"
+          },
+          {
+            // T12819 / T12827 (journal spec §2.3a, §3.5 Rule 4): nothing drops
+            // cleo_trigger_suspend; only dropSyncMachinery drops _sync_* tables;
+            // migrations never mention capture triggers; forward-only migration
+            // rules (owned triggers carry the suspension clause, deterministic
+            // DML, no parent DELETE in a rebuild file); released migration files
+            // are byte-identical to the base ref (#1719).
+            id: "gate-36",
+            task: "T12819",
+            script: "scripts/lint-sync-schema.mjs",
+            description: "Change-journal schema rules (suspend table, migrations)"
+          },
+          {
+            // T12897: every syncing cleo.db table is declared in ROW_IDENTITY or
+            // exempt with a reason and a task in ROW_IDENTITY_EXEMPT; a stale
+            // exemption (table gone, no longer syncing, or declared) fails too.
+            // The fresh-store check is store/__tests__/row-identity-gate.test.ts.
+            id: "gate-37",
+            task: "T12897",
+            script: "scripts/lint-row-identity-coverage.mjs",
+            description: "Every syncing cleo.db table has declared row identity or an exemption"
+          },
+          {
+            // T12881: the raw sync applier never runs TypeScript write paths, so
+            // every rejection site on a synced write path is tagged
+            // `// @sync-invariant <id>` (contracts sync-write-invariants
+            // registry) or an escape with a reason. Untagged sites are baselined
+            // per (file, symbol, code); the baseline only shrinks. Registry
+            // closure: tables classified, triggers created by migrations, no
+            // dead gates (spec t12859 §3.6.7).
+            id: "gate-38",
+            task: "T12881",
+            script: "scripts/lint-sync-write-invariants.mjs",
+            description: "Every synced-write rejection site is classified (ratchet)"
           }
         ];
         const scriptArgs = strict ? ["--strict"] : ["--check"];
         const results = [];
         let anyFailed = false;
         for (const gate of gates) {
-          const scriptPath = join40(repoRoot, gate.script);
+          const scriptPath = join41(repoRoot, gate.script);
           if (!existsSync22(scriptPath)) {
             results.push({
               id: gate.id,
@@ -55639,6 +56575,531 @@ var init_classify = __esm({
   }
 });
 
+// packages/cleo/src/cli/lib/nexus-cloud-cli.ts
+function stringArg(args, name) {
+  const raw = args[name];
+  return typeof raw === "string" && raw !== "" ? raw : void 0;
+}
+function writeWarnings(warnings) {
+  for (const w of warnings) process.stderr.write(`warning: ${w.message} (${w.code})
+`);
+}
+function deviceStateArg(args) {
+  const raw = stringArg(args, "state");
+  if (raw === void 0) return void 0;
+  const known = NEXUS_DEVICE_LIST_STATES.find((s) => s === raw);
+  if (known !== void 0) return known;
+  throw Object.assign(new Error(`unknown --state '${raw}'`), {
+    code: "E_VALIDATION",
+    fix: `use one of: ${NEXUS_DEVICE_LIST_STATES.join(", ")}`
+  });
+}
+function cloudStatusSummary(r) {
+  if (r.verdict === "not-signed-in") {
+    return `Cloud status: not signed in to ${r.local.apiUrl}. Run \`cleo login nexus\`.`;
+  }
+  const s = r.summary;
+  const parts = [`device ${r.local.nexusDeviceId ?? "unknown"} (${s.profile ?? "no profile"})`];
+  if (r.local.projectId !== null) {
+    parts.push(`project ${r.local.projectId} ${s.linked ? "linked" : "NOT linked"}`);
+    parts.push(s.replicaAttached ? "replica attached" : "replica NOT attached");
+    parts.push(`${s.devices} device(s)`);
+    if (s.headSeq !== null) parts.push(`head ${s.headSeq}`);
+    if (s.openConflicts !== null) parts.push(`${s.openConflicts} open conflict(s)`);
+  }
+  return `Cloud status: ${r.verdict}. ${parts.join("; ")}.`;
+}
+async function runCloudRead(operation, call, summary) {
+  let result;
+  try {
+    result = await call();
+  } catch (err) {
+    const { NexusCloudOfflineError } = await import(
+      /* webpackIgnore: true */
+      "@cleocode/core/cloud/nexus-cloud-status.js"
+    );
+    if (err instanceof NexusCloudOfflineError) writeWarnings(err.publicDetails.warnings);
+    failNexus(err, operation);
+  }
+  writeWarnings(result.warnings);
+  emitNexusResult(result, summary(result), "cloud", operation);
+}
+async function runCloudStatus(args) {
+  await runCloudRead(
+    "cloud.status",
+    async () => {
+      const { getNexusCloudStatus } = await import(
+        /* webpackIgnore: true */
+        "@cleocode/core/cloud/nexus-cloud-status.js"
+      );
+      const projectId = stringArg(args, "project");
+      return getNexusCloudStatus({
+        apiUrl: nexusApiUrlArg(args),
+        ...projectId !== void 0 ? { projectId } : {}
+      });
+    },
+    cloudStatusSummary
+  );
+}
+async function runCloudWhoami(args) {
+  await runCloudRead(
+    "cloud.whoami",
+    async () => {
+      const { nexusCloudWhoami } = await import(
+        /* webpackIgnore: true */
+        "@cleocode/core/cloud/nexus-cloud.js"
+      );
+      return nexusCloudWhoami({ apiUrl: nexusApiUrlArg(args) });
+    },
+    (r) => `Signed in to ${r.apiUrl} as ${r.user.email} with a ${r.credential.kind} credential${r.device ? ` (device ${r.device.deviceId}, profile ${r.credential.profile ?? "none"})` : ""}.`
+  );
+}
+async function runCloudDevices(args) {
+  await runCloudRead(
+    "cloud.devices.list",
+    async () => {
+      const state = deviceStateArg(args);
+      const { listNexusCloudDevices } = await import(
+        /* webpackIgnore: true */
+        "@cleocode/core/cloud/nexus-cloud.js"
+      );
+      return listNexusCloudDevices({
+        apiUrl: nexusApiUrlArg(args),
+        ...state !== void 0 ? { state } : {}
+      });
+    },
+    (r) => `${r.count} device(s) on ${r.apiUrl}${r.state ? ` (state ${r.state})` : ""}: ${r.devices.map((d) => `${d.name} ${d.deviceId} ${d.state}${d.current ? " (this machine)" : ""}`).join("; ")}`
+  );
+}
+async function runCloudProjects(args) {
+  const action = stringArg(args, "action");
+  if (action === "show") {
+    await runCloudRead(
+      "cloud.projects.show",
+      async () => {
+        const projectId = stringArg(args, "id");
+        const { showNexusCloudProject } = await import(
+          /* webpackIgnore: true */
+          "@cleocode/core/cloud/nexus-cloud.js"
+        );
+        return showNexusCloudProject({
+          apiUrl: nexusApiUrlArg(args),
+          ...projectId !== void 0 ? { projectId } : {}
+        });
+      },
+      (r) => `Project ${r.projectId} "${r.project.label ?? ""}" (${r.role}): ${r.devices.active} active device(s), ${r.replicas.length} replica(s), head ${r.stream?.headSeq ?? "none"}, ${r.openConflicts} open conflict(s).`
+    );
+    return;
+  }
+  if (action !== void 0 && action !== "list") {
+    failNexus(
+      Object.assign(new Error(`unknown action '${action}'`), {
+        code: "E_VALIDATION",
+        fix: "use `cleo cloud projects` or `cleo cloud projects show [<id>]`"
+      }),
+      "cloud.projects.list"
+    );
+  }
+  await runCloudRead(
+    "cloud.projects.list",
+    async () => {
+      const organizationId = stringArg(args, "org");
+      const { listNexusCloudProjects } = await import(
+        /* webpackIgnore: true */
+        "@cleocode/core/cloud/nexus-cloud.js"
+      );
+      return listNexusCloudProjects({
+        apiUrl: nexusApiUrlArg(args),
+        ...organizationId !== void 0 ? { organizationId } : {}
+      });
+    },
+    (r) => `${r.count} project(s) on ${r.apiUrl}: ${r.projects.map((p) => `${p.label ?? p.projectId} (${p.role})`).join("; ")}`
+  );
+}
+var init_nexus_cloud_cli = __esm({
+  "packages/cleo/src/cli/lib/nexus-cloud-cli.ts"() {
+    "use strict";
+    init_src2();
+    init_nexus_account_cli();
+  }
+});
+
+// packages/cleo/src/cli/lib/nexus-vault-cli.ts
+function scopeArg(args, operation) {
+  const raw = stringArg(args, "scope") ?? "project";
+  if (raw === "project" || raw === "global") return raw;
+  failNexus(
+    Object.assign(new Error(`unknown scope '${raw}'`), {
+      code: "E_VALIDATION",
+      fix: "use --scope project (default) or --scope global"
+    }),
+    operation
+  );
+}
+function common2(args, operation) {
+  return { apiUrl: nexusApiUrlArg(args), scope: scopeArg(args, operation) };
+}
+function activityLimitArg(args) {
+  const raw = stringArg(args, "limit");
+  if (raw === void 0) return void 0;
+  const limit = Number(raw);
+  if (/^\d+$/.test(raw) && Number.isSafeInteger(limit) && limit >= 1 && limit <= 200) return limit;
+  throw Object.assign(new Error(`--limit must be a whole number from 1 to 200, got '${raw}'`), {
+    code: "E_VALIDATION",
+    fix: "pass --limit 1..200 (default 50)"
+  });
+}
+async function runCloudPush(args) {
+  await runCloudRead(
+    "cloud.push",
+    async () => (await vaultModule()).pushNexusVault({
+      ...common2(args, "cloud.push"),
+      force: args["force"] === true,
+      hold: args["hold"] === true
+    }),
+    (r) => r.status === "up-to-date" ? `Up to date: ${r.streamId} already holds this ${r.scope} store (snapshot ${r.snapshot?.checkpointId ?? "none"}).` : `Pushed ${r.scope} snapshot ${r.snapshot?.checkpointId} to ${r.streamId} (${r.snapshot?.rows ?? 0} rows${r.parentCheckpointId ? `, parent ${r.parentCheckpointId}` : ", first snapshot"}${r.forked ? ", FORK: lease taken by force" : ""}).`
+  );
+}
+async function runCloudPull(args) {
+  await runCloudRestoreLike(args, "cloud.pull", "pull");
+}
+async function runCloudRestore(args) {
+  await runCloudRestoreLike(args, "cloud.restore", "restore");
+}
+async function runCloudRestoreLike(args, operation, mode) {
+  await runCloudRead(
+    operation,
+    async () => {
+      const checkpointId = stringArg(args, "checkpoint");
+      const projectId = stringArg(args, "project");
+      const into = stringArg(args, "into");
+      return (await vaultModule()).restoreNexusVault({
+        ...common2(args, operation),
+        mode,
+        force: args["force"] === true,
+        ...mode === "restore" && checkpointId !== void 0 ? { checkpointId } : {},
+        ...mode === "restore" && projectId !== void 0 ? { projectId } : {},
+        ...mode === "restore" && into !== void 0 ? { into } : {},
+        relink: async (projectRoot) => {
+          const { linkProjectToNexus } = await import(
+            /* webpackIgnore: true */
+            "@cleocode/core/cloud/nexus-link.js"
+          );
+          try {
+            const linked = await linkProjectToNexus({ apiUrl: nexusApiUrlArg(args), projectRoot });
+            return linked.warnings;
+          } catch (err) {
+            return [
+              `restored, but attaching this copy failed (${err instanceof Error ? err.message : String(err)}); run \`cleo project link\``
+            ];
+          }
+        }
+      });
+    },
+    (r) => r.status === "up-to-date" ? `Up to date: this ${r.scope} store already holds snapshot ${r.snapshot?.checkpointId ?? "none"}.` : `Restored ${r.scope} snapshot ${r.snapshot?.checkpointId} into ${r.target}: ${r.tables} table(s) verified by count and hash${r.safetyBackup ? `; previous state saved to ${r.safetyBackup}` : ""}.`
+  );
+}
+async function runCloudVerify(args) {
+  await runCloudRead(
+    "cloud.verify",
+    async () => (await vaultModule()).verifyNexusVault(common2(args, "cloud.verify")),
+    (r) => {
+      const bad = r.tables.filter((t) => !t.match).map((t) => t.table);
+      const devices = r.devices.map(
+        (d) => `${who(d.deviceName, d.deviceId)} ${d.matchesHead ? "matches" : "differs from"} head`
+      ).join("; ");
+      return `Verify ${r.scope}: ${r.verdict}${bad.length ? ` (${bad.length} table(s) differ: ${bad.slice(0, 8).join(", ")}${bad.length > 8 ? ", \u2026" : ""})` : ""}; local integrity ${r.localIntegrity ? "ok" : "FAILED"}${devices ? `; ${devices}` : ""}.`;
+    }
+  );
+}
+async function runCloudVault(args) {
+  await runCloudRead(
+    "cloud.vault",
+    async () => (await vaultModule()).nexusVaultStatus(common2(args, "cloud.vault")),
+    (r) => `Vault ${r.scope} ${r.streamId}: ${r.lineage.length} snapshot(s), head ${r.head?.checkpointId ?? "none"}${r.head ? ` by ${who(r.head.deviceName, r.head.deviceId)}` : ""}; this store last synced ${r.lastSynced ?? "never"}; ${r.pendingChanges.length} table(s) changed since; leases: ${r.leases.map((l) => `${l.role} ${who(l.deviceName, l.deviceId ?? l.replicaId)} until ${l.expiresAt}${l.mine ? " (this machine)" : ""}${l.forkedFromReplicaId ? " (forked)" : ""}`).join("; ") || "none"}.`
+  );
+}
+async function runCloudLease(args) {
+  const action = stringArg(args, "action") ?? "release";
+  if (action !== "release") {
+    failNexus(
+      Object.assign(new Error(`unknown action '${action}'`), {
+        code: "E_VALIDATION",
+        fix: "use `cleo cloud lease release` (see `cleo cloud vault` for holders)"
+      }),
+      "cloud.lease.release"
+    );
+  }
+  await runCloudRead(
+    "cloud.lease.release",
+    async () => (await vaultModule()).releaseNexusVaultLease(common2(args, "cloud.lease.release")),
+    (r) => r.released ? `Released the write lease on ${r.streamId}: another device may push now.` : `This machine held no write lease on ${r.streamId}.`
+  );
+}
+async function runCloudActivity(args) {
+  await runCloudRead(
+    "cloud.activity",
+    async () => {
+      const { nexusCloudActivity } = await import(
+        /* webpackIgnore: true */
+        "@cleocode/core/cloud/nexus-cloud-activity.js"
+      );
+      const limit = activityLimitArg(args);
+      const before = stringArg(args, "before");
+      const projectId = stringArg(args, "project");
+      const deviceId = stringArg(args, "device");
+      return nexusCloudActivity({
+        ...deviceId !== void 0 ? { deviceId } : {},
+        apiUrl: nexusApiUrlArg(args),
+        ...limit !== void 0 ? { limit } : {},
+        ...before !== void 0 ? { before } : {},
+        ...projectId !== void 0 ? { projectId } : {}
+      });
+    },
+    (r) => `${r.items.length} event(s)${r.projectId ? ` for project ${r.projectId}` : ""}: ${r.items.slice(0, 10).map(
+      (i) => `${i.at} ${who(i.deviceName, i.deviceId ?? "account")}${i.thisDevice ? " (this machine)" : ""} ${i.action}${i.target ? ` ${i.target}` : ""}`
+    ).join("; ")}${r.items.length > 10 ? "; \u2026" : ""}`
+  );
+}
+var vaultModule, who;
+var init_nexus_vault_cli = __esm({
+  "packages/cleo/src/cli/lib/nexus-vault-cli.ts"() {
+    "use strict";
+    init_nexus_account_cli();
+    init_nexus_cloud_cli();
+    vaultModule = () => import(
+      /* webpackIgnore: true */
+      "@cleocode/core/cloud/nexus-vault.js"
+    );
+    who = (name, id) => name ?? id;
+  }
+});
+
+// packages/cleo/src/cli/commands/cloud.ts
+var cloud_exports = {};
+__export(cloud_exports, {
+  cloudCommand: () => cloudCommand
+});
+var JSON_ARG, SCOPE_ARG, statusSubCommand, whoamiSubCommand, devicesSubCommand, projectsSubCommand, pushSubCommand, pullSubCommand, restoreSubCommand, verifyVaultSubCommand, vaultSubCommand, leaseSubCommand, activitySubCommand, cloudCommand;
+var init_cloud = __esm({
+  "packages/cleo/src/cli/commands/cloud.ts"() {
+    "use strict";
+    init_src2();
+    init_define_cli_command();
+    init_nexus_account_cli();
+    init_nexus_cloud_cli();
+    init_nexus_vault_cli();
+    JSON_ARG = { type: "boolean", description: "Output as JSON envelope" };
+    SCOPE_ARG = {
+      type: "string",
+      description: "Which store: 'project' (the current project, default) or 'global' (this account's global store: the main brain)."
+    };
+    statusSubCommand = defineCommand({
+      meta: {
+        name: "status",
+        description: "Verify this machine against Cleo Nexus in one call: device, credential, project link, replica and stream. Returns { verdict, summary, local, remote, warnings }; verdict is ok, attention, not-linked, not-registered or not-signed-in. Reads only (GET; never binds a replica), except that getting the credential may upgrade a 9.24 session (E1) and retry unsettled logouts (E9/E10)."
+      },
+      args: {
+        project: {
+          type: "string",
+          description: "Project id to check (default: the current project)."
+        },
+        "api-url": NEXUS_API_URL_ARG,
+        json: JSON_ARG
+      },
+      async run({ args }) {
+        await runCloudStatus(args);
+      }
+    });
+    whoamiSubCommand = defineCommand({
+      meta: {
+        name: "whoami",
+        description: "Show the Cleo Nexus user, organizations, credential and device for this machine."
+      },
+      args: { "api-url": NEXUS_API_URL_ARG, json: JSON_ARG },
+      async run({ args }) {
+        await runCloudWhoami(args);
+      }
+    });
+    devicesSubCommand = defineCommand({
+      meta: {
+        name: "devices",
+        description: "List the account's devices (newest first), following every page; reports truncation."
+      },
+      args: {
+        state: {
+          type: "string",
+          description: `Filter: ${NEXUS_DEVICE_LIST_STATES.join(", ")} (default: active).`
+        },
+        "api-url": NEXUS_API_URL_ARG,
+        json: JSON_ARG
+      },
+      async run({ args }) {
+        await runCloudDevices(args);
+      }
+    });
+    projectsSubCommand = defineCommand({
+      meta: {
+        name: "projects",
+        description: "List visible Cleo Nexus projects, following every page (cleo cloud projects [--org <id>]), or show one with its replicas and device counts (cleo cloud projects show [<id>], default: the current project)."
+      },
+      args: {
+        action: {
+          type: "positional",
+          description: "'list' (default) or 'show'.",
+          required: false
+        },
+        id: {
+          type: "positional",
+          description: "Project id for show (default: the current project).",
+          required: false
+        },
+        org: { type: "string", description: "Only this organization id (list)." },
+        "api-url": NEXUS_API_URL_ARG,
+        json: JSON_ARG
+      },
+      async run({ args }) {
+        await runCloudProjects(args);
+      }
+    });
+    pushSubCommand = defineCommand({
+      meta: {
+        name: "push",
+        description: "Back up this store to Cleo Nexus as an encrypted snapshot; the key is escrowed on Cleo Nexus (released only to your approved devices), so this is encrypted at rest, not zero-knowledge. The server also stores per-table row counts and keyed hashes in plaintext. Refused when another device holds the write lease or pushed since this machine last synced (pull first); --force takes the lease and pushes anyway as a labelled fork. The lease is released when the push ends unless --hold."
+      },
+      args: {
+        scope: SCOPE_ARG,
+        force: {
+          type: "boolean",
+          description: "Take the lease from another device / push over a newer snapshot (a labelled fork)."
+        },
+        hold: {
+          type: "boolean",
+          description: "Keep the write lease after the push (another device cannot push until it expires or `cleo cloud lease release`)."
+        },
+        "api-url": NEXUS_API_URL_ARG,
+        json: JSON_ARG
+      },
+      async run({ args }) {
+        await runCloudPush(args);
+      }
+    });
+    pullSubCommand = defineCommand({
+      meta: {
+        name: "pull",
+        description: "Bring this store to the cloud's newest snapshot, verified by per-table count and hash before anything is replaced; this machine's local-only state is kept. Refuses to overwrite local changes made since the last sync unless --force (a safety backup is taken first)."
+      },
+      args: {
+        scope: SCOPE_ARG,
+        force: { type: "boolean", description: "Overwrite local changes (after a safety backup)." },
+        "api-url": NEXUS_API_URL_ARG,
+        json: JSON_ARG
+      },
+      async run({ args }) {
+        await runCloudPull(args);
+      }
+    });
+    restoreSubCommand = defineCommand({
+      meta: {
+        name: "restore",
+        description: "Restore a snapshot: the newest, or --checkpoint <id> (point in time); or a project this machine does not have yet with --project <id> [--into <dir>] (then it is linked to this device). Verified by count and hash before activation; a safety backup of existing data is taken first."
+      },
+      args: {
+        scope: SCOPE_ARG,
+        checkpoint: { type: "string", description: "Snapshot id to restore (see `cleo cloud vault`)." },
+        project: {
+          type: "string",
+          description: "Server project id to restore onto this machine (see `cleo cloud projects`)."
+        },
+        into: {
+          type: "string",
+          description: "Directory for --project (default: the current directory)."
+        },
+        force: { type: "boolean", description: "Overwrite local changes (after a safety backup)." },
+        "api-url": NEXUS_API_URL_ARG,
+        json: JSON_ARG
+      },
+      async run({ args }) {
+        await runCloudRestore(args);
+      }
+    });
+    verifyVaultSubCommand = defineCommand({
+      meta: {
+        name: "verify",
+        description: "Integrity check across machines: SQLite integrity of this store, its per-table counts and keyed hashes against the cloud's newest snapshot, and every device's newest snapshot against it. Verdict: match, ahead, behind, diverged, empty, or untrusted (the newest snapshot's signature does not verify)."
+      },
+      args: { scope: SCOPE_ARG, "api-url": NEXUS_API_URL_ARG, json: JSON_ARG },
+      async run({ args }) {
+        await runCloudVerify(args);
+      }
+    });
+    vaultSubCommand = defineCommand({
+      meta: {
+        name: "vault",
+        description: "The store's cloud vault: snapshot lineage (newest first), the last push of each device, tables changed since this machine's last sync, and who holds the write lease until when."
+      },
+      args: { scope: SCOPE_ARG, "api-url": NEXUS_API_URL_ARG, json: JSON_ARG },
+      async run({ args }) {
+        await runCloudVault(args);
+      }
+    });
+    leaseSubCommand = defineCommand({
+      meta: {
+        name: "lease",
+        description: "Hand the write lease back so another device can push: cleo cloud lease release."
+      },
+      args: {
+        action: { type: "positional", description: "'release'.", required: false },
+        scope: SCOPE_ARG,
+        "api-url": NEXUS_API_URL_ARG,
+        json: JSON_ARG
+      },
+      async run({ args }) {
+        await runCloudLease(args);
+      }
+    });
+    activitySubCommand = defineCommand({
+      meta: {
+        name: "activity",
+        description: "What this account's devices did on Cleo Nexus and when (snapshots pushed or refused, leases taken, forced or released, projects linked, devices enrolled), newest first."
+      },
+      args: {
+        limit: { type: "string", description: "Events to show (1-200, default 50)." },
+        before: { type: "string", description: "Older page: the nextBefore of a previous call." },
+        project: { type: "string", description: "Only events about this server project id." },
+        device: {
+          type: "string",
+          description: "Only events by this device id (see `cleo cloud devices`)."
+        },
+        "api-url": NEXUS_API_URL_ARG,
+        json: JSON_ARG
+      },
+      async run({ args }) {
+        await runCloudActivity(args);
+      }
+    });
+    cloudCommand = defineCommand({
+      meta: {
+        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."
+      },
+      subCommands: {
+        status: statusSubCommand,
+        whoami: whoamiSubCommand,
+        devices: devicesSubCommand,
+        projects: projectsSubCommand,
+        activity: activitySubCommand,
+        push: pushSubCommand,
+        pull: pullSubCommand,
+        restore: restoreSubCommand,
+        verify: verifyVaultSubCommand,
+        vault: vaultSubCommand,
+        lease: leaseSubCommand
+      }
+    });
+  }
+});
+
 // packages/cleo/src/cli/commands/code.ts
 var code_exports = {};
 __export(code_exports, {
@@ -55686,9 +57147,9 @@ var init_code = __esm({
           async run({ args }) {
             await requireTreeSitter();
             const { smartOutline } = await import("@cleocode/core/internal");
-            const { join: join40 } = await import("node:path");
+            const { join: join41 } = await import("node:path");
             const root = process.cwd();
-            const absPath = args.file.startsWith("/") ? args.file : join40(root, args.file);
+            const absPath = args.file.startsWith("/") ? args.file : join41(root, args.file);
             const result = smartOutline(absPath, root);
             if (result.errors.length > 0 && result.symbols.length === 0) {
               cliError(result.errors.join(", "), 1, { name: "E_OUTLINE_FAILED" });
@@ -55779,9 +57240,9 @@ var init_code = __esm({
           async run({ args }) {
             await requireTreeSitter();
             const { smartUnfold } = await import("@cleocode/core/internal");
-            const { join: join40 } = await import("node:path");
+            const { join: join41 } = await import("node:path");
             const root = process.cwd();
-            const absPath = args.file.startsWith("/") ? args.file : join40(root, args.file);
+            const absPath = args.file.startsWith("/") ? args.file : join41(root, args.file);
             const result = smartUnfold(absPath, args.symbol, root);
             if (!result.found) {
               const errs = result.errors.length > 0 ? `: ${result.errors.join(", ")}` : "";
@@ -63770,15 +65231,15 @@ var init_doctor_fk_check = __esm({
         }
       },
       async run({ args }) {
-        const scopeArg = args.scope;
-        if (scopeArg !== void 0 && scopeArg !== "project" && scopeArg !== "global") {
-          cliError(`--scope must be 'project' or 'global' (received: ${scopeArg})`, "E_INVALID_INPUT", {
+        const scopeArg2 = args.scope;
+        if (scopeArg2 !== void 0 && scopeArg2 !== "project" && scopeArg2 !== "global") {
+          cliError(`--scope must be 'project' or 'global' (received: ${scopeArg2})`, "E_INVALID_INPUT", {
             fix: "Run 'cleo doctor fk-check --scope project' or omit --scope to check both."
           });
           process.exitCode = 6;
           return;
         }
-        const scopeOpt = scopeArg ? { scopes: [scopeArg] } : {};
+        const scopeOpt = scopeArg2 ? { scopes: [scopeArg2] } : {};
         if (args.fix === true) {
           const fixReport = await repairForeignKeyViolations({ cwd: process.cwd(), ...scopeOpt });
           humanInfo(
@@ -64195,12 +65656,44 @@ var init_doctor_memory_guard = __esm({
   }
 });
 
+// packages/cleo/src/cli/commands/doctor-migrations.ts
+var doctor_migrations_exports = {};
+__export(doctor_migrations_exports, {
+  doctorMigrationsCommand: () => doctorMigrationsCommand
+});
+import { getProjectRoot as getProjectRoot49 } from "@cleocode/core";
+import { inspectMigrations } from "@cleocode/core/doctor/migrations.js";
+var doctorMigrationsCommand;
+var init_doctor_migrations = __esm({
+  "packages/cleo/src/cli/commands/doctor-migrations.ts"() {
+    "use strict";
+    init_define_cli_command();
+    init_renderers();
+    doctorMigrationsCommand = defineCommand({
+      meta: {
+        name: "migrations",
+        description: "Report the migration journal of the project and global stores: row count, head, applied and pending files per lineage, and hash drift. Read-only."
+      },
+      args: {
+        json: { type: "boolean", description: "Output as JSON" },
+        human: { type: "boolean", description: "Force human-readable output" },
+        quiet: { type: "boolean", description: "Suppress non-essential output" }
+      },
+      async run() {
+        const report = inspectMigrations(getProjectRoot49());
+        cliOutput(report, { command: "doctor", operation: "doctor.migrations.run" });
+        if (report.scopes.some((s) => s.drift.length > 0)) process.exitCode = 1;
+      }
+    });
+  }
+});
+
 // packages/cleo/src/cli/commands/doctor-nexus-residency.ts
 var doctor_nexus_residency_exports = {};
 __export(doctor_nexus_residency_exports, {
   doctorNexusResidencyCommand: () => doctorNexusResidencyCommand
 });
-import { getCleoHome as getCleoHome6, getProjectRoot as getProjectRoot49 } from "@cleocode/core";
+import { getCleoHome as getCleoHome6, getProjectRoot as getProjectRoot50 } from "@cleocode/core";
 import { scanNexusSchemaResidency } from "@cleocode/core/doctor/nexus-schema-residency.js";
 var doctorNexusResidencyCommand;
 var init_doctor_nexus_residency = __esm({
@@ -64219,7 +65712,7 @@ var init_doctor_nexus_residency = __esm({
         quiet: { type: "boolean", description: "Suppress non-essential output" }
       },
       async run() {
-        const result = scanNexusSchemaResidency(getProjectRoot49(), getCleoHome6());
+        const result = scanNexusSchemaResidency(getProjectRoot50(), getCleoHome6());
         cliOutput(result, {
           command: "doctor",
           operation: "doctor.nexus-residency.run"
@@ -64237,7 +65730,7 @@ var doctor_project_identity_exports = {};
 __export(doctor_project_identity_exports, {
   doctorProjectIdentityCommand: () => doctorProjectIdentityCommand
 });
-import { getProjectRoot as getProjectRoot50 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot51 } from "@cleocode/core";
 import {
   inspectProjectIdentity,
   inspectProjectNameDrift,
@@ -64262,7 +65755,7 @@ var init_doctor_project_identity = __esm({
         quiet: { type: "boolean", description: "Suppress non-essential output" }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot50();
+        const projectRoot = getProjectRoot51();
         if (!args.resolve) {
           const report = inspectProjectIdentity(projectRoot);
           const nameDrift = await inspectProjectNameDrift(projectRoot);
@@ -64801,7 +66294,7 @@ var doctor_repair_exports = {};
 __export(doctor_repair_exports, {
   doctorRepairCommand: () => doctorRepairCommand
 });
-import { getLogger as getLogger21, getProjectRoot as getProjectRoot51 } from "@cleocode/core";
+import { getLogger as getLogger21, getProjectRoot as getProjectRoot52 } from "@cleocode/core";
 import { repairMalformedDbs } from "@cleocode/core/store/repair-malformed-dbs.js";
 var doctorRepairCommand;
 var init_doctor_repair = __esm({
@@ -64850,7 +66343,7 @@ var init_doctor_repair = __esm({
           return;
         }
         const result = repairMalformedDbs({
-          projectRoot: getProjectRoot51(),
+          projectRoot: getProjectRoot52(),
           roles: roleArg.length > 0 ? [roleArg] : void 0,
           dryRun,
           logger: getLogger21("doctor-repair"),
@@ -65052,7 +66545,7 @@ var doctor_superseded_store_exports = {};
 __export(doctor_superseded_store_exports, {
   doctorSupersededStoreCommand: () => doctorSupersededStoreCommand
 });
-import { getProjectRoot as getProjectRoot52 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot53 } from "@cleocode/core";
 import { scanSupersededStores } from "@cleocode/core/doctor/superseded-store.js";
 import { reconcileSupersededStores } from "@cleocode/core/store/exodus/index.js";
 var doctorSupersededStoreCommand;
@@ -65085,7 +66578,7 @@ var init_doctor_superseded_store = __esm({
       },
       async run({ args }) {
         if (args.reconcile === true) {
-          const receipt = await reconcileSupersededStores(getProjectRoot52(), {
+          const receipt = await reconcileSupersededStores(getProjectRoot53(), {
             dryRun: args["dry-run"] === true,
             additive: args.additive === true
           });
@@ -65107,7 +66600,7 @@ var init_doctor_superseded_store = __esm({
           );
           return;
         }
-        const result = scanSupersededStores(getProjectRoot52());
+        const result = scanSupersededStores(getProjectRoot53());
         cliOutput(result, {
           command: "doctor",
           operation: "doctor.superseded-store.run"
@@ -65208,7 +66701,7 @@ import {
   rollbackTwinCollapse
 } from "@cleocode/core/doctor/twin-collapse.js";
 import { CleoError as CleoError8 } from "@cleocode/core/errors";
-import { getProjectRoot as getProjectRoot53 } from "@cleocode/core/paths.js";
+import { getProjectRoot as getProjectRoot54 } from "@cleocode/core/paths.js";
 function reportTwinCollapseError(error, retry) {
   if (retry && !(error instanceof CleoError8)) throw error;
   const message = error instanceof Error ? error.message : String(error);
@@ -65279,7 +66772,7 @@ var init_doctor_twin_collapse = __esm({
         quiet: { type: "boolean", description: "Suppress non-essential output" }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot53();
+        const projectRoot = getProjectRoot54();
         const guard = { cwd: process.cwd(), confirmOwnerStore: args["confirm-owner-store"] === true };
         const actions = twinCollapseActions(args);
         if (actions.length > 1) {
@@ -65357,7 +66850,7 @@ __export(doctor_worktree_stores_exports, {
   doctorWorktreeStoresCommand: () => doctorWorktreeStoresCommand
 });
 import { scanWorktreeStores } from "@cleocode/core/doctor/worktree-stores.js";
-import { getProjectRoot as getProjectRoot54, resolveStoreOwnerRoot } from "@cleocode/core/paths.js";
+import { getProjectRoot as getProjectRoot55, resolveStoreOwnerRoot } from "@cleocode/core/paths.js";
 var doctorWorktreeStoresCommand;
 var init_doctor_worktree_stores = __esm({
   "packages/cleo/src/cli/commands/doctor-worktree-stores.ts"() {
@@ -65379,7 +66872,7 @@ var init_doctor_worktree_stores = __esm({
         quiet: { type: "boolean", description: "Suppress non-essential output" }
       },
       async run({ args }) {
-        const projectRoot = resolveStoreOwnerRoot(getProjectRoot54());
+        const projectRoot = resolveStoreOwnerRoot(getProjectRoot55());
         const result = scanWorktreeStores(projectRoot, { skipCompare: args["skip-compare"] === true });
         cliOutput(result, {
           command: "doctor",
@@ -65531,7 +67024,7 @@ import {
   resumePreparedKnowledgeRepair,
   runKnowledgeDoctor as runKnowledgeDoctor2
 } from "@cleocode/core/doctor/knowledge.js";
-import { getProjectRoot as getProjectRoot55 } from "@cleocode/core/paths.js";
+import { getProjectRoot as getProjectRoot56 } from "@cleocode/core/paths.js";
 var doctorKnowledgeSubcommand;
 var init_doctor_knowledge = __esm({
   "packages/cleo/src/cli/commands/doctor-knowledge.ts"() {
@@ -65606,7 +67099,7 @@ var init_doctor_knowledge = __esm({
       },
       async run({ args }) {
         const startedAt = Date.now();
-        const root = getProjectRoot55();
+        const root = getProjectRoot56();
         let context;
         let pending;
         try {
@@ -65774,7 +67267,7 @@ import { join as join24 } from "node:path";
 import {
   ensureGlobalAgentRegistryDb,
   getGlobalAgentRegistryNativeDb,
-  getProjectRoot as getProjectRoot56,
+  getProjectRoot as getProjectRoot57,
   installAgentFromCant
 } from "@cleocode/core/internal";
 function sha256Hex(bytes) {
@@ -65962,7 +67455,7 @@ var init_migrate_agents_v2 = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot56();
+        const projectRoot = getProjectRoot57();
         const verbose = args.quiet !== true;
         if (verbose) {
           humanInfo("Scanning .cleo/cant/agents/ and .cleo/agents/ for unregistered agents...");
@@ -66006,7 +67499,7 @@ __export(doctor_exports, {
 });
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "node:fs";
 import { join as join25 } from "node:path";
-import { getProjectRoot as getProjectRoot57, pushWarning as pushWarning5 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot58, pushWarning as pushWarning5 } from "@cleocode/core";
 import { renderInvariantAuditLines } from "@cleocode/core/doctor/invariant-audit-render.js";
 import {
   quarantineRogueCleoDir,
@@ -66137,6 +67630,7 @@ var init_doctor = __esm({
     init_doctor_malformed_ids();
     init_doctor_manifest_rows();
     init_doctor_memory_guard();
+    init_doctor_migrations();
     init_doctor_nexus_residency();
     init_doctor_project_identity();
     init_doctor_projects();
@@ -66169,6 +67663,8 @@ var init_doctor = __esm({
         "legacy-reaper": doctorLegacyReaperCommand,
         // T12128 — task ids that fail the write-path validator
         "malformed-ids": doctorMalformedIdsCommand,
+        // T12796 — the migration journal of each store (read-only; the live journal count)
+        migrations: doctorMigrationsCommand,
         // T12686 — manifest rows whose metadata violates the stored field contract (+ --repair/--rollback)
         "manifest-rows": doctorManifestRowsCommand,
         // T12095 — pre-dual-scope store files still on disk under their old LIVE names
@@ -66413,7 +67909,7 @@ var init_doctor = __esm({
             const { join: pathJoin } = await import("node:path");
             const { existsSync: existsSync22 } = await import("node:fs");
             const { detectAndHealCoreWorktreeLeak } = await import("@cleocode/worktree");
-            const projectRoot = getProjectRoot57();
+            const projectRoot = getProjectRoot58();
             let gitRoot = projectRoot;
             try {
               gitRoot = execFile2("git", ["rev-parse", "--show-toplevel"], {
@@ -66465,7 +67961,7 @@ var init_doctor = __esm({
           }
           if (args.brain) {
             const { computeBrainHealthDashboard } = await import("@cleocode/core/memory/brain-health-dashboard.js");
-            const projectRoot = getProjectRoot57();
+            const projectRoot = getProjectRoot58();
             const dashboard = await computeBrainHealthDashboard(projectRoot);
             cliOutput(dashboard, { command: "doctor", operation: "doctor.brain" });
             if (dashboard.hasP0Failure) {
@@ -66474,7 +67970,7 @@ var init_doctor = __esm({
             return;
           }
           if (args["scan-test-fixtures-in-prod"]) {
-            const projectRoot = getProjectRoot57();
+            const projectRoot = getProjectRoot58();
             const matches = await scanTestFixturesInProd(projectRoot);
             const dryRun = args["dry-run"] !== false && args.quarantine !== true;
             const quarantined = !dryRun && matches.length > 0 ? await quarantineTestFixtures(projectRoot, matches) : void 0;
@@ -66562,7 +68058,7 @@ var init_doctor = __esm({
             progress.complete("Comprehensive diagnostics complete");
           } else if (args["scan-rogue-cleo-dirs"]) {
             progress.step(0, "Scanning for rogue .cleo/ directories");
-            const projectRoot = getProjectRoot57();
+            const projectRoot = getProjectRoot58();
             const reports = scanRogueCleoDirs(projectRoot);
             progress.complete(
               `Found ${reports.length} rogue .cleo/ director${reports.length === 1 ? "y" : "ies"}`
@@ -66571,7 +68067,7 @@ var init_doctor = __esm({
           } else if (args["quarantine-rogue-cleo-dirs"]) {
             const isDryRun = args["dry-run"] === true;
             progress.step(0, `${isDryRun ? "[DRY RUN] " : ""}Scanning for rogue .cleo/ directories`);
-            const projectRoot = getProjectRoot57();
+            const projectRoot = getProjectRoot58();
             const reports = scanRogueCleoDirs(projectRoot);
             if (reports.length === 0) {
               progress.complete("No rogue .cleo/ directories found \u2014 nothing to quarantine");
@@ -66625,7 +68121,7 @@ var init_doctor = __esm({
             const { detectAndRemoveLegacyGlobalFiles, detectAndRemoveStrayProjectNexus } = await import("@cleocode/core/store/cleanup-legacy.js");
             const { getCleoHome: getCleoHome8 } = await import("@cleocode/core");
             const cleoHome = getCleoHome8();
-            const projectRoot = getProjectRoot57();
+            const projectRoot = getProjectRoot58();
             const legacyResult = detectAndRemoveLegacyGlobalFiles(cleoHome);
             const strayResult = detectAndRemoveStrayProjectNexus(projectRoot);
             const isDryRun = args["dry-run"] === true;
@@ -66658,7 +68154,7 @@ var init_doctor = __esm({
           } else if (args["audit-worktree-orphans"]) {
             progress.step(0, "Comprehensive worktree anomaly audit (T9808 / council D009)");
             const { auditWorktreeOrphansComprehensive, scanWorktreeOrphansBudgeted } = await import("@cleocode/core/doctor/worktree-orphans.js");
-            const projectRoot = getProjectRoot57();
+            const projectRoot = getProjectRoot58();
             const timeoutSecs = args["timeout"] !== void 0 ? Number.parseInt(String(args["timeout"]), 10) : 30;
             const timeoutMs = Number.isFinite(timeoutSecs) && timeoutSecs > 0 ? timeoutSecs * 1e3 : 3e4;
             const maxEntriesPerLevel = args["max-entries-per-level"] !== void 0 ? Number.parseInt(String(args["max-entries-per-level"]), 10) : 500;
@@ -66715,7 +68211,7 @@ var init_doctor = __esm({
               `${isDryRun ? "[DRY RUN] " : ""}Scanning + pruning worktree-orphan .cleo/ directories`
             );
             const { pruneWorktreeOrphans, scanWorktreeOrphansBudgeted } = await import("@cleocode/core/doctor/worktree-orphans.js");
-            const projectRoot = getProjectRoot57();
+            const projectRoot = getProjectRoot58();
             const timeoutSecs = args["timeout"] !== void 0 ? Number.parseInt(String(args["timeout"]), 10) : 30;
             const timeoutMs = Number.isFinite(timeoutSecs) && timeoutSecs > 0 ? timeoutSecs * 1e3 : 3e4;
             const maxEntriesPerLevel = args["max-entries-per-level"] !== void 0 ? Number.parseInt(String(args["max-entries-per-level"]), 10) : 500;
@@ -66794,7 +68290,7 @@ var init_doctor = __esm({
               `${isDryRun ? "[DRY RUN] " : ""}Migrating .cleo/worktree-include \u2192 .worktreeinclude`
             );
             const { migrateWorktreeIncludeFile } = await import("@cleocode/core");
-            const projectRoot = getProjectRoot57();
+            const projectRoot = getProjectRoot58();
             const result = await migrateWorktreeIncludeFile(projectRoot, { dryRun: isDryRun });
             progress.complete(`Migration ${result.action}`);
             cliOutput(result, { command: "doctor", operation: "doctor.migrate-worktree-include" });
@@ -66813,7 +68309,7 @@ var init_doctor = __esm({
             const stepLabel = isFocusedAlias ? "Auditing Saga hierarchy for ADR-073 invariants" : "Walking central INVARIANTS_REGISTRY";
             progress.step(0, stepLabel);
             const { auditInvariantRegistry } = await import("@cleocode/core/doctor/invariant-audit.js");
-            const projectRoot = getProjectRoot57();
+            const projectRoot = getProjectRoot58();
             const result = await auditInvariantRegistry(projectRoot, { adrFilter });
             const operation = isFocusedAlias ? "doctor.audit-sagas" : "doctor.audit-invariants";
             const summary = `Invariant audit complete \u2014 ${result.totalCount} entries walked, ${result.errorCount} error / ${result.warningCount} warning / ${result.infoCount} info violation(s), ${result.notApplicableCount} not-applicable, ${result.documentedCount} documented`;
@@ -66835,7 +68331,7 @@ var init_doctor = __esm({
               { command: "doctor", operation: "admin.health" }
             );
             try {
-              const projectRoot = getProjectRoot57();
+              const projectRoot = getProjectRoot58();
               const conflicts = readMigrationConflicts(projectRoot);
               if (conflicts.length > 0) {
                 progress.complete(
@@ -66866,7 +68362,7 @@ var init_doctor = __esm({
               progress.complete("Health check complete");
             }
             try {
-              const projectRoot = getProjectRoot57();
+              const projectRoot = getProjectRoot58();
               const { auditSagaHierarchy } = await import("@cleocode/core/doctor/saga-audit.js");
               const sagaAudit = await auditSagaHierarchy(projectRoot);
               if (sagaAudit.sagas.length === 0) {
@@ -66895,7 +68391,7 @@ Saga Hierarchy: audit skipped (${msg})`);
             }
             try {
               const { scanDependencyCycles: scanDependencyCycles2 } = await import("@cleocode/core/doctor/dependency-cycles.js");
-              const cycles = await scanDependencyCycles2(getProjectRoot57());
+              const cycles = await scanDependencyCycles2(getProjectRoot58());
               humanLine(
                 `
 Dependency cycles: ${cycles.cycleCount} (${cycles.edgeCount} edge(s) checked)`
@@ -67006,14 +68502,14 @@ var init_done = __esm({
           process.exitCode = 2;
           return;
         }
-        const { getProjectRoot: getProjectRoot75 } = await import("@cleocode/core/paths.js");
-        const options = { projectRoot: getProjectRoot75(), ...parsed.options };
+        const { getProjectRoot: getProjectRoot76 } = await import("@cleocode/core/paths.js");
+        const options = { projectRoot: getProjectRoot76(), ...parsed.options };
         const requested = [
           ...new Set([args.taskId, ...args._ ?? []].map(String))
         ];
-        const invalid = requested.filter((id) => !/^T\d+$/.test(id));
-        if (invalid.length > 0) {
-          cliError(`Not task ids: ${invalid.join(", ")} (expected T<digits>)`, "E_INVALID_INPUT");
+        const invalid2 = requested.filter((id) => !/^T\d+$/.test(id));
+        if (invalid2.length > 0) {
+          cliError(`Not task ids: ${invalid2.join(", ")} (expected T<digits>)`, "E_INVALID_INPUT");
           process.exitCode = 2;
           return;
         }
@@ -67277,8 +68773,8 @@ var init_event = __esm({
           }
           for (const file of filesToTail) {
             const agentId = file.replace(".jsonl", "");
-            const { readFileSync: readFileSync22 } = await import("node:fs");
-            const content = readFileSync22(join26(eventsDir, file), "utf-8");
+            const { readFileSync: readFileSync23 } = await import("node:fs");
+            const content = readFileSync23(join26(eventsDir, file), "utf-8");
             const eventLines = content.trim().split("\n").filter(Boolean);
             const tail = eventLines.slice(-lines);
             if (jsonMode) {
@@ -67373,8 +68869,8 @@ var init_event = __esm({
         const printAgentLog = async (file) => {
           const agentId = file.replace(".jsonl", "");
           try {
-            const { readFileSync: readFileSync22 } = await import("node:fs");
-            const content = readFileSync22(join26(eventsDir, file), "utf-8");
+            const { readFileSync: readFileSync23 } = await import("node:fs");
+            const content = readFileSync23(join26(eventsDir, file), "utf-8");
             const eventLines = content.trim().split("\n").filter(Boolean);
             const tail = eventLines.slice(-lines);
             if (jsonMode) {
@@ -67559,7 +69055,7 @@ function showStatus() {
   }
   cliOutput(result, { command: "exodus status" });
 }
-var migrateSubCommand, verifySubCommand, sealSubCommand, statusSubCommand, exodusCommand;
+var migrateSubCommand, verifySubCommand, sealSubCommand, statusSubCommand2, exodusCommand;
 var init_exodus = __esm({
   "packages/cleo/src/cli/commands/exodus.ts"() {
     "use strict";
@@ -67869,7 +69365,7 @@ Passing tables (${passing.length}):`);
         );
       }
     });
-    statusSubCommand = defineCommand({
+    statusSubCommand2 = defineCommand({
       meta: {
         name: "status",
         description: "Show exodus migration status (staging, source DBs, target DBs)"
@@ -67887,7 +69383,7 @@ Passing tables (${passing.length}):`);
         migrate: migrateSubCommand,
         verify: verifySubCommand,
         seal: sealSubCommand,
-        status: statusSubCommand
+        status: statusSubCommand2
       },
       async run({ cmd, rawArgs }) {
         if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
@@ -68369,7 +69865,7 @@ __export(gateway_exports, {
   gatewayOpenapiSubCommand: () => gatewayOpenapiSubCommand
 });
 import { resolve as resolve8 } from "node:path";
-import { generateOpenApi, getProjectRoot as getProjectRoot58 } from "@cleocode/core";
+import { generateOpenApi, getProjectRoot as getProjectRoot59 } from "@cleocode/core";
 var gatewayOpenapiSubCommand, gatewayCommand;
 var init_gateway = __esm({
   "packages/cleo/src/cli/commands/gateway.ts"() {
@@ -68401,7 +69897,7 @@ var init_gateway = __esm({
         const pathCount = Object.keys(doc.paths).length;
         if (typeof args.out === "string" && args.out.length > 0) {
           const { writeFileSync: writeFileSync8 } = await import("node:fs");
-          const target = resolve8(getProjectRoot58(), args.out);
+          const target = resolve8(getProjectRoot59(), args.out);
           writeFileSync8(target, json2, "utf8");
           cliOutput(
             { out: target, pathCount, version: doc.info.version, openapi: doc.openapi },
@@ -68862,7 +70358,7 @@ var go_exports = {};
 __export(go_exports, {
   goCommand: () => goCommand
 });
-import { getProjectRoot as getProjectRoot59, go } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot60, go } from "@cleocode/core";
 var goCommand;
 var init_go = __esm({
   "packages/cleo/src/cli/commands/go.ts"() {
@@ -68888,7 +70384,7 @@ var init_go = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot59();
+        const projectRoot = getProjectRoot60();
         const { getCurrentSessionId, resolveBoundSessionId } = await import("@cleocode/core/internal");
         let sessionId = getCurrentSessionId(projectRoot) ?? void 0;
         if (sessionId === void 0) {
@@ -68916,7 +70412,7 @@ var goal_exports = {};
 __export(goal_exports, {
   goalCommand: () => goalCommand
 });
-import { getProjectRoot as getProjectRoot60, goal } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot61, goal } from "@cleocode/core";
 function resolveGoalKind(task) {
   if (typeof task === "string" && task.length > 0) {
     if (!isValidGoalTargetTaskId(task)) {
@@ -68963,7 +70459,7 @@ var init_goal2 = __esm({
         }
         const record = await goal.createGoal(
           { goalKind: kindResult.kind, intent, turnBudget: resolveTurnBudget(args.turns) },
-          getProjectRoot60()
+          getProjectRoot61()
         );
         cliOutput(record, { command: "goal set", operation: "goal.set" });
       }
@@ -68974,7 +70470,7 @@ var init_goal2 = __esm({
         description: "Show the current agent's active goal (per-agent scoped)."
       },
       async run() {
-        const record = await goal.getActiveGoal(getProjectRoot60());
+        const record = await goal.getActiveGoal(getProjectRoot61());
         cliOutput(record ?? { active: null }, { command: "goal status", operation: "goal.status" });
       }
     });
@@ -68996,7 +70492,7 @@ var init_goal2 = __esm({
           });
           return;
         }
-        const cwd = getProjectRoot60();
+        const cwd = getProjectRoot61();
         const parent = await goal.getActiveGoal(cwd);
         if (!parent) {
           cliError(
@@ -69044,7 +70540,7 @@ var init_goal2 = __esm({
           });
           return;
         }
-        const cwd = getProjectRoot60();
+        const cwd = getProjectRoot61();
         const result = await goal.advanceGoalWithPersist(goalId, { cwd });
         if (!result) {
           cliError(`Goal '${goalId}' not found.`, 4 /* NOT_FOUND */, { name: "E_NOT_FOUND" });
@@ -69069,7 +70565,7 @@ var init_goal2 = __esm({
           });
           return;
         }
-        const cwd = getProjectRoot60();
+        const cwd = getProjectRoot61();
         const active = await goal.getActiveGoal(cwd);
         if (!active) {
           cliError(
@@ -70111,12 +71607,422 @@ var init_history = __esm({
   }
 });
 
+// packages/cleo/src/cli/hook-entry.ts
+var hook_entry_exports = {};
+__export(hook_entry_exports, {
+  HEAVY_HOOK_PROVIDERS: () => HEAVY_HOOK_PROVIDERS,
+  claudeGuardedBashRules: () => claudeGuardedBashRules,
+  claudeRuleFiles: () => claudeRuleFiles,
+  codexGuardedWords: () => codexGuardedWords,
+  guardedHeavyCommand: () => guardedHeavyCommand,
+  heavyCommandHook: () => heavyCommandHook,
+  heavyHookContext: () => heavyHookContext,
+  heavyHookWaitBudget: () => heavyHookWaitBudget,
+  heavyRuleWords: () => heavyRuleWords,
+  parseHookInput: () => parseHookInput,
+  processHookIo: () => processHookIo,
+  renderHeavyHookAnswer: () => renderHeavyHookAnswer,
+  runHookCli: () => runHookCli
+});
+import { readdirSync as readdirSync3, readFileSync as readFileSync12 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join28 } from "node:path";
+async function readProcessStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of process.stdin) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    size += buf.length;
+    if (size > MAX_STDIN_BYTES) return "";
+    chunks.push(buf);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function processHookIo() {
+  return {
+    readStdin: readProcessStdin,
+    writeStdout: (text) => process.stdout.write(text),
+    // stdout-discipline-allowed: PreToolUse hook protocol, the harness parses this JSON (not LAFS, not rendered output) // stdout-write-allowed: PreToolUse hook protocol output read raw by the harness
+    writeStderr: (text) => process.stderr.write(text),
+    env: process.env,
+    cwd: process.cwd()
+  };
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseHookInput(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!isRecord4(raw)) return null;
+  const toolInput = raw.tool_input;
+  if (!isRecord4(toolInput) || typeof toolInput.command !== "string") return null;
+  const toolName = typeof raw.tool_name === "string" ? raw.tool_name : void 0;
+  if (toolName !== void 0 && !/^(bash|shell|exec_command)$/i.test(toolName)) return null;
+  const str3 = (v) => typeof v === "string" ? v : void 0;
+  return {
+    ...toolName === void 0 ? {} : { tool_name: toolName },
+    tool_input: { ...toolInput, command: toolInput.command },
+    ...str3(raw.cwd) === void 0 ? {} : { cwd: str3(raw.cwd) },
+    ...str3(raw.permission_mode) === void 0 ? {} : { permission_mode: str3(raw.permission_mode) }
+  };
+}
+function positiveMs(value) {
+  const n = value === void 0 ? Number.NaN : Number(value);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : void 0;
+}
+function heavyHookWaitBudget(provider, toolInput, env = {}) {
+  if (toolInput.run_in_background === true) return {};
+  if (provider !== "claude-code" && provider !== "opencode") {
+    return { waitTimeoutSec: DEFAULT_WAIT_SEC };
+  }
+  const fromEnv = provider === "claude-code";
+  const def = (fromEnv ? positiveMs(env.BASH_DEFAULT_TIMEOUT_MS) : void 0) ?? BASH_DEFAULT_MS;
+  const max = Math.max(
+    (fromEnv ? positiveMs(env.BASH_MAX_TIMEOUT_MS) : void 0) ?? BASH_MAX_MS,
+    def
+  );
+  const asked = typeof toolInput.timeout === "number" && toolInput.timeout > 0 ? toolInput.timeout : def;
+  const effective = Math.min(asked, max);
+  const room = Math.floor((max - effective) / 1e3);
+  const waitTimeoutSec = Math.max(
+    MIN_WAIT_SEC,
+    Math.min(MAX_WAIT_SEC, Math.round(effective / 1e3), room)
+  );
+  return { waitTimeoutSec, timeoutMs: Math.min(max, effective + waitTimeoutSec * 1e3) };
+}
+function heavyHookContext(plan, pressure, provider = "claude-code") {
+  const lines = [];
+  const governed = plan.action === "none" ? "" : plan.segments.map((s) => s.governed).join(" ; ");
+  if (plan.action === "rewrite" && provider === "kimi") {
+    lines.push(
+      `[cleo] Not run: heavy commands share the machine-wide resource budget. Re-run it as: ${plan.command}`
+    );
+  } else if (plan.action === "rewrite") {
+    lines.push(
+      `[cleo] Routed heavy work through the machine-wide budget: ${governed}. cleo run passes the command its stdin, stdout, stderr and exit code; exit 75 means it was not admitted before the wait ran out (E_RESOURCE_DEFERRED on stderr lists holders and ways forward).`
+    );
+  } else if (plan.action === "warn") {
+    lines.push(
+      `[cleo] Heavy command not rewritten because ${plan.reason}. Run it governed so it shares the machine-wide budget: ${governed}`
+    );
+  }
+  if (pressure !== null) lines.push(pressure);
+  return lines.join("\n");
+}
+function demote(plan, reason) {
+  return plan.action === "rewrite" ? { action: "warn", reason, segments: plan.segments } : plan;
+}
+function renderHeavyHookAnswer(provider, toolInput, plan, context, timeoutMs) {
+  if (plan.action === "none" && context === "") return "";
+  const rewrite = plan.action === "rewrite";
+  if (provider === "opencode") {
+    const answer = {
+      ...rewrite ? { command: plan.command } : {},
+      ...rewrite && timeoutMs !== void 0 ? { timeout: timeoutMs } : {},
+      ...context === "" ? {} : { context }
+    };
+    return `${JSON.stringify(answer)}
+`;
+  }
+  if (provider === "kimi") {
+    if (!rewrite) return `${context}
+`;
+    const deny = {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: context
+      }
+    };
+    return `${JSON.stringify(deny)}
+`;
+  }
+  const updatedInput = rewrite ? {
+    ...toolInput,
+    command: plan.command,
+    ...provider === "claude-code" && timeoutMs !== void 0 ? { timeout: timeoutMs } : {}
+  } : void 0;
+  const output2 = {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      ...rewrite && provider === "codex" ? { permissionDecision: "allow" } : {},
+      ...updatedInput === void 0 ? {} : { updatedInput },
+      ...context === "" ? {} : { additionalContext: context }
+    }
+  };
+  return `${JSON.stringify(output2)}
+`;
+}
+function wordBase(word) {
+  return word.split("/").pop() ?? word;
+}
+function heavyRuleWords(argv) {
+  const out = [];
+  for (const w of argv) {
+    if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(w) || w.startsWith("-") || /^\d+$/.test(w)) continue;
+    out.push(wordBase(w));
+    if (out.length === 4) break;
+  }
+  return out;
+}
+function ruleWords(pattern) {
+  return pattern.split(/[\s:*()]+/).filter((w) => w !== "" && !w.startsWith("-")).map(wordBase);
+}
+function claudeRuleFiles(projectDir, env) {
+  const managed = process.platform === "darwin" ? "/Library/Application Support/ClaudeCode/managed-settings.json" : process.platform === "win32" ? "C:\\Program Files\\ClaudeCode\\managed-settings.json" : "/etc/claude-code/managed-settings.json";
+  const configDir = env.CLAUDE_CONFIG_DIR || join28(env.HOME || homedir3(), ".claude");
+  return [
+    managed,
+    join28(configDir, "settings.json"),
+    join28(projectDir, ".claude", "settings.json"),
+    join28(projectDir, ".claude", "settings.local.json")
+  ];
+}
+function claudeGuardedBashRules(files) {
+  const patterns = [];
+  let unreadable = null;
+  for (const file of files) {
+    let raw;
+    try {
+      raw = JSON.parse(readFileSync12(file, "utf-8"));
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") unreadable ??= file;
+      continue;
+    }
+    const permissions = isRecord4(raw) ? raw.permissions : void 0;
+    if (!isRecord4(permissions)) continue;
+    for (const key of ["deny", "ask"]) {
+      const rules = permissions[key];
+      if (!Array.isArray(rules)) continue;
+      for (const rule2 of rules) {
+        if (typeof rule2 !== "string") continue;
+        const trimmed = rule2.trim();
+        if (trimmed === "Bash") {
+          patterns.push("*");
+          continue;
+        }
+        const match = /^Bash\((.*)\)$/s.exec(trimmed);
+        if (match?.[1] !== void 0) patterns.push(match[1]);
+      }
+    }
+  }
+  return { patterns, unreadable };
+}
+function codexGuardedWords(projectDir, env) {
+  const home = env.CODEX_HOME || join28(env.HOME || homedir3(), ".codex");
+  const out = [];
+  for (const dir of [join28(home, "rules"), join28(projectDir, ".codex", "rules")]) {
+    let names;
+    try {
+      names = readdirSync3(dir).filter((n) => n.endsWith(".rules"));
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      let text;
+      try {
+        text = readFileSync12(join28(dir, name), "utf-8");
+      } catch {
+        continue;
+      }
+      if (!/decision\s*=\s*["'](forbidden|prompt)["']/.test(text)) continue;
+      for (const m of text.matchAll(/"([^"\\]*)"|'([^'\\]*)'/g)) {
+        for (const w of ruleWords(m[1] ?? m[2] ?? "")) out.push(w);
+      }
+    }
+  }
+  return out;
+}
+function guardedHeavyCommand(provider, segments, projectDir, env, files = claudeRuleFiles(projectDir, env)) {
+  let rules;
+  if (provider === "claude-code") {
+    const found = claudeGuardedBashRules(files);
+    if (found.unreadable !== null) return { kind: "unreadable", file: found.unreadable };
+    rules = found.patterns.map(ruleWords);
+    if (rules.some((words) => words.length === 0)) return { kind: "all" };
+  } else if (provider === "codex") {
+    const words = codexGuardedWords(projectDir, env);
+    rules = words.length === 0 ? [] : [words];
+  } else {
+    return null;
+  }
+  for (const segment of segments) {
+    const words = heavyRuleWords(segment.argv);
+    const first = words[0];
+    if (first === void 0) continue;
+    for (const rule2 of rules) {
+      if (provider === "codex") {
+        const hit = words.slice(0, 3).find((w) => rule2.includes(w));
+        if (hit !== void 0) return { kind: "word", word: hit };
+        continue;
+      }
+      const lead = rule2[0];
+      if (lead !== void 0 && words.includes(lead)) return { kind: "word", word: lead };
+      if (rule2.includes(first)) return { kind: "word", word: first };
+    }
+  }
+  return null;
+}
+function providerProjectDir(provider, env) {
+  return provider === "claude-code" ? env.CLAUDE_PROJECT_DIR || void 0 : void 0;
+}
+async function heavyCommandHook(provider, stdin2, io) {
+  const envMode = io.env.CLEO_HEAVY_COMMAND_HOOK?.trim().toLowerCase();
+  if (envMode === "off") return "";
+  const input2 = parseHookInput(stdin2);
+  if (input2?.tool_input === void 0) return "";
+  const core2 = await import("@cleocode/core/resources/heavy-command.js");
+  const cwd = input2.cwd ?? io.cwd;
+  const budget = heavyHookWaitBudget(provider, input2.tool_input, io.env);
+  let plan = core2.planHeavyCommand(input2.tool_input.command, {
+    cwd,
+    ...budget.waitTimeoutSec === void 0 ? {} : { waitTimeoutSec: budget.waitTimeoutSec }
+  });
+  if (plan.action === "none") return "";
+  const projectRoot = providerProjectDir(provider, io.env) ?? core2.heavyHookProjectRoot(cwd);
+  const mode = core2.resolveHeavyHookMode(
+    envMode,
+    core2.isHeavyCommandHookMode(envMode) ? void 0 : await core2.configuredHeavyHookMode(projectRoot)
+  );
+  if (mode === "off") return "";
+  if (mode === "warn") {
+    plan = demote(
+      plan,
+      "the hook is in warn mode (CLEO_HEAVY_COMMAND_HOOK or resources.heavyCommandHook)"
+    );
+  }
+  if (!core2.executableOnPath("cleo", io.env.PATH)) plan = demote(plan, "`cleo` is not on PATH");
+  if (provider !== "kimi" && !REWRITE_MODES.has(input2.permission_mode ?? "")) {
+    plan = demote(
+      plan,
+      `rewriting it would change which permission rules match it, so the hook rewrites only in bypassPermissions or auto mode (this session: ${input2.permission_mode ?? "unknown"})`
+    );
+  }
+  if (plan.action === "rewrite") {
+    const hit = guardedHeavyCommand(provider, plan.segments, projectRoot, io.env);
+    const where = provider === "codex" ? "Codex rules" : "Claude Code settings";
+    if (hit?.kind === "word") {
+      plan = demote(
+        plan,
+        `a deny or ask rule in your ${where} names \`${hit.word}\`, and a rewrite would hide the command from it`
+      );
+    } else if (hit?.kind === "all") {
+      plan = demote(
+        plan,
+        `a deny or ask rule in your ${where} covers every Bash command, and a rewrite would hide the command from it`
+      );
+    } else if (hit?.kind === "unreadable") {
+      plan = demote(
+        plan,
+        `${hit.file} could not be read or parsed, so the hook cannot tell whether a deny or ask rule names the command`
+      );
+    }
+  }
+  const context = heavyHookContext(plan, await core2.heavyPressureNotice(), provider);
+  return renderHeavyHookAnswer(provider, input2.tool_input, plan, context, budget.timeoutMs);
+}
+async function runHookCli(argv, io = processHookIo()) {
+  const [name, ...rest] = argv;
+  if (name !== "heavy-command") {
+    io.writeStderr(USAGE);
+    return 1;
+  }
+  const flag = rest.findIndex((a) => a === "--provider" || a.startsWith("--provider="));
+  const value = flag === -1 ? "claude-code" : rest[flag]?.split("=")[1] ?? rest[flag + 1];
+  const provider = HEAVY_HOOK_PROVIDERS.find((p) => p === value);
+  if (provider === void 0) {
+    io.writeStderr(USAGE);
+    return 1;
+  }
+  try {
+    const answer = await heavyCommandHook(provider, await io.readStdin(), io);
+    if (answer !== "") io.writeStdout(answer);
+  } catch (err) {
+    io.writeStderr(
+      `[cleo hook] heavy-command skipped: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  return 0;
+}
+var HEAVY_HOOK_PROVIDERS, BASH_DEFAULT_MS, BASH_MAX_MS, MIN_WAIT_SEC, MAX_WAIT_SEC, DEFAULT_WAIT_SEC, REWRITE_MODES, MAX_STDIN_BYTES, USAGE;
+var init_hook_entry = __esm({
+  "packages/cleo/src/cli/hook-entry.ts"() {
+    "use strict";
+    HEAVY_HOOK_PROVIDERS = [
+      "claude-code",
+      "codex",
+      "kimi",
+      "opencode"
+    ];
+    BASH_DEFAULT_MS = 12e4;
+    BASH_MAX_MS = 6e5;
+    MIN_WAIT_SEC = 30;
+    MAX_WAIT_SEC = 300;
+    DEFAULT_WAIT_SEC = 60;
+    REWRITE_MODES = /* @__PURE__ */ new Set(["bypassPermissions", "auto"]);
+    MAX_STDIN_BYTES = 1024 * 1024;
+    USAGE = "usage: cleo hook heavy-command [--provider claude-code|codex|kimi|opencode] < hook-input.json\n";
+  }
+});
+
+// packages/cleo/src/cli/commands/hook.ts
+var hook_exports = {};
+__export(hook_exports, {
+  hookCommand: () => hookCommand
+});
+var heavyCommandSubcommand, hookCommand;
+var init_hook = __esm({
+  "packages/cleo/src/cli/commands/hook.ts"() {
+    "use strict";
+    init_define_cli_command();
+    heavyCommandSubcommand = defineCommand({
+      meta: {
+        name: "heavy-command",
+        description: "PreToolUse hook: route heavy shell commands (tests, builds, typechecks, installs) through cleo run. Reads the hook JSON on stdin; prints the harness answer."
+      },
+      args: {
+        provider: {
+          type: "string",
+          description: "Harness protocol to answer in: claude-code (default), codex, kimi, opencode"
+        }
+      },
+      async run({ args }) {
+        const { runHookCli: runHookCli2 } = await Promise.resolve().then(() => (init_hook_entry(), hook_entry_exports));
+        const provider = typeof args.provider === "string" ? args.provider : "claude-code";
+        process.exitCode = await runHookCli2(["heavy-command", "--provider", provider]);
+      }
+    });
+    hookCommand = defineCommand({
+      meta: {
+        name: "hook",
+        description: "Agent-harness hooks installed by cleo init/upgrade; stdout is the harness hook protocol, not LAFS: cleo hook heavy-command --provider claude-code|codex|kimi|opencode"
+      },
+      subCommands: {
+        "heavy-command": heavyCommandSubcommand
+      },
+      async run({ cmd, rawArgs }) {
+        const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+        if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+        await showUsage(cmd);
+      }
+    });
+  }
+});
+
 // packages/cleo/src/cli/commands/hygiene.ts
 var hygiene_exports = {};
 __export(hygiene_exports, {
   hygieneCommand: () => hygieneCommand
 });
-import { getProjectRoot as getProjectRoot61 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot62 } from "@cleocode/core";
 import { runSpawnReadinessHygieneCli } from "@cleocode/core/hygiene/validate-spawn-readiness.js";
 var hygieneCommand;
 var init_hygiene = __esm({
@@ -70145,7 +72051,7 @@ var init_hygiene = __esm({
             }
           },
           async run({ args }) {
-            const projectRoot = args["project-root"] || getProjectRoot61() || process.cwd();
+            const projectRoot = args["project-root"] || getProjectRoot62() || process.cwd();
             const worktreePath = args["worktree-path"];
             await runSpawnReadinessHygieneCli(projectRoot, worktreePath);
           }
@@ -70320,8 +72226,8 @@ __export(init_exports, {
   isCredentialPoolEmpty: () => isCredentialPoolEmpty,
   maybeNudgeFirstRunLogin: () => maybeNudgeFirstRunLogin
 });
-import { existsSync as existsSync16, readFileSync as readFileSync12 } from "node:fs";
-import { join as join28 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync13 } from "node:fs";
+import { join as join29 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import {
   CleoError as CleoError9,
@@ -70336,12 +72242,12 @@ import { getTemplatesByKind } from "@cleocode/core/templates/registry";
 function getGitignoreTemplate() {
   try {
     const thisFile = fileURLToPath5(import.meta.url);
-    const packageRoot = join28(thisFile, "..", "..", "..", "..");
-    const localTemplatePath = join28(packageRoot, "templates", "cleo-gitignore");
-    const monorepoTemplatePath = join28(packageRoot, "..", "..", "templates", "cleo-gitignore");
+    const packageRoot = join29(thisFile, "..", "..", "..", "..");
+    const localTemplatePath = join29(packageRoot, "templates", "cleo-gitignore");
+    const monorepoTemplatePath = join29(packageRoot, "..", "..", "templates", "cleo-gitignore");
     const templatePath = existsSync16(localTemplatePath) ? localTemplatePath : monorepoTemplatePath;
     if (existsSync16(templatePath)) {
-      return readFileSync12(templatePath, "utf-8");
+      return readFileSync13(templatePath, "utf-8");
     }
   } catch {
   }
@@ -71488,7 +73394,7 @@ var llm_cost_exports = {};
 __export(llm_cost_exports, {
   costCommand: () => costCommand
 });
-import { getProjectRoot as getProjectRoot62 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot63 } from "@cleocode/core/internal";
 import { computeCost } from "@cleocode/core/llm/usage-pricing";
 function resolveSessionId(raw) {
   if (raw === "current") {
@@ -71561,7 +73467,7 @@ var init_llm_cost = __esm({
           process.exit(6);
         }
         const sessionId = resolveSessionId(rawSessionId);
-        const projectRoot = getProjectRoot62(process.cwd());
+        const projectRoot = getProjectRoot63(process.cwd());
         let breakdown;
         try {
           breakdown = await loadSessionCostBreakdown(projectRoot, sessionId);
@@ -71660,8 +73566,8 @@ async function resolveDefaultModel(provider) {
       "@cleocode/core/llm/role-resolver.js"
     )
   ]);
-  const profile = await getProviderProfile2(provider);
-  return profile?.defaultModel ?? IMPLICIT_FALLBACK_MODEL;
+  const profile2 = await getProviderProfile2(provider);
+  return profile2?.defaultModel ?? IMPLICIT_FALLBACK_MODEL;
 }
 async function runLlmStream(opts) {
   const stdout2 = opts.stdout ?? process.stdout;
@@ -72519,14 +74425,8 @@ var init_log = __esm({
 // packages/cleo/src/cli/commands/logout.ts
 var logout_exports = {};
 __export(logout_exports, {
-  logoutCommand: () => logoutCommand,
-  nexusLogoutSummary: () => nexusLogoutSummary
+  logoutCommand: () => logoutCommand
 });
-function nexusLogoutSummary(r) {
-  if (!r.removedLocally) return `Not signed in to ${r.apiUrl}; nothing to do.`;
-  const server = r.revocation === "revoked" ? "session revoked" : r.revocation === "already-invalid" ? "session was already invalid" : "server-side revocation FAILED (the session ends when it expires)";
-  return `Signed out of ${r.apiUrl}: ${server}; local token deleted.`;
-}
 var logoutCommand;
 var init_logout = __esm({
   "packages/cleo/src/cli/commands/logout.ts"() {
@@ -72538,7 +74438,7 @@ var init_logout = __esm({
     logoutCommand = defineCommand({
       meta: {
         name: "logout",
-        description: "Sign out. cleo logout [nexus] revokes the Cleo Nexus session server-side and deletes the stored token; cleo logout <provider> [label] removes an LLM credential exactly like cleo auth remove (the label may be omitted when the provider has one credential)."
+        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)."
       },
       args: {
         target: {
@@ -72552,6 +74452,10 @@ var init_logout = __esm({
           required: false
         },
         "api-url": NEXUS_API_URL_ARG,
+        revoke: {
+          type: "boolean",
+          description: "Hard-revoke this device: destroys its key grant and burns the device id; the next login enrols a new device. Without it, logout signs the device out and keeps it for the next login."
+        },
         json: { type: "boolean", description: "Output as JSON envelope" }
       },
       async run({ args }) {
@@ -72566,17 +74470,7 @@ var init_logout = __esm({
           emitLlmCredentialRemoval(await removeLlmCredential(target, label), "logout", "logout.run");
           return;
         }
-        const { logoutFromNexus } = await import(
-          /* webpackIgnore: true */
-          "@cleocode/core/cloud/nexus-auth.js"
-        );
-        let result;
-        try {
-          result = await logoutFromNexus({ apiUrl: nexusApiUrlArg(a) });
-        } catch (err) {
-          failNexus(err, "logout.run");
-        }
-        emitNexusResult(result, nexusLogoutSummary(result), "logout", "logout.run");
+        await runNexusDeviceLogout(a);
       }
     });
   }
@@ -72950,7 +74844,7 @@ var memory_exports = {};
 __export(memory_exports, {
   memoryCommand: () => memoryCommand
 });
-import { getProjectRoot as getProjectRoot63 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot64 } from "@cleocode/core";
 import {
   getBrainDb as getBrainDb2,
   getDreamStatus,
@@ -73908,7 +75802,7 @@ var init_memory3 = __esm({
       },
       args: {},
       async run() {
-        const root = getProjectRoot63();
+        const root = getProjectRoot64();
         try {
           const result = await runConsolidation(root);
           cliOutput(result, { command: "memory-consolidate", operation: "memory.consolidate" });
@@ -73932,7 +75826,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot63();
+        const root = getProjectRoot64();
         if (args.status) {
           try {
             const status = await getDreamStatus(root);
@@ -73969,7 +75863,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot63();
+        const root = getProjectRoot64();
         try {
           const { runObserver, runReflector } = await import("@cleocode/core/memory");
           const observerResult = await runObserver(root, args.session, {
@@ -74009,7 +75903,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot63();
+        const root = getProjectRoot64();
         await getBrainDb2(root);
         const { getBrainNativeDb: getBrainNativeDb3 } = await import("@cleocode/core/internal");
         const nativeDb = getBrainNativeDb3();
@@ -74047,7 +75941,7 @@ var init_memory3 = __esm({
       },
       async run({ args }) {
         const core2 = await import("@cleocode/core/internal");
-        const nexusDb = await core2.getNexusDb(getProjectRoot63());
+        const nexusDb = await core2.getNexusDb(getProjectRoot64());
         const result = args.restore ? await core2.restorePrunedTraits(
           nexusDb,
           String(args.restore),
@@ -74077,7 +75971,7 @@ var init_memory3 = __esm({
           return;
         }
         const core2 = await import("@cleocode/core/internal");
-        const nexusDb = await core2.getNexusDb(getProjectRoot63());
+        const nexusDb = await core2.getNexusDb(getProjectRoot64());
         const previous = await core2.setUserProfileTraitScope(nexusDb, String(args.key), scope);
         if (previous === null) {
           cliError(`No user-profile trait "${args.key}"`, "E_NOT_FOUND", { name: "E_NOT_FOUND" });
@@ -74101,7 +75995,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot63();
+        const root = getProjectRoot64();
         try {
           await getBrainDb2(root);
           const { totalDuplicateRows, groups } = await scanDuplicateEntries();
@@ -74147,7 +76041,7 @@ var init_memory3 = __esm({
       async run({ args }) {
         const sourceDir = args.from;
         const isDryRun = !!args["dry-run"];
-        const projectRoot = getProjectRoot63();
+        const projectRoot = getProjectRoot64();
         try {
           const result = await importMemoryFiles({
             sourceDir,
@@ -74298,7 +76192,7 @@ var init_memory3 = __esm({
       },
       args: {},
       async run() {
-        const root = getProjectRoot63();
+        const root = getProjectRoot64();
         try {
           await getBrainDb2(root);
           const result = await getTierStats(root);
@@ -74341,7 +76235,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot63();
+        const root = getProjectRoot64();
         const targetTier = args.to;
         const reason = args.reason;
         const validTiers = ["medium", "long"];
@@ -74407,7 +76301,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot63();
+        const root = getProjectRoot64();
         const targetTier = args.to;
         const reason = args.reason;
         const validTiers = ["short", "medium"];
@@ -74880,7 +76774,7 @@ var migrate_claude_mem_exports = {};
 __export(migrate_claude_mem_exports, {
   migrateClaudeMemCommand: () => migrateClaudeMemCommand
 });
-import { getProjectRoot as getProjectRoot64, migrateClaudeMem } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot65, migrateClaudeMem } from "@cleocode/core/internal";
 import { ingestLooseAgentOutputs, ingestRcasdDirectories } from "@cleocode/core/memory";
 import { getDb as getDb2 } from "@cleocode/core/store/sqlite";
 var storageCommand, claudeMemCommand, manifestIngestCommand, migrateClaudeMemCommand;
@@ -74943,7 +76837,7 @@ var init_migrate_claude_mem = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot64();
+        const root = getProjectRoot65();
         try {
           const result = await migrateClaudeMem(root, {
             sourcePath: args.source,
@@ -74992,7 +76886,7 @@ var init_migrate_claude_mem = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot64();
+        const projectRoot = getProjectRoot65();
         try {
           const db = await getDb2(projectRoot);
           const rcasdFlag = Boolean(args.rcasd);
@@ -75110,7 +77004,7 @@ __export(nexus_exports, {
 import { statSync as statSync2 } from "node:fs";
 import { appendFile as appendFile2, mkdir as mkdir5 } from "node:fs/promises";
 import path4 from "node:path";
-import { getProjectRoot as getProjectRoot65 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot66 } from "@cleocode/core";
 import { getSymbolImpact } from "@cleocode/core/nexus";
 import { runNexusAnalysis } from "@cleocode/core/nexus/analyze-orchestrator.js";
 import {
@@ -75281,7 +77175,7 @@ var init_nexus3 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         const startTime = Date.now();
         if (args.path) {
           let isDir = false;
@@ -75341,7 +77235,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648), so the coun
           process.exitCode = 2 /* INVALID_INPUT */;
           return;
         }
-        const currentRoot = getProjectRoot65();
+        const currentRoot = getProjectRoot66();
         if (args.path && path4.resolve(repoPath) !== path4.resolve(currentRoot)) {
           cliError(
             `nexus status cannot report on '${repoPath}' from this project.
@@ -75519,9 +77413,9 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
       args: {},
       async run() {
         try {
-          const { homedir: homedir4 } = await import("node:os");
+          const { homedir: homedir5 } = await import("node:os");
           const { installNexusAugmentHook } = await import("@cleocode/core/internal");
-          const homeDir = homedir4();
+          const homeDir = homedir5();
           installNexusAugmentHook(homeDir);
           cliOutput({ homeDir }, { command: "nexus-setup", operation: "nexus.setup" });
         } catch (err) {
@@ -75895,7 +77789,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "clusters", { projectId, repoPath });
         const durationMs = Date.now() - startTime;
@@ -75939,7 +77833,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "flows", { projectId, repoPath });
         const durationMs = Date.now() - startTime;
@@ -75982,7 +77876,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
         void appendDeprecationTelemetry("nexus.context", "cleo graph context");
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = getProjectRoot65();
+        const repoPath = getProjectRoot66();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const limit = parseInt(args.limit, 10);
         const symbolName = args.symbol;
@@ -76045,7 +77939,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
         const startTime = Date.now();
         const whyFlag = !!args.why;
         const projectIdOverride = args["project-id"];
-        const repoPath = getProjectRoot65();
+        const repoPath = getProjectRoot66();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const maxDepth = Math.min(parseInt(args.depth, 10), 5);
         const symbolName = args.symbol;
@@ -76149,7 +78043,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
         const projectIdOverride = args["project-id"];
         const full = !!args.full;
         const ctx = getFormatContext();
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         if (args.incremental)
           humanWarn(
             "[nexus] --incremental is deprecated and has no effect: incremental is the default."
@@ -76279,7 +78173,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         const name = args.name;
         const response = await dispatchRaw("mutate", "nexus", "projects.register", {
           path: repoPath,
@@ -76798,7 +78692,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("mutate", "nexus", "refresh-bridge", {
           repoPath,
@@ -76904,7 +78798,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         const projectIdOverride = args["project-id"];
         const beforeRef = args.before ?? "HEAD~1";
         const afterRef = args.after ?? "HEAD";
@@ -77022,7 +78916,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "route-map", { projectId });
         const durationMs = Date.now() - startTime;
@@ -77078,7 +78972,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
         const startTime = Date.now();
         const routeSymbol = args.routeSymbol;
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "shape-check", { routeSymbol, projectId });
         const durationMs = Date.now() - startTime;
@@ -77474,7 +79368,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         const projectIdOverride = args["project-id"];
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("mutate", "nexus", "contracts-sync", {
@@ -77584,7 +79478,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot65();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot66();
         const projectId = Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("mutate", "nexus", "contracts-link-tasks", {
           projectId,
@@ -77668,7 +79562,7 @@ The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store p
         const isIncremental = !!args.incremental;
         try {
           const result = await runNexusWiki({
-            projectRoot: getProjectRoot65(),
+            projectRoot: getProjectRoot66(),
             outputDir,
             communityFilter,
             incremental: isIncremental
@@ -78018,7 +79912,7 @@ __export(orchestrate_exports, {
 });
 import { execFileSync as execFileSync5 } from "node:child_process";
 import { orchestration } from "@cleocode/core";
-import { BUILD_CONFIG as BUILD_CONFIG2, getProjectRoot as getProjectRoot66 } from "@cleocode/core/internal";
+import { BUILD_CONFIG as BUILD_CONFIG2, getProjectRoot as getProjectRoot67 } from "@cleocode/core/internal";
 function formatRollupTable(rollup) {
   const waves = "waves" in rollup ? rollup.waves : [rollup];
   const lines = [];
@@ -78161,7 +80055,7 @@ var init_orchestrate3 = __esm({
       },
       async run({ args }) {
         const rateWindowHours = args.window !== void 0 ? Number.parseFloat(String(args.window)) : void 0;
-        const metrics = await orchestration.collectOrchestrateDashboard(getProjectRoot66(), {
+        const metrics = await orchestration.collectOrchestrateDashboard(getProjectRoot67(), {
           ...rateWindowHours !== void 0 && Number.isFinite(rateWindowHours) && rateWindowHours > 0 ? { rateWindowHours } : {}
         });
         cliOutput(metrics, {
@@ -79621,7 +81515,7 @@ __export(project_exports, {
 import { resolve as resolve9 } from "node:path";
 import {
   CleoError as CleoError11,
-  getProjectRoot as getProjectRoot67,
+  getProjectRoot as getProjectRoot68,
   moveProject,
   projectLifecycle,
   renameProject,
@@ -79643,7 +81537,7 @@ function emitEngineFailure(error, operation) {
 }
 function resolveRootOrFail(operation) {
   try {
-    return getProjectRoot67();
+    return getProjectRoot68();
   } catch (err) {
     const code = err instanceof CleoError11 && typeof err.details?.["code"] === "string" ? err.details["code"] : "E_NOT_CLEO_PROJECT";
     emitEngineFailure(
@@ -79874,6 +81768,10 @@ var init_project = __esm({
           type: "string",
           description: "Name shown in Nexus, sent in plaintext (default: the project name). A name, never a path."
         },
+        rebind: {
+          type: "boolean",
+          description: "Use only after E_NEXUS_REPLICA_COPIED: give this copy of the project a new replica id before attaching it (this machine was re-enrolled, or the store was copied). Each run mints a new id and leaves the old one on the server as stale history."
+        },
         "api-url": NEXUS_API_URL_ARG,
         json: { type: "boolean", description: "Output raw JSON envelope.", default: false }
       },
@@ -79886,14 +81784,17 @@ var init_project = __esm({
         try {
           result = await linkProjectToNexus({
             apiUrl: nexusApiUrlArg(args),
-            ...typeof args["label"] === "string" && args["label"] ? { label: args["label"] } : {}
+            ...typeof args["label"] === "string" && args["label"] ? { label: args["label"] } : {},
+            ...args["rebind"] === true ? { rebind: true } : {}
           });
         } catch (err) {
           failNexus(err, "project.link");
         }
-        const { link } = result;
+        const { link, replica } = result;
         const verb = result.alreadyLinked ? "Already linked" : "Linked";
-        const summary = `${verb}: project ${link.localProjectId} as "${link.label ?? ""}" on ${link.apiUrl}.`;
+        const attached = replica ? ` This machine (device ${replica.deviceId}) holds it as replica ${replica.replicaId}${replica.reboundFrom ? ` (rebound from ${replica.reboundFrom})` : ""}${replica.presenceAt ? "; presence reported" : ""}.` : "";
+        const summary = `${verb}: project ${link.localProjectId} as "${link.label ?? ""}" on ${link.apiUrl}.${attached}`;
+        writeNexusWarnings(result.warnings);
         emitNexusResult(result, summary, "project", "project.link");
       }
     });
@@ -80471,7 +82372,7 @@ var refresh_memory_exports = {};
 __export(refresh_memory_exports, {
   refreshMemoryCommand: () => refreshMemoryCommand
 });
-import { getProjectRoot as getProjectRoot68 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot69 } from "@cleocode/core";
 var refreshMemoryCommand;
 var init_refresh_memory = __esm({
   "packages/cleo/src/cli/commands/refresh-memory.ts"() {
@@ -80484,7 +82385,7 @@ var init_refresh_memory = __esm({
         description: "Regenerate .cleo/memory-bridge.md from brain.db"
       },
       async run() {
-        const projectDir = getProjectRoot68();
+        const projectDir = getProjectRoot69();
         const { writeMemoryBridge } = await import("@cleocode/core/internal");
         const result = await writeMemoryBridge(projectDir);
         if (result.written) {
@@ -82070,7 +83971,7 @@ import fs3 from "node:fs";
 import path5 from "node:path";
 import {
   CleoError as CleoError13,
-  getProjectRoot as getProjectRoot69,
+  getProjectRoot as getProjectRoot70,
   getTaskAccessor as getTaskAccessor3,
   parseConflictReport,
   setAtPath
@@ -82091,7 +83992,7 @@ var init_restore = __esm({
         description: "Apply manually-resolved conflicts from .cleo/restore-conflicts.md"
       },
       async run() {
-        const projectRoot = getProjectRoot69();
+        const projectRoot = getProjectRoot70();
         const reportPath = path5.join(projectRoot, CLEO_DIR_NAME3, RESTORE_CONFLICTS_MD);
         if (!fs3.existsSync(reportPath)) {
           humanLine("No pending restore conflicts. Nothing to finalize.");
@@ -82463,7 +84364,7 @@ __export(revert_exports, {
   revertCommand: () => revertCommand2
 });
 import { readFile as readFile8 } from "node:fs/promises";
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 import { cwd as processCwd2 } from "node:process";
 import { E_RECEIPT_NOT_FOUND } from "@cleocode/core/sentient/chain-walker.js";
 import { SENTIENT_STATE_FILE } from "@cleocode/core/sentient/daemon.js";
@@ -82516,7 +84417,7 @@ async function loadOwnerAttestation(attestationFilePath) {
   return obj;
 }
 async function loadOwnerPubkeys(projectRoot) {
-  const path6 = join29(projectRoot, OWNER_PUBKEYS_FILE);
+  const path6 = join30(projectRoot, OWNER_PUBKEYS_FILE);
   try {
     const raw = await readFile8(path6, "utf-8");
     const parsed = JSON.parse(raw);
@@ -82600,7 +84501,7 @@ var init_revert = __esm({
         if (attestation && allowedPubkeys.size > 0 && !allowedPubkeys.has(attestation.ownerPubkey)) {
           emitFailure2(
             E_OWNER_ATTESTATION_REQUIRED,
-            `Attestation pubkey "${attestation.ownerPubkey}" is not in the owner allowlist at ${join29(projectRoot, OWNER_PUBKEYS_FILE)}`,
+            `Attestation pubkey "${attestation.ownerPubkey}" is not in the owner allowlist at ${join30(projectRoot, OWNER_PUBKEYS_FILE)}`,
             jsonMode
           );
         }
@@ -82653,7 +84554,7 @@ ${lines}`
             identity,
             includeHuman
           });
-          const statePath = join29(projectRoot, SENTIENT_STATE_FILE);
+          const statePath = join30(projectRoot, SENTIENT_STATE_FILE);
           const state = await readSentientState(statePath);
           emitSuccess(
             {
@@ -82724,6 +84625,185 @@ var init_roadmap = __esm({
   }
 });
 
+// packages/cleo/src/cli/commands/run.ts
+var run_exports = {};
+__export(run_exports, {
+  runCommand: () => runCommand6,
+  runExitCode: () => runExitCode
+});
+import { constants } from "node:os";
+import {
+  canonicalForClass,
+  isWatchCommand,
+  resolveRunClass
+} from "@cleocode/core/resources/run-admission.js";
+import { runGoverned } from "@cleocode/core/resources/run-governed.js";
+import { heavyToolEnv } from "@cleocode/core/tasks/heavy-tool-env.js";
+function commandAfterDashes(rawArgs) {
+  const idx = rawArgs.indexOf("--");
+  return idx === -1 ? [] : rawArgs.slice(idx + 1);
+}
+function invalid(message, fix, stderr2) {
+  cliError(
+    message,
+    "E_VALIDATION",
+    { name: "E_VALIDATION", fix },
+    { operation: "resources.run" },
+    { stderr: stderr2 }
+  );
+  process.exit(6);
+}
+function runExitCode(r) {
+  if (r.spawnError !== null) return 127;
+  if (r.signal !== null) return 128 + (constants.signals[r.signal] ?? 0);
+  return r.exitCode ?? 1;
+}
+function exitFailed(result, code, passthrough) {
+  const { kind: _kind, ...data } = result;
+  const message = result.spawnError !== null ? `could not start command: ${result.spawnError}` : `command ${result.signal !== null ? `killed by ${result.signal}` : `exited with ${result.exitCode}`}`;
+  if (passthrough && result.spawnError === null) {
+    process.stderr.write(`[cleo run] ${RUN_COMMAND_FAILED_CODE}: ${message}
+`);
+  } else {
+    cliError(
+      message,
+      RUN_COMMAND_FAILED_CODE,
+      { name: RUN_COMMAND_FAILED_CODE, details: data },
+      { operation: "resources.run" },
+      { stderr: passthrough }
+    );
+  }
+  process.exit(code);
+}
+var runCommand6;
+var init_run = __esm({
+  "packages/cleo/src/cli/commands/run.ts"() {
+    "use strict";
+    init_src2();
+    init_define_cli_command();
+    init_renderers();
+    runCommand6 = defineCommand({
+      meta: {
+        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...>"
+      },
+      args: {
+        class: {
+          type: "string",
+          description: "Resource class: test, build, typecheck, install, scan, full-build, db (default: inferred from the command)"
+        },
+        wait: {
+          type: "boolean",
+          description: "Join the FIFO queue for the class instead of returning E_RESOURCE_DEFERRED",
+          default: false
+        },
+        timeout: {
+          type: "string",
+          description: "With --wait: give up after this many seconds (default 1800)"
+        },
+        passthrough: {
+          type: "boolean",
+          description: "Give the command this process's stdin, stdout and stderr and exit with its code. cleo run then writes nothing to stdout (an explicit ADR-086 exception, like docs fetch --content): its own envelopes go to stderr, and it prints only a deferral (exit 75), an ungoverned run, a pause or a failure",
+          default: false
+        }
+      },
+      async run({ args, rawArgs }) {
+        const passthrough = args.passthrough === true;
+        const argv = commandAfterDashes(rawArgs ?? []);
+        if (argv.length === 0) {
+          invalid(
+            "cleo run needs a command after --",
+            "cleo run --class test -- npx vitest run path/to/file.test.ts",
+            passthrough
+          );
+        }
+        if (args.class === void 0 && isWatchCommand(argv)) {
+          invalid(
+            `cleo run refuses watch/dev/serve commands, which never exit and would hold a resource slot forever: ${argv.join(" ")}`,
+            "Run the watcher directly, without cleo run. If it is a bounded job, say so with --class (cleo run --class test -- <cmd>)",
+            passthrough
+          );
+        }
+        let timeoutMs = 18e5;
+        if (args.timeout !== void 0) {
+          if (!args.wait)
+            invalid("--timeout requires --wait", "cleo run --wait --timeout 600 -- <cmd>", passthrough);
+          const seconds = Number(args.timeout);
+          if (!Number.isFinite(seconds) || seconds <= 0) {
+            invalid(
+              `--timeout must be a positive number of seconds (got '${args.timeout}')`,
+              "--timeout 600",
+              passthrough
+            );
+          }
+          timeoutMs = seconds * 1e3;
+        }
+        let cls;
+        try {
+          cls = resolveRunClass(args.class, argv, process.cwd());
+        } catch (err) {
+          invalid(
+            err instanceof Error ? err.message : String(err),
+            "cleo run --class test -- <cmd>",
+            passthrough
+          );
+        }
+        let result;
+        try {
+          result = await runGoverned({
+            argv,
+            cls,
+            cwd: process.cwd(),
+            env: { ...process.env, ...heavyToolEnv(canonicalForClass(cls)) },
+            sessionId: process.env.CLEO_SESSION_ID ?? process.env.CLAUDE_CODE_SESSION_ID ?? null,
+            wait: Boolean(args.wait),
+            timeoutMs,
+            passthrough,
+            // A terminal on stdin: keep the child in its foreground group.
+            foreground: passthrough && process.stdin.isTTY === true,
+            // Notices go to stderr; stdout carries only the final LAFS envelope, or
+            // with --passthrough only the child's output (and then only warnings).
+            notice: (line, level) => {
+              if (passthrough && level === "info") return;
+              process.stderr.write(`[cleo run] ${line}
+`);
+            }
+          });
+        } catch (err) {
+          cliError(
+            `cleo run failed: ${err instanceof Error ? err.message : String(err)}`,
+            1,
+            { name: "E_GENERAL" },
+            { operation: "resources.run" },
+            { stderr: passthrough }
+          );
+          process.exit(1);
+        }
+        if (result.kind === "deferred") {
+          cliError(
+            `not started: ${result.reason}`,
+            RESOURCE_DEFERRED_CODE,
+            {
+              name: RESOURCE_DEFERRED_CODE,
+              details: result.details,
+              fix: result.fix,
+              alternatives: result.alternatives
+            },
+            { operation: "resources.run" },
+            { stderr: passthrough }
+          );
+          process.exit(RUN_DEFERRED_EXIT_CODE);
+        }
+        const code = runExitCode(result);
+        if (code !== 0) exitFailed(result, code, passthrough);
+        if (passthrough) return;
+        const { kind: _kind, ...data } = result;
+        cliOutput(data, { command: "run", operation: "resources.run" });
+      }
+    });
+  }
+});
+
 // packages/cleo/src/cli/commands/safestop.ts
 var safestop_exports = {};
 __export(safestop_exports, {
@@ -83020,8 +85100,8 @@ var init_saga = __esm({
         }
       },
       async run({ args }) {
-        const { sagas: sagas2, getProjectRoot: getProjectRoot75 } = await import("@cleocode/core");
-        const projectRoot = getProjectRoot75();
+        const { sagas: sagas2, getProjectRoot: getProjectRoot76 } = await import("@cleocode/core");
+        const projectRoot = getProjectRoot76();
         const sagaId = typeof args.sagaId === "string" && args.sagaId.length > 0 ? args.sagaId : void 0;
         const result = await sagas2.sagaNext(projectRoot, { sagaId });
         cliOutput(result.success ? result.data : result, { command: "saga", operation: "saga.next" });
@@ -83235,7 +85315,7 @@ __export(self_update_exports, {
 });
 import { execFile } from "node:child_process";
 import { readFile as readFile9 } from "node:fs/promises";
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 import * as readline3 from "node:readline";
 import { promisify } from "node:util";
 import {
@@ -83250,7 +85330,7 @@ import {
 async function getCurrentVersion() {
   const cleoHome = getCleoHome7();
   try {
-    const content = await readFile9(join30(cleoHome, "VERSION"), "utf-8");
+    const content = await readFile9(join31(cleoHome, "VERSION"), "utf-8");
     return (content.split("\n")[0] ?? "unknown").trim();
   } catch {
     return "unknown";
@@ -83304,7 +85384,7 @@ async function writeRuntimeVersionMetadata(mode, source, version) {
   ];
   await import("node:fs/promises").then(
     ({ writeFile: writeFile4, mkdir: mkdir7 }) => mkdir7(cleoHome, { recursive: true }).then(
-      () => writeFile4(join30(cleoHome, "VERSION"), `${lines.join("\n")}
+      () => writeFile4(join31(cleoHome, "VERSION"), `${lines.join("\n")}
 `, "utf-8")
     )
   );
@@ -83716,13 +85796,13 @@ var selfimprove_exports = {};
 __export(selfimprove_exports, {
   selfimproveCommand: () => selfimproveCommand
 });
-var runCommand6, selfimproveCommand;
+var runCommand7, selfimproveCommand;
 var init_selfimprove2 = __esm({
   "packages/cleo/src/cli/commands/selfimprove.ts"() {
     "use strict";
     init_cli();
     init_define_cli_command();
-    runCommand6 = defineCommand({
+    runCommand7 = defineCommand({
       meta: {
         name: "run",
         description: "Run ONE self-improvement loop iteration: boot a sandbox, replay a canned scenario, diff vs golden; on regression emit ONE leased DHQ row + ONE DRAFT PR. DEFAULT OFF \u2014 pass --execute to act (else DRY-RUN: replay + diff + report only)."
@@ -83767,7 +85847,7 @@ var init_selfimprove2 = __esm({
         description: "Self-improvement loop \u2014 replay a canned dogfood scenario, diff vs golden, and surface regressions as leased DHQ rows + DRAFT PRs. Default OFF (requires --execute to act)."
       },
       subCommands: {
-        run: runCommand6
+        run: runCommand7
       },
       async run({ cmd, rawArgs }) {
         const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
@@ -83785,7 +85865,7 @@ __export(sentient_exports, {
   promptAcceptExecution: () => promptAcceptExecution,
   sentientCommand: () => sentientCommand
 });
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 import { cwd as processCwd3, stdin, stdout } from "node:process";
 import { createInterface as createInterface4 } from "node:readline/promises";
 import {
@@ -83875,7 +85955,7 @@ var init_sentient3 = __esm({
             return;
           }
           if (dryRun) {
-            const statePath2 = join31(projectRoot, SENTIENT_STATE_FILE2);
+            const statePath2 = join32(projectRoot, SENTIENT_STATE_FILE2);
             const outcome = await safeRunTick({ projectRoot, statePath: statePath2, dryRun: true });
             emitSuccess2(
               { dryRun: true, outcome },
@@ -83991,7 +86071,7 @@ Logs:  ${logPath}`
         const jsonMode = args.json === true;
         const dryRun = args["dry-run"] === true;
         try {
-          const statePath = join31(projectRoot, SENTIENT_STATE_FILE2);
+          const statePath = join32(projectRoot, SENTIENT_STATE_FILE2);
           const outcome = await safeRunTick({ projectRoot, statePath, dryRun });
           emitSuccess2(
             { outcome, dryRun },
@@ -84083,7 +86163,7 @@ Logs:  ${logPath}`
             return;
           }
           await db.update(tasks).set({ status: "pending", updatedAt: now }).where(eq2(tasks.id, id)).run();
-          const statePath = join31(projectRoot, SENTIENT_STATE_FILE2);
+          const statePath = join32(projectRoot, SENTIENT_STATE_FILE2);
           const state = await readSentientState2(statePath);
           await patchSentientState(statePath, {
             tier2Stats: {
@@ -84179,7 +86259,7 @@ Logs:  ${logPath}`
             return;
           }
           await db.update(tasks).set({ status: "cancelled", cancellationReason: reason, cancelledAt: now, updatedAt: now }).where(eq2(tasks.id, id)).run();
-          const statePath = join31(projectRoot, SENTIENT_STATE_FILE2);
+          const statePath = join32(projectRoot, SENTIENT_STATE_FILE2);
           const state = await readSentientState2(statePath);
           await patchSentientState(statePath, {
             tier2Stats: {
@@ -84224,7 +86304,7 @@ Logs:  ${logPath}`
         const projectRoot = resolveProjectRoot5(args.project);
         const jsonMode = args.json === true;
         try {
-          const statePath = join31(projectRoot, SENTIENT_STATE_FILE2);
+          const statePath = join32(projectRoot, SENTIENT_STATE_FILE2);
           const outcome = await safeRunProposeTick({ projectRoot, statePath });
           emitSuccess2(
             { outcome },
@@ -84244,7 +86324,7 @@ Logs:  ${logPath}`
         const projectRoot = resolveProjectRoot5(args.project);
         const jsonMode = args.json === true;
         try {
-          const statePath = join31(projectRoot, SENTIENT_STATE_FILE2);
+          const statePath = join32(projectRoot, SENTIENT_STATE_FILE2);
           const updated = await patchSentientState(statePath, { tier2Enabled: true });
           emitSuccess2({ tier2Enabled: updated.tier2Enabled }, jsonMode, "Tier-2 proposals enabled");
         } catch (err) {
@@ -84263,7 +86343,7 @@ Logs:  ${logPath}`
         const projectRoot = resolveProjectRoot5(args.project);
         const jsonMode = args.json === true;
         try {
-          const statePath = join31(projectRoot, SENTIENT_STATE_FILE2);
+          const statePath = join32(projectRoot, SENTIENT_STATE_FILE2);
           const updated = await patchSentientState(statePath, { tier2Enabled: false });
           emitSuccess2({ tier2Enabled: updated.tier2Enabled }, jsonMode, "Tier-2 proposals disabled");
         } catch (err) {
@@ -84294,7 +86374,7 @@ Logs:  ${logPath}`
         const projectRoot = resolveProjectRoot5(args.project);
         const jsonMode = args.json === true;
         try {
-          const statePath = join31(projectRoot, SENTIENT_STATE_FILE2);
+          const statePath = join32(projectRoot, SENTIENT_STATE_FILE2);
           const state = await readSentientState2(statePath);
           emitSuccess2(
             {
@@ -84852,7 +86932,7 @@ var sequence_exports = {};
 __export(sequence_exports, {
   sequenceCommand: () => sequenceCommand
 });
-import { getProjectRoot as getProjectRoot70 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot71 } from "@cleocode/core/internal";
 var showCommand12, checkCommand7, repairCommand3, sequenceCommand;
 var init_sequence = __esm({
   "packages/cleo/src/cli/commands/sequence.ts"() {
@@ -84888,7 +86968,7 @@ var init_sequence = __esm({
       meta: { name: "repair", description: "Reset counter to max + 1 if behind" },
       async run() {
         const { repairSequence } = await import("@cleocode/core/internal");
-        const projectRoot = getProjectRoot70();
+        const projectRoot = getProjectRoot71();
         const repair = await repairSequence(projectRoot);
         const result = {
           repaired: repair.repaired,
@@ -85485,8 +87565,8 @@ var init_session4 = __esm({
         "audit-scope": { type: "string", description: "Audit log scope (global|local)" }
       },
       async run({ args }) {
-        const { detectSessionDrift, getProjectRoot: getProjectRoot75 } = await import("@cleocode/core");
-        const projectRoot = await getProjectRoot75();
+        const { detectSessionDrift, getProjectRoot: getProjectRoot76 } = await import("@cleocode/core");
+        const projectRoot = await getProjectRoot76();
         const scope = args["audit-scope"] === "local" ? "local" : "global";
         const report = await detectSessionDrift({ projectRoot, auditScope: scope });
         cliOutput(report, { command: "session drift", operation: "session.drift" });
@@ -87885,10 +89965,10 @@ var init_sync = __esm({
         }
       },
       async run({ args }) {
-        const { readFileSync: readFileSync22 } = await import("node:fs");
+        const { readFileSync: readFileSync23 } = await import("node:fs");
         let externalTasks;
         try {
-          externalTasks = JSON.parse(readFileSync22(args.file, "utf8"));
+          externalTasks = JSON.parse(readFileSync23(args.file, "utf8"));
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           cliError(`Failed to read or parse external tasks file: ${message}`, 2, {
@@ -88185,19 +90265,19 @@ var init_telemetry2 = __esm({
 });
 
 // packages/cleo/src/cli/commands/templates/lib.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync14 } from "node:fs";
 import { isAbsolute as isAbsolute3, resolve as resolve10 } from "node:path";
-import { getProjectRoot as getProjectRoot71 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot72 } from "@cleocode/core";
 import { resolveSourcePathAbsolute } from "@cleocode/core/templates/registry";
 function resolveProjectRoot6(raw) {
   if (typeof raw === "string" && raw.length > 0) {
     return isAbsolute3(raw) ? raw : resolve10(process.cwd(), raw);
   }
-  return getProjectRoot71();
+  return getProjectRoot72();
 }
 function readTemplateSource(entry) {
   const sourceAbsolute = resolveSourcePathAbsolute(entry);
-  return readFileSync13(sourceAbsolute, "utf8");
+  return readFileSync14(sourceAbsolute, "utf8");
 }
 function applySubstitution(entry, source) {
   if (entry.substitution === "static") {
@@ -88212,8 +90292,8 @@ var init_lib = __esm({
 });
 
 // packages/cleo/src/cli/commands/templates/diff.ts
-import { existsSync as existsSync17, readFileSync as readFileSync14 } from "node:fs";
-import { join as join32 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "node:fs";
+import { join as join33 } from "node:path";
 import { getTemplateById } from "@cleocode/core/templates/registry";
 function unifiedDiff(a, b) {
   const aLines = a.length === 0 ? [] : a.split("\n");
@@ -88283,7 +90363,7 @@ var init_diff = __esm({
         let rendered;
         try {
           projectRoot = resolveProjectRoot6(args["project"]);
-          installPath = join32(projectRoot, entry.installPath);
+          installPath = join33(projectRoot, entry.installPath);
           const source = readTemplateSource(entry);
           rendered = applySubstitution(entry, source).rendered;
         } catch (err) {
@@ -88311,7 +90391,7 @@ ${unifiedDiff("", rendered)}`
           process.exit(1 /* GENERAL_ERROR */);
           return;
         }
-        const current = readFileSync14(installPath, "utf8");
+        const current = readFileSync15(installPath, "utf8");
         const same = current === rendered;
         const result = {
           id,
@@ -88333,8 +90413,8 @@ ${unifiedDiff("", rendered)}`
 });
 
 // packages/cleo/src/cli/commands/templates/install.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync5, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "node:fs";
-import { dirname as dirname10, join as join33 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync5, readFileSync as readFileSync16, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname10, join as join34 } from "node:path";
 import { getTemplateById as getTemplateById2 } from "@cleocode/core/templates/registry";
 var templatesInstallCommand;
 var init_install = __esm({
@@ -88388,7 +90468,7 @@ var init_install = __esm({
         let substituted;
         try {
           projectRoot = resolveProjectRoot6(args["project"]);
-          installPath = join33(projectRoot, entry.installPath);
+          installPath = join34(projectRoot, entry.installPath);
           const source = readTemplateSource(entry);
           const sub = applySubstitution(entry, source);
           rendered = sub.rendered;
@@ -88402,7 +90482,7 @@ var init_install = __esm({
           return;
         }
         if (existsSync18(installPath)) {
-          const current = readFileSync15(installPath, "utf8");
+          const current = readFileSync16(installPath, "utf8");
           if (current === rendered) {
             const noopResult = {
               id,
@@ -88550,8 +90630,8 @@ var init_show3 = __esm({
 });
 
 // packages/cleo/src/cli/commands/templates/upgrade.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync6, readFileSync as readFileSync16, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname11, join as join34 } from "node:path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync6, readFileSync as readFileSync17, writeFileSync as writeFileSync7 } from "node:fs";
+import { dirname as dirname11, join as join35 } from "node:path";
 import { getTemplateById as getTemplateById4 } from "@cleocode/core/templates/registry";
 var templatesUpgradeCommand;
 var init_upgrade2 = __esm({
@@ -88613,7 +90693,7 @@ var init_upgrade2 = __esm({
         let rendered;
         try {
           projectRoot = resolveProjectRoot6(args["project"]);
-          installPath = join34(projectRoot, entry.installPath);
+          installPath = join35(projectRoot, entry.installPath);
           const source = readTemplateSource(entry);
           rendered = applySubstitution(entry, source).rendered;
         } catch (err) {
@@ -88626,7 +90706,7 @@ var init_upgrade2 = __esm({
         }
         const previewOnly = args["diff"] === true;
         const accept = args["accept"] === true;
-        const current = existsSync19(installPath) ? readFileSync16(installPath, "utf8") : null;
+        const current = existsSync19(installPath) ? readFileSync17(installPath, "utf8") : null;
         const diffBody = current === null ? "" : current === rendered ? "" : unifiedDiff(current, rendered);
         let outcome;
         let reason;
@@ -88850,7 +90930,7 @@ var testing_exports = {};
 __export(testing_exports, {
   testingCommand: () => testingCommand
 });
-var validateCommand9, checkCommand8, statusCommand18, coverageCommand, runCommand7, testingCommand;
+var validateCommand9, checkCommand8, statusCommand18, coverageCommand, runCommand8, testingCommand;
 var init_testing = __esm({
   "packages/cleo/src/cli/commands/testing.ts"() {
     "use strict";
@@ -88935,7 +91015,7 @@ var init_testing = __esm({
         );
       }
     });
-    runCommand7 = defineCommand({
+    runCommand8 = defineCommand({
       meta: { name: "run", description: "Run test suite" },
       args: {
         filter: {
@@ -88960,7 +91040,7 @@ var init_testing = __esm({
         check: checkCommand8,
         status: statusCommand18,
         coverage: coverageCommand,
-        run: runCommand7
+        run: runCommand8
       },
       async run({ cmd, rawArgs }) {
         const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
@@ -88976,12 +91056,12 @@ var token_exports = {};
 __export(token_exports, {
   tokenCommand: () => tokenCommand
 });
-import { readFileSync as readFileSync17 } from "node:fs";
-import { getProjectRoot as getProjectRoot72, measureTokenExchange, recordTokenExchange as recordTokenExchange2 } from "@cleocode/core/internal";
+import { readFileSync as readFileSync18 } from "node:fs";
+import { getProjectRoot as getProjectRoot73, measureTokenExchange, recordTokenExchange as recordTokenExchange2 } from "@cleocode/core/internal";
 function readPayload(args, textKey, fileKey) {
   const text = args[textKey];
   const file = args[fileKey];
-  if (file) return readFileSync17(file, "utf-8");
+  if (file) return readFileSync18(file, "utf-8");
   return text;
 }
 var filterArgs, summaryCommand3, listCommand26, showCommand16, deleteCommand3, clearCommand2, estimateCommand, tokenCommand;
@@ -89141,7 +91221,7 @@ var init_token = __esm({
           domain: args.domain,
           operation: args.operation
         };
-        const result = args.record ? await recordTokenExchange2(getProjectRoot72(), input2) : await measureTokenExchange(input2);
+        const result = args.record ? await recordTokenExchange2(getProjectRoot73(), input2) : await measureTokenExchange(input2);
         cliOutput(result, {
           command: "token",
           operation: args.record ? "admin.token.record" : "token.estimate"
@@ -89175,9 +91255,9 @@ var transcript_exports = {};
 __export(transcript_exports, {
   transcriptCommand: () => transcriptCommand
 });
-import { homedir as homedir3 } from "node:os";
-import { join as join35 } from "node:path";
-import { getProjectRoot as getProjectRoot73 } from "@cleocode/core";
+import { homedir as homedir4 } from "node:os";
+import { join as join36 } from "node:path";
+import { getProjectRoot as getProjectRoot74 } from "@cleocode/core";
 import {
   parseDurationMs,
   pruneTranscripts,
@@ -89207,7 +91287,7 @@ var init_transcript = __esm({
       async run({ args }) {
         if (args.pending) {
           try {
-            const projectRoot = getProjectRoot73();
+            const projectRoot = getProjectRoot74();
             const { scanPendingTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
             const pending = await scanPendingTranscripts(projectRoot);
             cliOutput(
@@ -89230,7 +91310,7 @@ var init_transcript = __esm({
           }
           return;
         }
-        const projectsDir = args["projects-dir"] ?? join35(homedir3(), ".claude", "projects");
+        const projectsDir = args["projects-dir"] ?? join36(homedir4(), ".claude", "projects");
         try {
           const result = await scanTranscripts(projectsDir);
           cliOutput(
@@ -89304,7 +91384,7 @@ var init_transcript = __esm({
       async run({ args }) {
         const tier = args.tier ?? "warm";
         const dryRun = args["dry-run"] ?? false;
-        const projectRoot = getProjectRoot73();
+        const projectRoot = getProjectRoot74();
         try {
           const { extractTranscript } = await import("@cleocode/core/memory/transcript-extractor.js");
           const { findSessionTranscriptPath, listAllTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
@@ -89420,7 +91500,7 @@ var init_transcript = __esm({
         const dryRun = args["dry-run"] ?? false;
         const olderThanHours = args["older-than-hours"] ? Number.parseInt(args["older-than-hours"], 10) : 24;
         const limit = args.limit ? Number.parseInt(args.limit, 10) : void 0;
-        const projectRoot = getProjectRoot73();
+        const projectRoot = getProjectRoot74();
         try {
           const { extractTranscript } = await import("@cleocode/core/memory/transcript-extractor.js");
           const { listAllTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
@@ -89540,7 +91620,7 @@ var init_transcript = __esm({
           process.exit(2);
           return;
         }
-        const projectsDir = args["projects-dir"] ?? join35(homedir3(), ".claude", "projects");
+        const projectsDir = args["projects-dir"] ?? join36(homedir4(), ".claude", "projects");
         try {
           const pruneResult = await pruneTranscripts({
             olderThanMs,
@@ -89607,10 +91687,10 @@ __export(gateway_auto_start_exports, {
   spawnGatewayIfDown: () => spawnGatewayIfDown
 });
 import { once } from "node:events";
-import { createWriteStream, existsSync as existsSync20, readFileSync as readFileSync18, realpathSync } from "node:fs";
+import { createWriteStream, existsSync as existsSync20, readFileSync as readFileSync19, realpathSync } from "node:fs";
 import { mkdir as mkdir6 } from "node:fs/promises";
 import * as net from "node:net";
-import { dirname as dirname12, join as join36 } from "node:path";
+import { dirname as dirname12, join as join37 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 import { spawnWrapped } from "@cleocode/core/resources/spawn-wrapper.js";
 function shouldAutoStartGateway(config) {
@@ -89654,17 +91734,17 @@ function resolveCliEntryPath(startUrl = import.meta.url) {
   const startFile = realpathSync(fileURLToPath6(startUrl));
   let current = dirname12(startFile);
   for (let i = 0; i < 20; i++) {
-    const pkgJsonPath = join36(current, "package.json");
+    const pkgJsonPath = join37(current, "package.json");
     if (existsSync20(pkgJsonPath)) {
       let pkgName;
       try {
-        const raw = readFileSync18(pkgJsonPath, "utf8");
+        const raw = readFileSync19(pkgJsonPath, "utf8");
         const parsed = JSON.parse(raw);
         pkgName = typeof parsed["name"] === "string" ? parsed["name"] : void 0;
       } catch {
       }
       if (pkgName === CLEO_PACKAGE_NAME) {
-        const entry = join36(current, "dist", "cli", "index.js");
+        const entry = join37(current, "dist", "cli", "index.js");
         if (!existsSync20(entry)) {
           throw new Error(
             `@cleocode/cleo package root found at ${current} but dist/cli/index.js is missing \u2014 run \`pnpm --filter @cleocode/cleo run build\` to generate it`
@@ -89701,8 +91781,8 @@ async function spawnGatewayIfDown(opts = {}) {
     const { getCleoLogDir } = await import("@cleocode/core");
     const logDir = getCleoLogDir();
     await mkdir6(logDir, { recursive: true });
-    const outStream = createWriteStream(join36(logDir, "gateway.log"), { flags: "a" });
-    const errStream = createWriteStream(join36(logDir, "gateway.err"), { flags: "a" });
+    const outStream = createWriteStream(join37(logDir, "gateway.log"), { flags: "a" });
+    const errStream = createWriteStream(join37(logDir, "gateway.err"), { flags: "a" });
     await Promise.all([once(outStream, "open"), once(errStream, "open")]);
     outFd = outStream;
     errFd = errStream;
@@ -90161,8 +92241,8 @@ __export(cockpit_exports, {
   KanbanBoardComponent: () => KanbanBoardComponent,
   runCockpit: () => runCockpit
 });
-import { readFileSync as readFileSync19 } from "node:fs";
-import { join as join37 } from "node:path";
+import { readFileSync as readFileSync20 } from "node:fs";
+import { join as join38 } from "node:path";
 import { createCleoClient as createCleoClient2 } from "@cleocode/core/gateway-client";
 async function fetchTaskRows(baseUrl) {
   const client = createCleoClient2({ baseUrl });
@@ -90279,8 +92359,8 @@ async function runCockpit(options = {}, sink = (line) => process.stdout.write(`$
     }
     try {
       const { getCleoLogDir } = await import("@cleocode/core");
-      const errPath = join37(getCleoLogDir(), "gateway.err");
-      const errContent = readFileSync19(errPath, "utf8").trimEnd();
+      const errPath = join38(getCleoLogDir(), "gateway.err");
+      const errContent = readFileSync20(errPath, "utf8").trimEnd();
       if (errContent.length > 0) {
         const lastLine = errContent.split("\n").at(-1) ?? "";
         if (lastLine.length > 0) {
@@ -91308,7 +93388,7 @@ var init_verify = __esm({
         },
         evidence: {
           type: "string",
-          description: "Evidence for the gate (T832/ADR-051). Semicolon-separated atoms: 'commit:<sha>', 'files:<p1,p2>', 'test-run:<json>', 'tool:<name>', 'url:<url>', 'note:<text>', 'ci:<pr>' (required CI green on the merged PR's merge commit; testsPassed/qaPassed, opt-in via evidence.ciSatisfies)."
+          description: "Evidence for the gate (T832/ADR-051). Semicolon-separated atoms: 'commit:<sha>', 'files:<p1,p2>', 'test-run:<json>', 'tool:<name>' (e.g. tool:test, tool:test-affected, tool:lint), 'url:<url>', 'note:<text>', 'ci:<pr>' (required CI green on the merged PR's merge commit; testsPassed/qaPassed, opt-in via evidence.ciSatisfies)."
         },
         explain: {
           type: "boolean",
@@ -91330,6 +93410,10 @@ var init_verify = __esm({
           type: "string",
           description: "With --auto: the merged PR that implements the task"
         },
+        fresh: {
+          type: "boolean",
+          description: "Bypass the ADR-061 tool cache and re-run every tool: atom (same as CLEO_EVIDENCE_FRESH=1, which still works). Use only when a cached result is suspect, e.g. after adding an untracked file (T12964)."
+        },
         "shared-evidence": {
           type: "boolean",
           description: "Acknowledge that the same evidence atom is applied to >3 distinct tasks in this session (T1502 / ADR-059). Without this flag, such reuse triggers a warning; in strict mode (CLEO_STRICT_EVIDENCE=1) it is a hard reject."
@@ -91341,76 +93425,85 @@ var init_verify = __esm({
           return;
         }
         const isWrite = !!(args.gate || args.all || args.reset);
-        if (args.auto === true) {
-          if (isWrite || args.evidence || args.run === true) {
-            cliError(
-              "--auto derives its own evidence; drop --gate/--all/--reset/--evidence/--run",
-              "E_INVALID_INPUT"
-            );
-            process.exitCode = 6 /* VALIDATION_ERROR */;
+        const priorFresh = process.env["CLEO_EVIDENCE_FRESH"];
+        if (args.fresh === true) process.env["CLEO_EVIDENCE_FRESH"] = "1";
+        try {
+          if (args.auto === true) {
+            if (isWrite || args.evidence || args.run === true) {
+              cliError(
+                "--auto derives its own evidence; drop --gate/--all/--reset/--evidence/--run",
+                "E_INVALID_INPUT"
+              );
+              process.exitCode = 6 /* VALIDATION_ERROR */;
+              return;
+            }
+            const { parseDoneOptions } = await import("@cleocode/core/tasks/done-plan.js");
+            const parsed = parseDoneOptions(args.satisfies, args.pr);
+            if (!parsed.ok) {
+              cliError(parsed.message, "E_INVALID_INPUT");
+              process.exitCode = 6 /* VALIDATION_ERROR */;
+              return;
+            }
+            const { recordTaskDone } = await import("@cleocode/core/tasks/done-record.js");
+            const { getProjectRoot: getProjectRoot76 } = await import("@cleocode/core/paths.js");
+            const r = await recordTaskDone(args.taskId, {
+              projectRoot: getProjectRoot76(),
+              ...parsed.options,
+              ...args.agent ? { agent: args.agent } : {}
+            });
+            if (!r.success) {
+              cliError(r.error.message, r.error.code, { fix: r.error.fix, details: r.error.details });
+              process.exitCode = r.error.exitCode ?? 1;
+              return;
+            }
+            const { plan: _plan, ...summary } = r.data;
+            cliOutput(summary, { command: "verify", operation: "check.gate.auto" });
             return;
           }
-          const { parseDoneOptions } = await import("@cleocode/core/tasks/done-plan.js");
-          const parsed = parseDoneOptions(args.satisfies, args.pr);
-          if (!parsed.ok) {
-            cliError(parsed.message, "E_INVALID_INPUT");
+          if (args.satisfies !== void 0 || args.pr !== void 0) {
+            cliError("--satisfies and --pr apply only with --auto (or cleo done)", "E_INVALID_INPUT");
             process.exitCode = 6 /* VALIDATION_ERROR */;
             return;
           }
-          const { recordTaskDone } = await import("@cleocode/core/tasks/done-record.js");
-          const { getProjectRoot: getProjectRoot75 } = await import("@cleocode/core/paths.js");
-          const r = await recordTaskDone(args.taskId, {
-            projectRoot: getProjectRoot75(),
-            ...parsed.options,
-            ...args.agent ? { agent: args.agent } : {}
-          });
-          if (!r.success) {
-            cliError(r.error.message, r.error.code, { fix: r.error.fix, details: r.error.details });
-            process.exitCode = r.error.exitCode ?? 1;
+          if (args.run === true && isWrite) {
+            cliError(
+              "--run reports typed gate results and records nothing; it cannot be combined with --gate/--all/--reset.",
+              6 /* VALIDATION_ERROR */,
+              {
+                name: "E_VALIDATION",
+                fix: "Run `cleo verify <id> --run` first, then attest with `cleo verify <id> --gate <name> --evidence <atoms>`"
+              },
+              { operation: "check.gate.run" }
+            );
+            process.exitCode = 6 /* VALIDATION_ERROR */;
             return;
           }
-          const { plan: _plan, ...summary } = r.data;
-          cliOutput(summary, { command: "verify", operation: "check.gate.auto" });
-          return;
-        }
-        if (args.satisfies !== void 0 || args.pr !== void 0) {
-          cliError("--satisfies and --pr apply only with --auto (or cleo done)", "E_INVALID_INPUT");
-          process.exitCode = 6 /* VALIDATION_ERROR */;
-          return;
-        }
-        if (args.run === true && isWrite) {
-          cliError(
-            "--run reports typed gate results and records nothing; it cannot be combined with --gate/--all/--reset.",
-            6 /* VALIDATION_ERROR */,
+          const useExplain = !isWrite && args.explain === true;
+          const operation = isWrite ? "gate.set" : args.run === true ? "gate.run" : useExplain ? "verify.explain" : "gate.status";
+          await dispatchFromCli(
+            isWrite ? "mutate" : "query",
+            "check",
+            operation,
             {
-              name: "E_VALIDATION",
-              fix: "Run `cleo verify <id> --run` first, then attest with `cleo verify <id> --gate <name> --evidence <atoms>`"
+              taskId: args.taskId,
+              gate: args.gate,
+              value: args.value === "false" ? false : args.gate ? true : void 0,
+              agent: args.agent,
+              all: args.all,
+              reset: args.reset,
+              evidence: args.evidence,
+              sharedEvidence: args["shared-evidence"] ?? false,
+              // T12621: citty turns `--no-run` into `run: false`; read it through the helper.
+              ...isWrite && negatedFlag(args, "run") ? { noRun: true } : {}
             },
-            { operation: "check.gate.run" }
+            { command: "verify" }
           );
-          process.exitCode = 6 /* VALIDATION_ERROR */;
-          return;
+        } finally {
+          if (args.fresh === true) {
+            if (priorFresh === void 0) delete process.env["CLEO_EVIDENCE_FRESH"];
+            else process.env["CLEO_EVIDENCE_FRESH"] = priorFresh;
+          }
         }
-        const useExplain = !isWrite && args.explain === true;
-        const operation = isWrite ? "gate.set" : args.run === true ? "gate.run" : useExplain ? "verify.explain" : "gate.status";
-        await dispatchFromCli(
-          isWrite ? "mutate" : "query",
-          "check",
-          operation,
-          {
-            taskId: args.taskId,
-            gate: args.gate,
-            value: args.value === "false" ? false : args.gate ? true : void 0,
-            agent: args.agent,
-            all: args.all,
-            reset: args.reset,
-            evidence: args.evidence,
-            sharedEvidence: args["shared-evidence"] ?? false,
-            // T12621: citty turns `--no-run` into `run: false`; read it through the helper.
-            ...isWrite && negatedFlag(args, "run") ? { noRun: true } : {}
-          },
-          { command: "verify" }
-        );
       }
     });
   }
@@ -91671,7 +93764,7 @@ var workgraph_exports = {};
 __export(workgraph_exports, {
   workgraphCommand: () => workgraphCommand
 });
-import { readFileSync as readFileSync20 } from "node:fs";
+import { readFileSync as readFileSync21 } from "node:fs";
 import { resolve as resolve12 } from "node:path";
 var validateCommand10, applyCommand, planCommand4, structureCommand, statusCommand20, workgraphCommand;
 var init_workgraph2 = __esm({
@@ -91696,7 +93789,7 @@ var init_workgraph2 = __esm({
         const filePath = resolve12(String(args.file));
         let raw;
         try {
-          raw = readFileSync20(filePath, "utf-8");
+          raw = readFileSync21(filePath, "utf-8");
         } catch {
           cliOutput2(
             { error: `Cannot read file: ${filePath}` },
@@ -91741,7 +93834,7 @@ var init_workgraph2 = __esm({
         const filePath = resolve12(String(args.file));
         let raw;
         try {
-          raw = readFileSync20(filePath, "utf-8");
+          raw = readFileSync21(filePath, "utf-8");
         } catch {
           cliOutput2(
             { error: `Cannot read file: ${filePath}` },
@@ -91783,9 +93876,9 @@ var init_workgraph2 = __esm({
       },
       async run({ args }) {
         const { generatePlanningDoc } = await import("@cleocode/core/workgraph");
-        const { getProjectRoot: getProjectRoot75 } = await import("@cleocode/core");
+        const { getProjectRoot: getProjectRoot76 } = await import("@cleocode/core");
         const { cliOutput: cliOutput2 } = await Promise.resolve().then(() => (init_renderers(), renderers_exports));
-        const projectRoot = getProjectRoot75();
+        const projectRoot = getProjectRoot76();
         const audience = String(args.audience) === "agent" ? "agent" : "maintainer";
         const result = await generatePlanningDoc(projectRoot, {
           sagaId: String(args.sagaId),
@@ -91802,9 +93895,9 @@ var init_workgraph2 = __esm({
       async run() {
         const { validateWorkGraphStructure } = await import("@cleocode/core/workgraph");
         const { taskList: taskList2 } = await import("@cleocode/core/internal");
-        const { getProjectRoot: getProjectRoot75 } = await import("@cleocode/core");
+        const { getProjectRoot: getProjectRoot76 } = await import("@cleocode/core");
         const { cliOutput: cliOutput2 } = await Promise.resolve().then(() => (init_renderers(), renderers_exports));
-        const projectRoot = getProjectRoot75();
+        const projectRoot = getProjectRoot76();
         const listResult = await taskList2(projectRoot, { limit: 5e3 });
         const tasks = listResult.success ? listResult.data?.tasks ?? [] : [];
         const nodes = tasks.map((t) => ({
@@ -91823,9 +93916,9 @@ var init_workgraph2 = __esm({
         description: "One-shot saga-to-saga workgraph dashboard (tracking checklist)"
       },
       async run() {
-        const { sagas: sagas2, getProjectRoot: getProjectRoot75 } = await import("@cleocode/core");
+        const { sagas: sagas2, getProjectRoot: getProjectRoot76 } = await import("@cleocode/core");
         const { cliOutput: cliOutput2 } = await Promise.resolve().then(() => (init_renderers(), renderers_exports));
-        const projectRoot = getProjectRoot75();
+        const projectRoot = getProjectRoot76();
         const listResult = await sagas2.sagaList(projectRoot);
         if (!listResult.success) {
           cliOutput2(listResult, { command: "workgraph", operation: "workgraph.status" });
@@ -91891,7 +93984,7 @@ __export(worktree_exports, {
   worktreeCommand: () => worktreeCommand
 });
 import readline4 from "node:readline";
-import { getProjectRoot as getProjectRoot74, listWorktrees as listWorktrees2 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot75, listWorktrees as listWorktrees2 } from "@cleocode/core/internal";
 async function promptYesNo2(question) {
   return new Promise((resolve13) => {
     const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
@@ -91996,7 +94089,7 @@ var init_worktree3 = __esm({
         const staleDays = staleDaysRaw !== void 0 ? Number.parseInt(staleDaysRaw, 10) : void 0;
         const idleDaysRaw = typeof args["idle-days"] === "string" ? args["idle-days"] : void 0;
         const idleDays = idleDaysRaw !== void 0 ? Number.parseInt(idleDaysRaw, 10) : void 0;
-        const projectRoot = getProjectRoot74();
+        const projectRoot = getProjectRoot75();
         const listResult = await listWorktrees2({
           projectRoot,
           ...staleDays !== void 0 && !Number.isNaN(staleDays) ? { staleDays } : {}
@@ -92235,8 +94328,8 @@ var init_worktree3 = __esm({
 
 // packages/cleo/src/cli/index.ts
 init_dist();
-import { readFileSync as readFileSync21 } from "node:fs";
-import { dirname as dirname13, join as join39 } from "node:path";
+import { readFileSync as readFileSync22 } from "node:fs";
+import { dirname as dirname13, join as join40 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
 import { enforceNodeVersion } from "@cleocode/paths";
 
@@ -92446,6 +94539,12 @@ var COMMAND_MANIFEST = [
     description: "Classify a task: readiness verdict (proceed|grill) + persona routing (agent, confidence)",
     load: async () => (await Promise.resolve().then(() => (init_classify(), classify_exports))).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 Promise.resolve().then(() => (init_cloud(), cloud_exports))).cloudCommand
+  },
   {
     exportName: "codeCommand",
     name: "code",
@@ -92674,6 +94773,12 @@ var COMMAND_MANIFEST = [
     description: "Audit the machine-wide memory guard that bounds test runs an agent starts OUTSIDE cleo ",
     load: async () => (await Promise.resolve().then(() => (init_doctor_memory_guard(), doctor_memory_guard_exports))).doctorMemoryGuardCommand
   },
+  {
+    exportName: "doctorMigrationsCommand",
+    name: "migrations",
+    description: "Report the migration journal of the project and global stores: row count, head, applied ",
+    load: async () => (await Promise.resolve().then(() => (init_doctor_migrations(), doctor_migrations_exports))).doctorMigrationsCommand
+  },
   {
     exportName: "doctorNexusResidencyCommand",
     name: "nexus-residency",
@@ -92866,6 +94971,12 @@ var COMMAND_MANIFEST = [
     description: "Completion timeline and productivity analytics",
     load: async () => (await Promise.resolve().then(() => (init_history(), history_exports))).historyCommand
   },
+  {
+    exportName: "hookCommand",
+    name: "hook",
+    description: "Agent-harness hooks installed by cleo init/upgrade; stdout is the harness hook protocol, not LAFS: cleo hook heavy-command --provider claude-code|codex|kimi|opencode",
+    load: async () => (await Promise.resolve().then(() => (init_hook(), hook_exports))).hookCommand
+  },
   {
     exportName: "hygieneCommand",
     name: "hygiene",
@@ -92971,7 +95082,7 @@ var COMMAND_MANIFEST = [
   {
     exportName: "logoutCommand",
     name: "logout",
-    description: "Sign out. cleo logout [nexus] revokes the Cleo Nexus session server-side and deletes the stored token; cleo logout <provider> [label] removes an LLM credential exactly like cleo auth remove (the label may be omitted when the provider has one credential).",
+    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 Promise.resolve().then(() => (init_logout(), logout_exports))).logoutCommand
   },
   {
@@ -93172,6 +95283,12 @@ var COMMAND_MANIFEST = [
     description: "Generate project roadmap from task provenance \u2014 epics grouped by status with progress",
     load: async () => (await Promise.resolve().then(() => (init_roadmap(), roadmap_exports))).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 Promise.resolve().then(() => (init_run(), run_exports))).runCommand
+  },
   {
     exportName: "safestopCommand",
     name: "safestop",
@@ -93579,12 +95696,12 @@ init_did_you_mean();
 
 // packages/cleo/src/cli/lib/first-run-detection.ts
 import { existsSync as existsSync21 } from "node:fs";
-import { join as join38 } from "node:path";
+import { join as join39 } 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 = join38(getCleoPlatformPaths().config, "config.json");
+  const configPath = join39(getCleoPlatformPaths().config, "config.json");
   if (existsSync21(configPath)) return false;
   try {
     const { getCredentialPool: getCredentialPool2 } = await import("@cleocode/core/llm/credential-pool.js");
@@ -93716,8 +95833,8 @@ async function resolveSubCommandForHelp(cmd, rawArgs) {
 init_summary_context();
 enforceNodeVersion();
 function getPackageVersion() {
-  const pkgPath = join39(dirname13(fileURLToPath7(import.meta.url)), "../../package.json");
-  const pkg = JSON.parse(readFileSync21(pkgPath, "utf-8"));
+  const pkgPath = join40(dirname13(fileURLToPath7(import.meta.url)), "../../package.json");
+  const pkg = JSON.parse(readFileSync22(pkgPath, "utf-8"));
   return pkg.version;
 }
 var CLI_VERSION = getPackageVersion();
@@ -93758,6 +95875,7 @@ async function startCli() {
   let describeFlag = false;
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i];
+    if (arg === "--") break;
     if (arg === "--json") rawOpts["json"] = true;
     else if (arg === "--human") rawOpts["human"] = true;
     else if (arg === "--quiet") rawOpts["quiet"] = true;
@@ -93968,7 +96086,7 @@ async function runStartupMaintenance() {
     detectAndRemoveStrayProjectNexus,
     getGlobalSalt,
     getLogger: getLogger22,
-    getProjectRoot: getProjectRoot75,
+    getProjectRoot: getProjectRoot76,
     isCleanupMarkerSet,
     isMissingProjectError,
     migrateSignaldockToConduit,
@@ -93978,7 +96096,7 @@ async function runStartupMaintenance() {
   } = await import("@cleocode/core/internal");
   let projectRootForCleanup = "";
   try {
-    projectRootForCleanup = getProjectRoot75();
+    projectRootForCleanup = getProjectRoot76();
   } catch {
   }
   if (!isCleanupMarkerSet(CLI_VERSION, projectRootForCleanup)) {
@@ -93998,7 +96116,7 @@ async function runStartupMaintenance() {
   const isInitInvocation = process.argv.slice(2).some((a) => a === "init");
   if (!isInitInvocation) {
     try {
-      const _projectRootForMigration = getProjectRoot75();
+      const _projectRootForMigration = getProjectRoot76();
       if (needsSignaldockToConduitMigration(_projectRootForMigration)) {
         const migrationResult = await migrateSignaldockToConduit(_projectRootForMigration);
         if (migrationResult.status === "failed") {