@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/monitor-MEQA5C3I.js

@@ -0,0 +1,661 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  receiptEvidenceLabels,
+  workerTextLabel,
+  workerTextNonEvidenceNotices
+} from "./chunk-6N5PTWMY.js";
+import {
+  monitorToolSurface
+} from "./chunk-FJ3H4MN5.js";
+import {
+  COST_NOT_MEASURED,
+  costAggregateForAmount,
+  formatCostAggregate
+} from "./chunk-WVO7V2QY.js";
+import "./chunk-HC4CLZ2Y.js";
+import "./chunk-HFSBBKSQ.js";
+import {
+  UNVERIFIABLE_RECEIPT_VERIFICATION,
+  renderAgentLedgerBoard
+} from "./chunk-6EJV5X2W.js";
+import "./chunk-4BJ5BYCE.js";
+import "./chunk-QKMUKYO7.js";
+import {
+  verifyReceiptIntegrity
+} from "./chunk-AGYYIBLL.js";
+import "./chunk-OOJYHWRB.js";
+import "./chunk-TXOTCRLG.js";
+import "./chunk-G4BMMOKF.js";
+import {
+  isTerminalRunEnvelope
+} from "./chunk-MQSRRFWA.js";
+import "./chunk-STBPMHSX.js";
+import "./chunk-GGXXDWE4.js";
+import "./chunk-5UUP6MWO.js";
+import "./chunk-CMZWFGD2.js";
+import "./chunk-I4HZDVNP.js";
+import "./chunk-7MNJORFF.js";
+import "./chunk-OQE5J4C6.js";
+import "./chunk-ECH6PKUQ.js";
+import "./chunk-T6YILFSB.js";
+import "./chunk-VAKQQHWR.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import "./chunk-5B2AEOW5.js";
+import "./chunk-CGKSTWHD.js";
+import "./chunk-YHZX5GEU.js";
+import "./chunk-EKMEHE4H.js";
+import "./chunk-LZSJBIVT.js";
+import "./chunk-A3CYT5EX.js";
+import "./chunk-ZDOOVTXZ.js";
+import "./chunk-4VP4KH3K.js";
+import "./chunk-M6SHUN7Q.js";
+import "./chunk-R346GLFC.js";
+import "./chunk-X75S7HFS.js";
+import {
+  sleep
+} from "./chunk-FQ4SKYE4.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import "./chunk-IHXBNWMM.js";
+import "./chunk-SST6Z5JA.js";
+import "./chunk-4ZG3XFUR.js";
+import "./chunk-APJ265NV.js";
+import "./chunk-FCSXB6T2.js";
+import "./chunk-YXLYO42X.js";
+import "./chunk-BNAZZHFG.js";
+import "./chunk-6EJMN2Y3.js";
+import "./chunk-WEPFGWHJ.js";
+import "./chunk-OQ33BKR3.js";
+import "./chunk-7CR24IG7.js";
+import "./chunk-IWHMRKLL.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/monitor.ts
+init_esm_shims();
+import { readFileSync } from "node:fs";
+var LIST_LIMIT = 20;
+var PEEK_MAX_BYTES = 8 * 1024;
+var RECEIPT_MAX_BYTES = 14 * 1024;
+var WAIT_POLL_MS = 250;
+var WAIT_DEFAULT_TIMEOUT_MS = 6e4;
+var WAIT_MAX_TIMEOUT_MS = 10 * 6e4;
+var COLLECT_TEXT_BYTES = 2e3;
+var COLLECT_TIMEOUT_NOTICE = 'collect never blocks; timeout_ms is ignored \u2014 block on one run with mode="wait".';
+function runLine(run) {
+  const state = run.outcome ?? run.status;
+  const receipt = run.receiptPath ?? "n/a";
+  return `- ${run.id} agent=${run.agentId} state=${state} node=${run.node?.id ?? "local"} started=${run.startedAt} tokens=${run.tokenCount} receipt=${receipt}`;
+}
+function listRuns(deps, options) {
+  let runs;
+  try {
+    runs = deps.dispatch.listRuns();
+  } catch (err) {
+    return { kind: "error", message: `monitor: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  const sessionId = options?.sessionId ?? null;
+  const sessionRuns = sessionId !== null ? runs.filter((run) => run.sessionId === sessionId) : [];
+  const scoped = sessionRuns.length > 0 ? sessionRuns : runs;
+  const scopeNote = sessionRuns.length > 0 ? "this session" : "all sessions";
+  const shown = scoped.slice(0, LIST_LIMIT);
+  if (shown.length === 0) {
+    return { kind: "ok", output: "No dispatched runs recorded.", details: { mode: "list", runCount: 0 } };
+  }
+  const lines = [`dispatched runs (${scopeNote}, newest first, ${shown.length} of ${scoped.length}):`];
+  for (const run of shown) lines.push(runLine(run));
+  lines.push("", 'Use monitor(run_id=<id>) for state, mode="peek" for recent output, mode="receipt" for the receipt.');
+  return {
+    kind: "ok",
+    output: lines.join("\n"),
+    details: {
+      mode: "list",
+      runCount: scoped.length,
+      runs: shown.map((run) => ({ runId: run.id, agentId: run.agentId, state: run.outcome ?? run.status }))
+    }
+  };
+}
+function runStatus(deps, runId) {
+  const requestedRun = deps.dispatch.getRun(runId);
+  const rootRunId = requestedRun?.lineage?.rootRunId ?? runId;
+  const assignment = deps.dispatch.assignments?.getStored(rootRunId) ?? null;
+  const resolvedRunId = assignment?.terminalRunId ?? runId;
+  const run = deps.dispatch.getRun(resolvedRunId) ?? requestedRun;
+  if (!run && !assignment) return { kind: "error", message: `monitor: unknown run or assignment '${runId}'` };
+  if (!run) return { kind: "error", message: `monitor: assignment '${runId}' has no available attempt` };
+  const live = deps.dispatch.snapshot().running.find((entry) => entry.lineage.rootRunId === rootRunId) ?? null;
+  const reroutes = run.reroutes !== void 0 && run.reroutes.length > 0 ? ` reroutes=${run.reroutes.map((hop) => `${hop.fromNode}>${hop.toNode}`).join(",")}` : "";
+  const lines = [
+    ...assignment ? [
+      `assignment ${assignment.assignmentId} status=${assignment.status} terminal=${assignment.terminalRunId ?? "pending"}`,
+      `attempts: ${assignment.attempts.join(", ") || "none finalized"}`
+    ] : [],
+    `run ${run.id} (${run.agentId})`,
+    `state: ${run.status}${run.outcome ? ` outcome=${run.outcome}` : ""}${run.outcomeDetail ? ` detail=${run.outcomeDetail}` : ""}`,
+    `target=${run.targetId} model=${run.wireModelId} runtime=${run.runtimeKind} node=${run.node?.id ?? "local"}${reroutes}`,
+    `started=${run.startedAt} ended=${run.endedAt ?? "n/a"} exit=${run.exitCode ?? "n/a"}`,
+    `tokens=${run.tokenCount} cost=${formatCostAggregate(costAggregateForAmount(run.costUsd, run.costProvenance)) ?? COST_NOT_MEASURED} receipt=${run.receiptPath ?? "n/a"}`
+  ];
+  if (live) {
+    lines.push(
+      `live: phase=${live.outcomePhase} heartbeat=${live.heartbeat} elapsed=${Math.round(live.elapsedMs / 1e3)}s tokens=${live.tokens.total}`
+    );
+  }
+  return {
+    kind: "ok",
+    output: lines.join("\n"),
+    details: {
+      mode: "status",
+      ...assignment ? {
+        assignmentId: assignment.assignmentId,
+        assignmentStatus: assignment.status,
+        attemptRunIds: [...assignment.attempts],
+        terminalRunId: assignment.terminalRunId
+      } : {},
+      runId: run.id,
+      agentId: run.agentId,
+      status: run.status,
+      outcome: run.outcome ?? null,
+      exitCode: run.exitCode,
+      tokenCount: run.tokenCount,
+      costUsd: run.costUsd,
+      costProvenance: run.costProvenance ?? "unknown",
+      receiptPath: run.receiptPath,
+      running: live !== null
+    }
+  };
+}
+function runPeek(deps, runId) {
+  const run = deps.dispatch.getRun(runId);
+  const tail = deps.runEvents?.eventTail(runId) ?? null;
+  if (!tail || tail.entries.length === 0) {
+    if (!run) return { kind: "error", message: `monitor: unknown run '${runId}'` };
+    return {
+      kind: "ok",
+      output: `No buffered events for run ${runId} in this process. Use mode="receipt" for the stored receipt or mode="status" for run state.`,
+      details: { mode: "peek", runId, eventCount: 0 }
+    };
+  }
+  const rendered = tail.entries.map((entry) => `${entry.at} ${entry.type}${entry.detail ? `: ${entry.detail}` : ""}`);
+  let body = rendered.join("\n");
+  let dropped = 0;
+  while (Buffer.byteLength(body, "utf8") > PEEK_MAX_BYTES && dropped < rendered.length - 1) {
+    dropped += 1;
+    body = rendered.slice(dropped).join("\n");
+  }
+  const lines = [
+    `recent events for run ${runId} (${tail.agentId}), newest last${dropped > 0 ? `, ${dropped} older omitted` : ""}:`,
+    body
+  ];
+  return {
+    kind: "ok",
+    output: lines.join("\n"),
+    details: { mode: "peek", runId, eventCount: tail.entries.length, omitted: dropped }
+  };
+}
+var TOOLS_MAX_CALL_LINES = 60;
+var TOOLS_MAX_BYTES = 8 * 1024;
+var TOOLS_ARGUMENTS_CHARS = 160;
+var TOOL_CALL_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "clio_tool_finish",
+  "clio_permission_resolved",
+  "clio_permission_escalated"
+]);
+function toolCallLines(entries) {
+  const lines = [];
+  for (const entry of entries) {
+    const detailed = entry.detail !== void 0 && entry.detail.length > 0;
+    if (!TOOL_CALL_EVENT_TYPES.has(entry.type) && !(entry.type === "tool_execution_end" && detailed)) continue;
+    lines.push(`  ${entry.at} ${entry.type}${detailed ? `: ${entry.detail}` : ""}`);
+  }
+  return lines;
+}
+function receiptToolLines(receipt) {
+  const lines = [];
+  const activity = receipt.toolActivity;
+  if (activity) {
+    lines.push(
+      `  totals: calls=${activity.calls} succeeded=${activity.succeeded} failed=${activity.failed} blocked=${activity.blocked} mutating_succeeded=${activity.mutatingSucceeded}`
+    );
+  } else {
+    lines.push(`  totals: calls=${receipt.toolCalls}`);
+  }
+  for (const stat of receipt.toolStats) {
+    lines.push(
+      `  ${stat.tool}: count=${stat.count} ok=${stat.ok} errors=${stat.errors} blocked=${stat.blocked} total_ms=${stat.totalDurationMs}`
+    );
+  }
+  for (const attempt of receipt.safety?.blockedAttempts ?? []) {
+    const parts = [
+      `  blocked: ${attempt.tool}`,
+      attempt.actionClass !== void 0 ? `class=${attempt.actionClass}` : "",
+      attempt.ruleId !== void 0 ? `rule=${attempt.ruleId}` : "",
+      attempt.reasonCode !== void 0 ? `reason_code=${attempt.reasonCode}` : ""
+    ].filter((part) => part.length > 0);
+    lines.push(parts.join(" "));
+  }
+  for (const entry of receipt.delegation?.toolCallLog ?? []) {
+    let rendered;
+    try {
+      rendered = truncateUtf8(JSON.stringify(entry.arguments), TOOLS_ARGUMENTS_CHARS, "\u2026");
+    } catch {
+      rendered = "(arguments not serializable)";
+    }
+    lines.push(`  ${entry.timestamp} ${entry.tool} ${entry.decision} args=${rendered}`);
+  }
+  return lines;
+}
+function runTools(deps, runId) {
+  const requestedRun = deps.dispatch.getRun(runId);
+  const rootRunId = requestedRun?.lineage?.rootRunId ?? runId;
+  const assignment = deps.dispatch.assignments?.getStored(rootRunId) ?? null;
+  const resolvedRunId = assignment?.terminalRunId ?? runId;
+  const run = deps.dispatch.getRun(resolvedRunId) ?? requestedRun ?? null;
+  if (run === null && assignment === null) return { kind: "error", message: `monitor: unknown run '${runId}'` };
+  const tail = deps.runEvents?.eventTail(resolvedRunId) ?? null;
+  const callLines = tail ? toolCallLines(tail.entries) : [];
+  const evidence = durableRunEvidence(run);
+  const receiptLines = evidence.receipt !== null ? receiptToolLines(evidence.receipt) : [];
+  const lines = [`tool calls for run ${resolvedRunId}${run ? ` (${run.agentId})` : ""}:`];
+  let omitted = 0;
+  if (callLines.length > 0) {
+    const shown = callLines.length > TOOLS_MAX_CALL_LINES ? callLines.slice(-TOOLS_MAX_CALL_LINES) : callLines;
+    omitted = callLines.length - shown.length;
+    lines.push(
+      `executed calls from this process's event buffer (newest last, ${shown.length} of ${callLines.length}${omitted > 0 ? `, ${omitted} older omitted` : ""}):`,
+      ...shown
+    );
+  } else {
+    lines.push(
+      tail === null ? "executed calls: no event buffer for this run in this process (it ran in another process, or its tail was evicted)." : "executed calls: the event buffer holds no tool-call events for this run."
+    );
+  }
+  if (receiptLines.length > 0) {
+    lines.push("receipt totals (integrity verified):", ...receiptLines);
+  } else if (evidence.integrityNote !== null) {
+    lines.push(`receipt totals: unavailable. ${evidence.integrityNote}`);
+  }
+  lines.push(
+    "note: the event buffer records tool name and outcome, not command arguments; absent argv is not evidence that no command ran."
+  );
+  const body = truncateUtf8(lines.join("\n"), TOOLS_MAX_BYTES, "\n[tool list truncated]");
+  return {
+    kind: "ok",
+    output: body,
+    details: {
+      mode: "tools",
+      runId: resolvedRunId,
+      callCount: callLines.length,
+      omitted,
+      bufferAvailable: tail !== null,
+      receiptAvailable: evidence.receipt !== null,
+      ...evidence.receipt !== null ? {
+        toolCalls: evidence.receipt.toolCalls,
+        toolActivity: evidence.receipt.toolActivity ?? null,
+        toolStats: evidence.receipt.toolStats
+      } : {}
+    }
+  };
+}
+function runReceipt(deps, runId) {
+  const run = deps.dispatch.getRun(runId);
+  if (!run) return { kind: "error", message: `monitor: unknown run '${runId}'` };
+  if (!run.receiptPath) {
+    return {
+      kind: "error",
+      message: `monitor: run '${runId}' has no stored receipt (state=${run.outcome ?? run.status}); try mode="status" or mode="peek"`
+    };
+  }
+  let raw;
+  try {
+    raw = readFileSync(run.receiptPath, "utf8");
+  } catch (err) {
+    return {
+      kind: "error",
+      message: `monitor: cannot read receipt ${run.receiptPath}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  const body = truncateUtf8(raw, RECEIPT_MAX_BYTES, `
+[receipt truncated; read ${run.receiptPath} for the rest]`);
+  let receipt = null;
+  let receiptIntegrity;
+  try {
+    receipt = JSON.parse(raw);
+    receiptIntegrity = verifyReceiptIntegrity(receipt, run);
+  } catch (err) {
+    receiptIntegrity = {
+      ok: false,
+      reason: `receipt invalid: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  return {
+    kind: "ok",
+    output: body,
+    details: {
+      mode: "receipt",
+      runId,
+      receiptPath: run.receiptPath,
+      receiptIntegrity,
+      ...receipt !== null && receiptIntegrity.ok ? {
+        evidenceVerification: receipt.verification,
+        briefing: receipt.briefing ?? null,
+        projectContext: receipt.projectContext ?? null
+      } : {}
+    }
+  };
+}
+function unavailableRunEvidence(reason, note, integrityFailure = false) {
+  return {
+    receipt: null,
+    output: null,
+    verification: UNVERIFIABLE_RECEIPT_VERIFICATION,
+    integrity: { ok: false, reason },
+    integrityNote: note,
+    integrityFailure
+  };
+}
+function durableRunEvidence(run) {
+  if (!run) {
+    return unavailableRunEvidence(
+      "run ledger envelope unavailable",
+      "receipt integrity unavailable: the run ledger envelope is missing; worker text cannot be authenticated."
+    );
+  }
+  if (!run.receiptPath) {
+    return unavailableRunEvidence(
+      "receipt unavailable",
+      "receipt integrity unavailable: no stored receipt; worker text is unavailable and validation is unknown."
+    );
+  }
+  let receipt;
+  try {
+    receipt = JSON.parse(readFileSync(run.receiptPath, "utf8"));
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return unavailableRunEvidence(
+      `receipt unreadable: ${detail}`,
+      `receipt integrity unavailable: cannot read or parse ${run.receiptPath} (${detail}); worker text is unavailable and validation is unknown.`
+    );
+  }
+  let integrity;
+  try {
+    integrity = verifyReceiptIntegrity(receipt, run);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return unavailableRunEvidence(
+      `receipt invalid: ${detail}`,
+      `receipt integrity failed: invalid receipt (${detail}); worker text is withheld as untrusted and validation is unknown.`,
+      true
+    );
+  }
+  if (!integrity.ok) {
+    return unavailableRunEvidence(
+      integrity.reason,
+      `receipt integrity failed: ${integrity.reason}; worker text is withheld as untrusted and validation is unknown.`,
+      true
+    );
+  }
+  return {
+    receipt,
+    output: receipt.output ?? null,
+    verification: receipt.verification,
+    integrity,
+    integrityNote: null,
+    integrityFailure: false
+  };
+}
+async function runWait(deps, runId, timeoutMs, signal) {
+  const startedAt = performance.now();
+  let run = deps.dispatch.getRun(runId);
+  if (!run) return { kind: "error", message: `monitor: unknown run '${runId}'` };
+  const rootRunId = run.lineage?.rootRunId ?? runId;
+  let assignment = deps.dispatch.assignments?.getStored(rootRunId) ?? null;
+  while (assignment?.status === "running" || assignment === null && !isTerminalRunEnvelope(run)) {
+    if (signal?.aborted) return { kind: "error", message: "monitor: wait aborted" };
+    const elapsed = Math.round(performance.now() - startedAt);
+    if (elapsed >= timeoutMs) {
+      return {
+        kind: "ok",
+        output: `wait timed out after ${timeoutMs}ms: ${assignment ? "assignment" : "run"} ${runId} is still ${assignment?.status ?? run.status} and keeps running normally. Wait again or collect later. Only steer(action="cancel") if the result is no longer needed \u2014 cancelling discards its work.`,
+        details: {
+          mode: "wait",
+          runId,
+          timedOut: true,
+          state: assignment?.status ?? run.status,
+          waitedMs: elapsed
+        }
+      };
+    }
+    await sleep(Math.min(WAIT_POLL_MS, timeoutMs - elapsed));
+    assignment = deps.dispatch.assignments?.getStored(rootRunId) ?? null;
+    const resolvedRunId = assignment?.terminalRunId ?? runId;
+    run = deps.dispatch.getRun(resolvedRunId) ?? run;
+    if (!run) return { kind: "error", message: `monitor: run '${runId}' disappeared from the ledger while waiting` };
+  }
+  const status = runStatus(deps, runId);
+  if (status.kind !== "ok") return status;
+  const waitedMs = Math.round(performance.now() - startedAt);
+  return {
+    kind: "ok",
+    output: `wait complete after ${waitedMs}ms:
+${status.output}`,
+    details: { ...status.details, mode: "wait", timedOut: false, waitedMs }
+  };
+}
+function failedIntegrityReason(integrity) {
+  return integrity.ok ? "verification result unavailable" : integrity.reason;
+}
+function collectRunLine(row) {
+  const run = row.run;
+  const lines = run ? [
+    `- ${run.id} agent=${run.agentId} state=${run.outcome ?? run.status} node=${run.node?.id ?? "local"} exit=${run.exitCode ?? "n/a"} tokens=${run.tokenCount} cost=${formatCostAggregate(costAggregateForAmount(run.costUsd, run.costProvenance)) ?? COST_NOT_MEASURED} receipt=${run.receiptPath ?? "n/a"}${run.outcomeDetail ? ` detail=${run.outcomeDetail}` : ""}`
+  ] : [`- ${row.runId} agent=${row.agentId} state=missing (ledger row pruned; receipt may still exist)`];
+  if (row.assignmentId !== null) {
+    lines.unshift(
+      `- assignment=${row.assignmentId} status=${row.assignmentStatus ?? "unknown"} terminal=${row.runId}`,
+      `  attempts=${row.attemptRunIds.join(",") || "none"}`
+    );
+  }
+  if (row.evidence.receipt !== null) {
+    lines.push(
+      ...receiptEvidenceLabels(row.evidence.receipt, row.evidence.verification, row.evidence.integrity).map(
+        (label) => `  ${label}`
+      )
+    );
+  } else {
+    const reason = failedIntegrityReason(row.evidence.integrity);
+    lines.push(
+      row.evidence.integrityFailure ? `  RECEIPT INTEGRITY FAILED for ${row.runId} (${reason}); stored receipt fields and worker text are untrusted.` : `  receipt_integrity=unavailable reason=${JSON.stringify(reason)}`
+    );
+  }
+  if (row.evidence.integrityNote) lines.push(`  ${row.evidence.integrityNote}`);
+  lines.push(`  ${workerTextLabel(row.evidence.verification)}`);
+  const output = row.evidence.output;
+  if (output) {
+    const capped = truncateUtf8(output.text, COLLECT_TEXT_BYTES, "...");
+    const qualifier = output.state === "partial" ? " (partial; the run did not complete this message)" : "";
+    const truncatedNote = output.truncated ? ` (stored output truncated; full text was ${output.bytes} bytes)` : "";
+    lines.push(`  agent output${qualifier}${truncatedNote}:`, ...capped.split("\n").map((line) => `  ${line}`));
+    if (row.evidence.receipt) {
+      lines.push(
+        ...workerTextNonEvidenceNotices(row.evidence.receipt, row.evidence.verification, output.text).map(
+          (notice) => `  ${notice}`
+        )
+      );
+    }
+  } else if (row.evidence.integrity.ok) {
+    lines.push("  (no assistant text captured)");
+  }
+  return lines;
+}
+function resolveCollectRow(deps, originalRunId, agentId) {
+  const original = deps.dispatch.getRun(originalRunId);
+  const rootRunId = original?.lineage?.rootRunId ?? originalRunId;
+  const assignment = deps.dispatch.assignments?.getStored(rootRunId) ?? null;
+  const runId = assignment?.terminalRunId ?? originalRunId;
+  const run = deps.dispatch.getRun(runId) ?? original;
+  return {
+    runId,
+    assignmentId: assignment?.assignmentId ?? null,
+    attemptRunIds: assignment?.attempts ?? [originalRunId],
+    assignmentStatus: assignment?.status ?? null,
+    agentId: run?.agentId ?? agentId,
+    run
+  };
+}
+async function runCollect(deps, batchId, runIds, timeoutWasPassed) {
+  let rows;
+  let scope;
+  let ledgerId = null;
+  if (batchId.length > 0) {
+    const detached = deps.dispatch.detached;
+    if (!detached) return { kind: "error", message: "monitor: no detached batch records are available in this context" };
+    const record = detached.get(batchId);
+    if (!record) return { kind: "error", message: `monitor: unknown batch '${batchId}'` };
+    ledgerId = record.ledgerId ?? null;
+    rows = record.runs.map((entry) => resolveCollectRow(deps, entry.assignmentId, entry.agentId));
+    scope = `batch ${batchId}${record.collectedAt !== null ? " (already collected)" : ""}`;
+  } else {
+    rows = runIds.map((runId) => resolveCollectRow(deps, runId, "unknown"));
+    scope = `${rows.length} run(s)`;
+  }
+  const pending = rows.filter((row) => {
+    if (row.assignmentStatus === null) return row.run !== null && !isTerminalRunEnvelope(row.run);
+    return row.assignmentStatus === "running";
+  });
+  if (pending.length > 0) {
+    const lines2 = [
+      `collect pending: ${pending.length} of ${rows.length} run(s) still in flight for ${scope}`,
+      ...rows.map((row) => {
+        const state = row.run === null ? "missing" : row.run.outcome ?? row.run.status;
+        return `- ${row.assignmentId ?? row.runId} agent=${row.agentId} state=${row.assignmentStatus ?? state}`;
+      }),
+      "",
+      'Collect again later, or block on a single run with mode="wait".',
+      ...timeoutWasPassed ? ["", COLLECT_TIMEOUT_NOTICE] : []
+    ];
+    return {
+      kind: "ok",
+      output: lines2.join("\n"),
+      details: {
+        mode: "collect",
+        ...batchId.length > 0 ? { batchId } : {},
+        complete: false,
+        pendingCount: pending.length,
+        runCount: rows.length,
+        pendingRunIds: pending.map((row) => row.assignmentId ?? row.runId)
+      }
+    };
+  }
+  const failed = rows.filter(
+    (row) => row.run === null || row.run.exitCode !== 0 || row.run.outcome !== void 0 && row.run.outcome !== "succeeded" && row.run.outcome !== null
+  );
+  const missing = rows.filter((row) => row.run === null);
+  const board = ledgerId === null ? null : renderAgentLedgerBoard(ledgerId);
+  let collected = false;
+  if (batchId.length > 0) {
+    try {
+      const marked = await deps.dispatch.detached?.markCollected(batchId);
+      collected = marked !== null && marked !== void 0;
+    } catch {
+      collected = false;
+    }
+  }
+  const collectedRows = rows.map((row) => ({ ...row, evidence: durableRunEvidence(row.run) }));
+  const lines = [
+    `collect complete for ${scope}: total=${rows.length} failed=${failed.length}${missing.length > 0 ? ` missing=${missing.length}` : ""}`,
+    ...collectedRows.flatMap((row) => collectRunLine(row)),
+    ...board !== null ? ["", board] : [],
+    ...batchId.length > 0 && !collected ? ["", "note: the batch record could not be marked collected; it stays open for a later collect."] : [],
+    ...timeoutWasPassed ? ["", COLLECT_TIMEOUT_NOTICE] : []
+  ];
+  return {
+    kind: "ok",
+    output: lines.join("\n"),
+    details: {
+      mode: "collect",
+      ...batchId.length > 0 ? { batchId, collected } : {},
+      ...board !== null ? { agentLedgerBoard: board } : {},
+      complete: true,
+      runCount: rows.length,
+      failedCount: failed.length,
+      runs: collectedRows.map((row) => {
+        const output = row.evidence.output;
+        return {
+          runId: row.runId,
+          ...row.assignmentId !== null ? {
+            assignmentId: row.assignmentId,
+            assignmentStatus: row.assignmentStatus,
+            attemptRunIds: [...row.attemptRunIds],
+            terminalRunId: row.runId
+          } : {},
+          agentId: row.agentId,
+          state: row.run === null ? "missing" : row.run.outcome ?? row.run.status,
+          exitCode: row.run?.exitCode ?? null,
+          receiptPath: row.run?.receiptPath ?? null,
+          receiptIntegrity: row.evidence.integrity,
+          evidenceVerification: row.evidence.verification,
+          briefing: row.evidence.receipt?.briefing ?? null,
+          projectContext: row.evidence.receipt?.projectContext ?? null,
+          ...output ? { output: { state: output.state, bytes: output.bytes, truncated: output.truncated } } : {}
+        };
+      })
+    }
+  };
+}
+function createMonitorTool(deps) {
+  return {
+    ...monitorToolSurface,
+    async run(args, options) {
+      const explicitRunId = typeof args.run_id === "string" ? args.run_id.trim() : "";
+      const rawRunIds = Array.isArray(args.run_ids) ? args.run_ids : null;
+      const singletonRunId = rawRunIds?.length === 1 && typeof rawRunIds[0] === "string" ? rawRunIds[0].trim() : "";
+      const runId = explicitRunId.length > 0 ? explicitRunId : singletonRunId;
+      const mode = typeof args.mode === "string" ? args.mode : runId.length > 0 ? "status" : "list";
+      if (mode !== "status" && mode !== "peek" && mode !== "receipt" && mode !== "list" && mode !== "wait" && mode !== "collect" && mode !== "tools") {
+        return {
+          kind: "error",
+          message: `monitor: mode must be status, peek, receipt, list, wait, collect, or tools; got '${mode}'`
+        };
+      }
+      if (mode === "list") return listRuns(deps, options);
+      if (mode === "collect") {
+        const batchId = typeof args.batch_id === "string" ? args.batch_id.trim() : "";
+        const runIds = rawRunIds ? rawRunIds.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+        if (batchId.length === 0 && runIds.length === 0) {
+          return { kind: "error", message: "monitor: mode=collect requires batch_id or a non-empty run_ids array" };
+        }
+        return runCollect(deps, batchId, runIds, Object.hasOwn(args, "timeout_ms"));
+      }
+      if (runId.length === 0) {
+        if (rawRunIds !== null) {
+          const entryLabel = rawRunIds.length === 1 ? "entry" : "entries";
+          return {
+            kind: "error",
+            message: `monitor: mode=${mode} observes one run; got run_ids with ${rawRunIds.length} ${entryLabel} \u2014 pass run_id=<one id>, or use mode=collect run_ids=[...] for a batch`
+          };
+        }
+        return {
+          kind: "error",
+          message: `monitor: mode=${mode} observes one run and needs run_id; call monitor(mode="list") first to see the run ids this session knows about`
+        };
+      }
+      if (mode === "wait") {
+        const rawTimeout = typeof args.timeout_ms === "number" && Number.isFinite(args.timeout_ms) ? args.timeout_ms : NaN;
+        const timeoutMs = Number.isFinite(rawTimeout) && rawTimeout > 0 ? Math.min(Math.floor(rawTimeout), WAIT_MAX_TIMEOUT_MS) : WAIT_DEFAULT_TIMEOUT_MS;
+        return runWait(deps, runId, timeoutMs, options?.signal);
+      }
+      if (mode === "status") return runStatus(deps, runId);
+      if (mode === "peek") return runPeek(deps, runId);
+      if (mode === "tools") return runTools(deps, runId);
+      return runReceipt(deps, runId);
+    }
+  };
+}
+export {
+  createMonitorTool
+};
+//# sourceMappingURL=monitor-MEQA5C3I.js.map