baa-conductor

commit

309eab2

parent

5cdeb5d

author

codex@macbookpro

date

2026-03-27 19:26:18 +0800 CST

feat: add baa execution persistence and delivery bridge

 1@@ -2,12 +2,12 @@
 2 
 3 ## 结论摘要
 4 
 5-- 当前“已提交功能代码基线”仍可按 `main@25be868` 理解，主题是 `restore managed firefox shell tabs on startup`；在当前本地代码里又额外补上了 `BUG-011`、`BUG-012`、`BUG-013`、`BUG-014`、`BUG-017` 修复，以及 `T-S029`、`T-S030`、`T-S031`、`T-S032` 的功能落地。
 6-- 当前浏览器桥接主线已经完成到“Firefox 本地 WS bridge + Claude / ChatGPT 代发 + ChatGPT / Gemini 最终消息 raw relay + live instruction ingest + 结构化 action_result + shell_runtime + 登录态持久化”的阶段。
 7+- 当前“已提交功能代码基线”仍可按 `main@25be868` 理解，主题是 `restore managed firefox shell tabs on startup`；在当前本地代码里又额外补上了 `BUG-011`、`BUG-012`、`BUG-013`、`BUG-014`、`BUG-017` 修复，以及 `T-S029`、`T-S030`、`T-S031`、`T-S032`、`T-S033`、`T-S034` 的功能落地。
 8+- 当前浏览器桥接主线已经完成到“Firefox 本地 WS bridge + Claude / ChatGPT 代发 + ChatGPT / Gemini 最终消息 raw relay + live instruction ingest + dedupe/journal 本地持久化 + artifact/upload/inject/send 主链 + 结构化 action_result + shell_runtime + 登录态持久化”的阶段。
 9 - 代码和自动化测试都表明：`/describe/business`、`/describe/control`、`GET /v1/browser`、`POST /v1/browser/actions`、`POST /v1/browser/request`、`POST /v1/browser/request/cancel` 已经形成正式主链路。
10 - 目前不应再把系统描述成“只有 Claude / ChatGPT request relay”；当前更准确的表述是“通用 browser surface 已落地，正式 request relay 已覆盖 Claude 和 ChatGPT，ChatGPT / Gemini 的 `browser.final_message` raw relay 也已接通，但这层仍只是最终消息中继，不等于 Gemini 正式 request relay 已转正”。
11-- 当前仍不能写成“全部收尾完成”。剩余未闭项主要是：真实 Firefox 手工 smoke 未完成、风控状态仍是进程内内存态、ChatGPT 仍依赖真实浏览器登录态 / header 且没有 Claude 风格 prompt shortcut、ChatGPT / Gemini 最终消息提取仍有平台特定边界，以及 live message dedupe / instruction dedupe 仍未持久化。
12-- 此前拆出的后续任务卡里，`T-S027`、`T-S028`、`T-S029`、`T-S030`、`T-S031`、`T-S032` 已完成；当前主要剩余 `T-S026`。
13+- 当前仍不能写成“全部收尾完成”。剩余未闭项主要是：真实 Firefox 手工 smoke 未完成、风控状态仍是进程内内存态、ChatGPT 仍依赖真实浏览器登录态 / header 且没有 Claude 风格 prompt shortcut、ChatGPT / Gemini 最终消息提取仍有平台特定边界，以及 BAA 仍只做到单节点本地持久化、有界 journal、单客户端单轮 delivery 首版和 Phase 1 exact target。
14+- 此前拆出的后续任务卡里，`T-S027`、`T-S028`、`T-S029`、`T-S030`、`T-S031`、`T-S032`、`T-S033`、`T-S034` 已完成；当前主要剩余 `T-S026`。
15 
16 ## 本次核对依据
17 
18@@ -26,9 +26,9 @@
19 - `pnpm -C /Users/george/code/baa-conductor -F @baa-conductor/conductor-daemon build`
20   - 结果：通过
21 - `node --test /Users/george/code/baa-conductor/apps/conductor-daemon/src/index.test.js`
22-  - 结果：`44/44` 通过
23+  - 结果：`45/45` 通过
24 - `node --test /Users/george/code/baa-conductor/tests/browser/browser-control-e2e-smoke.test.mjs`
25-  - 结果：`6/6` 通过
26+  - 结果：`8/8` 通过
27 
28 ## 当前已完成功能
29 
30@@ -309,10 +309,11 @@
31 - 但它的最终文本提取基于 `StreamGenerate` / `batchexecute` 风格 payload 的启发式解析，稳定性弱于 ChatGPT。
32 - 当前保留 synthetic `assistant_message_id` 兜底，因此这层应表述为“已接通 raw relay，但平台提取稳定性仍有边界”，不是“Gemini 整个平台能力都已转正”。
33 
34-### 4. live message dedupe 和 instruction dedupe 仍是内存态
35+### 4. live message dedupe 和 instruction dedupe 已持久化，但仍只做单节点本地恢复
36 
37-- `browser.final_message` 当前已经 live 接入 instruction center，但 live message dedupe 和 instruction dedupe 都还是进程内内存态。
38-- 因此进程重启后，这两类 dedupe 状态都不会保留。
39+- `browser.final_message` 当前已经 live 接入 instruction center，live message dedupe 和 instruction dedupe 也都已落到本地 control-plane sqlite。
40+- 因此进程重启后，这两类 dedupe 状态会保留。
41+- 当前残余边界不是“会丢失”，而是“只做单节点本地持久化，不做跨节点共享”。
42 
43 ### 5. 风控状态仍是进程内内存态
44 
45@@ -337,13 +338,19 @@
46 - 但它仍依赖浏览器里真实捕获到的有效登录态 / header，不是“无前提可用”的平台。
47 - 另外，ChatGPT 也没有 Claude 风格的 prompt shortcut；当前正式支持面仍是 raw relay，不是 prompt helper。
48 
49-### 9. 当前摘要只保留最近一次 live ingest / execute，且仍只覆盖 Phase 1 exact target
50+### 9. 当前摘要已落到 bounded journal，live 路径也已接到 delivery bridge，但仍只覆盖 Phase 1 exact target
51 
52-- 当前 live ingest 读面只保留最近一次 ingest / execute 摘要，不落库。
53+- 当前 live ingest / execute 摘要已经落到有界 journal，并能在重启后恢复到：
54+  - Firefox WS `state_snapshot.snapshot.browser.instruction_ingest`
55+  - `GET /v1/browser` → `data.instruction_ingest`
56+- 当前 journal 只保留最近窗口，不扩成无限历史。
57+- 插件侧 upload / inject / send 仍是 DOM heuristic，当前只对 `Claude` / `ChatGPT` 做了首版选择器与流程。
58+- artifact payload 当前通过本地 `download_url` 以 base64 JSON 形式提供，适合当前 text/json 类产物；大二进制和 download 闭环还没做。
59+- 当前交付仍按任务边界停留在单客户端、单轮 delivery 首版。
60 - 当前仍只允许 Phase 1 精确 target：
61   - `conductor`
62   - `system`
63-- 虽然 service-side artifact center core 已落地，但 live 路径还没有把执行结果真正接到 artifact / upload / inject / send。
64+- 当前 live 路径已经把执行结果接到 artifact / upload / inject / send，但不扩到跨节点或完整 task/run 编排。
65 
66 ## 已拆出的后续任务
67 
68@@ -366,4 +373,4 @@
69 
70 如果只写一段给外部协作者看，可以用下面这版：
71 
72-> 当前代码已经完成单节点 `mini` 主接口收口，以及 Firefox 本地 bridge 下的 Claude / ChatGPT request relay 主链路、ChatGPT / Gemini 最终消息 raw relay、conductor 侧 live instruction ingest，以及 service-side artifact center core。`GET /v1/browser`、`POST /v1/browser/actions`、`POST /v1/browser/request`、`POST /v1/browser/request/cancel`、正式 SSE、结构化 `action_result`、`shell_runtime`、登录态元数据持久化、`browser.final_message` 最近快照、`instruction_ingest` 最近摘要，以及 `BUG-012` 的 stale `inFlight` 自愈清扫都已落地；`BUG-011`、`BUG-012`、`BUG-013`、`BUG-014`、`BUG-017` 也已在当前代码中修复，并已通过 `conductor-daemon build`、`index.test.js`（44/44）和 browser-control e2e smoke（6/6）。当前剩余缺口主要是：真实 Firefox 手工 smoke 未完成、ChatGPT / Gemini 最终消息提取仍有平台边界、live message dedupe / instruction dedupe 仍是内存态、最近摘要不落库，以及 live 路径还没有真正接到 artifact / upload / inject / send。
73+> 当前代码已经完成单节点 `mini` 主接口收口，以及 Firefox 本地 bridge 下的 Claude / ChatGPT request relay 主链路、ChatGPT / Gemini 最终消息 raw relay、conductor 侧 live instruction ingest、dedupe / execution journal 本地持久化，以及 artifact / upload / inject / send 主链。`GET /v1/browser`、`POST /v1/browser/actions`、`POST /v1/browser/request`、`POST /v1/browser/request/cancel`、正式 SSE、结构化 `action_result`、`shell_runtime`、登录态元数据持久化、`browser.final_message` 最近快照、`instruction_ingest` 最近摘要、upload receipt barrier，以及 `BUG-012` 的 stale `inFlight` 自愈清扫都已落地；`BUG-011`、`BUG-012`、`BUG-013`、`BUG-014`、`BUG-017` 也已在当前代码中修复，并已通过 `conductor-daemon build`、`index.test.js`（45/45）和 browser-control e2e smoke（8/8）。当前剩余缺口主要是：真实 Firefox 手工 smoke 未完成、ChatGPT / Gemini 最终消息提取仍有平台边界、插件侧 upload / inject / send 仍是首版 DOM heuristic、artifact payload 仍以本地 `download_url` 的 base64 JSON 形式提供且未覆盖大二进制 / download 闭环、BAA 仍只做单节点本地持久化、execution journal 只保留最近窗口，以及 live 执行路径仍只覆盖 Phase 1 exact target。

1@@ -101,7 +101,7 @@ test("artifact materializer turns exec output into artifact, manifest, and deliv
2 
3     assert.equal(plan.uploads.length, 2);
4     assert.deepEqual(plan.pendingBarriers, ["upload_receipt"]);
5-    assert.equal(plan.receiptBarrierImplemented, false);
6+    assert.equal(plan.receiptBarrierImplemented, true);
7     assert.match(indexText, /instruction_id: inst_exec_01/);
8     assert.match(indexText, /baa-result_trace-artifacts_r03_b02_exec_conductor_ok\.log/);
9     assert.match(indexText, /baa-manifest_trace-artifacts_r03\.json/);

 1@@ -9,12 +9,16 @@ function toUploadItem(artifact: {
 2   filename: string;
 3   localPath: string;
 4   mimeType: string;
 5+  sha256: string;
 6+  sizeBytes: number;
 7 }): BaaDeliveryUploadItem {
 8   return {
 9     artifactId: artifact.artifactId,
10     filename: artifact.filename,
11     localPath: artifact.localPath,
12-    mimeType: artifact.mimeType
13+    mimeType: artifact.mimeType,
14+    sha256: artifact.sha256,
15+    sizeBytes: artifact.sizeBytes
16   };
17 }
18 
19@@ -32,7 +36,7 @@ export function buildBaaDeliveryPlan(input: BuildBaaDeliveryPlanInput): BaaDeliv
20     messageText: input.indexText,
21     pendingBarriers: uploads.length === 0 ? [] : ["upload_receipt"],
22     planId: `plan_${input.materialization.traceId}_${input.materialization.roundId}`,
23-    receiptBarrierImplemented: false,
24+    receiptBarrierImplemented: true,
25     roundId: input.materialization.roundId,
26     target: input.target,
27     traceId: input.materialization.traceId,

1@@ -2,3 +2,4 @@ export * from "./types.js";
2 export * from "./materialize.js";
3 export * from "./manifest.js";
4 export * from "./delivery-plan.js";
5+export * from "./upload-session.js";

 1@@ -68,8 +68,8 @@ export async function buildBaaArtifactManifest(
 2     createdAt: materialization.createdAt,
 3     manifestId: `mf_${sanitizeSegment(materialization.traceId)}_${sanitizeSegment(materialization.roundId)}`,
 4     notes: [
 5-      "Service-side artifact materialization, manifest generation, and delivery-plan generation are implemented in conductor.",
 6-      "Browser upload/download execution and upload receipt barrier are not implemented in this phase."
 7+      "Service-side artifact materialization, manifest generation, delivery-plan generation, and upload receipt barrier are implemented in conductor.",
 8+      "Firefox bridge delivery currently covers upload_artifacts, upload_receipt, inject_message, and send_message for the single-client live path."
 9     ],
10     resultCount: materialization.results.length,
11     results: toManifestResultEntry(materialization),

 1@@ -139,6 +139,8 @@ export interface BaaDeliveryUploadItem {
 2   filename: string;
 3   localPath: string;
 4   mimeType: string;
 5+  sha256: string;
 6+  sizeBytes: number;
 7 }
 8 
 9 export interface BaaDeliveryPlan {
10@@ -164,3 +166,56 @@ export interface BuildBaaDeliveryPlanInput {
11   materialization: BaaArtifactMaterialization;
12   target: string;
13 }
14+
15+export type BaaDeliverySessionStage =
16+  | "idle"
17+  | "awaiting_receipts"
18+  | "injecting"
19+  | "sending"
20+  | "completed"
21+  | "failed";
22+
23+export interface BaaDeliveryUploadReceipt {
24+  artifactId: string;
25+  attempts: number;
26+  error: string | null;
27+  filename: string;
28+  ok: boolean;
29+  receivedAt: number | null;
30+  remoteHandle: string | null;
31+  sha256: string;
32+  sizeBytes: number;
33+}
34+
35+export interface BaaDeliverySessionSnapshot {
36+  autoSend: boolean;
37+  clientId: string | null;
38+  completedAt: number | null;
39+  connectionId: string | null;
40+  conversationId: string | null;
41+  createdAt: number;
42+  failedAt: number | null;
43+  failedReason: string | null;
44+  injectCompletedAt: number | null;
45+  injectRequestId: string | null;
46+  injectStartedAt: number | null;
47+  manifestId: string;
48+  pendingUploadArtifactIds: string[];
49+  planId: string;
50+  platform: string;
51+  receiptConfirmedCount: number;
52+  roundId: string;
53+  sendCompletedAt: number | null;
54+  sendRequestId: string | null;
55+  sendStartedAt: number | null;
56+  stage: BaaDeliverySessionStage;
57+  traceId: string;
58+  uploadCount: number;
59+  uploadDispatchedAt: number | null;
60+  uploadReceipts: BaaDeliveryUploadReceipt[];
61+}
62+
63+export interface BaaDeliveryBridgeSnapshot {
64+  activeSessionCount: number;
65+  lastSession: BaaDeliverySessionSnapshot | null;
66+}

  1@@ -0,0 +1,583 @@
  2+import { mkdir, readFile } from "node:fs/promises";
  3+import { tmpdir } from "node:os";
  4+import { join } from "node:path";
  5+
  6+import type { BrowserBridgeController } from "../browser-types.js";
  7+import type { BaaInstructionProcessResult } from "../instructions/types.js";
  8+
  9+import { buildBaaDeliveryPlan } from "./delivery-plan.js";
 10+import { buildBaaArtifactManifest, renderBaaArtifactIndexText } from "./manifest.js";
 11+import { materializeBaaExecutionArtifacts } from "./materialize.js";
 12+import type {
 13+  BaaDeliveryBridgeSnapshot,
 14+  BaaDeliveryPlan,
 15+  BaaDeliverySessionSnapshot,
 16+  BaaDeliveryUploadItem,
 17+  BaaDeliveryUploadReceipt
 18+} from "./types.js";
 19+
 20+type TimeoutHandle = ReturnType<typeof globalThis.setTimeout>;
 21+
 22+const DEFAULT_UPLOAD_RECEIPT_TIMEOUT_MS = 60_000;
 23+const DEFAULT_COMPLETED_SESSION_TTL_MS = 10 * 60_000;
 24+
 25+interface BaaArtifactContentPayload {
 26+  artifact_id: string;
 27+  content_base64: string;
 28+  encoding: "base64";
 29+  filename: string;
 30+  mime_type: string;
 31+  sha256: string;
 32+  size_bytes: number;
 33+}
 34+
 35+interface BaaDeliveryReceiptBarrier {
 36+  promise: Promise<void>;
 37+  reject: (error: Error) => void;
 38+  resolve: () => void;
 39+  settled: boolean;
 40+  timer: TimeoutHandle;
 41+}
 42+
 43+interface BaaDeliverySessionRecord {
 44+  barrier: BaaDeliveryReceiptBarrier | null;
 45+  expiresAt: number;
 46+  plan: BaaDeliveryPlan;
 47+  snapshot: BaaDeliverySessionSnapshot;
 48+  targetClientId: string | null;
 49+  targetConnectionId: string | null;
 50+  uploadsByArtifactId: Map<string, BaaDeliveryUploadItem>;
 51+}
 52+
 53+export interface BaaArtifactDeliveryBridgeOptions {
 54+  baseUrlLoader: () => string;
 55+  bridge: BrowserBridgeController;
 56+  now?: () => number;
 57+  onChange?: (() => Promise<void> | void) | null;
 58+  outputDirLoader?: (() => string | null) | null;
 59+}
 60+
 61+export interface BaaArtifactDeliveryInput {
 62+  assistantMessageId: string;
 63+  autoSend?: boolean;
 64+  clientId?: string | null;
 65+  connectionId?: string | null;
 66+  conversationId?: string | null;
 67+  platform: string;
 68+  processResult: BaaInstructionProcessResult | null;
 69+}
 70+
 71+function sanitizePathSegment(value: string): string {
 72+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/gu, "-");
 73+  const collapsed = normalized.replace(/-+/gu, "-").replace(/^-|-$/gu, "");
 74+  return collapsed === "" ? "unknown" : collapsed;
 75+}
 76+
 77+function cloneUploadReceipt(receipt: BaaDeliveryUploadReceipt): BaaDeliveryUploadReceipt {
 78+  return {
 79+    artifactId: receipt.artifactId,
 80+    attempts: receipt.attempts,
 81+    error: receipt.error,
 82+    filename: receipt.filename,
 83+    ok: receipt.ok,
 84+    receivedAt: receipt.receivedAt,
 85+    remoteHandle: receipt.remoteHandle,
 86+    sha256: receipt.sha256,
 87+    sizeBytes: receipt.sizeBytes
 88+  };
 89+}
 90+
 91+function cloneSessionSnapshot(snapshot: BaaDeliverySessionSnapshot): BaaDeliverySessionSnapshot {
 92+  return {
 93+    autoSend: snapshot.autoSend,
 94+    clientId: snapshot.clientId,
 95+    completedAt: snapshot.completedAt,
 96+    connectionId: snapshot.connectionId,
 97+    conversationId: snapshot.conversationId,
 98+    createdAt: snapshot.createdAt,
 99+    failedAt: snapshot.failedAt,
100+    failedReason: snapshot.failedReason,
101+    injectCompletedAt: snapshot.injectCompletedAt,
102+    injectRequestId: snapshot.injectRequestId,
103+    injectStartedAt: snapshot.injectStartedAt,
104+    manifestId: snapshot.manifestId,
105+    pendingUploadArtifactIds: [...snapshot.pendingUploadArtifactIds],
106+    planId: snapshot.planId,
107+    platform: snapshot.platform,
108+    receiptConfirmedCount: snapshot.receiptConfirmedCount,
109+    roundId: snapshot.roundId,
110+    sendCompletedAt: snapshot.sendCompletedAt,
111+    sendRequestId: snapshot.sendRequestId,
112+    sendStartedAt: snapshot.sendStartedAt,
113+    stage: snapshot.stage,
114+    traceId: snapshot.traceId,
115+    uploadCount: snapshot.uploadCount,
116+    uploadDispatchedAt: snapshot.uploadDispatchedAt,
117+    uploadReceipts: snapshot.uploadReceipts.map(cloneUploadReceipt)
118+  };
119+}
120+
121+function normalizeNonEmptyString(value: unknown): string | null {
122+  if (typeof value !== "string") {
123+    return null;
124+  }
125+
126+  const normalized = value.trim();
127+  return normalized === "" ? null : normalized;
128+}
129+
130+function readPositiveInteger(value: unknown): number | null {
131+  return typeof value === "number" && Number.isFinite(value) && value > 0
132+    ? Math.round(value)
133+    : null;
134+}
135+
136+function asRecord(value: unknown): Record<string, unknown> | null {
137+  if (value == null || typeof value !== "object" || Array.isArray(value)) {
138+    return null;
139+  }
140+
141+  return value as Record<string, unknown>;
142+}
143+
144+export class BaaArtifactDeliveryBridge {
145+  private readonly baseUrlLoader: () => string;
146+  private readonly bridge: BrowserBridgeController;
147+  private lastSession: BaaDeliverySessionSnapshot | null = null;
148+  private readonly now: () => number;
149+  private readonly onChange: (() => Promise<void> | void) | null;
150+  private readonly outputDirLoader: () => string | null;
151+  private readonly sessions = new Map<string, BaaDeliverySessionRecord>();
152+
153+  constructor(options: BaaArtifactDeliveryBridgeOptions) {
154+    this.baseUrlLoader = options.baseUrlLoader;
155+    this.bridge = options.bridge;
156+    this.now = options.now ?? (() => Date.now());
157+    this.onChange = options.onChange ?? null;
158+    this.outputDirLoader = options.outputDirLoader ?? (() => null);
159+  }
160+
161+  getSnapshot(): BaaDeliveryBridgeSnapshot {
162+    this.cleanupExpiredSessions();
163+
164+    return {
165+      activeSessionCount: [...this.sessions.values()].filter((entry) =>
166+        entry.snapshot.stage !== "completed" && entry.snapshot.stage !== "failed"
167+      ).length,
168+      lastSession: this.lastSession == null ? null : cloneSessionSnapshot(this.lastSession)
169+    };
170+  }
171+
172+  async deliver(input: BaaArtifactDeliveryInput): Promise<BaaDeliverySessionSnapshot | null> {
173+    this.cleanupExpiredSessions();
174+
175+    const processResult = input.processResult;
176+
177+    if (processResult == null || processResult.executions.length === 0) {
178+      return null;
179+    }
180+
181+    const traceId = `delivery_${sanitizePathSegment(input.assistantMessageId)}`;
182+    const roundId = `round_${this.now()}`;
183+    const outputDir = await this.prepareOutputDir(traceId, roundId);
184+    const instructionById = new Map(
185+      processResult.instructions.map((instruction) => [instruction.instructionId, instruction])
186+    );
187+    const materialization = await materializeBaaExecutionArtifacts(
188+      processResult.executions.map((execution, index) => ({
189+        blockIndex: instructionById.get(execution.instructionId)?.blockIndex ?? null,
190+        execution,
191+        sequence: index + 1
192+      })),
193+      {
194+        outputDir,
195+        roundId,
196+        traceId
197+      }
198+    );
199+    const manifestBundle = await buildBaaArtifactManifest(materialization);
200+    const indexText = renderBaaArtifactIndexText(materialization, manifestBundle);
201+    const plan = buildBaaDeliveryPlan({
202+      autoSend: input.autoSend ?? true,
203+      conversationId: input.conversationId ?? null,
204+      indexText,
205+      manifestBundle,
206+      materialization,
207+      target: `browser.${input.platform}`
208+    });
209+    const createdAt = this.now();
210+    const session: BaaDeliverySessionSnapshot = {
211+      autoSend: plan.autoSend,
212+      clientId: input.clientId ?? null,
213+      completedAt: null,
214+      connectionId: input.connectionId ?? null,
215+      conversationId: plan.conversationId,
216+      createdAt,
217+      failedAt: null,
218+      failedReason: null,
219+      injectCompletedAt: null,
220+      injectRequestId: null,
221+      injectStartedAt: null,
222+      manifestId: plan.manifestId,
223+      pendingUploadArtifactIds: plan.uploads.map((upload) => upload.artifactId),
224+      planId: plan.planId,
225+      platform: input.platform,
226+      receiptConfirmedCount: 0,
227+      roundId: plan.roundId,
228+      sendCompletedAt: null,
229+      sendRequestId: null,
230+      sendStartedAt: null,
231+      stage: plan.uploads.length === 0 ? "injecting" : "awaiting_receipts",
232+      traceId: plan.traceId,
233+      uploadCount: plan.uploads.length,
234+      uploadDispatchedAt: null,
235+      uploadReceipts: plan.uploads.map((upload) => ({
236+        artifactId: upload.artifactId,
237+        attempts: 0,
238+        error: null,
239+        filename: upload.filename,
240+        ok: false,
241+        receivedAt: null,
242+        remoteHandle: null,
243+        sha256: upload.sha256,
244+        sizeBytes: upload.sizeBytes
245+      }))
246+    };
247+    const barrier = plan.uploads.length === 0 ? null : this.createReceiptBarrier(plan.planId);
248+    const record: BaaDeliverySessionRecord = {
249+      barrier,
250+      expiresAt: createdAt + DEFAULT_COMPLETED_SESSION_TTL_MS,
251+      plan,
252+      snapshot: session,
253+      targetClientId: input.clientId ?? null,
254+      targetConnectionId: input.connectionId ?? null,
255+      uploadsByArtifactId: new Map(plan.uploads.map((upload) => [upload.artifactId, upload]))
256+    };
257+
258+    this.sessions.set(plan.planId, record);
259+    this.lastSession = cloneSessionSnapshot(session);
260+    this.signalChange();
261+
262+    try {
263+      if (plan.uploads.length > 0) {
264+        const dispatch = this.bridge.uploadArtifacts({
265+          clientId: input.clientId,
266+          conversationId: plan.conversationId,
267+          manifestId: plan.manifestId,
268+          planId: plan.planId,
269+          platform: input.platform,
270+          uploads: plan.uploads.map((upload) => ({
271+            artifactId: upload.artifactId,
272+            downloadUrl: this.buildArtifactDownloadUrl(plan.planId, upload.artifactId),
273+            filename: upload.filename,
274+            mimeType: upload.mimeType,
275+            sha256: upload.sha256,
276+            sizeBytes: upload.sizeBytes
277+          }))
278+        });
279+
280+        record.snapshot.uploadDispatchedAt = dispatch.dispatchedAt;
281+        this.captureLastSession(record.snapshot);
282+
283+        await record.barrier?.promise;
284+      }
285+
286+      const injectDispatch = this.bridge.injectMessage({
287+        clientId: input.clientId,
288+        conversationId: plan.conversationId,
289+        messageText: plan.messageText,
290+        planId: plan.planId,
291+        platform: input.platform
292+      });
293+
294+      record.snapshot.injectRequestId = injectDispatch.requestId;
295+      record.snapshot.injectStartedAt = injectDispatch.dispatchedAt;
296+      record.snapshot.stage = "injecting";
297+      this.captureLastSession(record.snapshot);
298+      const injectResult = await injectDispatch.result;
299+
300+      if (injectResult.accepted !== true || injectResult.failed === true) {
301+        throw new Error(injectResult.reason ?? "browser inject_message failed");
302+      }
303+
304+      record.snapshot.injectCompletedAt = this.now();
305+
306+      if (plan.autoSend) {
307+        const sendDispatch = this.bridge.sendMessage({
308+          clientId: input.clientId,
309+          conversationId: plan.conversationId,
310+          planId: plan.planId,
311+          platform: input.platform
312+        });
313+
314+        record.snapshot.sendRequestId = sendDispatch.requestId;
315+        record.snapshot.sendStartedAt = sendDispatch.dispatchedAt;
316+        record.snapshot.stage = "sending";
317+        this.captureLastSession(record.snapshot);
318+        const sendResult = await sendDispatch.result;
319+
320+        if (sendResult.accepted !== true || sendResult.failed === true) {
321+          throw new Error(sendResult.reason ?? "browser send_message failed");
322+        }
323+
324+        record.snapshot.sendCompletedAt = this.now();
325+      }
326+
327+      record.snapshot.completedAt = this.now();
328+      record.snapshot.stage = "completed";
329+      record.expiresAt = record.snapshot.completedAt + DEFAULT_COMPLETED_SESSION_TTL_MS;
330+      this.captureLastSession(record.snapshot);
331+      return cloneSessionSnapshot(record.snapshot);
332+    } catch (error) {
333+      this.failSession(
334+        record,
335+        error instanceof Error ? error.message : String(error)
336+      );
337+      throw error;
338+    }
339+  }
340+
341+  handleUploadReceipt(
342+    connectionId: string,
343+    payload: Record<string, unknown>
344+  ): boolean {
345+    this.cleanupExpiredSessions();
346+
347+    const planId = normalizeNonEmptyString(payload.plan_id ?? payload.planId);
348+
349+    if (planId == null) {
350+      return false;
351+    }
352+
353+    const session = this.sessions.get(planId);
354+
355+    if (session == null) {
356+      return false;
357+    }
358+
359+    if (session.targetConnectionId != null && session.targetConnectionId !== connectionId) {
360+      return false;
361+    }
362+
363+    const receipts = Array.isArray(payload.receipts) ? payload.receipts : [];
364+
365+    if (receipts.length === 0) {
366+      return false;
367+    }
368+
369+    let touched = false;
370+
371+    for (const entry of receipts) {
372+      const record = asRecord(entry);
373+
374+      if (record == null) {
375+        continue;
376+      }
377+
378+      const artifactId = normalizeNonEmptyString(record.artifact_id ?? record.artifactId);
379+
380+      if (artifactId == null) {
381+        continue;
382+      }
383+
384+      const upload = session.uploadsByArtifactId.get(artifactId);
385+      const receipt = session.snapshot.uploadReceipts.find((candidate) => candidate.artifactId === artifactId);
386+
387+      if (upload == null || receipt == null) {
388+        continue;
389+      }
390+
391+      receipt.attempts = readPositiveInteger(record.attempts) ?? Math.max(1, receipt.attempts);
392+      receipt.error = normalizeNonEmptyString(record.error ?? record.reason);
393+      receipt.ok = record.ok !== false;
394+      receipt.receivedAt = readPositiveInteger(record.received_at ?? record.receivedAt) ?? this.now();
395+      receipt.remoteHandle = normalizeNonEmptyString(record.remote_handle ?? record.remoteHandle);
396+      touched = true;
397+
398+      if (receipt.ok) {
399+        session.snapshot.pendingUploadArtifactIds = session.snapshot.pendingUploadArtifactIds.filter(
400+          (candidate) => candidate !== artifactId
401+        );
402+      } else {
403+        this.failSession(
404+          session,
405+          receipt.error ?? `artifact ${upload.filename} upload failed`
406+        );
407+      }
408+    }
409+
410+    if (!touched) {
411+      return false;
412+    }
413+
414+    session.snapshot.receiptConfirmedCount = session.snapshot.uploadReceipts.filter((entry) => entry.ok).length;
415+    this.captureLastSession(session.snapshot);
416+
417+    if (
418+      session.barrier != null
419+      && session.barrier.settled === false
420+      && session.snapshot.pendingUploadArtifactIds.length === 0
421+      && session.snapshot.uploadReceipts.every((entry) => entry.ok)
422+    ) {
423+      session.barrier.settled = true;
424+      globalThis.clearTimeout(session.barrier.timer);
425+      session.barrier.resolve();
426+    }
427+
428+    return true;
429+  }
430+
431+  handleConnectionClosed(connectionId: string, reason?: string | null): void {
432+    for (const session of this.sessions.values()) {
433+      if (session.targetConnectionId !== connectionId) {
434+        continue;
435+      }
436+
437+      if (session.snapshot.stage === "completed" || session.snapshot.stage === "failed") {
438+        continue;
439+      }
440+
441+      this.failSession(
442+        session,
443+        normalizeNonEmptyString(reason) ?? "firefox delivery client disconnected"
444+      );
445+    }
446+  }
447+
448+  readArtifactContent(
449+    planId: string,
450+    artifactId: string
451+  ): Promise<BaaArtifactContentPayload | null> {
452+    this.cleanupExpiredSessions();
453+    return this.loadArtifactContent(planId, artifactId);
454+  }
455+
456+  stop(): void {
457+    for (const session of this.sessions.values()) {
458+      if (session.barrier != null && session.barrier.settled === false) {
459+        session.barrier.settled = true;
460+        globalThis.clearTimeout(session.barrier.timer);
461+        session.barrier.reject(new Error("artifact delivery bridge stopped"));
462+      }
463+    }
464+
465+    this.sessions.clear();
466+  }
467+
468+  private captureLastSession(snapshot: BaaDeliverySessionSnapshot): void {
469+    this.lastSession = cloneSessionSnapshot(snapshot);
470+    this.signalChange();
471+  }
472+
473+  private cleanupExpiredSessions(): void {
474+    const now = this.now();
475+
476+    for (const [planId, session] of this.sessions.entries()) {
477+      if (session.expiresAt > now) {
478+        continue;
479+      }
480+
481+      if (session.barrier != null && session.barrier.settled === false) {
482+        session.barrier.settled = true;
483+        globalThis.clearTimeout(session.barrier.timer);
484+        session.barrier.reject(new Error("artifact delivery receipt timed out"));
485+      }
486+
487+      this.sessions.delete(planId);
488+    }
489+  }
490+
491+  private createReceiptBarrier(planId: string): BaaDeliveryReceiptBarrier {
492+    let resolveBarrier!: () => void;
493+    let rejectBarrier!: (error: Error) => void;
494+    const promise = new Promise<void>((resolve, reject) => {
495+      resolveBarrier = resolve;
496+      rejectBarrier = reject;
497+    });
498+    void promise.catch(() => {});
499+    const timer = globalThis.setTimeout(() => {
500+      const session = this.sessions.get(planId);
501+
502+      if (session == null || session.barrier == null || session.barrier.settled) {
503+        return;
504+      }
505+
506+      this.failSession(session, `upload receipt barrier timed out for plan "${planId}"`);
507+    }, DEFAULT_UPLOAD_RECEIPT_TIMEOUT_MS);
508+
509+    return {
510+      promise,
511+      reject: rejectBarrier,
512+      resolve: resolveBarrier,
513+      settled: false,
514+      timer
515+    };
516+  }
517+
518+  private async loadArtifactContent(
519+    planId: string,
520+    artifactId: string
521+  ): Promise<BaaArtifactContentPayload | null> {
522+    const session = this.sessions.get(planId);
523+
524+    if (session == null) {
525+      return null;
526+    }
527+
528+    const upload = session.uploadsByArtifactId.get(artifactId);
529+
530+    if (upload == null) {
531+      return null;
532+    }
533+
534+    const content = await readFile(upload.localPath);
535+
536+    return {
537+      artifact_id: artifactId,
538+      content_base64: content.toString("base64"),
539+      encoding: "base64",
540+      filename: upload.filename,
541+      mime_type: upload.mimeType,
542+      sha256: upload.sha256,
543+      size_bytes: upload.sizeBytes
544+    };
545+  }
546+
547+  private buildArtifactDownloadUrl(planId: string, artifactId: string): string {
548+    const baseUrl = this.baseUrlLoader().replace(/\/+$/u, "");
549+    return `${baseUrl}/v1/browser/delivery/artifacts/${encodeURIComponent(planId)}/${encodeURIComponent(artifactId)}`;
550+  }
551+
552+  private failSession(session: BaaDeliverySessionRecord, reason: string): void {
553+    if (session.barrier != null && session.barrier.settled === false) {
554+      session.barrier.settled = true;
555+      globalThis.clearTimeout(session.barrier.timer);
556+      session.barrier.reject(new Error(reason));
557+    }
558+
559+    const failedAt = this.now();
560+
561+    session.snapshot.failedAt = failedAt;
562+    session.snapshot.failedReason = reason;
563+    session.snapshot.stage = "failed";
564+    session.expiresAt = failedAt + DEFAULT_COMPLETED_SESSION_TTL_MS;
565+    this.captureLastSession(session.snapshot);
566+  }
567+
568+  private async prepareOutputDir(traceId: string, roundId: string): Promise<string> {
569+    const baseDir = this.outputDirLoader() ?? tmpdir();
570+    const outputDir = join(baseDir, "baa-artifact-delivery", traceId, roundId);
571+    await mkdir(outputDir, {
572+      recursive: true
573+    });
574+    return outputDir;
575+  }
576+
577+  private signalChange(): void {
578+    if (this.onChange == null) {
579+      return;
580+    }
581+
582+    void Promise.resolve(this.onChange()).catch(() => {});
583+  }
584+}

 1@@ -1,4 +1,5 @@
 2 import type { BaaLiveInstructionIngestSnapshot } from "./instructions/ingest.js";
 3+import type { BaaDeliveryBridgeSnapshot } from "./artifacts/types.js";
 4 
 5 export type BrowserBridgeLoginStatus = "fresh" | "stale" | "lost";
 6 
 7@@ -145,6 +146,7 @@ export interface BrowserBridgeStateSnapshot {
 8   active_connection_id: string | null;
 9   client_count: number;
10   clients: BrowserBridgeClientSnapshot[];
11+  delivery: BaaDeliveryBridgeSnapshot;
12   instruction_ingest: BaaLiveInstructionIngestSnapshot;
13   ws_path: string;
14   ws_url: string | null;
15@@ -257,6 +259,34 @@ export interface BrowserBridgeController {
16     streamId?: string | null;
17     timeoutMs?: number | null;
18   }): Promise<BrowserBridgeApiResponse>;
19+  injectMessage(input: {
20+    clientId?: string | null;
21+    conversationId?: string | null;
22+    messageText: string;
23+    planId: string;
24+    platform: string;
25+  }): BrowserBridgeActionDispatch;
26+  sendMessage(input: {
27+    clientId?: string | null;
28+    conversationId?: string | null;
29+    planId: string;
30+    platform: string;
31+  }): BrowserBridgeActionDispatch;
32+  uploadArtifacts(input: {
33+    clientId?: string | null;
34+    conversationId?: string | null;
35+    manifestId: string;
36+    planId: string;
37+    platform: string;
38+    uploads: Array<{
39+      artifactId: string;
40+      downloadUrl: string;
41+      filename: string;
42+      mimeType: string;
43+      sha256: string;
44+      sizeBytes: number;
45+    }>;
46+  }): BrowserBridgeDispatchReceipt;
47   cancelApiRequest(input: {
48     clientId?: string | null;
49     platform?: string | null;

  1@@ -17,6 +17,9 @@ type TimeoutHandle = ReturnType<typeof globalThis.setTimeout>;
  2 export type FirefoxBridgeResponseMode = "buffered" | "sse";
  3 export type FirefoxBridgeOutboundCommandType =
  4   | "api_request"
  5+  | "browser.inject_message"
  6+  | "browser.send_message"
  7+  | "browser.upload_artifacts"
  8   | "controller_reload"
  9   | "open_tab"
 10   | "plugin_status"
 11@@ -94,6 +97,34 @@ export interface FirefoxApiRequestCommandInput extends FirefoxBridgeCommandTarge
 12   timeoutMs?: number | null;
 13 }
 14 
 15+export interface FirefoxUploadArtifactsCommandInput extends FirefoxBridgeCommandTarget {
 16+  conversationId?: string | null;
 17+  manifestId: string;
 18+  planId: string;
 19+  platform: string;
 20+  uploads: Array<{
 21+    artifactId: string;
 22+    downloadUrl: string;
 23+    filename: string;
 24+    mimeType: string;
 25+    sha256: string;
 26+    sizeBytes: number;
 27+  }>;
 28+}
 29+
 30+export interface FirefoxInjectMessageCommandInput extends FirefoxBridgeCommandTarget {
 31+  conversationId?: string | null;
 32+  messageText: string;
 33+  planId: string;
 34+  platform: string;
 35+}
 36+
 37+export interface FirefoxSendMessageCommandInput extends FirefoxBridgeCommandTarget {
 38+  conversationId?: string | null;
 39+  planId: string;
 40+  platform: string;
 41+}
 42+
 43 export interface FirefoxRequestCancelCommandInput extends FirefoxBridgeCommandTarget {
 44   platform?: string | null;
 45   reason?: string | null;
 46@@ -1388,6 +1419,60 @@ export class FirefoxBridgeService {
 47     );
 48   }
 49 
 50+  uploadArtifacts(
 51+    input: FirefoxUploadArtifactsCommandInput
 52+  ): FirefoxBridgeDispatchReceipt {
 53+    return this.broker.dispatch(
 54+      "browser.upload_artifacts",
 55+      {
 56+        conversation_id: normalizeOptionalString(input.conversationId) ?? undefined,
 57+        manifest_id: input.manifestId,
 58+        plan_id: input.planId,
 59+        platform: input.platform,
 60+        uploads: input.uploads.map((upload) => ({
 61+          artifact_id: upload.artifactId,
 62+          download_url: upload.downloadUrl,
 63+          filename: upload.filename,
 64+          mime_type: upload.mimeType,
 65+          sha256: upload.sha256,
 66+          size_bytes: upload.sizeBytes
 67+        }))
 68+      },
 69+      input
 70+    );
 71+  }
 72+
 73+  injectMessage(
 74+    input: FirefoxInjectMessageCommandInput
 75+  ): BrowserBridgeActionDispatch {
 76+    return this.broker.dispatchWithActionResult(
 77+      "browser.inject_message",
 78+      compactRecord({
 79+        action: "inject_message",
 80+        conversation_id: normalizeOptionalString(input.conversationId) ?? undefined,
 81+        message_text: input.messageText,
 82+        plan_id: input.planId,
 83+        platform: input.platform
 84+      }),
 85+      input
 86+    );
 87+  }
 88+
 89+  sendMessage(
 90+    input: FirefoxSendMessageCommandInput
 91+  ): BrowserBridgeActionDispatch {
 92+    return this.broker.dispatchWithActionResult(
 93+      "browser.send_message",
 94+      compactRecord({
 95+        action: "send_message",
 96+        conversation_id: normalizeOptionalString(input.conversationId) ?? undefined,
 97+        plan_id: input.planId,
 98+        platform: input.platform
 99+      }),
100+      input
101+    );
102+  }
103+
104   reload(input: FirefoxReloadCommandInput = {}): BrowserBridgeActionDispatch {
105     return this.broker.dispatchWithActionResult(
106       "reload",

  1@@ -3,6 +3,7 @@ import type { IncomingMessage } from "node:http";
  2 import type { Socket } from "node:net";
  3 import type { ControlPlaneRepository } from "../../../packages/db/dist/index.js";
  4 
  5+import { BaaArtifactDeliveryBridge } from "./artifacts/upload-session.js";
  6 import {
  7   FirefoxBridgeService,
  8   FirefoxCommandBroker,
  9@@ -947,6 +948,7 @@ class FirefoxWebSocketConnection {
 10 export class ConductorFirefoxWebSocketServer {
 11   private readonly baseUrlLoader: () => string;
 12   private readonly bridgeService: FirefoxBridgeService;
 13+  private readonly deliveryBridge: BaaArtifactDeliveryBridge;
 14   private readonly instructionIngest: BaaLiveInstructionIngest | null;
 15   private readonly now: () => number;
 16   private readonly repository: ControlPlaneRepository;
 17@@ -970,6 +972,15 @@ export class ConductorFirefoxWebSocketServer {
 18       resolveClientById: (clientId) => this.getClientById(clientId)
 19     });
 20     this.bridgeService = new FirefoxBridgeService(commandBroker);
 21+    this.deliveryBridge = new BaaArtifactDeliveryBridge({
 22+      baseUrlLoader: this.baseUrlLoader,
 23+      bridge: this.bridgeService,
 24+      now: () => this.getNextTimestampMilliseconds(),
 25+      onChange: () => this.broadcastStateSnapshot("delivery_session", {
 26+        force: true
 27+      }),
 28+      outputDirLoader: () => this.snapshotLoader().paths.stateDir ?? this.snapshotLoader().paths.tmpDir ?? null
 29+    });
 30   }
 31 
 32   getUrl(): string | null {
 33@@ -980,6 +991,10 @@ export class ConductorFirefoxWebSocketServer {
 34     return this.bridgeService;
 35   }
 36 
 37+  getDeliveryBridge(): BaaArtifactDeliveryBridge {
 38+    return this.deliveryBridge;
 39+  }
 40+
 41   getNowMilliseconds(): number {
 42     return this.now() * 1000;
 43   }
 44@@ -1012,6 +1027,7 @@ export class ConductorFirefoxWebSocketServer {
 45     }
 46 
 47     this.bridgeService.stop();
 48+    this.deliveryBridge.stop();
 49 
 50     for (const connection of [...this.connections]) {
 51       connection.close(1001, "server shutdown");
 52@@ -1083,6 +1099,7 @@ export class ConductorFirefoxWebSocketServer {
 53       connectionId: connection.getConnectionId(),
 54       reason: closeInfo.reason
 55     });
 56+    this.deliveryBridge.handleConnectionClosed(connection.getConnectionId(), closeInfo.reason);
 57     void this.markClientLoginStatesStale(clientId);
 58 
 59     void this.broadcastStateSnapshot("disconnect", {
 60@@ -1145,6 +1162,9 @@ export class ConductorFirefoxWebSocketServer {
 61       case "browser.final_message":
 62         await this.handleBrowserFinalMessage(connection, message);
 63         return;
 64+      case "browser.upload_receipt":
 65+        await this.handleBrowserUploadReceipt(connection, message);
 66+        return;
 67       case "api_request":
 68         this.sendError(
 69           connection,
 70@@ -1209,6 +1229,7 @@ export class ConductorFirefoxWebSocketServer {
 71           "api_endpoints",
 72           "client_log",
 73           "browser.final_message",
 74+          "browser.upload_receipt",
 75           "api_response",
 76           "stream_open",
 77           "stream_event",
 78@@ -1219,6 +1240,9 @@ export class ConductorFirefoxWebSocketServer {
 79           "hello_ack",
 80           "state_snapshot",
 81           "action_result",
 82+          "browser.upload_artifacts",
 83+          "browser.inject_message",
 84+          "browser.send_message",
 85           "request_credentials",
 86           "open_tab",
 87           "plugin_status",
 88@@ -1564,7 +1588,7 @@ export class ConductorFirefoxWebSocketServer {
 89       return;
 90     }
 91 
 92-    await this.instructionIngest.ingestAssistantFinalMessage({
 93+    const ingestResult = await this.instructionIngest.ingestAssistantFinalMessage({
 94       assistantMessageId: finalMessage.assistant_message_id,
 95       conversationId: finalMessage.conversation_id,
 96       observedAt: finalMessage.observed_at,
 97@@ -1573,6 +1597,50 @@ export class ConductorFirefoxWebSocketServer {
 98       text: finalMessage.raw_text
 99     });
100     await this.broadcastStateSnapshot("instruction_ingest");
101+
102+    if (ingestResult.processResult == null) {
103+      return;
104+    }
105+
106+    try {
107+      await this.deliveryBridge.deliver({
108+        assistantMessageId: finalMessage.assistant_message_id,
109+        clientId: connection.getClientId(),
110+        connectionId: connection.getConnectionId(),
111+        conversationId: finalMessage.conversation_id,
112+        platform: finalMessage.platform,
113+        processResult: ingestResult.processResult
114+      });
115+    } catch {
116+      // delivery session state is already written back into browser snapshots
117+    }
118+  }
119+
120+  private async handleBrowserUploadReceipt(
121+    connection: FirefoxWebSocketConnection,
122+    message: Record<string, unknown>
123+  ): Promise<void> {
124+    const planId = readFirstString(message, ["plan_id", "planId"]);
125+
126+    if (planId == null) {
127+      this.sendError(connection, "invalid_message", "browser.upload_receipt requires a non-empty plan_id field.");
128+      return;
129+    }
130+
131+    if (!Array.isArray(message.receipts) || message.receipts.length === 0) {
132+      this.sendError(connection, "invalid_message", "browser.upload_receipt requires a non-empty receipts array.");
133+      return;
134+    }
135+
136+    const handled = this.deliveryBridge.handleUploadReceipt(connection.getConnectionId(), message);
137+
138+    if (!handled) {
139+      this.sendError(
140+        connection,
141+        "invalid_message",
142+        `browser.upload_receipt does not match an active delivery plan: ${planId}.`
143+      );
144+    }
145   }
146 
147   private handleApiResponse(
148@@ -1798,9 +1866,12 @@ export class ConductorFirefoxWebSocketServer {
149       active_connection_id: activeClient?.connectionId ?? null,
150       client_count: clients.length,
151       clients,
152+      delivery: this.deliveryBridge.getSnapshot(),
153       instruction_ingest: this.instructionIngest?.getSnapshot() ?? {
154         last_execute: null,
155-        last_ingest: null
156+        last_ingest: null,
157+        recent_executes: [],
158+        recent_ingests: []
159       },
160       ws_path: FIREFOX_WS_PATH,
161       ws_url: this.getUrl()

  1@@ -17,6 +17,9 @@ import {
  2   BrowserRequestPolicyController,
  3   ConductorDaemon,
  4   ConductorRuntime,
  5+  PersistentBaaInstructionDeduper,
  6+  PersistentBaaLiveInstructionMessageDeduper,
  7+  PersistentBaaLiveInstructionSnapshotStore,
  8   createFetchControlApiClient,
  9   extractBaaInstructionBlocks,
 10   handleConductorHttpRequest,
 11@@ -58,10 +61,10 @@ function createLeaseResult({
 12   };
 13 }
 14 
 15-async function createLocalApiFixture() {
 16+async function createLocalApiFixture(options = {}) {
 17   const sharedToken = "local-shared-token";
 18   const controlPlane = new ConductorLocalControlPlane({
 19-    databasePath: ":memory:"
 20+    databasePath: options.databasePath ?? ":memory:"
 21   });
 22   await controlPlane.initialize();
 23 
 24@@ -4350,6 +4353,176 @@ test("ConductorRuntime routes browser.final_message into live instruction ingest
 25   }
 26 });
 27 
 28+test("persistent live ingest survives restart and /v1/browser restores recent history from the journal", async () => {
 29+  const stateDir = mkdtempSync(join(tmpdir(), "baa-conductor-final-message-persist-"));
 30+  const databasePath = join(stateDir, "control-plane.sqlite");
 31+  const hostOpsDir = mkdtempSync(join(tmpdir(), "baa-conductor-final-message-history-"));
 32+  const outputPath = join(hostOpsDir, "final-message-persist.txt");
 33+  const messageText = [
 34+    "```baa",
 35+    `@conductor::exec::{"command":"printf 'persisted-live\\n' >> final-message-persist.txt","cwd":${JSON.stringify(hostOpsDir)}}`,
 36+    "```"
 37+  ].join("\n");
 38+  let nowMs = 1_710_000_020_000;
 39+  let runtime = null;
 40+
 41+  const buildPersistentIngest = (repository, sharedToken, snapshot) =>
 42+    new BaaLiveInstructionIngest({
 43+      center: new BaaInstructionCenter({
 44+        deduper: new PersistentBaaInstructionDeduper(repository, () => nowMs),
 45+        localApiContext: {
 46+          fetchImpl: globalThis.fetch,
 47+          repository,
 48+          sharedToken,
 49+          snapshotLoader: () => snapshot
 50+        }
 51+      }),
 52+      historyLimit: 10,
 53+      messageDeduper: new PersistentBaaLiveInstructionMessageDeduper(repository, () => nowMs),
 54+      now: () => nowMs,
 55+      snapshotStore: new PersistentBaaLiveInstructionSnapshotStore(repository, 10)
 56+    });
 57+
 58+  let firstFixture = null;
 59+  let restartedControlPlane = null;
 60+
 61+  try {
 62+    firstFixture = await createLocalApiFixture({
 63+      databasePath
 64+    });
 65+    const firstIngest = buildPersistentIngest(
 66+      firstFixture.repository,
 67+      firstFixture.sharedToken,
 68+      firstFixture.snapshot
 69+    );
 70+
 71+    await firstIngest.initialize();
 72+    const firstPass = await firstIngest.ingestAssistantFinalMessage({
 73+      assistantMessageId: "msg-final-message-persist",
 74+      conversationId: null,
 75+      observedAt: 1_710_000_020_000,
 76+      platform: "chatgpt",
 77+      source: "browser.final_message",
 78+      text: messageText
 79+    });
 80+
 81+    assert.equal(firstPass.summary.status, "executed");
 82+    assert.equal(readFileSync(outputPath, "utf8"), "persisted-live\n");
 83+
 84+    firstFixture.controlPlane.close();
 85+    firstFixture = null;
 86+
 87+    restartedControlPlane = new ConductorLocalControlPlane({
 88+      databasePath
 89+    });
 90+    await restartedControlPlane.initialize();
 91+
 92+    const restartedIngest = buildPersistentIngest(
 93+      restartedControlPlane.repository,
 94+      "local-shared-token",
 95+      {
 96+        codexd: {
 97+          localApiBase: null
 98+        },
 99+        controlApi: {
100+          baseUrl: "https://control.example.test",
101+          firefoxWsUrl: "ws://127.0.0.1:4317/ws/firefox",
102+          hasSharedToken: true,
103+          localApiBase: "http://127.0.0.1:4317",
104+          usesPlaceholderToken: false
105+        },
106+        daemon: {
107+          currentLeaderId: "mini-main",
108+          currentTerm: 1,
109+          host: "mini",
110+          lastError: null,
111+          leaseExpiresAt: 130,
112+          leaseState: "leader",
113+          nodeId: "mini-main",
114+          role: "primary",
115+          schedulerEnabled: true
116+        },
117+        identity: "mini-main@mini(primary)",
118+        runtime: {
119+          pid: 123,
120+          started: true,
121+          startedAt: 100
122+        },
123+        warnings: []
124+      }
125+    );
126+
127+    await restartedIngest.initialize();
128+    assert.equal(restartedIngest.getSnapshot().recent_ingests[0].status, "executed");
129+    assert.equal(restartedIngest.getSnapshot().recent_executes[0].status, "executed");
130+
131+    nowMs = 1_710_000_020_500;
132+
133+    const replayPass = await restartedIngest.ingestAssistantFinalMessage({
134+      assistantMessageId: "msg-final-message-persist",
135+      conversationId: "conv-replayed",
136+      observedAt: 1_710_000_020_500,
137+      platform: "chatgpt",
138+      source: "browser.final_message",
139+      text: messageText
140+    });
141+
142+    assert.equal(replayPass.summary.status, "duplicate_message");
143+    assert.equal(readFileSync(outputPath, "utf8"), "persisted-live\n");
144+    assert.equal(restartedIngest.getSnapshot().recent_ingests[0].status, "duplicate_message");
145+    assert.equal(restartedIngest.getSnapshot().recent_ingests[1].status, "executed");
146+    assert.equal(restartedIngest.getSnapshot().recent_executes[0].status, "executed");
147+
148+    restartedControlPlane.close();
149+    restartedControlPlane = null;
150+
151+    runtime = new ConductorRuntime(
152+      {
153+        nodeId: "mini-main",
154+        host: "mini",
155+        role: "primary",
156+        controlApiBase: "https://control.example.test",
157+        localApiBase: "http://127.0.0.1:0",
158+        sharedToken: "replace-me",
159+        paths: {
160+          runsDir: "/tmp/runs",
161+          stateDir
162+        }
163+      },
164+      {
165+        autoStartLoops: false,
166+        now: () => 100
167+      }
168+    );
169+
170+    const runtimeSnapshot = await runtime.start();
171+    const browserStatus = await fetchJson(`${runtimeSnapshot.controlApi.localApiBase}/v1/browser`);
172+
173+    assert.equal(browserStatus.response.status, 200);
174+    assert.equal(browserStatus.payload.data.instruction_ingest.last_ingest.status, "duplicate_message");
175+    assert.equal(browserStatus.payload.data.instruction_ingest.last_execute.status, "executed");
176+    assert.equal(browserStatus.payload.data.instruction_ingest.recent_ingests[0].status, "duplicate_message");
177+    assert.equal(browserStatus.payload.data.instruction_ingest.recent_ingests[1].status, "executed");
178+    assert.equal(browserStatus.payload.data.instruction_ingest.recent_executes[0].status, "executed");
179+  } finally {
180+    restartedControlPlane?.close();
181+    firstFixture?.controlPlane.close();
182+
183+    if (runtime != null) {
184+      await runtime.stop();
185+    }
186+
187+    rmSync(stateDir, {
188+      force: true,
189+      recursive: true
190+    });
191+    rmSync(hostOpsDir, {
192+      force: true,
193+      recursive: true
194+    });
195+  }
196+});
197+
198 test("ConductorRuntime exposes /v1/browser Claude HTTP routes over the local Firefox bridge", async () => {
199   const stateDir = mkdtempSync(join(tmpdir(), "baa-conductor-browser-http-"));
200   const runtime = new ConductorRuntime(

  1@@ -5,7 +5,10 @@ import {
  2   type ServerResponse
  3 } from "node:http";
  4 import type { AddressInfo } from "node:net";
  5-import type { ControlPlaneRepository } from "../../../packages/db/dist/index.js";
  6+import {
  7+  DEFAULT_BAA_EXECUTION_JOURNAL_LIMIT,
  8+  type ControlPlaneRepository
  9+} from "../../../packages/db/dist/index.js";
 10 
 11 import {
 12   type ConductorHttpRequest,
 13@@ -19,8 +22,15 @@ import {
 14   BrowserRequestPolicyController,
 15   type BrowserRequestPolicyControllerOptions
 16 } from "./browser-request-policy.js";
 17+import type { BrowserBridgeController } from "./browser-types.js";
 18 import type { FirefoxBridgeService } from "./firefox-bridge.js";
 19 import { BaaLiveInstructionIngest } from "./instructions/ingest.js";
 20+import { BaaInstructionCenter } from "./instructions/loop.js";
 21+import {
 22+  PersistentBaaInstructionDeduper,
 23+  PersistentBaaLiveInstructionMessageDeduper,
 24+  PersistentBaaLiveInstructionSnapshotStore
 25+} from "./instructions/store.js";
 26 import { handleConductorHttpRequest as handleConductorLocalHttpRequest } from "./local-api.js";
 27 import { ConductorLocalControlPlane } from "./local-control-plane.js";
 28 
 29@@ -32,8 +42,11 @@ export {
 30   type FirefoxBridgeApiResponse,
 31   type FirefoxBridgeCommandTarget,
 32   type FirefoxBridgeDispatchReceipt,
 33+  type FirefoxInjectMessageCommandInput,
 34   type FirefoxOpenTabCommandInput,
 35   type FirefoxReloadCommandInput,
 36+  type FirefoxSendMessageCommandInput,
 37+  type FirefoxUploadArtifactsCommandInput,
 38   type FirefoxRequestCredentialsCommandInput
 39 } from "./firefox-bridge.js";
 40 export {
 41@@ -680,6 +693,7 @@ class ConductorLocalHttpServer {
 42   private readonly codexdLocalApiBase: string | null;
 43   private readonly fetchImpl: typeof fetch;
 44   private readonly firefoxWebSocketServer: ConductorFirefoxWebSocketServer;
 45+  private readonly instructionIngest: BaaLiveInstructionIngest;
 46   private readonly localApiBase: string;
 47   private readonly now: () => number;
 48   private readonly repository: ControlPlaneRepository;
 49@@ -710,17 +724,32 @@ class ConductorLocalHttpServer {
 50     this.snapshotLoader = snapshotLoader;
 51     this.version = version;
 52     this.resolvedBaseUrl = localApiBase;
 53+    const nowMs = () => this.now() * 1000;
 54+    const localApiContext = {
 55+      fetchImpl: this.fetchImpl,
 56+      now: this.now,
 57+      repository: this.repository,
 58+      sharedToken: this.sharedToken,
 59+      snapshotLoader: this.snapshotLoader,
 60+      version: this.version
 61+    };
 62     const instructionIngest = new BaaLiveInstructionIngest({
 63+      center: new BaaInstructionCenter({
 64+        deduper: new PersistentBaaInstructionDeduper(this.repository, nowMs),
 65+        localApiContext
 66+      }),
 67+      historyLimit: DEFAULT_BAA_EXECUTION_JOURNAL_LIMIT,
 68       localApiContext: {
 69-        fetchImpl: this.fetchImpl,
 70-        now: this.now,
 71-        repository: this.repository,
 72-        sharedToken: this.sharedToken,
 73-        snapshotLoader: this.snapshotLoader,
 74-        version: this.version
 75+        ...localApiContext
 76       },
 77-      now: () => this.now() * 1000
 78+      messageDeduper: new PersistentBaaLiveInstructionMessageDeduper(this.repository, nowMs),
 79+      now: nowMs,
 80+      snapshotStore: new PersistentBaaLiveInstructionSnapshotStore(
 81+        this.repository,
 82+        DEFAULT_BAA_EXECUTION_JOURNAL_LIMIT
 83+      )
 84     });
 85+    this.instructionIngest = instructionIngest;
 86     this.firefoxWebSocketServer = new ConductorFirefoxWebSocketServer({
 87       baseUrlLoader: () => this.resolvedBaseUrl,
 88       instructionIngest,
 89@@ -747,6 +776,8 @@ class ConductorLocalHttpServer {
 90       return this.resolvedBaseUrl;
 91     }
 92 
 93+    await this.instructionIngest.initialize();
 94+
 95     const listenConfig = resolveLocalApiListenConfig(this.localApiBase);
 96     const server = createServer((request, response) => {
 97       void (async () => {
 98@@ -774,7 +805,9 @@ class ConductorLocalHttpServer {
 99             signal: requestAbortController.signal
100           },
101           {
102-            browserBridge: this.firefoxWebSocketServer.getBridgeService(),
103+            artifactDelivery: this.firefoxWebSocketServer.getDeliveryBridge(),
104+            browserBridge:
105+              this.firefoxWebSocketServer.getBridgeService() as unknown as BrowserBridgeController,
106             browserRequestPolicy: this.browserRequestPolicy,
107             browserStateLoader: () => this.firefoxWebSocketServer.getStateSnapshot(),
108             codexdLocalApiBase: this.codexdLocalApiBase,