@xopcai/xopc 0.0.160 → 0.0.162

package/dist/src/gateway/hono/routes/you.js

@@ -1,4 +1,5 @@
 import { runSqliteWriteTransaction } from "../../../storage/sqlite/transaction.js";
+import { getRelationshipSettings, updateRelationshipSettings } from "../../../storage/sqlite/relationship-settings-repository.js";
 import { deleteMemoryRecord, getMemoryRecord, listMemoryRecords, upsertMemoryRecord } from "../../../storage/sqlite/memory-records-repository.js";
 import { listKnowledgeSourceItems, listKnowledgeSyncRuns } from "../../../storage/sqlite/knowledge-repository.js";
 import { getConnectorConnection, listConnectorConnections } from "../../../storage/sqlite/connector-repository.js";
@@ -15,6 +16,7 @@ import "../../../goals/index.js";
 import { revokeComposioConnection } from "../../../connectors/composio.js";
 import { listConnectorCatalog } from "../../../connectors/catalog.js";
 import { nextMemoryReviewAt, resolveMemoryStability } from "../../../agent/memory/lifecycle.js";
+import { PERSONAL_PLAYBOOK_DISABLED_TAG, PERSONAL_PLAYBOOK_ORDER_PREFIX, PERSONAL_PLAYBOOK_RULE_TAG, patchPersonalPlaybookContextTags, personalPlaybookContext } from "../../../user-context/personal-playbook.js";
 import { listConnectorInstances } from "../../../connectors/instances.js";
 import { uninstallConnector } from "../../../connectors/install.js";
 import { readUserProfileFile, writeUserProfileFile } from "../../agents-admin.js";
@@ -44,8 +46,13 @@ const PLAYBOOK_IDS = [
 	"execution",
 	"routines"
 ];
-const PLAYBOOK_DISABLED_TAG = "playbook:disabled";
-const PLAYBOOK_ORDER_PREFIX = "playbook:order:";
+const PLAYBOOK_SUPPORT_NEEDS = new Set([
+	"listen",
+	"clarify",
+	"advise",
+	"act",
+	"unknown"
+]);
 const PROFILE_FIELD_LIMITS = {
 	callName: 80,
 	pronouns: 80,
@@ -154,34 +161,57 @@ function parseProfilePatch(body) {
 	return Object.keys(patch).length > 0 ? { patch } : { error: "No profile fields provided" };
 }
 function playbookForRecord(record) {
+	if (!record.tags?.includes("playbook:rule")) return void 0;
 	if (record.kind === "preference" || record.kind === "boundary" || record.kind === "tool_preference") return "communication";
 	if (record.kind === "task_lesson" || record.kind === "derived_insight") return "execution";
 	if (record.kind === "routine") return "routines";
 }
 function playbookRuleOrder(record) {
-	const tag = record.tags?.find((value) => value.startsWith(PLAYBOOK_ORDER_PREFIX));
-	const parsed = tag ? Number.parseInt(tag.slice(15), 10) : NaN;
+	const tag = record.tags?.find((value) => value.startsWith(PERSONAL_PLAYBOOK_ORDER_PREFIX));
+	const parsed = tag ? Number.parseInt(tag.slice(PERSONAL_PLAYBOOK_ORDER_PREFIX.length), 10) : NaN;
 	return Number.isFinite(parsed) ? parsed : 1e3;
 }
 function patchPlaybookRuleTags(record, patch) {
-	let tags = (record.tags ?? []).filter((tag) => !tag.startsWith(PLAYBOOK_ORDER_PREFIX));
-	if (patch.enabled === true) tags = tags.filter((tag) => tag !== PLAYBOOK_DISABLED_TAG);
-	if (patch.enabled === false) tags.push(PLAYBOOK_DISABLED_TAG);
-	if (patch.order !== void 0) tags.push(`${PLAYBOOK_ORDER_PREFIX}${patch.order}`);
+	let tags = (record.tags ?? []).filter((tag) => !tag.startsWith(PERSONAL_PLAYBOOK_ORDER_PREFIX));
+	if (patch.enabled === true) tags = tags.filter((tag) => tag !== PERSONAL_PLAYBOOK_DISABLED_TAG);
+	if (patch.enabled === false) tags.push(PERSONAL_PLAYBOOK_DISABLED_TAG);
+	if (patch.order !== void 0) tags.push(`${PERSONAL_PLAYBOOK_ORDER_PREFIX}${patch.order}`);
 	return [...new Set(tags)];
 }
+function parsePlaybookContext(value) {
+	if (value === void 0) return { context: {} };
+	if (!value || typeof value !== "object" || Array.isArray(value)) return { error: "context must be an object" };
+	const input = value;
+	const context = {};
+	if ("channel" in input) {
+		if (input.channel !== null && (typeof input.channel !== "string" || !/^[a-z0-9_-]{1,40}$/i.test(input.channel))) return { error: "context.channel is invalid" };
+		context.channel = input.channel === null ? void 0 : String(input.channel);
+	}
+	if ("supportNeed" in input) {
+		if (input.supportNeed !== null && !PLAYBOOK_SUPPORT_NEEDS.has(String(input.supportNeed))) return { error: "context.supportNeed is invalid" };
+		context.supportNeed = input.supportNeed === null ? void 0 : input.supportNeed;
+	}
+	return { context };
+}
 function buildPersonalPlaybooks(records) {
 	return PLAYBOOK_IDS.map((id) => {
-		const rules = records.filter((record) => playbookForRecord(record) === id).sort((left, right) => playbookRuleOrder(left) - playbookRuleOrder(right) || left.updatedAt.localeCompare(right.updatedAt));
+		const rules = records.filter((record) => record.status === "active" && playbookForRecord(record) === id).sort((left, right) => playbookRuleOrder(left) - playbookRuleOrder(right) || left.updatedAt.localeCompare(right.updatedAt));
 		return {
 			id,
-			enabled: rules.some((record) => !record.tags?.includes(PLAYBOOK_DISABLED_TAG)),
+			enabled: rules.some((record) => !record.tags?.includes(PERSONAL_PLAYBOOK_DISABLED_TAG)),
 			rules: rules.map((record) => ({
 				id: record.id,
 				statement: record.content,
 				origin: record.explicitness,
-				enabled: !record.tags?.includes(PLAYBOOK_DISABLED_TAG),
-				order: playbookRuleOrder(record)
+				enabled: !record.tags?.includes(PERSONAL_PLAYBOOK_DISABLED_TAG),
+				order: playbookRuleOrder(record),
+				context: personalPlaybookContext(record),
+				versions: playbookVersionChain(records, record.id).map((version) => ({
+					id: version.id,
+					statement: version.content,
+					updatedAt: version.updatedAt,
+					current: version.id === record.id
+				}))
 			})),
 			updatedAt: rules.map((record) => record.updatedAt).sort().at(-1)
 		};
@@ -195,7 +225,7 @@ function buildInsightSuggestions(records) {
 		id: record.id,
 		insight: record.content,
 		kind: record.kind,
-		action: record.kind === "routine" ? "make_repeatable" : "start_progress",
+		action: record.kind === "routine" ? "make_repeatable" : record.kind === "task_lesson" || record.kind === "derived_insight" ? "add_playbook" : "start_progress",
 		evidenceCount: record.evidence?.length ?? 0,
 		confidence: record.confidence,
 		sourceName: record.source.provider ?? "local"
@@ -216,11 +246,11 @@ function editableRecord(recordId) {
 	if (!record || !VISIBLE_STATUSES.has(record.status) || !isUserContextRecord(record)) return null;
 	return record;
 }
-function preserveRecord(record, patch) {
-	return upsertMemoryRecord({
-		id: record.id,
+function memoryRecordInput(record) {
+	return {
 		providerId: record.source.provider ?? "local",
 		kind: record.kind,
+		userId: record.scope.userId,
 		sourceAgentId: record.provenance.sourceAgentId,
 		workspaceId: record.scope.workspaceId,
 		sessionKey: record.scope.sessionKey,
@@ -242,8 +272,41 @@ function preserveRecord(record, patch) {
 		validFrom: record.validFrom,
 		validTo: record.validTo,
 		supersedesRecordId: record.supersedesRecordId,
-		conflictGroupId: record.conflictGroupId,
-		...patch
+		conflictGroupId: record.conflictGroupId
+	};
+}
+function preserveRecord(record, patch) {
+	return upsertMemoryRecord({
+		...memoryRecordInput(record),
+		...patch,
+		id: record.id
+	});
+}
+function playbookVersionChain(records, recordId) {
+	const relatedIds = new Set([recordId]);
+	let previousSize = 0;
+	while (previousSize !== relatedIds.size) {
+		previousSize = relatedIds.size;
+		for (const record of records) {
+			if (!record.supersedesRecordId) continue;
+			if (relatedIds.has(record.id) || relatedIds.has(record.supersedesRecordId)) {
+				relatedIds.add(record.id);
+				relatedIds.add(record.supersedesRecordId);
+			}
+		}
+	}
+	return records.filter((record) => relatedIds.has(record.id) && playbookForRecord(record) !== void 0).sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt));
+}
+function versionPlaybookRule(record, patch) {
+	return upsertMemoryRecord({
+		...memoryRecordInput(record),
+		...patch,
+		status: "active",
+		supersedesRecordId: record.id,
+		source: {
+			provider: "local",
+			path: "you://playbook/version"
+		}
 	});
 }
 function registerYouRoutes(authenticated, deps) {
@@ -291,13 +354,14 @@ function registerYouRoutes(authenticated, deps) {
 			}),
 			conflictGroups: buildConflictGroups(allUserContextRecords),
 			insights: buildInsightSuggestions(records),
-			playbooks: buildPersonalPlaybooks(records.filter((record) => record.status === "active")),
+			playbooks: buildPersonalPlaybooks(allUserContextRecords),
 			sources,
 			sourceRecommendations: buildGoalSourceRecommendations(sourceDefinitions.filter((definition) => definition.capabilities.includes("context") || definition.capabilities.includes("memory_source")), new Set(sourceInstances.map((instance) => instance.connectorId)), activeGoals),
 			controls: {
 				mode: config.userContext.memory.mode,
 				sensitiveWritePolicy: config.userContext.privacy.sensitiveWritePolicy
 			},
+			relationship: getRelationshipSettings(),
 			trust: {
 				defaultActionLevel: trustPolicy.defaultActionLevel,
 				levels: USER_TRUST_LEVELS,
@@ -305,6 +369,41 @@ function registerYouRoutes(authenticated, deps) {
 			}
 		});
 	});
+	authenticated.patch("/api/you/relationship", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		if (!body || typeof body !== "object" || Array.isArray(body)) return c.json({ error: "Invalid relationship settings" }, 400);
+		const input = body;
+		const patch = {};
+		if ("supportMode" in input) {
+			if (![
+				"efficient",
+				"coach",
+				"companion",
+				"auto"
+			].includes(String(input.supportMode))) return c.json({ error: "Invalid supportMode" }, 400);
+			patch.supportMode = input.supportMode;
+		}
+		if ("proactiveEnabled" in input) {
+			if (typeof input.proactiveEnabled !== "boolean") return c.json({ error: "proactiveEnabled must be boolean" }, 400);
+			patch.proactiveEnabled = input.proactiveEnabled;
+		}
+		for (const field of ["quietStart", "quietEnd"]) {
+			if (!(field in input)) continue;
+			const value = input[field];
+			if (value !== null && (typeof value !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(value))) return c.json({ error: `${field} must use HH:mm` }, 400);
+			patch[field] = value === null ? void 0 : String(value);
+		}
+		for (const field of ["allowedTopics", "blockedTopics"]) {
+			if (!(field in input)) continue;
+			if (!Array.isArray(input[field]) || input[field].length > 20 || input[field].some((value) => typeof value !== "string" || !value.trim() || value.length > 80)) return c.json({ error: `${field} must contain up to 20 short topics` }, 400);
+			patch[field] = [...new Set(input[field].map((value) => value.trim()))];
+		}
+		if (Object.keys(patch).length === 0) return c.json({ error: "No relationship settings provided" }, 400);
+		return c.json({
+			ok: true,
+			relationship: updateRelationshipSettings(patch)
+		});
+	});
 	authenticated.get("/api/you/profile", async (c) => {
 		return c.json(await readProfileBundle(deps.service.currentConfig));
 	});
@@ -523,7 +622,7 @@ function registerYouRoutes(authenticated, deps) {
 			limit: 500
 		}).filter(isUserContextRecord).filter((record) => playbookForRecord(record) === id);
 		runSqliteWriteTransaction(() => {
-			for (const record of active) preserveRecord(record, { tags: patchPlaybookRuleTags(record, { enabled }) });
+			for (const record of active) versionPlaybookRule(record, { tags: patchPlaybookRuleTags(record, { enabled }) });
 		});
 		const current = active.map((record) => ({
 			...record,
@@ -540,6 +639,8 @@ function registerYouRoutes(authenticated, deps) {
 		const body = await c.req.json().catch(() => ({}));
 		const statement = typeof body.statement === "string" ? body.statement.trim() : "";
 		if (!statement || statement.length > 5e3) return c.json({ error: "Rule statement is required" }, 400);
+		const parsedContext = parsePlaybookContext(body.context);
+		if ("error" in parsedContext) return c.json({ error: parsedContext.error }, 400);
 		const record = upsertMemoryRecord({
 			providerId: "local",
 			kind: id === "communication" ? "preference" : id === "execution" ? "task_lesson" : "routine",
@@ -550,11 +651,11 @@ function registerYouRoutes(authenticated, deps) {
 				path: "you://playbook"
 			},
 			confidence: 1,
-			tags: [
+			tags: patchPersonalPlaybookContextTags([
 				"user-understanding",
-				"playbook:explicit",
-				`${PLAYBOOK_ORDER_PREFIX}${Number.isInteger(body.order) ? body.order : 1e3}`
-			],
+				PERSONAL_PLAYBOOK_RULE_TAG,
+				`${PERSONAL_PLAYBOOK_ORDER_PREFIX}${Number.isInteger(body.order) ? body.order : 1e3}`
+			], parsedContext.context),
 			status: "active",
 			sensitivity: "normal",
 			explicitness: "explicit",
@@ -576,12 +677,14 @@ function registerYouRoutes(authenticated, deps) {
 		if (!content || content.length > 5e3) return c.json({ error: "Rule statement is required" }, 400);
 		if (body.enabled !== void 0 && typeof body.enabled !== "boolean") return c.json({ error: "enabled must be boolean" }, 400);
 		if (body.order !== void 0 && (!Number.isInteger(body.order) || body.order < 0 || body.order > 1e4)) return c.json({ error: "order must be an integer between 0 and 10000" }, 400);
-		const updated = preserveRecord(record, {
+		const parsedContext = parsePlaybookContext(body.context);
+		if ("error" in parsedContext) return c.json({ error: parsedContext.error }, 400);
+		const updated = versionPlaybookRule(record, {
 			content,
-			tags: patchPlaybookRuleTags(record, {
+			tags: patchPersonalPlaybookContextTags(patchPlaybookRuleTags(record, {
 				enabled: body.enabled,
 				order: body.order
-			}),
+			}), parsedContext.context),
 			explicitness: body.statement === void 0 ? record.explicitness : "explicit"
 		});
 		return c.json({
@@ -593,9 +696,32 @@ function registerYouRoutes(authenticated, deps) {
 		const id = c.req.param("id");
 		const record = editableRecord(c.req.param("recordId"));
 		if (!PLAYBOOK_IDS.includes(id) || !record || playbookForRecord(record) !== id) return c.json({ error: "Playbook rule not found" }, 404);
-		deleteMemoryRecord(record.id);
+		preserveRecord(record, {
+			status: "archived",
+			validTo: (/* @__PURE__ */ new Date()).toISOString()
+		});
 		return c.json({ ok: true });
 	});
+	authenticated.post("/api/you/playbooks/:id/rules/:recordId/rollback", deps.strictRateLimitMiddleware, async (c) => {
+		const id = c.req.param("id");
+		const current = editableRecord(c.req.param("recordId"));
+		if (!PLAYBOOK_IDS.includes(id) || !current || playbookForRecord(current) !== id) return c.json({ error: "Playbook rule not found" }, 404);
+		const body = await c.req.json().catch(() => ({}));
+		const versionId = typeof body.versionId === "string" ? body.versionId : "";
+		const all = listAllUserContextRecords(ALL_MEMORY_STATUSES);
+		const target = playbookVersionChain(all, current.id).find((record) => record.id === versionId);
+		if (!target || target.id === current.id) return c.json({ error: "Previous version not found" }, 404);
+		const rolledBack = versionPlaybookRule(current, {
+			content: target.content,
+			tags: target.tags,
+			evidence: target.evidence,
+			explicitness: "explicit"
+		});
+		return c.json({
+			ok: true,
+			rule: buildPersonalPlaybooks([...all, rolledBack]).find((playbook) => playbook.id === id)?.rules.find((rule) => rule.id === rolledBack.id)
+		});
+	});
 	authenticated.patch("/api/you/insights/:id", deps.strictRateLimitMiddleware, async (c) => {
 		const config = deps.service.currentConfig;
 		const existing = editableRecord(c.req.param("id"));
@@ -622,6 +748,36 @@ function registerYouRoutes(authenticated, deps) {
 			status: "drafting",
 			href: buildRoutineAutomationDraftHref(existing)
 		});
+		if (existing.kind === "task_lesson" || existing.kind === "derived_insight") {
+			upsertMemoryRecord({
+				providerId: "local",
+				kind: "task_lesson",
+				sourceAgentId: selectedAgentId(config),
+				content: existing.content,
+				source: {
+					provider: "local",
+					path: "you://insight-proposal"
+				},
+				confidence: 1,
+				tags: [
+					"user-understanding",
+					PERSONAL_PLAYBOOK_RULE_TAG,
+					`${PERSONAL_PLAYBOOK_ORDER_PREFIX}1000`
+				],
+				status: "active",
+				sensitivity: existing.sensitivity,
+				explicitness: "explicit",
+				durability: "durable",
+				importance: existing.importance,
+				disclosurePolicy: existing.disclosurePolicy,
+				evidence: existing.evidence
+			});
+			preserveRecord(existing, { tags: [...new Set([...existing.tags ?? [], INSIGHT_ACCEPTED_TAG])] });
+			return c.json({
+				ok: true,
+				status: "saved"
+			});
+		}
 		const title = existing.content.trim().split(/\r?\n/)[0].slice(0, 72);
 		const uiLocale = body.uiLocale === "zh" ? "zh" : "en";
 		const contractDraft = await draftGoalContract({

package/dist/src/gateway/hono/sse.d.ts

@@ -1,5 +1,7 @@
 import type { Context } from 'hono';
 import type { GatewayService } from '../service.js';
+/** Close long-lived gateway event streams before the HTTP server starts draining. */
+export declare function closeAllEventStreams(): void;
 export interface SSEHandlerConfig {
     service: GatewayService;
     maxSseConnections?: number;

package/dist/src/gateway/hono/sse.js

@@ -9,6 +9,10 @@ import { streamSSE } from "hono/streaming";
 init_logger();
 const log = createLogger("Gateway:SSE");
 const activeConnections = /* @__PURE__ */ new Map();
+/** Close long-lived gateway event streams before the HTTP server starts draining. */
+function closeAllEventStreams() {
+	for (const controller of activeConnections.values()) controller.abort();
+}
 function isValidAgentRequest(body) {
 	if (!body || typeof body !== "object") return false;
 	const b = body;
@@ -341,17 +345,20 @@ function createEventsSSEHandler(config) {
 				}
 			}, 3e4);
 			await new Promise((resolve) => {
-				stream.onAbort(() => {
+				const finish = () => {
 					aborted = true;
 					clearInterval(keepAlive);
 					cleanup();
 					activeConnections.delete(sessionId);
 					log.debug({ sessionId }, "Event stream disconnected");
 					resolve();
-				});
+				};
+				stream.onAbort(finish);
+				abortController.signal.addEventListener("abort", () => stream.abort(), { once: true });
+				if (abortController.signal.aborted) stream.abort();
 			});
 		});
 	};
 }
 //#endregion
-export { createAgentResumeHandler, createAgentSSEHandler, createEventsSSEHandler, createSendHandler };
+export { closeAllEventStreams, createAgentResumeHandler, createAgentSSEHandler, createEventsSSEHandler, createSendHandler };

package/dist/src/gateway/run-loop.js

@@ -15,7 +15,8 @@ async function runGatewayLoop(opts) {
 	let lock = await acquireGatewayLock(opts.configPath, { port: opts.port });
 	let server = null;
 	let shuttingDown = false;
-	let restartResolver = null;
+	let forceCloseRequested = false;
+	let loopResolver = null;
 	const cleanupSignals = () => {
 		process.removeListener("SIGTERM", onSigterm);
 		process.removeListener("SIGINT", onSigint);
@@ -51,20 +52,27 @@ async function runGatewayLoop(opts) {
 			return;
 		}
 		shuttingDown = false;
-		restartResolver?.();
+		forceCloseRequested = false;
+		loopResolver?.("restart");
 	};
 	const handleStopAfterClose = async () => {
 		await releaseLock();
-		exitProcess(0);
+		loopResolver?.("stop");
 	};
 	const DRAIN_TIMEOUT_MS = 3e4;
 	const SHUTDOWN_TIMEOUT_MS = 15e3;
 	const requestShutdown = (action, signal) => {
-		if (shuttingDown) return;
+		if (shuttingDown) {
+			if (!forceCloseRequested && (signal === "SIGINT" || signal === "SIGTERM")) {
+				forceCloseRequested = true;
+				console.warn(`[GatewayRunLoop] Received ${signal} again; force closing connections`);
+				server?.forceCloseConnections();
+			}
+			return;
+		}
 		shuttingDown = true;
 		const isRestart = action === "restart";
 		console.log(`[GatewayRunLoop] Received ${signal}; ${isRestart ? "restarting" : "shutting down"}`);
-		cleanupSignals();
 		const forceExitMs = isRestart ? DRAIN_TIMEOUT_MS + SHUTDOWN_TIMEOUT_MS : SHUTDOWN_TIMEOUT_MS;
 		const forceExitTimer = setTimeout(() => {
 			console.error("[GatewayRunLoop] Shutdown timed out; force exiting");
@@ -129,9 +137,11 @@ async function runGatewayLoop(opts) {
 				exitProcess(1);
 				return;
 			}
-			await new Promise((resolve) => {
-				restartResolver = resolve;
+			const action = await new Promise((resolve) => {
+				loopResolver = resolve;
 			});
+			loopResolver = null;
+			if (action === "stop") return;
 			console.log("[GatewayRunLoop] Restart signal received, restarting gateway...");
 		}
 	} finally {

package/dist/src/gateway/server.d.ts

@@ -23,6 +23,7 @@ export declare class GatewayServer {
         restartExpectedMs?: number | null;
     }): Promise<void>;
     stop(): Promise<void>;
+    forceCloseConnections(): void;
     get isRunning(): boolean;
     get serviceInstance(): GatewayService;
 }

package/dist/src/gateway/server.js

@@ -2,6 +2,7 @@ import { resolveGatewayBindHost, resolveGatewayListenHosts } from "../config/gat
 import { ensureXopcCliOnPath } from "../infra/path-env.js";
 import { resolveGatewayListenPlan } from "./listen.js";
 import { GatewayService } from "./service.js";
+import { closeAllEventStreams } from "./hono/sse.js";
 import { handleSiteShareUpgrade } from "../share/site-share-router.js";
 import { createHonoApp } from "./hono/app.js";
 import { serve } from "@hono/node-server";
@@ -94,6 +95,7 @@ var GatewayServer = class {
 	}
 	async stop() {
 		console.log("[GatewayServer] Stopping gateway server...");
+		closeAllEventStreams();
 		const closeServer = async (server) => {
 			if (!server) return;
 			const forceClose = setTimeout(() => {
@@ -113,6 +115,13 @@ var GatewayServer = class {
 		await this.service.stop();
 		console.log("[GatewayServer] Gateway server stopped");
 	}
+	forceCloseConnections() {
+		const close = (server) => {
+			server?.closeAllConnections?.();
+		};
+		close(this.server);
+		for (const extra of this.extraServers) close(extra);
+	}
 	get isRunning() {
 		return this.server !== void 0;
 	}

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

@@ -1,6 +1,11 @@
 import { inboundCorrelationMetadataFromAsyncLogContext, updateAsyncLogContext } from "../../utils/logger/context.js";
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { updateInteractionStateFromMessage } from "../../storage/sqlite/interaction-state-repository.js";
+import { completeTaskOutcome, startTaskOutcome, updateTaskOutcome } from "../../storage/sqlite/task-outcome-repository.js";
+import "../../storage/sqlite/index.js";
+import { init_session_key, parseSessionKey } from "../../routing/session-key.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";
@@ -11,6 +16,7 @@ import { coalesceThinkingDeltas } from "../chat-stream/thinking-delta-coalescer.
 import crypto from "crypto";
 //#region src/gateway/service/run-gateway-agent.ts
 init_logger();
+init_session_key();
 const log = createLogger("Gateway:Service");
 /**
 * @param runOptions.signal — When set (e.g. client disconnect), aborts in-flight generation and persists partial output.
@@ -24,6 +30,11 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 	const runId = crypto.randomUUID();
 	const { agentService, bus, runRelay, runAbortControllers, activeWebchatRunBySession, sessionIndex: sessionIndexFromDeps, emit } = deps;
 	const sessionIndex = sessionIndexFromDeps;
+	let taskOutcomeStarted = false;
+	let taskOutcomeStatus = "failed";
+	let taskOutcomeSummary = "Agent run ended unexpectedly";
+	let taskContract;
+	const taskEvidence = [];
 	let webchatSessionKey;
 	let webchatSessionId;
 	let webchatStaleSkip = false;
@@ -40,15 +51,65 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 		runAbortControllers.set(runId, new AbortController());
 	}
 	const streamSessionKey = webchatSessionKey ?? chatId;
+	if (webchatSessionKey) {
+		const parsedSession = parseSessionKey(webchatSessionKey);
+		if (!parsedSession) throw new Error("Resolved webchat session key is invalid");
+		updateInteractionStateFromMessage({
+			sessionKey: webchatSessionKey,
+			message
+		});
+		recordExplicitRelationshipFollowUp({
+			sessionKey: webchatSessionKey,
+			sourceAgentId: parsedSession.agentId,
+			message
+		});
+		startTaskOutcome({
+			runId,
+			sessionKey: webchatSessionKey,
+			channel,
+			objective: message.trim()
+		});
+		taskOutcomeStarted = true;
+	}
 	const mapper = new ChatStreamMapper({
 		runId,
 		sessionKey: streamSessionKey,
 		channel
 	});
 	let registeredActiveWebchatRun = false;
+	const addTaskEvidence = (evidence) => {
+		if (taskEvidence.some((item) => item.kind === evidence.kind && item.title === evidence.title)) return;
+		taskEvidence.push(evidence);
+	};
+	const captureTaskEvent = (event) => {
+		if (event.type === "turn_plan") {
+			taskContract = {
+				objective: message.trim(),
+				deliverables: [],
+				acceptanceCriteria: event.payload.plan.map((item) => item.step),
+				constraints: [],
+				approvalRequired: []
+			};
+			return;
+		}
+		if (event.type === "patch_applied") {
+			addTaskEvidence({
+				kind: "state",
+				title: "Changes applied",
+				summary: `${event.payload.added} additions and ${event.payload.removed} removals`
+			});
+			return;
+		}
+		if (event.type === "command_completed" && event.payload.exitCode === 0 && /(^|\s)(test|vitest|jest|pytest|lint|typecheck|build)(\s|$|:)/i.test(event.payload.command)) addTaskEvidence({
+			kind: "test",
+			title: event.payload.command.slice(0, 120),
+			summary: event.payload.durationMs === void 0 ? "Command completed successfully" : `Command completed successfully in ${event.payload.durationMs} ms`
+		});
+	};
 	const publishStreamEvent = (event) => channel === "webchat" ? runRelay.publish(runId, event) ?? event : event;
 	const emitAndYield = function* (events) {
 		for (const event of events) {
+			if (taskOutcomeStarted) captureTaskEvent(event);
 			const relayedEvent = publishStreamEvent(event);
 			if (channel === "webchat") emit("agent.stream", {
 				sessionKey: streamSessionKey,
@@ -61,6 +122,8 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 	try {
 		if (channel === "webchat" && webchatSessionKey) {
 			if (webchatStaleSkip) {
+				taskOutcomeStatus = "cancelled";
+				taskOutcomeSummary = "Stale inbound message skipped";
 				yield* emitAndYield(mapper.end("cancelled", "Stale inbound after abort (clientCreatedAtMs before cutoff)"));
 				runRelay.complete(runId);
 				runAbortControllers.delete(runId);
@@ -97,6 +160,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";
+				taskOutcomeStatus = mergedSignal.aborted ? "cancelled" : "succeeded";
+				taskOutcomeSummary = endSummary;
 				yield* emitAndYield(mapper.end(endStatus, endSummary));
 				runRelay.complete(runId);
 				try {
@@ -121,6 +186,8 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 					channel: "webchat"
 				}, `Agent processing failed: ${em}`);
 				streamError = em;
+				taskOutcomeStatus = "failed";
+				taskOutcomeSummary = em;
 				const errorContent = formatAgentRunErrorForClient(streamError);
 				yield* emitAndYield(mapper.error(errorContent));
 				yield* emitAndYield(mapper.end("error", streamError));
@@ -198,12 +265,16 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 			payload: { messageId }
 		}]);
 		yield* emitAndYield(mapper.end("success", "Message processed"));
+		taskOutcomeStatus = "succeeded";
+		taskOutcomeSummary = "Message processed";
 		return {
 			status: "ok",
 			summary: "Message processed"
 		};
 	} catch (error) {
 		const em = error instanceof Error ? error.message : String(error);
+		taskOutcomeStatus = "failed";
+		taskOutcomeSummary = em;
 		log.error({
 			err: error,
 			errorMessage: em,
@@ -213,6 +284,19 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 			chatId
 		}, `Agent run failed: ${em}`);
 		throw error;
+	} finally {
+		if (taskOutcomeStarted) {
+			updateTaskOutcome({
+				runId,
+				...taskContract ? { contract: taskContract } : {},
+				evidence: taskEvidence
+			});
+			completeTaskOutcome({
+				runId,
+				status: taskOutcomeStatus,
+				summary: taskOutcomeSummary
+			});
+		}
 	}
 }
 //#endregion

package/dist/src/gateway/service.d.ts

@@ -11,6 +11,7 @@ import { AgentRunRelay } from './agent-run-relay.js';
 import { type EnqueueGoalRunOptions } from '../goals/index.js';
 import { ProjectService } from '../projects/index.js';
 import { LocalAppService } from '../local-apps/index.js';
+import { type BrowserRecipeService } from '../browser/recipes/index.js';
 import { GatewaySessionsApi } from './service/sessions-api.js';
 import { GatewayMarketplaceService } from './service/marketplace-service.js';
 import { GatewayAgentRunner } from './service/agent-runner.js';
@@ -26,6 +27,7 @@ export declare class GatewayService {
     private _agentService;
     private channelManager;
     private automationService;
+    private browserRecipeService;
     private notesService;
     private extensionLoader;
     private extensionMetadataSnapshot;
@@ -42,6 +44,7 @@ export declare class GatewayService {
     private auth;
     private readonly sse;
     getConfig(): Config;
+    get browserRecipes(): BrowserRecipeService;
     private stopGatewayUpdateCheck;
     /** When set (e.g. by `GatewayServer`), `triggerGatewayProcessRestart` can stop HTTP then exit. */
     private gatewayShutdownForRestart;