@cleocode/cleo 2026.4.130 → 2026.4.132

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,9 +955,69 @@ 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]();
+      }
+    };
   }
 });
 
@@ -819,10 +1082,95 @@ var init_session_journal = __esm({
 });
 
 // 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
@@ -908,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();
@@ -4716,6 +5148,43 @@ var init_registry = __esm({
           }
         ]
       },
+      // T1147 W7 — BRAIN noise sweep (shadow-write envelope, self-healing gate)
+      {
+        gateway: "query",
+        domain: "memory",
+        operation: "sweep",
+        description: "memory.sweep (query/mutate) \u2014 T1147 W7 BRAIN noise sweep. dry-run: detect noise candidates and write sample JSON to agent-outputs. approve <runId>: apply sweep to live brain tables (sets killSwitch during tx). status: list all noise-sweep-2440 runs. rollback <runId>: discard a staged run without applying changes.",
+        tier: 0,
+        idempotent: false,
+        sessionRequired: false,
+        requiredParams: [],
+        params: [
+          {
+            name: "dry-run",
+            type: "boolean",
+            required: false,
+            description: "Detect noise candidates without staging DB writes."
+          },
+          {
+            name: "approve",
+            type: "string",
+            required: false,
+            description: "Run ID to approve and apply to live tables."
+          },
+          {
+            name: "status",
+            type: "boolean",
+            required: false,
+            description: "List recent noise-sweep-2440 runs."
+          },
+          {
+            name: "rollback",
+            type: "string",
+            required: false,
+            description: "Run ID to roll back without applying changes."
+          }
+        ]
+      },
       // T791 — LLM extraction backend status
       {
         gateway: "query",
@@ -9068,6 +9537,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");
@@ -9128,6 +9609,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 } }
@@ -18539,19 +19052,141 @@ var init_memory2 = __esm({
               const { scanBrainNoise } = await import("@cleocode/core/memory/brain-doctor.js");
               const result = await scanBrainNoise(projectRoot);
               const assertClean = params?.["assert-clean"];
-              if (assertClean && !result.isClean) {
-                return errorResult(
+              if (assertClean) {
+                let pendingCandidates = 0;
+                try {
+                  const { getBrainNativeDb: _getDoctorNativeDb } = await import("@cleocode/core/store/memory-sqlite.js");
+                  const doctorNativeDb = _getDoctorNativeDb();
+                  if (doctorNativeDb) {
+                    const tableExists = doctorNativeDb.prepare(
+                      `SELECT name FROM sqlite_master WHERE type='table' AND name='brain_v2_candidate'`
+                    ).get();
+                    if (tableExists) {
+                      const countRow = doctorNativeDb.prepare(
+                        `SELECT COUNT(*) AS cnt FROM brain_v2_candidate WHERE validation_status = 'pending'`
+                      ).get();
+                      pendingCandidates = countRow?.cnt ?? 0;
+                    }
+                  }
+                } catch {
+                }
+                if (!result.isClean) {
+                  return errorResult(
+                    "query",
+                    "memory",
+                    operation,
+                    "E_BRAIN_NOISE_DETECTED",
+                    `Brain noise detected: ${result.findings.length} pattern(s) across ${result.totalScanned} entries. ` + result.findings.map((f) => `${f.pattern}(${f.count})`).join(", ") + ". Run `cleo memory doctor` for details. Fix noise before enabling Sentient v1 (M7 gate).",
+                    startTime
+                  );
+                }
+                if (pendingCandidates > 0) {
+                  return errorResult(
+                    "query",
+                    "memory",
+                    operation,
+                    "E_SWEEP_PENDING",
+                    `Staged sweep has ${pendingCandidates} pending brain_v2_candidate rows. Run \`cleo memory sweep --status\` to review, then \`cleo memory sweep --approve <runId>\` to apply.`,
+                    startTime
+                  );
+                }
+              } else if (!result.isClean) {
+              }
+              return wrapResult(
+                { success: true, data: { ...result, pendingCandidates: 0 } },
+                "query",
+                "memory",
+                operation,
+                startTime
+              );
+            }
+            // T1147 W7 — BRAIN noise sweep (shadow-write envelope, self-healing gate)
+            case "sweep": {
+              const dryRun = params?.["dry-run"] === true || params?.dryRun === true;
+              const approveRunId = params?.approve;
+              const statusQuery = params?.status === true;
+              const rollbackRunId = params?.rollback;
+              if (statusQuery) {
+                const { getBrainDb: _getBrainDb2, getBrainNativeDb: _getNativeDb2 } = await import("@cleocode/core/store/memory-sqlite.js");
+                const sweepDb = await _getBrainDb2(projectRoot);
+                const nativeDb2 = _getNativeDb2();
+                if (!nativeDb2) {
+                  return errorResult(
+                    "query",
+                    "memory",
+                    operation,
+                    "E_DB_UNAVAILABLE",
+                    "brain.db not available",
+                    startTime
+                  );
+                }
+                const rows = nativeDb2.prepare(
+                  `SELECT id, status, rows_affected, created_at, approved_at, approved_by
+                 FROM brain_backfill_runs
+                 WHERE kind = 'noise-sweep-2440'
+                 ORDER BY created_at DESC
+                 LIMIT 20`
+                ).all();
+                void sweepDb;
+                return wrapResult(
+                  { success: true, data: { runs: rows } },
                   "query",
                   "memory",
                   operation,
-                  "E_BRAIN_NOISE_DETECTED",
-                  `Brain noise detected: ${result.findings.length} pattern(s) across ${result.totalScanned} entries. ` + result.findings.map((f) => `${f.pattern}(${f.count})`).join(", ") + ". Run `cleo memory doctor` for details. Fix noise before enabling Sentient v1 (M7 gate).",
                   startTime
                 );
               }
+              if (approveRunId) {
+                const { executeSweep } = await import("@cleocode/core/memory/brain-sweep-executor.js");
+                const result = await executeSweep({
+                  projectRoot,
+                  runId: approveRunId,
+                  approvedBy: "cleo-cli"
+                });
+                if (!result.success) {
+                  return errorResult(
+                    "mutate",
+                    "memory",
+                    operation,
+                    "E_SWEEP_FAILED",
+                    result.errorMessage ?? "Sweep failed",
+                    startTime
+                  );
+                }
+                return wrapResult(
+                  { success: true, data: result },
+                  "mutate",
+                  "memory",
+                  operation,
+                  startTime
+                );
+              }
+              if (rollbackRunId) {
+                const { rollbackSweep } = await import("@cleocode/core/memory/brain-sweep-executor.js");
+                const rolled = await rollbackSweep(projectRoot, rollbackRunId);
+                if (!rolled) {
+                  return errorResult(
+                    "mutate",
+                    "memory",
+                    operation,
+                    "E_SWEEP_ROLLBACK_FAILED",
+                    `Run '${rollbackRunId}' not found or not in staged status`,
+                    startTime
+                  );
+                }
+                return wrapResult(
+                  { success: true, data: { rolledBack: rollbackRunId } },
+                  "mutate",
+                  "memory",
+                  operation,
+                  startTime
+                );
+              }
+              const { detectNoiseCandidates } = await import("@cleocode/core/memory/brain-noise-detector.js");
+              const detectResult = await detectNoiseCandidates(projectRoot, { dryRun });
               return wrapResult(
-                { success: true, data: result },
-                "query",
+                { success: true, data: detectResult },
+                dryRun ? "query" : "mutate",
                 "memory",
                 operation,
                 startTime
@@ -19655,8 +20290,10 @@ var init_memory2 = __esm({
             "code.links",
             "code.memories-for-code",
             "code.for-memory",
-            // T1262 — brain noise detector (E1-parallel, read-only)
+            // T1262 — brain noise detector (E1-parallel, read-only) + assert-clean gate
             "doctor",
+            // T1147 W7 — sweep status query (dry-run mode)
+            "sweep",
             // T791 — LLM extraction backend status
             "llm-status",
             // T792 — pending verification queue
@@ -25983,8 +26620,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,
@@ -26937,7 +27574,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),
@@ -27027,7 +27664,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),