@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-AO4RKG4M.js

@@ -0,0 +1,277 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  assistantTextFromEvent
+} from "./chunk-4KLWL3UC.js";
+import {
+  compileExecutionPlan,
+  durableAssistantTextFromEvent
+} from "./chunk-6EJV5X2W.js";
+import {
+  deriveExecutionRole
+} from "./chunk-GGXXDWE4.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  BusChannels
+} from "./chunk-OQ33BKR3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/dispatch-run-events.ts
+init_esm_shims();
+var RUN_TAIL_ENTRY_LIMIT = 100;
+var RUN_TAIL_RUN_LIMIT = 64;
+var RUN_TAIL_TEXT_LIMIT = 600;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function eventDetail(event) {
+  const text = assistantTextFromEvent(event);
+  if (text.length > 0) return truncateUtf8(text, RUN_TAIL_TEXT_LIMIT, "...");
+  if (!isRecord(event)) return void 0;
+  if (event.type === "clio_tool_finish" && isRecord(event.payload)) {
+    const tool = typeof event.payload.tool === "string" ? event.payload.tool : "tool";
+    const outcome = typeof event.payload.outcome === "string" ? event.payload.outcome : "";
+    return `${tool} ${outcome}`.trim();
+  }
+  if (event.type === "attempt_start") {
+    const attempt = typeof event.attempt === "number" ? event.attempt : "?";
+    const runId = typeof event.runId === "string" ? event.runId : "?";
+    const reason = typeof event.reason === "string" ? event.reason : "retry";
+    return truncateUtf8(`attempt ${attempt} -> ${runId}: ${reason}`, RUN_TAIL_TEXT_LIMIT, "...");
+  }
+  return void 0;
+}
+function createDispatchRunEventRegistry() {
+  const runTails = /* @__PURE__ */ new Map();
+  const activeRuns = /* @__PURE__ */ new Set();
+  const activeBatches = /* @__PURE__ */ new Set();
+  const pruneRunTails = () => {
+    while (runTails.size > RUN_TAIL_RUN_LIMIT) {
+      let oldestKey = null;
+      let oldestSeen = Number.POSITIVE_INFINITY;
+      for (const [key, state] of runTails) {
+        if (activeRuns.has(key) || state.lastSeenAt >= oldestSeen) continue;
+        oldestKey = key;
+        oldestSeen = state.lastSeenAt;
+      }
+      if (oldestKey === null) break;
+      runTails.delete(oldestKey);
+    }
+  };
+  const recordRunEvent = (runId, agentId, event) => {
+    const type = isRecord(event) && typeof event.type === "string" ? event.type : "unknown";
+    if (type === "heartbeat" || type === "message_update") return;
+    const state = runTails.get(runId) ?? { agentId, entries: [], lastSeenAt: Date.now() };
+    state.lastSeenAt = Date.now();
+    const entry = { at: (/* @__PURE__ */ new Date()).toISOString(), type };
+    const detail = eventDetail(event);
+    if (detail !== void 0) entry.detail = detail;
+    state.entries.push(entry);
+    if (state.entries.length > RUN_TAIL_ENTRY_LIMIT) {
+      state.entries.splice(0, state.entries.length - RUN_TAIL_ENTRY_LIMIT);
+    }
+    runTails.set(runId, state);
+    pruneRunTails();
+  };
+  const drainSingle = async (runId, agentId, events, bus) => {
+    const summary = {
+      count: 0,
+      types: [],
+      lastAssistantText: "",
+      terminalAttemptRunId: runId
+    };
+    for await (const event of events) {
+      summary.count += 1;
+      const type = isRecord(event) && typeof event.type === "string" ? event.type : "unknown";
+      summary.types.push(type);
+      if (type === "attempt_start") summary.lastAssistantText = "";
+      const text = durableAssistantTextFromEvent(event);
+      if (text.trim().length > 0) summary.lastAssistantText = text;
+      recordRunEvent(runId, agentId, event);
+      if (type !== "heartbeat") bus?.emit(BusChannels.DispatchProgress, { runId, agentId, event });
+    }
+    return summary;
+  };
+  const drainBatch = async (batchId, events, bus) => {
+    const summaries = /* @__PURE__ */ new Map();
+    for await (const event of events) {
+      if (!isRecord(event) || event.type !== "batch_run_event") continue;
+      const runId = typeof event.runId === "string" ? event.runId : batchId;
+      const agentId = typeof event.agentId === "string" ? event.agentId : "batch";
+      const inner = event.event;
+      const summary = summaries.get(runId) ?? {
+        count: 0,
+        types: [],
+        lastAssistantText: "",
+        terminalAttemptRunId: runId
+      };
+      summary.count += 1;
+      const type = isRecord(inner) && typeof inner.type === "string" ? inner.type : "unknown";
+      summary.types.push(type);
+      const text = durableAssistantTextFromEvent(inner);
+      if (text.trim().length > 0) summary.lastAssistantText = text;
+      summaries.set(runId, summary);
+      recordRunEvent(runId, agentId, inner);
+      if (type !== "heartbeat") bus?.emit(BusChannels.DispatchProgress, { runId, agentId, event: inner });
+    }
+    return summaries;
+  };
+  return {
+    registerSingle(handle, agentId, bus) {
+      if (activeRuns.has(handle.runId)) {
+        throw new Error(`dispatch event registry: run '${handle.runId}' is already registered`);
+      }
+      activeRuns.add(handle.runId);
+      const summaryPromise = drainSingle(handle.runId, agentId, handle.events, bus);
+      const completion = Promise.allSettled([summaryPromise, handle.finalPromise]).then(
+        ([summaryResult, receiptResult]) => {
+          if (summaryResult.status === "rejected") throw summaryResult.reason;
+          if (receiptResult.status === "rejected") throw receiptResult.reason;
+          return { receipt: receiptResult.value, summary: summaryResult.value };
+        }
+      );
+      void completion.finally(() => {
+        activeRuns.delete(handle.runId);
+        pruneRunTails();
+      }).catch(() => {
+      });
+      return { runId: handle.runId, completion };
+    },
+    registerBatch(handle, agentIds, bus) {
+      if (activeBatches.has(handle.batchId)) {
+        throw new Error(`dispatch event registry: batch '${handle.batchId}' is already registered`);
+      }
+      const duplicateRunId = handle.assignmentIds.find(
+        (runId, index) => handle.assignmentIds.slice(0, index).includes(runId)
+      );
+      if (duplicateRunId !== void 0) {
+        throw new Error(`dispatch event registry: batch '${handle.batchId}' repeats run '${duplicateRunId}'`);
+      }
+      const activeRunId = handle.assignmentIds.find((runId) => activeRuns.has(runId));
+      if (activeRunId !== void 0) {
+        throw new Error(`dispatch event registry: run '${activeRunId}' is already registered`);
+      }
+      activeBatches.add(handle.batchId);
+      for (const runId of handle.assignmentIds) activeRuns.add(runId);
+      const completion = Promise.allSettled([drainBatch(handle.batchId, handle.events, bus), handle.finalPromise]).then(
+        ([summariesResult, receiptsResult]) => {
+          if (summariesResult.status === "rejected") throw summariesResult.reason;
+          if (receiptsResult.status === "rejected") throw receiptsResult.reason;
+          return { receipts: receiptsResult.value, summaries: summariesResult.value };
+        }
+      );
+      void completion.finally(() => {
+        activeBatches.delete(handle.batchId);
+        for (const runId of handle.assignmentIds) activeRuns.delete(runId);
+        pruneRunTails();
+      }).catch(() => {
+      });
+      for (const [index, runId] of handle.assignmentIds.entries()) {
+        if (!runTails.has(runId)) {
+          runTails.set(runId, {
+            agentId: agentIds[index] ?? "unknown",
+            entries: [],
+            lastSeenAt: Date.now()
+          });
+        }
+      }
+      return { batchId: handle.batchId, assignmentIds: handle.assignmentIds, completion };
+    },
+    recordEvent: recordRunEvent,
+    eventTail(runId) {
+      const state = runTails.get(runId);
+      return state === void 0 ? null : { agentId: state.agentId, entries: [...state.entries] };
+    }
+  };
+}
+
+// src/domains/dispatch/scout-transition.ts
+init_esm_shims();
+function scopeFor(authority) {
+  return authority === "read-only" || authority === "verification" ? "readonly" : "workspace";
+}
+function assertReceiptDigest(value) {
+  if (!/^[0-9a-f]{64}$/u.test(value)) throw new Error("scout transition: source receipt digest is invalid");
+}
+function compileScoutTransition(input) {
+  assertReceiptDigest(input.sourceReceiptDigest);
+  if (!input.scout.needsSplit) {
+    return {
+      kind: "settled",
+      sourceReceiptDigest: input.sourceReceiptDigest,
+      findings: input.scout.findings.map((finding) => ({ ...finding }))
+    };
+  }
+  const subtasks = input.scout.proposedSubtasks;
+  const byId = new Map(input.bindings.map((binding) => [binding.subtaskId, binding]));
+  if (byId.size !== input.bindings.length || byId.size !== subtasks.length) {
+    throw new Error("scout transition: coordinator bindings must match subtasks exactly");
+  }
+  for (const binding of input.bindings) {
+    if (!subtasks.some((subtask) => subtask.id === binding.subtaskId)) {
+      throw new Error(`scout transition: undeclared binding '${binding.subtaskId}'`);
+    }
+  }
+  const approved = new Set(input.authority.approvedAuthorities);
+  const missing = /* @__PURE__ */ new Set();
+  const steps = subtasks.map((subtask) => {
+    const binding = byId.get(subtask.id);
+    if (binding === void 0) throw new Error(`scout transition: subtask '${subtask.id}' has no agent binding`);
+    if (binding.spec.resultContract.kind !== subtask.expectedResultContract) {
+      throw new Error(`scout transition: subtask '${subtask.id}' result contract does not match its bound agent`);
+    }
+    if (binding.spec.capabilityClass !== subtask.requestedAuthority) {
+      throw new Error(`scout transition: subtask '${subtask.id}' authority does not match its bound agent`);
+    }
+    const granted = approved.has(subtask.requestedAuthority);
+    if (!granted) missing.add(subtask.requestedAuthority);
+    return {
+      id: subtask.id,
+      agentId: binding.spec.id,
+      executionRole: deriveExecutionRole({
+        attempt: 0,
+        capabilityClass: binding.spec.capabilityClass,
+        resultContractKind: binding.spec.resultContract.kind
+      }),
+      scope: scopeFor(subtask.requestedAuthority),
+      expectedResultContract: subtask.expectedResultContract,
+      requestedAuthority: subtask.requestedAuthority,
+      approvedAuthority: granted ? subtask.requestedAuthority : null,
+      dependencies: [...subtask.dependencies],
+      task: subtask.task
+    };
+  });
+  const plan = compileExecutionPlan({
+    topology: "fleet",
+    rootTask: input.rootTask,
+    maxWorkers: Math.max(1, Math.min(4, input.maxWorkers, steps.length)),
+    onFailure: "stop",
+    steps
+  });
+  if (missing.size > 0) {
+    return {
+      kind: "approval-required",
+      sourceReceiptDigest: input.sourceReceiptDigest,
+      plan,
+      requiredAuthorities: [...missing]
+    };
+  }
+  return {
+    kind: "ready",
+    sourceReceiptDigest: input.sourceReceiptDigest,
+    plan,
+    authority: {
+      basis: input.authority.basis,
+      approvedAuthorities: [...input.authority.approvedAuthorities]
+    }
+  };
+}
+
+export {
+  compileScoutTransition,
+  createDispatchRunEventRegistry
+};
+//# sourceMappingURL=chunk-AO4RKG4M.js.map