@xopcai/xopc 0.0.179 → 0.0.187

package/dist/src/gateway/index.js

@@ -8,7 +8,7 @@ import { resolveGatewayListenHost, resolveGatewayListenPlan } from "./listen.js"
 import { assertGatewayRuntimeConfig } from "./runtime-config.js";
 import { restartGatewayProcessWithFreshPid } from "./respawn.js";
 import { GatewayService } from "./service.js";
-import { createAgentResumeHandler, createAgentSSEHandler, createEventsSSEHandler, createSendHandler } from "./hono/sse.js";
+import { createAgentResumeHandler, createEventsSSEHandler, createSendHandler } from "./hono/sse.js";
 import { createHonoApp } from "./hono/app.js";
 import { GatewayServer } from "./server.js";
 import { GatewayLockError, acquireGatewayLock } from "./lock.js";
@@ -17,4 +17,4 @@ import { checkPortAvailable, forceFreePortAndWait, listPortListeners, parseLsofO
 import { apiError, apiOk } from "./protocol.js";
 import "./hono/index.js";
 import { assertSecureGatewayHttpUrl, assertSecureWebSocketUrl, isInsecurePrivateWsAllowed, isSecureWebSocketUrl } from "./ws-security.js";
-export { GatewayLockError, GatewayServer, GatewayService, acquireGatewayLock, apiError, apiOk, assertGatewayAuthConfigured, assertGatewayRuntimeConfig, assertSecureGatewayHttpUrl, assertSecureWebSocketUrl, buckets, buildDefaultCorsOrigins, checkPortAvailable, createAgentResumeHandler, createAgentSSEHandler, createEventsSSEHandler, createHonoApp, createSendHandler, defaultGatewayBindMode, extractToken, forceFreePortAndWait, isAllInterfacesHost, isContainerEnvironment, isGatewayStrictSecurityEnabled, isInsecurePrivateWsAllowed, isLoopbackHost, isSecureWebSocketUrl, listPortListeners, parseLsofOutput, resolveEffectiveGatewayPort, resolveGatewayAuth, resolveGatewayBindHost, resolveGatewayBindHostSync, resolveGatewayBindMode, resolveGatewayEffectiveHost, resolveGatewayListenHost, resolveGatewayListenPlan, resolveGatewayServiceListenPort, restartGatewayProcessWithFreshPid, runGatewayLoop, validateToken };
+export { GatewayLockError, GatewayServer, GatewayService, acquireGatewayLock, apiError, apiOk, assertGatewayAuthConfigured, assertGatewayRuntimeConfig, assertSecureGatewayHttpUrl, assertSecureWebSocketUrl, buckets, buildDefaultCorsOrigins, checkPortAvailable, createAgentResumeHandler, createEventsSSEHandler, createHonoApp, createSendHandler, defaultGatewayBindMode, extractToken, forceFreePortAndWait, isAllInterfacesHost, isContainerEnvironment, isGatewayStrictSecurityEnabled, isInsecurePrivateWsAllowed, isLoopbackHost, isSecureWebSocketUrl, listPortListeners, parseLsofOutput, resolveEffectiveGatewayPort, resolveGatewayAuth, resolveGatewayBindHost, resolveGatewayBindHostSync, resolveGatewayBindMode, resolveGatewayEffectiveHost, resolveGatewayListenHost, resolveGatewayListenPlan, resolveGatewayServiceListenPort, restartGatewayProcessWithFreshPid, runGatewayLoop, validateToken };

package/dist/src/gateway/rate-limit/buckets.d.ts

@@ -35,6 +35,7 @@ declare class BucketRegistry {
     private authFailureLimiter?;
     private authFailureSignature?;
     private strictApiLimiter?;
+    private chatApiLimiter?;
     private xopcCloudPollLimiter?;
     private channelApiLimiter?;
     private tunnelMutateLimiter?;
@@ -49,6 +50,8 @@ declare class BucketRegistry {
     authFailure(cfg: ResolvedAuthRateLimitConfig): FailureLimiter;
     /** Sensitive admin / mutation endpoints — 15 req / 60 s per client IP. */
     strictApi(): RateLimiter;
+    /** Interactive chat actions — 180 req / 60 s per client IP. */
+    chatApi(): RateLimiter;
     /** XOPC Cloud authorization polling — 60 req / 60 s per client IP. */
     xopcCloudPoll(): RateLimiter;
     /** Channel mutation/action endpoints — 20 req / 60 s per client IP. */

package/dist/src/gateway/rate-limit/buckets.js

@@ -47,6 +47,7 @@ var BucketRegistry = class {
 	authFailureLimiter;
 	authFailureSignature;
 	strictApiLimiter;
+	chatApiLimiter;
 	xopcCloudPollLimiter;
 	channelApiLimiter;
 	tunnelMutateLimiter;
@@ -80,6 +81,14 @@ var BucketRegistry = class {
 		});
 		return this.strictApiLimiter;
 	}
+	/** Interactive chat actions — 180 req / 60 s per client IP. */
+	chatApi() {
+		if (!this.chatApiLimiter) this.chatApiLimiter = new RateLimiter({
+			maxRequests: 180,
+			windowMs: 6e4
+		});
+		return this.chatApiLimiter;
+	}
 	/** XOPC Cloud authorization polling — 60 req / 60 s per client IP. */
 	xopcCloudPoll() {
 		if (!this.xopcCloudPollLimiter) this.xopcCloudPollLimiter = new RateLimiter({
@@ -132,6 +141,7 @@ var BucketRegistry = class {
 	destroyAll() {
 		this.authFailureLimiter?.destroy();
 		this.strictApiLimiter?.destroy();
+		this.chatApiLimiter?.destroy();
 		this.xopcCloudPollLimiter?.destroy();
 		this.channelApiLimiter?.destroy();
 		this.tunnelMutateLimiter?.destroy();
@@ -140,6 +150,7 @@ var BucketRegistry = class {
 		this.sharePublicLongLimiter?.destroy();
 		this.authFailureLimiter = void 0;
 		this.strictApiLimiter = void 0;
+		this.chatApiLimiter = void 0;
 		this.xopcCloudPollLimiter = void 0;
 		this.channelApiLimiter = void 0;
 		this.tunnelMutateLimiter = void 0;
@@ -152,6 +163,7 @@ var BucketRegistry = class {
 	resetAllForTests() {
 		this.authFailureLimiter?.resetForTests();
 		this.strictApiLimiter?.resetForTests();
+		this.chatApiLimiter?.resetForTests();
 		this.xopcCloudPollLimiter?.resetForTests();
 		this.channelApiLimiter?.resetForTests();
 		this.tunnelMutateLimiter?.resetForTests();

package/dist/src/gateway/security/csp.d.ts

@@ -11,6 +11,8 @@ export declare function computeInlineScriptHashes(html: string): string[];
  * - `style-src 'self' 'unsafe-inline'` (Tailwind + runtime style injection)
  * - `media-src 'self' blob:` (chat voice previews / recorded clips use blob URLs)
  * - `frame-ancestors 'none'` (prevent clickjacking)
+ * - `frame-src 'none'` (the console never embeds frames)
+ * - `form-action 'self'` (prevent form submissions to untrusted origins)
  * - `base-uri 'none'` (prevent base tag hijacking)
  * - `object-src 'none'` (prevent plugin execution)
  */

package/dist/src/gateway/security/csp.js

@@ -29,6 +29,8 @@ function hasSrcAttribute(openTag) {
 * - `style-src 'self' 'unsafe-inline'` (Tailwind + runtime style injection)
 * - `media-src 'self' blob:` (chat voice previews / recorded clips use blob URLs)
 * - `frame-ancestors 'none'` (prevent clickjacking)
+* - `frame-src 'none'` (the console never embeds frames)
+* - `form-action 'self'` (prevent form submissions to untrusted origins)
 * - `base-uri 'none'` (prevent base tag hijacking)
 * - `object-src 'none'` (prevent plugin execution)
 */
@@ -39,6 +41,8 @@ function buildGatewayConsoleCspHeader(options) {
 		"base-uri 'none'",
 		"object-src 'none'",
 		"frame-ancestors 'none'",
+		"frame-src 'none'",
+		"form-action 'self'",
 		hashes?.length ? `script-src 'self' ${hashes.map((hash) => `'${hash}'`).join(" ")}` : "script-src 'self'",
 		"style-src 'self' 'unsafe-inline'",
 		"img-src 'self' data: blob: https:",

package/dist/src/gateway/service/agent-runner.d.ts

@@ -1,6 +1,6 @@
 /**
  * GatewayAgentRunner — webchat agent invocation and the surrounding control
- * surface (abort, steer, clarify-bridge plumbing, scheduled continuations).
+ * surface (abort, steer, clarify-bridge plumbing, scheduled Task continuations).
  *
  * Was 200 lines of `GatewayService` covering seven concerns that all hung off
  * the same handful of fields (`activeWebchatRunBySession`, `runAbortControllers`,
@@ -8,11 +8,9 @@
  *
  *   - `runAgent(message, channel, chatId, ...)` — wraps {@link runGatewayAgent}
  *   - `abortAgentRun(runId)` — POST /api/agent/abort + cleanup
- *   - `steerWebchatAgent(chatId, message)` — Agent.steer queue at tool boundary
  *   - `submitClarifyResponse(requestId, answer)` — UI answers a `clarify` call
  *   - `runScheduledWebchatTurn(sk, userTurn)` — background webchat user turn
- *   - `drainScheduledWebchatContinuation(sk, msg)` — background text continuation
- *     (extension scheduler + persistent-goal flow)
+ *   - `drainScheduledWebchatContinuation(sk, msg)` — background Task continuation
  *   - `clarifyForSession({ sessionKey, request })` — clarify-bridge dispatch
  *     used by `gatewayClarify.requestClarification` in AgentService
  *
@@ -28,6 +26,7 @@ import type { SessionIndex } from '../../session/index.js';
 import { AgentRunRelay, type RelayEvent } from '../agent-run-relay.js';
 import { ClarifyBridge, type ClarifyBridgeRequest } from '../clarify-bridge.js';
 import type { UserTurnAttachment, UserTurnInput } from '../user-turn-input.js';
+import { SessionInputCoordinator, type SubmitSessionInput } from './session-input-coordinator.js';
 export interface GatewayAgentRunnerOptions {
     bus: MessageBus;
     sessionIndex: SessionIndex;
@@ -43,9 +42,12 @@ export declare class GatewayAgentRunner {
     readonly runRelay: AgentRunRelay;
     /** Per-run abort for webchat (POST /api/agent/abort or client disconnect). */
     private readonly runAbortControllers;
+    private readonly runCompletions;
+    private readonly resolveRunCompletions;
     private readonly clarifyBridge;
     /** Maps webchat session key → active `runId` for `clarify` tool routing. */
     private readonly activeWebchatRunBySession;
+    readonly inputs: SessionInputCoordinator;
     constructor(opts: GatewayAgentRunnerOptions);
     /** True when a webchat agent run is currently in-flight for `sessionKey`. */
     hasActiveRun(sessionKey: string): boolean;
@@ -55,7 +57,7 @@ export declare class GatewayAgentRunner {
     disposeClarifyBridge(): void;
     runAgent(message: string, channel: string, chatId: string, attachments?: UserTurnAttachment[], thinking?: string, runOptions?: {
         signal?: AbortSignal;
-        clientCreatedAtMs?: number;
+        runId?: string;
     }): AsyncGenerator<{
         type: string;
         [key: string]: unknown;
@@ -63,17 +65,34 @@ export declare class GatewayAgentRunner {
         status: string;
         summary: string;
     }, unknown>;
-    /** Abort an in-flight webchat agent run (matches `runId` from SSE `run_start`). */
-    abortAgentRun(runId: string): boolean;
-    /**
-     * Queue steering text for an active webchat run (`Agent.steer` /
-     * tool-boundary injection). The caller must pass the session key.
-     */
-    steerWebchatAgent(sessionKey: string, message: string): Promise<{
+    submitSessionInput(input: SubmitSessionInput): Promise<{
         ok: true;
+        effectiveDelivery: import("../../storage/sqlite/session-input-repository.js").SessionInputDelivery;
+        state: import("../../storage/sqlite/session-input-repository.js").SessionInputState;
     } | {
         ok: false;
-        code: 'BAD_REQUEST' | 'NO_ACTIVE_RUN' | 'STEER_FAILED';
+        code: "BAD_REQUEST" | "QUEUE_FULL";
+    }>;
+    getSessionInputState(sessionKey: string): import("../../storage/sqlite/session-input-repository.js").SessionInputState;
+    updateSessionInput(sessionKey: string, id: string, body: {
+        version: number;
+        content?: string;
+        attachments?: UserTurnAttachment[];
+        thinking?: string;
+        position?: number;
+    }): Promise<{
+        ok: boolean;
+        state: import("../../storage/sqlite/session-input-repository.js").SessionInputState;
+    }>;
+    removeSessionInput(sessionKey: string, id: string, version: number): {
+        ok: boolean;
+        state: import("../../storage/sqlite/session-input-repository.js").SessionInputState;
+    };
+    recoverSessionInputs(): void;
+    /** Abort an in-flight webchat agent run (matches `runId` from SSE `run_start`). */
+    abortAgentRun(runId: string): Promise<{
+        aborted: boolean;
+        idle: boolean;
     }>;
     /** Deliver a user's answer to a pending `clarify` tool call. */
     submitClarifyResponse(requestId: string, answer: string): boolean;

package/dist/src/gateway/service/agent-runner.js

@@ -3,6 +3,8 @@ import { init_logger } from "../../utils/logger.js";
 import { AgentRunRelay } from "../agent-run-relay.js";
 import { ClarifyBridge } from "../clarify-bridge.js";
 import { runGatewayAgent } from "./run-gateway-agent.js";
+import { SessionInputCoordinator } from "./session-input-coordinator.js";
+import crypto from "node:crypto";
 //#region src/gateway/service/agent-runner.ts
 init_logger();
 const log = createLogger("Gateway:AgentRunner");
@@ -11,11 +13,43 @@ var GatewayAgentRunner = class {
 	runRelay = new AgentRunRelay();
 	/** Per-run abort for webchat (POST /api/agent/abort or client disconnect). */
 	runAbortControllers = /* @__PURE__ */ new Map();
+	runCompletions = /* @__PURE__ */ new Map();
+	resolveRunCompletions = /* @__PURE__ */ new Map();
 	clarifyBridge = new ClarifyBridge();
 	/** Maps webchat session key → active `runId` for `clarify` tool routing. */
 	activeWebchatRunBySession = /* @__PURE__ */ new Map();
+	inputs;
 	constructor(opts) {
 		this.opts = opts;
+		this.inputs = new SessionInputCoordinator({
+			sessionExists: async (sessionKey) => Boolean(await opts.sessionIndex.getSessionMetadata(sessionKey)),
+			execute: async (input) => {
+				const generator = this.runAgent(input.content, "webchat", input.sessionKey, input.attachments, input.thinking, { runId: input.runId });
+				let result;
+				while (true) {
+					const step = await generator.next();
+					if (step.done) {
+						result = step.value;
+						break;
+					}
+				}
+				return result;
+			},
+			prepareAttachments: async (sessionKey, attachments) => {
+				const media = await opts.getAgentService().prepareInboundAttachments(sessionKey, attachments);
+				if (!media?.length) return void 0;
+				return media.map((ref) => ({
+					id: ref.id,
+					type: ref.type,
+					mimeType: ref.mimeType,
+					uri: ref.uri,
+					name: ref.name,
+					size: ref.size
+				}));
+			},
+			steer: (sessionKey, content) => opts.getAgentService().turnDispatcher.steerWebchatSession(sessionKey, content),
+			emit: opts.emit
+		});
 	}
 	/** True when a webchat agent run is currently in-flight for `sessionKey`. */
 	hasActiveRun(sessionKey) {
@@ -32,6 +66,14 @@ var GatewayAgentRunner = class {
 		this.clarifyBridge.dispose();
 	}
 	async *runAgent(message, channel, chatId, attachments, thinking, runOptions) {
+		const trackedRunId = runOptions?.runId;
+		if (trackedRunId) {
+			let resolve = () => {};
+			this.runCompletions.set(trackedRunId, new Promise((done) => {
+				resolve = done;
+			}));
+			this.resolveRunCompletions.set(trackedRunId, resolve);
+		}
 		const iter = runGatewayAgent({
 			config: this.opts.getConfig(),
 			agentService: this.opts.getAgentService(),
@@ -42,57 +84,61 @@ var GatewayAgentRunner = class {
 			sessionIndex: this.opts.sessionIndex,
 			emit: this.opts.emit
 		}, message, channel, chatId, attachments, thinking, runOptions);
-		let step = await iter.next();
-		while (!step.done) {
-			yield step.value;
-			step = await iter.next();
+		try {
+			let step = await iter.next();
+			while (!step.done) {
+				yield step.value;
+				step = await iter.next();
+			}
+			return step.value;
+		} finally {
+			if (trackedRunId) {
+				this.resolveRunCompletions.get(trackedRunId)?.();
+				this.resolveRunCompletions.delete(trackedRunId);
+				this.runCompletions.delete(trackedRunId);
+			}
 		}
-		return step.value;
+	}
+	submitSessionInput(input) {
+		return this.inputs.submit(input);
+	}
+	getSessionInputState(sessionKey) {
+		return this.inputs.snapshot(sessionKey);
+	}
+	updateSessionInput(sessionKey, id, body) {
+		return this.inputs.update(sessionKey, id, body);
+	}
+	removeSessionInput(sessionKey, id, version) {
+		return this.inputs.remove(sessionKey, id, version);
+	}
+	recoverSessionInputs() {
+		this.inputs.recover();
 	}
 	/** Abort an in-flight webchat agent run (matches `runId` from SSE `run_start`). */
-	abortAgentRun(runId) {
+	async abortAgentRun(runId) {
 		this.clarifyBridge.cancelForRun(runId);
 		const keysToMark = [];
 		for (const [sk, id] of this.activeWebchatRunBySession) if (id === runId) keysToMark.push(sk);
-		for (const sk of keysToMark) this.activeWebchatRunBySession.delete(sk);
 		const relaySk = this.runRelay.getSessionKey(runId);
 		if (relaySk && !keysToMark.includes(relaySk)) keysToMark.push(relaySk);
 		const c = this.runAbortControllers.get(runId);
-		if (!c) return false;
-		const cutoffTs = Date.now();
-		for (const sk of keysToMark) {
-			this.opts.sessionIndex.updateSessionMetadata(sk, { abortCutoffTimestamp: cutoffTs }).catch(() => {});
-			this.opts.sessionIndex.appendTranscriptContextEntry(sk, {
-				text: "Webchat agent run aborted",
-				data: {
-					runId,
-					abortCutoffTimestamp: cutoffTs
-				}
-			}).catch(() => {});
-		}
-		c.abort();
-		for (const sk of keysToMark) import("../../agent/embedded/runs.js").then(({ abortEmbeddedRun }) => abortEmbeddedRun(sk));
-		return true;
-	}
-	/**
-	* Queue steering text for an active webchat run (`Agent.steer` /
-	* tool-boundary injection). The caller must pass the session key.
-	*/
-	async steerWebchatAgent(sessionKey, message) {
-		const trimmed = message.trim();
-		if (!trimmed) return {
-			ok: false,
-			code: "BAD_REQUEST"
+		if (!c) return {
+			aborted: false,
+			idle: true
 		};
-		if (!this.activeWebchatRunBySession.has(sessionKey)) return {
-			ok: false,
-			code: "NO_ACTIVE_RUN"
-		};
-		if (!await this.opts.getAgentService().turnDispatcher.steerWebchatSession(sessionKey, trimmed)) return {
-			ok: false,
-			code: "STEER_FAILED"
+		const completion = this.runCompletions.get(runId);
+		for (const sk of keysToMark) this.opts.sessionIndex.appendTranscriptContextEntry(sk, {
+			text: "Webchat agent run aborted",
+			data: { runId }
+		}).catch(() => {});
+		c.abort();
+		const { abortEmbeddedRun } = await import("../../agent/embedded/runs.js");
+		await Promise.all(keysToMark.map((sessionKey) => abortEmbeddedRun(sessionKey).catch(() => false)));
+		await completion;
+		return {
+			aborted: true,
+			idle: true
 		};
-		return { ok: true };
 	}
 	/** Deliver a user's answer to a pending `clarify` tool call. */
 	submitClarifyResponse(requestId, answer) {
@@ -100,14 +146,19 @@ var GatewayAgentRunner = class {
 	}
 	/** Same execution path as scheduled continuation, but lets callers observe failures. */
 	async runScheduledWebchatTurn(sessionKey, userTurn) {
-		const gen = this.runAgent(userTurn.text, "webchat", sessionKey, userTurn.attachments, void 0, { clientCreatedAtMs: userTurn.clientCreatedAtMs ?? Date.now() });
-		for await (const _ of gen);
+		const clientMessageId = crypto.randomUUID();
+		const accepted = await this.inputs.submit({
+			sessionKey,
+			clientMessageId,
+			delivery: "next",
+			content: userTurn.text,
+			attachments: userTurn.attachments
+		});
+		if (accepted.ok === false) throw new Error(`Scheduled session input was rejected: ${accepted.code}`);
+		await this.inputs.waitForCompletion(sessionKey, clientMessageId);
 	}
 	async runScheduledWebchatContinuation(sessionKey, message) {
-		await this.runScheduledWebchatTurn(sessionKey, {
-			text: message,
-			clientCreatedAtMs: Date.now()
-		});
+		await this.runScheduledWebchatTurn(sessionKey, { text: message });
 	}
 	/** Background drain for extension-initiated webchat turns (`scheduleWebchatContinuation`). */
 	async drainScheduledWebchatContinuation(sessionKey, message) {

package/dist/src/gateway/service/run-gateway-agent.d.ts

@@ -21,7 +21,7 @@ export type RunGatewayAgentDeps = {
  */
 export declare function runGatewayAgent(deps: RunGatewayAgentDeps, message: string, channel: string, chatId: string, attachments?: UserTurnAttachment[], thinking?: string, runOptions?: {
     signal?: AbortSignal;
-    clientCreatedAtMs?: number;
+    runId?: string;
 }): AsyncGenerator<RunGatewayAgentYield, {
     status: string;
     summary: string;

package/dist/src/gateway/service/run-gateway-agent.js

@@ -4,12 +4,11 @@ import { init_logger } from "../../utils/logger.js";
 import { updateInteractionStateFromMessage } from "../../storage/sqlite/interaction-state-repository.js";
 import "../../storage/sqlite/index.js";
 import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
-import { resolveExecutionContext } from "../../work/execution-context.js";
-import { OutcomeRunCoordinator } from "../../work/outcome-run-coordinator.js";
+import { resolveExecutionContext } from "../../tasks/execution-context.js";
+import { TaskRunCoordinator } from "../../tasks/task-run-coordinator.js";
 import { recordExplicitRelationshipFollowUp } from "../../user-context/relationship-continuity.js";
 import { formatAgentRunErrorForClient } from "../../agent/client-error-format.js";
 import { prependEnvelopeTimestamp } from "../../channels/envelope-timestamp.js";
-import { shouldSkipWebchatInboundByAbortCutoff } from "../../session/abort-cutoff.js";
 import "../chat-limits.js";
 import { resolveWebchatSessionKey } from "../resolve-webchat-session-key.js";
 import { ChatStreamMapper } from "../chat-stream/mapper.js";
@@ -28,16 +27,15 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 		dropped: attachments.length - cappedAttachments.length,
 		max: 10
 	}, "Attachments capped for webchat");
-	const runId = crypto.randomUUID();
+	const runId = runOptions?.runId ?? crypto.randomUUID();
 	const { agentService, bus, runRelay, runAbortControllers, activeWebchatRunBySession, sessionIndex: sessionIndexFromDeps, emit } = deps;
 	const sessionIndex = sessionIndexFromDeps;
-	let outcomeRun;
-	let executionReceiptStatus = "failed";
-	let executionReceiptSummary = "Agent run ended unexpectedly";
+	let taskRun;
+	let taskRunStatus = "failed";
+	let taskRunSummary = "Agent run ended unexpectedly";
 	let webchatSessionKey;
 	let webchatSessionId;
 	let webchatMetadata;
-	let webchatStaleSkip = false;
 	if (channel === "webchat") {
 		const resolved = resolveWebchatSessionKey({ sessionKey: chatId });
 		if (resolved.ok === false) throw new Error(resolved.error);
@@ -46,8 +44,6 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 		if (!meta) throw new Error("Session not found; create sessions via POST /api/sessions");
 		webchatSessionId = meta?.sessionId;
 		webchatMetadata = meta;
-		webchatStaleSkip = shouldSkipWebchatInboundByAbortCutoff(meta, runOptions?.clientCreatedAtMs);
-		if (!webchatStaleSkip && meta?.abortCutoffTimestamp !== void 0) await sessionIndex.updateSessionMetadata(webchatSessionKey, { abortCutoffTimestamp: void 0 }).catch(() => {});
 		runRelay.ensureRun(runId, webchatSessionKey);
 		runAbortControllers.set(runId, new AbortController());
 	}
@@ -71,7 +67,7 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 			channel,
 			metadata: webchatMetadata
 		});
-		outcomeRun = OutcomeRunCoordinator.start({
+		taskRun = TaskRunCoordinator.start({
 			runId,
 			context: executionContext,
 			fallbackObjective: message
@@ -85,26 +81,26 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 	let registeredActiveWebchatRun = false;
 	const captureTaskEvent = (event) => {
 		if (event.type === "task_plan_updated") {
-			outcomeRun?.capturePlan(event.payload.items);
+			taskRun?.capturePlan(event.payload.items);
 			return;
 		}
 		if (event.type === "turn_plan") {
-			outcomeRun?.capturePlan(event.payload.plan.map((item) => ({
+			taskRun?.capturePlan(event.payload.plan.map((item) => ({
 				title: item.step,
 				status: item.status
 			})));
 			return;
 		}
 		if (event.type === "patch_applied") {
-			outcomeRun?.capturePatch(event.payload.added, event.payload.removed);
+			taskRun?.capturePatch(event.payload.added, event.payload.removed);
 			return;
 		}
-		if (event.type === "command_completed" && event.payload.exitCode === 0 && /(^|\s)(test|vitest|jest|pytest|lint|typecheck|build)(\s|$|:)/i.test(event.payload.command)) outcomeRun?.captureCommand(event.payload.command, event.payload.durationMs);
+		if (event.type === "command_completed" && event.payload.exitCode === 0 && /(^|\s)(test|vitest|jest|pytest|lint|typecheck|build)(\s|$|:)/i.test(event.payload.command)) taskRun?.captureCommand(event.payload.command, event.payload.durationMs);
 	};
 	const publishStreamEvent = (event) => channel === "webchat" ? runRelay.publish(runId, event) ?? event : event;
 	const emitAndYield = function* (events) {
 		for (const event of events) {
-			if (outcomeRun) captureTaskEvent(event);
+			if (taskRun) captureTaskEvent(event);
 			const relayedEvent = publishStreamEvent(event);
 			if (channel === "webchat") emit("agent.stream", {
 				sessionKey: streamSessionKey,
@@ -116,17 +112,6 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 	yield* emitAndYield(mapper.start());
 	try {
 		if (channel === "webchat" && webchatSessionKey) {
-			if (webchatStaleSkip) {
-				executionReceiptStatus = "cancelled";
-				executionReceiptSummary = "Stale inbound message skipped";
-				yield* emitAndYield(mapper.end("cancelled", "Stale inbound after abort (clientCreatedAtMs before cutoff)"));
-				runRelay.complete(runId);
-				runAbortControllers.delete(runId);
-				return {
-					status: "skipped",
-					summary: "Stale inbound after abort (clientCreatedAtMs before cutoff)"
-				};
-			}
 			const sessionKey = webchatSessionKey;
 			updateAsyncLogContext({
 				sessionKey,
@@ -155,8 +140,8 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 				for await (const event of coalesceThinkingDeltas(mappedEvents)) yield* emitAndYield([event]);
 				const endStatus = mergedSignal.aborted ? "cancelled" : "success";
 				const endSummary = mergedSignal.aborted ? "Interrupted" : "Message processed successfully";
-				executionReceiptStatus = mergedSignal.aborted ? "cancelled" : "succeeded";
-				executionReceiptSummary = endSummary;
+				taskRunStatus = mergedSignal.aborted ? "cancelled" : "succeeded";
+				taskRunSummary = endSummary;
 				yield* emitAndYield(mapper.end(endStatus, endSummary));
 				runRelay.complete(runId);
 				try {
@@ -181,8 +166,8 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 					channel: "webchat"
 				}, `Agent processing failed: ${em}`);
 				streamError = em;
-				executionReceiptStatus = "failed";
-				executionReceiptSummary = em;
+				taskRunStatus = "failed";
+				taskRunSummary = em;
 				const errorContent = formatAgentRunErrorForClient(streamError);
 				yield* emitAndYield(mapper.error(errorContent));
 				yield* emitAndYield(mapper.end("error", streamError));
@@ -195,7 +180,7 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 				if (registeredActiveWebchatRun && activeWebchatRunBySession.get(sessionKey) === runId) activeWebchatRunBySession.delete(sessionKey);
 				runAbortControllers.delete(runId);
 				const assistantPlainText = agentService.getLastAssistantPlainText(sessionKey);
-				const streamOutcome = agentService.persistentGoals.takeStreamOutcome(sessionKey);
+				const reviewHint = agentService.takeTaskReviewStreamHint(sessionKey);
 				try {
 					await agentService.outboundCoordinator.emitSessionTurnComplete({
 						sessionKey,
@@ -205,7 +190,7 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 						assistantPlainText,
 						aborted: mergedSignal.aborted,
 						...streamError !== void 0 ? { streamError } : {},
-						skipPersistentGoalPostTurn: streamOutcome?.skipPersistentGoalPostTurn ?? false,
+						skipTaskReview: reviewHint?.skipTaskReview ?? false,
 						outboundMetadata: {}
 					});
 				} catch (goalErr) {
@@ -260,16 +245,16 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 			payload: { messageId }
 		}]);
 		yield* emitAndYield(mapper.end("success", "Message processed"));
-		executionReceiptStatus = "succeeded";
-		executionReceiptSummary = "Message processed";
+		taskRunStatus = "succeeded";
+		taskRunSummary = "Message processed";
 		return {
 			status: "ok",
 			summary: "Message processed"
 		};
 	} catch (error) {
 		const em = error instanceof Error ? error.message : String(error);
-		executionReceiptStatus = "failed";
-		executionReceiptSummary = em;
+		taskRunStatus = "failed";
+		taskRunSummary = em;
 		log.error({
 			err: error,
 			errorMessage: em,
@@ -280,17 +265,17 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 		}, `Agent run failed: ${em}`);
 		throw error;
 	} finally {
-		if (outcomeRun) try {
-			outcomeRun.finalize({
-				status: executionReceiptStatus,
-				summary: executionReceiptSummary
+		if (taskRun) try {
+			taskRun.finalize({
+				status: taskRunStatus,
+				summary: taskRunSummary
 			});
 		} catch (err) {
 			const errorMessage = err instanceof Error ? err.message : String(err);
 			log.warn({
 				err,
 				runId
-			}, `Outcome run finalization failed: ${errorMessage}`);
+			}, `Task run finalization failed: ${errorMessage}`);
 		}
 	}
 }

package/dist/src/gateway/service/session-input-coordinator.d.ts

@@ -0,0 +1,59 @@
+import type { UserTurnAttachment } from '../user-turn-input.js';
+import { type SessionInputDelivery, type SessionInputState } from '../../storage/sqlite/index.js';
+export type SubmitSessionInput = {
+    sessionKey: string;
+    clientMessageId: string;
+    delivery: SessionInputDelivery;
+    content: string;
+    attachments?: UserTurnAttachment[];
+    thinking?: string;
+};
+export declare class SessionInputCoordinator {
+    private readonly deps;
+    private readonly draining;
+    private readonly submissionTails;
+    constructor(deps: {
+        sessionExists: (sessionKey: string) => Promise<boolean>;
+        execute: (input: {
+            runId: string;
+            sessionKey: string;
+            content: string;
+            attachments?: UserTurnAttachment[];
+            thinking?: string;
+        }) => Promise<{
+            status: string;
+            summary: string;
+        }>;
+        prepareAttachments: (sessionKey: string, attachments?: UserTurnAttachment[]) => Promise<UserTurnAttachment[] | undefined>;
+        steer: (sessionKey: string, content: string) => Promise<boolean>;
+        emit: (type: string, payload: unknown) => void;
+    });
+    snapshot(sessionKey: string): SessionInputState;
+    private publish;
+    submit(input: SubmitSessionInput): Promise<{
+        ok: true;
+        effectiveDelivery: SessionInputDelivery;
+        state: SessionInputState;
+    } | {
+        ok: false;
+        code: 'BAD_REQUEST' | 'QUEUE_FULL';
+    }>;
+    private submitLocked;
+    drain(sessionKey: string): Promise<void>;
+    update(sessionKey: string, id: string, body: {
+        version: number;
+        content?: string;
+        attachments?: UserTurnAttachment[];
+        thinking?: string;
+        position?: number;
+    }): Promise<{
+        ok: boolean;
+        state: SessionInputState;
+    }>;
+    remove(sessionKey: string, id: string, version: number): {
+        ok: boolean;
+        state: SessionInputState;
+    };
+    waitForCompletion(sessionKey: string, clientMessageId: string): Promise<void>;
+    recover(): void;
+}