@cleocode/cleo 2026.4.129 → 2026.4.131

package/dist/cli/index.js

@@ -363,13 +363,72 @@ var init_attachment_schema = __esm({
 });
 
 // packages/contracts/src/branch-lock.ts
+var BRANCH_LOCK_ERROR_CODES;
 var init_branch_lock = __esm({
   "packages/contracts/src/branch-lock.ts"() {
     "use strict";
+    BRANCH_LOCK_ERROR_CODES = {
+      /** L2: git shim blocked a branch-mutating operation. */
+      E_GIT_OP_BLOCKED: "E_GIT_OP_BLOCKED",
+      /** L1: spawn attempted without a worktree handle. */
+      E_WORKTREE_REQUIRED: "E_WORKTREE_REQUIRED",
+      /** L1: worktree path does not exist or is not a valid git worktree. */
+      E_WORKTREE_INVALID: "E_WORKTREE_INVALID",
+      /** L1: cherry-pick failed during worktree.complete. */
+      E_CHERRY_PICK_FAILED: "E_CHERRY_PICK_FAILED",
+      /** L3: filesystem harden failed. */
+      E_FS_HARDEN_FAILED: "E_FS_HARDEN_FAILED",
+      /** L4a: HMAC token invalid or missing. */
+      E_OVERRIDE_TOKEN_INVALID: "E_OVERRIDE_TOKEN_INVALID",
+      /** L4b: caller has CLEO_AGENT_ROLE=worker|lead|subagent — override forbidden. */
+      E_OVERRIDE_FORBIDDEN_AGENT_ROLE: "E_OVERRIDE_FORBIDDEN_AGENT_ROLE",
+      /** L4c: override requires TTY but stdin/stderr is not a TTY. */
+      E_OVERRIDE_NEEDS_TTY: "E_OVERRIDE_NEEDS_TTY",
+      /** L4d: session override limit exceeded. */
+      E_OVERRIDE_RATE_LIMIT: "E_OVERRIDE_RATE_LIMIT"
+    };
   }
 });
 
 // packages/contracts/src/exit-codes.ts
+function isErrorCode(code) {
+  return code >= 1 && code < 100;
+}
+function isSuccessCode(code) {
+  return code === 0 || code >= 100;
+}
+function isNoChangeCode(code) {
+  return code === 102 /* NO_CHANGE */;
+}
+function isRecoverableCode(code) {
+  const nonRecoverable = /* @__PURE__ */ new Set([
+    3 /* FILE_ERROR */,
+    5 /* DEPENDENCY_ERROR */,
+    14 /* CIRCULAR_REFERENCE */,
+    18 /* CASCADE_FAILED */,
+    37 /* SESSION_CLOSE_BLOCKED */,
+    46 /* VERIFICATION_LOCKED */,
+    50 /* CONTEXT_WARNING */,
+    51 /* CONTEXT_CAUTION */,
+    52 /* CONTEXT_CRITICAL */,
+    53 /* CONTEXT_EMERGENCY */,
+    54 /* CONTEXT_STALE */,
+    64 /* AUTONOMOUS_BOUNDARY */,
+    65 /* HANDOFF_REQUIRED */,
+    72 /* NEXUS_PERMISSION_DENIED */,
+    75 /* NEXUS_REGISTRY_CORRUPT */,
+    82 /* CIRCULAR_VALIDATION */,
+    83 /* LIFECYCLE_TRANSITION_INVALID */,
+    85 /* ARTIFACT_TYPE_UNKNOWN */,
+    89 /* ARTIFACT_ROLLBACK_FAILED */,
+    93 /* DIGEST_MISMATCH */
+  ]);
+  if (!isErrorCode(code)) return false;
+  return !nonRecoverable.has(code);
+}
+function getExitCodeName(code) {
+  return ExitCode[code] ?? "UNKNOWN";
+}
 var ExitCode;
 var init_exit_codes = __esm({
   "packages/contracts/src/exit-codes.ts"() {
@@ -471,6 +530,18 @@ var init_exit_codes = __esm({
 });
 
 // packages/contracts/src/errors.ts
+function normalizeError(error, fallbackMessage = "An unexpected error occurred") {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "string") {
+    return new Error(error);
+  }
+  if (error !== null && typeof error === "object" && "message" in error && typeof error.message === "string") {
+    return new Error(error.message);
+  }
+  return new Error(fallbackMessage);
+}
 function getErrorMessage(error, fallback = "Unknown error") {
   if (error instanceof Error) {
     return error.message;
@@ -483,10 +554,87 @@ function getErrorMessage(error, fallback = "Unknown error") {
   }
   return fallback;
 }
+function formatError(error, context, includeStack = false) {
+  const message = getErrorMessage(error);
+  const prefix = context ? `[${context}] ` : "";
+  let result = `${prefix}${message}`;
+  if (includeStack && error instanceof Error && error.stack) {
+    result += `
+${error.stack}`;
+  }
+  return result;
+}
+function isErrorType(error, codeOrName) {
+  if (error instanceof Error) {
+    if (error.name === codeOrName) {
+      return true;
+    }
+    if ("code" in error && error.code === codeOrName) {
+      return true;
+    }
+  }
+  return false;
+}
+function createErrorResult(error) {
+  return {
+    success: false,
+    error: getErrorMessage(error)
+  };
+}
+function createSuccessResult() {
+  return { success: true };
+}
+function isErrorResult(result) {
+  return !result.success;
+}
+var ThinAgentViolationError, LifecycleScopeDeniedError;
 var init_errors = __esm({
   "packages/contracts/src/errors.ts"() {
     "use strict";
     init_exit_codes();
+    ThinAgentViolationError = class extends Error {
+      /**
+       * @param agentId - The offending agent's unique identifier.
+       * @param role - The offending agent's declared role (lead, worker, etc.).
+       * @param attemptedAction - The spawn action that was blocked.
+       */
+      constructor(agentId, role, attemptedAction) {
+        super(
+          `E_THIN_AGENT_VIOLATION: agent '${agentId}' (role=${role}) attempted '${attemptedAction}'. Only orchestrators may spawn. Escalate via playbook approval gate.`
+        );
+        this.agentId = agentId;
+        this.role = role;
+        this.attemptedAction = attemptedAction;
+        this.name = "ThinAgentViolationError";
+      }
+      agentId;
+      role;
+      attemptedAction;
+      /** Stable LAFS error code string for envelope emission. */
+      code = "E_THIN_AGENT_VIOLATION";
+      /** Numeric exit code aligned with {@link ExitCode.THIN_AGENT_VIOLATION}. */
+      exitCode = 68 /* THIN_AGENT_VIOLATION */;
+    };
+    LifecycleScopeDeniedError = class extends Error {
+      /**
+       * @param epicId      - The epic whose lifecycle mutation was blocked.
+       * @param sessionScope - Human-readable description of the current session scope.
+       */
+      constructor(epicId, sessionScope) {
+        super(
+          `E_LIFECYCLE_SCOPE_DENIED: lifecycle stage advancement for epic '${epicId}' requires a session scoped to that epic or an owner override. Current session scope: ${sessionScope}. Use CLEO_OWNER_OVERRIDE=1 if this is an authorized operation.`
+        );
+        this.epicId = epicId;
+        this.sessionScope = sessionScope;
+        this.name = "LifecycleScopeDeniedError";
+      }
+      epicId;
+      sessionScope;
+      /** Stable LAFS error code string for envelope emission. */
+      code = "E_LIFECYCLE_SCOPE_DENIED";
+      /** Numeric exit code aligned with {@link ExitCode.TASK_NOT_IN_SCOPE} (34). */
+      exitCode = 34 /* TASK_NOT_IN_SCOPE */;
+    };
   }
 });
 
@@ -553,13 +701,49 @@ var init_evidence_record_schema = __esm({
 });
 
 // packages/contracts/src/facade.ts
+var BRAIN_OBSERVATION_TYPES, AGENT_INSTANCE_STATUSES, AGENT_TYPES;
 var init_facade = __esm({
   "packages/contracts/src/facade.ts"() {
     "use strict";
+    BRAIN_OBSERVATION_TYPES = [
+      "discovery",
+      "change",
+      "feature",
+      "bugfix",
+      "decision",
+      "refactor",
+      "diary"
+    ];
+    AGENT_INSTANCE_STATUSES = [
+      "starting",
+      "active",
+      "idle",
+      "error",
+      "crashed",
+      "stopped"
+    ];
+    AGENT_TYPES = [
+      "orchestrator",
+      "executor",
+      "researcher",
+      "architect",
+      "validator",
+      "documentor",
+      "custom"
+    ];
   }
 });
 
 // packages/contracts/src/lafs.ts
+function isLafsSuccess(envelope) {
+  return envelope.success === true;
+}
+function isLafsError(envelope) {
+  return envelope.success === false;
+}
+function isGatewayEnvelope(envelope) {
+  return "_meta" in envelope && envelope._meta !== void 0;
+}
 var init_lafs = __esm({
   "packages/contracts/src/lafs.ts"() {
     "use strict";
@@ -720,6 +904,10 @@ var init_worktree = __esm({
 });
 
 // packages/contracts/src/operations/index.ts
+var operations_exports = {};
+__export(operations_exports, {
+  paramsToCittyArgs: () => paramsToCittyArgs
+});
 var init_operations = __esm({
   "packages/contracts/src/operations/index.ts"() {
     "use strict";
@@ -745,6 +933,21 @@ var init_operations = __esm({
 });
 
 // packages/contracts/src/peer.ts
+function isPeerIdentity(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  return typeof v["peerId"] === "string" && v["peerId"].length > 0 && typeof v["peerKind"] === "string" && ["orchestrator", "lead", "worker", "subagent"].includes(v["peerKind"]) && typeof v["cantFile"] === "string" && v["cantFile"].length > 0 && typeof v["displayName"] === "string" && typeof v["description"] === "string";
+}
+function assertPeerIdentity(value) {
+  if (!isPeerIdentity(value)) {
+    throw new TypeError(
+      `Expected PeerIdentity { peerId, peerKind, cantFile, displayName, description } \u2014 got: ${JSON.stringify(value)}`
+    );
+  }
+}
+function filterPeerIdentities(values) {
+  return values.filter(isPeerIdentity);
+}
 var init_peer = __esm({
   "packages/contracts/src/peer.ts"() {
     "use strict";
@@ -752,17 +955,222 @@ var init_peer = __esm({
 });
 
 // packages/contracts/src/session.ts
+var SessionView;
 var init_session2 = __esm({
   "packages/contracts/src/session.ts"() {
     "use strict";
+    SessionView = class _SessionView {
+      _sessions;
+      constructor(sessions2) {
+        this._sessions = sessions2;
+      }
+      /** Create a SessionView from a Session array. */
+      static from(sessions2) {
+        return new _SessionView(sessions2);
+      }
+      /** All sessions in the view (readonly). */
+      get all() {
+        return this._sessions;
+      }
+      /** Number of sessions. */
+      get length() {
+        return this._sessions.length;
+      }
+      /** Find the currently active session (if any). */
+      findActive() {
+        return this._sessions.find((s) => s.status === "active");
+      }
+      /** Find a session by ID. */
+      findById(id) {
+        return this._sessions.find((s) => s.id === id);
+      }
+      /** Filter sessions by one or more statuses. */
+      filterByStatus(...statuses) {
+        return this._sessions.filter((s) => statuses.includes(s.status));
+      }
+      /** Find sessions matching a scope type and optional rootTaskId. */
+      findByScope(type2, rootTaskId) {
+        return this._sessions.filter((s) => {
+          if (s.scope?.type !== type2) return false;
+          if (rootTaskId && s.scope?.rootTaskId !== rootTaskId) return false;
+          return true;
+        });
+      }
+      /** Sort sessions by a date field. Returns a new array (does not mutate). */
+      sortByDate(field, descending = true) {
+        return [...this._sessions].sort((a, b) => {
+          const aDate = new Date(a[field] || "").getTime();
+          const bDate = new Date(b[field] || "").getTime();
+          return descending ? bDate - aDate : aDate - bDate;
+        });
+      }
+      /** Get the most recently started session. */
+      mostRecent() {
+        if (this._sessions.length === 0) return void 0;
+        return this.sortByDate("startedAt", true)[0];
+      }
+      /** Convert back to a plain Session array (shallow copy). */
+      toArray() {
+        return [...this._sessions];
+      }
+      /** Support for-of iteration. */
+      [Symbol.iterator]() {
+        return this._sessions[Symbol.iterator]();
+      }
+    };
+  }
+});
+
+// packages/contracts/src/session-journal.ts
+import { z as z4 } from "zod";
+var SESSION_JOURNAL_SCHEMA_VERSION, sessionJournalDoctorSummarySchema, sessionJournalDebriefSummarySchema, sessionJournalEntrySchema;
+var init_session_journal = __esm({
+  "packages/contracts/src/session-journal.ts"() {
+    "use strict";
+    SESSION_JOURNAL_SCHEMA_VERSION = "1.0";
+    sessionJournalDoctorSummarySchema = z4.object({
+      /** `true` when zero noise patterns were detected. */
+      isClean: z4.boolean(),
+      /** Total number of noise findings across all patterns. */
+      findingsCount: z4.number().int().nonnegative(),
+      /** Pattern names that were detected (empty when isClean). */
+      patterns: z4.array(z4.string()),
+      /** Total brain entries scanned. `0` = empty or unavailable. */
+      totalScanned: z4.number().int().nonnegative()
+    });
+    sessionJournalDebriefSummarySchema = z4.object({
+      /** First 200 characters of the session end note (if provided). */
+      noteExcerpt: z4.string().max(200).optional(),
+      /** Number of tasks completed during the session. */
+      tasksCompletedCount: z4.number().int().nonnegative(),
+      /** Up to 5 task IDs (not titles) that were the focus of the session. */
+      tasksFocused: z4.array(z4.string()).max(5).optional()
+    });
+    sessionJournalEntrySchema = z4.object({
+      // Identity
+      /** Schema version for forward-compatibility. Always `'1.0'` in this release. */
+      schemaVersion: z4.literal(SESSION_JOURNAL_SCHEMA_VERSION),
+      /** ISO 8601 timestamp when the entry was written. */
+      timestamp: z4.string(),
+      /** CLEO session ID (e.g. `ses_20260424055456_ede571`). */
+      sessionId: z4.string(),
+      /** Event type that triggered this journal entry. */
+      eventType: z4.enum(["session_start", "session_end", "observation", "decision", "error"]),
+      // Session metadata (set on session_start / session_end)
+      /** Agent identifier (e.g. `cleo-prime`, `claude-code`). */
+      agentIdentifier: z4.string().optional(),
+      /** Provider adapter ID active for this session. */
+      providerId: z4.string().optional(),
+      /** Session scope string (e.g. `'global'` or `'epic:T1263'`). */
+      scope: z4.string().optional(),
+      // Session-end fields
+      /** Duration of the session in seconds (session_end only). */
+      duration: z4.number().int().nonnegative().optional(),
+      /** Task IDs (not titles) completed during the session. */
+      tasksCompleted: z4.array(z4.string()).optional(),
+      // Doctor summary (T1262 absorbed)
+      /** Compact result of `scanBrainNoise` run at session-end. */
+      doctorSummary: sessionJournalDoctorSummarySchema.optional(),
+      // Debrief summary
+      /** Compact excerpt from session debrief data. */
+      debriefSummary: sessionJournalDebriefSummarySchema.optional(),
+      // Optional hash chain
+      /** SHA-256 hex of the previous entry's raw JSON string (for integrity chain). */
+      prevEntryHash: z4.string().optional()
+    });
   }
 });
 
 // packages/contracts/src/status-registry.ts
-var TASK_STATUS_SYMBOLS_UNICODE, TASK_STATUS_SYMBOLS_ASCII;
+function isValidStatus(entityType, value) {
+  return STATUS_REGISTRY[entityType].includes(value);
+}
+var TASK_STATUSES, SESSION_STATUSES, LIFECYCLE_PIPELINE_STATUSES, LIFECYCLE_STAGE_STATUSES, ADR_STATUSES, GATE_STATUSES, MANIFEST_STATUSES, TERMINAL_TASK_STATUSES, TERMINAL_PIPELINE_STATUSES, TERMINAL_STAGE_STATUSES, STATUS_REGISTRY, PIPELINE_STATUS_ICONS, STAGE_STATUS_ICONS, TASK_STATUS_SYMBOLS_UNICODE, TASK_STATUS_SYMBOLS_ASCII;
 var init_status_registry = __esm({
   "packages/contracts/src/status-registry.ts"() {
     "use strict";
+    TASK_STATUSES = [
+      "pending",
+      "active",
+      "blocked",
+      "done",
+      "cancelled",
+      "archived",
+      "proposed"
+    ];
+    SESSION_STATUSES = ["active", "ended", "orphaned", "suspended"];
+    LIFECYCLE_PIPELINE_STATUSES = [
+      "active",
+      "completed",
+      "blocked",
+      "failed",
+      "cancelled",
+      "aborted"
+    ];
+    LIFECYCLE_STAGE_STATUSES = [
+      "not_started",
+      "in_progress",
+      "blocked",
+      "completed",
+      "skipped",
+      "failed"
+    ];
+    ADR_STATUSES = ["proposed", "accepted", "superseded", "deprecated"];
+    GATE_STATUSES = ["pending", "passed", "failed", "waived"];
+    MANIFEST_STATUSES = ["completed", "partial", "blocked", "archived"];
+    TERMINAL_TASK_STATUSES = /* @__PURE__ */ new Set([
+      "done",
+      "cancelled",
+      "archived"
+    ]);
+    TERMINAL_PIPELINE_STATUSES = /* @__PURE__ */ new Set([
+      "completed",
+      "failed",
+      "cancelled",
+      "aborted"
+    ]);
+    TERMINAL_STAGE_STATUSES = /* @__PURE__ */ new Set([
+      "completed",
+      "skipped",
+      "failed"
+    ]);
+    STATUS_REGISTRY = {
+      task: TASK_STATUSES,
+      session: SESSION_STATUSES,
+      lifecycle_pipeline: LIFECYCLE_PIPELINE_STATUSES,
+      lifecycle_stage: LIFECYCLE_STAGE_STATUSES,
+      adr: ADR_STATUSES,
+      gate: GATE_STATUSES,
+      manifest: MANIFEST_STATUSES
+    };
+    PIPELINE_STATUS_ICONS = {
+      active: "\u25B6",
+      // pipeline is running
+      completed: "\u2713",
+      // all stages done successfully
+      blocked: "\u23F8",
+      // cannot advance; waiting
+      failed: "\u2717",
+      // terminal failure
+      cancelled: "\u2298",
+      // user-initiated abandonment
+      aborted: "\u23F9"
+      // system-forced termination
+    };
+    STAGE_STATUS_ICONS = {
+      not_started: "\u23F9",
+      // not yet entered
+      in_progress: "\u25B6",
+      // actively running
+      blocked: "\u23F8",
+      // paused / waiting
+      completed: "\u2713",
+      // finished successfully
+      skipped: "\u23ED",
+      // intentionally bypassed
+      failed: "\u2717"
+      // terminal failure
+    };
     TASK_STATUS_SYMBOLS_UNICODE = {
       pending: "\u25CB",
       // ○  not yet started
@@ -792,52 +1200,52 @@ var init_status_registry = __esm({
 });
 
 // packages/contracts/src/task-evidence.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var fileEvidenceSchema, logEvidenceSchema, screenshotEvidenceSchema, testOutputEvidenceSchema, commandOutputEvidenceSchema, taskEvidenceSchema;
 var init_task_evidence = __esm({
   "packages/contracts/src/task-evidence.ts"() {
     "use strict";
-    fileEvidenceSchema = z4.object({
-      kind: z4.literal("file"),
-      sha256: z4.string().length(64),
-      timestamp: z4.string().datetime(),
-      path: z4.string().min(1),
-      mime: z4.string().optional(),
-      description: z4.string().optional()
+    fileEvidenceSchema = z5.object({
+      kind: z5.literal("file"),
+      sha256: z5.string().length(64),
+      timestamp: z5.string().datetime(),
+      path: z5.string().min(1),
+      mime: z5.string().optional(),
+      description: z5.string().optional()
     });
-    logEvidenceSchema = z4.object({
-      kind: z4.literal("log"),
-      sha256: z4.string().length(64),
-      timestamp: z4.string().datetime(),
-      source: z4.string().min(1),
-      description: z4.string().optional()
+    logEvidenceSchema = z5.object({
+      kind: z5.literal("log"),
+      sha256: z5.string().length(64),
+      timestamp: z5.string().datetime(),
+      source: z5.string().min(1),
+      description: z5.string().optional()
     });
-    screenshotEvidenceSchema = z4.object({
-      kind: z4.literal("screenshot"),
-      sha256: z4.string().length(64),
-      timestamp: z4.string().datetime(),
-      mime: z4.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
-      description: z4.string().optional()
+    screenshotEvidenceSchema = z5.object({
+      kind: z5.literal("screenshot"),
+      sha256: z5.string().length(64),
+      timestamp: z5.string().datetime(),
+      mime: z5.enum(["image/png", "image/jpeg", "image/webp"]).optional(),
+      description: z5.string().optional()
     });
-    testOutputEvidenceSchema = z4.object({
-      kind: z4.literal("test-output"),
-      sha256: z4.string().length(64),
-      timestamp: z4.string().datetime(),
-      passed: z4.number().int().nonnegative(),
-      failed: z4.number().int().nonnegative(),
-      skipped: z4.number().int().nonnegative(),
-      exitCode: z4.number().int(),
-      description: z4.string().optional()
+    testOutputEvidenceSchema = z5.object({
+      kind: z5.literal("test-output"),
+      sha256: z5.string().length(64),
+      timestamp: z5.string().datetime(),
+      passed: z5.number().int().nonnegative(),
+      failed: z5.number().int().nonnegative(),
+      skipped: z5.number().int().nonnegative(),
+      exitCode: z5.number().int(),
+      description: z5.string().optional()
     });
-    commandOutputEvidenceSchema = z4.object({
-      kind: z4.literal("command-output"),
-      sha256: z4.string().length(64),
-      timestamp: z4.string().datetime(),
-      cmd: z4.string().min(1),
-      exitCode: z4.number().int(),
-      description: z4.string().optional()
+    commandOutputEvidenceSchema = z5.object({
+      kind: z5.literal("command-output"),
+      sha256: z5.string().length(64),
+      timestamp: z5.string().datetime(),
+      cmd: z5.string().min(1),
+      exitCode: z5.number().int(),
+      description: z5.string().optional()
     });
-    taskEvidenceSchema = z4.discriminatedUnion("kind", [
+    taskEvidenceSchema = z5.discriminatedUnion("kind", [
       fileEvidenceSchema,
       logEvidenceSchema,
       screenshotEvidenceSchema,
@@ -848,6 +1256,90 @@ var init_task_evidence = __esm({
 });
 
 // packages/contracts/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ADR_STATUSES: () => ADR_STATUSES,
+  AGENT_INSTANCE_STATUSES: () => AGENT_INSTANCE_STATUSES,
+  AGENT_TYPES: () => AGENT_TYPES,
+  BRAIN_OBSERVATION_TYPES: () => BRAIN_OBSERVATION_TYPES,
+  BRANCH_LOCK_ERROR_CODES: () => BRANCH_LOCK_ERROR_CODES,
+  ExitCode: () => ExitCode,
+  GATE_STATUSES: () => GATE_STATUSES,
+  LIFECYCLE_PIPELINE_STATUSES: () => LIFECYCLE_PIPELINE_STATUSES,
+  LIFECYCLE_STAGE_STATUSES: () => LIFECYCLE_STAGE_STATUSES,
+  LifecycleScopeDeniedError: () => LifecycleScopeDeniedError,
+  MANIFEST_STATUSES: () => MANIFEST_STATUSES,
+  PIPELINE_STATUS_ICONS: () => PIPELINE_STATUS_ICONS,
+  SESSION_JOURNAL_SCHEMA_VERSION: () => SESSION_JOURNAL_SCHEMA_VERSION,
+  SESSION_STATUSES: () => SESSION_STATUSES,
+  STAGE_STATUS_ICONS: () => STAGE_STATUS_ICONS,
+  STATUS_REGISTRY: () => STATUS_REGISTRY,
+  SessionView: () => SessionView,
+  TASK_STATUSES: () => TASK_STATUSES,
+  TASK_STATUS_SYMBOLS_ASCII: () => TASK_STATUS_SYMBOLS_ASCII,
+  TASK_STATUS_SYMBOLS_UNICODE: () => TASK_STATUS_SYMBOLS_UNICODE,
+  TERMINAL_PIPELINE_STATUSES: () => TERMINAL_PIPELINE_STATUSES,
+  TERMINAL_STAGE_STATUSES: () => TERMINAL_STAGE_STATUSES,
+  TERMINAL_TASK_STATUSES: () => TERMINAL_TASK_STATUSES,
+  ThinAgentViolationError: () => ThinAgentViolationError,
+  acceptanceArraySchema: () => acceptanceArraySchema,
+  acceptanceGateResultSchema: () => acceptanceGateResultSchema,
+  acceptanceGateSchema: () => acceptanceGateSchema,
+  acceptanceItemSchema: () => acceptanceItemSchema,
+  assertPeerIdentity: () => assertPeerIdentity,
+  attachmentMetadataSchema: () => attachmentMetadataSchema,
+  attachmentRefSchema: () => attachmentRefSchema,
+  attachmentSchema: () => attachmentSchema,
+  blobAttachmentSchema: () => blobAttachmentSchema,
+  commandGateSchema: () => commandGateSchema,
+  commandOutputEvidenceSchema: () => commandOutputEvidenceSchema,
+  commandOutputRecordSchema: () => commandOutputRecordSchema,
+  createErrorResult: () => createErrorResult,
+  createSuccessResult: () => createSuccessResult,
+  evidenceRecordSchema: () => evidenceRecordSchema,
+  fileAssertionSchema: () => fileAssertionSchema,
+  fileEvidenceSchema: () => fileEvidenceSchema,
+  fileGateSchema: () => fileGateSchema,
+  filterPeerIdentities: () => filterPeerIdentities,
+  formatError: () => formatError,
+  gateBaseSchema: () => gateBaseSchema,
+  gateResultDetailsSchema: () => gateResultDetailsSchema,
+  getErrorMessage: () => getErrorMessage,
+  getExitCodeName: () => getExitCodeName,
+  httpGateSchema: () => httpGateSchema,
+  implDiffRecordSchema: () => implDiffRecordSchema,
+  isErrorCode: () => isErrorCode,
+  isErrorResult: () => isErrorResult,
+  isErrorType: () => isErrorType,
+  isGatewayEnvelope: () => isGatewayEnvelope,
+  isLafsError: () => isLafsError,
+  isLafsSuccess: () => isLafsSuccess,
+  isNoChangeCode: () => isNoChangeCode,
+  isPeerIdentity: () => isPeerIdentity,
+  isRecoverableCode: () => isRecoverableCode,
+  isSuccessCode: () => isSuccessCode,
+  isValidStatus: () => isValidStatus,
+  lintGateSchema: () => lintGateSchema,
+  lintReportRecordSchema: () => lintReportRecordSchema,
+  llmsTxtAttachmentSchema: () => llmsTxtAttachmentSchema,
+  llmtxtDocAttachmentSchema: () => llmtxtDocAttachmentSchema,
+  localFileAttachmentSchema: () => localFileAttachmentSchema,
+  logEvidenceSchema: () => logEvidenceSchema,
+  manualGateSchema: () => manualGateSchema,
+  normalizeError: () => normalizeError,
+  ops: () => operations_exports,
+  paramsToCittyArgs: () => paramsToCittyArgs,
+  screenshotEvidenceSchema: () => screenshotEvidenceSchema,
+  sessionJournalDebriefSummarySchema: () => sessionJournalDebriefSummarySchema,
+  sessionJournalDoctorSummarySchema: () => sessionJournalDoctorSummarySchema,
+  sessionJournalEntrySchema: () => sessionJournalEntrySchema,
+  taskEvidenceSchema: () => taskEvidenceSchema,
+  testGateSchema: () => testGateSchema,
+  testOutputEvidenceSchema: () => testOutputEvidenceSchema,
+  testOutputRecordSchema: () => testOutputRecordSchema,
+  urlAttachmentSchema: () => urlAttachmentSchema,
+  validateSpecCheckRecordSchema: () => validateSpecCheckRecordSchema
+});
 var init_src = __esm({
   "packages/contracts/src/index.ts"() {
     init_acceptance_gate_schema();
@@ -862,6 +1354,7 @@ var init_src = __esm({
     init_params();
     init_peer();
     init_session2();
+    init_session_journal();
     init_status_registry();
     init_task_evidence();
   }
@@ -9007,6 +9500,18 @@ async function sessionStart(projectRoot, params) {
       ...previousDebrief && { previousDebrief },
       ...previousHandoff && { previousHandoff }
     };
+    import("@cleocode/core/sessions/session-journal.js").then(async ({ appendSessionJournalEntry }) => {
+      const { SESSION_JOURNAL_SCHEMA_VERSION: SESSION_JOURNAL_SCHEMA_VERSION2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+      await appendSessionJournalEntry(projectRoot, {
+        schemaVersion: SESSION_JOURNAL_SCHEMA_VERSION2,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId,
+        eventType: "session_start",
+        agentIdentifier: agentIdentifier ?? void 0,
+        scope: params.scope
+      });
+    }).catch(() => {
+    });
     return { success: true, data: enrichedSession };
   } catch {
     return engineError("E_NOT_INITIALIZED", "Task database not initialized");
@@ -9067,6 +9572,38 @@ async function sessionEnd(projectRoot, notes, params) {
       }
     } catch {
     }
+    try {
+      const { appendSessionJournalEntry } = await import("@cleocode/core/sessions/session-journal.js");
+      const { SESSION_JOURNAL_SCHEMA_VERSION: SESSION_JOURNAL_SCHEMA_VERSION2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+      let doctorSummary;
+      try {
+        const { scanBrainNoise } = await import("@cleocode/core/memory/brain-doctor.js");
+        const scanResult = await scanBrainNoise(projectRoot);
+        doctorSummary = {
+          isClean: scanResult.isClean,
+          findingsCount: scanResult.findings.length,
+          patterns: scanResult.findings.map((f) => f.pattern),
+          totalScanned: scanResult.totalScanned
+        };
+      } catch {
+      }
+      const agentIdentifier = process.env.CLEO_AGENT_ID ?? process.env.CLAUDE_CODE_AGENT_ID ?? void 0;
+      const duration = Math.floor(
+        (Date.now() - new Date(activeSession.startedAt).getTime()) / 1e3
+      );
+      await appendSessionJournalEntry(projectRoot, {
+        schemaVersion: SESSION_JOURNAL_SCHEMA_VERSION2,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId,
+        eventType: "session_end",
+        agentIdentifier,
+        providerId: activeSession.providerId ?? void 0,
+        duration,
+        tasksCompleted: activeSession.tasksCompleted ?? [],
+        ...doctorSummary !== void 0 ? { doctorSummary } : {}
+      });
+    } catch {
+    }
     return {
       success: true,
       data: { sessionId, ended: true, ...memoryPrompt && { memoryPrompt } }
@@ -9155,6 +9692,11 @@ async function sessionGc(projectRoot, maxAgeDays = 1) {
         await accessor.removeSingleSession(s.id);
       }
     }
+    try {
+      const { rotateSessionJournals } = await import("@cleocode/core/sessions/session-journal.js");
+      await rotateSessionJournals(projectRoot);
+    } catch {
+    }
     return { success: true, data: { orphaned, removed } };
   } catch {
     return engineError("E_NOT_INITIALIZED", "Task database not initialized");
@@ -11740,9 +12282,9 @@ async function systemLog(projectRoot, filters) {
 }
 async function queryAuditLogSqlite(projectRoot, filters) {
   try {
-    const { join: join22 } = await import("node:path");
+    const { join: join23 } = await import("node:path");
     const { existsSync: existsSync12 } = await import("node:fs");
-    const dbPath = join22(projectRoot, CLEO_DIR_NAME, TASKS_DB_FILENAME);
+    const dbPath = join23(projectRoot, CLEO_DIR_NAME, TASKS_DB_FILENAME);
     if (!existsSync12(dbPath)) {
       const offset = filters?.offset ?? 0;
       const limit = filters?.limit ?? 20;
@@ -25339,6 +25881,8 @@ var init_state = __esm({
 });
 
 // packages/playbooks/src/runtime.ts
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
 function buildEdgeIndex(def) {
   const outgoing = /* @__PURE__ */ new Map();
   const incoming = /* @__PURE__ */ new Map();
@@ -25506,16 +26050,19 @@ function resolveEdge(fromId, toId, edges) {
 function auditContractViolation(projectRoot, runId, nodeId, field, key, playbookName) {
   if (!projectRoot) return;
   try {
-    void import("@cleocode/core").then(({ appendContractViolation }) => {
-      appendContractViolation(projectRoot, {
-        runId,
-        nodeId,
-        field,
-        key,
-        message: `contract_violation: ${field}['${key}'] check failed on node '${nodeId}'`,
-        playbookName
-      });
+    const filePath = join4(projectRoot, ".cleo", "audit", "contract-violations.jsonl");
+    mkdirSync(dirname2(filePath), { recursive: true });
+    const entry = JSON.stringify({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      runId,
+      nodeId,
+      field,
+      key,
+      message: `contract_violation: ${field}['${key}'] check failed on node '${nodeId}'`,
+      playbookName
     });
+    appendFileSync(filePath, `${entry}
+`, { encoding: "utf-8" });
   } catch {
   }
 }
@@ -25912,8 +26459,8 @@ var init_runtime = __esm({
 });
 
 // packages/playbooks/src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var src_exports2 = {};
+__export(src_exports2, {
   DEFAULT_POLICY_RULES: () => DEFAULT_POLICY_RULES,
   E_APPROVAL_ALREADY_DECIDED: () => E_APPROVAL_ALREADY_DECIDED,
   E_APPROVAL_NOT_FOUND: () => E_APPROVAL_NOT_FOUND,
@@ -25960,7 +26507,7 @@ var init_src2 = __esm({
 // packages/cleo/src/dispatch/domains/playbook.ts
 import { existsSync as existsSync3, readFileSync as readFileSync6 } from "node:fs";
 import { homedir } from "node:os";
-import { dirname as dirname2, join as join4, resolve as resolvePath2 } from "node:path";
+import { dirname as dirname3, join as join5, resolve as resolvePath2 } from "node:path";
 import { fileURLToPath } from "node:url";
 function normalizeListStatus(raw) {
   if (typeof raw !== "string" || raw.length === 0) return void 0;
@@ -25988,8 +26535,8 @@ function resolvePlaybookDirs() {
   if (__playbookRuntimeOverrides.playbookBaseDirs) {
     return __playbookRuntimeOverrides.playbookBaseDirs;
   }
-  const globalDir = join4(homedir(), ".local", "share", "cleo", "playbooks");
-  const here = dirname2(fileURLToPath(import.meta.url));
+  const globalDir = join5(homedir(), ".local", "share", "cleo", "playbooks");
+  const here = dirname3(fileURLToPath(import.meta.url));
   const sourceStarter = resolvePath2(here, "..", "..", "..", "..", "playbooks", "starter");
   const bundledStarter = resolvePath2(here, "..", "..", "..", "playbooks", "starter");
   return [globalDir, sourceStarter, bundledStarter];
@@ -25998,7 +26545,7 @@ function loadPlaybookByName(name) {
   const candidates = resolvePlaybookDirs();
   const fileName = name.endsWith(".cantbook") ? name : `${name}.cantbook`;
   for (const dir of candidates) {
-    const full = join4(dir, fileName);
+    const full = join5(dir, fileName);
     if (existsSync3(full)) {
       return { sourcePath: full, source: readFileSync6(full, "utf8") };
     }
@@ -26562,7 +27109,7 @@ async function orchestrateClassify(request, context, projectRoot) {
   try {
     const { getCleoCantWorkflowsDir: getCleoCantWorkflowsDir2 } = await import("@cleocode/core/internal");
     const { readFileSync: readFileSync16, readdirSync: readdirSync4, existsSync: existsSync12 } = await import("node:fs");
-    const { join: join22 } = await import("node:path");
+    const { join: join23 } = await import("node:path");
     const workflowsDir = getCleoCantWorkflowsDir2();
     const combined = `${request} ${context ?? ""}`.toLowerCase();
     const matches = [];
@@ -26570,7 +27117,7 @@ async function orchestrateClassify(request, context, projectRoot) {
       const files = readdirSync4(workflowsDir).filter((f) => f.endsWith(".cant"));
       for (const file of files) {
         try {
-          const src = readFileSync16(join22(workflowsDir, file), "utf-8");
+          const src = readFileSync16(join23(workflowsDir, file), "utf-8");
           const teamMatch = /^team\s+(\S+):/m.exec(src);
           if (!teamMatch) continue;
           const teamName = teamMatch[1];
@@ -26585,12 +27132,12 @@ async function orchestrateClassify(request, context, projectRoot) {
         }
       }
     }
-    const localCantDir = join22(projectRoot, CLEO_DIR_NAME, WORKFLOWS_SUBDIR);
+    const localCantDir = join23(projectRoot, CLEO_DIR_NAME, WORKFLOWS_SUBDIR);
     if (existsSync12(localCantDir)) {
       const files = readdirSync4(localCantDir).filter((f) => f.endsWith(".cant"));
       for (const file of files) {
         try {
-          const src = readFileSync16(join22(localCantDir, file), "utf-8");
+          const src = readFileSync16(join23(localCantDir, file), "utf-8");
           const teamMatch = /^team\s+(\S+):/m.exec(src);
           if (!teamMatch) continue;
           const teamName = teamMatch[1];
@@ -26866,7 +27413,7 @@ async function handleApproveGate(params, startTime) {
       );
     }
     const db = await acquirePlaybookDb();
-    const { approveGate: approveGate2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+    const { approveGate: approveGate2 } = await Promise.resolve().then(() => (init_src2(), src_exports2));
     const updated = approveGate2(db, resumeToken, approver, reason);
     return {
       meta: dispatchMeta("mutate", "orchestrate", "approve", startTime),
@@ -26956,7 +27503,7 @@ async function handleRejectGate(params, startTime) {
       );
     }
     const db = await acquirePlaybookDb();
-    const { rejectGate: rejectGate2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+    const { rejectGate: rejectGate2 } = await Promise.resolve().then(() => (init_src2(), src_exports2));
     const updated = rejectGate2(db, resumeToken, approver, reason);
     return {
       meta: dispatchMeta("mutate", "orchestrate", "reject", startTime),
@@ -28568,7 +29115,7 @@ var init_pipeline2 = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/sentient.ts
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import { getProjectRoot as getProjectRoot11 } from "@cleocode/core";
 function safeParseJsonArray(json2) {
   if (!json2) return [];
@@ -28597,7 +29144,7 @@ async function incrementTier2Stat(projectRoot, field) {
   try {
     const { patchSentientState: patchSentientState2, readSentientState: readSentientState2 } = await import("@cleocode/core/sentient/state.js");
     const { SENTIENT_STATE_FILE: SENTIENT_STATE_FILE2 } = await import("@cleocode/core/sentient/daemon.js");
-    const statePath = join5(projectRoot, SENTIENT_STATE_FILE2);
+    const statePath = join6(projectRoot, SENTIENT_STATE_FILE2);
     const state = await readSentientState2(statePath);
     await patchSentientState2(statePath, {
       tier2Stats: {
@@ -28874,7 +29421,7 @@ var init_sentient = __esm({
       async runProposeTick(projectRoot, params) {
         const { safeRunProposeTick: safeRunProposeTick2 } = await import("@cleocode/core/sentient/propose-tick.js");
         const { SENTIENT_STATE_FILE: SENTIENT_STATE_FILE2 } = await import("@cleocode/core/sentient/daemon.js");
-        const statePath = join5(projectRoot, SENTIENT_STATE_FILE2);
+        const statePath = join6(projectRoot, SENTIENT_STATE_FILE2);
         const outcome = await safeRunProposeTick2({ projectRoot, statePath });
         const _ = params;
         void _;
@@ -28922,7 +29469,7 @@ var init_sentient = __esm({
       async setTier2Enabled(projectRoot, enabled) {
         const { patchSentientState: patchSentientState2 } = await import("@cleocode/core/sentient/state.js");
         const { SENTIENT_STATE_FILE: SENTIENT_STATE_FILE2 } = await import("@cleocode/core/sentient/daemon.js");
-        const statePath = join5(projectRoot, SENTIENT_STATE_FILE2);
+        const statePath = join6(projectRoot, SENTIENT_STATE_FILE2);
         const updated = await patchSentientState2(statePath, { tier2Enabled: enabled });
         return {
           success: true,
@@ -30303,7 +30850,7 @@ var init_tasks3 = __esm({
 });
 
 // packages/cleo/src/dispatch/engines/code-engine.ts
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { getProjectRoot as getProjectRoot15 } from "@cleocode/core";
 async function codeOutline(params) {
   const { smartOutline } = await import("@cleocode/core/internal");
@@ -30314,7 +30861,7 @@ async function codeOutline(params) {
       error: { code: "E_INVALID_INPUT", message: "file parameter required" }
     };
   const root = getProjectRoot15();
-  const absPath = filePath.startsWith("/") ? filePath : join6(root, filePath);
+  const absPath = filePath.startsWith("/") ? filePath : join7(root, filePath);
   return { success: true, data: smartOutline(absPath, root) };
 }
 async function codeSearch(params) {
@@ -30346,7 +30893,7 @@ async function codeUnfold(params) {
       error: { code: "E_INVALID_INPUT", message: "file and symbol parameters required" }
     };
   const root = getProjectRoot15();
-  const absPath = filePath.startsWith("/") ? filePath : join6(root, filePath);
+  const absPath = filePath.startsWith("/") ? filePath : join7(root, filePath);
   return { success: true, data: smartUnfold(absPath, symbol, root) };
 }
 async function codeParse(params) {
@@ -30358,7 +30905,7 @@ async function codeParse(params) {
       error: { code: "E_INVALID_INPUT", message: "file parameter required" }
     };
   const root = getProjectRoot15();
-  const absPath = filePath.startsWith("/") ? filePath : join6(root, filePath);
+  const absPath = filePath.startsWith("/") ? filePath : join7(root, filePath);
   return { success: true, data: parseFile(absPath, root) };
 }
 var init_code_engine = __esm({
@@ -31528,7 +32075,7 @@ var init_defaults = __esm({
 
 // packages/cleo/src/dispatch/lib/config-loader.ts
 import { existsSync as existsSync4, readFileSync as readFileSync7 } from "fs";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 function loadFromEnv(key) {
   const envKey = `${ENV_PREFIX}${key.toUpperCase()}`;
   return process.env[envKey];
@@ -31549,7 +32096,7 @@ function parseEnvValue(key, value) {
 }
 function loadFromFile(projectRoot) {
   const root = projectRoot || process.cwd();
-  const configPath = join7(root, CLEO_DIR_NAME, CONFIG_JSON);
+  const configPath = join8(root, CLEO_DIR_NAME, CONFIG_JSON);
   if (!existsSync4(configPath)) {
     return {};
   }
@@ -32023,7 +32570,7 @@ __export(cli_exports, {
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { existsSync as existsSync5 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { catalog as catalog2, registerSkillLibraryFromPath } from "@cleocode/caamp";
 import { autoRecordDispatchTokenUsage, getProjectRoot as getProjectRoot17, hooks } from "@cleocode/core/internal";
@@ -32034,17 +32581,17 @@ function ensureCaampLibrary() {
     try {
       const req = createRequire2(import.meta.url);
       const skillsPkgJson = req.resolve("@cleocode/skills/package.json");
-      const candidate = dirname3(skillsPkgJson);
-      if (existsSync5(join8(candidate, "skills.json"))) {
+      const candidate = dirname4(skillsPkgJson);
+      if (existsSync5(join9(candidate, "skills.json"))) {
         skillsRoot = candidate;
       }
     } catch {
     }
     if (!skillsRoot) {
       const thisFile = fileURLToPath2(import.meta.url);
-      const packageRoot = join8(dirname3(thisFile), "..", "..", "..", "..", "..");
-      const candidate = join8(packageRoot, "packages", "skills");
-      if (existsSync5(join8(candidate, "skills.json"))) {
+      const packageRoot = join9(dirname4(thisFile), "..", "..", "..", "..", "..");
+      const candidate = join9(packageRoot, "packages", "skills");
+      if (existsSync5(join9(candidate, "skills.json"))) {
         skillsRoot = candidate;
       }
     }
@@ -32264,7 +32811,7 @@ var init_cli = __esm({
 
 // packages/cleo/src/cli/index.ts
 import { readFileSync as readFileSync15 } from "node:fs";
-import { dirname as dirname9, join as join21 } from "node:path";
+import { dirname as dirname10, join as join22 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import {
   detectAndRemoveLegacyGlobalFiles,
@@ -33891,13 +34438,13 @@ var registerCommand = defineCommand({
         transportConfig: {},
         isActive: true
       });
-      const { existsSync: existsSync12, mkdirSync: mkdirSync4, writeFileSync: writeFileSync5 } = await import("node:fs");
-      const { join: join22 } = await import("node:path");
-      const cantDir = join22(CLEO_DIR_NAME, AGENTS_SUBDIR);
-      const cantPath = join22(cantDir, `${agentId}.cant`);
+      const { existsSync: existsSync12, mkdirSync: mkdirSync5, writeFileSync: writeFileSync5 } = await import("node:fs");
+      const { join: join23 } = await import("node:path");
+      const cantDir = join23(CLEO_DIR_NAME, AGENTS_SUBDIR);
+      const cantPath = join23(cantDir, `${agentId}.cant`);
       let cantScaffolded = false;
       if (!existsSync12(cantPath)) {
-        mkdirSync4(cantDir, { recursive: true });
+        mkdirSync5(cantDir, { recursive: true });
         const role = classification ?? "specialist";
         const cantContent = `---
 kind: agent
@@ -34076,7 +34623,7 @@ var startCommand = defineCommand({
       const { AgentRegistryAccessor, getDb: getDb3 } = await import("@cleocode/core/internal");
       const { createRuntime } = await import("@cleocode/runtime");
       const { existsSync: existsSync12, readFileSync: readFileSync16 } = await import("node:fs");
-      const { join: join22 } = await import("node:path");
+      const { join: join23 } = await import("node:path");
       await getDb3();
       const registry = new AgentRegistryAccessor(process.cwd());
       const credential = await registry.get(args.agentId);
@@ -34096,7 +34643,7 @@ var startCommand = defineCommand({
       }
       let profile = null;
       let cantValidation = null;
-      const cantPath = args.cant ?? join22(CLEO_DIR_NAME, AGENTS_SUBDIR, `${args.agentId}.cant`);
+      const cantPath = args.cant ?? join23(CLEO_DIR_NAME, AGENTS_SUBDIR, `${args.agentId}.cant`);
       if (existsSync12(cantPath)) {
         profile = readFileSync16(cantPath, "utf-8");
         try {
@@ -34622,7 +35169,7 @@ var workCommand = defineCommand({
       const { AgentRegistryAccessor, getDb: getDb3 } = await import("@cleocode/core/internal");
       const { createRuntime } = await import("@cleocode/runtime");
       const { existsSync: existsSync12 } = await import("node:fs");
-      const { join: join22 } = await import("node:path");
+      const { join: join23 } = await import("node:path");
       const { execFile: execFile2 } = await import("node:child_process");
       const { promisify: promisify2 } = await import("node:util");
       const execFileAsync = promisify2(execFile2);
@@ -34642,7 +35189,7 @@ var workCommand = defineCommand({
       }
       await registry.update(args.agentId, { isActive: true });
       await registry.markUsed(args.agentId);
-      const cantPath = join22(CLEO_DIR_NAME, AGENTS_SUBDIR, `${args.agentId}.cant`);
+      const cantPath = join23(CLEO_DIR_NAME, AGENTS_SUBDIR, `${args.agentId}.cant`);
       const hasProfile = existsSync12(cantPath);
       const runtime = await createRuntime(registry, {
         agentId: args.agentId,
@@ -35493,8 +36040,8 @@ var installCommand = defineCommand({
   async run({ args }) {
     let tempDir = null;
     try {
-      const { existsSync: existsSync12, mkdirSync: mkdirSync4, statSync, readdirSync: readdirSync4, copyFileSync } = await import("node:fs");
-      const { join: join22, basename: basename2, resolve: resolve5, extname } = await import("node:path");
+      const { existsSync: existsSync12, mkdirSync: mkdirSync5, statSync, readdirSync: readdirSync4, copyFileSync } = await import("node:fs");
+      const { join: join23, basename: basename2, resolve: resolve5, extname } = await import("node:path");
       const { tmpdir } = await import("node:os");
       const resolvedPath = resolve5(args.path);
       if (!existsSync12(resolvedPath)) {
@@ -35518,8 +36065,8 @@ var installCommand = defineCommand({
         cantPath = resolvedPath;
       } else if (stat2.isFile() && ext === ".cantz") {
         const { execFileSync: execFileSync6 } = await import("node:child_process");
-        tempDir = join22(tmpdir(), `cleo-agent-install-${Date.now()}`);
-        mkdirSync4(tempDir, { recursive: true });
+        tempDir = join23(tmpdir(), `cleo-agent-install-${Date.now()}`);
+        mkdirSync5(tempDir, { recursive: true });
         try {
           execFileSync6("unzip", ["-o", "-q", resolvedPath, "-d", tempDir], {
             encoding: "utf-8",
@@ -35540,7 +36087,7 @@ var installCommand = defineCommand({
           return;
         }
         const topLevel = readdirSync4(tempDir).filter(
-          (entry) => statSync(join22(tempDir, entry)).isDirectory()
+          (entry) => statSync(join23(tempDir, entry)).isDirectory()
         );
         if (topLevel.length !== 1) {
           cliOutput(
@@ -35557,7 +36104,7 @@ var installCommand = defineCommand({
           return;
         }
         const agentName = topLevel[0];
-        const personaPath = join22(tempDir, agentName, "persona.cant");
+        const personaPath = join23(tempDir, agentName, "persona.cant");
         if (!existsSync12(personaPath)) {
           cliOutput(
             {
@@ -35572,11 +36119,11 @@ var installCommand = defineCommand({
           process.exitCode = 6;
           return;
         }
-        cantPath = join22(tempDir, `${agentName}.cant`);
+        cantPath = join23(tempDir, `${agentName}.cant`);
         copyFileSync(personaPath, cantPath);
       } else if (stat2.isDirectory()) {
         const agentName = basename2(resolvedPath);
-        const personaPath = join22(resolvedPath, "persona.cant");
+        const personaPath = join23(resolvedPath, "persona.cant");
         if (!existsSync12(personaPath)) {
           cliOutput(
             {
@@ -35591,9 +36138,9 @@ var installCommand = defineCommand({
           process.exitCode = 6;
           return;
         }
-        tempDir = join22(tmpdir(), `cleo-agent-install-${Date.now()}`);
-        mkdirSync4(tempDir, { recursive: true });
-        cantPath = join22(tempDir, `${agentName}.cant`);
+        tempDir = join23(tmpdir(), `cleo-agent-install-${Date.now()}`);
+        mkdirSync5(tempDir, { recursive: true });
+        cantPath = join23(tempDir, `${agentName}.cant`);
         copyFileSync(personaPath, cantPath);
       } else {
         cliOutput(
@@ -35721,7 +36268,7 @@ var packCommand = defineCommand({
   async run({ args }) {
     try {
       const { existsSync: existsSync12, statSync } = await import("node:fs");
-      const { resolve: resolve5, basename: basename2, dirname: dirname10 } = await import("node:path");
+      const { resolve: resolve5, basename: basename2, dirname: dirname11 } = await import("node:path");
       const { execFileSync: execFileSync6 } = await import("node:child_process");
       const resolvedDir = resolve5(args.dir);
       if (!existsSync12(resolvedDir) || !statSync(resolvedDir).isDirectory()) {
@@ -35738,8 +36285,8 @@ var packCommand = defineCommand({
         process.exitCode = 4;
         return;
       }
-      const { join: join22 } = await import("node:path");
-      const personaPath = join22(resolvedDir, "persona.cant");
+      const { join: join23 } = await import("node:path");
+      const personaPath = join23(resolvedDir, "persona.cant");
       if (!existsSync12(personaPath)) {
         cliOutput(
           {
@@ -35757,7 +36304,7 @@ var packCommand = defineCommand({
       const agentName = basename2(resolvedDir);
       const archiveName = `${agentName}.cantz`;
       const archivePath = resolve5(archiveName);
-      const parentDir = dirname10(resolvedDir);
+      const parentDir = dirname11(resolvedDir);
       try {
         execFileSync6("zip", ["-r", archivePath, agentName], {
           cwd: parentDir,
@@ -35787,7 +36334,7 @@ var packCommand = defineCommand({
           if (entry.isFile()) {
             fileCount++;
           } else if (entry.isDirectory()) {
-            countFiles(join22(dirPath, entry.name));
+            countFiles(join23(dirPath, entry.name));
           }
         }
       };
@@ -35856,8 +36403,8 @@ var createCommand = defineCommand({
   },
   async run({ args }) {
     try {
-      const { existsSync: existsSync12, mkdirSync: mkdirSync4, writeFileSync: writeFileSync5 } = await import("node:fs");
-      const { join: join22 } = await import("node:path");
+      const { existsSync: existsSync12, mkdirSync: mkdirSync5, writeFileSync: writeFileSync5 } = await import("node:fs");
+      const { join: join23 } = await import("node:path");
       const { homedir: homedir6 } = await import("node:os");
       const name = args.name;
       const role = args.role;
@@ -35917,12 +36464,12 @@ var createCommand = defineCommand({
       let targetRoot;
       if (isGlobal) {
         const home = homedir6();
-        const xdgData = process.env["XDG_DATA_HOME"] ?? join22(home, ".local", "share");
-        targetRoot = join22(xdgData, "cleo", "cant", "agents");
+        const xdgData = process.env["XDG_DATA_HOME"] ?? join23(home, ".local", "share");
+        targetRoot = join23(xdgData, "cleo", "cant", "agents");
       } else {
-        targetRoot = join22(process.cwd(), CLEO_DIR_NAME, CANT_AGENTS_SUBDIR);
+        targetRoot = join23(process.cwd(), CLEO_DIR_NAME, CANT_AGENTS_SUBDIR);
       }
-      const agentDir = join22(targetRoot, name);
+      const agentDir = join23(targetRoot, name);
       if (existsSync12(agentDir)) {
         cliOutput(
           {
@@ -35938,7 +36485,7 @@ var createCommand = defineCommand({
         process.exitCode = 6;
         return;
       }
-      mkdirSync4(agentDir, { recursive: true });
+      mkdirSync5(agentDir, { recursive: true });
       const personaContent = generatePersonaCant({
         name,
         role,
@@ -35947,29 +36494,29 @@ var createCommand = defineCommand({
         domain,
         parent
       });
-      writeFileSync5(join22(agentDir, "persona.cant"), personaContent, "utf-8");
+      writeFileSync5(join23(agentDir, "persona.cant"), personaContent, "utf-8");
       const manifest = generateManifest({ name, role, tier, domain });
       writeFileSync5(
-        join22(agentDir, "manifest.json"),
+        join23(agentDir, "manifest.json"),
         `${JSON.stringify(manifest, null, 2)}
 `,
         "utf-8"
       );
       const createdFiles = [
-        join22(agentDir, "persona.cant"),
-        join22(agentDir, "manifest.json")
+        join23(agentDir, "persona.cant"),
+        join23(agentDir, "manifest.json")
       ];
       if (team) {
         const teamConfigContent = generateTeamConfig(name, role, team);
-        writeFileSync5(join22(agentDir, "team-config.cant"), teamConfigContent, "utf-8");
-        createdFiles.push(join22(agentDir, "team-config.cant"));
+        writeFileSync5(join23(agentDir, "team-config.cant"), teamConfigContent, "utf-8");
+        createdFiles.push(join23(agentDir, "team-config.cant"));
       }
       if (seedBrain) {
-        const expertiseDir = join22(agentDir, "expertise");
-        mkdirSync4(expertiseDir, { recursive: true });
+        const expertiseDir = join23(agentDir, "expertise");
+        mkdirSync5(expertiseDir, { recursive: true });
         const seedContent = generateMentalModelSeed(name, role, domain);
-        writeFileSync5(join22(expertiseDir, "mental-model-seed.md"), seedContent, "utf-8");
-        createdFiles.push(join22(expertiseDir, "mental-model-seed.md"));
+        writeFileSync5(join23(expertiseDir, "mental-model-seed.md"), seedContent, "utf-8");
+        createdFiles.push(join23(expertiseDir, "mental-model-seed.md"));
         try {
           const { execFile: execFile2 } = await import("node:child_process");
           const { promisify: promisify2 } = await import("node:util");
@@ -36067,8 +36614,8 @@ var mintCommand = defineCommand({
   },
   async run({ args }) {
     try {
-      const { existsSync: existsSync12, readFileSync: readFileSync16, mkdirSync: mkdirSync4 } = await import("node:fs");
-      const { resolve: resolve5, join: join22 } = await import("node:path");
+      const { existsSync: existsSync12, readFileSync: readFileSync16, mkdirSync: mkdirSync5 } = await import("node:fs");
+      const { resolve: resolve5, join: join23 } = await import("node:path");
       const specPath = resolve5(args.spec);
       if (!existsSync12(specPath)) {
         const errEnv = {
@@ -36087,8 +36634,8 @@ var mintCommand = defineCommand({
       }
       const specContent = readFileSync16(specPath, "utf-8");
       const projectRoot = process.cwd();
-      const outputDir = args["output-dir"] ? resolve5(args["output-dir"]) : join22(projectRoot, ".cleo", "cant", "agents");
-      mkdirSync4(outputDir, { recursive: true });
+      const outputDir = args["output-dir"] ? resolve5(args["output-dir"]) : join23(projectRoot, ".cleo", "cant", "agents");
+      mkdirSync5(outputDir, { recursive: true });
       if (args["dry-run"]) {
         const preview = {
           success: true,
@@ -38095,7 +38642,7 @@ var briefingCommand = defineCommand({
 // packages/cleo/src/cli/commands/bug.ts
 import { existsSync as existsSync7 } from "node:fs";
 import { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile2 } from "node:fs/promises";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { dirname as dirname5, join as join10 } from "node:path";
 import { getCleoDirAbsolute as getCleoDirAbsolute2, getCleoIdentity, getConfigPath, signAuditLine } from "@cleocode/core";
 init_cli();
 var SEVERITY_MAP = {
@@ -38148,8 +38695,8 @@ async function appendSignedBugSeverity(record) {
   const sig = await signAuditLine(id, canonical);
   const line = `${JSON.stringify({ ...full, _sig: sig })}
 `;
-  const auditPath = join9(getCleoDirAbsolute2(), "audit", "bug-severity.jsonl");
-  await mkdir2(dirname4(auditPath), { recursive: true });
+  const auditPath = join10(getCleoDirAbsolute2(), "audit", "bug-severity.jsonl");
+  await mkdir2(dirname5(auditPath), { recursive: true });
   await appendFile2(auditPath, line, { encoding: "utf-8" });
 }
 var bugCommand = defineCommand({
@@ -38261,8 +38808,8 @@ var cancelCommand = defineCommand({
 });
 
 // packages/cleo/src/cli/commands/cant.ts
-import { existsSync as existsSync8, mkdirSync, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname5, isAbsolute, join as join10, resolve as resolve3 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync9, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname6, isAbsolute, join as join11, resolve as resolve3 } from "node:path";
 init_renderers();
 function resolveFilePath(file) {
   return isAbsolute(file) ? file : resolve3(process.cwd(), file);
@@ -38422,8 +38969,8 @@ var cantMigrateCommand = defineCommand({
         const projectRoot = process.cwd();
         let written = 0;
         for (const outputFile of result.outputFiles) {
-          const outputPath = isAbsolute(outputFile.path) ? outputFile.path : join10(projectRoot, outputFile.path);
-          mkdirSync(dirname5(outputPath), { recursive: true });
+          const outputPath = isAbsolute(outputFile.path) ? outputFile.path : join11(projectRoot, outputFile.path);
+          mkdirSync2(dirname6(outputPath), { recursive: true });
           writeFileSync2(outputPath, outputFile.content, "utf-8");
           written++;
         }
@@ -39021,9 +39568,9 @@ var codeCommand = defineCommand({
       async run({ args }) {
         await requireTreeSitter();
         const { smartOutline } = await import("@cleocode/core/internal");
-        const { join: join22 } = await import("node:path");
+        const { join: join23 } = await import("node:path");
         const root = process.cwd();
-        const absPath = args.file.startsWith("/") ? args.file : join22(root, args.file);
+        const absPath = args.file.startsWith("/") ? args.file : join23(root, args.file);
         const result = smartOutline(absPath, root);
         if (result.errors.length > 0 && result.symbols.length === 0) {
           console.error(`Error: ${result.errors.join(", ")}`);
@@ -39114,9 +39661,9 @@ var codeCommand = defineCommand({
       async run({ args }) {
         await requireTreeSitter();
         const { smartUnfold } = await import("@cleocode/core/internal");
-        const { join: join22 } = await import("node:path");
+        const { join: join23 } = await import("node:path");
         const root = process.cwd();
-        const absPath = args.file.startsWith("/") ? args.file : join22(root, args.file);
+        const absPath = args.file.startsWith("/") ? args.file : join23(root, args.file);
         const result = smartUnfold(absPath, args.symbol, root);
         if (!result.found) {
           console.error(`Symbol "${args.symbol}" not found in ${args.file}`);
@@ -40159,7 +40706,7 @@ var currentCommand = defineCommand({
 
 // packages/cleo/src/cli/commands/daemon.ts
 import { homedir as homedir2 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 import { getGCDaemonStatus, spawnGCDaemon, stopGCDaemon } from "@cleocode/core/gc/daemon.js";
 async function showDaemonStatus(cleoDir, json2) {
   try {
@@ -40212,7 +40759,7 @@ var startCommand3 = defineCommand({
     }
   },
   async run({ args }) {
-    const cleoDir = args["cleo-dir"] ?? join11(homedir2(), ".cleo");
+    const cleoDir = args["cleo-dir"] ?? join12(homedir2(), ".cleo");
     const jsonMode = args.json ?? false;
     try {
       const status = await getGCDaemonStatus(cleoDir);
@@ -40243,7 +40790,7 @@ var startCommand3 = defineCommand({
       } else {
         process.stdout.write(`GC daemon started (PID ${pid})
 `);
-        process.stdout.write(`Logs: ${join11(cleoDir, "logs", "gc.log")}
+        process.stdout.write(`Logs: ${join12(cleoDir, "logs", "gc.log")}
 `);
       }
     } catch (err) {
@@ -40272,7 +40819,7 @@ var stopCommand3 = defineCommand({
     }
   },
   async run({ args }) {
-    const cleoDir = args["cleo-dir"] ?? join11(homedir2(), ".cleo");
+    const cleoDir = args["cleo-dir"] ?? join12(homedir2(), ".cleo");
     const jsonMode = args.json ?? false;
     try {
       const stopResult = await stopGCDaemon(cleoDir);
@@ -40318,7 +40865,7 @@ var statusCommand4 = defineCommand({
     }
   },
   async run({ args }) {
-    const cleoDir = args["cleo-dir"] ?? join11(homedir2(), ".cleo");
+    const cleoDir = args["cleo-dir"] ?? join12(homedir2(), ".cleo");
     await showDaemonStatus(cleoDir, args.json ?? false);
   }
 });
@@ -40344,7 +40891,7 @@ var daemonCommand = defineCommand({
   },
   async run({ args, cmd, rawArgs }) {
     if (isSubCommandDispatch(rawArgs, cmd.subCommands)) return;
-    const cleoDir = args["cleo-dir"] ?? join11(homedir2(), ".cleo");
+    const cleoDir = args["cleo-dir"] ?? join12(homedir2(), ".cleo");
     await showDaemonStatus(cleoDir, args.json ?? false);
   }
 });
@@ -40696,16 +41243,16 @@ var detectCommand2 = defineCommand({
 // packages/cleo/src/cli/commands/detect-drift.ts
 init_src();
 import { existsSync as existsSync9, readdirSync as readdirSync2, readFileSync as readFileSync11 } from "node:fs";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { dirname as dirname7, join as join13 } from "node:path";
 init_paths();
 init_renderers();
 function findProjectRoot() {
   let currentDir = process.cwd();
   while (currentDir !== "/") {
-    if (existsSync9(join12(currentDir, "package.json"))) {
+    if (existsSync9(join13(currentDir, "package.json"))) {
       return currentDir;
     }
-    const parent = dirname6(currentDir);
+    const parent = dirname7(currentDir);
     if (parent === currentDir) break;
     currentDir = parent;
   }
@@ -40718,8 +41265,8 @@ var detectDriftCommand = defineCommand({
   },
   async run() {
     const projectRoot = findProjectRoot();
-    const isCleoRepo = existsSync9(join12(projectRoot, "packages", "cleo", "src"));
-    const cleoSrcRoot = isCleoRepo ? join12(projectRoot, "packages", "cleo", "src") : join12(projectRoot, "src");
+    const isCleoRepo = existsSync9(join13(projectRoot, "packages", "cleo", "src"));
+    const cleoSrcRoot = isCleoRepo ? join13(projectRoot, "packages", "cleo", "src") : join13(projectRoot, "src");
     const safeRead = (filePath) => {
       try {
         return readFileSync11(filePath, "utf-8");
@@ -40733,7 +41280,7 @@ var detectDriftCommand = defineCommand({
         checks: [],
         recommendations: []
       };
-      const injPath = join12(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
+      const injPath = join13(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
       if (existsSync9(injPath)) {
         const content = safeRead(injPath);
         userResult.checks.push({
@@ -40785,9 +41332,9 @@ var detectDriftCommand = defineCommand({
       }
     };
     try {
-      const specPath = join12(projectRoot, "docs", "specs", "CLEO-OPERATION-CONSTITUTION.md");
-      const registryPath = join12(cleoSrcRoot, "dispatch", "registry.ts");
-      const dispatchDomainsDir = join12(cleoSrcRoot, "dispatch", "domains");
+      const specPath = join13(projectRoot, "docs", "specs", "CLEO-OPERATION-CONSTITUTION.md");
+      const registryPath = join13(cleoSrcRoot, "dispatch", "registry.ts");
+      const dispatchDomainsDir = join13(cleoSrcRoot, "dispatch", "domains");
       if (!existsSync9(specPath)) {
         addCheck("Gateway-to-spec sync", "fail", "CLEO-OPERATION-CONSTITUTION.md missing", [
           {
@@ -40856,8 +41403,8 @@ var detectDriftCommand = defineCommand({
       ]);
     }
     try {
-      const cliDir = join12(cleoSrcRoot, "cli", "commands");
-      const coreDir = isCleoRepo ? join12(projectRoot, "packages", "core", "src") : join12(projectRoot, "src", "core");
+      const cliDir = join13(cleoSrcRoot, "cli", "commands");
+      const coreDir = isCleoRepo ? join13(projectRoot, "packages", "core", "src") : join13(projectRoot, "src", "core");
       if (!existsSync9(cliDir)) {
         addCheck("CLI-to-core sync", "fail", "CLI commands directory missing", [
           {
@@ -40884,7 +41431,7 @@ var detectDriftCommand = defineCommand({
       addCheck("CLI-to-core sync", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const domainsDir = join12(cleoSrcRoot, "dispatch", "domains");
+      const domainsDir = join13(cleoSrcRoot, "dispatch", "domains");
       if (!existsSync9(domainsDir)) {
         addCheck("Domain handler coverage", "fail", "Dispatch domains directory missing", [
           {
@@ -40902,7 +41449,7 @@ var detectDriftCommand = defineCommand({
       addCheck("Domain handler coverage", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const matrixPath = join12(cleoSrcRoot, "dispatch", "lib", "capability-matrix.ts");
+      const matrixPath = join13(cleoSrcRoot, "dispatch", "lib", "capability-matrix.ts");
       if (!existsSync9(matrixPath)) {
         addCheck("Capability matrix", "fail", "Capability matrix missing", [
           {
@@ -40919,7 +41466,7 @@ var detectDriftCommand = defineCommand({
       addCheck("Capability matrix", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const schemaPath = join12(projectRoot, "src", "store", "schema.ts");
+      const schemaPath = join13(projectRoot, "src", "store", "schema.ts");
       if (!existsSync9(schemaPath)) {
         addCheck("Schema validation", "fail", "Schema definition missing", [
           {
@@ -40954,8 +41501,8 @@ var detectDriftCommand = defineCommand({
       addCheck("Schema validation", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const visionPath = join12(projectRoot, "docs", "concepts", "CLEO-VISION.md");
-      const specPath = join12(projectRoot, "docs", "specs", "CLEO-PORTABLE-PROJECT-BRAIN-SPEC.md");
+      const visionPath = join13(projectRoot, "docs", "concepts", "CLEO-VISION.md");
+      const specPath = join13(projectRoot, "docs", "specs", "CLEO-PORTABLE-PROJECT-BRAIN-SPEC.md");
       const issues = [];
       if (!existsSync9(visionPath)) {
         issues.push({
@@ -41010,7 +41557,7 @@ var detectDriftCommand = defineCommand({
       addCheck("Canonical identity", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const injectionPath = join12(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
+      const injectionPath = join13(projectRoot, CLEO_DIR_NAME, TEMPLATES_SUBDIR, CLEO_INJECTION_MD);
       if (!existsSync9(injectionPath)) {
         addCheck("Agent injection", "fail", "Agent injection template missing", [
           {
@@ -41040,7 +41587,7 @@ var detectDriftCommand = defineCommand({
       addCheck("Agent injection", "fail", `Error: ${getErrorMessage(e)}`);
     }
     try {
-      const exitCodesPath = join12(cleoSrcRoot, "dispatch", "lib", "exit-codes.ts");
+      const exitCodesPath = join13(cleoSrcRoot, "dispatch", "lib", "exit-codes.ts");
       if (!existsSync9(exitCodesPath)) {
         addCheck("Exit codes", "fail", "Exit codes definition missing", [
           {
@@ -41173,7 +41720,7 @@ var diagnosticsCommand = defineCommand({
 // packages/cleo/src/cli/commands/docs.ts
 init_src();
 import { mkdir as mkdir3, readdir, readFile as readFile3, writeFile } from "node:fs/promises";
-import { dirname as dirname7, isAbsolute as isAbsolute2, join as join13, resolve as resolve4 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute2, join as join14, resolve as resolve4 } from "node:path";
 import {
   buildDocsGraph,
   CleoError as CleoError3,
@@ -41191,7 +41738,7 @@ import {
 init_cli();
 init_renderers();
 async function getScriptNames(projectRoot) {
-  const scriptsDir = join13(projectRoot, "scripts");
+  const scriptsDir = join14(projectRoot, "scripts");
   try {
     const files = await readdir(scriptsDir);
     return files.filter((f) => f.endsWith(".sh")).map((f) => f.replace(".sh", "")).sort();
@@ -41200,7 +41747,7 @@ async function getScriptNames(projectRoot) {
   }
 }
 async function getIndexedCommands(projectRoot) {
-  const indexPath = join13(projectRoot, "docs", "commands", "COMMANDS-INDEX.json");
+  const indexPath = join14(projectRoot, "docs", "commands", "COMMANDS-INDEX.json");
   const index = await readJson(indexPath);
   if (!index) return [];
   return index.commands.map((c) => c.name).sort();
@@ -41233,7 +41780,7 @@ async function runGapCheck(_projectRoot, filterId) {
     const reviewFiles = files.filter((f) => f.endsWith(".md"));
     for (const file of reviewFiles) {
       if (filterId && !file.includes(filterId)) continue;
-      const filePath = join13(reviewDir, file);
+      const filePath = join14(reviewDir, file);
       const content = await readFile3(filePath, "utf-8");
       const taskMatch = file.match(/^(T\d+)/);
       const taskId = taskMatch ? taskMatch[1] : "UNKNOWN";
@@ -41480,7 +42027,7 @@ var exportCommand4 = defineCommand({
       let writtenPath;
       if (typeof args.out === "string" && args.out.length > 0) {
         const outPath = isAbsolute2(args.out) ? args.out : resolve4(projectRoot, args.out);
-        await mkdir3(dirname7(outPath), { recursive: true });
+        await mkdir3(dirname8(outPath), { recursive: true });
         await writeFile(outPath, result.markdown, "utf8");
         writtenPath = outPath;
       }
@@ -41595,7 +42142,7 @@ var mergeCommand = defineCommand({
       });
       if (typeof args.out === "string" && args.out.length > 0) {
         const outPath = isAbsolute2(args.out) ? args.out : resolve4(projectRoot, args.out);
-        await mkdir3(dirname7(outPath), { recursive: true });
+        await mkdir3(dirname8(outPath), { recursive: true });
         await writeFile(outPath, result.merged, "utf8");
         process.stderr.write(`Wrote merged content to ${outPath}
 `);
@@ -41667,7 +42214,7 @@ var graphCommand = defineCommand({
       }
       if (typeof args.out === "string" && args.out.length > 0) {
         const outPath = isAbsolute2(args.out) ? args.out : resolve4(projectRoot, args.out);
-        await mkdir3(dirname7(outPath), { recursive: true });
+        await mkdir3(dirname8(outPath), { recursive: true });
         await writeFile(outPath, output, "utf8");
         process.stderr.write(`Wrote graph to ${outPath}
 `);
@@ -42591,7 +43138,7 @@ var findCommand2 = defineCommand({
 
 // packages/cleo/src/cli/commands/gc.ts
 import { homedir as homedir3 } from "node:os";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 import { runGC } from "@cleocode/core/gc/runner.js";
 import { readGCState } from "@cleocode/core/gc/state.js";
 function formatBytes(bytes) {
@@ -42623,7 +43170,7 @@ var runCommand2 = defineCommand({
     }
   },
   async run({ args }) {
-    const cleoDir = args["cleo-dir"] ?? join14(homedir3(), ".cleo");
+    const cleoDir = args["cleo-dir"] ?? join15(homedir3(), ".cleo");
     const dryRun = args["dry-run"];
     try {
       const gcResult = await runGC({ cleoDir, dryRun });
@@ -42678,8 +43225,8 @@ var statusCommand6 = defineCommand({
     }
   },
   async run({ args }) {
-    const cleoDir = args["cleo-dir"] ?? join14(homedir3(), ".cleo");
-    const statePath = join14(cleoDir, "gc-state.json");
+    const cleoDir = args["cleo-dir"] ?? join15(homedir3(), ".cleo");
+    const statePath = join15(cleoDir, "gc-state.json");
     try {
       const state = await readGCState(statePath);
       const result = { success: true, data: state };
@@ -42738,8 +43285,8 @@ var gcCommand = defineCommand({
 // packages/cleo/src/cli/commands/generate-changelog.ts
 init_src();
 import { execFileSync as execFileSync3 } from "node:child_process";
-import { existsSync as existsSync10, mkdirSync as mkdirSync2, readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname8, join as join15 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync12, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname9, join as join16 } from "node:path";
 import { CleoError as CleoError4, formatError as formatError6, getConfigPath as getConfigPath2, getProjectRoot as getProjectRoot21 } from "@cleocode/core";
 init_renderers();
 function getChangelogSource(cwd) {
@@ -42898,7 +43445,7 @@ var generateChangelogCommand = defineCommand({
       const targetPlatform = args.platform;
       const dryRun = args["dry-run"] === true;
       const sourceFile = getChangelogSource();
-      const sourcePath = join15(getProjectRoot21(), sourceFile);
+      const sourcePath = join16(getProjectRoot21(), sourceFile);
       if (!existsSync10(sourcePath)) {
         throw new CleoError4(4 /* NOT_FOUND */, `Changelog source not found: ${sourcePath}`);
       }
@@ -42911,8 +43458,8 @@ var generateChangelogCommand = defineCommand({
         const outputPath = platformConfig?.path ?? getDefaultOutputPath(targetPlatform);
         const content = generateForPlatform(targetPlatform, sourceContent, repoSlug, limit);
         if (!dryRun) {
-          const fullPath = join15(getProjectRoot21(), outputPath);
-          mkdirSync2(dirname8(fullPath), { recursive: true });
+          const fullPath = join16(getProjectRoot21(), outputPath);
+          mkdirSync3(dirname9(fullPath), { recursive: true });
           writeFileSync3(fullPath, content, "utf-8");
         }
         results.push({ platform: targetPlatform, path: outputPath, written: !dryRun });
@@ -42932,8 +43479,8 @@ var generateChangelogCommand = defineCommand({
             limit
           );
           if (!dryRun) {
-            const fullPath = join15(getProjectRoot21(), platformConfig.path);
-            mkdirSync2(dirname8(fullPath), { recursive: true });
+            const fullPath = join16(getProjectRoot21(), platformConfig.path);
+            mkdirSync3(dirname9(fullPath), { recursive: true });
             writeFileSync3(fullPath, content, "utf-8");
           }
           results.push({
@@ -44342,9 +44889,9 @@ var mapCommand = defineCommand({
 
 // packages/cleo/src/cli/commands/memory.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync11, mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readdirSync as readdirSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 import {
   getBrainDb as getBrainDb2,
   getBrainNativeDb as getBrainNativeDb3,
@@ -44397,7 +44944,7 @@ function loadImportHashes(stateFile) {
 }
 function saveImportHashes(stateFile, hashes) {
   const dir = stateFile.slice(0, stateFile.lastIndexOf("/"));
-  if (!existsSync11(dir)) mkdirSync3(dir, { recursive: true });
+  if (!existsSync11(dir)) mkdirSync4(dir, { recursive: true });
   writeFileSync4(stateFile, JSON.stringify({ hashes: [...hashes] }, null, 2), "utf-8");
 }
 var storeCommand = defineCommand({
@@ -45642,11 +46189,11 @@ var importCommand3 = defineCommand({
     }
   },
   async run({ args }) {
-    const sourceDir = args.from ?? join16(homedir4(), ".claude", "projects", "-mnt-projects-cleocode", "memory");
+    const sourceDir = args.from ?? join17(homedir4(), ".claude", "projects", "-mnt-projects-cleocode", "memory");
     const isDryRun = !!args["dry-run"];
     const isJson = !!args.json;
     const projectRoot = getProjectRoot22();
-    const stateFile = join16(projectRoot, CLEO_DIR_NAME, MIGRATE_MEMORY_HASHES_JSON);
+    const stateFile = join17(projectRoot, CLEO_DIR_NAME, MIGRATE_MEMORY_HASHES_JSON);
     if (!existsSync11(sourceDir)) {
       const msg = `Source directory not found: ${sourceDir}`;
       if (isJson) {
@@ -45656,7 +46203,7 @@ var importCommand3 = defineCommand({
       }
       process.exit(1);
     }
-    const files = readdirSync3(sourceDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md").map((f) => join16(sourceDir, f));
+    const files = readdirSync3(sourceDir).filter((f) => f.endsWith(".md") && f !== "MEMORY.md").map((f) => join17(sourceDir, f));
     const importedHashes = isDryRun ? /* @__PURE__ */ new Set() : loadImportHashes(stateFile);
     const stats = { total: files.length, imported: 0, skipped: 0, errors: 0 };
     const importedEntries = [];
@@ -54932,7 +55479,7 @@ var schemaCommand = defineCommand({
 init_src();
 import { execFile } from "node:child_process";
 import { readFile as readFile4 } from "node:fs/promises";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import * as readline2 from "node:readline";
 import { promisify } from "node:util";
 import {
@@ -54951,7 +55498,7 @@ var GITHUB_REPO = BUILD_CONFIG2.repository.fullName;
 async function getCurrentVersion() {
   const cleoHome = getCleoHome2();
   try {
-    const content = await readFile4(join17(cleoHome, "VERSION"), "utf-8");
+    const content = await readFile4(join18(cleoHome, "VERSION"), "utf-8");
     return (content.split("\n")[0] ?? "unknown").trim();
   } catch {
     return "unknown";
@@ -55005,7 +55552,7 @@ async function writeRuntimeVersionMetadata(mode, source, version) {
   ];
   await import("node:fs/promises").then(
     ({ writeFile: writeFile3, mkdir: mkdir5 }) => mkdir5(cleoHome, { recursive: true }).then(
-      () => writeFile3(join17(cleoHome, "VERSION"), `${lines.join("\n")}
+      () => writeFile3(join18(cleoHome, "VERSION"), `${lines.join("\n")}
 `, "utf-8")
     )
   );
@@ -55406,7 +55953,7 @@ async function runPostUpdateDiagnostics(opts) {
 }
 
 // packages/cleo/src/cli/commands/sentient.ts
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 import { cwd as processCwd } from "node:process";
 import {
   getSentientDaemonStatus,
@@ -55477,7 +56024,7 @@ var startSub = defineCommand({
         return;
       }
       if (dryRun) {
-        const statePath2 = join18(projectRoot, SENTIENT_STATE_FILE);
+        const statePath2 = join19(projectRoot, SENTIENT_STATE_FILE);
         const outcome = await safeRunTick({ projectRoot, statePath: statePath2, dryRun: true });
         emitSuccess(
           { dryRun: true, outcome },
@@ -55611,7 +56158,7 @@ var tickSub = defineCommand({
     const jsonMode = args.json === true;
     const dryRun = args["dry-run"] === true;
     try {
-      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
       const outcome = await safeRunTick({ projectRoot, statePath, dryRun });
       emitSuccess(
         { outcome, dryRun },
@@ -55680,7 +56227,7 @@ var proposeAcceptSub = defineCommand({
         return;
       }
       await db.update(tasks).set({ status: "pending", updatedAt: now }).where(eq2(tasks.id, id)).run();
-      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
       const state = await readSentientState(statePath);
       await patchSentientState(statePath, {
         tier2Stats: {
@@ -55732,7 +56279,7 @@ var proposeRejectSub = defineCommand({
         return;
       }
       await db.update(tasks).set({ status: "cancelled", cancellationReason: reason, cancelledAt: now, updatedAt: now }).where(eq2(tasks.id, id)).run();
-      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
       const state = await readSentientState(statePath);
       await patchSentientState(statePath, {
         tier2Stats: {
@@ -55777,7 +56324,7 @@ var proposeRunSub = defineCommand({
     const projectRoot = resolveProjectRoot7(args.project);
     const jsonMode = args.json === true;
     try {
-      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
       const outcome = await safeRunProposeTick({ projectRoot, statePath });
       emitSuccess(
         { outcome },
@@ -55797,7 +56344,7 @@ var proposeEnableSub = defineCommand({
     const projectRoot = resolveProjectRoot7(args.project);
     const jsonMode = args.json === true;
     try {
-      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
       const updated = await patchSentientState(statePath, { tier2Enabled: true });
       emitSuccess({ tier2Enabled: updated.tier2Enabled }, jsonMode, "Tier-2 proposals enabled");
     } catch (err) {
@@ -55816,7 +56363,7 @@ var proposeDisableSub = defineCommand({
     const projectRoot = resolveProjectRoot7(args.project);
     const jsonMode = args.json === true;
     try {
-      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
       const updated = await patchSentientState(statePath, { tier2Enabled: false });
       emitSuccess({ tier2Enabled: updated.tier2Enabled }, jsonMode, "Tier-2 proposals disabled");
     } catch (err) {
@@ -55847,7 +56394,7 @@ var proposeSub = defineCommand({
     const projectRoot = resolveProjectRoot7(args.project);
     const jsonMode = args.json === true;
     try {
-      const statePath = join18(projectRoot, SENTIENT_STATE_FILE);
+      const statePath = join19(projectRoot, SENTIENT_STATE_FILE);
       const state = await readSentientState(statePath);
       emitSuccess(
         {
@@ -57922,7 +58469,7 @@ var tokenCommand = defineCommand({
 
 // packages/cleo/src/cli/commands/transcript.ts
 import { homedir as homedir5 } from "node:os";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 import { getProjectRoot as getProjectRoot27 } from "@cleocode/core";
 import {
   parseDurationMs,
@@ -57980,7 +58527,7 @@ var scanCommand = defineCommand({
       }
       return;
     }
-    const projectsDir = args["projects-dir"] ?? join19(homedir5(), ".claude", "projects");
+    const projectsDir = args["projects-dir"] ?? join20(homedir5(), ".claude", "projects");
     try {
       const result = await scanTranscripts(projectsDir);
       const envelope = {
@@ -58365,7 +58912,7 @@ var pruneCommand = defineCommand({
       process.exit(2);
       return;
     }
-    const projectsDir = args["projects-dir"] ?? join19(homedir5(), ".claude", "projects");
+    const projectsDir = args["projects-dir"] ?? join20(homedir5(), ".claude", "projects");
     try {
       const pruneResult = await pruneTranscripts({
         olderThanMs,
@@ -58791,7 +59338,7 @@ var verifyCommand2 = defineCommand({
 init_src();
 import { execFileSync as execFileSync5, spawn } from "node:child_process";
 import { mkdir as mkdir4, open, readFile as readFile5, rm, stat, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 import { CleoError as CleoError12, formatError as formatError14, getCleoHome as getCleoHome3 } from "@cleocode/core";
 init_renderers();
 var DEFAULT_PORT = 3456;
@@ -58799,10 +59346,10 @@ var DEFAULT_HOST = "127.0.0.1";
 function getWebPaths() {
   const cleoHome = getCleoHome3();
   return {
-    pidFile: join20(cleoHome, "web-server.pid"),
-    configFile: join20(cleoHome, "web-server.json"),
-    logDir: join20(cleoHome, "logs"),
-    logFile: join20(cleoHome, "logs", "web-server.log")
+    pidFile: join21(cleoHome, "web-server.pid"),
+    configFile: join21(cleoHome, "web-server.json"),
+    logDir: join21(cleoHome, "logs"),
+    logFile: join21(cleoHome, "logs", "web-server.log")
   };
 }
 function isProcessRunning(pid) {
@@ -58841,7 +59388,7 @@ async function startWebServer(port, host) {
     throw new CleoError12(1 /* GENERAL_ERROR */, `Server already running (PID: ${status.pid})`);
   }
   const projectRoot = process.env["CLEO_ROOT"] ?? process.cwd();
-  const studioDir = process.env["CLEO_STUDIO_DIR"] ?? join20(projectRoot, "packages", "studio", "build");
+  const studioDir = process.env["CLEO_STUDIO_DIR"] ?? join21(projectRoot, "packages", "studio", "build");
   await mkdir4(logDir, { recursive: true });
   await writeFile2(
     configFile,
@@ -58851,7 +59398,7 @@ async function startWebServer(port, host) {
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     })
   );
-  const webIndexPath = join20(studioDir, "index.js");
+  const webIndexPath = join21(studioDir, "index.js");
   try {
     await stat(webIndexPath);
   } catch {
@@ -59130,7 +59677,7 @@ Or via NodeSource: https://github.com/nodesource/distributions
   }
 }
 function getPackageVersion() {
-  const pkgPath = join21(dirname9(fileURLToPath3(import.meta.url)), "../../package.json");
+  const pkgPath = join22(dirname10(fileURLToPath3(import.meta.url)), "../../package.json");
   const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
   return pkg.version;
 }