@iowarp/clio-coder 0.3.3 → 0.3.6

package/dist/{auth-5TWEIYDN.js → auth-KXXFI2VS.js}

@@ -10,14 +10,14 @@ import {
 import {
   credentialWriteFailed,
   printPlaintextCredentialWarning
-} from "./chunk-YCWGATWI.js";
+} from "./chunk-24I7BN55.js";
 import {
   columnWidths,
   formatColumnRow,
   formatColumns,
   printError,
   printOk
-} from "./chunk-ED4KHGC3.js";
+} from "./chunk-PPAMZ32Z.js";
 import "./chunk-5TSRNF4G.js";
 import {
   EMPTY_CAPABILITIES,
@@ -26,11 +26,13 @@ import {
   registerBuiltinRuntimes,
   resolveProviderReference,
   supportGroupLabel
-} from "./chunk-LZSJBIVT.js";
+} from "./chunk-DJVECN66.js";
+import "./chunk-CFGTUFWB.js";
 import {
   readSettings
-} from "./chunk-A3CYT5EX.js";
-import "./chunk-ZDOOVTXZ.js";
+} from "./chunk-AD2SYQYC.js";
+import "./chunk-4OC57DA6.js";
+import "./chunk-LL4KHSZI.js";
 import {
   authNotRequiredStatus,
   openAuthStorage,
@@ -38,19 +40,21 @@ import {
   resolveRuntimeAuthTarget,
   targetRequiresAuth
 } from "./chunk-4VP4KH3K.js";
-import "./chunk-M6SHUN7Q.js";
-import "./chunk-R346GLFC.js";
 import "./chunk-FQ4SKYE4.js";
 import "./chunk-IKCO5N3L.js";
 import "./chunk-3I7MS7N2.js";
+import "./chunk-GEYXPTRF.js";
 import "./chunk-SST6Z5JA.js";
+import "./chunk-FO5ZOVUY.js";
+import "./chunk-R346GLFC.js";
 import "./chunk-4ZG3XFUR.js";
-import "./chunk-APJ265NV.js";
 import "./chunk-FCSXB6T2.js";
+import "./chunk-APJ265NV.js";
 import "./chunk-YXLYO42X.js";
 import "./chunk-BNAZZHFG.js";
 import "./chunk-WEPFGWHJ.js";
-import "./chunk-OQ33BKR3.js";
+import "./chunk-ZGVHUX3M.js";
+import "./chunk-G7MUEIGA.js";
 import "./chunk-IWHMRKLL.js";
 import {
   init_esm_shims
@@ -533,4 +537,4 @@ async function runAuthCommand(args) {
 export {
   runAuthCommand
 };
-//# sourceMappingURL=auth-5TWEIYDN.js.map
+//# sourceMappingURL=auth-KXXFI2VS.js.map

package/dist/{chunk-GGXXDWE4.js → chunk-22NAGB7X.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   isAgentCapabilityClass
-} from "./chunk-5UUP6MWO.js";
+} from "./chunk-AOCYTWAV.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -1084,4 +1084,4 @@ export {
   routingIntentRejection,
   explainRouteDecision
 };
-//# sourceMappingURL=chunk-GGXXDWE4.js.map
+//# sourceMappingURL=chunk-22NAGB7X.js.map

package/dist/{chunk-YCWGATWI.js → chunk-24I7BN55.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   printError
-} from "./chunk-ED4KHGC3.js";
+} from "./chunk-PPAMZ32Z.js";
 import {
   source_default
 } from "./chunk-5TSRNF4G.js";
@@ -35,4 +35,4 @@ export {
   printPlaintextCredentialWarning,
   credentialWriteFailed
 };
-//# sourceMappingURL=chunk-YCWGATWI.js.map
+//# sourceMappingURL=chunk-24I7BN55.js.map

package/dist/{chunk-EKMEHE4H.js → chunk-33YXPOE3.js}

@@ -94,8 +94,7 @@ var WORKSPACE_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
   "vendor",
   ".superpowers",
   ".codex",
-  ".claude",
-  ".clio-coder-benchmark"
+  ".claude"
 ]);
 function comparePaths(a, b) {
   return a === b ? 0 : a < b ? -1 : 1;
@@ -337,4 +336,4 @@ export {
   enumerateWorkspaceFilesAsync,
   filterWorkspaceFileCandidates
 };
-//# sourceMappingURL=chunk-EKMEHE4H.js.map
+//# sourceMappingURL=chunk-33YXPOE3.js.map

package/dist/chunk-3BPUFZDL.js

@@ -0,0 +1,37 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  durableAssistantTextFromEvent
+} from "./chunk-QM3F2GKX.js";
+import {
+  responseModelIdObservationFromRecord
+} from "./chunk-CJUB2JJ2.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/dispatch-event-text.ts
+init_esm_shims();
+function assistantTextFromEvent(event) {
+  return durableAssistantTextFromEvent(event).trim();
+}
+function receiptResponseModelIdObservationLabel(receipt) {
+  const responses = receipt.upstreamResponses ?? [];
+  if (responses.length === 0) return null;
+  const labels = responses.map((response) => {
+    const observation = responseModelIdObservationFromRecord(
+      response,
+      "legacy-difference-only"
+    );
+    if (observation.state === "reported") return `reported:${observation.reportedModelId}`;
+    if (observation.state === "not-reported") return "not-reported";
+    if (observation.state === "not-observed") return "not-observed";
+    return `legacy-difference-only:${observation.differingModelId ?? "none"}`;
+  });
+  return `response_model_id_observation=${labels.join(",")}`;
+}
+
+export {
+  assistantTextFromEvent,
+  receiptResponseModelIdObservationLabel
+};
+//# sourceMappingURL=chunk-3BPUFZDL.js.map

package/dist/chunk-43AOLP7E.js

@@ -0,0 +1,375 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  isSessionEntry
+} from "./chunk-GOXNB3AO.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-43AOLP7E.js.map

package/dist/{chunk-ZDOOVTXZ.js → chunk-4OC57DA6.js}

@@ -1,4 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  DEFAULT_WORKING_SET_SETTINGS
+} from "./chunk-LL4KHSZI.js";
 import {
   GUARDRAIL_DEFAULTS
 } from "./chunk-4ZG3XFUR.js";
@@ -124,6 +127,9 @@ var DEFAULT_SETTINGS = {
     threshold: 0.8,
     excludeLastTurns: 6
   },
+  context: {
+    workingSet: DEFAULT_WORKING_SET_SETTINGS
+  },
   retry: {
     enabled: true,
     maxRetries: 3,
@@ -364,9 +370,9 @@ keybindings: {}
 #   auto              master switch for the pre-request compaction trigger.
 #                     Manual /context compact always runs the LLM summary.
 #   threshold         pressure = estimated_tokens / context_window. Crossing
-#                     it masks stale tool observations first, then runs a
-#                     full LLM summary if pressure stays above the threshold.
-#   excludeLastTurns  recent user turns protected from observation masking.
+#                     it evicts from the working set first, then runs a full
+#                     LLM summary if pressure stays above the threshold.
+#   excludeLastTurns  recent turns protected only by the temporary legacy mask.
 #   model             optional pattern (e.g. provider/summary-model-id) for a
 #                     dedicated summarization model. Absent \u21D2 orchestrator target.
 #   systemPrompt      optional path to a prompt-override file.
@@ -377,6 +383,23 @@ compaction:
   # model: provider/summary-model-id
   # systemPrompt: ~/.config/clio-coder/prompts/compaction.md
 
+# Non-destructive working-set eviction before summary compaction.
+#   enabled             false skips eviction and goes directly to the summary stage.
+#   policy              structural-v1 evicts by what the session did since
+#                       (re-reads, edits, resolved failures, consumed listings)
+#                       and falls back to age only under pressure;
+#                       age-horizon is the previous age-based selection.
+#   target              pressure ratio an applied eviction batches down to.
+#   protectLastTurns    recent user turns whose observations remain in the working set.
+#   minEvictableTokens  entries below this estimate remain in the working set.
+context:
+  workingSet:
+    enabled: true
+    policy: structural-v1
+    target: 0.6
+    protectLastTurns: 6
+    minEvictableTokens: 200
+
 # Transient provider/stream retry controls for interactive chat.
 # Retryable errors include overloads, rate limits, 5xx responses, network
 # resets, and timeouts. Context overflow uses compaction recovery instead.
@@ -423,4 +446,4 @@ export {
   DEFAULT_SETTINGS,
   DEFAULT_SETTINGS_YAML
 };
-//# sourceMappingURL=chunk-ZDOOVTXZ.js.map
+//# sourceMappingURL=chunk-4OC57DA6.js.map

package/dist/{chunk-6SGHMWE3.js → chunk-5JGRAMKL.js}

@@ -1,20 +1,20 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   assistantTextFromEvent
-} from "./chunk-XBXAASKX.js";
+} from "./chunk-3BPUFZDL.js";
 import {
   compileExecutionPlan,
   durableAssistantTextFromEvent
-} from "./chunk-SRDMMSEP.js";
+} from "./chunk-QM3F2GKX.js";
 import {
   deriveExecutionRole
-} from "./chunk-GGXXDWE4.js";
+} from "./chunk-22NAGB7X.js";
 import {
   truncateUtf8
 } from "./chunk-6XLNIQDB.js";
 import {
   BusChannels
-} from "./chunk-OQ33BKR3.js";
+} from "./chunk-G7MUEIGA.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -274,4 +274,4 @@ export {
   compileScoutTransition,
   createDispatchRunEventRegistry
 };
-//# sourceMappingURL=chunk-6SGHMWE3.js.map
+//# sourceMappingURL=chunk-5JGRAMKL.js.map