@iowarp/clio-coder 0.4.3 → 0.4.4

package/dist/chunk-I2DWJ4GM.js

@@ -0,0 +1,390 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  decisionRef
+} from "./chunk-54X7T7DK.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/dispatch/event-pump.ts
+init_esm_shims();
+var EVENT_TEE_LIMIT = 1024;
+function startDispatchEventPump(source, fold, options = {}) {
+  const limit = options.limit ?? EVENT_TEE_LIMIT;
+  const pending = [...options.prelude ?? []];
+  const waiters = [];
+  let finished = false;
+  let abandoned = false;
+  let dropped = 0;
+  const push = (value) => {
+    if (abandoned) return;
+    const waiter = waiters.shift();
+    if (waiter) {
+      waiter({ value, done: false });
+      return;
+    }
+    pending.push(value);
+    while (pending.length > limit) {
+      pending.shift();
+      dropped += 1;
+    }
+  };
+  const end = () => {
+    finished = true;
+    while (waiters.length > 0) {
+      waiters.shift()?.({ value: void 0, done: true });
+    }
+  };
+  const notify = (event) => {
+    try {
+      options.onEvent?.(event);
+    } catch (error) {
+      options.onError?.(error);
+    }
+  };
+  const done = (async () => {
+    try {
+      for (const event of options.prelude ?? []) notify(event);
+      for await (const event of source) {
+        try {
+          fold(event);
+        } catch (error) {
+          options.onError?.(error);
+        }
+        notify(event);
+        push(event);
+      }
+    } catch (error) {
+      options.onError?.(error);
+    } finally {
+      end();
+    }
+  })();
+  const events = {
+    next() {
+      if (pending.length > 0) {
+        return Promise.resolve({ value: pending.shift(), done: false });
+      }
+      if (finished || abandoned) return Promise.resolve({ value: void 0, done: true });
+      return new Promise((resolve) => {
+        waiters.push(resolve);
+      });
+    },
+    return() {
+      abandoned = true;
+      pending.length = 0;
+      while (waiters.length > 0) {
+        waiters.shift()?.({ value: void 0, done: true });
+      }
+      return Promise.resolve({ value: void 0, done: true });
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+  return { events, done, droppedEvents: () => dropped };
+}
+var WORKER_OUTPUT_MAX_BYTES = 8192;
+var WORKER_OUTPUT_TRUNCATION_MARKER = "\n[worker output truncated]";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assistantTextFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => {
+    if (typeof block === "string") return block;
+    if (!isRecord(block)) return "";
+    return typeof block.text === "string" ? block.text : "";
+  }).join("");
+}
+function isDurableAssistantMessage(message) {
+  const stopReason = message.stopReason;
+  if (stopReason === "toolUse" || stopReason === "error" || stopReason === "aborted" || stopReason === "cancelled") {
+    return false;
+  }
+  if (!Array.isArray(message.content)) return true;
+  return !message.content.some((block) => isRecord(block) && block.type === "toolCall");
+}
+function durableAssistantTextFromEvent(event) {
+  if (!isRecord(event) || event.type !== "message_end" || !isRecord(event.message)) return "";
+  if (event.message.role !== "assistant" || !isDurableAssistantMessage(event.message)) return "";
+  return assistantTextFromContent(event.message.content);
+}
+function boundedOutput(state, text) {
+  const bytes = Buffer.byteLength(text, "utf8");
+  const bounded = truncateUtf8(text, WORKER_OUTPUT_MAX_BYTES, WORKER_OUTPUT_TRUNCATION_MARKER);
+  return { state, text: bounded, bytes, truncated: bounded !== text };
+}
+function createWorkerOutputCapture() {
+  let finalText = null;
+  let partialText = "";
+  let partialBytes = 0;
+  let partialStored = 0;
+  return {
+    observe(event) {
+      if (!isRecord(event)) return;
+      if (event.type === "message_end") {
+        const message = isRecord(event.message) ? event.message : null;
+        partialText = "";
+        partialBytes = 0;
+        partialStored = 0;
+        if (message === null || message.role !== "assistant") return;
+        if (!isDurableAssistantMessage(message)) return;
+        const text = assistantTextFromContent(message.content).trim();
+        if (text.length > 0) finalText = text;
+        return;
+      }
+      if (event.type !== "message_update") return;
+      const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
+      if (assistantEvent === null || assistantEvent.type !== "text_delta") return;
+      const delta = assistantEvent.delta;
+      if (typeof delta !== "string" || delta.length === 0) return;
+      partialBytes += Buffer.byteLength(delta, "utf8");
+      if (partialStored < WORKER_OUTPUT_MAX_BYTES) {
+        partialText += delta;
+        partialStored += Buffer.byteLength(delta, "utf8");
+      }
+    },
+    snapshot() {
+      if (partialBytes > 0 && partialText.trim().length > 0) {
+        const bounded = truncateUtf8(partialText.trim(), WORKER_OUTPUT_MAX_BYTES, WORKER_OUTPUT_TRUNCATION_MARKER);
+        return {
+          state: "partial",
+          text: bounded,
+          bytes: partialBytes,
+          truncated: bounded !== partialText.trim() || partialBytes > partialStored
+        };
+      }
+      if (finalText !== null) return boundedOutput("final", finalText);
+      return void 0;
+    }
+  };
+}
+
+// src/domains/dispatch/admission-error.ts
+init_esm_shims();
+var AdmissionCanceledError = class extends Error {
+  code = "admission_canceled";
+  constructor(message = "dispatch: admission canceled before a capacity slot opened") {
+    super(message);
+    this.name = "AdmissionCanceledError";
+  }
+};
+
+// src/domains/session/decision-board.ts
+init_esm_shims();
+import { randomUUID } from "node:crypto";
+function answeredAtForDecision(policy, sourceQuestion) {
+  for (let index = policy.rounds.length - 1; index >= 0; index -= 1) {
+    const round = policy.rounds[index];
+    if (!round?.answeredAt) continue;
+    if (round.answers.some((answer) => answer.question === sourceQuestion)) return round.answeredAt;
+    if (round.questions.some((question) => question.question === sourceQuestion)) return round.answeredAt;
+  }
+  return void 0;
+}
+function finalizedInterviewEntryFields(policy) {
+  if (policy.rounds.length === 0 && policy.decisions.length === 0) return null;
+  if (!policy.turnId) throw new Error(`decision board: interview ${policy.id} has no originating user turn`);
+  if (policy.status !== "complete" && policy.status !== "cancelled") {
+    throw new Error(`decision board: interview ${policy.id} finalized with status ${policy.status}`);
+  }
+  const endedAt = policy.endedAt ?? policy.updatedAt;
+  const decisionsByKey = /* @__PURE__ */ new Map();
+  for (const decision of policy.decisions) {
+    const decidedAt = decision.source_question ? answeredAtForDecision(policy, decision.source_question) ?? endedAt : endedAt;
+    decisionsByKey.set(decision.key, {
+      key: decision.key,
+      value: decision.value,
+      ...decision.label ? { label: decision.label } : {},
+      ...decision.source_question ? { source_question: decision.source_question } : {},
+      status: "active",
+      decidedAt
+    });
+  }
+  return {
+    kind: "decisionLedger",
+    parentTurnId: policy.turnId,
+    interviewId: policy.id,
+    interviewStatus: policy.status,
+    startedAt: policy.startedAt,
+    endedAt,
+    roundCount: policy.rounds.length,
+    ...policy.summary ? { summary: policy.summary } : {},
+    ...policy.transcriptPath ? { transcriptPath: policy.transcriptPath } : {},
+    exposure: policy.exposure ?? "local",
+    decisions: [...decisionsByKey.values()]
+  };
+}
+var DECISION_REFS_CAP = 32;
+function activeDecisionRefs(board) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const entry of board) {
+    for (const decision of entry.decisions) {
+      if (decision.status === "active") refs.add(decisionRef(entry.interviewId, decision.key));
+    }
+  }
+  return [...refs].sort().slice(0, DECISION_REFS_CAP);
+}
+function isDecisionLedgerEntry(value) {
+  return !!value && typeof value === "object" && value.kind === "decisionLedger";
+}
+function foldDecisionBoard(entries) {
+  const lastByInterview = /* @__PURE__ */ new Map();
+  for (let index = 0; index < entries.length; index += 1) {
+    const raw = entries[index];
+    if (!isDecisionLedgerEntry(raw)) continue;
+    lastByInterview.set(raw.interviewId, { entry: raw, index });
+  }
+  return [...lastByInterview.values()].sort((left, right) => {
+    const byEndedAt = right.entry.endedAt.localeCompare(left.entry.endedAt);
+    return byEndedAt !== 0 ? byEndedAt : right.index - left.index;
+  }).map(({ entry }) => entry);
+}
+function activeLeafFromEntries(entries) {
+  for (let index = entries.length - 1; index >= 0; index -= 1) {
+    const entry = entries[index];
+    if (entry && typeof entry === "object" && entry.kind === "message") {
+      const turnId = entry.turnId;
+      if (typeof turnId === "string" && turnId.length > 0) return turnId;
+    }
+  }
+  return null;
+}
+function createDecisionBoardStore(deps = {}) {
+  let cachedSessionId;
+  let dirty = true;
+  let interviews = [];
+  const syncToSession = () => {
+    const sessionId = deps.getSessionId?.() ?? null;
+    if (!dirty && sessionId === cachedSessionId) return;
+    const entries = deps.readEntries?.() ?? [];
+    interviews = foldDecisionBoard(entries);
+    cachedSessionId = sessionId;
+    dirty = false;
+  };
+  const append = (entry) => {
+    if (!deps.appendEntry) throw new Error("decision board: no session ledger is available");
+    deps.appendEntry(entry);
+    dirty = true;
+  };
+  const store = {
+    snapshot() {
+      syncToSession();
+      return interviews;
+    },
+    recordFinalizedInterview(policy) {
+      const entry = finalizedInterviewEntryFields(policy);
+      if (entry === null) return false;
+      append(entry);
+      return true;
+    },
+    recordAgentDecision(input) {
+      syncToSession();
+      let superseded = null;
+      for (const interview of interviews) {
+        const prior = interview.decisions.find((decision) => decision.key === input.key && decision.status === "active");
+        if (prior === void 0) continue;
+        if (interview.origin !== "agent" || prior.source !== "agent") {
+          throw new Error(
+            `decision board: '${input.key}' is an operator decision (${interview.interviewId}); it can only be revised through ask_user`
+          );
+        }
+        superseded = { interviewId: interview.interviewId, key: prior.key };
+        break;
+      }
+      if (superseded !== null) store.supersede(superseded.interviewId, superseded.key, input.rationale);
+      const now = (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+      const entries = deps.readEntries?.() ?? [];
+      const parentTurnId = deps.getActiveLeafTurnId?.() ?? activeLeafFromEntries(entries);
+      if (!parentTurnId) throw new Error("decision board: no active branch leaf is available for the decision");
+      const entry = {
+        kind: "decisionLedger",
+        parentTurnId,
+        origin: "agent",
+        interviewId: `agent:${randomUUID()}`,
+        interviewStatus: "complete",
+        startedAt: now,
+        endedAt: now,
+        roundCount: 0,
+        exposure: "local",
+        decisions: [
+          {
+            key: input.key,
+            value: input.value,
+            ...input.label ? { label: input.label } : {},
+            status: "active",
+            decidedAt: now,
+            source: "agent",
+            alternatives: [...input.alternatives],
+            rationale: input.rationale
+          }
+        ]
+      };
+      append(entry);
+      return { entry, superseded };
+    },
+    supersede(interviewId, key, correction) {
+      syncToSession();
+      const interview = interviews.find((candidate) => candidate.interviewId === interviewId);
+      if (!interview) throw new Error(`decision board: interview ${interviewId} was not found on the active branch`);
+      const selected = interview.decisions.find((decision) => decision.key === key);
+      if (!selected) throw new Error(`decision board: decision ${key} was not found in interview ${interviewId}`);
+      const revisedAt = (deps.now?.() ?? /* @__PURE__ */ new Date()).toISOString();
+      const normalizedCorrection = correction?.trim();
+      const entries = deps.readEntries?.() ?? [];
+      const parentTurnId = deps.getActiveLeafTurnId?.() ?? activeLeafFromEntries(entries);
+      if (!parentTurnId) throw new Error("decision board: no active branch leaf is available for the revision");
+      const revision = {
+        kind: "decisionLedger",
+        parentTurnId,
+        interviewId: interview.interviewId,
+        interviewStatus: interview.interviewStatus,
+        startedAt: interview.startedAt,
+        endedAt: interview.endedAt,
+        roundCount: interview.roundCount,
+        ...interview.summary ? { summary: interview.summary } : {},
+        ...interview.transcriptPath ? { transcriptPath: interview.transcriptPath } : {},
+        ...interview.exposure ? { exposure: interview.exposure } : {},
+        decisions: interview.decisions.map((decision) => {
+          if (decision.key !== selected.key) return { ...decision };
+          const next = { ...decision, status: "superseded", revisedAt };
+          if (normalizedCorrection) next.correction = normalizedCorrection;
+          else delete next.correction;
+          return next;
+        })
+      };
+      append(revision);
+      return revision;
+    },
+    invalidate() {
+      dirty = true;
+    }
+  };
+  return store;
+}
+function decisionRationale(decision) {
+  const parts = [];
+  if (decision.alternatives?.length) parts.push(`Alternatives: ${decision.alternatives.join("; ")}`);
+  if (decision.rationale) parts.push(`Rationale: ${decision.rationale}`);
+  if (parts.length > 0) return parts.join(". ");
+  return decision.source_question ?? decision.correction;
+}
+
+export {
+  EVENT_TEE_LIMIT,
+  startDispatchEventPump,
+  WORKER_OUTPUT_MAX_BYTES,
+  durableAssistantTextFromEvent,
+  createWorkerOutputCapture,
+  AdmissionCanceledError,
+  activeDecisionRefs,
+  foldDecisionBoard,
+  createDecisionBoardStore,
+  decisionRationale
+};
+//# sourceMappingURL=chunk-I2DWJ4GM.js.map

package/dist/{chunk-TXOTCRLG.js → chunk-I5FWO7L5.js}

@@ -3,13 +3,13 @@ import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// src/core/shell-quote.ts
+// src/domains/evidence/ordering.ts
 init_esm_shims();
-function shellQuote(value) {
-  return `'${value.replace(/'/g, "'\\''")}'`;
+function compareCodepoints(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
 }
 
 export {
-  shellQuote
+  compareCodepoints
 };
-//# sourceMappingURL=chunk-TXOTCRLG.js.map
+//# sourceMappingURL=chunk-I5FWO7L5.js.map