@iowarp/clio-coder 0.3.3 → 0.3.4

package/dist/chunk-VSNATDE6.js

@@ -0,0 +1,122 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  EMPTY_WORKING_SET_VIEW,
+  callPathsByToolCallId,
+  offloadPathOf,
+  parseRefKey,
+  primaryPathOf,
+  refKey,
+  toolResultPayload,
+  toolResultText
+} from "./chunk-TZSKNMZG.js";
+import {
+  filterEntriesToActivePath
+} from "./chunk-W6GROXXM.js";
+import {
+  ceilChars
+} from "./chunk-BPGS2WCQ.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/context/working-set/recall.ts
+init_esm_shims();
+function isThinkingEntry(entry) {
+  return entry.kind === "message" && entry.role === "assistant";
+}
+function isToolResultEntry(entry) {
+  return entry.kind === "message" && entry.role === "tool_result";
+}
+function resolveRecall(entries, view, ref, activeLeafTurnId) {
+  const parsed = parseRefKey(ref);
+  if (parsed === null) return { ok: false, error: { kind: "invalid_ref", ref } };
+  const key = refKey(parsed);
+  const active = filterEntriesToActivePath(entries, activeLeafTurnId);
+  const entry = active.find((candidate) => candidate.turnId === key);
+  if (entry === void 0) {
+    return { ok: false, error: { kind: "not_on_active_path", ref: key } };
+  }
+  if (isThinkingEntry(entry) || !view.evicted.has(key) || !isToolResultEntry(entry)) {
+    return { ok: false, error: { kind: "not_evicted", ref: key } };
+  }
+  const payload = toolResultPayload(entry.payload);
+  const body = toolResultText(payload.result);
+  const offloadPath = offloadPathOf(payload);
+  return {
+    ok: true,
+    result: {
+      ref: parsed,
+      entry,
+      body,
+      tokens: ceilChars(body.length),
+      ...offloadPath !== void 0 ? { offloadPath } : {}
+    }
+  };
+}
+function recallParentTurnId(entries, activeLeafTurnId) {
+  const active = filterEntriesToActivePath(entries, activeLeafTurnId);
+  for (let i = active.length - 1; i >= 0; i -= 1) {
+    const candidate = active[i];
+    if (candidate?.kind === "message") return candidate.turnId;
+  }
+  return null;
+}
+function buildRecallFields(result, meta) {
+  return {
+    kind: "contextRecall",
+    ref: { entry: result.ref.entry },
+    trigger: meta.trigger,
+    tokensReadmitted: result.tokens,
+    ...meta.toolCallId !== void 0 ? { toolCallId: meta.toolCallId } : {}
+  };
+}
+var MAX_LISTED_REFS = 8;
+function recallableRefListing(entries, view) {
+  const byTurnId = /* @__PURE__ */ new Map();
+  for (const entry of entries) byTurnId.set(entry.turnId, entry);
+  const callPaths = callPathsByToolCallId(entries);
+  const refs = [];
+  for (const key of view.evicted.keys()) {
+    const entry = byTurnId.get(key);
+    if (entry === void 0 || !isToolResultEntry(entry)) continue;
+    const payload = toolResultPayload(entry.payload);
+    const toolCallId = typeof payload.obj.toolCallId === "string" ? payload.obj.toolCallId : void 0;
+    const path = primaryPathOf(payload) ?? (toolCallId === void 0 ? void 0 : callPaths.get(toolCallId));
+    refs.push(`${key} (${payload.toolName}${path === void 0 ? "" : ` ${path}`})`);
+  }
+  return {
+    refs: refs.slice(0, MAX_LISTED_REFS),
+    remaining: Math.max(0, refs.length - MAX_LISTED_REFS)
+  };
+}
+function recallableRefMessage(entries, view) {
+  const listing = recallableRefListing(entries, view);
+  if (listing.refs.length === 0) return "No recallable refs on the active path.";
+  const more = listing.remaining > 0 ? `, and ${listing.remaining} more` : "";
+  return `Recallable refs on the active path: ${listing.refs.join(", ")}${more}.`;
+}
+function recallErrorMessage(error, entries = [], view = EMPTY_WORKING_SET_VIEW) {
+  const listing = ` ${recallableRefMessage(entries, view)}`;
+  switch (error.kind) {
+    case "invalid_ref":
+      return `recall ref must be a single turnId without whitespace; got '${error.ref}'.`;
+    case "not_on_active_path":
+      return `ref ${error.ref} is not on the active path of this session (unknown or on an abandoned branch).${listing}`;
+    case "not_evicted": {
+      const entry = entries.find((candidate) => candidate.turnId === error.ref);
+      if (entry !== void 0 && isThinkingEntry(entry)) {
+        return `ref ${error.ref} is an assistant turn; thinking is not recallable.${listing}`;
+      }
+      return `ref ${error.ref} is not evicted; its content is already in context.${listing}`;
+    }
+  }
+}
+
+export {
+  resolveRecall,
+  recallParentTurnId,
+  buildRecallFields,
+  recallableRefListing,
+  recallErrorMessage
+};
+//# sourceMappingURL=chunk-VSNATDE6.js.map

package/dist/chunk-W6GROXXM.js

@@ -0,0 +1,69 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/session/tree/active-path.ts
+init_esm_shims();
+function filterEntriesToActivePath(entries, leafTurnId) {
+  const messages = [];
+  const messagesById = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.kind !== "message") continue;
+    messages.push(entry);
+    messagesById.set(entry.turnId, entry);
+  }
+  const latest = messages[messages.length - 1];
+  const pinnedLeaf = resolveLeafMessage(entries, messagesById, leafTurnId);
+  if (!hasBranch(messages) && (pinnedLeaf === void 0 || pinnedLeaf.turnId === latest?.turnId)) return [...entries];
+  const leaf = pinnedLeaf ?? latest;
+  if (!leaf) return [...entries];
+  const pathIds = /* @__PURE__ */ new Set();
+  let current = leaf;
+  while (current && !pathIds.has(current.turnId)) {
+    pathIds.add(current.turnId);
+    if (current.parentTurnId === null) break;
+    current = messagesById.get(current.parentTurnId);
+  }
+  const leafIndex = entries.findIndex((entry) => entry.kind === "message" && entry.turnId === leaf.turnId);
+  return entries.filter((entry, index) => entryBelongsToPath(entry, pathIds, leafIndex >= 0 && index <= leafIndex));
+}
+function resolveLeafMessage(entries, messagesById, leafTurnId) {
+  if (leafTurnId === void 0) return void 0;
+  const direct = messagesById.get(leafTurnId);
+  if (direct) return direct;
+  const sidecar = entries.find((entry) => entry.turnId === leafTurnId);
+  if (!sidecar) return void 0;
+  const anchor = sidecarAnchorTurnId(sidecar);
+  return anchor === null ? void 0 : messagesById.get(anchor);
+}
+function sidecarAnchorTurnId(entry) {
+  if (entry.kind === "label") return entry.targetTurnId;
+  if (entry.kind === "sessionInfo") return entry.targetTurnId ?? entry.parentTurnId;
+  if (entry.kind === "compactionSummary" && entry.firstKeptTurnId.length > 0) return entry.firstKeptTurnId;
+  return entry.parentTurnId;
+}
+function hasBranch(messages) {
+  const seenParents = /* @__PURE__ */ new Set();
+  for (const message of messages) {
+    if (message.parentTurnId === null) continue;
+    if (seenParents.has(message.parentTurnId)) return true;
+    seenParents.add(message.parentTurnId);
+  }
+  return false;
+}
+function entryBelongsToPath(entry, pathIds, atOrBeforeLeaf) {
+  if (entry.kind === "message") return pathIds.has(entry.turnId);
+  if (entry.kind === "label") return pathIds.has(entry.targetTurnId);
+  if (entry.kind === "sessionInfo") return entry.targetTurnId === void 0 || pathIds.has(entry.targetTurnId);
+  if (entry.kind === "compactionSummary" && entry.firstKeptTurnId.length > 0 && pathIds.has(entry.firstKeptTurnId)) {
+    return true;
+  }
+  return entry.parentTurnId === null ? atOrBeforeLeaf : pathIds.has(entry.parentTurnId);
+}
+
+export {
+  filterEntriesToActivePath,
+  entryBelongsToPath
+};
+//# sourceMappingURL=chunk-W6GROXXM.js.map

package/dist/chunk-WPQLXFOZ.js

@@ -0,0 +1,375 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  isSessionEntry
+} from "./chunk-BEY543CS.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/session/task-board.ts
+init_esm_shims();
+import { randomUUID } from "node:crypto";
+var TASK_BOARD_GOAL_ID = "board";
+var LEGACY_TASK_BOARD_ID = "legacy";
+function isOpenUserTask(task) {
+  return task.origin === "user" && (task.status === "pending" || task.status === "active");
+}
+function taskBoardCounts(board) {
+  const counts = {
+    total: board.tasks.length,
+    completed: 0,
+    active: 0,
+    pending: 0,
+    blocked: 0,
+    cancelled: 0,
+    open: 0
+  };
+  for (const task of board.tasks) {
+    if (task.status === "completed") counts.completed += 1;
+    else if (task.status === "active") counts.active += 1;
+    else if (task.status === "pending") counts.pending += 1;
+    else if (task.status === "blocked") counts.blocked += 1;
+    else counts.cancelled += 1;
+  }
+  counts.open = counts.pending + counts.active;
+  return counts;
+}
+function boardStatus(tasks) {
+  const counts = taskBoardCounts({ tasks });
+  if (counts.total === 0) return "pending";
+  if (counts.active > 0) return "active";
+  if (counts.open === 0 && counts.blocked === 0) return "completed";
+  if (counts.blocked > 0 && counts.open === 0) return "blocked";
+  return "pending";
+}
+function toTaskLedgerEntryFields(board, now) {
+  const evidence = [];
+  const subgoals = board.tasks.map((task) => {
+    if (task.status === "completed" && task.evidence) {
+      evidence.push({
+        id: `${task.id}.evidence`,
+        description: task.evidence,
+        status: "passed",
+        observedAt: now.toISOString()
+      });
+    }
+    const goal = {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      parentGoalId: TASK_BOARD_GOAL_ID
+    };
+    if (task.origin) goal.origin = task.origin;
+    if (task.userTaskId) goal.userTaskId = task.userTaskId;
+    if (task.reason) goal.description = task.reason;
+    return goal;
+  });
+  return {
+    kind: "taskLedger",
+    parentTurnId: null,
+    boardId: board.boardId,
+    goals: [{ id: TASK_BOARD_GOAL_ID, title: board.title, status: boardStatus(board.tasks) }],
+    subgoals,
+    activeRunIds: [...board.activeRunIds],
+    requiredValidationEvidence: evidence
+  };
+}
+function isTaskLedgerShaped(value) {
+  return isSessionEntry(value) && value.kind === "taskLedger";
+}
+function foldTaskBoard(entries) {
+  let last = null;
+  for (const raw of entries) {
+    if (isTaskLedgerShaped(raw)) last = toEntryView(raw);
+  }
+  return last;
+}
+function foldSessionTaskHistory(entries) {
+  const boards = /* @__PURE__ */ new Map();
+  for (const [index, raw] of entries.entries()) {
+    if (!isTaskLedgerShaped(raw)) continue;
+    const view = toEntryView(raw);
+    if (!view) continue;
+    const boardId = typeof raw.boardId === "string" && raw.boardId.length > 0 ? raw.boardId : LEGACY_TASK_BOARD_ID;
+    const timestamp = typeof raw.timestamp === "string" ? raw.timestamp : "";
+    if (boardId === LEGACY_TASK_BOARD_ID) {
+      boards.set(boardId, {
+        boardId,
+        title: view.title,
+        tasks: new Map(view.tasks.map((task) => [task.id, task])),
+        lastSnapshotAt: timestamp,
+        lastIndex: index
+      });
+      continue;
+    }
+    const existing = boards.get(boardId);
+    if (!existing) {
+      boards.set(boardId, {
+        boardId,
+        title: view.title,
+        tasks: new Map(view.tasks.map((task) => [task.id, task])),
+        lastSnapshotAt: timestamp,
+        lastIndex: index
+      });
+      continue;
+    }
+    existing.title = view.title;
+    for (const task of view.tasks) existing.tasks.set(task.id, task);
+    existing.lastSnapshotAt = timestamp;
+    existing.lastIndex = index;
+  }
+  return [...boards.values()].sort((left, right) => right.lastIndex - left.lastIndex).map(({ lastIndex: _lastIndex, tasks, ...board }) => ({ ...board, tasks: [...tasks.values()] }));
+}
+function toEntryView(entry) {
+  const boardGoal = entry.goals[0];
+  if (!boardGoal) return null;
+  const evidenceByTask = /* @__PURE__ */ new Map();
+  for (const item of entry.requiredValidationEvidence) {
+    const taskId = item.id.endsWith(".evidence") ? item.id.slice(0, -".evidence".length) : item.id;
+    evidenceByTask.set(taskId, item.description);
+  }
+  return {
+    boardId: entry.boardId ?? LEGACY_TASK_BOARD_ID,
+    title: boardGoal.title,
+    tasks: entry.subgoals.map((goal) => {
+      const task = {
+        id: goal.id,
+        title: goal.title,
+        status: goal.status,
+        origin: goal.origin ?? "agent"
+      };
+      if (goal.userTaskId) task.userTaskId = goal.userTaskId;
+      if (goal.description) task.reason = goal.description;
+      const evidence = evidenceByTask.get(goal.id);
+      if (evidence) task.evidence = evidence;
+      return task;
+    }),
+    // Run linkage is process-live: the runs recorded in old entries ended
+    // with the process that dispatched them, so a refold starts empty and
+    // the historical linkage stays readable in the earlier entries.
+    activeRunIds: []
+  };
+}
+function nextTaskId(tasks) {
+  let max = 0;
+  for (const task of tasks) {
+    const match = /^t(\d+)$/.exec(task.id);
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  return max + 1;
+}
+function normalizeTitles(titles) {
+  return titles.map((title) => title.trim()).filter((title) => title.length > 0);
+}
+function applyMutation(board, mutation) {
+  if (mutation.op === "plan") {
+    const titles = normalizeTitles(mutation.tasks);
+    if (mutation.title.trim().length === 0) return { error: "plan requires a non-empty title" };
+    if (titles.length === 0) return { error: "plan requires at least one task" };
+    const retained = board?.tasks.filter(isOpenUserTask) ?? [];
+    const notes2 = [];
+    const replacedOpen = board ? taskBoardCounts(board).open - retained.length : 0;
+    if (board && replacedOpen > 0) {
+      notes2.push(`replaced board "${board.title}" with ${replacedOpen} agent task(s) still open`);
+    }
+    if (retained.length > 0) notes2.push(`preserved ${retained.length} open operator task(s)`);
+    const start = nextTaskId(retained);
+    return {
+      board: {
+        boardId: "",
+        title: mutation.title.trim(),
+        tasks: [
+          ...retained,
+          ...titles.map((title, index) => ({
+            id: `t${start + index}`,
+            title,
+            status: "pending",
+            origin: "agent"
+          }))
+        ],
+        // Runs in flight outlive a board swap: they belong to the session,
+        // so the fresh board inherits the linkage until the runs finish.
+        activeRunIds: board?.activeRunIds ?? []
+      },
+      notes: notes2
+    };
+  }
+  if (mutation.op === "pick") {
+    const title = mutation.title.trim();
+    if (title.length === 0) return { error: "pick requires a non-empty operator task title" };
+    if (!/^u[1-9]\d*$/.test(mutation.userTaskId)) return { error: "pick requires an operator task id like u3" };
+    if (board?.tasks.some(
+      (task) => task.userTaskId === mutation.userTaskId && (task.status === "pending" || task.status === "active" || task.status === "completed")
+    )) {
+      return { error: `operator task ${mutation.userTaskId} is already linked to durable board work` };
+    }
+    const tasks2 = board?.tasks ?? [];
+    const picked = {
+      id: `t${nextTaskId(tasks2)}`,
+      title,
+      status: "pending",
+      origin: "user",
+      userTaskId: mutation.userTaskId
+    };
+    return {
+      board: {
+        boardId: board?.boardId ?? "",
+        title: board?.title ?? "Operator tasks",
+        tasks: [...tasks2, picked],
+        activeRunIds: board?.activeRunIds ?? []
+      },
+      notes: []
+    };
+  }
+  if (board === null) return { error: 'no task board yet; declare one with action="plan" first' };
+  if (mutation.op === "add") {
+    const titles = normalizeTitles(mutation.tasks);
+    if (titles.length === 0) return { error: "add requires at least one task" };
+    const start = nextTaskId(board.tasks);
+    const added = titles.map((title, index) => ({
+      id: `t${start + index}`,
+      title,
+      status: "pending",
+      origin: "agent"
+    }));
+    return { board: { ...board, tasks: [...board.tasks, ...added] }, notes: [] };
+  }
+  const target = board.tasks.find((task) => task.id === mutation.id);
+  if (!target) return { error: `task ${mutation.id} not found on the board` };
+  if (mutation.op === "block" && mutation.reason.trim().length === 0) {
+    return { error: "block requires a reason so the ledger records why work stopped" };
+  }
+  if (mutation.op === "done") {
+    if (mutation.evidence.trim().length === 0) {
+      return {
+        error: "done requires note as the evidence that the task actually finished (the command you ran, the file:line you verified). If the work did not happen, use block with a reason or drop it."
+      };
+    }
+    if (target.status === "pending") {
+      return {
+        error: `task ${target.id} was never started, so it cannot be completed. Start it and do the work, or record the truth with block (reason) or drop.`
+      };
+    }
+  }
+  const notes = [];
+  const tasks = board.tasks.map((task) => {
+    if (task.id !== target.id) {
+      if (mutation.op === "start" && task.status === "active") {
+        notes.push(`parked ${task.id} back to pending (one task active at a time)`);
+        return { ...task, status: "pending" };
+      }
+      return task;
+    }
+    return applyStatusMutation(task, mutation);
+  });
+  return { board: { ...board, tasks }, notes };
+}
+function applyStatusMutation(task, mutation) {
+  switch (mutation.op) {
+    case "start":
+      return { ...task, status: "active" };
+    case "done": {
+      const done = { ...task, status: "completed", evidence: mutation.evidence.trim() };
+      delete done.reason;
+      return done;
+    }
+    case "block":
+      return { ...task, status: "blocked", reason: mutation.reason.trim() };
+    case "drop": {
+      const dropped = { ...task, status: "cancelled" };
+      if (mutation.reason?.trim()) dropped.reason = mutation.reason.trim();
+      return dropped;
+    }
+  }
+}
+function createTaskBoardStore(deps = {}) {
+  let cachedSessionId;
+  let dirty = true;
+  let board = null;
+  const syncToSession = () => {
+    const sessionId = deps.getSessionId?.() ?? null;
+    if (!dirty && cachedSessionId === sessionId) return;
+    dirty = false;
+    cachedSessionId = sessionId;
+    try {
+      board = deps.readEntries ? foldTaskBoard(deps.readEntries()) : null;
+    } catch {
+      board = null;
+    }
+  };
+  const persist = (next) => {
+    try {
+      deps.appendEntry?.(toTaskLedgerEntryFields(next, deps.now?.() ?? /* @__PURE__ */ new Date()));
+    } catch {
+    }
+  };
+  const mutationRequiresAcknowledgement = (current, mutation) => {
+    if (mutation.op === "pick") return true;
+    if (mutation.op === "plan") return current?.tasks.some(isOpenUserTask) ?? false;
+    if (mutation.op !== "done") return false;
+    return current?.tasks.some((task) => task.id === mutation.id && task.origin === "user") ?? false;
+  };
+  return {
+    snapshot() {
+      syncToSession();
+      return board;
+    },
+    cachedSnapshot() {
+      const sessionId = deps.getSessionId?.() ?? null;
+      return !dirty && cachedSessionId === sessionId ? board : null;
+    },
+    historySnapshot() {
+      syncToSession();
+      try {
+        return deps.readEntries ? foldSessionTaskHistory(deps.readEntries()) : [];
+      } catch {
+        return [];
+      }
+    },
+    apply(mutation) {
+      syncToSession();
+      const result = applyMutation(board, mutation);
+      if ("error" in result) return { ok: false, message: result.error };
+      const needsBoardId = mutation.op === "plan" || result.board.boardId.length === 0;
+      const nextBoard = needsBoardId ? { ...result.board, boardId: deps.createBoardId?.() ?? randomUUID() } : result.board;
+      if (mutationRequiresAcknowledgement(board, mutation)) {
+        if (!deps.appendEntry) {
+          return { ok: false, message: "durable task-ledger persistence is unavailable for operator-linked work" };
+        }
+        try {
+          deps.appendEntry(toTaskLedgerEntryFields(nextBoard, deps.now?.() ?? /* @__PURE__ */ new Date()));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return { ok: false, message: `could not persist operator-linked task board: ${message}` };
+        }
+        board = nextBoard;
+        return { ok: true, board: nextBoard, notes: result.notes };
+      }
+      board = nextBoard;
+      persist(nextBoard);
+      return { ok: true, board: nextBoard, notes: result.notes };
+    },
+    attachRun(runId) {
+      syncToSession();
+      if (board === null || runId.length === 0 || board.activeRunIds.includes(runId)) return;
+      board = { ...board, activeRunIds: [...board.activeRunIds, runId] };
+      persist(board);
+    },
+    detachRun(runId) {
+      syncToSession();
+      if (board === null || !board.activeRunIds.includes(runId)) return;
+      board = { ...board, activeRunIds: board.activeRunIds.filter((id) => id !== runId) };
+      persist(board);
+    },
+    invalidate() {
+      dirty = true;
+    }
+  };
+}
+
+export {
+  taskBoardCounts,
+  foldSessionTaskHistory,
+  createTaskBoardStore
+};
+//# sourceMappingURL=chunk-WPQLXFOZ.js.map

package/dist/{chunk-ORBHGJC5.js → chunk-WR67VIZY.js}

@@ -3,10 +3,10 @@ import {
   readSettings,
   settingsPath,
   updateSettings
-} from "./chunk-A3CYT5EX.js";
+} from "./chunk-AD2SYQYC.js";
 import {
   DEFAULT_SETTINGS
-} from "./chunk-ZDOOVTXZ.js";
+} from "./chunk-4OC57DA6.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -552,4 +552,4 @@ export {
   importShareArchive,
   ShareDomainModule
 };
-//# sourceMappingURL=chunk-ORBHGJC5.js.map
+//# sourceMappingURL=chunk-WR67VIZY.js.map

package/dist/{chunk-PAJK6MAQ.js → chunk-X6COSD2O.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   assertAgentIdNamespace
-} from "./chunk-OC7FIQPC.js";
+} from "./chunk-KRPY7NTG.js";
 import {
   parseFrontmatter
 } from "./chunk-QKMUKYO7.js";
@@ -21,7 +21,7 @@ import {
 import {
   createSafetyPolicyEngine,
   parseResultContract
-} from "./chunk-STBPMHSX.js";
+} from "./chunk-7RXG6QRZ.js";
 import {
   assertAgentSpecPolicy,
   classify,
@@ -33,7 +33,7 @@ import {
   isAgentProjectContextTier,
   isShadowAgent,
   normalizeAgentSpec
-} from "./chunk-5UUP6MWO.js";
+} from "./chunk-AOCYTWAV.js";
 import {
   clioConfigDir,
   clioStateDir,
@@ -42,7 +42,7 @@ import {
 import {
   BusChannels,
   isRunAbortedPayload
-} from "./chunk-OQ33BKR3.js";
+} from "./chunk-TTNYS3EA.js";
 import {
   resolvePackageRoot
 } from "./chunk-IWHMRKLL.js";
@@ -1036,4 +1036,4 @@ export {
   AgentsDomainModule,
   SafetyDomainModule
 };
-//# sourceMappingURL=chunk-PAJK6MAQ.js.map
+//# sourceMappingURL=chunk-X6COSD2O.js.map

package/dist/chunk-ZGVHUX3M.js

@@ -0,0 +1,66 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/shared-bus.ts
+init_esm_shims();
+
+// src/core/event-bus.ts
+init_esm_shims();
+function reportListenerError(channel, error) {
+  const message = error instanceof Error ? error.stack ?? error.message : String(error);
+  console.error(`[clio:event-bus] Listener crashed on ${channel}: ${message}`);
+}
+function createSafeEventBus() {
+  const registry = /* @__PURE__ */ new Map();
+  const deliver = (channel, payload) => {
+    const ls = registry.get(channel);
+    if (!ls) return;
+    for (const listener of [...ls]) {
+      try {
+        const result = listener(payload);
+        if (result && typeof result.then === "function") {
+          result.catch((error) => reportListenerError(channel, error));
+        }
+      } catch (error) {
+        reportListenerError(channel, error);
+      }
+    }
+  };
+  const bus = {
+    emit(channel, payload) {
+      deliver(channel, payload);
+    },
+    on(channel, listener) {
+      const set = registry.get(channel) ?? /* @__PURE__ */ new Set();
+      set.add(listener);
+      registry.set(channel, set);
+      return () => {
+        const current = registry.get(channel);
+        if (!current) return;
+        current.delete(listener);
+        if (current.size === 0) registry.delete(channel);
+      };
+    },
+    listeners(channel) {
+      return [...registry.get(channel) ?? []];
+    },
+    clear() {
+      registry.clear();
+    }
+  };
+  return bus;
+}
+
+// src/core/shared-bus.ts
+var sharedBus = null;
+function getSharedBus() {
+  if (!sharedBus) sharedBus = createSafeEventBus();
+  return sharedBus;
+}
+
+export {
+  getSharedBus
+};
+//# sourceMappingURL=chunk-ZGVHUX3M.js.map