@cleocode/cleo 2026.10.4 → 2026.10.5

package/dist/cli/chunk-L7ONYSV6.js

@@ -0,0 +1,2497 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  CLEO_DIR_NAME,
+  CONFIG_JSON
+} from "./chunk-6N6WGLXE.js";
+import {
+  resolve
+} from "./chunk-4VASFLUW.js";
+import {
+  getIdempotencyKeyContext,
+  getProjectionOptOut,
+  isDescribeMode,
+  settleThenExit
+} from "./chunk-QKMBWYAS.js";
+import {
+  cliError,
+  cliOutput,
+  loadEsmSync
+} from "./chunk-4RGSNUUP.js";
+import {
+  getFieldContext,
+  getFormatContext
+} from "./chunk-6JSJNYH2.js";
+import {
+  getBoundSession
+} from "./chunk-D7BAQNV2.js";
+import {
+  createLazyDomainHandlers
+} from "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/dispatch/adapters/cli.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join as join2 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { hooks } from "@cleocode/core/hooks/registry";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+import { trackBackgroundOp } from "@cleocode/core/store/background-ops";
+
+// packages/animations/src/animate-context.ts
+function createAnimateContext(input) {
+  const format = input.flagResolution.format;
+  const quiet = input.flagResolution.quiet;
+  const isTTY = input.isTTY ?? Boolean(process.stdout.isTTY);
+  const noColor = input.noColor ?? process.env.NO_COLOR != null;
+  const inputs = { format, quiet, isTTY, noColor };
+  if (format !== "human") {
+    return { enabled: false, reason: "format-json", inputs };
+  }
+  if (quiet) {
+    return { enabled: false, reason: "quiet", inputs };
+  }
+  if (!isTTY) {
+    return { enabled: false, reason: "no-tty", inputs };
+  }
+  if (noColor) {
+    return { enabled: false, reason: "no-color", inputs };
+  }
+  return { enabled: true, reason: "enabled", inputs };
+}
+var SILENT_CONTEXT = Object.freeze({
+  enabled: false,
+  reason: "format-json",
+  inputs: Object.freeze({
+    format: "json",
+    quiet: false,
+    isTTY: false,
+    noColor: false
+  })
+});
+
+// packages/animations/src/braille.ts
+var BRAILLE_DOT_MAP = [
+  [1, 8],
+  // row 0
+  [2, 16],
+  // row 1
+  [4, 32],
+  // row 2
+  [64, 128]
+  // row 3
+];
+function gridToBraille(grid) {
+  const rows = grid.length;
+  const cols = grid[0] ? grid[0].length : 0;
+  const charCount = Math.ceil(cols / 2);
+  let result = "";
+  for (let c = 0; c < charCount; c++) {
+    let code = 10240;
+    for (let r = 0; r < 4 && r < rows; r++) {
+      for (let d = 0; d < 2; d++) {
+        const col = c * 2 + d;
+        if (col < cols && grid[r] && grid[r][col]) {
+          code |= BRAILLE_DOT_MAP[r][d];
+        }
+      }
+    }
+    result += String.fromCodePoint(code);
+  }
+  return result;
+}
+function makeGrid(rows, cols) {
+  if (rows <= 0 || cols <= 0) return [];
+  return Array.from({ length: rows }, () => Array(cols).fill(false));
+}
+function genScan() {
+  const W = 8, H = 4, frames = [];
+  for (let pos = -1; pos < W + 1; pos++) {
+    const g = makeGrid(H, W);
+    for (let r = 0; r < H; r++) {
+      for (let c = 0; c < W; c++) {
+        if (c === pos || c === pos - 1) g[r][c] = true;
+      }
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genRain() {
+  const W = 8, H = 4, totalFrames = 12, frames = [];
+  const offsets = [0, 3, 1, 5, 2, 7, 4, 6];
+  for (let f = 0; f < totalFrames; f++) {
+    const g = makeGrid(H, W);
+    for (let c = 0; c < W; c++) {
+      const row = (f + offsets[c]) % (H + 2);
+      if (row < H) g[row][c] = true;
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genScanLine() {
+  const W = 6, H = 4, frames = [];
+  const positions = [0, 1, 2, 3, 2, 1];
+  for (const row of positions) {
+    const g = makeGrid(H, W);
+    for (let c = 0; c < W; c++) {
+      g[row][c] = true;
+      if (row > 0) g[row - 1][c] = c % 2 === 0;
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genPulse() {
+  const W = 6, H = 4, frames = [];
+  const cx = W / 2 - 0.5, cy = H / 2 - 0.5;
+  const radii = [0.5, 1.2, 2, 3, 3.5];
+  for (const r of radii) {
+    const g = makeGrid(H, W);
+    for (let row = 0; row < H; row++) {
+      for (let col = 0; col < W; col++) {
+        const dist = Math.sqrt((col - cx) ** 2 + (row - cy) ** 2);
+        if (Math.abs(dist - r) < 0.9) g[row][col] = true;
+      }
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genSnake() {
+  const W = 4, H = 4;
+  const path = [];
+  for (let r = 0; r < H; r++) {
+    if (r % 2 === 0) {
+      for (let c = 0; c < W; c++) path.push([r, c]);
+    } else {
+      for (let c = W - 1; c >= 0; c--) path.push([r, c]);
+    }
+  }
+  const frames = [];
+  for (let i = 0; i < path.length; i++) {
+    const g = makeGrid(H, W);
+    for (let t = 0; t < 4; t++) {
+      const idx = (i - t + path.length) % path.length;
+      g[path[idx][0]][path[idx][1]] = true;
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genSparkle() {
+  const patterns = [
+    [
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0
+    ],
+    [
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      0,
+      1,
+      0
+    ],
+    [
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1
+    ],
+    [
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      1,
+      0,
+      0,
+      1,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0
+    ],
+    [
+      0,
+      0,
+      0,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1
+    ],
+    [
+      0,
+      1,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      1,
+      0,
+      0,
+      0,
+      0,
+      1,
+      0,
+      1,
+      0,
+      0,
+      0
+    ]
+  ];
+  const W = 8, H = 4, frames = [];
+  for (const pat of patterns) {
+    const g = makeGrid(H, W);
+    for (let r = 0; r < H; r++) {
+      for (let c = 0; c < W; c++) {
+        g[r][c] = !!pat[r * W + c];
+      }
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genCascade() {
+  const W = 8, H = 4, frames = [];
+  for (let offset = -2; offset < W + H; offset++) {
+    const g = makeGrid(H, W);
+    for (let r = 0; r < H; r++) {
+      for (let c = 0; c < W; c++) {
+        const diag = c + r;
+        if (diag === offset || diag === offset - 1) g[r][c] = true;
+      }
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genColumns() {
+  const W = 6, H = 4, frames = [];
+  for (let col = 0; col < W; col++) {
+    for (let fillTo = H - 1; fillTo >= 0; fillTo--) {
+      const g = makeGrid(H, W);
+      for (let pc = 0; pc < col; pc++) {
+        for (let r = 0; r < H; r++) g[r][pc] = true;
+      }
+      for (let r = fillTo; r < H; r++) g[r][col] = true;
+      frames.push(gridToBraille(g));
+    }
+  }
+  const full = makeGrid(H, W);
+  for (let r = 0; r < H; r++) for (let c = 0; c < W; c++) full[r][c] = true;
+  frames.push(gridToBraille(full));
+  frames.push(gridToBraille(makeGrid(H, W)));
+  return frames;
+}
+function genOrbit() {
+  const W = 2, H = 4;
+  const path = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [2, 1],
+    [3, 1],
+    [3, 0],
+    [2, 0],
+    [1, 0]
+  ];
+  const frames = [];
+  for (let i = 0; i < path.length; i++) {
+    const g = makeGrid(H, W);
+    g[path[i][0]][path[i][1]] = true;
+    const t1 = (i - 1 + path.length) % path.length;
+    g[path[t1][0]][path[t1][1]] = true;
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genBreathe() {
+  const stages = [
+    [],
+    [[1, 0]],
+    [
+      [0, 1],
+      [2, 0]
+    ],
+    [
+      [0, 0],
+      [1, 1],
+      [3, 0]
+    ],
+    [
+      [0, 0],
+      [1, 1],
+      [2, 0],
+      [3, 1]
+    ],
+    [
+      [0, 0],
+      [0, 1],
+      [1, 1],
+      [2, 0],
+      [3, 1]
+    ],
+    [
+      [0, 0],
+      [0, 1],
+      [1, 0],
+      [2, 1],
+      [3, 0],
+      [3, 1]
+    ],
+    [
+      [0, 0],
+      [0, 1],
+      [1, 0],
+      [1, 1],
+      [2, 0],
+      [3, 0],
+      [3, 1]
+    ],
+    [
+      [0, 0],
+      [0, 1],
+      [1, 0],
+      [1, 1],
+      [2, 0],
+      [2, 1],
+      [3, 0],
+      [3, 1]
+    ]
+  ];
+  const frames = [];
+  const sequence = [...stages, ...stages.slice().reverse().slice(1)];
+  for (const dots of sequence) {
+    const g = makeGrid(4, 2);
+    for (const [r, c] of dots) g[r][c] = true;
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genWaveRows() {
+  const W = 8, H = 4, totalFrames = 16, frames = [];
+  for (let f = 0; f < totalFrames; f++) {
+    const g = makeGrid(H, W);
+    for (let c = 0; c < W; c++) {
+      const phase = f - c * 0.5;
+      const row = Math.round((Math.sin(phase * 0.8) + 1) / 2 * (H - 1));
+      g[row][c] = true;
+      if (row > 0) g[row - 1][c] = (f + c) % 3 === 0;
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genCheckerboard() {
+  const W = 6, H = 4, frames = [];
+  for (let phase = 0; phase < 4; phase++) {
+    const g = makeGrid(H, W);
+    for (let r = 0; r < H; r++) {
+      for (let c = 0; c < W; c++) {
+        if (phase < 2) {
+          g[r][c] = (r + c + phase) % 2 === 0;
+        } else {
+          g[r][c] = (r + c + phase) % 3 === 0;
+        }
+      }
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genHelix() {
+  const W = 8, H = 4, totalFrames = 16, frames = [];
+  for (let f = 0; f < totalFrames; f++) {
+    const g = makeGrid(H, W);
+    for (let c = 0; c < W; c++) {
+      const phase = (f + c) * (Math.PI / 4);
+      const y1 = Math.round((Math.sin(phase) + 1) / 2 * (H - 1));
+      const y2 = Math.round((Math.sin(phase + Math.PI) + 1) / 2 * (H - 1));
+      g[y1][c] = true;
+      g[y2][c] = true;
+    }
+    frames.push(gridToBraille(g));
+  }
+  return frames;
+}
+function genFillSweep() {
+  const W = 4, H = 4, frames = [];
+  for (let row = H - 1; row >= 0; row--) {
+    const g = makeGrid(H, W);
+    for (let r = row; r < H; r++) {
+      for (let c = 0; c < W; c++) g[r][c] = true;
+    }
+    frames.push(gridToBraille(g));
+  }
+  const full = makeGrid(H, W);
+  for (let r = 0; r < H; r++) for (let c = 0; c < W; c++) full[r][c] = true;
+  frames.push(gridToBraille(full));
+  frames.push(gridToBraille(full));
+  for (let row = 0; row < H; row++) {
+    const g = makeGrid(H, W);
+    for (let r = row + 1; r < H; r++) {
+      for (let c = 0; c < W; c++) g[r][c] = true;
+    }
+    frames.push(gridToBraille(g));
+  }
+  frames.push(gridToBraille(makeGrid(H, W)));
+  return frames;
+}
+function genDiagonalSwipe() {
+  const W = 4, H = 4, frames = [];
+  const maxDiag = W + H - 2;
+  for (let d = 0; d <= maxDiag; d++) {
+    const g = makeGrid(H, W);
+    for (let r = 0; r < H; r++) {
+      for (let c = 0; c < W; c++) {
+        if (r + c <= d) g[r][c] = true;
+      }
+    }
+    frames.push(gridToBraille(g));
+  }
+  const full = makeGrid(H, W);
+  for (let r = 0; r < H; r++) for (let c = 0; c < W; c++) full[r][c] = true;
+  frames.push(gridToBraille(full));
+  for (let d = 0; d <= maxDiag; d++) {
+    const g = makeGrid(H, W);
+    for (let r = 0; r < H; r++) {
+      for (let c = 0; c < W; c++) {
+        if (r + c > d) g[r][c] = true;
+      }
+    }
+    frames.push(gridToBraille(g));
+  }
+  frames.push(gridToBraille(makeGrid(H, W)));
+  return frames;
+}
+var spinners = {
+  // === Classic braille single-char ===
+  braille: {
+    frames: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+    interval: 80
+  },
+  braillewave: {
+    frames: ["\u2801\u2802\u2804\u2840", "\u2802\u2804\u2840\u2880", "\u2804\u2840\u2880\u2820", "\u2840\u2880\u2820\u2810", "\u2880\u2820\u2810\u2808", "\u2820\u2810\u2808\u2801", "\u2810\u2808\u2801\u2802", "\u2808\u2801\u2802\u2804"],
+    interval: 100
+  },
+  dna: {
+    frames: [
+      "\u280B\u2809\u2819\u281A",
+      "\u2809\u2819\u281A\u2812",
+      "\u2819\u281A\u2812\u2802",
+      "\u281A\u2812\u2802\u2802",
+      "\u2812\u2802\u2802\u2812",
+      "\u2802\u2802\u2812\u2832",
+      "\u2802\u2812\u2832\u2834",
+      "\u2812\u2832\u2834\u2824",
+      "\u2832\u2834\u2824\u2804",
+      "\u2834\u2824\u2804\u280B",
+      "\u2824\u2804\u280B\u2809",
+      "\u2804\u280B\u2809\u2819"
+    ],
+    interval: 80
+  },
+  // === Generated braille grid animations ===
+  scan: { frames: genScan(), interval: 70 },
+  rain: { frames: genRain(), interval: 100 },
+  scanline: { frames: genScanLine(), interval: 120 },
+  pulse: { frames: genPulse(), interval: 180 },
+  snake: { frames: genSnake(), interval: 80 },
+  sparkle: { frames: genSparkle(), interval: 150 },
+  cascade: { frames: genCascade(), interval: 60 },
+  columns: { frames: genColumns(), interval: 60 },
+  orbit: { frames: genOrbit(), interval: 100 },
+  breathe: { frames: genBreathe(), interval: 100 },
+  waverows: { frames: genWaveRows(), interval: 90 },
+  checkerboard: { frames: genCheckerboard(), interval: 250 },
+  helix: { frames: genHelix(), interval: 80 },
+  fillsweep: { frames: genFillSweep(), interval: 100 },
+  diagswipe: { frames: genDiagonalSwipe(), interval: 60 }
+};
+var CANON_TO_GENERIC = {
+  looming: "helix",
+  weaving: "braillewave",
+  heartbeat: "breathe",
+  awakening: "pulse",
+  sweeping: "scan",
+  watching: "orbit",
+  cascade: "cascade",
+  tapestry: "waverows",
+  refinery: "columns"
+};
+var canonSpinners = {
+  looming: spinners[CANON_TO_GENERIC.looming],
+  weaving: spinners[CANON_TO_GENERIC.weaving],
+  heartbeat: spinners[CANON_TO_GENERIC.heartbeat],
+  awakening: spinners[CANON_TO_GENERIC.awakening],
+  sweeping: spinners[CANON_TO_GENERIC.sweeping],
+  watching: spinners[CANON_TO_GENERIC.watching],
+  cascade: spinners[CANON_TO_GENERIC.cascade],
+  tapestry: spinners[CANON_TO_GENERIC.tapestry],
+  refinery: spinners[CANON_TO_GENERIC.refinery]
+};
+function resolveSpinner(name) {
+  if (name in spinners) {
+    return spinners[name];
+  }
+  if (name in canonSpinners) {
+    return canonSpinners[name];
+  }
+  return void 0;
+}
+
+// packages/animations/src/render/legend.ts
+var DEFAULT_MULTILINE_THRESHOLD = 8;
+var SUMMARY_SEPARATOR = " \xB7 ";
+var SUMMARY_SEPARATOR_ASCII = " | ";
+function renderLegend(input) {
+  if (!input.ctx.enabled) return "";
+  if (input.items.length === 0) return "";
+  const threshold = input.multiLineThreshold ?? DEFAULT_MULTILINE_THRESHOLD;
+  const formatted = input.items.map((item) => `${item.icon} ${item.label}`);
+  if (input.items.length <= threshold) {
+    return formatted.join("  ");
+  }
+  return formatted.join("\n");
+}
+function renderSummary(input) {
+  if (!input.ctx.enabled) return "";
+  if (input.counts.length === 0) return "";
+  const separator = input.ctx.inputs.noColor ? SUMMARY_SEPARATOR_ASCII : SUMMARY_SEPARATOR;
+  return input.counts.map((c) => `${c.n} ${c.label}`).join(separator);
+}
+
+// packages/animations/src/render/tree.ts
+import { ascii, KindIcon, StatusIcon } from "@cleocode/contracts/render/icon.js";
+var DEFAULT_FOLD_AT = 50;
+var CONNECTOR_UNICODE = Object.freeze({
+  branch: "\u251C\u2500 ",
+  leaf: "\u2514\u2500 ",
+  vertical: "\u2502  ",
+  blank: "   "
+});
+var CONNECTOR_ASCII = Object.freeze({
+  branch: "+- ",
+  leaf: "+- ",
+  vertical: "|  ",
+  blank: "   "
+});
+var KIND_LABEL = {
+  saga: "sagas",
+  epic: "epics",
+  task: "tasks",
+  subtask: "subtasks"
+};
+function renderTree(resp, opts) {
+  if (!opts.ctx.enabled) return "";
+  if (resp.tree.length === 0) return "";
+  const useAscii = opts.asciiBoxDrawing ?? opts.ctx.inputs.noColor;
+  const connectors = useAscii ? CONNECTOR_ASCII : CONNECTOR_UNICODE;
+  const foldAt = opts.foldAt ?? DEFAULT_FOLD_AT;
+  const childrenByParent = /* @__PURE__ */ new Map();
+  let rootNode;
+  for (const node of resp.tree) {
+    if (node.parentId === null) {
+      if (node.id === resp.root) rootNode = node;
+      continue;
+    }
+    const bucket = childrenByParent.get(node.parentId);
+    if (bucket) bucket.push(node);
+    else childrenByParent.set(node.parentId, [node]);
+  }
+  if (rootNode === void 0) return "";
+  const lines = [];
+  lines.push(formatRow(rootNode, "", useAscii));
+  emitChildren(rootNode.id, [], childrenByParent, connectors, foldAt, useAscii, lines);
+  return lines.join("\n");
+}
+function emitChildren(parentId, ancestorIsLast, childrenByParent, connectors, foldAt, useAscii, out) {
+  const children = childrenByParent.get(parentId);
+  if (children === void 0 || children.length === 0) return;
+  const ancestorPrefix = ancestorIsLast.map((isLast) => isLast ? connectors.blank : connectors.vertical).join("");
+  const shouldFold = children.length > foldAt;
+  const visibleCount = shouldFold ? foldAt - 1 : children.length;
+  const visible = children.slice(0, visibleCount);
+  for (let i = 0; i < visible.length; i++) {
+    const child = visible[i];
+    if (child === void 0) continue;
+    const isLastInBatch = !shouldFold && i === children.length - 1;
+    const connector = isLastInBatch ? connectors.leaf : connectors.branch;
+    out.push(formatRow(child, `${ancestorPrefix}${connector}`, useAscii));
+    emitChildren(
+      child.id,
+      [...ancestorIsLast, isLastInBatch],
+      childrenByParent,
+      connectors,
+      foldAt,
+      useAscii,
+      out
+    );
+  }
+  if (shouldFold) {
+    const hidden = children.length - visibleCount;
+    const sampleKind = children[0]?.kind ?? "task";
+    const label = KIND_LABEL[sampleKind];
+    out.push(
+      `${ancestorPrefix}${connectors.leaf}\u2026 and ${hidden} more ${label} (run cleo tree ${parentId} to expand)`
+    );
+  }
+}
+function formatRow(node, prefix, useAscii) {
+  const kindIcon = resolveKindIcon(node.kind, useAscii);
+  const statusIcon = resolveStatusIcon(node.status, useAscii);
+  return `${prefix}${kindIcon} ${node.title} ${statusIcon}`.trimEnd();
+}
+function resolveKindIcon(kind, useAscii) {
+  const icon = KIND_BY_NODE_KIND[kind];
+  return useAscii ? ascii(icon) : icon;
+}
+function resolveStatusIcon(status, useAscii) {
+  const icon = STATUS_BY_NODE_STATUS[status];
+  return useAscii ? ascii(icon) : icon;
+}
+var KIND_BY_NODE_KIND = {
+  saga: KindIcon.SAGA,
+  epic: KindIcon.EPIC,
+  task: KindIcon.TASK,
+  subtask: KindIcon.SUBTASK
+};
+var STATUS_BY_NODE_STATUS = {
+  pending: StatusIcon.PENDING,
+  in_progress: StatusIcon.ACTIVE,
+  done: StatusIcon.DONE,
+  blocked: StatusIcon.BLOCKED,
+  cancelled: StatusIcon.CANCELLED,
+  archived: StatusIcon.ARCHIVED
+};
+
+// packages/animations/src/spinner-handle.ts
+var HIDE_CURSOR = "\x1B[?25l";
+var SHOW_CURSOR = "\x1B[?25h";
+var CLEAR_LINE = "\r\x1B[2K";
+var NOOP_HANDLE = Object.freeze({
+  start() {
+  },
+  stop() {
+  },
+  update() {
+  },
+  enabled: false
+});
+var activeRestores = /* @__PURE__ */ new Set();
+var exitListenersInstalled = false;
+function ensureProcessExitListeners() {
+  if (exitListenersInstalled) return;
+  exitListenersInstalled = true;
+  const restoreAll = () => {
+    for (const fn of activeRestores) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+    activeRestores.clear();
+  };
+  process.once("exit", restoreAll);
+  process.once("SIGINT", () => {
+    restoreAll();
+    process.exit(130);
+  });
+  process.once("SIGTERM", () => {
+    restoreAll();
+    process.exit(143);
+  });
+}
+function createSpinnerHandle(context, name, label, options) {
+  if (!context.enabled) return NOOP_HANDLE;
+  const spinner = resolveSpinner(name);
+  if (!spinner) return NOOP_HANDLE;
+  const delayMs = options?.delayMs ?? 150;
+  let timer = null;
+  let delayTimer = null;
+  let frameIndex = 0;
+  let currentLabel = label;
+  let visible = false;
+  let registeredRestore = null;
+  function render() {
+    const frame = spinner.frames[frameIndex++ % spinner.frames.length];
+    process.stdout.write(`${CLEAR_LINE}  ${frame} ${currentLabel}`);
+  }
+  function clear() {
+    if (visible) {
+      process.stdout.write(`${CLEAR_LINE}${SHOW_CURSOR}`);
+      visible = false;
+    }
+  }
+  function deregister() {
+    if (registeredRestore) {
+      activeRestores.delete(registeredRestore);
+      registeredRestore = null;
+    }
+  }
+  return {
+    enabled: true,
+    start() {
+      if (timer || delayTimer) return;
+      ensureProcessExitListeners();
+      registeredRestore = clear;
+      activeRestores.add(registeredRestore);
+      delayTimer = setTimeout(() => {
+        delayTimer = null;
+        process.stdout.write(HIDE_CURSOR);
+        visible = true;
+        render();
+        timer = setInterval(render, spinner.interval);
+      }, delayMs);
+    },
+    stop(finalLine) {
+      if (delayTimer) {
+        clearTimeout(delayTimer);
+        delayTimer = null;
+      }
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      clear();
+      deregister();
+      if (finalLine !== void 0 && finalLine.length > 0) {
+        process.stdout.write(`${finalLine}
+`);
+      }
+    },
+    update(newLabel) {
+      currentLabel = newLabel;
+    }
+  };
+}
+
+// packages/cleo/src/cli/animation-bridge.ts
+function deriveSpinnerLabel(domain, operation) {
+  const key = `${domain}.${operation}`;
+  switch (key) {
+    case "tasks.list":
+    case "tasks.find":
+    case "tasks.search":
+      return { label: "Searching tasks\u2026", spinner: "sweeping" };
+    case "tasks.show":
+    case "tasks.depends":
+      return { label: "Loading task\u2026", spinner: "weaving" };
+    case "tasks.tree":
+    case "tasks.deps.tree":
+    case "tasks.deps.validate":
+      return { label: "Building dep graph\u2026", spinner: "looming" };
+    case "orchestrate.waves":
+    case "orchestrate.ready":
+      return { label: "Computing waves\u2026", spinner: "tapestry" };
+    case "session.briefing.show":
+    case "session.status":
+      return { label: "Resolving session\u2026", spinner: "awakening" };
+    case "memory.find":
+    case "brain.find":
+    case "brain.digest":
+      return { label: "Querying BRAIN\u2026", spinner: "refinery" };
+    case "nexus.query":
+    case "nexus.context":
+    case "nexus.impact":
+      return { label: "Walking the graph\u2026", spinner: "looming" };
+    default:
+      return { label: "Working\u2026", spinner: "weaving" };
+  }
+}
+function createDispatchSpinner(domain, operation) {
+  const flagResolution = getFormatContext();
+  const animCtx = createAnimateContext({ flagResolution });
+  const { label, spinner } = deriveSpinnerLabel(domain, operation);
+  return createSpinnerHandle(animCtx, spinner, label);
+}
+
+// packages/cleo/src/dispatch/dispatcher.ts
+import { createGatewayHandler, Dispatcher } from "@cleocode/runtime/gateway/dispatch";
+
+// packages/cleo/src/dispatch/middleware/audit.ts
+import { getLogger } from "@cleocode/core/logger";
+import { getProjectInfoSync } from "@cleocode/core/project-info";
+import { resolveSessionIdFromEnv } from "@cleocode/core/sessions/session-id";
+import { resolveBoundSession } from "@cleocode/core/store/session-store";
+
+// packages/cleo/src/dispatch/lib/config-loader.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+
+// packages/cleo/src/dispatch/middleware/rate-limiter.ts
+var DEFAULT_RATE_LIMITING = {
+  enabled: true,
+  query: { maxRequests: 100, windowMs: 6e4 },
+  mutate: { maxRequests: 30, windowMs: 6e4 },
+  spawn: { maxRequests: 10, windowMs: 6e4 }
+};
+
+// packages/cleo/src/dispatch/lib/defaults.ts
+var DEFAULT_LIFECYCLE_ENFORCEMENT = {
+  mode: "strict",
+  allowSkip: ["consensus"],
+  emergencyBypass: false
+};
+var DEFAULT_PROTOCOL_VALIDATION = {
+  strictMode: true,
+  blockOnViolation: true,
+  logViolations: true
+};
+var DEFAULT_CONFIG = {
+  cliPath: "cleo",
+  timeout: 3e4,
+  // 30 seconds
+  logLevel: "info",
+  enableMetrics: false,
+  maxRetries: 3,
+  queryCache: true,
+  queryCacheTtl: 3e4,
+  // 30 seconds
+  auditLog: true,
+  strictValidation: true,
+  lifecycleEnforcement: { ...DEFAULT_LIFECYCLE_ENFORCEMENT },
+  protocolValidation: { ...DEFAULT_PROTOCOL_VALIDATION },
+  rateLimiting: { ...DEFAULT_RATE_LIMITING }
+};
+var ENV_PREFIX = "CLEO_";
+var CONFIG_SCHEMA = {
+  cliPath: { type: "string", required: true },
+  timeout: { type: "number", min: 1e3, max: 3e5 },
+  logLevel: { type: "string", enum: ["debug", "info", "warn", "error"] },
+  enableMetrics: { type: "boolean" },
+  maxRetries: { type: "number", min: 0, max: 10 },
+  queryCache: { type: "boolean" },
+  queryCacheTtl: { type: "number", min: 0, max: 6e5 },
+  auditLog: { type: "boolean" },
+  strictValidation: { type: "boolean" }
+};
+
+// packages/cleo/src/dispatch/lib/config-loader.ts
+var ConfigValidationError = class extends Error {
+  constructor(field, value, constraint) {
+    super(`Invalid config field '${field}': ${constraint} (got ${value})`);
+    this.field = field;
+    this.value = value;
+    this.constraint = constraint;
+    this.name = "ConfigValidationError";
+  }
+  field;
+  value;
+  constraint;
+};
+function loadFromEnv(key) {
+  const envKey = `${ENV_PREFIX}${key.toUpperCase()}`;
+  return process.env[envKey];
+}
+function parseEnvValue(key, value) {
+  const schema = CONFIG_SCHEMA[key];
+  if (schema.type === "boolean") {
+    return value.toLowerCase() === "true" || value === "1";
+  }
+  if (schema.type === "number") {
+    const num = parseInt(value, 10);
+    if (Number.isNaN(num)) {
+      throw new ConfigValidationError(key, value, "must be a number");
+    }
+    return num;
+  }
+  return value;
+}
+function loadFromFile(projectRoot) {
+  const root = projectRoot || process.cwd();
+  const configPath = join(root, CLEO_DIR_NAME, CONFIG_JSON);
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(content);
+    const result = {};
+    if (config.lifecycleEnforcement) {
+      result.lifecycleEnforcement = {
+        ...DEFAULT_LIFECYCLE_ENFORCEMENT,
+        ...config.lifecycleEnforcement
+      };
+    }
+    if (config.protocolValidation) {
+      result.protocolValidation = {
+        ...DEFAULT_PROTOCOL_VALIDATION,
+        ...config.protocolValidation
+      };
+    }
+    if (config.rateLimiting) {
+      const rlConfig = config.rateLimiting;
+      result.rateLimiting = {
+        ...DEFAULT_RATE_LIMITING,
+        ...rlConfig,
+        query: { ...DEFAULT_RATE_LIMITING.query, ...rlConfig?.query },
+        mutate: { ...DEFAULT_RATE_LIMITING.mutate, ...rlConfig?.mutate },
+        spawn: { ...DEFAULT_RATE_LIMITING.spawn, ...rlConfig?.spawn }
+      };
+    }
+    return result;
+  } catch (error) {
+    console.error(`Warning: Failed to load config file: ${error}`);
+    return {};
+  }
+}
+function validateField(key, value) {
+  const schema = CONFIG_SCHEMA[key];
+  if (!schema) {
+    return;
+  }
+  const actualType = typeof value;
+  if (actualType !== schema.type) {
+    throw new ConfigValidationError(key, value, `must be of type ${schema.type}`);
+  }
+  if ("enum" in schema && schema.enum && !schema.enum.includes(value)) {
+    throw new ConfigValidationError(key, value, `must be one of: ${schema.enum.join(", ")}`);
+  }
+  if (schema.type === "number") {
+    const numValue = value;
+    if ("min" in schema && numValue < schema.min) {
+      throw new ConfigValidationError(key, value, `must be >= ${schema.min}`);
+    }
+    if ("max" in schema && numValue > schema.max) {
+      throw new ConfigValidationError(key, value, `must be <= ${schema.max}`);
+    }
+  }
+}
+function validateConfig(config) {
+  for (const [key, value] of Object.entries(config)) {
+    validateField(key, value);
+  }
+  for (const [key, schema] of Object.entries(CONFIG_SCHEMA)) {
+    if ("required" in schema && schema.required) {
+      if (config[key] === void 0) {
+        throw new ConfigValidationError(key, void 0, "is required");
+      }
+    }
+  }
+}
+function loadConfig(projectRoot) {
+  const config = {
+    ...DEFAULT_CONFIG,
+    lifecycleEnforcement: { ...DEFAULT_LIFECYCLE_ENFORCEMENT },
+    protocolValidation: { ...DEFAULT_PROTOCOL_VALIDATION },
+    rateLimiting: {
+      ...DEFAULT_RATE_LIMITING,
+      query: { ...DEFAULT_RATE_LIMITING.query },
+      mutate: { ...DEFAULT_RATE_LIMITING.mutate },
+      spawn: { ...DEFAULT_RATE_LIMITING.spawn }
+    }
+  };
+  const fileConfig = loadFromFile(projectRoot);
+  const {
+    lifecycleEnforcement: fileLc,
+    protocolValidation: filePv,
+    rateLimiting: fileRl,
+    ...restFileConfig
+  } = fileConfig;
+  if (fileLc) {
+    config.lifecycleEnforcement = { ...config.lifecycleEnforcement, ...fileLc };
+  }
+  if (filePv) {
+    config.protocolValidation = { ...config.protocolValidation, ...filePv };
+  }
+  if (fileRl) {
+    config.rateLimiting = {
+      ...config.rateLimiting,
+      ...fileRl,
+      query: { ...config.rateLimiting.query, ...fileRl.query },
+      mutate: { ...config.rateLimiting.mutate, ...fileRl.mutate },
+      spawn: { ...config.rateLimiting.spawn, ...fileRl.spawn }
+    };
+  }
+  Object.assign(config, restFileConfig);
+  for (const key of Object.keys(DEFAULT_CONFIG)) {
+    const envValue = loadFromEnv(key);
+    if (envValue !== void 0) {
+      config[key] = parseEnvValue(key, envValue);
+    }
+  }
+  validateConfig(config);
+  return config;
+}
+var globalConfig = null;
+function getConfig() {
+  if (globalConfig === null) {
+    globalConfig = loadConfig();
+  }
+  return globalConfig;
+}
+
+// packages/cleo/src/dispatch/middleware/audit.ts
+import { queryAudit } from "@cleocode/core/audit";
+var log = getLogger("audit");
+var cachedProjectHash;
+function resolveProjectHash() {
+  if (cachedProjectHash !== void 0) return cachedProjectHash;
+  try {
+    const info = getProjectInfoSync();
+    cachedProjectHash = info?.projectHash ?? null;
+  } catch {
+    cachedProjectHash = null;
+  }
+  return cachedProjectHash ?? null;
+}
+async function isGradeMode() {
+  if (process.env.CLEO_SESSION_GRADE === "true") return true;
+  try {
+    const session = (await resolveBoundSession())?.session;
+    if (session?.gradeMode) return true;
+  } catch {
+  }
+  return false;
+}
+async function getActiveSessionInfo() {
+  const gradeId = process.env.CLEO_SESSION_GRADE_ID;
+  if (gradeId && process.env.CLEO_SESSION_GRADE === "true") {
+    return { id: gradeId, gradeMode: true };
+  }
+  const envId = resolveSessionIdFromEnv();
+  if (envId) {
+    return { id: envId, gradeMode: false };
+  }
+  return null;
+}
+async function writeToSqlite(entry, requestId, response) {
+  try {
+    const { getDb } = await import("@cleocode/core/store/sqlite");
+    const { auditLog } = await import("@cleocode/core/store/schema/audit");
+    const { AuditLogInsertSchema } = await import("@cleocode/core/store/audit-log-schema");
+    const { randomUUID: randomUUID3 } = await import("node:crypto");
+    const payload = {
+      id: randomUUID3(),
+      timestamp: entry.timestamp,
+      action: entry.operation,
+      taskId: entry.metadata.taskId ?? "system",
+      actor: entry.metadata.userId ?? "agent",
+      detailsJson: JSON.stringify(entry.params),
+      // Dispatch-level columns (ADR-019)
+      domain: entry.domain,
+      operation: entry.operation,
+      sessionId: entry.sessionId,
+      requestId: requestId ?? null,
+      idempotencyKey: typeof entry.params["idempotencyKey"] === "string" ? entry.params["idempotencyKey"] : null,
+      durationMs: entry.result.duration,
+      success: entry.result.success ? 1 : 0,
+      source: entry.metadata.source,
+      gateway: entry.metadata.gateway ?? null,
+      errorMessage: entry.error ?? null,
+      afterJson: typeof entry.params["idempotencyKey"] === "string" && response ? JSON.stringify({
+        success: response.success,
+        ...response.data !== void 0 ? { data: response.data } : {},
+        ...response.page !== void 0 ? { page: response.page } : {},
+        ...response.partial !== void 0 ? { partial: response.partial } : {},
+        ...response.error !== void 0 ? { error: response.error } : {}
+      }) : null,
+      // Project correlation (T5337)
+      projectHash: resolveProjectHash()
+    };
+    const parsed = AuditLogInsertSchema.safeParse(payload);
+    if (!parsed.success) {
+      log.warn(
+        { issues: parsed.error.issues },
+        "Audit payload failed Zod validation; skipping insert"
+      );
+      return;
+    }
+    const db = await getDb(process.cwd());
+    await db.insert(auditLog).values(parsed.data).run();
+  } catch (err) {
+    log.warn({ err }, "Failed to write audit entry to SQLite");
+  }
+}
+function createAudit() {
+  return async (req, next) => {
+    const startTime = Date.now();
+    const currentSessionId = req.sessionId ?? (await getActiveSessionInfo())?.id ?? null;
+    const isGradeSession = await isGradeMode();
+    const response = await next();
+    const shouldAudit = req.gateway === "mutate" || req.gateway === "query" && isGradeSession;
+    if (!shouldAudit) return response;
+    const config = getConfig();
+    if (!config.auditLog) return response;
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      sessionId: currentSessionId,
+      domain: req.domain,
+      operation: req.operation,
+      params: req.params || {},
+      result: {
+        success: response.success,
+        exitCode: response.error?.exitCode || 0,
+        duration: Date.now() - startTime
+      },
+      metadata: {
+        taskId: req.params?.taskId || req.params?.parent,
+        source: req.source,
+        gateway: req.gateway
+      },
+      error: response.error?.message
+    };
+    log.info(
+      {
+        domain: entry.domain,
+        operation: entry.operation,
+        sessionId: entry.sessionId,
+        taskId: entry.metadata.taskId,
+        gateway: entry.metadata.gateway,
+        success: entry.result.success,
+        exitCode: entry.result.exitCode,
+        durationMs: entry.result.duration,
+        idempotencyKey: typeof entry.params["idempotencyKey"] === "string" ? entry.params["idempotencyKey"] : void 0
+      },
+      `${entry.metadata.gateway ?? "dispatch"} ${entry.domain}.${entry.operation}`
+    );
+    await writeToSqlite(entry, req.requestId, response);
+    return response;
+  };
+}
+
+// packages/cleo/src/dispatch/middleware/budget-enforcement.ts
+import { ExitCode } from "@cleocode/contracts/exit-codes.js";
+
+// packages/cleo/src/dispatch/lib/budget.ts
+import { MVI_TRUTH_FIELDS } from "@cleocode/core/dispatch/mvi-projection";
+import { applyBudgetEnforcement, BUDGET_EXCEEDED_CODE, checkBudget } from "@cleocode/lafs";
+var DEFAULT_BUDGET = 4e3;
+function toProtoEnvelope(response) {
+  const protoMeta = response["meta"] ?? {};
+  return {
+    $schema: "https://lafs.dev/schemas/v1/envelope.schema.json",
+    _meta: Object.keys(protoMeta).length > 0 ? protoMeta : {
+      specVersion: "1.2.3",
+      schemaVersion: "2026.2.1",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      operation: "dispatch.response",
+      requestId: "budget-check",
+      transport: "sdk",
+      strict: true,
+      mvi: "standard",
+      contextVersion: 1
+    },
+    success: response["success"] ?? true,
+    result: response["data"] ?? null,
+    ...response["error"] ? { error: response["error"] } : {}
+  };
+}
+function enforceBudget(response, budgetOrOptions) {
+  const options = typeof budgetOrOptions === "number" ? { budget: budgetOrOptions } : budgetOrOptions ?? {};
+  const effectiveBudget = options.budget ?? DEFAULT_BUDGET;
+  const mode = options.mode ?? "truncate";
+  const envelope = toProtoEnvelope(response);
+  const enforcement = applyBudgetEnforcement(
+    envelope,
+    effectiveBudget,
+    // In 'truncate' mode the engine attempts to shrink the payload; in 'error'
+    // mode we skip truncation so the overflow surfaces as an error envelope.
+    { truncateOnExceed: mode === "truncate", requiredFields: MVI_TRUTH_FIELDS }
+  );
+  const exceeded = !enforcement.withinBudget;
+  const meta = response["meta"] ?? {};
+  meta["_budgetEnforcement"] = {
+    budget: effectiveBudget,
+    estimatedTokens: enforcement.estimatedTokens,
+    withinBudget: enforcement.withinBudget,
+    truncated: enforcement.truncated,
+    mode
+  };
+  return {
+    response: {
+      ...response,
+      meta,
+      // Replace data with the (possibly truncated) result when truncation
+      // actually occurred.
+      ...enforcement.truncated && enforcement.envelope.result !== void 0 && {
+        data: enforcement.envelope.result
+      }
+    },
+    enforcement,
+    exceeded
+  };
+}
+
+// packages/cleo/src/dispatch/lib/budget-ceilings.ts
+var FOCUS_TOKEN_CEILING = 1500;
+var BRIEFING_TOKEN_CEILING = 4e3;
+var BUDGET_POLICIES = {
+  "focus.show": { budget: FOCUS_TOKEN_CEILING, mode: "truncate" },
+  "session.briefing.show": { budget: BRIEFING_TOKEN_CEILING, mode: "truncate" }
+};
+
+// packages/cleo/src/dispatch/middleware/budget-enforcement.ts
+function resolvePolicy(req) {
+  const override = req.params?.["_budget"];
+  if (typeof override === "number" && Number.isFinite(override) && override >= 0) {
+    const modeOverride = req.params?.["_budgetMode"];
+    const mode = modeOverride === "error" || modeOverride === "truncate" ? modeOverride : "truncate";
+    return { budget: override, mode };
+  }
+  const opKey = `${req.domain}.${req.operation}`;
+  return BUDGET_POLICIES[opKey];
+}
+function budgetExceededError(details) {
+  const estimated = typeof details["estimatedTokens"] === "number" ? details["estimatedTokens"] : 0;
+  const budget = typeof details["budget"] === "number" ? details["budget"] : 0;
+  return {
+    code: BUDGET_EXCEEDED_CODE,
+    exitCode: ExitCode.VALIDATION_ERROR,
+    message: `Response exceeds declared MVI budget: estimated ${estimated} tokens, budget ${budget} tokens`,
+    details,
+    fix: "Request a narrower view (e.g. add --limit, --field, or a tighter --mvi level) or raise the budget."
+  };
+}
+function createBudgetEnforcement() {
+  return async (req, next) => {
+    const policy = resolvePolicy(req);
+    if (req.params) {
+      if ("_budget" in req.params) delete req.params["_budget"];
+      if ("_budgetMode" in req.params) delete req.params["_budgetMode"];
+    }
+    if (policy && req.gateway === "mutate") {
+      const meta = {
+        gateway: req.gateway,
+        domain: req.domain,
+        operation: req.operation,
+        source: req.source,
+        requestId: req.requestId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        duration_ms: 0
+      };
+      const minimum = enforceBudget(
+        { success: true, meta, data: {} },
+        { budget: policy.budget, mode: "error" }
+      );
+      if (minimum.exceeded) {
+        return {
+          success: false,
+          meta,
+          data: null,
+          error: budgetExceededError({
+            budget: policy.budget,
+            estimatedTokens: minimum.enforcement.estimatedTokens
+          })
+        };
+      }
+    }
+    const response = await next();
+    if (!policy || !response.success || response.data === void 0) {
+      return response;
+    }
+    const options = {
+      budget: policy.budget,
+      mode: req.gateway === "mutate" ? "error" : policy.mode
+    };
+    const { response: enforced, exceeded } = enforceBudget(
+      // Bridge the canonical DispatchResponse into the Record shape enforceBudget
+      // consumes. Field names (meta/data/success) match 1:1.
+      { meta: response.meta, data: response.data, success: response.success },
+      options
+    );
+    const enforcedData = enforced["data"];
+    const enforcedMeta = enforced["meta"] ?? response.meta;
+    if (exceeded && req.gateway === "mutate") {
+      return { ...response, meta: enforcedMeta };
+    }
+    if (exceeded) {
+      const beDetails = enforcedMeta["_budgetEnforcement"] ?? {};
+      return {
+        ...response,
+        meta: enforcedMeta,
+        success: false,
+        data: null,
+        error: budgetExceededError(beDetails)
+      };
+    }
+    response.meta = enforcedMeta;
+    if (enforcedData !== void 0) {
+      response.data = enforcedData;
+    }
+    return response;
+  };
+}
+
+// packages/cleo/src/dispatch/middleware/claim-heartbeat.ts
+var CLAIM_HEARTBEAT_BUDGET_MS = 250;
+function createClaimHeartbeat(renew, budgetMs = CLAIM_HEARTBEAT_BUDGET_MS) {
+  return async (req, next) => {
+    const response = await next();
+    const sessionId = req.sessionId;
+    if (req.gateway === "mutate" && response.success && sessionId) {
+      const renewal = renew(req, sessionId).catch(() => void 0);
+      let timer;
+      const budget = new Promise((resolve2) => {
+        timer = setTimeout(resolve2, budgetMs);
+        timer.unref?.();
+      });
+      await Promise.race([renewal, budget]);
+      if (timer) clearTimeout(timer);
+    }
+    return response;
+  };
+}
+
+// packages/cleo/src/dispatch/middleware/field-filter.ts
+import { isMVILevel, applyFieldFilter as sdkApplyFieldFilter } from "@cleocode/lafs";
+function createFieldFilter() {
+  return async (req, next) => {
+    const _fields = req._fields ?? req.params?._fields;
+    const rawMvi = req._mvi ?? req.params?._mvi;
+    const _mvi = isMVILevel(rawMvi) ? rawMvi : void 0;
+    if (req.params) {
+      delete req.params["_fields"];
+      delete req.params["_mvi"];
+    }
+    if (_fields) req._fields = _fields;
+    if (_mvi) req._mvi = _mvi;
+    const response = await next();
+    if (_fields?.length && response.success && response.data !== void 0) {
+      const stub = {
+        $schema: "https://lafs.dev/schemas/v1/envelope.schema.json",
+        _meta: {
+          specVersion: "",
+          schemaVersion: "",
+          timestamp: response.meta.timestamp,
+          operation: response.meta.operation,
+          requestId: response.meta.requestId,
+          transport: "sdk",
+          strict: true,
+          mvi: "minimal",
+          contextVersion: 0
+        },
+        success: true,
+        result: response.data
+      };
+      const filtered = sdkApplyFieldFilter(
+        stub,
+        _fields
+      );
+      response.data = filtered.result ?? void 0;
+    }
+    return response;
+  };
+}
+
+// packages/cleo/src/dispatch/middleware/idempotency.ts
+function getIdempotencyKey(params) {
+  const value = params?.["idempotencyKey"];
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function asStoredResponse(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  if (typeof candidate.success !== "boolean") return null;
+  return value;
+}
+function stripIdempotencyKey(params) {
+  if (!params || typeof params !== "object" || Array.isArray(params)) return params;
+  const clone = { ...params };
+  delete clone["idempotencyKey"];
+  return clone;
+}
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableJson(item)).join(",")}]`;
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    return `{${entries.map(([key, val]) => `${JSON.stringify(key)}:${stableJson(val)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function sameRequestParams(currentParams, persistedJson) {
+  try {
+    const persisted = JSON.parse(persistedJson);
+    return stableJson(stripIdempotencyKey(currentParams ?? {})) === stableJson(stripIdempotencyKey(persisted));
+  } catch {
+    return false;
+  }
+}
+async function findPersistedResponse(req, idempotencyKey) {
+  try {
+    const { getDb, getNativeDb, getProjectInfoSync: getProjectInfoSync2 } = await import("@cleocode/core/internal");
+    let projectHash = null;
+    try {
+      projectHash = getProjectInfoSync2()?.projectHash ?? null;
+    } catch {
+      projectHash = null;
+    }
+    if (!projectHash) return { kind: "miss" };
+    await getDb(process.cwd());
+    const db = getNativeDb();
+    if (!db) return { kind: "miss" };
+    const values = [req.domain, req.operation, idempotencyKey, projectHash];
+    const rows = db.prepare(
+      `SELECT after_json AS afterJson, details_json AS detailsJson
+         FROM audit_log
+         WHERE domain = ?
+           AND operation = ?
+           AND idempotency_key = ?
+           AND success = 1
+           AND project_hash = ?
+         ORDER BY timestamp DESC
+         LIMIT 1`
+    ).all(...values);
+    const row = rows[0];
+    if (!row?.afterJson) return { kind: "miss" };
+    if (!row.detailsJson || !sameRequestParams(req.params, row.detailsJson)) {
+      return { kind: "conflict" };
+    }
+    const response = asStoredResponse(JSON.parse(row.afterJson));
+    return response ? { kind: "hit", response } : { kind: "miss" };
+  } catch {
+    return { kind: "miss" };
+  }
+}
+function createIdempotency() {
+  return async (req, next) => {
+    if (req.gateway !== "mutate") return next();
+    const resolved = resolve(req.gateway, req.domain, req.operation);
+    const idempotencyKey = getIdempotencyKey(req.params);
+    if (!resolved?.def.idempotent) {
+      if (idempotencyKey) {
+        return {
+          meta: {
+            gateway: req.gateway,
+            domain: req.domain,
+            operation: req.operation,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            duration_ms: 0,
+            source: req.source,
+            requestId: req.requestId,
+            ...req.sessionId ? { sessionId: req.sessionId } : {},
+            idempotencyKey
+          },
+          success: false,
+          error: {
+            code: "E_IDEMPOTENCY_UNSUPPORTED",
+            message: `${req.domain}.${req.operation} does not support --idempotency-key, so the key was NOT applied. Do not retry this command blindly: query first with \`cleo find\` or \`cleo show <id> --full\` to establish whether the previous attempt committed.`,
+            details: {
+              domain: req.domain,
+              operation: req.operation,
+              idempotencySupported: false
+            }
+          }
+        };
+      }
+      return next();
+    }
+    if (!idempotencyKey) return next();
+    const lookup = await findPersistedResponse(req, idempotencyKey);
+    if (lookup.kind === "miss") return next();
+    if (lookup.kind === "conflict") {
+      return {
+        meta: {
+          gateway: req.gateway,
+          domain: req.domain,
+          operation: req.operation,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          duration_ms: 0,
+          source: req.source,
+          requestId: req.requestId,
+          ...req.sessionId ? { sessionId: req.sessionId } : {},
+          idempotencyKey
+        },
+        success: false,
+        error: {
+          code: "E_IDEMPOTENCY_KEY_CONFLICT",
+          message: "Idempotency key was already used with different parameters",
+          details: { domain: req.domain, operation: req.operation }
+        }
+      };
+    }
+    const persisted = lookup.response;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      meta: {
+        gateway: req.gateway,
+        domain: req.domain,
+        operation: req.operation,
+        timestamp: now,
+        duration_ms: 0,
+        source: req.source,
+        requestId: req.requestId,
+        ...req.sessionId ? { sessionId: req.sessionId } : {},
+        idempotencyKey,
+        idempotentReplay: true
+      },
+      success: persisted.success,
+      ...persisted.data !== void 0 ? { data: persisted.data } : {},
+      ...persisted.page !== void 0 ? { page: persisted.page } : {},
+      ...persisted.partial !== void 0 ? { partial: persisted.partial } : {},
+      ...persisted.error !== void 0 ? { error: persisted.error } : {}
+    };
+  };
+}
+
+// packages/cleo/src/dispatch/middleware/mutate-minimal-envelope.ts
+import {
+  applyMutateProjection,
+  MUTATE_PROJECTION_PLANS
+} from "@cleocode/core/dispatch/mutate-projection";
+import { resolveProjectionMode } from "@cleocode/core/dispatch/mvi-projection";
+import { isJsonPointer } from "@cleocode/core/dispatch/projection";
+function resolveModeFor(req) {
+  const override = req.params?.["_projection"];
+  if (override === "full" || override === "mvi") return override;
+  return resolveProjectionMode(getProjectionOptOut() || void 0);
+}
+var OPERATION_BUCKETS = {
+  "tasks.add": "created",
+  "tasks.add-batch": "created",
+  // T11482 (DHQ-036): saga.create now projects the created saga ID into the
+  // `created` bucket so `--field /data/created/0` resolves a parseable saga ID.
+  "tasks.saga.create": "created",
+  "tasks.update": "updated",
+  "tasks.complete": "updated",
+  "tasks.delete": "deleted"
+};
+var BASE_DATA_FIELDS = /* @__PURE__ */ new Set([
+  "count",
+  "created",
+  "updated",
+  "deleted",
+  "ids",
+  "fieldPathHints",
+  "status",
+  "completedAt",
+  "changes",
+  "dryRun",
+  "duplicate",
+  "acceptanceCriteriaIds",
+  "autoCompleted",
+  // T12660: `cleo complete` reports a cleared focus pointer + next ready task.
+  "focusCleared",
+  "nextSuggested",
+  "cascadeDeleted",
+  // T10599 add-batch dry-run semantics exposed by the projected mutate
+  // envelope. Keep these pointer-addressable for --field consumers.
+  "wouldCreate",
+  "wouldAffect",
+  "insertedCount",
+  "validatedCount",
+  "validationFindings",
+  "knowledgeCoverage"
+]);
+function decodePointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function prevalidateMutateProjectionPointer(operation, pointer) {
+  if (pointer === "" || pointer === "/") return null;
+  if (!pointer.startsWith("/data/")) return null;
+  const [, root, field, index] = pointer.split("/").map(decodePointerToken);
+  if (root !== "data" || !field || !BASE_DATA_FIELDS.has(field)) {
+    return `Pointer "${pointer}" is not available on the projected mutation envelope. Use /data/created/0, /data/updated/0, /data/deleted/0, or legacy /data/ids/0.`;
+  }
+  const bucket = OPERATION_BUCKETS[operation];
+  if (index !== void 0 && ["created", "updated", "deleted"].includes(field) && field !== bucket) {
+    return `Pointer "${pointer}" cannot resolve for ${operation}; use /data/${bucket}/0.`;
+  }
+  return null;
+}
+function fieldNotFoundResponse(req, message) {
+  return {
+    meta: {
+      gateway: req.gateway,
+      domain: req.domain,
+      operation: req.operation,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      duration_ms: 0,
+      source: req.source,
+      requestId: req.requestId,
+      mutateProjection: "mvi"
+    },
+    success: false,
+    error: {
+      code: "E_FIELD_NOT_FOUND",
+      exitCode: 4,
+      message,
+      details: { phase: "prewrite-field-projection-validation" }
+    }
+  };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object";
+}
+function safeRead(value, key) {
+  try {
+    return value[key];
+  } catch {
+    return void 0;
+  }
+}
+function safeStringArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function addUnique(target, values) {
+  for (const value of values) {
+    if (!target.includes(value)) target.push(value);
+  }
+}
+function collectCreatedIds(data) {
+  if (!isRecord(data)) return { created: [], acceptanceCriteriaIds: [] };
+  const created = [];
+  const acceptanceCriteriaIds = [];
+  const task = safeRead(data, "task");
+  if (isRecord(task)) {
+    const id = safeRead(task, "id");
+    if (typeof id === "string") created.push(id);
+  }
+  const createdIds = safeRead(data, "createdIds");
+  if (isRecord(createdIds)) {
+    addUnique(created, safeStringArray(safeRead(createdIds, "tasks")));
+    addUnique(acceptanceCriteriaIds, safeStringArray(safeRead(createdIds, "acceptanceCriteria")));
+  }
+  const tasks = safeRead(data, "tasks");
+  if (Array.isArray(tasks)) {
+    for (const entry of tasks) {
+      if (!isRecord(entry)) continue;
+      const nestedTask = safeRead(entry, "task");
+      const id = isRecord(nestedTask) ? safeRead(nestedTask, "id") : safeRead(entry, "id");
+      if (typeof id === "string" && !created.includes(id)) created.push(id);
+    }
+  }
+  return { created, acceptanceCriteriaIds };
+}
+function buildProjectionFailureWarning(data, error) {
+  const { created, acceptanceCriteriaIds } = collectCreatedIds(data);
+  const createdSuffix = created.length > 0 ? ` Created task IDs: ${created.join(", ")}.` : "";
+  const acSuffix = acceptanceCriteriaIds.length > 0 ? ` Acceptance criteria IDs: ${acceptanceCriteriaIds.join(", ")}.` : "";
+  const warning = {
+    code: "W_MUTATE_PROJECTION_FAILED",
+    message: `Mutation succeeded, but the response projection failed.${createdSuffix}${acSuffix} Do not retry creation; inspect the IDs above or rerun with --full if you need the unprojected payload.`,
+    created,
+    acceptanceCriteriaIds,
+    retryHazard: true,
+    recoveryHint: "Do not retry creation. Use the emitted IDs with cleo show, or rerun the command with --full only for inspection."
+  };
+  if (error instanceof Error && error.message.length > 0) warning.cause = error.message;
+  return warning;
+}
+function createMutateMinimalEnvelope() {
+  return async (req, next) => {
+    const mode = resolveModeFor(req);
+    const opKey = `${req.domain}.${req.operation}`;
+    const hasPlan = MUTATE_PROJECTION_PLANS[opKey] !== void 0;
+    const field = getFieldContext().field;
+    if (hasPlan && mode === "mvi" && field && isJsonPointer(field)) {
+      const validationError = prevalidateMutateProjectionPointer(opKey, field);
+      if (validationError) return fieldNotFoundResponse(req, validationError);
+    }
+    const response = await next();
+    if (!hasPlan) return response;
+    if (response.success && response.data !== void 0) {
+      try {
+        response.data = applyMutateProjection(response.data, opKey, mode);
+      } catch (error) {
+        response.partial = true;
+        response.meta.mutateProjection = "projection-failed";
+        response.meta.warning = buildProjectionFailureWarning(response.data, error);
+        return response;
+      }
+    }
+    response.meta.mutateProjection = mode;
+    return response;
+  };
+}
+
+// packages/cleo/src/dispatch/middleware/mvi-record-projection.ts
+import {
+  applyProjectionPlan,
+  PROJECTION_PLANS,
+  resolveProjectionMode as resolveProjectionMode2
+} from "@cleocode/core/dispatch/mvi-projection";
+import { extractByJsonPointer, isJsonPointer as isJsonPointer2 } from "@cleocode/core/dispatch/projection";
+function resolveModeFor2(req) {
+  const override = req.params?.["_projection"];
+  if (override === "full" || override === "mvi") return override;
+  return resolveProjectionMode2(getProjectionOptOut() || void 0);
+}
+function fieldPointerNeedsFullData(fullData, projectedData) {
+  const field = getFieldContext().field;
+  if (!field || !isJsonPointer2(field) || !field.startsWith("/data/")) return false;
+  const pointer = field.slice("/data".length);
+  return extractByJsonPointer(projectedData, pointer) === void 0 && extractByJsonPointer(fullData, pointer) !== void 0;
+}
+function createMviRecordProjection() {
+  return async (req, next) => {
+    const mode = resolveModeFor2(req);
+    if (req.params && "_projection" in req.params) {
+      delete req.params["_projection"];
+    }
+    const opKey = `${req.domain}.${req.operation}`;
+    const hasPlan = PROJECTION_PLANS[opKey] !== void 0;
+    const response = await next();
+    if (!hasPlan) return response;
+    let appliedMode = mode;
+    if (response.success && response.data !== void 0) {
+      const projected = applyProjectionPlan(response.data, opKey, mode);
+      if (mode === "mvi" && opKey === "tasks.show" && fieldPointerNeedsFullData(response.data, projected)) {
+        appliedMode = "full";
+      } else {
+        response.data = projected;
+      }
+    }
+    response.meta.projection = appliedMode;
+    return response;
+  };
+}
+
+// packages/cleo/src/dispatch/lib/security.ts
+import {
+  ALL_VALID_STATUSES,
+  DEFAULT_RATE_LIMITS,
+  ensureArray,
+  RateLimiter,
+  SecurityError,
+  sanitizeContent,
+  sanitizeParams,
+  sanitizePath,
+  sanitizeTaskId,
+  VALID_DOMAINS,
+  VALID_GATEWAYS,
+  VALID_LIFECYCLE_STAGE_STATUSES,
+  VALID_MANIFEST_STATUSES,
+  VALID_PRIORITIES,
+  validateEnum
+} from "@cleocode/core/security/input-sanitization";
+
+// packages/cleo/src/dispatch/middleware/sanitizer.ts
+function createSanitizer(getProjectRoot2) {
+  return async (req, next) => {
+    if (req.params) {
+      try {
+        const root = getProjectRoot2 ? getProjectRoot2() : void 0;
+        req.params = sanitizeParams(req.params, root, {
+          domain: req.domain,
+          operation: req.operation
+        });
+      } catch (error) {
+        return {
+          meta: {
+            gateway: req.gateway,
+            domain: req.domain,
+            operation: req.operation,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            duration_ms: 0,
+            source: req.source,
+            requestId: req.requestId
+          },
+          success: false,
+          error: {
+            code: "E_VALIDATION_FAILED",
+            exitCode: 6,
+            // VALIDATION_ERROR
+            message: error instanceof Error ? error.message : String(error)
+          }
+        };
+      }
+    }
+    return next();
+  };
+}
+
+// packages/cleo/src/dispatch/middleware/session-resolver.ts
+import { randomUUID } from "node:crypto";
+import { resolveSessionIdFromEnv as resolveSessionIdFromEnv2 } from "@cleocode/core/sessions/session-id";
+function resolveOriginSessionId(sessionId, executionSessionId) {
+  return process.env.CLEO_ORIGIN_SESSION_ID ?? process.env.CLEO_SESSION_ORIGIN_ID ?? sessionId ?? executionSessionId;
+}
+function resolveExecutionSessionId() {
+  return process.env.CLEO_EXECUTION_SESSION_ID ?? process.env.CLEO_SESSION_EXECUTION_ID ?? randomUUID();
+}
+function createSessionResolver(cliSessionLookup, onUnboundMutation) {
+  return async (req, next) => {
+    if (!req.executionSessionId) {
+      req.executionSessionId = resolveExecutionSessionId();
+    }
+    if (req.sessionId) {
+      req.originSessionId ??= resolveOriginSessionId(req.sessionId, req.executionSessionId);
+      return next();
+    }
+    const bound = getBoundSession();
+    if (bound) {
+      req.sessionId = bound.sessionId;
+      req.originSessionId ??= resolveOriginSessionId(req.sessionId, req.executionSessionId);
+      return next();
+    }
+    if (cliSessionLookup && req.source === "cli") {
+      try {
+        const activeId = await cliSessionLookup();
+        if (activeId) {
+          req.sessionId = activeId;
+          req.originSessionId ??= resolveOriginSessionId(req.sessionId, req.executionSessionId);
+          return next();
+        }
+      } catch {
+      }
+    }
+    const envGradeId = process.env.CLEO_SESSION_GRADE_ID;
+    if (envGradeId && process.env.CLEO_SESSION_GRADE === "true") {
+      req.sessionId = envGradeId;
+      req.originSessionId ??= resolveOriginSessionId(req.sessionId, req.executionSessionId);
+      return next();
+    }
+    const cliResolved = cliSessionLookup !== void 0 && req.source === "cli";
+    const envId = cliResolved ? null : resolveSessionIdFromEnv2();
+    if (envId) {
+      req.sessionId = envId;
+      req.originSessionId ??= resolveOriginSessionId(req.sessionId, req.executionSessionId);
+      return next();
+    }
+    req.originSessionId ??= resolveOriginSessionId(req.sessionId, req.executionSessionId);
+    if (onUnboundMutation && req.source === "cli" && req.gateway === "mutate" && req.domain !== "session") {
+      try {
+        await onUnboundMutation(req);
+      } catch {
+      }
+    }
+    return next();
+  };
+}
+
+// packages/cleo/src/dispatch/middleware/store-write-guard.ts
+var ALLOWED_WHILE_READ_ONLY = /* @__PURE__ */ new Set(["admin.backup"]);
+function createStoreWriteGuard(getProjectRoot2) {
+  return async (req, next) => {
+    if (req.gateway !== "mutate" || ALLOWED_WHILE_READ_ONLY.has(`${req.domain}.${req.operation}`)) {
+      return next();
+    }
+    let projectRoot;
+    try {
+      projectRoot = getProjectRoot2();
+    } catch {
+      return next();
+    }
+    const { storeWriteBlock } = await import("@cleocode/core/store/store-write-guard.js");
+    const blocked = await storeWriteBlock(projectRoot, {
+      domain: req.domain,
+      operation: req.operation
+    });
+    if (blocked === null) return next();
+    return {
+      success: false,
+      meta: {
+        gateway: req.gateway,
+        domain: req.domain,
+        operation: req.operation,
+        source: req.source,
+        requestId: req.requestId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        duration_ms: 0
+      },
+      data: null,
+      error: {
+        code: "E_TWIN_COLLAPSE_FAILED",
+        exitCode: blocked.code,
+        message: blocked.message,
+        ...blocked.details ? { details: blocked.details } : {},
+        ...blocked.fix ? { fix: blocked.fix } : {}
+      }
+    };
+  };
+}
+
+// packages/cleo/src/dispatch/middleware/telemetry.ts
+import { isTelemetryEnabled, recordTelemetryEvent } from "@cleocode/core/telemetry/index";
+function createTelemetry() {
+  return async (req, next) => {
+    const startTime = Date.now();
+    const response = await next();
+    try {
+      if (isTelemetryEnabled()) {
+        const durationMs = response.meta.duration_ms ?? Date.now() - startTime;
+        const exitCode = response.success ? 0 : response.error?.exitCode ?? 1;
+        const errorCode = response.error?.code ?? null;
+        recordTelemetryEvent({
+          domain: req.domain,
+          gateway: req.gateway,
+          operation: req.operation,
+          durationMs,
+          exitCode,
+          errorCode
+        }).catch(() => {
+        });
+      }
+    } catch {
+    }
+    return response;
+  };
+}
+
+// packages/cleo/src/dispatch/middleware/write-actor.ts
+import { runWithWriteActor } from "@cleocode/core/store/sync/write-actor";
+function createWriteActor() {
+  return async (req, next) => {
+    if (req.gateway !== "mutate") return next();
+    return runWithWriteActor(
+      {
+        op: `${req.domain}.${req.operation}`,
+        ...req.sessionId ? { session: req.sessionId } : {}
+      },
+      next
+    );
+  };
+}
+
+// packages/cleo/src/dispatch/adapters/cli.ts
+var ERROR_CODE_TO_EXIT = {
+  E_NOT_FOUND: 4,
+  E_INVALID_INPUT: 2,
+  E_FILE_ERROR: 3,
+  E_DEPENDENCY: 5,
+  E_VALIDATION: 6,
+  E_RETRYABLE: 7,
+  E_CONFIG_ERROR: 8,
+  E_PROJECT_MOVED: 9,
+  E_PARENT_NOT_FOUND: 10,
+  E_DEPTH_EXCEEDED: 11,
+  E_SIBLING_LIMIT: 12,
+  E_CIRCULAR_DEP: 14,
+  E_INVALID_PARENT_TYPE: 13,
+  E_ORPHAN_DETECTED: 15,
+  E_HAS_CHILDREN: 16,
+  E_TASK_COMPLETED: 17,
+  // ExitCode.TASK_COMPLETED — canonical value from @cleocode/contracts
+  E_HAS_DEPENDENTS: 19,
+  E_CHECKSUM_MISMATCH: 20,
+  E_CONFLICT: 23,
+  E_SESSION_UNBOUND: 24,
+  E_WORKTREE_LOCKED: 25,
+  E_TASK_RENAMED: 26,
+  E_TWIN_COLLAPSE_FAILED: 55,
+  E_SESSION_EXISTS: 30,
+  E_SESSION_NOT_FOUND: 31,
+  E_SCOPE_CONFLICT: 32,
+  E_ACTIVE_TASK_REQUIRED: 38,
+  E_INVALID_OPERATION: 2,
+  E_MISSING_PARAMS: 2,
+  E_NO_HANDLER: 1,
+  E_INTERNAL: 1,
+  // T9796 — docs canon CI gate: violation = fail-build, invalid = tool-error.
+  E_CANON_VIOLATION: 1,
+  E_CANON_INVALID: 2
+};
+var caampLibraryReady = null;
+function ensureCaampLibrary() {
+  caampLibraryReady ??= registerCaampLibrary();
+  return caampLibraryReady;
+}
+async function registerCaampLibrary() {
+  let caamp;
+  try {
+    caamp = await import("@cleocode/caamp");
+  } catch {
+    return;
+  }
+  const { catalog, registerSkillLibraryFromPath } = caamp;
+  if (catalog.isCatalogAvailable()) return;
+  try {
+    let skillsRoot = null;
+    try {
+      const req = createRequire(import.meta.url);
+      const skillsPkgJson = req.resolve("@cleocode/skills/package.json");
+      const candidate = dirname(skillsPkgJson);
+      if (existsSync2(join2(candidate, "skills", "manifest.json"))) {
+        skillsRoot = candidate;
+      }
+    } catch {
+    }
+    if (!skillsRoot) {
+      const thisFile = fileURLToPath(import.meta.url);
+      const packageRoot = join2(dirname(thisFile), "..", "..", "..", "..", "..");
+      const candidate = join2(packageRoot, "packages", "skills");
+      if (existsSync2(join2(candidate, "skills", "manifest.json"))) {
+        skillsRoot = candidate;
+      }
+    }
+    if (skillsRoot) {
+      registerSkillLibraryFromPath(skillsRoot);
+    }
+  } catch {
+  }
+}
+var BARREL_FREE_OPERATIONS = /* @__PURE__ */ new Set([
+  "query:tasks.show",
+  "query:tasks.find",
+  "query:tasks.list",
+  "query:tasks.current",
+  "query:session.status",
+  "query:session.briefing.show"
+]);
+async function prepareCoreFor(gateway, domain, operation) {
+  if (BARREL_FREE_OPERATIONS.has(`${gateway}:${domain}.${operation}`)) return;
+  await import("@cleocode/core/registrations");
+  await ensureCaampLibrary();
+}
+var _dispatcher = null;
+function getCliDispatcher() {
+  if (!_dispatcher) {
+    _dispatcher = createCliDispatcher();
+  }
+  return _dispatcher;
+}
+function createCliGatewayHandler() {
+  const dispatcher = getCliDispatcher();
+  return {
+    // A daemon serves every operation, so it prepares CORE the way the CLI
+    // does for an operation outside BARREL_FREE_OPERATIONS (T13126).
+    handle: async (req) => {
+      await import("@cleocode/core/internal");
+      await ensureCaampLibrary();
+      return dispatcher.dispatch(req);
+    }
+  };
+}
+async function lookupCliSession() {
+  try {
+    const { resolveBoundSessionId } = await import("@cleocode/core/store/session-store");
+    return await resolveBoundSessionId();
+  } catch {
+    return null;
+  }
+}
+async function heartbeatCliSession(_req, sessionId) {
+  const { heartbeatProjectSession } = await import("@cleocode/core/task-work/claims");
+  await heartbeatProjectSession(getProjectRoot(), sessionId);
+}
+async function warnUnboundMutation(req) {
+  if (getFormatContext().quiet) return;
+  const { hasActiveSession } = await import("@cleocode/core/store/session-store");
+  if (!await hasActiveSession()) return;
+  process.stderr.write(
+    `[cleo] warning: no session is bound to this terminal; ${req.domain}.${req.operation} is not attributed to any session (bind: 'cleo session start' | 'cleo session resume <id>' | CLEO_SESSION_ID=<id>)
+`
+  );
+}
+function createCliDispatcher() {
+  const handlers = createLazyDomainHandlers();
+  return new Dispatcher({
+    handlers,
+    middlewares: [
+      // T12535: refuse mutating ops while the store's twin collapse is failed
+      // (reads stay available, served from the merged TEMP shadows).
+      createStoreWriteGuard(() => getProjectRoot()),
+      createSessionResolver(lookupCliSession, warnUnboundMutation),
+      // T4959: session identity first; T12500: warn when unbound
+      createWriteActor(),
+      // T13229: local write frames record the command as actor.op
+      createClaimHeartbeat(heartbeatCliSession),
+      // T12502 · T12540: a bound session's mutation refreshes lastActivity + renews its leases
+      createSanitizer(() => getProjectRoot()),
+      createFieldFilter(),
+      // T9922 (Saga T9855 / E8.3): MVI record projection default for read ops.
+      // Runs AFTER the domain handler returns so it can trim the data payload
+      // before audit + telemetry record byte sizes. Sits before audit so the
+      // audit trail captures the projected (final) bytes.
+      createMviRecordProjection(),
+      // T9931 (Saga T9855 / E9.4): minimal envelopes for mutate ops. Mirror
+      // policy to the read-side projection — sits in the same pre-audit slot
+      // so audit/telemetry record the trimmed bytes.
+      createMutateMinimalEnvelope(),
+      // T11350 (Epic T11285 EP-MVI-PRIMITIVE): LIVE MVI token-budget chokepoint.
+      // Runs AFTER projection/minimal-envelope (measures the trimmed payload)
+      // and BEFORE audit/telemetry (so they record the final budget-enforced
+      // bytes). Enforces per-op ceilings from BUDGET_POLICIES (e.g. focus ≤1500).
+      createBudgetEnforcement(),
+      createAudit(),
+      // T4959: CLI now gets audit trail
+      createIdempotency(),
+      // T10600: duplicate retry protection after audit wraps the response
+      createTelemetry()
+      // T624: opt-in self-improvement telemetry
+    ]
+  });
+}
+function resetCliDispatcher() {
+  _dispatcher = null;
+}
+function maybeEmitDescribe(gateway, domain, operation, outputOpts) {
+  if (!isDescribeMode()) return false;
+  const key = `${domain}.${operation}`;
+  const { describeOperation } = loadEsmSync(
+    "@cleocode/core/dispatch/describe-operation"
+  );
+  const descriptor = describeOperation(key);
+  const command = outputOpts?.command ?? operation;
+  if (descriptor === null) {
+    cliOutput(
+      { operation: key, gateway, inputContract: null, outputContract: null },
+      {
+        command,
+        operation: `describe.${key}`,
+        message: `No registered operation found for "${key}".`
+      }
+    );
+    return true;
+  }
+  cliOutput(descriptor, {
+    command,
+    operation: `describe.${key}`,
+    message: `Schema for ${key} (input + output). Use the outputContract.fieldPointers for --field.`
+  });
+  return true;
+}
+async function dispatchFromCli(gateway, domain, operation, params, outputOpts) {
+  if (maybeEmitDescribe(gateway, domain, operation, outputOpts)) return;
+  await prepareCoreFor(gateway, domain, operation);
+  const dispatcher = getCliDispatcher();
+  const projectRoot = getProjectRoot();
+  const dispatchStart = Date.now();
+  void trackBackgroundOp(
+    hooks.dispatch("PromptSubmit", projectRoot, {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      gateway,
+      domain,
+      operation,
+      source: "cli"
+    }).catch(() => {
+    })
+  );
+  const spinner = createDispatchSpinner(domain, operation);
+  spinner.start();
+  let response;
+  const mergedParams = mergeIdempotencyParam(gateway, params);
+  try {
+    response = await dispatcher.dispatch({
+      gateway,
+      domain,
+      operation,
+      params: mergedParams,
+      source: "cli",
+      requestId: randomUUID2()
+    });
+  } finally {
+    spinner.stop();
+  }
+  void trackBackgroundOp(
+    hooks.dispatch("ResponseComplete", projectRoot, {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      gateway,
+      domain,
+      operation,
+      success: response.success,
+      durationMs: Date.now() - dispatchStart,
+      errorCode: response.error?.code
+    }).catch(() => {
+    })
+  );
+  if (response.success) {
+    if (gateway === "mutate") {
+      const { autoRecordDispatchTokenUsage } = await import("@cleocode/core/metrics/token-service");
+      await autoRecordDispatchTokenUsage({
+        requestPayload: mergedParams,
+        responsePayload: { data: response.data, page: response.page },
+        transport: "cli",
+        gateway,
+        domain,
+        operation,
+        sessionId: response.meta.sessionId,
+        requestId: response.meta.requestId,
+        cwd: getProjectRoot()
+      });
+    }
+    const opts = {
+      command: outputOpts?.command ?? operation,
+      operation: outputOpts?.operation ?? `${domain}.${operation}`,
+      ...outputOpts
+    };
+    if (opts.page === void 0 && response.page !== void 0) {
+      opts.page = response.page;
+    }
+    if (opts.responseMeta === void 0) {
+      opts.responseMeta = response.meta;
+    }
+    cliOutput(response.data, opts);
+  } else {
+    const errorCode = response.error?.code ?? "E_GENERAL";
+    const exitCode = response.error?.exitCode ?? ERROR_CODE_TO_EXIT[errorCode] ?? 1;
+    cliError(
+      response.error?.message ?? "Unknown error",
+      exitCode,
+      {
+        name: errorCode,
+        details: response.error?.details,
+        fix: response.error?.fix,
+        alternatives: response.error?.alternatives
+      },
+      {
+        operation: `${domain}.${operation}`,
+        requestId: response.meta.requestId,
+        duration_ms: response.meta.duration_ms,
+        timestamp: response.meta.timestamp,
+        ...response.meta.sessionId ? { sessionId: response.meta.sessionId } : {},
+        ...response.meta.originSessionId ? { originSessionId: response.meta.originSessionId } : {},
+        ...response.meta.executionSessionId ? { executionSessionId: response.meta.executionSessionId } : {}
+      }
+    );
+    await settleThenExit(exitCode);
+  }
+}
+function handleRawError(response, _opts) {
+  if (response.success) return;
+  const errorCode = response.error?.code ?? "E_GENERAL";
+  const exitCode = response.error?.exitCode ?? ERROR_CODE_TO_EXIT[errorCode] ?? 1;
+  cliError(
+    response.error?.message ?? "Unknown error",
+    exitCode,
+    {
+      name: errorCode,
+      details: response.error?.details,
+      fix: response.error?.fix,
+      alternatives: response.error?.alternatives
+    },
+    {
+      operation: _opts.operation,
+      requestId: response.meta.requestId,
+      duration_ms: response.meta.duration_ms,
+      timestamp: response.meta.timestamp,
+      ...response.meta.sessionId ? { sessionId: response.meta.sessionId } : {},
+      ...response.meta.originSessionId ? { originSessionId: response.meta.originSessionId } : {},
+      ...response.meta.executionSessionId ? { executionSessionId: response.meta.executionSessionId } : {}
+    }
+  );
+  process.exit(exitCode);
+}
+async function dispatchRaw(gateway, domain, operation, params) {
+  await prepareCoreFor(gateway, domain, operation);
+  const dispatcher = getCliDispatcher();
+  const projectRoot = getProjectRoot();
+  const dispatchStart = Date.now();
+  void trackBackgroundOp(
+    hooks.dispatch("PromptSubmit", projectRoot, {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      gateway,
+      domain,
+      operation,
+      source: "cli"
+    }).catch(() => {
+    })
+  );
+  const spinner = createDispatchSpinner(domain, operation);
+  spinner.start();
+  let response;
+  const mergedParams = mergeIdempotencyParam(gateway, params);
+  try {
+    response = await dispatcher.dispatch({
+      gateway,
+      domain,
+      operation,
+      params: mergedParams,
+      source: "cli",
+      requestId: randomUUID2()
+    });
+  } finally {
+    spinner.stop();
+  }
+  void trackBackgroundOp(
+    hooks.dispatch("ResponseComplete", projectRoot, {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      gateway,
+      domain,
+      operation,
+      success: response.success,
+      durationMs: Date.now() - dispatchStart,
+      errorCode: response.error?.code
+    }).catch(() => {
+    })
+  );
+  if (!response.success) {
+    const { settleBeforeExit } = await import("@cleocode/core/shutdown");
+    await settleBeforeExit();
+  }
+  return response;
+}
+function mergeIdempotencyParam(gateway, params) {
+  if (gateway !== "mutate") return params;
+  const idempotencyKey = getIdempotencyKeyContext();
+  if (!idempotencyKey || params?.["idempotencyKey"] !== void 0) return params;
+  return { ...params ?? {}, idempotencyKey };
+}
+
+export {
+  createAnimateContext,
+  renderLegend,
+  renderSummary,
+  renderTree,
+  prepareCoreFor,
+  getCliDispatcher,
+  createCliGatewayHandler,
+  lookupCliSession,
+  heartbeatCliSession,
+  warnUnboundMutation,
+  createCliDispatcher,
+  resetCliDispatcher,
+  maybeEmitDescribe,
+  dispatchFromCli,
+  handleRawError,
+  dispatchRaw
+};
+//# sourceMappingURL=chunk-L7ONYSV6.js.map