@iowarp/clio-coder 0.3.2 → 0.3.4

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-3ZXDFGR5.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-V4RXGQ5Q.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-3ZXDFGR5.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

package/dist/{chunk-MAW544W2.js → chunk-ZWMF7253.js}

@@ -1418,13 +1418,13 @@ var CLIO_APP_KEYBINDINGS = {
   },
   "clio.tool.expand": {
     defaultKeys: "alt+o",
-    description: "Fold or unfold the newest tool call or worker block between its one-line summary and full details (no effect while /output verbose pins them open)"
+    description: "Fold or unfold the newest tool call or worker block between its one-line summary and full details, overriding the /output level for that block"
   },
   "clio.tool.expandAll": {
     // Alt+Shift+letter is commonly consumed by OS keyboard-layout switching.
     // Keep it discoverable, but pair it with the legacy-safe Ctrl+Alt form.
     defaultKeys: ["ctrl+alt+o", "alt+shift+o"],
-    description: "Fold or unfold every tool call and worker block at once (no effect while /output verbose pins them open)"
+    description: "Fold or unfold every tool call and worker block at once, overriding the /output level; changing /output clears the overrides"
   },
   "clio.tool.liveOutput": {
     defaultKeys: "alt+p",
@@ -1438,7 +1438,7 @@ var CLIO_APP_KEYBINDINGS = {
     // Ctrl+Alt+R is the fallback for terminals/OSes that do not forward
     // Alt+Shift+R as a distinct key event.
     defaultKeys: ["ctrl+alt+r", "alt+shift+r"],
-    description: "Toggle all thinking blocks between hidden markers and full bodies (no effect while /output verbose pins them open)"
+    description: "Toggle all thinking blocks between hidden markers and full bodies, overriding the /output level; changing /output clears the overrides"
   },
   "clio.editor.external": {
     defaultKeys: "alt+g",
@@ -1879,4 +1879,4 @@ export {
   formatPlatformKeybindingNotice,
   createKeybindingManager
 };
-//# sourceMappingURL=chunk-MAW544W2.js.map
+//# sourceMappingURL=chunk-ZWMF7253.js.map