@xopcai/xopc 0.0.161 → 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/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;

package/dist/src/gateway/service.js

@@ -78,6 +78,8 @@ import { runBootstrapMigrationsSync } from "../migrations/runner.js";
 import { MobileNotificationService } from "../mobile/notification-service.js";
 import { LocalAppService } from "../local-apps/service.js";
 import "../local-apps/index.js";
+import { createRuntimeBrowserRecipeService } from "../browser/recipes/runtime-service.js";
+import "../browser/recipes/index.js";
 import { scheduleGatewayUpdateCheck } from "../infra/update-startup.js";
 import { resolveChannelConnectDeferSet } from "./resolve-channel-connect-defer.js";
 import { restartGatewayProcessWithFreshPid } from "./respawn.js";
@@ -108,6 +110,7 @@ var GatewayService = class {
 	_agentService = null;
 	channelManager;
 	automationService;
+	browserRecipeService = null;
 	notesService;
 	extensionLoader = null;
 	extensionMetadataSnapshot = null;
@@ -126,6 +129,13 @@ var GatewayService = class {
 	getConfig() {
 		return this.config;
 	}
+	get browserRecipes() {
+		if (!this.browserRecipeService) this.browserRecipeService = createRuntimeBrowserRecipeService({
+			getConfig: () => this.config,
+			emit: (type, payload) => this.emit(type, payload)
+		});
+		return this.browserRecipeService;
+	}
 	stopGatewayUpdateCheck = null;
 	/** When set (e.g. by `GatewayServer`), `triggerGatewayProcessRestart` can stop HTTP then exit. */
 	gatewayShutdownForRestart = null;
@@ -322,6 +332,7 @@ var GatewayService = class {
 			},
 			extensionRegistry: this.extensionLoader?.getRegistry(),
 			getAutomationService: () => this.automationService,
+			getBrowserRecipeService: () => this.browserRecipes,
 			getNotesService: () => this.notesService,
 			getProjectService: () => this.projects,
 			getWorkItemService: () => new WorkItemService(),
@@ -361,6 +372,7 @@ var GatewayService = class {
 			getDefaultAgentId: () => getDefaultAgentId(this.config),
 			getProjectWorkspaceRoot: (projectId) => this.projects.get(projectId)?.workspaceRoot,
 			workflowRunService: this.createWorkflowRunService(),
+			browserRecipeService: this.browserRecipes,
 			onRunCompleted: (run) => this.handleAutomationRunCompleted(run)
 		});
 		this._agentService.persistentGoals.setWebchatContinuationScheduler((sessionKey, message) => {
@@ -671,6 +683,7 @@ var GatewayService = class {
 			agentService: this.agentService,
 			getDefaultAgentId: () => getDefaultAgentId(this.config),
 			workflowRunService: this.createWorkflowRunService(),
+			browserRecipeService: this.browserRecipes,
 			onRunCompleted: (run) => this.handleAutomationRunCompleted(run)
 		});
 		this.startAutomationProductEventBridge();
@@ -822,6 +835,7 @@ var GatewayService = class {
 		this.connectorMemorySyncCoordinator = null;
 		this.connectedKnowledgeCoordinator?.stop();
 		this.connectedKnowledgeCoordinator = null;
+		await this.browserRecipeService?.shutdown();
 		if (this.browserExtensionRelease) {
 			await this.browserExtensionRelease();
 			this.browserExtensionRelease = null;

package/dist/src/proactive/insight-repository.d.ts

@@ -13,6 +13,8 @@ export declare function createProactiveInsight(input: {
     whyItMatters: string;
     nextAction: string;
     evidence: ProactiveEvidence[];
+    valueScore: number;
+    valueReasons: string[];
     nowMs?: number;
 }): ProactiveInsight | null;
 export declare function setProactiveInsightStatus(id: string, status: ProactiveInsightStatus, nowMs?: number, expectedStatus?: ProactiveInsightStatus): ProactiveInsight | null;

package/dist/src/proactive/insight-repository.js

@@ -14,6 +14,8 @@ function insightFromRow(row) {
 		nextAction: row.next_action,
 		evidence: JSON.parse(row.evidence_json),
 		status: row.status,
+		valueScore: row.value_score,
+		valueReasons: JSON.parse(row.value_reasons_json),
 		createdAt: row.created_at,
 		updatedAt: row.updated_at
 	};
@@ -58,8 +60,9 @@ function createProactiveInsight(input) {
 	runSqliteWriteTransaction((db) => {
 		created = db.prepare(`INSERT OR IGNORE INTO proactive_insights (
         insight_id, watch_id, run_id, kind, title, summary, why_it_matters,
-        next_action, evidence_json, content_hash, status, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'unread', ?, ?)`).run(id, input.watchId, input.runId, input.kind, input.title, input.summary, input.whyItMatters, input.nextAction, JSON.stringify(input.evidence), contentHash, now, now).changes > 0;
+        next_action, evidence_json, content_hash, status, value_score,
+        value_reasons_json, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'unread', ?, ?, ?, ?)`).run(id, input.watchId, input.runId, input.kind, input.title, input.summary, input.whyItMatters, input.nextAction, JSON.stringify(input.evidence), contentHash, input.valueScore, JSON.stringify(input.valueReasons), now, now).changes > 0;
 	});
 	return created ? listProactiveInsights({ limit: 100 }).find((item) => item.id === id) ?? null : null;
 }

package/dist/src/proactive/run-processor.js

@@ -1,7 +1,10 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { getRelationshipSettings, isProactiveSupportAllowed } from "../storage/sqlite/relationship-settings-repository.js";
+import "../storage/sqlite/index.js";
 import { getFocusWatchByAutomationId, recordFocusWatchRun } from "./watch-repository.js";
-import { createProactiveInsight } from "./insight-repository.js";
+import { createProactiveInsight, listProactiveInsights } from "./insight-repository.js";
+import { scoreProactiveValue } from "./value-score.js";
 //#region src/proactive/run-processor.ts
 init_logger();
 const log = createLogger("ProactiveRunProcessor");
@@ -105,6 +108,22 @@ function processFocusAutomationRun(run) {
 		nowMs: run.endedAtMs
 	})) return { handled: true };
 	if (!result.meaningful) return { handled: true };
+	if (!isProactiveSupportAllowed(getRelationshipSettings(), {
+		now: new Date(run.endedAtMs),
+		topic: watch.kind
+	})) return { handled: true };
+	const history = listProactiveInsights({
+		status: ["approved", "dismissed"],
+		limit: 50
+	});
+	const value = scoreProactiveValue({
+		kind: watch.kind,
+		evidenceCount: result.evidence.length,
+		hasNextAction: Boolean(result.nextAction),
+		approvedCount: history.filter((item) => item.status === "approved").length,
+		dismissedCount: history.filter((item) => item.status === "dismissed").length
+	});
+	if (!value.shouldDeliver) return { handled: true };
 	const insight = createProactiveInsight({
 		watchId: watch.id,
 		runId: run.id,
@@ -114,6 +133,8 @@ function processFocusAutomationRun(run) {
 		whyItMatters: result.whyItMatters,
 		nextAction: result.nextAction,
 		evidence: result.evidence,
+		valueScore: value.score,
+		valueReasons: value.reasons,
 		nowMs: run.endedAtMs
 	});
 	return insight ? {

package/dist/src/proactive/types.d.ts

@@ -49,6 +49,8 @@ export interface ProactiveInsight {
     whyItMatters: string;
     nextAction: string;
     evidence: ProactiveEvidence[];
+    valueScore: number;
+    valueReasons: string[];
     status: ProactiveInsightStatus;
     createdAt: number;
     updatedAt: number;