@agentconnect.md/daemon 1.0.0-rc.282 → 1.0.0-rc.284

package/dist/{run-foreground-BV2scayf.js → run-foreground-D_sn_AMV.js}

@@ -5,7 +5,7 @@ import { t as DAEMON_VERSION } from "./version-DGaRXjBK.js";
 import { C as _coercedNumber, T as NEVER, a as array, d as literal, f as looseObject, i as any, m as object, o as boolean, p as number$1, t as ZodNumber, v as string, x as url$4 } from "./schemas-CQkO9hC5.js";
 import { C as ZodIssueCode, S as RESERVED_MCP_SERVER_NAME, _ as buildEnvelope, a as agentChildEnv, b as MAX_FRAME_BYTES, c as persistRelays, d as normalizeGitUrl, f as RELAY_DAEMON_SUBPROTOCOL, g as SHARED_CONFIG_ACTION_ID, h as decodeRelayDaemonFrame, i as selectAgent, m as buildRelayDaemonFrame, n as findAgentFiles, o as loadConfig, p as RELAY_DAEMON_WS_PATH, r as loadAgents, s as persistDaemonId, v as decodeEnvelope, y as encode } from "./load-agents-DzCnR0cj.js";
 import { l as resolveRoot, o as mcpSocketPath, u as statePath } from "./paths-DEcUO8lC.js";
-import { S as resolveRuntimes, _ as writeMemoryFile, a as initGitInjection, b as cachedRuntimeNames, c as simpleGit, d as memoryProviderFor, f as MemoryConflictError, g as resolveInMemoryDir, h as listMemory, i as prepareWorkspace, l as createMemoryProvider, m as MemoryTooLargeError, n as installedRuntimes, o as probeGitVersion, p as MemoryPathError, r as prefetchWorkspace, s as sessionGitEnv, t as AcpHost, u as memoryKindOf, v as MEMORY_TOOL_NAMES, x as cachedRuntimeVersions, y as toolsForIntegrations } from "./acp-host-C-4zFhF8.js";
+import { S as resolveRuntimes, _ as writeMemoryFile, a as initGitInjection, b as cachedRuntimeNames, c as simpleGit, d as memoryProviderFor, f as MemoryConflictError, g as resolveInMemoryDir, h as listMemory, i as prepareWorkspace, l as createMemoryProvider, m as MemoryTooLargeError, n as installedRuntimes, o as probeGitVersion, p as MemoryPathError, r as prefetchWorkspace, s as sessionGitEnv, t as AcpHost, u as memoryKindOf, v as MEMORY_TOOL_NAMES, x as cachedRuntimeVersions, y as toolsForIntegrations } from "./acp-host-CDuL4q1C.js";
 import { i as GitCredentialCache, n as gitcredSocketPath, r as writeGitcredShim, t as GitCredServer } from "./gitcred-server-CMC80O_1.js";
 import { B as ToolListChangedNotificationSchema, D as ListPromptsResultSchema, E as ListChangedOptionsBaseSchema, F as PromptListChangedNotificationSchema, G as isZ4Schema, H as isJSONRPCRequest, I as ReadResourceResultSchema, J as encodeFrame, K as safeParse, L as ResourceListChangedNotificationSchema, M as ListToolsResultSchema, O as ListResourceTemplatesResultSchema, P as McpError, R as SUPPORTED_PROTOCOL_VERSIONS, S as InitializeResultSchema, T as LATEST_PROTOCOL_VERSION, U as isJSONRPCResultResponse, V as isInitializedNotification, W as getObjectShape, _ as ElicitResultSchema, a as AjvJsonSchemaValidator, b as GetPromptResultSchema, c as mergeCapabilities, d as CompleteResultSchema, f as CreateMessageRequestSchema, g as ElicitRequestSchema, h as CreateTaskResultSchema, i as assertToolsCallTaskCapability, k as ListResourcesResultSchema, m as CreateMessageResultWithToolsSchema, n as serializeMessage, o as require_fast_deep_equal, p as CreateMessageResultSchema, q as decodeFrames, r as assertClientRequestTaskCapability, s as Protocol, t as ReadBuffer, u as CallToolResultSchema, v as EmptyResultSchema, w as JSONRPCMessageSchema, y as ErrorCode } from "./stdio-DnS8WcXi.js";
 import { URL as URL$1 } from "url";
@@ -6373,6 +6373,68 @@ var LocalStore = class {
       CREATE TABLE IF NOT EXISTS cron_runs (
         key TEXT PRIMARY KEY, lastRunAt INTEGER NOT NULL
       );
+      -- §6.9 #353 durable inbox: an ADMITTED-but-QUEUED message persisted BEFORE the
+      -- admission ACK, so a hard kill / agent move can't lose a message the caller was
+      -- already told delivered:true. Replayed FIFO-by-sessionKey on startup and removed
+      -- on every terminal path (success / reject / cancel / gate-drop). The id column is the
+      -- message's STABLE deliveryId/msgId (§6.3) so re-append and replay are idempotent
+      -- against the existing admission-idempotency maps. Webchat turns are NOT persisted
+      -- here (their live sink can't be restored — see §6.9 #367). enqueuedAt is a
+      -- monotonic decimal string (fixed-width ⇒ string order == numeric order) driving
+      -- FIFO within a sessionKey.
+      CREATE TABLE IF NOT EXISTS inbox (
+        id TEXT PRIMARY KEY,
+        sessionKey TEXT NOT NULL,
+        agentId TEXT NOT NULL,
+        msg TEXT NOT NULL,
+        integrationId TEXT,
+        callMeta TEXT,
+        isQueueCmd INTEGER,
+        enqueuedAt TEXT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS inbox_fifo ON inbox (sessionKey, enqueuedAt);
+      -- §3.4/§6.8 main-agent orchestration: a main agent fans out N subtasks to
+      -- worker agents, then waits asynchronously and summarizes. The record is
+      -- persisted BEFORE any delivery (record-first — a fast worker's reply must
+      -- never arrive before the record exists, else §3.3 correlation drops it).
+      -- daemon-local (never on the CP hot path); the deadline epoch is the durable
+      -- SoT for the one-shot cron re-armed on startup. status: active|done|cancelled.
+      CREATE TABLE IF NOT EXISTS orchestration (
+        orchestrationId TEXT PRIMARY KEY,
+        mainSessionKey TEXT NOT NULL,
+        mainAgentId TEXT NOT NULL,
+        -- The main's session coords, stored explicitly (not parsed from mainSessionKey,
+        -- whose channel/thread may contain ':') so the deadline fire wakes the exact session.
+        platform TEXT NOT NULL,
+        channel TEXT NOT NULL,
+        thread TEXT NOT NULL,
+        integrationId TEXT,
+        replyTarget TEXT,
+        deadline INTEGER,
+        status TEXT NOT NULL,
+        createdAt INTEGER NOT NULL,
+        updatedAt INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS orchestration_active ON orchestration (status);
+      -- One row per subtask. Stable correlationId = "<orchestrationId>.<idx>" is the
+      -- delivery/report correlation key (§3.3). State machine (§6.8):
+      --   pending → sending → delivered → succeeded | worker_error | timed_out
+      -- busy/offline are RETRYABLE attempt states folded back to a delivery failure.
+      -- Transitions are CAS + idempotent on (orchestrationId, correlationId).
+      CREATE TABLE IF NOT EXISTS orchestration_subtask (
+        orchestrationId TEXT NOT NULL,
+        correlationId TEXT NOT NULL,
+        idx INTEGER NOT NULL,
+        toAgentId TEXT NOT NULL,
+        text TEXT NOT NULL,
+        status TEXT NOT NULL,
+        result TEXT,
+        deliveryReason TEXT,
+        updatedAt TEXT NOT NULL,
+        PRIMARY KEY (orchestrationId, correlationId)
+      );
+      CREATE INDEX IF NOT EXISTS orchestration_subtask_by_orch
+        ON orchestration_subtask (orchestrationId, idx);
     `);
 		this.migrateSessionUsage();
 		this.migrateTranscriptToolBody();
@@ -6727,6 +6789,125 @@ var LocalStore = class {
 	getCronLastRun(key) {
 		return this.db.prepare("SELECT lastRunAt FROM cron_runs WHERE key = ?").get(key)?.lastRunAt;
 	}
+	/** §6.9 #353 durable inbox: persist an admitted message BEFORE its admission ACK. Keyed
+	*  by the stable id (deliveryId/msgId) with INSERT OR IGNORE, so a re-append of the same
+	*  delivery (P2 retry / replay) is a no-op — idempotent against the admission maps. */
+	appendInbox(row) {
+		this.db.prepare(`INSERT OR IGNORE INTO inbox (id, sessionKey, agentId, msg, integrationId, callMeta, isQueueCmd, enqueuedAt)
+         VALUES (@id, @sessionKey, @agentId, @msg, @integrationId, @callMeta, @isQueueCmd, @enqueuedAt)`).run({
+			id: row.id,
+			sessionKey: row.sessionKey,
+			agentId: row.agentId,
+			msg: row.msg,
+			integrationId: row.integrationId ?? null,
+			callMeta: row.callMeta ?? null,
+			isQueueCmd: row.isQueueCmd ?? null,
+			enqueuedAt: row.enqueuedAt
+		});
+	}
+	/** Remove an inbox row once its turn reaches a terminal state (success / reject / cancel /
+	*  gate-drop) so it is never replayed. No-op on an unknown id. */
+	removeInbox(id) {
+		this.db.prepare("DELETE FROM inbox WHERE id = ?").run(id);
+	}
+	/** All pending inbox rows, ordered FIFO-by-sessionKey (sessionKey, then enqueuedAt) for
+	*  startup replay (§6.9 #353). Order within a sessionKey is preserved by `enqueuedAt`. */
+	listInboxBySessionKeyFifo() {
+		return this.db.prepare("SELECT * FROM inbox ORDER BY sessionKey ASC, enqueuedAt ASC").all();
+	}
+	/**
+	* RECORD-FIRST (§3.4): persist the orchestration header + all subtask rows (status
+	* 'pending') in ONE transaction, BEFORE any delivery. A fast worker's reply that
+	* arrives before this returns has nothing to correlate against and is dropped — so
+	* this MUST complete before startOrchestration delivers anything. Idempotent via
+	* INSERT OR IGNORE on the stable ids (replay-safe).
+	*/
+	createOrchestration(orch, subtasks) {
+		const insertOrch = this.db.prepare(`INSERT OR IGNORE INTO orchestration
+         (orchestrationId, mainSessionKey, mainAgentId, platform, channel, thread,
+          integrationId, replyTarget, deadline, status, createdAt, updatedAt)
+       VALUES (@orchestrationId, @mainSessionKey, @mainAgentId, @platform, @channel, @thread,
+          @integrationId, @replyTarget, @deadline, @status, @createdAt, @updatedAt)`);
+		const insertSub = this.db.prepare(`INSERT OR IGNORE INTO orchestration_subtask
+         (orchestrationId, correlationId, idx, toAgentId, text, status, result, deliveryReason, updatedAt)
+       VALUES (@orchestrationId, @correlationId, @idx, @toAgentId, @text, @status, @result, @deliveryReason, @updatedAt)`);
+		this.db.exec("BEGIN");
+		try {
+			insertOrch.run({
+				orchestrationId: orch.orchestrationId,
+				mainSessionKey: orch.mainSessionKey,
+				mainAgentId: orch.mainAgentId,
+				platform: orch.platform,
+				channel: orch.channel,
+				thread: orch.thread,
+				integrationId: orch.integrationId ?? null,
+				replyTarget: orch.replyTarget ?? null,
+				deadline: orch.deadline ?? null,
+				status: orch.status,
+				createdAt: orch.createdAt,
+				updatedAt: orch.updatedAt
+			});
+			for (const s of subtasks) insertSub.run({
+				orchestrationId: s.orchestrationId,
+				correlationId: s.correlationId,
+				idx: s.idx,
+				toAgentId: s.toAgentId,
+				text: s.text,
+				status: s.status,
+				result: s.result ?? null,
+				deliveryReason: s.deliveryReason ?? null,
+				updatedAt: s.updatedAt
+			});
+			this.db.exec("COMMIT");
+		} catch (err) {
+			this.db.exec("ROLLBACK");
+			throw err;
+		}
+	}
+	getOrchestration(orchestrationId) {
+		return this.db.prepare("SELECT * FROM orchestration WHERE orchestrationId = ?").get(orchestrationId);
+	}
+	getSubtasks(orchestrationId) {
+		return this.db.prepare("SELECT * FROM orchestration_subtask WHERE orchestrationId = ? ORDER BY idx ASC").all(orchestrationId);
+	}
+	getSubtaskByCorrelation(orchestrationId, correlationId) {
+		return this.db.prepare("SELECT * FROM orchestration_subtask WHERE orchestrationId = ? AND correlationId = ?").get(orchestrationId, correlationId);
+	}
+	/** All still-`active` orchestrations — for startup re-arm of deadlines + re-drive
+	*  of non-terminal subtasks (§6.8). */
+	listActiveOrchestrations() {
+		return this.db.prepare("SELECT * FROM orchestration WHERE status = 'active' ORDER BY createdAt ASC").all();
+	}
+	/** CAS subtask status — only advances when the current status is one of `from`.
+	*  Idempotent + monotonic: a stale/duplicate transition (current status not in
+	*  `from`) is a no-op and returns false. */
+	setSubtaskStatus(orchestrationId, correlationId, from, to, updatedAt, extra) {
+		const placeholders = from.map((_, i) => `@from${i}`).join(", ");
+		const params = {
+			orchestrationId,
+			correlationId,
+			to,
+			updatedAt
+		};
+		from.forEach((f, i) => params[`from${i}`] = f);
+		let setResult = "";
+		if (extra && "result" in extra) {
+			setResult += ", result=@result";
+			params.result = extra.result ?? null;
+		}
+		if (extra && "deliveryReason" in extra) {
+			setResult += ", deliveryReason=@deliveryReason";
+			params.deliveryReason = extra.deliveryReason ?? null;
+		}
+		return this.db.prepare(`UPDATE orchestration_subtask SET status=@to, updatedAt=@updatedAt${setResult}
+         WHERE orchestrationId=@orchestrationId AND correlationId=@correlationId AND status IN (${placeholders})`).run(params).changes > 0;
+	}
+	setOrchestrationStatus(orchestrationId, status, updatedAt) {
+		this.db.prepare("UPDATE orchestration SET status=?, updatedAt=? WHERE orchestrationId=?").run(status, updatedAt, orchestrationId);
+	}
+	setOrchestrationDeadline(orchestrationId, deadline, updatedAt) {
+		this.db.prepare("UPDATE orchestration SET deadline=?, updatedAt=? WHERE orchestrationId=?").run(deadline, updatedAt, orchestrationId);
+	}
 	close() {
 		this.db.close();
 	}
@@ -7128,6 +7309,8 @@ async function executeTool(ctx, name, args, deps) {
 		return await deps.messageAgent({
 			callerAgentId: ctx.agentId,
 			platform: ctx.platform,
+			callerChannel: ctx.channel,
+			callerThread: ctx.thread,
 			toAgentId,
 			text,
 			channel,
@@ -7135,6 +7318,50 @@ async function executeTool(ctx, name, args, deps) {
 			...correlationId !== void 0 ? { correlationId } : {}
 		});
 	}
+	if (name === "startOrchestration") {
+		const rawSubtasks = args.subtasks;
+		if (!Array.isArray(rawSubtasks) || rawSubtasks.length === 0) throw new Error("missing required argument: subtasks (non-empty array)");
+		const subtasks = rawSubtasks.map((s, i) => {
+			if (typeof s !== "object" || s === null) throw new Error(`subtasks[${i}] must be an object`);
+			const so = s;
+			return {
+				toAgentId: requireString(so, "toAgentId"),
+				text: requireString(so, "text")
+			};
+		});
+		const deadlineMs = optionalNumber(args, "deadlineMs");
+		const replyTarget = optionalString(args, "replyTarget");
+		return await deps.startOrchestration({
+			mainAgentId: ctx.agentId,
+			platform: ctx.platform,
+			channel: ctx.channel,
+			thread: ctx.thread,
+			...ctx.integrationId !== void 0 ? { integrationId: ctx.integrationId } : {},
+			subtasks,
+			...deadlineMs !== void 0 ? { deadlineMs } : {},
+			...replyTarget !== void 0 ? { replyTarget } : {}
+		});
+	}
+	if (name === "getOrchestration" || name === "cancelOrchestration") {
+		const orchestrationId = requireString(args, "orchestrationId");
+		const req = {
+			mainAgentId: ctx.agentId,
+			platform: ctx.platform,
+			channel: ctx.channel,
+			thread: ctx.thread,
+			orchestrationId
+		};
+		if (name === "getOrchestration") {
+			const rec = await deps.getOrchestration(req);
+			if (rec === null) throw new Error(`no orchestration ${orchestrationId} owned by this session`);
+			return rec;
+		}
+		if (!await deps.cancelOrchestration(req)) throw new Error(`no orchestration ${orchestrationId} owned by this session`);
+		return {
+			orchestrationId,
+			cancelled: true
+		};
+	}
 	const gw = ctx.integrationId ? deps.gatewayFor(ctx.integrationId) : void 0;
 	if (!gw) throw new Error(`no live platform connection for integration ${ctx.integrationId ?? "(none)"}`);
 	switch (name) {
@@ -7215,6 +7442,12 @@ function optionalString(args, key) {
 	if (typeof v !== "string") throw new Error(`argument ${key} must be a string`);
 	return v;
 }
+function optionalNumber(args, key) {
+	const v = args[key];
+	if (v === void 0 || v === null) return void 0;
+	if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`argument ${key} must be a finite number`);
+	return v;
+}
 //#endregion
 //#region src/mcp/control-server.ts
 /**
@@ -214181,6 +214414,9 @@ var Daemon = class Daemon {
 				return client.channelAgents(req);
 			},
 			messageAgent: (req) => this.messageAgent(req),
+			startOrchestration: (req) => this.startOrchestration(req),
+			getOrchestration: (req) => Promise.resolve(this.getOrchestrationForOwner(req)),
+			cancelOrchestration: (req) => Promise.resolve(this.cancelOrchestrationForOwner(req)),
 			memory: this.memory,
 			recordOutbound: (ctx, channel, thread, text, ts) => this.store.appendTranscript({
 				channel,
@@ -214295,6 +214531,8 @@ var Daemon = class Daemon {
 		};
 		this.watcher.on("add", debounced).on("change", debounced).on("unlink", debounced);
 		this.log.info(`watching ${this.agentsDir} for agent changes`);
+		this.replayInbox();
+		this.rearmOrchestrationDeadlines();
 		this.startCpClient(root);
 		this.armIdleSweep();
 		this.log.info("daemon ready");
@@ -215058,6 +215296,7 @@ var Daemon = class Daemon {
 	}
 	relayMsgAcks = /* @__PURE__ */ new Map();
 	agentCallDeliveries = /* @__PURE__ */ new Map();
+	orchestrationDeadlines = /* @__PURE__ */ new Map();
 	/**
 	* Dispatch one inbound relay item (`rd/msg` — a webchat op or a hook fire) and
 	* return the `rd/ack` verdict — the relay-path entry, reusing the SAME turn
@@ -215225,10 +215464,19 @@ var Daemon = class Daemon {
 				reason: "not_allowed"
 			});
 		}
-		const hopCount = 0;
+		const callerKey = sessionKey(platform, req.callerChannel, req.callerThread, req.callerAgentId);
+		const inbound = this.activeTurnCallMeta.get(callerKey);
+		const hopCount = inbound ? inbound.hopCount + 1 : 0;
+		if (hopCount > MAX_AGENT_CALL_HOPS) return record({
+			delivered: false,
+			targetSession,
+			reason: "hop_limit"
+		});
+		const isReply = inbound !== void 0 && req.toAgentId === inbound.callFrom;
+		const correlationId = req.correlationId !== void 0 ? req.correlationId : isReply ? inbound.correlationId : void 0;
 		const callMeta = {
 			callFrom: req.callerAgentId,
-			...req.correlationId !== void 0 ? { correlationId: req.correlationId } : {},
+			...correlationId !== void 0 ? { correlationId } : {},
 			hopCount,
 			deliveryId
 		};
@@ -215311,6 +215559,235 @@ var Daemon = class Daemon {
 		return p === "telegram" || p === "webchat" || p === "discord" || p === "hook" ? p : "slack";
 	}
 	/**
+	* Start an orchestration (§3.4/§6.8). ATOMIC ordering per §3.4:
+	*   (a) RECORD-FIRST — persist the orchestration header + every subtask (status
+	*       'pending') in one transaction BEFORE any delivery, so a fast worker's reply can
+	*       never arrive before the record exists (§3.3 would otherwise drop it);
+	*   (b) deliver each subtask via the existing `messageAgent` path, CAS-recording
+	*       pending→sending→delivered | pending→sending→(delivered rollback)failed per subtask;
+	*   (c) schedule the one-shot, session-anchored, cancelable cron deadline (if requested)
+	*       — but only when at least one subtask actually delivered (all-failed ⇒ no wait).
+	* The main identity + coords are the TRUSTED SessionContext (never tool input).
+	*/
+	async startOrchestration(req) {
+		const orchestrationId = randomUUID();
+		const platform = this.narrowPlatform(req.platform);
+		const mainSessionKey = sessionKey(platform, req.channel, req.thread, req.mainAgentId);
+		const now = this.clock.now();
+		const deadline = req.deadlineMs !== void 0 && req.deadlineMs > 0 ? now + Math.min(req.deadlineMs, 2147483647) : null;
+		const subtaskRows = req.subtasks.map((s, idx) => ({
+			orchestrationId,
+			correlationId: `${orchestrationId}.${idx}`,
+			idx,
+			toAgentId: s.toAgentId,
+			text: s.text,
+			status: "pending",
+			updatedAt: monotonicTs()
+		}));
+		const orch = {
+			orchestrationId,
+			mainSessionKey,
+			mainAgentId: req.mainAgentId,
+			platform,
+			channel: req.channel,
+			thread: req.thread,
+			integrationId: req.integrationId ?? null,
+			replyTarget: req.replyTarget ?? null,
+			deadline,
+			status: "active",
+			createdAt: now,
+			updatedAt: now
+		};
+		this.store.createOrchestration(orch, subtaskRows);
+		const delivered = [];
+		const failed = [];
+		for (const s of subtaskRows) {
+			this.store.setSubtaskStatus(orchestrationId, s.correlationId, ["pending"], "sending", monotonicTs());
+			let result;
+			try {
+				result = await this.messageAgent({
+					callerAgentId: req.mainAgentId,
+					platform: req.platform,
+					callerChannel: req.channel,
+					callerThread: req.thread,
+					toAgentId: s.toAgentId,
+					text: s.text,
+					channel: req.channel,
+					thread: req.thread,
+					correlationId: s.correlationId
+				});
+			} catch (err) {
+				result = {
+					delivered: false,
+					targetSession: "",
+					reason: "error"
+				};
+				this.log.warn(`orchestration ${orchestrationId}: delivery of ${s.correlationId} threw: ${formatErr(err)}`);
+			}
+			if (result.delivered) {
+				this.store.setSubtaskStatus(orchestrationId, s.correlationId, ["sending"], "delivered", monotonicTs());
+				delivered.push(s.correlationId);
+			} else {
+				const reason = result.reason ?? "undeliverable";
+				this.store.setSubtaskStatus(orchestrationId, s.correlationId, ["sending"], "worker_error", monotonicTs(), { deliveryReason: reason });
+				failed.push({
+					correlationId: s.correlationId,
+					reason
+				});
+			}
+		}
+		if (deadline !== null && delivered.length > 0) this.armOrchestrationDeadline(orchestrationId, deadline);
+		else if (deadline !== null) this.store.setOrchestrationDeadline(orchestrationId, null, this.clock.now());
+		this.log.info(`orchestration ${orchestrationId}: ${delivered.length} delivered, ${failed.length} failed` + (deadline !== null && delivered.length > 0 ? `, deadline in ${deadline - now}ms` : ""));
+		return {
+			orchestrationId,
+			delivered,
+			failed
+		};
+	}
+	/** Arm (or re-arm) the one-shot, session-anchored deadline for an orchestration. On fire
+	*  it wakes the main's session DIRECTLY (dispatch to mainSessionKey) — NOT via fireTrigger
+	*  (which would post a channel anchor / open a new thread). Idempotent: replaces any
+	*  existing timer for this id. Clamped to setTimeout's 32-bit ceiling. */
+	armOrchestrationDeadline(orchestrationId, deadlineEpoch) {
+		const existing = this.orchestrationDeadlines.get(orchestrationId);
+		if (existing !== void 0) this.clock.clearTimeout(existing);
+		const delay = Math.min(Math.max(0, deadlineEpoch - this.clock.now()), 2147483647);
+		const handle = this.clock.setTimeout(() => {
+			this.orchestrationDeadlines.delete(orchestrationId);
+			this.fireOrchestrationDeadline(orchestrationId);
+		}, delay);
+		this.orchestrationDeadlines.set(orchestrationId, handle);
+	}
+	/** Deadline fired (§3.5): mark every still-open subtask timed_out, then WAKE the main's
+	*  session so it re-reads getOrchestration and summarizes the partial result. The wake is
+	*  a direct dispatch to the stored session coords — no platform post, no new thread. */
+	fireOrchestrationDeadline(orchestrationId) {
+		const orch = this.store.getOrchestration(orchestrationId);
+		if (!orch || orch.status !== "active") return;
+		for (const s of this.store.getSubtasks(orchestrationId)) this.store.setSubtaskStatus(orchestrationId, s.correlationId, [
+			"pending",
+			"sending",
+			"delivered"
+		], "timed_out", monotonicTs());
+		this.store.setOrchestrationDeadline(orchestrationId, null, this.clock.now());
+		this.wakeOrchestrationMain(orch, `orchestration ${orchestrationId} deadline reached — summarize what you have`);
+	}
+	/** Wake the orchestration's owning main session with a synthetic agent-source turn keyed
+	*  to the exact stored coords (so it lands in the same session that started it). Headless
+	*  is NOT set — the main needs its reply transport to post the summary. */
+	wakeOrchestrationMain(orch, text) {
+		const platform = this.narrowPlatform(orch.platform);
+		const msg = {
+			msgId: `orchestration:${orch.orchestrationId}:${monotonicTs()}`,
+			traceId: orch.orchestrationId,
+			source: "agent",
+			platform,
+			channel: orch.channel,
+			thread: orch.thread,
+			sender: {
+				id: `orchestration:${orch.orchestrationId}`,
+				isBot: true
+			},
+			text,
+			mentionedBots: [],
+			isDm: false
+		};
+		this.dispatch(orch.mainAgentId, msg, orch.integrationId ?? void 0).catch((err) => this.log.error(`orchestration ${orch.orchestrationId}: deadline wake dispatch failed: ${formatErr(err)}`));
+	}
+	/** §3.3 correlation-recording hook, called from dispatchOne when the MAIN receives a
+	*  messageAgent turn carrying a correlationId. Records the worker's result into the
+	*  orchestration ONLY if ALL four safety checks hold; any failure drops the report
+	*  (debug log) and never corrupts completion. Uses ONLY trusted values (callMeta.callFrom,
+	*  the receiving session key) — never a frame/prompt field. */
+	recordWorkerReport(receivingSessionKey, callMeta, reportText) {
+		const correlationId = callMeta.correlationId;
+		if (correlationId === void 0) return;
+		const dot = correlationId.lastIndexOf(".");
+		if (dot <= 0) return;
+		const orchestrationId = correlationId.slice(0, dot);
+		const orch = this.store.getOrchestration(orchestrationId);
+		if (!orch) return;
+		if (orch.mainSessionKey !== receivingSessionKey) {
+			this.log.debug(`orchestration ${orchestrationId}: report dropped — session mismatch`);
+			return;
+		}
+		if (orch.status !== "active") {
+			this.log.debug(`orchestration ${orchestrationId}: report dropped — orchestration ${orch.status}`);
+			return;
+		}
+		const sub = this.store.getSubtaskByCorrelation(orchestrationId, correlationId);
+		if (!sub) return;
+		if (callMeta.callFrom !== sub.toAgentId) {
+			this.log.debug(`orchestration ${orchestrationId}: report for ${correlationId} dropped — reporter "${callMeta.callFrom}" ≠ tasked worker "${sub.toAgentId}"`);
+			return;
+		}
+		if (this.store.setSubtaskStatus(orchestrationId, correlationId, [
+			"sending",
+			"delivered",
+			"timed_out"
+		], "succeeded", monotonicTs(), { result: reportText })) this.log.info(`orchestration ${orchestrationId}: recorded result for ${correlationId} from ${callMeta.callFrom}`);
+		else this.log.debug(`orchestration ${orchestrationId}: duplicate/late report for ${correlationId} — no-op`);
+	}
+	getOrchestrationForOwner(req) {
+		const orch = this.ownedOrchestration(req);
+		if (!orch) return null;
+		return {
+			orchestrationId: orch.orchestrationId,
+			status: orch.status,
+			deadline: orch.deadline ?? null,
+			replyTarget: orch.replyTarget ?? null,
+			createdAt: orch.createdAt,
+			subtasks: this.store.getSubtasks(orch.orchestrationId).map((s) => ({
+				correlationId: s.correlationId,
+				toAgentId: s.toAgentId,
+				status: s.status,
+				result: s.result ?? null,
+				...s.deliveryReason ? { deliveryReason: s.deliveryReason } : {}
+			}))
+		};
+	}
+	cancelOrchestrationForOwner(req) {
+		const orch = this.ownedOrchestration(req);
+		if (!orch) return false;
+		const handle = this.orchestrationDeadlines.get(orch.orchestrationId);
+		if (handle !== void 0) {
+			this.clock.clearTimeout(handle);
+			this.orchestrationDeadlines.delete(orch.orchestrationId);
+		}
+		this.store.setOrchestrationDeadline(orch.orchestrationId, null, this.clock.now());
+		this.store.setOrchestrationStatus(orch.orchestrationId, "cancelled", this.clock.now());
+		return true;
+	}
+	/** Resolve an orchestration IFF the requesting main+session OWNS it (§3.5a owner check).
+	*  Returns undefined on unknown id or any owner mismatch. */
+	ownedOrchestration(req) {
+		const orch = this.store.getOrchestration(req.orchestrationId);
+		if (!orch) return void 0;
+		const requesterKey = sessionKey(this.narrowPlatform(req.platform), req.channel, req.thread, req.mainAgentId);
+		if (orch.mainSessionKey !== requesterKey || orch.mainAgentId !== req.mainAgentId) return void 0;
+		return orch;
+	}
+	/** Startup re-arm (§3.5): re-arm the one-shot deadline for every still-active orchestration
+	*  from the durable `deadline` epoch. A deadline already in the past fires ~immediately.
+	*  Mirrors replayInbox's read-active-rows/re-schedule pattern; idempotent. */
+	rearmOrchestrationDeadlines() {
+		let active;
+		try {
+			active = this.store.listActiveOrchestrations();
+		} catch (err) {
+			this.log.warn(`orchestration: deadline re-arm read failed: ${err.message}`);
+			return;
+		}
+		let armed = 0;
+		for (const orch of active) {
+			if (orch.deadline == null) continue;
+			this.armOrchestrationDeadline(orch.orchestrationId, orch.deadline);
+			armed++;
+		}
+		if (armed) this.log.info(`orchestration: re-armed ${armed} deadline(s) on startup`);
+	}
+	/**
 	* Ack-verdict gate for one hook fire (`rd/msg` hook member) — the mirror of
 	* {@link dispatchWebchatTurn}'s synchronous gates: the relay's rc/run-report
 	* needs a REASONED rejection now, not a silently dropped fire-and-forget
@@ -215537,6 +216014,10 @@ var Daemon = class Daemon {
 	}
 	inflight = /* @__PURE__ */ new Set();
 	serialQueue = /* @__PURE__ */ new Map();
+	/** §6.9 #353: stable ids of messages currently backed by a durable inbox row (admitted,
+	*  not yet terminal). Guards startup replay from re-admitting a row whose entry is already
+	*  live in the gate (idempotency — a duplicate/in-flight id is not double-processed). */
+	liveInboxIds = /* @__PURE__ */ new Set();
 	/**
 	* Resolve a command's target from the channel's latest session when the routing ladder
 	* couldn't (no mention entity / thread / dm rule matched — e.g. a group `/status@bot`).
@@ -215868,6 +216349,49 @@ var Daemon = class Daemon {
 		}
 	}
 	/**
+	* §6.9 #353 durable inbox: persist an ADMITTED entry BEFORE its admission ACK/return, so a
+	* hard kill / agent move can't lose a message the caller was already told delivered:true.
+	* Called ONLY on the two genuine admission branches in dispatch() (claim + enqueue), never
+	* on a rejected/gate-dropped admission — a queue-full or paused/draining drop persists
+	* nothing. WEBCHAT turns are skipped (§6.9 #367): their `sink` is a live in-memory transport
+	* that can't be restored across a restart and a dead browser socket can't be resumed, so a
+	* durable row would be un-replayable. Sets `entry.inboxId` so every terminal path can delete
+	* the row. The row id is the message's stable deliveryId/msgId (§6.3) — idempotent re-append.
+	*/
+	persistInbox(entry, key) {
+		if (entry.webchat) return;
+		const id = entry.callMeta?.deliveryId ?? entry.msg.msgId;
+		try {
+			this.store.appendInbox({
+				id,
+				sessionKey: key,
+				agentId: entry.agentId,
+				msg: JSON.stringify(entry.msg),
+				integrationId: entry.integrationId ?? null,
+				callMeta: entry.callMeta ? JSON.stringify(entry.callMeta) : null,
+				isQueueCmd: entry.isQueueCmd ? 1 : null,
+				enqueuedAt: monotonicTs()
+			});
+			entry.inboxId = id;
+			this.liveInboxIds.add(id);
+		} catch (err) {
+			this.log.warn(`durable inbox: append failed for ${id}: ${err.message}`);
+		}
+	}
+	/** Remove an entry's durable inbox row once its turn reaches ANY terminal state (success,
+	*  reject/fail-stop, cancel, gate-drop) so it is not replayed on the next startup. No-op
+	*  for a non-persisted entry (webchat / never-admitted). NOT called on graceful-shutdown
+	*  settle: those admitted-but-unrun rows are intentionally LEFT for startup replay. */
+	removeInbox(entry) {
+		if (!entry.inboxId) return;
+		this.liveInboxIds.delete(entry.inboxId);
+		try {
+			this.store.removeInbox(entry.inboxId);
+		} catch (err) {
+			this.log.warn(`durable inbox: remove failed for ${entry.inboxId}: ${err.message}`);
+		}
+	}
+	/**
 	* Terminate a QUEUED entry's webchat sink when it is gate-dropped/rejected without ever
 	* entering dispatchOne (drain/pause gate-drop, fail-stop of the queued rest, `!cancel`/`!stop`
 	* queue drop, shutdown). A webchat turn signals its client via the WebchatSink terminal
@@ -215915,9 +216439,11 @@ var Daemon = class Daemon {
 				}
 				q.push(entry);
 				this.serialQueue.set(key, q);
+				this.persistInbox(entry, key);
 				this.log.debug(`dispatch: queued behind in-flight turn for session ${key} (depth ${q.length})`);
 				return;
 			}
+			this.persistInbox(entry, key);
 			this.inflight.add(key);
 			this.runLoop(key, entry);
 		});
@@ -215939,11 +216465,13 @@ var Daemon = class Daemon {
 		while (entry) {
 			if (entry !== firstEntry && (this.draining || this.drainingAgents.has(entry.agentId) || this.paused(entry.agentId))) {
 				this.terminateQueuedSink(entry);
+				if (!this.draining) this.removeInbox(entry);
 				entry.resolve(null);
 				const rest = this.serialQueue.get(key) ?? [];
 				this.serialQueue.delete(key);
 				for (const e of rest) {
 					this.terminateQueuedSink(e);
+					if (!this.draining) this.removeInbox(e);
 					e.resolve(null);
 				}
 				this.inflight.delete(key);
@@ -215951,14 +216479,17 @@ var Daemon = class Daemon {
 			}
 			try {
 				const sessionId = await this.dispatchOne(entry, key);
+				this.removeInbox(entry);
 				entry.resolve(sessionId);
 			} catch (err) {
+				if (!this.draining) this.removeInbox(entry);
 				entry.reject(err);
 				const rest = this.serialQueue.get(key) ?? [];
 				this.serialQueue.delete(key);
 				for (const e of rest) {
 					const failStop = new FailStopError(key);
 					this.terminateQueuedSink(e, failStop.message);
+					if (!this.draining) this.removeInbox(e);
 					e.reject(failStop);
 				}
 				this.inflight.delete(key);
@@ -215972,6 +216503,7 @@ var Daemon = class Daemon {
 	}
 	async dispatchOne(entry, key) {
 		const { agentId, msg, integrationId, webchat, callMeta } = entry;
+		if (callMeta?.correlationId !== void 0) this.recordWorkerReport(key, callMeta, msg.text);
 		const agent = this.agents.get(agentId);
 		const rec = new TranscriptRecorder();
 		const replyConn = msg.headless || webchat ? void 0 : this.replyConnFor(agentId, integrationId);
@@ -216028,6 +216560,7 @@ var Daemon = class Daemon {
 			} } : {}
 		};
 		this.pending.set(sessionId, p);
+		if (callMeta) this.activeTurnCallMeta.set(key, callMeta);
 		let finalPhase = "end";
 		try {
 			const host = await this.ensureHostAsync(agentId);
@@ -216103,6 +216636,7 @@ var Daemon = class Daemon {
 			this.releasePermissions(sessionId);
 			this.releaseElicits(sessionId);
 			this.pending.delete(sessionId);
+			if (callMeta) this.activeTurnCallMeta.delete(key);
 			this.store.setSessionState(key, "idle", this.clock.now());
 			this.emitSessionMetadataSnapshot({
 				sessionId,
@@ -216130,6 +216664,7 @@ var Daemon = class Daemon {
 			this.serialQueue.delete(key);
 			for (const e of queued) {
 				this.terminateQueuedSink(e, reason);
+				this.removeInbox(e);
 				e.reject(new FailStopError(key));
 			}
 		}
@@ -216591,6 +217126,17 @@ var Daemon = class Daemon {
 		p.idleTimer = void 0;
 	}
 	pending = /* @__PURE__ */ new Map();
+	/**
+	* DAEMON-PRIVATE trusted call metadata of the CURRENTLY in-flight turn, keyed by the
+	* turn's LOGICAL sessionKey (§6.7). Installed at the start of a `dispatchOne` turn that
+	* carries `callMeta` and cleared in its `finally`; the tool is keyed by the static
+	* session-level MCP token, so a nested `messageAgent` resolves the caller's sessionKey
+	* (from its trusted SessionContext coords + agentId) and reads THIS map to auto-inherit
+	* hop/origin (all child calls) and correlationId (replies only) — never trusting the
+	* agent to pass them. A plain human/platform turn has no entry, so a `messageAgent` it
+	* makes is a fresh call (hopCount 0, no inherited correlation).
+	*/
+	activeTurnCallMeta = /* @__PURE__ */ new Map();
 	permSeq = 0;
 	pendingPerms = /* @__PURE__ */ new Map();
 	/**
@@ -217068,6 +217614,49 @@ var Daemon = class Daemon {
 		}
 		this.serialQueue.clear();
 	}
+	/**
+	* §6.9 #353 startup replay: re-admit durably-persisted admitted-but-not-completed inbox rows
+	* through the SAME serial gate (`dispatch`), FIFO-by-sessionKey (rows come back ordered by
+	* (sessionKey, enqueuedAt), so order within a sessionKey is preserved and the gate keeps them
+	* serial). Runs once on start() after the store is open, agents are loaded into `this.agents`,
+	* and platform connections/crons are up (so a re-admitted turn has its reply transport), as
+	* normal inbound begins. Idempotency: a row whose id is already live in the gate (`liveInboxIds`)
+	* is skipped — dispatch re-appends the same id with INSERT OR IGNORE so no double row is written,
+	* and the re-admitted entry adopts the existing row for later removal. Rows for an agent that no
+	* longer exists on this daemon are SKIPPED + logged (the simplest choice — another owner/daemon
+	* may hold that agent; we neither drop the row nor block on it). Webchat turns were never
+	* persisted, so none appear here.
+	*/
+	replayInbox() {
+		let rows;
+		try {
+			rows = this.store.listInboxBySessionKeyFifo();
+		} catch (err) {
+			this.log.warn(`durable inbox: replay read failed: ${err.message}`);
+			return;
+		}
+		if (rows.length === 0) return;
+		let replayed = 0;
+		for (const row of rows) {
+			if (this.liveInboxIds.has(row.id)) continue;
+			if (!this.agents.has(row.agentId)) {
+				this.log.warn(`durable inbox: skipping replay of ${row.id} — unknown agent "${row.agentId}"`);
+				continue;
+			}
+			let msg;
+			let callMeta;
+			try {
+				msg = JSON.parse(row.msg);
+				callMeta = row.callMeta ? JSON.parse(row.callMeta) : void 0;
+			} catch (err) {
+				this.log.warn(`durable inbox: skipping corrupt row ${row.id}: ${err.message}`);
+				continue;
+			}
+			this.dispatch(row.agentId, msg, row.integrationId ?? void 0, void 0, callMeta, row.isQueueCmd ? { isQueueCmd: true } : void 0).catch(() => {});
+			replayed++;
+		}
+		if (replayed) this.log.info(`durable inbox: replayed ${replayed} admitted message(s) through the serial gate`);
+	}
 	/** daemon/restart + daemon/upgrade (§8.3): ack now, then drain + stop + exit so
 	*  the supervisor relaunches (the new binary, for upgrade). */
 	scheduleFleetExit(kind, targetVersion) {
@@ -217423,6 +218012,8 @@ var Daemon = class Daemon {
 		this.cancelTimers.clear();
 		for (const t of this.slackRetryTimers.values()) this.clock.clearTimeout(t);
 		this.slackRetryTimers.clear();
+		for (const t of this.orchestrationDeadlines.values()) this.clock.clearTimeout(t);
+		this.orchestrationDeadlines.clear();
 		this.metrics?.stop();
 		await this.watcher?.close();
 		await this.drainForShutdown();
@@ -217473,4 +218064,4 @@ async function runForeground(opts, deps = {}) {
 //#endregion
 export { ClientTransport as i, CP_SUBPROTOCOL as n, CP_WS_PATH as r, runForeground as t };
 
-//# sourceMappingURL=run-foreground-BV2scayf.js.map
+//# sourceMappingURL=run-foreground-D_sn_AMV.js.map