@agentconnect.md/daemon 1.0.0-rc.323 → 1.0.0-rc.324

package/dist/{run-foreground-B5Kfk1KO.js → run-foreground-BLhVJZlp.js}

@@ -3,10 +3,10 @@ import { n as require_ms, t as require_src$3 } from "./src-DDtlVutj.js";
 import { n as init_esm_shims, t as __dirname } from "./esm-shims-DxGcm4Hw.js";
 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 { a as RELAY_DAEMON_WS_PATH, c as SHARED_CONFIG_ACTION_ID, d as encode, f as MAX_FRAME_BYTES, g as ZodIssueCode, h as RESERVED_MCP_SERVER_NAME, i as RELAY_DAEMON_SUBPROTOCOL, l as buildEnvelope, n as gitRepoLabel, o as buildRelayDaemonFrame, r as normalizeGitUrl, s as decodeRelayDaemonFrame, u as decodeEnvelope } from "./dist-D8I6ZfGL.js";
-import { a as agentChildEnv, c as persistRelays, i as selectAgent, n as findAgentFiles, o as loadConfig, r as loadAgents, s as persistDaemonId } from "./load-agents-C2pFahVp.js";
+import { _ as ZodIssueCode, a as RELAY_DAEMON_WS_PATH, c as SHARED_CONFIG_ACTION_ID, d as encode, f as MAX_FRAME_BYTES, g as RESERVED_MCP_SERVER_NAME, i as RELAY_DAEMON_SUBPROTOCOL, l as buildEnvelope, m as HookReport, n as gitRepoLabel, o as buildRelayDaemonFrame, r as normalizeGitUrl, s as decodeRelayDaemonFrame, u as decodeEnvelope } from "./dist-D97dgR66.js";
+import { a as agentChildEnv, c as persistRelays, i as selectAgent, n as findAgentFiles, o as loadConfig, r as loadAgents, s as persistDaemonId } from "./load-agents-CuXy_Ei1.js";
 import { l as resolveRoot, o as mcpSocketPath, u as statePath } from "./paths-DEcUO8lC.js";
-import { C as cachedRuntimeVersions, S as cachedRuntimeNames, _ as resolveInMemoryDir, a as prepareWorkspace, b as MEMORY_TOOL_NAMES, c as sessionGitEnv, d as memoryKindOf, f as memoryProviderFor, g as listMemory, h as MemoryTooLargeError, i as prefetchWorkspace, l as simpleGit, m as MemoryPathError, n as turnFailureReason, o as initGitInjection, p as MemoryConflictError, r as installedRuntimes, s as probeGitVersion, t as AcpHost, u as createMemoryProvider, v as writeMemoryFile, w as resolveRuntimes, x as toolsForIntegrations, y as ALL_TOOL_NAMES } from "./acp-host-BEjpql6l.js";
+import { C as cachedRuntimeNames, S as toolsForIntegrations, T as resolveRuntimes, _ as resolveInMemoryDir, a as prepareWorkspace, b as GITHUB_REVIEW_TOOLS, c as sessionGitEnv, d as memoryKindOf, f as memoryProviderFor, g as listMemory, h as MemoryTooLargeError, i as prefetchWorkspace, l as simpleGit, m as MemoryPathError, n as turnFailureReason, o as initGitInjection, p as MemoryConflictError, r as installedRuntimes, s as probeGitVersion, t as AcpHost, u as createMemoryProvider, v as writeMemoryFile, w as cachedRuntimeVersions, x as MEMORY_TOOL_NAMES, y as ALL_TOOL_NAMES } from "./acp-host-DKkoWiWe.js";
 import { i as GitCredentialCache, n as gitcredSocketPath, r as writeGitcredShim, t as GitCredServer } from "./gitcred-server-Bu-Svl7L.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 { createRequire } from "node:module";
@@ -4229,6 +4229,7 @@ var CpClient = class {
 	correlator;
 	stopped = false;
 	fatal = false;
+	hookReportAckV1 = false;
 	attempt = 0;
 	reconnectTimer;
 	lastAuthedEpoch = 0;
@@ -4306,12 +4307,14 @@ var CpClient = class {
 		this.deps.onWebAppUrl?.(ok.webAppUrl);
 		this.deps.onOrgSlug?.(ok.orgSlug);
 		this.state = "REGISTERING";
-		const snap = (await this.request("register", {
+		const regOk = await this.request("register", {
 			host: this.deps.host,
 			capabilities: this.deps.capabilities(),
 			maxAgents: this.deps.maxAgents,
 			localState: this.deps.localState()
-		})).payload;
+		});
+		const snap = regOk.payload;
+		this.hookReportAckV1 = regOk.payload.serverFeatures?.includes("hook-report-ack-v1") ?? false;
 		this.routingEpoch = snap.routingEpoch;
 		this.deps.configApply.applyReconcileSnapshot(snap);
 		this.state = "READY";
@@ -4380,15 +4383,45 @@ var CpClient = class {
 		this.transport?.send(encode(buildEnvelope("cron/report", report)));
 	}
 	/**
-	* Report a hook fire's turn outcome (D→C `hook/report` EVT, fire-and-forget) —
-	* the completion half of the HookRun two-stage lifecycle (the relay's
-	* `rc/run-report` opened the row). A drop is absorbed by the CP's
-	* HookRunReaper (`failed(orphaned)`, still overwritable by a late report).
-	* No-op unless READY/DRAINING.
+	* Durably converge a hook turn outcome (D→C `hook/report` REQ). The daemon
+	* retains its metadata-only outbox row until the CP replies after persistence
+	* and projection convergence, so a long CP outage delays GC instead of losing
+	* a terminal result.
 	*/
-	emitHookReport(report) {
-		if (this.state !== "READY" && this.state !== "DRAINING") return;
-		this.transport?.send(encode(buildEnvelope("hook/report", report)));
+	async emitHookReport(report) {
+		this.requireReady("hook/report");
+		if (!this.hookReportAckV1) {
+			this.transport.send(encode(buildEnvelope("hook/report", report)));
+			return "legacy-sent";
+		}
+		const rep = await this.request("hook/report", report);
+		if (rep.type !== "ack" || rep.payload.ok !== true) throw new WireError("INTERNAL", `expected hook/report ack, got ${rep.type}`, false);
+		return "acknowledged";
+	}
+	/** Durable start barrier for an accepted GitHub hook turn. Formal review is
+	* not exposed until this correlated request succeeds. */
+	async startHook(payload) {
+		this.requireReady("hook/start");
+		const rep = await this.request("hook/start", payload);
+		if (rep.type !== "hook/start/ok") throw new WireError("INTERNAL", `expected hook/start/ok, got ${rep.type}`, false);
+		return rep.payload;
+	}
+	/** One-attempt, action-time formal-review purpose token. */
+	async authorizeGithubReview(payload) {
+		this.requireReady("github/review-authorize");
+		const rep = await this.request("github/review-authorize", payload);
+		if (rep.type !== "github/review-authorized") throw new WireError("INTERNAL", `expected github/review-authorized, got ${rep.type}`, false);
+		return rep.payload;
+	}
+	/** Immediate body-free outcome; HookReport repeats it for lost-reply recovery. */
+	async reportGithubReviewResult(payload) {
+		this.requireReady("github/review-result");
+		const rep = await this.request("github/review-result", payload);
+		if (rep.type !== "github/review-result/ok") throw new WireError("INTERNAL", `expected github/review-result/ok, got ${rep.type}`, false);
+		return rep.payload;
+	}
+	requireReady(op) {
+		if (this.state !== "READY" && this.state !== "DRAINING" || !this.transport) throw new WireError("INTERNAL", `control plane unreachable for ${op} (client ${this.state})`, true);
 	}
 	request(type, payload) {
 		const frame = buildEnvelope(type, payload);
@@ -6416,6 +6449,11 @@ var LocalStore = class {
         msg TEXT NOT NULL,
         integrationId TEXT,
         callMeta TEXT,
+        hookContext TEXT,
+        posterPublishState TEXT,
+        terminalReport TEXT,
+        legacyReportConnection TEXT,
+        completedAt INTEGER,
         isQueueCmd INTEGER,
         loopGuardCounted INTEGER NOT NULL DEFAULT 0,
         enqueuedAt TEXT NOT NULL
@@ -6481,6 +6519,7 @@ var LocalStore = class {
 		this.migrateInboxLoopGuardCounted();
 		this.migrateTranscriptToolBody();
 		this.migrateTranscriptRecipient();
+		this.migrateInboxHookContext();
 	}
 	/** Add the `transcript.recipient` column (the agent a row was delivered to) to a
 	*  pre-existing DB. Legacy rows have NULL recipient, so they surface in a session view
@@ -6488,6 +6527,16 @@ var LocalStore = class {
 	migrateTranscriptRecipient() {
 		if (!this.db.prepare("PRAGMA table_info(transcript)").all().some((c) => c.name === "recipient")) this.db.exec("ALTER TABLE transcript ADD COLUMN recipient TEXT");
 	}
+	/** R1 hook turns must retain their trusted dispatch fence and the poster's
+	* single-attempt state across restart. Upgrade existing local stores in place. */
+	migrateInboxHookContext() {
+		const cols = this.db.prepare("PRAGMA table_info(inbox)").all();
+		if (!cols.some((c) => c.name === "hookContext")) this.db.exec("ALTER TABLE inbox ADD COLUMN hookContext TEXT");
+		if (!cols.some((c) => c.name === "posterPublishState")) this.db.exec("ALTER TABLE inbox ADD COLUMN posterPublishState TEXT");
+		if (!cols.some((c) => c.name === "terminalReport")) this.db.exec("ALTER TABLE inbox ADD COLUMN terminalReport TEXT");
+		if (!cols.some((c) => c.name === "legacyReportConnection")) this.db.exec("ALTER TABLE inbox ADD COLUMN legacyReportConnection TEXT");
+		if (!cols.some((c) => c.name === "completedAt")) this.db.exec("ALTER TABLE inbox ADD COLUMN completedAt INTEGER");
+	}
 	/** Backfill the durable mute tombstones from the legacy sessions.muted column.
 	*  Both writes in setSessionMuted stay transactional, so this idempotent sync cannot
 	*  resurrect a mute that was explicitly cleared. */
@@ -6930,28 +6979,96 @@ var LocalStore = class {
 		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); a re-append preserves the original payload/FIFO
+	*  by the stable id (deliveryId/msgId). A re-append preserves the original payload/FIFO
 	*  position and may only advance the durable loop-accounting marker from 0 to 1. */
 	appendInbox(row) {
-		this.db.prepare(`INSERT INTO inbox
-           (id, sessionKey, agentId, msg, integrationId, callMeta, isQueueCmd, loopGuardCounted, enqueuedAt)
+		const inserted = this.db.prepare(`INSERT OR IGNORE INTO inbox
+          (id, sessionKey, agentId, msg, integrationId, callMeta, hookContext, posterPublishState,
+            terminalReport, legacyReportConnection, completedAt, isQueueCmd, loopGuardCounted, enqueuedAt)
          VALUES
-           (@id, @sessionKey, @agentId, @msg, @integrationId, @callMeta, @isQueueCmd, @loopGuardCounted, @enqueuedAt)
-         ON CONFLICT(id) DO UPDATE SET
-           loopGuardCounted=MAX(inbox.loopGuardCounted, excluded.loopGuardCounted)`).run({
+           (@id, @sessionKey, @agentId, @msg, @integrationId, @callMeta, @hookContext, @posterPublishState,
+            @terminalReport, @legacyReportConnection, @completedAt, @isQueueCmd, @loopGuardCounted, @enqueuedAt)`).run({
 			id: row.id,
 			sessionKey: row.sessionKey,
 			agentId: row.agentId,
 			msg: row.msg,
 			integrationId: row.integrationId ?? null,
 			callMeta: row.callMeta ?? null,
+			hookContext: row.hookContext ?? null,
+			posterPublishState: row.posterPublishState ?? null,
+			terminalReport: row.terminalReport ?? null,
+			legacyReportConnection: row.legacyReportConnection ?? null,
+			completedAt: row.completedAt ?? null,
 			isQueueCmd: row.isQueueCmd ?? null,
 			loopGuardCounted: row.loopGuardCounted ?? 0,
 			enqueuedAt: row.enqueuedAt
 		});
+		if (inserted.changes === 0 && row.loopGuardCounted === 1) this.db.prepare("UPDATE inbox SET loopGuardCounted = MAX(loopGuardCounted, 1) WHERE id = ?").run(row.id);
+		return inserted.changes === 1;
 	}
-	/** 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. */
+	/** Stable-id admission probe used before any hook anchoring side effect. A
+	* live row will be replayed (or is already running); a terminal row is the
+	* durable receipt. Either way, redelivery must not post another anchor. */
+	hasInbox(id) {
+		return this.db.prepare("SELECT 1 FROM inbox WHERE id = ?").get(id) !== void 0;
+	}
+	updateInboxHookState(id, hookContext, posterPublishState) {
+		return this.db.prepare(`UPDATE inbox
+         SET hookContext = @hookContext,
+             posterPublishState = COALESCE(@posterPublishState, posterPublishState)
+         WHERE id = @id`).run({
+			id,
+			hookContext,
+			posterPublishState: posterPublishState ?? null
+		}).changes === 1;
+	}
+	/** Atomically turn a live hook inbox row into a redacted terminal receipt.
+	* The stable id remains present to absorb relay redelivery after restart;
+	* startup re-emits only the metadata report, never the model prompt. The CAS
+	* result identifies the sole writer so a later terminal path cannot replace
+	* the winning outbox body. */
+	completeHookInbox(id, terminalReport, completedAt) {
+		if (this.db.prepare(`UPDATE inbox
+         SET msg = '{}', integrationId = NULL, callMeta = NULL, hookContext = NULL,
+             posterPublishState = 'settled', terminalReport = @terminalReport,
+             legacyReportConnection = NULL, completedAt = @completedAt, isQueueCmd = NULL
+         WHERE id = @id AND hookContext IS NOT NULL AND completedAt IS NULL`).run({
+			id,
+			terminalReport,
+			completedAt
+		}).changes === 1) return "completed";
+		const row = this.db.prepare("SELECT completedAt FROM inbox WHERE id = ?").get(id);
+		return row?.completedAt !== null && row?.completedAt !== void 0 ? "already-terminal" : "missing";
+	}
+	/** Remember a best-effort legacy EVT on this exact CP connection so an
+	* outbox pump can move past it without repeatedly re-sending. The report body
+	* remains retained until a future ACK-capable connection durably converges it. */
+	markLegacyHookReportSent(id, connectionId) {
+		return this.db.prepare(`UPDATE inbox
+         SET legacyReportConnection = @connectionId
+         WHERE id = @id AND terminalReport IS NOT NULL`).run({
+			id,
+			connectionId
+		}).changes === 1;
+	}
+	/** A CP-correlated ACK releases only the report payload. Keep a bounded
+	* metadata-only stable-id receipt so relay redelivery still cannot rerun the
+	* model; unacknowledged reports are never capacity-evicted. */
+	acknowledgeHookInbox(id, maxAcknowledgedReceipts = 1e4) {
+		const result = this.db.prepare(`UPDATE inbox
+         SET terminalReport = NULL, legacyReportConnection = NULL
+         WHERE id = @id AND completedAt IS NOT NULL AND terminalReport IS NOT NULL`).run({ id });
+		if (result.changes === 1) this.db.prepare(`DELETE FROM inbox
+           WHERE id IN (
+             SELECT id FROM inbox
+             WHERE completedAt IS NOT NULL AND terminalReport IS NULL
+             ORDER BY completedAt DESC, id DESC
+             LIMIT -1 OFFSET @maxAcknowledgedReceipts
+           )`).run({ maxAcknowledgedReceipts });
+		return result.changes === 1;
+	}
+	/** Remove an ordinary inbox row once its turn reaches a terminal state. Hook
+	* rows are converted to bounded redacted receipts by completeHookInbox. */
 	removeInbox(id) {
 		this.db.prepare("DELETE FROM inbox WHERE id = ?").run(id);
 	}
@@ -6960,15 +7077,15 @@ var LocalStore = class {
 	listInboxBySessionKeyFifo() {
 		return this.db.prepare("SELECT * FROM inbox ORDER BY sessionKey ASC, enqueuedAt ASC").all();
 	}
-	hasInbox(id) {
-		return this.db.prepare("SELECT 1 FROM inbox WHERE id = ?").get(id) !== void 0;
-	}
-	/** Remove every durable turn owned by an agent. Agent pause is an operator stop,
-	*  not a drain/retry signal: work purged here must never resurrect after unpause +
-	*  restart. Returns the removed ids so the daemon can clear its live-id cache. */
+	/** Remove ordinary durable turns owned by an agent. Live hook rows have their
+	*  own single completion owner and must survive until that owner atomically
+	*  redacts them into a terminal report. Unacknowledged terminal hook reports
+	*  are an outbox and likewise must survive lifecycle purges. ACKed receipts
+	*  may be discarded here because CP already durably converged them. */
 	removeInboxByAgentId(agentId) {
-		const rows = this.db.prepare("SELECT id FROM inbox WHERE agentId = ?").all(agentId);
-		this.db.prepare("DELETE FROM inbox WHERE agentId = ?").run(agentId);
+		const removable = "agentId = ? AND hookContext IS NULL AND terminalReport IS NULL";
+		const rows = this.db.prepare(`SELECT id FROM inbox WHERE ${removable}`).all(agentId);
+		this.db.prepare(`DELETE FROM inbox WHERE ${removable}`).run(agentId);
 		return rows.map((row) => row.id);
 	}
 	/** Record one turn admission against a conversation-wide fixed window. A trusted
@@ -7692,6 +7809,31 @@ async function executeTool(ctx, name, args, deps) {
 			cancelled: true
 		};
 	}
+	if (name === "submitGithubReview") {
+		if (!deps.submitGithubReview) throw new Error("formal GitHub reviews are unavailable on this daemon");
+		const event = requireEnum(args, "event", [
+			"COMMENT",
+			"REQUEST_CHANGES",
+			"APPROVE"
+		]);
+		const verdict = requireEnum(args, "verdict", [
+			"pass",
+			"fail",
+			"neutral"
+		]);
+		const body = requireStringAllowEmpty(args, "body");
+		const comments = parseReviewComments(args.comments);
+		return deps.submitGithubReview({
+			agentId: ctx.agentId,
+			platform: ctx.platform,
+			channel: ctx.channel,
+			thread: ctx.thread,
+			event,
+			verdict,
+			body,
+			...comments ? { comments } : {}
+		});
+	}
 	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) {
@@ -7778,6 +7920,35 @@ function optionalNumber(args, key) {
 	if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`argument ${key} must be a finite number`);
 	return v;
 }
+function requireEnum(args, key, values) {
+	const value = args[key];
+	if (typeof value !== "string" || !values.includes(value)) throw new Error(`argument ${key} must be one of: ${values.join(", ")}`);
+	return value;
+}
+function requirePositiveInt(args, key) {
+	const value = args[key];
+	if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) throw new Error(`argument ${key} must be a positive integer`);
+	return value;
+}
+function parseReviewComments(value) {
+	if (value === void 0 || value === null) return void 0;
+	if (!Array.isArray(value)) throw new Error("argument comments must be an array");
+	if (value.length > 100) throw new Error("argument comments may contain at most 100 entries");
+	return value.map((item, index) => {
+		if (typeof item !== "object" || item === null || Array.isArray(item)) throw new Error(`comments[${index}] must be an object`);
+		const row = item;
+		const startLine = row.startLine === void 0 ? void 0 : requirePositiveInt(row, "startLine");
+		const startSide = row.startSide === void 0 ? void 0 : requireEnum(row, "startSide", ["LEFT", "RIGHT"]);
+		return {
+			path: requireString(row, "path"),
+			body: requireString(row, "body"),
+			line: requirePositiveInt(row, "line"),
+			side: requireEnum(row, "side", ["LEFT", "RIGHT"]),
+			...startLine !== void 0 ? { startLine } : {},
+			...startSide !== void 0 ? { startSide } : {}
+		};
+	});
+}
 //#endregion
 //#region src/mcp/control-server.ts
 /**
@@ -11251,7 +11422,7 @@ var SSEClientTransport = class {
 };
 //#endregion
 //#region src/mcp/mcp-prober.ts
-const DEFAULT_TIMEOUT_MS$1 = 15e3;
+const DEFAULT_TIMEOUT_MS$2 = 15e3;
 const DEFAULT_CONCURRENCY$1 = 3;
 function envRecord(pairs) {
 	return Object.fromEntries(pairs.map((e) => [e.name, e.value]));
@@ -11290,7 +11461,7 @@ async function connectReal(name, def) {
 * not a failure.
 */
 async function probeMcpServer(name, def, opts = {}) {
-	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS$2;
 	let timer;
 	let timedOut = false;
 	const timeout = new Promise((_, reject) => {
@@ -197666,7 +197837,10 @@ const UNTRUSTED_CONTENT_BEGIN = "----- BEGIN UNTRUSTED EXTERNAL CONTENT (GitHub
 const UNTRUSTED_CONTENT_END = "----- END UNTRUSTED EXTERNAL CONTENT -----";
 /** channel/thread from the affinity key — see the sessionKey grammar on {@link RdMsgHook}. */
 function splitSessionKey(msg) {
-	if (msg.sessionKey === msg.hookId) return { channel: msg.hookId };
+	if (msg.sessionKey === msg.hookId) return {
+		channel: msg.hookId,
+		thread: msg.hookId
+	};
 	if (msg.sessionKey === `${msg.hookId}:${msg.deliveryKey}`) return {
 		channel: msg.hookId,
 		thread: msg.deliveryKey
@@ -197731,7 +197905,7 @@ function neutralizeDelimiters(body) {
 *  Only emitted when the poster will actually run (a thread number exists); push
 *  fires have no thread, so they never see this. */
 function githubReplyHint(c) {
-	return ["", `Your final reply is posted back to ${`${c.repo ?? "this thread"}#${c.number}`} automatically as a GitHub comment. Keep it self-contained. The daemon exclusively owns that reply comment. Do NOT create, update, or delete GitHub issue/PR comments or reviews through any CLI (including \`gh\`), MCP/connector, API, or other tool — that would race or double-post with the automatic poster. Use GitHub tools only for READ-only inspection (viewing the thread, diffs, files), then return the content to publish in your final reply.`].join("\n");
+	return ["", `Your final reply is posted back to ${`${c.repo ?? "this thread"}#${c.number}`} automatically as an ordinary GitHub comment. Keep it self-contained; the daemon exclusively owns that reply comment. If this active PR hook permits a formal review, use only the structured \`submitGithubReview\` tool for COMMENT / REQUEST_CHANGES / APPROVE and inline review comments. Do NOT create, update, or delete GitHub comments or formal reviews through \`gh\`, another CLI, a connector, or a direct API call — those paths would race or double-post. Other GitHub tools are for READ-only inspection (thread, diff, files), then return the ordinary comment content in your final reply.`].join("\n");
 }
 /** The github-kind turn text: a trusted metadata header + the FENCED excerpt.
 *  The title rides the header (relay-sanitized to one capped line) — it is
@@ -198125,6 +198299,227 @@ var GithubFinalPoster = class {
 	}
 };
 //#endregion
+//#region src/github/review.ts
+const DEFAULT_TIMEOUT_MS$1 = 15e3;
+const MAX_REVIEW_PAGES = 10;
+const REVIEWS_PER_PAGE = 100;
+var GithubHttpError = class extends Error {
+	status;
+	constructor(status, message) {
+		super(message);
+		this.status = status;
+		this.name = "GithubHttpError";
+	}
+};
+function markerFor(target) {
+	return `<!-- agentconnect-review:${Buffer.from(JSON.stringify({
+		v: 1,
+		hookId: target.hookId,
+		deliveryKey: target.deliveryKey,
+		attemptId: target.attemptId,
+		headSha: target.expectedHeadSha
+	}), "utf8").toString("base64url")} -->`;
+}
+function validateInput(input) {
+	if (input.event === "APPROVE" && input.verdict !== "pass") return "APPROVE requires verdict=pass";
+	if (input.event === "REQUEST_CHANGES" && input.verdict !== "fail") return "REQUEST_CHANGES requires verdict=fail";
+	if ((input.event === "COMMENT" || input.event === "REQUEST_CHANGES") && !input.body.trim()) return `${input.event} requires a non-empty body`;
+	for (const [index, comment] of (input.comments ?? []).entries()) {
+		if (!comment.path.trim()) return `comments[${index}].path is required`;
+		if (!comment.body.trim()) return `comments[${index}].body is required`;
+		if (!Number.isInteger(comment.line) || comment.line <= 0) return `comments[${index}].line must be positive`;
+		if (comment.startLine !== void 0) {
+			if (!Number.isInteger(comment.startLine) || comment.startLine <= 0 || comment.startLine > comment.line) return `comments[${index}].startLine must be positive and no greater than line`;
+			if (!comment.startSide) return `comments[${index}].startSide is required with startLine`;
+		}
+	}
+}
+function safeJson(text) {
+	if (!text) return void 0;
+	return JSON.parse(text.replace(/"id"\s*:\s*(\d{15,})/g, "\"id\":\"$1\""));
+}
+/** One lexical-scope client; it never caches tokens or targets. */
+var GithubReviewClient = class {
+	fetchImpl;
+	baseUrl;
+	timeoutMs;
+	constructor(deps = {}) {
+		this.fetchImpl = deps.fetchImpl ?? fetch;
+		this.baseUrl = (deps.baseUrl ?? "https://api.github.com").replace(/\/+$/, "");
+		this.timeoutMs = deps.timeoutMs ?? DEFAULT_TIMEOUT_MS$1;
+	}
+	async getPull(token, repoFullName, pullNumber) {
+		const pull = await this.request(`/repos/${repoFullName}/pulls/${pullNumber}`, token, "GET");
+		const headSha = pull.head?.sha;
+		const baseSha = pull.base?.sha;
+		if (!headSha || !baseSha) throw new GithubHttpError(502, "GitHub pull response omitted head/base SHA");
+		return {
+			headSha,
+			baseSha,
+			draft: pull.draft === true,
+			state: pull.state ?? "unknown",
+			merged: pull.merged === true
+		};
+	}
+	async submit(target, input) {
+		const invalid = validateInput(input);
+		if (invalid) return {
+			state: "not_submitted",
+			code: "invalid_input",
+			message: invalid
+		};
+		const marker = markerFor(target);
+		try {
+			let existing;
+			try {
+				existing = await this.findByMarker(target, marker);
+			} catch (err) {
+				if (target.recovering) return {
+					state: "ambiguous",
+					code: "ambiguous_write",
+					message: "cannot reconcile the prior formal review attempt; automatic retry is blocked"
+				};
+				throw err;
+			}
+			if (existing) return this.submitted(existing, target, input);
+			const pull = await this.getPull(target.token, target.repoFullName, target.pullNumber);
+			if (pull.state !== "open" || pull.merged || pull.draft) return {
+				state: "not_submitted",
+				code: "pull_unavailable",
+				message: `pull request is ${pull.merged ? "merged" : pull.draft ? "draft" : pull.state}`
+			};
+			if (pull.headSha !== target.expectedHeadSha || pull.baseSha !== target.expectedBaseSha) return {
+				state: "not_submitted",
+				code: "revision_changed",
+				message: "pull request head/base changed while the review was running"
+			};
+			const body = input.body.trim() ? `${input.body}\n\n${marker}` : marker;
+			try {
+				const created = await this.request(`/repos/${target.repoFullName}/pulls/${target.pullNumber}/reviews`, target.token, "POST", {
+					commit_id: target.expectedHeadSha,
+					event: input.event,
+					body,
+					...input.comments?.length ? { comments: input.comments.map((comment) => ({
+						path: comment.path,
+						body: comment.body,
+						line: comment.line,
+						side: comment.side,
+						...comment.startLine !== void 0 ? { start_line: comment.startLine } : {},
+						...comment.startSide !== void 0 ? { start_side: comment.startSide } : {}
+					})) } : {}
+				});
+				return this.submitted(created, target, input);
+			} catch (err) {
+				if (err instanceof GithubHttpError && err.status >= 400 && err.status < 500) return {
+					state: "not_submitted",
+					code: "github_rejected",
+					message: err.message
+				};
+				const recovered = await this.findByMarker(target, marker).catch(() => void 0);
+				if (recovered) return this.submitted(recovered, target, input);
+				return {
+					state: "ambiguous",
+					code: "ambiguous_write",
+					message: "GitHub review outcome is unknown; automatic retry is blocked"
+				};
+			}
+		} catch (err) {
+			return {
+				state: "not_submitted",
+				code: "github_rejected",
+				message: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	/** Read-only recovery for an attempt whose POST outcome was ambiguous. This
+	* is safe to run automatically before a replayed model turn: it can converge
+	* a now-visible marker, but never issues a second review mutation. */
+	async reconcile(target, event, verdict) {
+		const marker = markerFor(target);
+		try {
+			const existing = await this.findByMarker(target, marker);
+			if (existing) return this.submitted(existing, target, {
+				event,
+				verdict,
+				body: ""
+			});
+			return {
+				state: "ambiguous",
+				code: "ambiguous_write",
+				message: "the prior formal review marker is not visible yet; automatic mutation retry is blocked"
+			};
+		} catch {
+			return {
+				state: "ambiguous",
+				code: "ambiguous_write",
+				message: "cannot reconcile the prior formal review attempt; automatic mutation retry is blocked"
+			};
+		}
+	}
+	submitted(review, target, input) {
+		if (review.id === void 0 || review.id === null) return {
+			state: "ambiguous",
+			code: "ambiguous_write",
+			message: "GitHub created/recovered a review without an id"
+		};
+		if (!review.commit_id) return {
+			state: "ambiguous",
+			code: "ambiguous_write",
+			message: "GitHub created/recovered a review without its commit id"
+		};
+		const commitId = review.commit_id;
+		if (commitId !== target.expectedHeadSha) return {
+			state: "ambiguous",
+			code: "ambiguous_write",
+			message: "recovered review is anchored to an unexpected commit"
+		};
+		return {
+			state: "submitted",
+			reviewId: String(review.id),
+			event: input.event,
+			verdict: input.verdict,
+			commitId
+		};
+	}
+	async findByMarker(target, marker) {
+		for (let page = 1; page <= MAX_REVIEW_PAGES; page += 1) {
+			const rows = await this.request(`/repos/${target.repoFullName}/pulls/${target.pullNumber}/reviews?per_page=${REVIEWS_PER_PAGE}&page=${page}`, target.token, "GET");
+			const hit = rows.find((review) => review.body?.includes(marker));
+			if (hit) return hit;
+			if (rows.length < REVIEWS_PER_PAGE) return void 0;
+		}
+		throw new Error("review marker reconciliation exceeded pagination bound");
+	}
+	async request(path, token, method, body) {
+		let response;
+		try {
+			response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+				method,
+				headers: {
+					authorization: `Bearer ${token}`,
+					accept: "application/vnd.github+json",
+					"x-github-api-version": "2022-11-28",
+					...body === void 0 ? {} : { "content-type": "application/json" }
+				},
+				...body === void 0 ? {} : { body: JSON.stringify(body) },
+				signal: AbortSignal.timeout(this.timeoutMs)
+			});
+		} catch (err) {
+			throw new Error(`GitHub request failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		const text = await response.text();
+		if (!response.ok) {
+			let detail = "";
+			try {
+				const parsed = safeJson(text);
+				detail = parsed?.message ? `: ${parsed.message}` : "";
+			} catch {}
+			throw new GithubHttpError(response.status, `GitHub ${method} ${response.status}${detail}`);
+		}
+		return safeJson(text);
+	}
+};
+//#endregion
 //#region src/runtimes/runtime-prober.ts
 const DEFAULT_TIMEOUT_MS = 3e4;
 const DEFAULT_CONCURRENCY = 3;
@@ -198358,7 +198753,7 @@ var RelayClient = class {
 		const frame = decoded.frame;
 		if (frame.corr && this.correlator.settle(frame)) return;
 		if (frame.type === "rd/msg") {
-			this.handleMsg(frame.id, frame.payload);
+			await this.handleMsg(frame.id, frame.payload);
 			return;
 		}
 		if (frame.type === "rd/agentmsg/fwd") {
@@ -198370,9 +198765,9 @@ var RelayClient = class {
 	/** An inbound rd/msg: dispatch it, reply `rd/ack`; only a webchat op streams
 	*  `rd/chat` back over this socket. A shared-bot `im` replies out-of-band via the
 	*  daemon's own Slack send, and a hook fire has no reply stream — both get a noop. */
-	handleMsg(reqId, msg) {
+	async handleMsg(reqId, msg) {
 		const chat = msg.source === "webchat" ? (event) => this.sendChat(msg.chatId, event) : () => void 0;
-		const ack = this.deps.onRelayMsg(msg, chat);
+		const ack = await this.deps.onRelayMsg(msg, chat);
 		this.transport?.send(JSON.stringify(buildRelayDaemonFrame("rd/ack", ack, { corr: reqId })));
 	}
 	/** A forwarded cross-daemon agent-call: terminal-verify + dispatch, reply the typed
@@ -215511,10 +215906,35 @@ function isBuiltinSystemTool(params) {
 		tc?.toolCallId
 	].some((id) => typeof id === "string" && [...BUILTIN_TOOL_FQNS].some((fqn) => id.includes(fqn)));
 }
+function hookSnapshot(msg) {
+	if (msg.configRevision === void 0 || msg.dispatchRevision === void 0 || msg.dispatchDaemonId === void 0 || msg.reviewPolicy === void 0 || msg.reportingMode === void 0 || msg.gateMode === void 0) return void 0;
+	return {
+		configRevision: msg.configRevision,
+		dispatchRevision: msg.dispatchRevision,
+		dispatchDaemonId: msg.dispatchDaemonId,
+		reviewPolicy: msg.reviewPolicy,
+		reportingMode: msg.reportingMode,
+		gateMode: msg.gateMode
+	};
+}
+function reviewPolicyAllows(policy, event) {
+	if (policy === "full") return true;
+	if (policy === "request_changes") return event === "COMMENT" || event === "REQUEST_CHANGES";
+	if (policy === "comment") return event === "COMMENT";
+	return false;
+}
+function reviewResultForWire(effect) {
+	if (effect.state === "submitted") return effect;
+	return {
+		state: effect.state,
+		code: effect.code
+	};
+}
 const MAX_QUEUED_PER_SESSION = 10;
 const LOOP_GUARD_WINDOW_MS = 6e4;
 const MAX_AUTOMATIC_TURNS_PER_WINDOW = 8;
 const MAX_TOTAL_TURNS_PER_WINDOW = 60;
+const MAX_HOOK_REPORT_INFLIGHT = 100;
 /** Thrown to a `dispatch()` caller when the per-session admission queue is at its depth
 *  cap (§4.4 backpressure): the message is fast-failed, not buffered. Carries a stable
 *  `reason` so an agent-call source (P1/P2) can surface a typed `queue_full`. */
@@ -215610,6 +216030,22 @@ function usesLoopGuard(msg) {
 function isMalformedPlatformTurn(msg) {
 	return msg.platform === "slack" && msg.source === "user" && !msg.sender.isBot && msg.sender.id === "unknown" && msg.text.trim() === "" && (msg.attachments?.length ?? 0) === 0;
 }
+function authorizedReviewTargetMatches(active, attemptId, authorized) {
+	return authorized.attemptId === attemptId && authorized.repoId === active.repoId && authorized.repoFullName.toLowerCase() === active.repoFullName.toLowerCase() && authorized.pullNumber === active.pullNumber && authorized.expectedHeadSha === active.expectedHeadSha && authorized.expectedBaseSha === active.expectedBaseSha;
+}
+function authorizedReviewTarget(active, attemptId, authorized, recovering = false) {
+	return {
+		token: authorized.token,
+		repoFullName: authorized.repoFullName,
+		pullNumber: authorized.pullNumber,
+		expectedHeadSha: authorized.expectedHeadSha,
+		expectedBaseSha: authorized.expectedBaseSha,
+		hookId: active.hook.hookId,
+		deliveryKey: active.hook.deliveryKey,
+		attemptId,
+		...recovering ? { recovering: true } : {}
+	};
+}
 function isSlackStatusBarText(text) {
 	return text.startsWith(":bar_chart:") || text.startsWith("📊");
 }
@@ -215694,6 +216130,10 @@ var Daemon = class Daemon {
 	botUserIds = {};
 	cpRouting;
 	cpCollab = new CpCollabRoutes();
+	/** One active PR hook turn per logical session key. Long-lived ACP sessions
+	* may span deliveries, so authorization must never live in SessionContext. */
+	activeGithubTurnMeta = /* @__PURE__ */ new Map();
+	githubReviewClient = new GithubReviewClient();
 	clock;
 	requestExit;
 	draining = false;
@@ -215717,6 +216157,9 @@ var Daemon = class Daemon {
 	cancelTimers = /* @__PURE__ */ new Map();
 	coldCancelTimers = /* @__PURE__ */ new Map();
 	slackRetryTimers = /* @__PURE__ */ new Map();
+	hookReportRetryTimer;
+	hookReportInflight = /* @__PURE__ */ new Set();
+	hookReportConnectionId = randomUUID();
 	slackRetryRuns = /* @__PURE__ */ new Map();
 	constructor(opts = {}) {
 		this.opts = opts;
@@ -215846,6 +216289,7 @@ var Daemon = class Daemon {
 			startOrchestration: (req) => this.startOrchestration(req),
 			getOrchestration: (req) => Promise.resolve(this.getOrchestrationForOwner(req)),
 			cancelOrchestration: (req) => Promise.resolve(this.cancelOrchestrationForOwner(req)),
+			submitGithubReview: (req) => this.submitGithubReview(req),
 			memory: this.memory,
 			recordOutbound: (ctx, channel, thread, text, ts) => this.store.appendTranscript({
 				channel,
@@ -215867,6 +216311,7 @@ var Daemon = class Daemon {
 			mcpServersFor: ({ agent, platform, channel, thread, integrationId, isDm }) => {
 				const servers = [];
 				let tools = toolsForIntegrations(agent.integrations);
+				tools = [...tools, ...GITHUB_REVIEW_TOOLS];
 				if (memoryKindOf(agent) === "native") tools = tools.filter((t) => !MEMORY_TOOL_NAMES.has(t.name));
 				if (tools.length > 0) {
 					const token = this.mcp.register({
@@ -216874,6 +217319,10 @@ var Daemon = class Daemon {
 		this.log.debug(`webchat cancel: no in-flight turn for conversation ${conversationId}`);
 	}
 	relayMsgAcks = /* @__PURE__ */ new Map();
+	/** Hook admission crosses an async anchor + durable-inbox barrier. Coalesce a
+	* retransmit that arrives before that barrier settles instead of dispatching
+	* the same delivery twice. */
+	pendingRelayMsgAcks = /* @__PURE__ */ new Map();
 	agentCallDeliveries = /* @__PURE__ */ new Map();
 	orchestrationDeadlines = /* @__PURE__ */ new Map();
 	/**
@@ -216895,7 +217344,26 @@ var Daemon = class Daemon {
 			this.log.debug(`relay: duplicate rd/msg ${dedupKey} — replaying ack (no re-dispatch)`);
 			return prior;
 		}
-		const ack = msg.source === "webchat" ? this.dispatchRelayOp(msg, chat) : msg.source === "im" ? this.handleRelayIm(msg) : this.dispatchRelayHook(msg);
+		const pending = this.pendingRelayMsgAcks.get(dedupKey);
+		if (pending) return pending;
+		if (msg.source === "hook") {
+			const task = this.dispatchRelayHook(msg).catch((err) => {
+				this.log.error(`hook admission failed for ${dedupKey}: ${formatErr(err)}`);
+				return {
+					msgId: msg.msgId,
+					accepted: false,
+					reason: "durability"
+				};
+			}).then((ack) => {
+				this.pendingRelayMsgAcks.delete(dedupKey);
+				if (this.relayMsgAcks.size >= 2e3) this.relayMsgAcks.clear();
+				this.relayMsgAcks.set(dedupKey, ack);
+				return ack;
+			});
+			this.pendingRelayMsgAcks.set(dedupKey, task);
+			return task;
+		}
+		const ack = msg.source === "webchat" ? this.dispatchRelayOp(msg, chat) : this.handleRelayIm(msg);
 		if (this.relayMsgAcks.size >= 2e3) this.relayMsgAcks.clear();
 		this.relayMsgAcks.set(dedupKey, ack);
 		return ack;
@@ -217397,9 +217865,10 @@ var Daemon = class Daemon {
 	* 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
-	* dispatch. Accepted fires run async via {@link onHookFire}.
+	* dispatch. Accepted is returned only after {@link onHookFire} has crossed
+	* the durable-inbox admission barrier; the model turn itself remains async.
 	*/
-	dispatchRelayHook(msg) {
+	async dispatchRelayHook(msg) {
 		if (!this.agents.has(msg.agentId)) {
 			this.log.warn(`hook: no agent "${msg.agentId}" on this daemon — rejecting fire ${msg.msgId}`);
 			return {
@@ -217432,10 +217901,11 @@ var Daemon = class Daemon {
 				reason: "draining"
 			};
 		}
-		this.onHookFire(msg).catch((err) => this.log.error(`hook fire dispatch failed for agent "${msg.agentId}": ${formatErr(err)}`));
+		const admission = await this.onHookFire(msg);
 		return {
 			msgId: msg.msgId,
-			accepted: true
+			accepted: admission.accepted,
+			...admission.reason ? { reason: admission.reason } : {}
 		};
 	}
 	/**
@@ -217448,25 +217918,36 @@ var Daemon = class Daemon {
 	* without one the fire runs headless.
 	*/
 	async onHookFire(msg) {
-		const firedAt = this.clock.now();
-		const report = (status, extra = {}) => {
-			this.cpClient?.emitHookReport({
-				hookId: msg.hookId,
-				agentId: msg.agentId,
-				deliveryKey: msg.deliveryKey,
-				status,
-				durationMs: Math.max(0, this.clock.now() - firedAt),
-				...extra
-			});
-		};
 		const nmsg = buildHookMessage(msg, randomUUID());
+		if (this.store.hasInbox(nmsg.msgId)) {
+			this.log.debug(`hook: durable duplicate ${nmsg.msgId} — replaying accepted admission`);
+			return { accepted: true };
+		}
+		const snapshot = hookSnapshot(msg);
+		const hookContext = {
+			hookId: msg.hookId,
+			agentId: msg.agentId,
+			deliveryKey: msg.deliveryKey,
+			firedAt: msg.firedAt,
+			...msg.event ? { event: msg.event } : {},
+			...snapshot ? { snapshot } : {},
+			...msg.github ? { github: msg.github } : {}
+		};
 		const c = msg.context;
 		if (c?.source === "github" && c.action === "deleted" && !msg.target) {
 			const key = sessionKey(nmsg.platform, nmsg.channel, nmsg.thread ?? nmsg.msgId, msg.agentId);
 			if (!this.store.getSession(key)?.acpSessionId) {
 				this.log.info(`hook: skipping github ${c.event ?? "event"}:deleted fire ${msg.msgId} — no session for ${key}`);
-				report("success", { reason: "deleted: no existing session" });
-				return;
+				const entry = {
+					agentId: msg.agentId,
+					msg: nmsg,
+					initAbort: new AbortController(),
+					hookContext,
+					resolve: () => {},
+					reject: () => {}
+				};
+				if (this.persistInbox(entry, key, { required: true }) !== "existing") this.emitHookCompletion(hookContext, "success", { reason: "deleted: no existing session" }, entry);
+				return { accepted: true };
 			}
 		}
 		const githubReply = c?.source === "github" && c.repo && c.number !== void 0 ? {
@@ -217474,14 +217955,223 @@ var Daemon = class Daemon {
 			repo: c.repo,
 			number: c.number
 		} : void 0;
+		if (githubReply) hookContext.githubReply = githubReply;
+		const anchored = await this.anchorTrigger(msg.agentId, nmsg, msg.target, hookAnchorText(msg), `hook "${msg.hookId}"`);
+		if (!anchored) return {
+			accepted: false,
+			reason: "dropped"
+		};
+		let admission;
+		this.dispatch(msg.agentId, anchored, msg.target?.integrationId, void 0, void 0, {
+			requireDurable: true,
+			onAdmission: (result) => {
+				admission = result;
+			}
+		}, githubReply, hookContext).catch((err) => this.log.error(`hook turn failed for agent "${msg.agentId}": ${formatErr(err)}`));
+		if (!admission) throw new Error("hook admission barrier did not settle synchronously");
+		if (!admission.accepted) return {
+			accepted: false,
+			reason: admission.reason ?? "durability"
+		};
+		return { accepted: true };
+	}
+	/** Resolve a PR revision if the webhook omitted it (notably
+	* issue_comment), cross the CP hook/start barrier, then return the active
+	* review authority. Failure only disables structured effects; the ordinary
+	* agent turn and final poster continue. */
+	async prepareGithubTurn(entry) {
+		const hook = entry.hookContext;
+		const snapshot = hook?.snapshot;
+		const github = hook?.github;
+		if (!hook || !snapshot || !github || github.subjectKind !== "pull_request" || github.pullNumber === void 0 || snapshot.reviewPolicy === "off" && snapshot.reportingMode === "off" || snapshot.gateMode !== "informational" || snapshot.reportingMode === "status") return void 0;
+		if (this.cfg.daemonId && snapshot.dispatchDaemonId !== this.cfg.daemonId) {
+			this.log.warn(`github review: stale dispatch daemon for ${hook.hookId}:${hook.deliveryKey}`);
+			return;
+		}
+		if (!github.headSha || !github.baseSha) try {
+			const postToken = await this.gitCreds.getPostToken(hook.agentId, github.repoFullName, hook.hookId);
+			const revision = await this.githubReviewClient.getPull(postToken.token, github.repoFullName, github.pullNumber);
+			hook.github = {
+				...github,
+				headSha: revision.headSha,
+				baseSha: revision.baseSha,
+				reportSha: revision.headSha,
+				isDraft: revision.draft
+			};
+			this.persistHookState(entry, void 0, true);
+		} catch (err) {
+			this.log.warn(`github review: unable to resolve PR revision (${formatErr(err)})`);
+			return;
+		}
+		const trusted = hook.github;
+		if (!trusted.headSha || !trusted.baseSha || trusted.pullNumber === void 0) return void 0;
+		const client = this.cpClient;
+		if (!client) return void 0;
+		const payload = {
+			hookId: hook.hookId,
+			agentId: hook.agentId,
+			deliveryKey: hook.deliveryKey,
+			...hook.event ? { event: hook.event } : {},
+			github: {
+				...trusted,
+				reportSha: trusted.reportSha ?? trusted.headSha
+			},
+			...snapshot
+		};
+		let started = false;
+		for (let attempt = 0; attempt < 3 && !started; attempt += 1) try {
+			await client.startHook(payload);
+			started = true;
+		} catch (err) {
+			if (attempt === 2) {
+				this.log.warn(`github review: hook/start rejected (${formatErr(err)})`);
+				return;
+			}
+			await new Promise((resolve) => setTimeout(resolve, 50 * (attempt + 1)));
+		}
+		if (snapshot.reviewPolicy === "off") return void 0;
+		const recoverableAttempt = hook.reviewAttemptId !== void 0 && hook.reviewRequestedEvent !== void 0 && hook.reviewRequestedVerdict !== void 0 && (hook.reviewResult === void 0 || hook.reviewResult.state === "ambiguous");
+		const active = {
+			entry,
+			hook,
+			snapshot,
+			repoId: trusted.repoId,
+			repoFullName: trusted.repoFullName,
+			pullNumber: trusted.pullNumber,
+			expectedHeadSha: trusted.headSha,
+			expectedBaseSha: trusted.baseSha,
+			reportSha: trusted.reportSha ?? trusted.headSha,
+			reviewState: hook.reviewAttemptId === void 0 || recoverableAttempt ? "idle" : "done"
+		};
+		if (recoverableAttempt) await this.reconcileGithubReviewAttempt(active);
+		return active;
+	}
+	/** Store the immediate and terminal-report copies together so they cannot
+	* drift across submit and restart-recovery paths. */
+	persistGithubReviewEffect(active, attemptId, effect, required = false) {
+		const result = reviewResultForWire(effect);
+		active.hook.reviewResult = result;
+		active.hook.reviewReportAttemptId = attemptId;
+		active.hook.reviewReportResult = result;
+		this.persistHookState(active.entry, void 0, required);
+		return result;
+	}
+	/** A daemon restart may replay an attempt after an ambiguous POST/list race.
+	* Before prompting the model, perform a GET-only marker reconciliation. A
+	* still-missing marker remains blocked; only an explicit tool invocation can
+	* cross the full reauthorization + revision fence and retry the mutation. */
+	async reconcileGithubReviewAttempt(active) {
+		const cp = this.cpClient;
+		const attemptId = active.hook.reviewAttemptId;
+		const requestedEvent = active.hook.reviewRequestedEvent;
+		const requestedVerdict = active.hook.reviewRequestedVerdict;
+		if (!cp || !attemptId || !requestedEvent || !requestedVerdict) return;
+		try {
+			const authorized = await cp.authorizeGithubReview({
+				hookId: active.hook.hookId,
+				deliveryKey: active.hook.deliveryKey,
+				attemptId,
+				requestedEvent,
+				requestedVerdict,
+				snapshot: active.snapshot
+			});
+			if (!authorizedReviewTargetMatches(active, attemptId, authorized)) {
+				this.log.warn("github review: recovery authorization returned a mismatched target");
+				return;
+			}
+			const effect = await this.githubReviewClient.reconcile(authorizedReviewTarget(active, attemptId, authorized, true), requestedEvent, requestedVerdict);
+			if (effect.state !== "submitted") return;
+			const result = this.persistGithubReviewEffect(active, attemptId, effect, true);
+			await cp.reportGithubReviewResult({
+				hookId: active.hook.hookId,
+				deliveryKey: active.hook.deliveryKey,
+				attemptId,
+				snapshot: active.snapshot,
+				result
+			});
+			active.reviewState = "done";
+		} catch (err) {
+			this.log.warn(`github review: replay reconciliation deferred (${formatErr(err)})`);
+		}
+	}
+	async submitGithubReview(req) {
+		const key = sessionKey(req.platform, req.channel, req.thread, req.agentId);
+		const active = this.activeGithubTurnMeta.get(key);
+		if (!active || active.hook.agentId !== req.agentId) throw new Error("formal GitHub review is only available during the active PR hook turn");
+		if (!reviewPolicyAllows(active.snapshot.reviewPolicy, req.event)) throw new Error(`${req.event} exceeds this hook's ${active.snapshot.reviewPolicy} review policy`);
+		if (active.reviewState !== "idle") throw new Error("this PR hook turn already has a formal review attempt");
+		active.reviewState = "submitting";
+		const recovering = active.hook.reviewAttemptId !== void 0;
+		if (recovering) {
+			if (active.hook.reviewRequestedEvent === void 0 || active.hook.reviewRequestedVerdict === void 0 || active.hook.reviewRequestedEvent !== req.event || active.hook.reviewRequestedVerdict !== req.verdict) {
+				active.reviewState = "idle";
+				throw new Error("a recovered formal-review attempt must keep its original event and verdict");
+			}
+		} else {
+			active.hook.reviewRequestedEvent = req.event;
+			active.hook.reviewRequestedVerdict = req.verdict;
+		}
+		const attemptId = active.hook.reviewAttemptId ?? randomUUID();
+		active.hook.reviewAttemptId = attemptId;
+		const entry = active.entry;
 		try {
-			const sessionId = await this.fireTrigger(msg.agentId, nmsg, msg.target, hookAnchorText(msg), `hook "${msg.hookId}"`, githubReply);
-			if (sessionId !== null) report("success", { sessionId });
-			else report("failed", { reason: "dropped" });
+			this.persistHookState(entry, void 0, true);
 		} catch (err) {
-			report("failed", { reason: err.message?.slice(0, 300) || "dispatch failed" });
+			if (!recovering) {
+				delete active.hook.reviewAttemptId;
+				delete active.hook.reviewRequestedEvent;
+				delete active.hook.reviewRequestedVerdict;
+			}
+			active.reviewState = "idle";
+			throw new Error(`formal review durability barrier failed: ${formatErr(err)}`);
+		}
+		const cp = this.cpClient;
+		if (!cp) {
+			active.reviewState = "done";
+			throw new Error("control plane is not connected; formal review denied");
+		}
+		let authorized;
+		try {
+			authorized = await cp.authorizeGithubReview({
+				hookId: active.hook.hookId,
+				deliveryKey: active.hook.deliveryKey,
+				attemptId,
+				requestedEvent: req.event,
+				requestedVerdict: req.verdict,
+				snapshot: active.snapshot
+			});
+		} catch (err) {
+			active.reviewState = "done";
 			throw err;
 		}
+		if (!authorizedReviewTargetMatches(active, attemptId, authorized)) {
+			active.reviewState = "done";
+			throw new Error("control plane returned a mismatched formal-review target");
+		}
+		const effect = await this.githubReviewClient.submit(authorizedReviewTarget(active, attemptId, authorized, recovering), req);
+		const result = this.persistGithubReviewEffect(active, attemptId, effect);
+		try {
+			await cp.reportGithubReviewResult({
+				hookId: active.hook.hookId,
+				deliveryKey: active.hook.deliveryKey,
+				attemptId,
+				snapshot: active.snapshot,
+				result
+			});
+			if (effect.state === "not_submitted") {
+				delete active.hook.reviewAttemptId;
+				delete active.hook.reviewRequestedEvent;
+				delete active.hook.reviewRequestedVerdict;
+				delete active.hook.reviewResult;
+				active.reviewState = "idle";
+				this.persistHookState(entry);
+			} else if (effect.state === "ambiguous") active.reviewState = "idle";
+			else active.reviewState = "done";
+		} catch (err) {
+			active.reviewState = effect.state === "ambiguous" ? "idle" : "done";
+			this.log.warn(`github review: immediate result report failed (${formatErr(err)})`);
+		}
+		return effect;
 	}
 	/** The op-switch behind {@link handleRelayMsg} (dedup handled by the caller). */
 	dispatchRelayOp(msg, chat) {
@@ -218075,26 +218765,142 @@ var Daemon = class Daemon {
 	* 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;
+	persistInbox(entry, key, options = {}) {
+		if (entry.webchat) return "skipped";
 		const id = entry.callMeta?.deliveryId ?? entry.msg.msgId;
 		try {
-			this.store.appendInbox({
+			const inserted = 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,
+				hookContext: entry.hookContext ? JSON.stringify(entry.hookContext) : null,
+				posterPublishState: entry.posterPublishState ?? null,
 				isQueueCmd: entry.isQueueCmd ? 1 : null,
 				loopGuardCounted: 1,
 				enqueuedAt: monotonicTs()
 			});
+			if (!inserted && !options.adoptExisting) return "existing";
 			entry.inboxId = id;
 			this.liveInboxIds.add(id);
+			return inserted ? "inserted" : "adopted";
 		} catch (err) {
+			if (options.required) throw err;
 			this.log.warn(`durable inbox: append failed for ${id}: ${err.message}`);
+			return "failed";
+		}
+	}
+	persistHookState(entry, posterPublishState, required = false) {
+		if (!entry.inboxId || !entry.hookContext) {
+			if (required) throw new Error("hook state has no durable inbox row");
+			return;
+		}
+		if (posterPublishState) entry.posterPublishState = posterPublishState;
+		try {
+			if (!this.store.updateInboxHookState(entry.inboxId, JSON.stringify(entry.hookContext), posterPublishState)) throw new Error("durable inbox row is missing");
+		} catch (err) {
+			if (required) throw err;
+			this.log.warn(`durable inbox: hook state update failed for ${entry.inboxId}: ${err.message}`);
+		}
+	}
+	emitHookCompletion(hook, status, extra = {}, owner) {
+		if (owner?.hookTerminalReceipt) return;
+		const start = Date.parse(hook.turnStartedAt ?? hook.firedAt);
+		const reviewAttemptId = hook.reviewReportAttemptId ?? hook.reviewAttemptId;
+		const reviewResult = hook.reviewReportResult ?? hook.reviewResult;
+		const report = {
+			hookId: hook.hookId,
+			agentId: hook.agentId,
+			deliveryKey: hook.deliveryKey,
+			...hook.snapshot ?? {},
+			...hook.event ? { event: hook.event } : {},
+			...hook.github ? { github: hook.github } : {},
+			status,
+			durationMs: Number.isFinite(start) ? Math.max(0, this.clock.now() - start) : 0,
+			...extra,
+			...reviewAttemptId && reviewResult ? {
+				reviewAttemptId,
+				reviewResult
+			} : {}
+		};
+		let reportInboxId;
+		if (owner?.inboxId) try {
+			const completed = this.store.completeHookInbox(owner.inboxId, JSON.stringify(report), this.clock.now());
+			if (completed === "already-terminal") {
+				owner.hookTerminalReceipt = true;
+				this.liveInboxIds.delete(owner.inboxId);
+				return;
+			}
+			if (completed === "missing") {
+				this.log.warn(`durable inbox: hook terminal receipt owner is missing for ${owner.inboxId}`);
+				this.liveInboxIds.delete(owner.inboxId);
+			} else {
+				owner.hookTerminalReceipt = true;
+				this.liveInboxIds.delete(owner.inboxId);
+				reportInboxId = owner.inboxId;
+			}
+		} catch (err) {
+			this.log.warn(`durable inbox: hook terminal receipt failed for ${owner.inboxId}: ${formatErr(err)}`);
 		}
+		this.sendHookReport(report, reportInboxId);
+	}
+	/** Send one durable terminal report and release only its outbox payload after
+	* the CP's correlated persistence/projection ACK. The stable id receipt stays
+	* bounded locally to absorb later relay redelivery. */
+	sendHookReport(report, inboxId) {
+		if (!this.cpClient) return;
+		if (inboxId && this.hookReportInflight.has(inboxId)) return;
+		if (inboxId && this.hookReportInflight.size >= MAX_HOOK_REPORT_INFLIGHT) {
+			this.scheduleHookReportRetry();
+			return;
+		}
+		if (inboxId) this.hookReportInflight.add(inboxId);
+		const connectionId = this.hookReportConnectionId;
+		let refillDrainSlot = false;
+		Promise.resolve(this.cpClient.emitHookReport(report)).then((result) => {
+			if (!inboxId) return;
+			if (result === "legacy-sent") {
+				try {
+					if (!this.store.markLegacyHookReportSent(inboxId, connectionId)) throw new Error("durable inbox row is missing");
+					refillDrainSlot = true;
+				} catch (err) {
+					this.log.warn(`durable inbox: legacy report stamp failed for ${inboxId}: ${formatErr(err)}`);
+					this.scheduleHookReportRetry();
+				}
+				return;
+			}
+			refillDrainSlot = true;
+			try {
+				this.store.acknowledgeHookInbox(inboxId);
+			} catch (err) {
+				this.log.warn(`durable inbox: hook report ACK cleanup failed for ${inboxId}: ${formatErr(err)}`);
+			}
+		}).catch((err) => {
+			if (typeof err === "object" && err !== null && "retryable" in err && err.retryable === false && inboxId) {
+				refillDrainSlot = true;
+				try {
+					this.store.acknowledgeHookInbox(inboxId);
+				} catch (cleanupError) {
+					this.log.warn(`durable inbox: hook report dead-letter failed for ${inboxId}: ${formatErr(cleanupError)}`);
+				}
+				this.log.warn(`hook report permanently rejected for ${inboxId}: ${formatErr(err)}`);
+				return;
+			}
+			this.log.debug(`hook report retained for retry: ${formatErr(err)}`);
+			this.scheduleHookReportRetry();
+		}).finally(() => {
+			if (inboxId) this.hookReportInflight.delete(inboxId);
+			if (refillDrainSlot) this.scheduleHookReportRetry(250);
+		});
+	}
+	scheduleHookReportRetry(delayMs = 5e3) {
+		if (this.draining || this.hookReportRetryTimer !== void 0) return;
+		this.hookReportRetryTimer = this.clock.setTimeout(() => {
+			this.hookReportRetryTimer = void 0;
+			this.replayHookTerminalReports();
+		}, delayMs);
 	}
 	/** 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
@@ -218103,6 +218909,7 @@ var Daemon = class Daemon {
 	removeInbox(entry) {
 		if (!entry.inboxId) return;
 		this.liveInboxIds.delete(entry.inboxId);
+		if (entry.hookContext) return;
 		try {
 			this.store.removeInbox(entry.inboxId);
 		} catch (err) {
@@ -218130,6 +218937,7 @@ var Daemon = class Daemon {
 		let removed = 0;
 		try {
 			for (const row of this.store.listInboxBySessionKeyFifo()) {
+				if (row.hookContext || row.terminalReport) continue;
 				let msg;
 				try {
 					msg = JSON.parse(row.msg);
@@ -218146,8 +218954,8 @@ var Daemon = class Daemon {
 		}
 		return removed;
 	}
-	isLoopGuardOpen(msg) {
-		return usesLoopGuard(msg) && this.store.isLoopGuardOpen(loopGuardScope(msg));
+	isLoopGuardOpen(msg, includeHook = false) {
+		return (usesLoopGuard(msg) || includeHook) && this.store.isLoopGuardOpen(loopGuardScope(msg));
 	}
 	/** First-open side effects for a durable conversation circuit: purge restart work,
 	*  drop every matching serial queue, cancel live ACP turns across ALL agents sharing
@@ -218214,41 +219022,71 @@ var Daemon = class Daemon {
 			...error ? { error } : {}
 		});
 	}
-	dispatch(agentId, msg, integrationId, webchat, callMeta, opts, githubReply) {
+	dispatch(agentId, msg, integrationId, webchat, callMeta, opts, githubReply, hookContext, posterPublishState = githubReply ? "not_started" : void 0) {
 		return new Promise((resolve, reject) => {
+			let admissionSettled = false;
+			const settleAdmission = (result) => {
+				if (admissionSettled) return;
+				admissionSettled = true;
+				opts?.onAdmission?.(result);
+			};
 			if (this.draining || this.drainingAgents.has(agentId)) {
 				this.log.debug(`dispatch: skipped for agent "${agentId}" (draining)`);
+				settleAdmission({
+					accepted: false,
+					reason: "draining"
+				});
 				resolve(null);
 				return;
 			}
 			if (this.paused(agentId)) {
 				this.log.info(`dispatch: skipped for agent "${agentId}" (paused)`);
+				settleAdmission({
+					accepted: false,
+					reason: "paused"
+				});
 				resolve(null);
 				return;
 			}
 			if (this.safetyDrainingAgents.has(agentId)) {
 				if (opts?.fromInboxReplay) this.waitForSafetyDrain(agentId).then(() => {
 					if (this.draining || !this.agents.has(agentId)) {
+						settleAdmission({
+							accepted: false,
+							reason: "draining"
+						});
 						resolve(null);
 						return;
 					}
 					if (opts.inboxReplayId !== void 0 && !this.store.hasInbox(opts.inboxReplayId)) {
+						settleAdmission({
+							accepted: false,
+							reason: "dropped"
+						});
 						resolve(null);
 						return;
 					}
-					this.dispatch(agentId, msg, integrationId, webchat, callMeta, opts, githubReply).then(resolve, reject);
+					this.dispatch(agentId, msg, integrationId, webchat, callMeta, opts, githubReply, hookContext, posterPublishState).then(resolve, reject);
 				}).catch(reject);
 				else {
 					this.log.info(`dispatch: skipped for agent "${agentId}" (stopping interrupted work)`);
+					settleAdmission({
+						accepted: false,
+						reason: "busy"
+					});
 					resolve(null);
 				}
 				return;
 			}
 			const key = sessionKey(msg.platform, msg.channel, msg.thread ?? msg.msgId, agentId);
 			const loopScope = loopGuardScope(msg);
-			if (usesLoopGuard(msg) && this.store.isLoopGuardOpen(loopScope)) {
+			if ((usesLoopGuard(msg) || hookContext !== void 0) && this.store.isLoopGuardOpen(loopScope)) {
 				if (opts?.fromInboxReplay) this.purgeLoopScopeInbox(loopScope);
 				this.log.warn(`dispatch: skipped ${msg.msgId}; loop guard is open for ${loopScope}`);
+				settleAdmission({
+					accepted: false,
+					reason: "loop_protection"
+				});
 				resolve(null);
 				return;
 			}
@@ -218262,6 +219100,10 @@ var Daemon = class Daemon {
 					});
 					else this.purgeLoopScopeInbox(loopScope);
 				} else this.log.warn(`dispatch: dropped malformed Slack platform event ${msg.msgId}`);
+				settleAdmission({
+					accepted: false,
+					reason: "malformed_platform_event"
+				});
 				resolve(null);
 				return;
 			}
@@ -218272,8 +219114,10 @@ var Daemon = class Daemon {
 				...integrationId !== void 0 ? { integrationId } : {},
 				...webchat ? { webchat } : {},
 				...callMeta ? { callMeta } : {},
+				...hookContext ? { hookContext } : {},
 				...opts?.isQueueCmd ? { isQueueCmd: true } : {},
 				...githubReply ? { githubReply } : {},
+				...posterPublishState ? { posterPublishState } : {},
 				resolve,
 				reject
 			};
@@ -218281,25 +219125,81 @@ var Daemon = class Daemon {
 				const q = this.serialQueue.get(key) ?? [];
 				if (q.length >= MAX_QUEUED_PER_SESSION) {
 					this.log.warn(`dispatch: queue full for session ${key} (${q.length}) — rejecting (queue_full)`);
+					settleAdmission({
+						accepted: false,
+						reason: "queue_full"
+					});
 					reject(new QueueFullError(key));
 					return;
 				}
 				if (!opts?.replay && !this.admitLoopGuardTurn(agentId, msg, integrationId, opts?.inboxReplayId)) {
+					settleAdmission({
+						accepted: false,
+						reason: "loop_protection"
+					});
+					resolve(null);
+					return;
+				}
+				let persistence;
+				try {
+					persistence = this.persistInbox(entry, key, {
+						required: opts?.requireDurable,
+						adoptExisting: opts?.adoptExistingInbox
+					});
+				} catch (err) {
+					settleAdmission({
+						accepted: false,
+						reason: "durability"
+					});
+					reject(err);
+					return;
+				}
+				if (persistence === "existing") {
+					settleAdmission({
+						accepted: true,
+						duplicate: true
+					});
 					resolve(null);
 					return;
 				}
 				q.push(entry);
 				this.serialQueue.set(key, q);
-				this.persistInbox(entry, key);
+				settleAdmission({ accepted: true });
 				this.log.debug(`dispatch: queued behind in-flight turn for session ${key} (depth ${q.length})`);
 				return;
 			}
 			if (!opts?.replay && !this.admitLoopGuardTurn(agentId, msg, integrationId, opts?.inboxReplayId)) {
+				settleAdmission({
+					accepted: false,
+					reason: "loop_protection"
+				});
+				resolve(null);
+				return;
+			}
+			let persistence;
+			try {
+				persistence = this.persistInbox(entry, key, {
+					required: opts?.requireDurable,
+					adoptExisting: opts?.adoptExistingInbox
+				});
+			} catch (err) {
+				settleAdmission({
+					accepted: false,
+					reason: "durability"
+				});
+				reject(err);
+				return;
+			}
+			if (persistence === "existing") {
+				settleAdmission({
+					accepted: true,
+					duplicate: true
+				});
 				resolve(null);
 				return;
 			}
-			this.persistInbox(entry, key);
 			this.inflight.add(key);
+			settleAdmission({ accepted: true });
 			this.runLoop(key, entry);
 		});
 	}
@@ -218355,7 +219255,7 @@ var Daemon = class Daemon {
 	dispatchGateReason(entry) {
 		if (entry.cancelledReason) return entry.cancelledReason;
 		if (this.paused(entry.agentId)) return "pause";
-		if (this.isLoopGuardOpen(entry.msg)) return "loop protection";
+		if (this.isLoopGuardOpen(entry.msg, entry.hookContext !== void 0)) return "loop protection";
 	}
 	beginActiveDispatch(agentId, key) {
 		let resolveDone;
@@ -218406,13 +219306,19 @@ var Daemon = class Daemon {
 				this.activeGateEntries.set(key, entry);
 				if (entry !== firstEntry && (this.draining || this.drainingAgents.has(entry.agentId) || this.paused(entry.agentId))) {
 					this.terminateQueuedSink(entry);
-					if (!this.draining) this.removeInbox(entry);
+					if (!this.draining) {
+						if (entry.hookContext) this.emitHookCompletion(entry.hookContext, "failed", { reason: "dropped" }, entry);
+						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);
+						if (!this.draining) {
+							if (e.hookContext) this.emitHookCompletion(e.hookContext, "failed", { reason: "dropped" }, e);
+							this.removeInbox(e);
+						}
 						e.resolve(null);
 					}
 					this.inflight.delete(key);
@@ -218436,7 +219342,10 @@ var Daemon = class Daemon {
 					for (const e of rest) {
 						const failStop = new FailStopError(key);
 						this.terminateQueuedSink(e, failStop.message);
-						if (!this.draining) this.removeInbox(e);
+						if (!this.draining) {
+							if (e.hookContext) this.emitHookCompletion(e.hookContext, "failed", { reason: "fail_stop" }, e);
+							this.removeInbox(e);
+						}
 						e.reject(failStop);
 					}
 					this.inflight.delete(key);
@@ -218452,13 +219361,23 @@ var Daemon = class Daemon {
 		}
 	}
 	async dispatchOne(entry, key) {
-		const { agentId, msg, integrationId, webchat, callMeta, githubReply } = entry;
+		const { agentId, msg, integrationId, webchat, callMeta, githubReply, hookContext } = entry;
 		const initialGate = this.dispatchGateReason(entry);
 		if (initialGate) {
 			this.terminateQueuedSink(entry);
+			if (hookContext && !this.draining) this.emitHookCompletion(hookContext, "failed", { reason: initialGate }, entry);
 			this.log.info(`dispatch: skipped admitted turn ${msg.msgId} (${initialGate})`);
 			return null;
 		}
+		if (hookContext && !hookContext.turnStartedAt) {
+			hookContext.turnStartedAt = new Date(this.clock.now()).toISOString();
+			try {
+				this.persistHookState(entry, void 0, true);
+			} catch (err) {
+				this.emitHookCompletion(hookContext, "failed", { reason: "durability" }, entry);
+				throw err;
+			}
+		}
 		if (callMeta?.correlationId !== void 0) this.recordWorkerReport(key, callMeta, msg.text);
 		const agent = this.agents.get(agentId);
 		const agentName = agent.displayName?.trim() || agent.name;
@@ -218510,7 +219429,11 @@ var Daemon = class Daemon {
 			} finally {
 				releaseReplyConn();
 			}
-			if (interrupted) return null;
+			if (interrupted) {
+				if (hookContext && !this.draining) this.emitHookCompletion(hookContext, "failed", { reason: interrupted }, entry);
+				return null;
+			}
+			if (hookContext && !this.draining) this.emitHookCompletion(hookContext, "failed", { reason: "session_start_failed" }, entry);
 			throw err;
 		}
 		const { sessionId, blocks, created } = handled;
@@ -218530,6 +219453,7 @@ var Daemon = class Daemon {
 			this.showActivity(replyConn, msg.channel, statusThread, "");
 			this.terminateQueuedSink(entry);
 			releaseReplyConn();
+			if (hookContext && !this.draining) this.emitHookCompletion(hookContext, "failed", { reason: initializedGate }, entry);
 			this.log.info(`dispatch: skipped initialized turn ${msg.msgId} (${initializedGate})`);
 			return null;
 		}
@@ -218570,13 +219494,17 @@ var Daemon = class Daemon {
 			resolveDone,
 			...callMeta ? { callMeta } : {},
 			...pendingWebchat ? { webchat: pendingWebchat } : {},
-			...githubReply ? { github: {
+			...githubReply && entry.posterPublishState !== "in_flight" && entry.posterPublishState !== "settled" ? { github: {
 				...this.makeGithubReply(agentId, githubReply, sessionId),
 				deferredFinalTranscript: false
 			} } : {}
 		};
 		this.pending.set(pendingTurnKey(agentId, sessionId), p);
 		if (callMeta) this.activeTurnCallMeta.set(key, callMeta);
+		const activeGithub = await this.prepareGithubTurn(entry).catch((err) => {
+			this.log.warn(`github review: turn setup failed (${formatErr(err)})`);
+		});
+		if (activeGithub) this.activeGithubTurnMeta.set(key, activeGithub);
 		let finalPhase = "end";
 		try {
 			const host = await this.ensureHostAsync(agentId);
@@ -218593,6 +219521,10 @@ var Daemon = class Daemon {
 				this.showActivity(replyConn, msg.channel, statusThread, "");
 				this.terminateQueuedSink(entry);
 				if (readyGate === "loop protection") finalPhase = "problem";
+				if (hookContext && !this.draining) this.emitHookCompletion(hookContext, "failed", {
+					sessionId,
+					reason: readyGate
+				}, entry);
 				this.log.info(`dispatch: skipped ready turn ${msg.msgId} (${readyGate})`);
 				return null;
 			}
@@ -218604,6 +219536,10 @@ var Daemon = class Daemon {
 			const { stopReason, usage } = await host.prompt(sessionId, blocks);
 			if (p.outputSuppressed) {
 				if (p.outputSuppressed === "loop protection") finalPhase = "problem";
+				if (hookContext && !this.draining) this.emitHookCompletion(hookContext, "failed", {
+					sessionId,
+					reason: p.outputSuppressed
+				}, entry);
 				return null;
 			}
 			if (usage) {
@@ -218658,6 +219594,10 @@ var Daemon = class Daemon {
 			this.clearIdle(p);
 			if (p.outputSuppressed) {
 				if (p.outputSuppressed === "loop protection") finalPhase = "problem";
+				if (hookContext && !this.draining) this.emitHookCompletion(hookContext, "failed", {
+					sessionId,
+					reason: p.outputSuppressed
+				}, entry);
 				return null;
 			}
 			finalPhase = "problem";
@@ -218695,6 +219635,10 @@ var Daemon = class Daemon {
 				this.showActivity(replyConn, msg.channel, statusThread, "");
 				await p.applyChain;
 			}
+			if (hookContext && !this.draining) this.emitHookCompletion(hookContext, "failed", {
+				sessionId,
+				reason: "turn_failed"
+			}, entry);
 			throw err;
 		} finally {
 			this.clearCancelBackstop(agentId, sessionId);
@@ -218704,6 +219648,7 @@ var Daemon = class Daemon {
 			this.releasePermissions(agentId, sessionId);
 			this.releaseElicits(agentId, sessionId);
 			if (callMeta) this.activeTurnCallMeta.delete(key);
+			if (activeGithub && this.activeGithubTurnMeta.get(key) === activeGithub) this.activeGithubTurnMeta.delete(key);
 			const githubFinal = p.github && !p.outputSuppressed && finalPhase === "end" ? p.github.collector.finalText(true) : void 0;
 			if (p.github?.deferredFinalTranscript && githubFinal?.trim()) this.store.appendTranscript({
 				channel: p.channel,
@@ -218713,7 +219658,19 @@ var Daemon = class Daemon {
 				kind: "text",
 				text: githubFinal
 			});
-			if (p.github && !p.outputSuppressed) await p.github.poster.publish(githubFinal).catch((err) => this.log.warn(`github poster: final publish failed (${formatErr(err)})`));
+			if (p.github && !p.outputSuppressed) {
+				let recordedInFlight = false;
+				try {
+					this.persistHookState(entry, "in_flight", true);
+					recordedInFlight = true;
+				} catch (err) {
+					this.log.warn(`github poster: durability barrier failed; final publish skipped (${formatErr(err)})`);
+				}
+				if (recordedInFlight) {
+					await p.github.poster.publish(githubFinal).catch((err) => this.log.warn(`github poster: final publish failed (${formatErr(err)})`));
+					this.persistHookState(entry, "settled");
+				}
+			}
 			this.pending.delete(pendingTurnKey(agentId, sessionId));
 			this.store.setSessionState(key, "idle", this.clock.now());
 			this.emitSessionMetadataSnapshot({
@@ -218726,6 +219683,7 @@ var Daemon = class Daemon {
 			});
 			p.resolveDone();
 		}
+		if (hookContext) this.emitHookCompletion(hookContext, "success", { sessionId }, entry);
 		return sessionId;
 	}
 	/** Interrupt a session by its LOGICAL sessionKey (shared by pause, `!stop`, `!cancel`,
@@ -218747,6 +219705,7 @@ var Daemon = class Daemon {
 			this.serialQueue.delete(key);
 			for (const e of queued) {
 				this.terminateQueuedSink(e, opts.dropQueued ? void 0 : reason);
+				if (e.hookContext) this.emitHookCompletion(e.hookContext, "failed", { reason: opts.dropQueued ? "dropped" : "cancelled" }, e);
 				this.removeInbox(e);
 				if (opts.dropQueued) e.resolve(null);
 				else e.reject(new FailStopError(key));
@@ -220139,49 +221098,92 @@ var Daemon = class Daemon {
 		const purgedPausedAgents = /* @__PURE__ */ new Set();
 		const purgedLoopScopes = /* @__PURE__ */ new Set();
 		for (const row of rows) {
+			if (row.completedAt !== null && row.completedAt !== void 0) continue;
 			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;
 			}
-			if (this.paused(row.agentId)) {
-				if (!purgedPausedAgents.has(row.agentId)) {
-					purgedPausedAgents.add(row.agentId);
-					this.purgeAgentInbox(row.agentId);
-				}
-				continue;
-			}
 			let msg;
 			let callMeta;
+			let hookContext;
 			try {
 				msg = JSON.parse(row.msg);
 				callMeta = row.callMeta ? JSON.parse(row.callMeta) : void 0;
+				hookContext = row.hookContext ? JSON.parse(row.hookContext) : void 0;
 			} catch (err) {
 				this.log.warn(`durable inbox: skipping corrupt row ${row.id}: ${err.message}`);
 				continue;
 			}
+			if (msg.source === "hook" && !hookContext) {
+				this.log.warn(`durable inbox: tombstoning legacy hook row ${row.id} without trusted context`);
+				this.store.removeInbox(row.id);
+				continue;
+			}
+			if (this.paused(row.agentId)) {
+				if (!purgedPausedAgents.has(row.agentId)) {
+					purgedPausedAgents.add(row.agentId);
+					this.purgeAgentInbox(row.agentId);
+				}
+				if (hookContext) this.emitHookCompletion(hookContext, "failed", { reason: "pause" }, { inboxId: row.id });
+				continue;
+			}
 			if (isMalformedPlatformTurn(msg) && !msg.isDm) {
 				this.store.removeInbox(row.id);
 				continue;
 			}
 			const loopScope = loopGuardScope(msg);
-			if (usesLoopGuard(msg) && this.store.isLoopGuardOpen(loopScope)) {
+			if ((usesLoopGuard(msg) || hookContext !== void 0) && this.store.isLoopGuardOpen(loopScope)) {
 				if (!purgedLoopScopes.has(loopScope)) {
 					purgedLoopScopes.add(loopScope);
 					this.purgeLoopScopeInbox(loopScope);
 				}
+				if (hookContext) this.emitHookCompletion(hookContext, "failed", { reason: "loop protection" }, { inboxId: row.id });
 				continue;
 			}
+			const posterPublishState = row.posterPublishState === "in_flight" || row.posterPublishState === "settled" ? row.posterPublishState : hookContext?.githubReply ? "not_started" : void 0;
 			this.dispatch(row.agentId, msg, row.integrationId ?? void 0, void 0, callMeta, {
 				...row.isQueueCmd ? { isQueueCmd: true } : {},
 				fromInboxReplay: true,
 				inboxReplayId: row.id,
-				replay: row.loopGuardCounted === 1
-			}).catch(() => {});
+				replay: row.loopGuardCounted === 1,
+				adoptExistingInbox: true,
+				...hookContext ? { requireDurable: true } : {}
+			}, hookContext?.githubReply, hookContext, posterPublishState).catch(() => {});
 			replayed++;
 		}
 		if (replayed) this.log.info(`durable inbox: replayed ${replayed} admitted message(s) through the serial gate`);
 	}
+	/** Re-assert retained metadata-only hook completions whenever the CP socket
+	* becomes ready. HookRepo applies them idempotently; keeping the receipt also
+	* closes the completed-before-restart relay redelivery window. */
+	replayHookTerminalReports() {
+		let rows;
+		try {
+			rows = this.store.listInboxBySessionKeyFifo();
+		} catch (err) {
+			this.log.warn(`durable inbox: terminal report read failed: ${formatErr(err)}`);
+			this.scheduleHookReportRetry();
+			return;
+		}
+		const pending = rows.filter((row) => row.terminalReport && row.legacyReportConnection !== this.hookReportConnectionId && !this.hookReportInflight.has(row.id));
+		const available = Math.max(0, MAX_HOOK_REPORT_INFLIGHT - this.hookReportInflight.size);
+		const batch = pending.slice(0, available);
+		let emitted = 0;
+		for (const row of batch) try {
+			const decoded = HookReport.parse(JSON.parse(row.terminalReport));
+			this.sendHookReport(decoded, row.id);
+			emitted += 1;
+		} catch (err) {
+			this.log.warn(`durable inbox: corrupt terminal hook receipt ${row.id}: ${formatErr(err)}`);
+			try {
+				this.store.acknowledgeHookInbox(row.id);
+			} catch (cleanupError) {
+				this.log.warn(`durable inbox: corrupt receipt cleanup failed for ${row.id}: ${formatErr(cleanupError)}`);
+			}
+		}
+		if (emitted) this.log.info(`durable inbox: re-emitted ${emitted} terminal hook report(s)`);
+	}
 	/** daemon/restart + daemon/upgrade (§8.3): ack now, then drain + stop + exit so
 	*  the supervisor relaunches (the new binary, for upgrade). */
 	scheduleFleetExit(kind, targetVersion) {
@@ -220438,7 +221440,7 @@ var Daemon = class Daemon {
 	* still runs; a `headless` msg additionally suppresses all platform output
 	* in dispatch. Resolves with dispatch's sessionId (null = gate-dropped).
 	*/
-	async fireTrigger(agentId, msg, target, anchorText, label, githubReply) {
+	async anchorTrigger(agentId, msg, target, anchorText, label) {
 		if (this.draining || this.drainingAgents.has(agentId) || this.paused(agentId) || this.safetyDrainingAgents.has(agentId)) {
 			this.log.info(`${label}: skipped for agent "${agentId}" (paused or draining)`);
 			return null;
@@ -220456,7 +221458,12 @@ var Daemon = class Daemon {
 				this.log.warn(`${label}: failed to post trigger to ${target.channel} (${formatErr(err)}) — running without anchor`);
 			}
 		}
-		return this.dispatch(agentId, msg, target?.integrationId, void 0, void 0, void 0, githubReply);
+		return msg;
+	}
+	async fireTrigger(agentId, msg, target, anchorText, label, githubReply, hookContext) {
+		const anchored = await this.anchorTrigger(agentId, msg, target, anchorText, label);
+		if (!anchored) return null;
+		return this.dispatch(agentId, anchored, target?.integrationId, void 0, void 0, void 0, githubReply, hookContext);
 	}
 	/** Build the per-turn GitHub final-answer selector and poster, tokened
 	*  via the repo-targeted gitcred mint (issues/PR write, no contents — never
@@ -220590,6 +221597,8 @@ var Daemon = class Daemon {
 			mcpServerFacts: () => this.mcpServerFacts,
 			onReady: () => {
 				this.probeRuntimesAndEmit();
+				this.hookReportConnectionId = randomUUID();
+				this.replayHookTerminalReports();
 				for (const [integrationId, channels] of this.channelSnapshots) this.cpClient?.emitIntegrationChannels({
 					integrationId,
 					channels
@@ -220711,6 +221720,10 @@ var Daemon = class Daemon {
 		this.coldCancelTimers.clear();
 		for (const t of this.slackRetryTimers.values()) this.clock.clearTimeout(t);
 		this.slackRetryTimers.clear();
+		if (this.hookReportRetryTimer !== void 0) {
+			this.clock.clearTimeout(this.hookReportRetryTimer);
+			this.hookReportRetryTimer = void 0;
+		}
 		for (const t of this.orchestrationDeadlines.values()) this.clock.clearTimeout(t);
 		this.orchestrationDeadlines.clear();
 		this.metrics?.stop();
@@ -220772,4 +221785,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-B5Kfk1KO.js.map
+//# sourceMappingURL=run-foreground-BLhVJZlp.js.map