@iowarp/clio-coder 0.4.2 → 0.4.4

package/dist/{chunk-34BHNEE3.js → chunk-GHS5EBTQ.js}

@@ -2,9 +2,6 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   warnLegacyNaming
 } from "./chunk-D7E7WCDF.js";
-import {
-  MAX_TIMER_DELAY_MS
-} from "./chunk-EBY63B7G.js";
 import {
   ACTIVE_AGENT_AUTOMATION_ROLES,
   ACTIVE_ROUTING_POSTURES,
@@ -14,19 +11,22 @@ import {
   THEME_NAMED_COLORS,
   THINKING_LEVELS
 } from "./chunk-UXCU4E3T.js";
+import {
+  MAX_TIMER_DELAY_MS
+} from "./chunk-EBY63B7G.js";
 import {
   withStateFileLockSync
 } from "./chunk-IKCO5N3L.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
+import {
+  safeResourceWrite
+} from "./chunk-WEPFGWHJ.js";
 import {
   clioConfigDir,
   resolveClioDirs
 } from "./chunk-BYP5D4HI.js";
-import {
-  safeResourceWrite
-} from "./chunk-WEPFGWHJ.js";
 import {
   __toESM,
   init_esm_shims
@@ -393,6 +393,52 @@ function validateLmStudioSettings(issues, path, value) {
   }
   return Object.keys(out).length > 0 ? out : void 0;
 }
+function validateLiteLLMSettings(issues, path, value) {
+  if (!isPlainObject(value)) {
+    issues.add(path, `expected a map, got ${describe(value)}`);
+    return void 0;
+  }
+  issues.unknownKeys(path, value, ["request"]);
+  const out = {};
+  if ("request" in value) {
+    if (!isPlainObject(value.request)) {
+      issues.add(`${path}.request`, `expected a map, got ${describe(value.request)}`);
+    } else {
+      issues.unknownKeys(`${path}.request`, value.request, [
+        "tags",
+        "sendSessionId",
+        "timeoutSeconds",
+        "streamTimeoutSeconds",
+        "numRetries"
+      ]);
+      const request = {};
+      if ("tags" in value.request) {
+        const parsed = expectStringArray(issues, `${path}.request.tags`, value.request.tags);
+        if (parsed !== void 0) {
+          const invalidTag = parsed.find((tag) => tag.includes(","));
+          if (invalidTag) issues.add(`${path}.request.tags`, "tags may not contain commas");
+          else if (parsed.length > 0) request.tags = [...new Set(parsed)];
+        }
+      }
+      if ("sendSessionId" in value.request) {
+        const parsed = expectBoolean(issues, `${path}.request.sendSessionId`, value.request.sendSessionId);
+        if (parsed !== void 0) request.sendSessionId = parsed;
+      }
+      for (const key of ["timeoutSeconds", "streamTimeoutSeconds"]) {
+        if (key in value.request) {
+          const parsed = expectNumber(issues, `${path}.request.${key}`, value.request[key], { min: 1e-3, max: 86400 });
+          if (parsed !== void 0) request[key] = parsed;
+        }
+      }
+      if ("numRetries" in value.request) {
+        const parsed = expectInteger(issues, `${path}.request.numRetries`, value.request.numRetries, { min: 0, max: 100 });
+        if (parsed !== void 0) request.numRetries = parsed;
+      }
+      if (Object.keys(request).length > 0) out.request = request;
+    }
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
 function validateTarget(issues, path, value) {
   if (!isPlainObject(value)) {
     issues.add(path, `expected a map, got ${describe(value)}`);
@@ -410,6 +456,7 @@ function validateTarget(issues, path, value) {
     "gateway",
     "pricing",
     "lmstudio",
+    "litellm",
     "maxConcurrentRequests"
   ]);
   const id = "id" in value ? expectString(issues, `${path}.id`, value.id) : void 0;
@@ -461,6 +508,10 @@ function validateTarget(issues, path, value) {
     const v = validateLmStudioSettings(issues, `${path}.lmstudio`, value.lmstudio);
     if (v !== void 0) target.lmstudio = v;
   }
+  if ("litellm" in value) {
+    const v = validateLiteLLMSettings(issues, `${path}.litellm`, value.litellm);
+    if (v !== void 0) target.litellm = v;
+  }
   if ("maxConcurrentRequests" in value) {
     const v = expectInteger(issues, `${path}.maxConcurrentRequests`, value.maxConcurrentRequests, { min: 1 });
     if (v !== void 0) target.maxConcurrentRequests = v;
@@ -1843,4 +1894,4 @@ export {
   removeFleetProfileFromSettings,
   bindAgentProfileInSettings
 };
-//# sourceMappingURL=chunk-34BHNEE3.js.map
+//# sourceMappingURL=chunk-GHS5EBTQ.js.map

package/dist/{chunk-DYHAXKHD.js → chunk-GWZNEVM2.js}

@@ -1,23 +1,23 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  clio_coder_naming_default
-} from "./chunk-XQRY4DTA.js";
 import {
   settings_v2_default
-} from "./chunk-3KIPBMUA.js";
+} from "./chunk-5ICU3EUH.js";
+import {
+  clio_coder_naming_default
+} from "./chunk-IGLP3ODT.js";
 import {
   upgradeLegacyExtensionInstallState
-} from "./chunk-77QIVUZB.js";
+} from "./chunk-5MEZN6CB.js";
 import {
   readSettings,
   settingsPath,
   updateSettings,
   withSettingsLock
-} from "./chunk-34BHNEE3.js";
+} from "./chunk-GHS5EBTQ.js";
 import {
   authStoragePath,
   openAuthStorage
-} from "./chunk-WNP7O5WZ.js";
+} from "./chunk-ID64D7PE.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
@@ -140,6 +140,9 @@ var REGISTRY = Object.freeze([
 function listMigrations() {
   return REGISTRY;
 }
+function readMigrationManifest(stateDir) {
+  return readManifest(manifestPath(stateDir));
+}
 function manifestPath(stateDir) {
   return join2(stateDir, "migrations.json");
 }
@@ -184,6 +187,7 @@ async function runPending(stateDir, migrations = REGISTRY) {
 
 export {
   listMigrations,
+  readMigrationManifest,
   runPending
 };
-//# sourceMappingURL=chunk-DYHAXKHD.js.map
+//# sourceMappingURL=chunk-GWZNEVM2.js.map

package/dist/chunk-GX5WYQO4.js

@@ -0,0 +1,59 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  VERIFICATION_SCRIPT_FAMILY_HINT
+} from "./chunk-UL3WSD3F.js";
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-4NSRCOYP.js";
+import {
+  StringEnum
+} from "./chunk-YPC6ZR5L.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/verify/surface.ts
+init_esm_shims();
+var BROWSER_MODES = ["auto", "required", "off"];
+function prepareVerifyArguments(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) return args;
+  const next = { ...args };
+  if (typeof next.args === "string") {
+    try {
+      const parsed = JSON.parse(next.args);
+      if (Array.isArray(parsed)) next.args = parsed;
+    } catch {
+    }
+  }
+  return next;
+}
+var verifyToolSurface = {
+  name: ToolNames.Verify,
+  description: 'Run a declared verification check: no arguments lists package scripts and .clio-coder/verifiers.yaml entries, check=<id> runs one, and check="frontend" with path validates an HTML/CSS/JS artifact.',
+  parameters: typebox_exports.Object({
+    check: typebox_exports.Optional(
+      typebox_exports.String({
+        description: `Check id, package script (${VERIFICATION_SCRIPT_FAMILY_HINT}), or "frontend"; omit to list.`
+      })
+    ),
+    path: typebox_exports.Optional(typebox_exports.String({ description: "frontend: artifact file under the workspace root." })),
+    args: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String(), { description: "Package scripts only: arguments after --." })),
+    browser: typebox_exports.Optional(StringEnum(BROWSER_MODES, { description: "frontend: headless browser mode (default auto)." })),
+    cwd: typebox_exports.Optional(typebox_exports.String({ description: "Package scripts only: working directory." })),
+    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Package and frontend checks only: timeout in ms." })),
+    max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Output cap in bytes (default 600000)." }))
+  }),
+  baseActionClass: "execute",
+  executionMode: "sequential",
+  prepareArguments: prepareVerifyArguments
+};
+
+export {
+  BROWSER_MODES,
+  prepareVerifyArguments,
+  verifyToolSurface
+};
+//# sourceMappingURL=chunk-GX5WYQO4.js.map

package/dist/chunk-GYV6VZOC.js

@@ -0,0 +1,26 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/artifact-paths.ts
+init_esm_shims();
+var CLIO_PROJECT_DIR = ".clio-coder";
+var CLIO_ARTIFACT_DIR = `${CLIO_PROJECT_DIR}/artifacts`;
+var KIND_FILENAMES = {
+  plan: "PLAN.md",
+  review: "REVIEW.md",
+  report: "REPORT.md"
+};
+var DEFAULT_FILENAME = KIND_FILENAMES.plan;
+function artifactDefaultPath(kind) {
+  const filename = typeof kind === "string" ? KIND_FILENAMES[kind] ?? DEFAULT_FILENAME : DEFAULT_FILENAME;
+  return `${CLIO_ARTIFACT_DIR}/${filename}`;
+}
+
+export {
+  CLIO_PROJECT_DIR,
+  CLIO_ARTIFACT_DIR,
+  artifactDefaultPath
+};
+//# sourceMappingURL=chunk-GYV6VZOC.js.map

package/dist/{chunk-MQXIVJ35.js → chunk-HAXOFFRH.js}

@@ -9,14 +9,14 @@ import {
   readClioVersion,
   readPiMonoVersion
 } from "./chunk-IWHMRKLL.js";
-import {
-  clioStateDir,
-  stateRootRemoved
-} from "./chunk-BYP5D4HI.js";
 import {
   fsyncDirectory,
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
+import {
+  clioStateDir,
+  stateRootRemoved
+} from "./chunk-BYP5D4HI.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -576,4 +576,4 @@ export {
   openSession,
   resumeSession
 };
-//# sourceMappingURL=chunk-MQXIVJ35.js.map
+//# sourceMappingURL=chunk-HAXOFFRH.js.map

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