@h-rig/run-worker 0.0.6-alpha.155 → 0.0.6-alpha.156

package/dist/src/runs/control.d.ts

@@ -0,0 +1,24 @@
+import type { CollabFrame } from "@oh-my-pi/pi-coding-agent/collab/protocol";
+import { type RunRecord } from "./projection";
+export type RunControl = {
+    readonly kind: "steer";
+    readonly message: string;
+} | {
+    readonly kind: "stop";
+    readonly reason: string;
+} | {
+    readonly kind: "pause";
+} | {
+    readonly kind: "resume";
+};
+export interface DeliverRemoteControlDeps {
+    readonly WebSocket?: typeof WebSocket;
+}
+export type RemoteControlTarget = Pick<RunRecord, "runId" | "joinLink">;
+export declare function collabControlFrames(runId: string, control: RunControl): readonly CollabFrame[];
+export declare function collabControlFrame(runId: string, control: RunControl): CollabFrame;
+export declare function deliverRemoteRunControl(projectRoot: string, target: RemoteControlTarget | string, control: RunControl, deps?: DeliverRemoteControlDeps): Promise<void>;
+export declare function deliverRunControl(projectRoot: string, target: RunRecord | string, control: RunControl, deps?: DeliverRemoteControlDeps & {
+    readonly getRun?: (projectRoot: string, runId: string) => Promise<RunRecord | null>;
+    readonly deliverRemote?: (projectRoot: string, target: RunRecord, control: RunControl) => Promise<void>;
+}): Promise<void>;

package/dist/src/runs/control.js

@@ -0,0 +1,398 @@
+// @bun
+var __require = import.meta.require;
+
+// packages/run-worker/src/runs/control.ts
+import { buildPauseSentinel, buildResumeSentinel, buildStopSentinel } from "@rig/contracts";
+
+// packages/run-worker/src/runs/projection.ts
+import { isAbsolute, relative, resolve } from "path";
+import { Duration, Effect, Option, Stream } from "effect";
+import {
+  foldRunSessionEntries,
+  isTerminalRunStatus,
+  timelineEntriesFromCustomEntries
+} from "@rig/contracts";
+import { registrySnapshotStream } from "@rig/runtime/control-plane/discovery";
+
+// packages/run-worker/src/runs/diagnostics.ts
+function normalizeString(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function isGenericRunFailure(value) {
+  const text = normalizeString(value);
+  return Boolean(text && /^Task run failed \([^)]*\)$/i.test(text));
+}
+function appendCandidate(candidates, value) {
+  const text = normalizeString(value);
+  if (text && !candidates.includes(text))
+    candidates.push(text);
+}
+function categorizeUsefulRunError(lines) {
+  const taskSourceFailure = lines.find((line) => /failed to update task source/i.test(line));
+  if (taskSourceFailure)
+    return `Task source update failed: ${taskSourceFailure}`;
+  const moduleFailure = lines.find((line) => /cannot find module/i.test(line));
+  if (moduleFailure)
+    return `Runtime module resolution failed: ${moduleFailure}`;
+  const providerFailure = lines.find((line) => /no api key found|unauthorized|authentication failed|invalid api key/i.test(line));
+  if (providerFailure)
+    return `Provider authentication failed: ${providerFailure}`;
+  return null;
+}
+function summarizeRunError(projection) {
+  if (projection.status !== "failed")
+    return null;
+  const candidates = [];
+  for (const anomaly of projection.anomalies) {
+    appendCandidate(candidates, `Journal anomaly (${anomaly.kind}): ${anomaly.detail}`);
+  }
+  for (const phase of projection.closeoutPhases) {
+    if (phase.outcome === "failed")
+      appendCandidate(candidates, phase.detail);
+  }
+  for (const entry of projection.statusHistory) {
+    appendCandidate(candidates, entry.reason);
+  }
+  appendCandidate(candidates, projection.record.statusDetail);
+  appendCandidate(candidates, projection.record.errorText);
+  const nonGeneric = candidates.filter((candidate) => !isGenericRunFailure(candidate));
+  return categorizeUsefulRunError(nonGeneric) ?? nonGeneric.at(-1) ?? normalizeString(projection.record.errorText);
+}
+
+// packages/run-worker/src/runs/projection.ts
+var EMPTY_PROJECTION = foldRunSessionEntries([], "");
+var DISCOVERY_DIAGNOSTIC_RUN_ID = "__registry_discovery_error__";
+function stringOrNull(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function numberOrNull(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function objectRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function registryStatusAsRunStatus(status) {
+  if (status === "waiting-input")
+    return "waiting-user-input";
+  if (status === "starting")
+    return "preparing";
+  return typeof status === "string" && [
+    "created",
+    "queued",
+    "preparing",
+    "running",
+    "waiting-approval",
+    "waiting-user-input",
+    "paused",
+    "validating",
+    "reviewing",
+    "closing-out",
+    "needs-attention",
+    "completed",
+    "failed",
+    "stopped"
+  ].includes(status) ? status : null;
+}
+function payloadString(payload, keys) {
+  if (!payload || typeof payload !== "object")
+    return null;
+  const record = payload;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return null;
+}
+function payloadOptions(payload) {
+  if (!payload || typeof payload !== "object")
+    return;
+  const record = payload;
+  const options = Array.isArray(record.options) ? record.options : Array.isArray(record.choices) ? record.choices : null;
+  const values = options?.filter((value) => typeof value === "string" && value.trim().length > 0) ?? [];
+  return values.length > 0 ? values : undefined;
+}
+function inboxRequest(request, kind) {
+  const fallback = kind === "approval" ? "Approval requested" : "Input requested";
+  return {
+    requestId: request.requestId,
+    kind,
+    title: payloadString(request.payload, ["title", "message", "reason", "prompt", "summary"]) ?? fallback,
+    body: payloadString(request.payload, ["body", "description", "detail", "details"]),
+    ...payloadOptions(request.payload) ? { options: payloadOptions(request.payload) } : {},
+    requestedAt: request.requestedAt ?? null,
+    source: "run"
+  };
+}
+function inboxFromProjection(projection) {
+  return [
+    ...projection.pendingApprovals.map((request) => inboxRequest(request, "approval")),
+    ...projection.pendingUserInputs.map((request) => inboxRequest(request, "input"))
+  ].sort((a, b) => (Date.parse(a.requestedAt ?? "") || 0) - (Date.parse(b.requestedAt ?? "") || 0));
+}
+function isProjectPath(projectRoot, cwd) {
+  const root = resolve(projectRoot);
+  const candidate = resolve(cwd);
+  const pathFromRoot = relative(root, candidate);
+  return pathFromRoot === "" || !pathFromRoot.startsWith("../") && pathFromRoot !== ".." && !isAbsolute(pathFromRoot);
+}
+function sourceFromEntry(projectRoot, projection, entry) {
+  const candidates = [
+    stringOrNull(projection.collabCwd),
+    stringOrNull(projection.cwd),
+    stringOrNull(entry.cwd),
+    stringOrNull(projection.worktreePath)
+  ].filter((cwd) => cwd !== null);
+  return candidates.some((cwd) => isProjectPath(projectRoot, cwd)) ? "local" : "remote";
+}
+function pendingRequests(value, fallbackKind) {
+  if (!Array.isArray(value))
+    return [];
+  return value.flatMap((item) => {
+    const record = objectRecord(item);
+    const requestId = stringOrNull(record?.requestId) ?? stringOrNull(record?.id);
+    if (!record || !requestId)
+      return [];
+    return [{
+      requestId,
+      requestKind: stringOrNull(record.requestKind) ?? stringOrNull(record.kind) ?? fallbackKind,
+      actionId: stringOrNull(record.actionId),
+      payload: "payload" in record ? record.payload : record,
+      requestedAt: stringOrNull(record.requestedAt) ?? stringOrNull(record.at) ?? ""
+    }];
+  });
+}
+function emptyFoldedProjection(runId, projection) {
+  const projectionRecord = projection;
+  const nestedProjection = objectRecord(projectionRecord.projection);
+  const pendingApprovals = pendingRequests(nestedProjection?.pendingApprovals ?? projectionRecord.pendingApprovals, "approval");
+  const pendingUserInputs = pendingRequests(nestedProjection?.pendingUserInputs ?? nestedProjection?.pendingInputs ?? projectionRecord.pendingUserInputs ?? (Array.isArray(projectionRecord.pendingInputs) ? projectionRecord.pendingInputs : undefined), "user-input");
+  const nestedRecord = objectRecord(nestedProjection?.record);
+  const nestedFolded = nestedProjection;
+  return {
+    ...EMPTY_PROJECTION,
+    ...nestedFolded ?? {},
+    record: {
+      ...nestedRecord ?? {},
+      runId,
+      ...projection.taskId ? { taskId: projection.taskId } : {},
+      ...projection.title ? { title: projection.title } : {},
+      ...projection.startedAt ? { startedAt: projection.startedAt } : {},
+      ...projection.updatedAt ? { updatedAt: projection.updatedAt } : {},
+      ...projection.completedAt ? { completedAt: projection.completedAt } : {},
+      ...projection.sessionPath ? { sessionPath: projection.sessionPath } : {},
+      ...projection.worktreePath ? { worktreePath: projection.worktreePath } : {},
+      ...projection.prUrl ? { prUrl: projection.prUrl } : {}
+    },
+    status: registryStatusAsRunStatus(projection.status) ?? registryStatusAsRunStatus(nestedProjection?.status),
+    pendingApprovals,
+    pendingUserInputs,
+    steeringCount: projection.steeringCount ?? numberOrNull(nestedProjection?.steeringCount) ?? 0,
+    stallCount: projection.stallCount ?? numberOrNull(nestedProjection?.stallCount) ?? 0,
+    lastEventAt: projection.updatedAt ?? stringOrNull(nestedProjection?.lastEventAt)
+  };
+}
+function runRecordFromRegistryEntry(projectRoot, entry) {
+  const projection = entry.projection && typeof entry.projection === "object" ? entry.projection : {};
+  const runId = stringOrNull(projection.runId) ?? entry.roomId;
+  const folded = emptyFoldedProjection(runId, projection);
+  const pushedStatus = registryStatusAsRunStatus(projection.status) ?? folded.status ?? registryStatusAsRunStatus(entry.status);
+  const status = entry.stale ? pushedStatus && isTerminalRunStatus(pushedStatus) ? pushedStatus : "stale" : pushedStatus ?? "running";
+  const sessionPath = stringOrNull(projection.sessionPath) ?? stringOrNull(entry.sessionPath) ?? null;
+  const collabCwd = stringOrNull(projection.collabCwd) ?? stringOrNull(projection.cwd) ?? stringOrNull(entry.cwd) ?? stringOrNull(projection.worktreePath);
+  return {
+    runId,
+    taskId: stringOrNull(projection.taskId),
+    title: stringOrNull(projection.title) ?? entry.title,
+    status,
+    source: sourceFromEntry(projectRoot, projection, entry),
+    live: !entry.stale,
+    stale: entry.stale,
+    startedAt: stringOrNull(projection.startedAt) ?? entry.startedAt ?? null,
+    updatedAt: stringOrNull(projection.updatedAt) ?? entry.heartbeatAt ?? null,
+    completedAt: stringOrNull(projection.completedAt),
+    joinLink: stringOrNull(projection.joinLink) ?? entry.joinLink ?? null,
+    webLink: stringOrNull(projection.webLink) ?? entry.webLink ?? null,
+    relayUrl: stringOrNull(projection.relayUrl) ?? entry.relayUrl ?? null,
+    sessionPath,
+    prUrl: stringOrNull(projection.prUrl),
+    worktreePath: stringOrNull(projection.worktreePath) ?? collabCwd,
+    pendingApprovals: numberOrNull(projection.pendingApprovals) ?? folded.pendingApprovals.length,
+    pendingInputs: numberOrNull(projection.pendingInputs) ?? folded.pendingUserInputs.length,
+    steeringCount: projection.steeringCount ?? 0,
+    stallCount: projection.stallCount ?? 0,
+    errorSummary: stringOrNull(projection.errorSummary) ?? summarizeRunError(folded),
+    timeline: Array.isArray(projection.timeline) ? [...projection.timeline] : [...timelineEntriesFromCustomEntries([])],
+    inbox: inboxFromProjection(folded),
+    collabCwd: collabCwd ?? null,
+    projection: folded
+  };
+}
+function runRecordsFromRegistrySnapshot(projectRoot, snapshot) {
+  return sortByRecency(snapshot.entries.map((entry) => runRecordFromRegistryEntry(projectRoot, entry)).filter((record) => record !== null));
+}
+function sortByRecency(records) {
+  return [...records].sort((a, b) => {
+    const at = Date.parse(b.updatedAt ?? b.startedAt ?? "") || 0;
+    const bt = Date.parse(a.updatedAt ?? a.startedAt ?? "") || 0;
+    return at - bt;
+  });
+}
+function discoveryDiagnosticRunRecord(projectRoot, error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  const runId = DISCOVERY_DIAGNOSTIC_RUN_ID;
+  const projection = {
+    ...EMPTY_PROJECTION,
+    record: { runId, title: "Registry discovery unavailable" },
+    status: "needs-attention",
+    stallCount: 1
+  };
+  return {
+    runId,
+    taskId: null,
+    title: "Registry discovery unavailable",
+    status: "needs-attention",
+    source: "remote",
+    live: false,
+    stale: true,
+    startedAt: null,
+    updatedAt: null,
+    completedAt: null,
+    joinLink: null,
+    webLink: null,
+    relayUrl: null,
+    sessionPath: null,
+    prUrl: null,
+    worktreePath: null,
+    pendingApprovals: 0,
+    pendingInputs: 0,
+    steeringCount: 0,
+    stallCount: 1,
+    errorSummary: `registry discovery unavailable: ${detail}`,
+    timeline: [],
+    inbox: [],
+    collabCwd: null,
+    projection
+  };
+}
+async function listRunProjections(projectRoot, filter = {}) {
+  try {
+    const snapshot = await Effect.runPromise(registrySnapshotStream(projectRoot, filter).pipe(Stream.runHead, Effect.timeout(Duration.seconds(15)), Effect.map(Option.getOrNull)));
+    return snapshot ? runRecordsFromRegistrySnapshot(projectRoot, snapshot) : [discoveryDiagnosticRunRecord(projectRoot, "registry discovery stream ended without a snapshot")];
+  } catch (error) {
+    return [discoveryDiagnosticRunRecord(projectRoot, error)];
+  }
+}
+function selectRunProjection(runs, runId) {
+  const exactRun = runs.find((run) => run.runId === runId);
+  if (exactRun)
+    return exactRun;
+  const exactTask = runs.find((run) => run.taskId === runId);
+  if (exactTask)
+    return exactTask;
+  const prefixMatches = runs.filter((run) => run.runId.startsWith(runId));
+  if (prefixMatches.length === 1)
+    return prefixMatches[0] ?? null;
+  if (prefixMatches.length > 1) {
+    const matches = prefixMatches.map((run) => run.runId).join(", ");
+    throw new Error(`Ambiguous run id prefix "${runId}" matched ${prefixMatches.length} runs: ${matches}`);
+  }
+  return runs.find((run) => run.runId === DISCOVERY_DIAGNOSTIC_RUN_ID) ?? null;
+}
+async function getRunProjection(projectRoot, runId, filter = {}) {
+  const runs = await listRunProjections(projectRoot, filter);
+  return selectRunProjection(runs, runId);
+}
+var getRun = getRunProjection;
+
+// packages/run-worker/src/runs/control.ts
+async function loadCollabControlDeps() {
+  const [{ importRoomKey, seal }, { COLLAB_PROTO, packEnvelope, parseCollabLink }] = await Promise.all([
+    import("@oh-my-pi/pi-coding-agent/collab/crypto"),
+    import("@oh-my-pi/pi-coding-agent/collab/protocol")
+  ]);
+  return { importRoomKey, seal, COLLAB_PROTO, packEnvelope, parseCollabLink };
+}
+function collabControlFrames(runId, control) {
+  switch (control.kind) {
+    case "steer":
+      return [{ t: "prompt", text: control.message }];
+    case "resume":
+      return [{ t: "prompt", text: `${buildResumeSentinel(runId)}
+Continue the run from where it paused.` }];
+    case "pause":
+      return [
+        { t: "prompt", text: `${buildPauseSentinel(runId)}
+Pause this run after the current interruption settles.` },
+        { t: "abort" }
+      ];
+    case "stop":
+      return [
+        { t: "prompt", text: `${buildStopSentinel(runId, control.reason)}
+Stop this run and do not continue after the interruption settles.` },
+        { t: "abort" }
+      ];
+  }
+}
+function collabControlFrame(runId, control) {
+  return collabControlFrames(runId, control)[0];
+}
+async function sendSealedCollabFrames(joinLink, frames, deps = {}) {
+  const { importRoomKey, seal, COLLAB_PROTO, packEnvelope, parseCollabLink } = await loadCollabControlDeps();
+  const parsed = parseCollabLink(joinLink);
+  if ("error" in parsed)
+    throw new Error(parsed.error);
+  if (!parsed.writeToken)
+    throw new Error("Run collab link is read-only; cannot send control.");
+  const key = await importRoomKey(parsed.key);
+  const WebSocketCtor = deps.WebSocket ?? WebSocket;
+  const ws = new WebSocketCtor(`${parsed.wsUrl}?role=guest`);
+  await new Promise((resolveOpen, rejectOpen) => {
+    ws.addEventListener("open", () => resolveOpen(), { once: true });
+    ws.addEventListener("error", () => rejectOpen(new Error("collab websocket error")), { once: true });
+  });
+  const hello = {
+    t: "hello",
+    proto: COLLAB_PROTO,
+    name: "rig-operator",
+    writeToken: Buffer.from(parsed.writeToken).toString("base64url")
+  };
+  ws.send(packEnvelope(0, await seal(key, hello)));
+  for (const frame of frames)
+    ws.send(packEnvelope(0, await seal(key, frame)));
+  try {
+    ws.close();
+  } catch {}
+}
+async function deliverRemoteRunControl(projectRoot, target, control, deps = {}) {
+  const record = typeof target === "string" ? await getRun(projectRoot, target) : target;
+  const runId = typeof target === "string" ? target : target.runId;
+  if (!record)
+    throw new Error(`Run not found: ${runId}`);
+  if (!record.joinLink)
+    throw new Error(`Run ${record.runId} has no writable collab join link.`);
+  await sendSealedCollabFrames(record.joinLink, collabControlFrames(record.runId, control), deps);
+}
+async function deliverRunControl(projectRoot, target, control, deps = {}) {
+  const record = typeof target === "string" ? await (deps.getRun ?? getRun)(projectRoot, target) : target;
+  const runId = typeof target === "string" ? target : target.runId;
+  if (!record)
+    throw new Error(`Run not found: ${runId}`);
+  if (!record.joinLink)
+    throw new Error(`Run ${record.runId} has no writable collab join link; attach interactively to ${control.kind}.`);
+  try {
+    await (deps.deliverRemote ?? deliverRemoteRunControl)(projectRoot, record, control);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : `Attach to ${control.kind} interactively: rig run attach ${record.runId}`;
+    throw new Error(`Could not ${control.kind} run ${record.runId}. ${detail}`);
+  }
+}
+export {
+  deliverRunControl,
+  deliverRemoteRunControl,
+  collabControlFrames,
+  collabControlFrame
+};

package/dist/src/runs/diagnostics.d.ts

@@ -0,0 +1,10 @@
+import type { RunJournalProjection } from "@rig/contracts";
+/**
+ * Extract the most useful human-facing failure diagnostic from the folded run journal.
+ *
+ * The live projection deliberately does not retain log/timeline lines, so this mirrors the
+ * deleted server-side categorization using only fields that survive folding: record fields,
+ * status reasons, closeout details, and reducer anomalies.
+ */
+export declare function summarizeRunError(projection: RunJournalProjection): string | null;
+export declare const summarizeUsefulRunError: typeof summarizeRunError;

package/dist/src/runs/diagnostics.js

@@ -0,0 +1,53 @@
+// @bun
+// packages/run-worker/src/runs/diagnostics.ts
+function normalizeString(value) {
+  if (typeof value !== "string")
+    return null;
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : null;
+}
+function isGenericRunFailure(value) {
+  const text = normalizeString(value);
+  return Boolean(text && /^Task run failed \([^)]*\)$/i.test(text));
+}
+function appendCandidate(candidates, value) {
+  const text = normalizeString(value);
+  if (text && !candidates.includes(text))
+    candidates.push(text);
+}
+function categorizeUsefulRunError(lines) {
+  const taskSourceFailure = lines.find((line) => /failed to update task source/i.test(line));
+  if (taskSourceFailure)
+    return `Task source update failed: ${taskSourceFailure}`;
+  const moduleFailure = lines.find((line) => /cannot find module/i.test(line));
+  if (moduleFailure)
+    return `Runtime module resolution failed: ${moduleFailure}`;
+  const providerFailure = lines.find((line) => /no api key found|unauthorized|authentication failed|invalid api key/i.test(line));
+  if (providerFailure)
+    return `Provider authentication failed: ${providerFailure}`;
+  return null;
+}
+function summarizeRunError(projection) {
+  if (projection.status !== "failed")
+    return null;
+  const candidates = [];
+  for (const anomaly of projection.anomalies) {
+    appendCandidate(candidates, `Journal anomaly (${anomaly.kind}): ${anomaly.detail}`);
+  }
+  for (const phase of projection.closeoutPhases) {
+    if (phase.outcome === "failed")
+      appendCandidate(candidates, phase.detail);
+  }
+  for (const entry of projection.statusHistory) {
+    appendCandidate(candidates, entry.reason);
+  }
+  appendCandidate(candidates, projection.record.statusDetail);
+  appendCandidate(candidates, projection.record.errorText);
+  const nonGeneric = candidates.filter((candidate) => !isGenericRunFailure(candidate));
+  return categorizeUsefulRunError(nonGeneric) ?? nonGeneric.at(-1) ?? normalizeString(projection.record.errorText);
+}
+var summarizeUsefulRunError = summarizeRunError;
+export {
+  summarizeUsefulRunError,
+  summarizeRunError
+};

package/dist/src/runs/guard.d.ts

@@ -0,0 +1,4 @@
+import type { RunRecord } from "./projection";
+export declare function runBlocksNewRunForTask(run: RunRecord): boolean;
+export declare function activeRunByTaskId(listRuns: (projectRoot: string) => Promise<RunRecord[]>, projectRoot: string): Promise<Map<string, string>>;
+export declare function assertNoActiveRunForTask(listRuns: (projectRoot: string) => Promise<RunRecord[]>, projectRoot: string, taskId: string): Promise<void>;

package/dist/src/runs/guard.js

@@ -0,0 +1,26 @@
+// @bun
+// packages/run-worker/src/runs/guard.ts
+import { TERMINAL_RUN_STATUSES } from "@rig/contracts";
+var TERMINAL = new Set(TERMINAL_RUN_STATUSES);
+function runBlocksNewRunForTask(run) {
+  return run.live && !run.stale && !TERMINAL.has(run.status) && run.status !== "needs-attention" && run.status !== "needs_attention";
+}
+async function activeRunByTaskId(listRuns, projectRoot) {
+  const active = new Map;
+  for (const run of await listRuns(projectRoot)) {
+    if (run.taskId && runBlocksNewRunForTask(run) && !active.has(run.taskId))
+      active.set(run.taskId, run.runId);
+  }
+  return active;
+}
+async function assertNoActiveRunForTask(listRuns, projectRoot, taskId) {
+  const existing = (await activeRunByTaskId(listRuns, projectRoot)).get(taskId);
+  if (existing) {
+    throw new Error(`Task ${taskId} already has an active run: ${existing}. Attach instead: rig run attach ${existing} \u2014 or re-dispatch anyway with --force.`);
+  }
+}
+export {
+  runBlocksNewRunForTask,
+  assertNoActiveRunForTask,
+  activeRunByTaskId
+};

package/dist/src/runs/inbox.d.ts

@@ -0,0 +1,44 @@
+import { deliverRunControl } from "./control";
+import { type RunRecord, type UnifiedInboxRequest } from "./projection";
+export type InboxKind = "approvals" | "inputs";
+export interface InboxFilters {
+    readonly run?: string;
+    readonly task?: string;
+}
+export interface InboxRecord {
+    readonly runId: string;
+    readonly taskId: string | null;
+    readonly requestId: string;
+    readonly status: "pending";
+    readonly prompt: string;
+    readonly requestedAt: string;
+    readonly payload: unknown;
+    readonly kind: "approval" | "input";
+}
+export type InboxDecision = {
+    readonly kind: "approval";
+    readonly decision: "approved" | "rejected" | "approve" | "reject";
+    readonly note?: string | null;
+} | {
+    readonly kind: "input";
+    readonly answer: string | Record<string, string>;
+};
+export declare function recordsFromRun(run: RunRecord, kind: InboxKind): InboxRecord[];
+export interface InboxDeps {
+    readonly listRuns?: (projectRoot: string) => Promise<readonly RunRecord[]>;
+}
+export interface ResolveInboxDeps {
+    readonly deliverRunControl?: typeof deliverRunControl;
+}
+export declare function listInboxRecords(context: {
+    readonly projectRoot: string;
+} | string, kind: InboxKind, filters?: InboxFilters, deps?: InboxDeps): Promise<InboxRecord[]>;
+export declare function listInbox(projectRoot: string, filters?: InboxFilters, deps?: InboxDeps): Promise<UnifiedInboxRequest[]>;
+export declare function readPendingInboxCounts(context: {
+    readonly projectRoot: string;
+} | string, deps?: InboxDeps): Promise<{
+    approvals: number;
+    inputs: number;
+} | null>;
+export declare const readInboxCounts: typeof readPendingInboxCounts;
+export declare function resolveInboxRequest(projectRoot: string, runId: string, requestId: string, decision: InboxDecision, deps?: ResolveInboxDeps): Promise<void>;