@xopcai/xopc 0.0.178 → 0.0.179

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

@@ -2,9 +2,10 @@ import { inboundCorrelationMetadataFromAsyncLogContext, updateAsyncLogContext }
 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 { resolveExecutionContext } from "../../work/execution-context.js";
+import { OutcomeRunCoordinator } from "../../work/outcome-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";
@@ -30,13 +31,12 @@ 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 outcomeRun;
+	let executionReceiptStatus = "failed";
+	let executionReceiptSummary = "Agent run ended unexpectedly";
 	let webchatSessionKey;
 	let webchatSessionId;
+	let webchatMetadata;
 	let webchatStaleSkip = false;
 	if (channel === "webchat") {
 		const resolved = resolveWebchatSessionKey({ sessionKey: chatId });
@@ -45,6 +45,7 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 		const meta = await sessionIndex.getSessionMetadata(webchatSessionKey);
 		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);
@@ -52,6 +53,7 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 	}
 	const streamSessionKey = webchatSessionKey ?? chatId;
 	if (webchatSessionKey) {
+		if (!webchatMetadata) throw new Error("Session metadata is unavailable");
 		const parsedSession = parseSessionKey(webchatSessionKey);
 		if (!parsedSession) throw new Error("Resolved webchat session key is invalid");
 		updateInteractionStateFromMessage({
@@ -63,13 +65,17 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 			sourceAgentId: parsedSession.agentId,
 			message
 		});
-		startTaskOutcome({
+		const executionContext = resolveExecutionContext({
 			runId,
 			sessionKey: webchatSessionKey,
 			channel,
-			objective: message.trim()
+			metadata: webchatMetadata
+		});
+		outcomeRun = OutcomeRunCoordinator.start({
+			runId,
+			context: executionContext,
+			fallbackObjective: message
 		});
-		taskOutcomeStarted = true;
 	}
 	const mapper = new ChatStreamMapper({
 		runId,
@@ -77,39 +83,28 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 		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 === "task_plan_updated") {
+			outcomeRun?.capturePlan(event.payload.items);
+			return;
+		}
 		if (event.type === "turn_plan") {
-			taskContract = {
-				objective: message.trim(),
-				deliverables: [],
-				acceptanceCriteria: event.payload.plan.map((item) => item.step),
-				constraints: [],
-				approvalRequired: []
-			};
+			outcomeRun?.capturePlan(event.payload.plan.map((item) => ({
+				title: item.step,
+				status: item.status
+			})));
 			return;
 		}
 		if (event.type === "patch_applied") {
-			addTaskEvidence({
-				kind: "state",
-				title: "Changes applied",
-				summary: `${event.payload.added} additions and ${event.payload.removed} removals`
-			});
+			outcomeRun?.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)) 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`
-		});
+		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);
 	};
 	const publishStreamEvent = (event) => channel === "webchat" ? runRelay.publish(runId, event) ?? event : event;
 	const emitAndYield = function* (events) {
 		for (const event of events) {
-			if (taskOutcomeStarted) captureTaskEvent(event);
+			if (outcomeRun) captureTaskEvent(event);
 			const relayedEvent = publishStreamEvent(event);
 			if (channel === "webchat") emit("agent.stream", {
 				sessionKey: streamSessionKey,
@@ -122,8 +117,8 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 	try {
 		if (channel === "webchat" && webchatSessionKey) {
 			if (webchatStaleSkip) {
-				taskOutcomeStatus = "cancelled";
-				taskOutcomeSummary = "Stale inbound message skipped";
+				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);
@@ -160,8 +155,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;
+				executionReceiptStatus = mergedSignal.aborted ? "cancelled" : "succeeded";
+				executionReceiptSummary = endSummary;
 				yield* emitAndYield(mapper.end(endStatus, endSummary));
 				runRelay.complete(runId);
 				try {
@@ -186,8 +181,8 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 					channel: "webchat"
 				}, `Agent processing failed: ${em}`);
 				streamError = em;
-				taskOutcomeStatus = "failed";
-				taskOutcomeSummary = em;
+				executionReceiptStatus = "failed";
+				executionReceiptSummary = em;
 				const errorContent = formatAgentRunErrorForClient(streamError);
 				yield* emitAndYield(mapper.error(errorContent));
 				yield* emitAndYield(mapper.end("error", streamError));
@@ -265,16 +260,16 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 			payload: { messageId }
 		}]);
 		yield* emitAndYield(mapper.end("success", "Message processed"));
-		taskOutcomeStatus = "succeeded";
-		taskOutcomeSummary = "Message processed";
+		executionReceiptStatus = "succeeded";
+		executionReceiptSummary = "Message processed";
 		return {
 			status: "ok",
 			summary: "Message processed"
 		};
 	} catch (error) {
 		const em = error instanceof Error ? error.message : String(error);
-		taskOutcomeStatus = "failed";
-		taskOutcomeSummary = em;
+		executionReceiptStatus = "failed";
+		executionReceiptSummary = em;
 		log.error({
 			err: error,
 			errorMessage: em,
@@ -285,17 +280,17 @@ async function* runGatewayAgent(deps, message, channel, chatId, attachments, thi
 		}, `Agent run failed: ${em}`);
 		throw error;
 	} finally {
-		if (taskOutcomeStarted) {
-			updateTaskOutcome({
-				runId,
-				...taskContract ? { contract: taskContract } : {},
-				evidence: taskEvidence
-			});
-			completeTaskOutcome({
-				runId,
-				status: taskOutcomeStatus,
-				summary: taskOutcomeSummary
+		if (outcomeRun) try {
+			outcomeRun.finalize({
+				status: executionReceiptStatus,
+				summary: executionReceiptSummary
 			});
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			log.warn({
+				err,
+				runId
+			}, `Outcome run finalization failed: ${errorMessage}`);
 		}
 	}
 }

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

@@ -1,6 +1,7 @@
 import { AgentService } from '../agent/service.js';
 import { MessageBus } from '../infra/bus/index.js';
 import { AutomationService } from '../automations/index.js';
+import { DiscussionLiveWorker, DiscussionService, DiscussionWorker } from '../discussions/index.js';
 import { NotesService } from '../notes/index.js';
 import { WorkflowRunService } from '../workflows/service/workflow-run-service.js';
 import { ExtensionLoader } from '../extensions/index.js';
@@ -14,7 +15,7 @@ import { ProjectService } from '../projects/index.js';
 import { LocalAppService } from '../local-apps/index.js';
 import { WorkItemService } from '../work-items/index.js';
 import { type BrowserRecipeService } from '../browser/recipes/index.js';
-import { listInsights, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveWorker } from '../proactive/index.js';
+import { listInsights, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker } from '../proactive/index.js';
 import { GatewaySessionsApi } from './service/sessions-api.js';
 import { GatewayMarketplaceService } from './service/marketplace-service.js';
 import { GatewayAgentRunner } from './service/agent-runner.js';
@@ -67,6 +68,7 @@ export declare class GatewayService {
     private mobileNotifications;
     private connectorSupervisor;
     private connectorLearningCoordinator;
+    private connectedSourceChangePublisher;
     private connectedKnowledgeCoordinator;
     private stopAutomationProductEventBridge;
     private stopSessionTranscriptAutomationEvents;
@@ -92,6 +94,9 @@ export declare class GatewayService {
     /** First-class project grouping surface. */
     readonly projects: ProjectService;
     readonly workItems: WorkItemService;
+    readonly discussions: DiscussionService;
+    readonly discussionWorker: DiscussionWorker;
+    readonly discussionLiveWorker: DiscussionLiveWorker;
     /** Local user-created apps, their coder projects, previews, and installs. */
     readonly localApps: LocalAppService;
     /** Unified durable event spine for proactive scenarios. */
@@ -100,6 +105,7 @@ export declare class GatewayService {
     readonly proactiveInbox: ProactiveInboxService;
     readonly proactiveInsights: typeof listInsights;
     readonly proactiveWorker: ProactiveWorker;
+    readonly proactiveTemporalWorker: ProactiveTemporalWorker;
     readonly proactiveInboxWorker: ProactiveInboxWorker;
     constructor(serviceConfig?: GatewayServiceConfig);
     /** Lazy AgentService — constructed on first use or during `start()`. */
@@ -130,6 +136,7 @@ export declare class GatewayService {
     private schedulePostReadySidecars;
     private runPostReadySidecars;
     start(): Promise<void>;
+    private ensureDefaultProactiveScenarioSubscriptions;
     /** Called when the HTTP listener is bound (before deferred channel work). */
     markHttpListening(): void;
     isGatewayReady(): boolean;

package/dist/src/gateway/service.js

@@ -22,8 +22,22 @@ import { GoalRunner } from "../goals/goal-runner.js";
 import { GoalNotificationService } from "../goals/goal-notifications.js";
 import "../goals/index.js";
 import { resolveEffectiveGatewayPort } from "./host.js";
+import { sanitizeTunnelConfig } from "../tunnel/tunnel-config.js";
+import { wireTunnelEventsToGateway } from "../tunnel/gateway-lifecycle.js";
+import { buckets } from "./rate-limit/buckets.js";
+import { isGatewayStrictSecurityEnabled } from "./rate-limit/env-flags.js";
+import "./rate-limit/index.js";
+import { AutomationService } from "../automations/service/automation-service.js";
+import "../automations/index.js";
+import { WorkItemService } from "../work-items/work-item-service.js";
+import { buildWorkItemAgentContext } from "../work-items/agent-context.js";
+import "../work-items/index.js";
+import { OutcomeProjectionService } from "../work/outcome-projection-service.js";
 import { ProjectService } from "../projects/project-service.js";
 import "../projects/index.js";
+import { ProactiveScenarioService } from "../proactive/scenarios/service.js";
+import { WorkIntakeService } from "../work/work-intake-service.js";
+import "../work/index.js";
 import { disposeAllSessionMcpRuntimes } from "../agent/mcp/bundle-mcp-runtime.js";
 import "../agent/mcp/bundle-mcp-tools.js";
 import { onSessionTranscriptUpdate } from "../session/transcript-events.js";
@@ -35,8 +49,6 @@ import { MessageBus, MessageBusShutdownError } from "../infra/bus/queue.js";
 import "../infra/bus/index.js";
 import { AgentService } from "../agent/service.js";
 import { ensureStarterAgentsInitialized } from "../agent/starter-agents.js";
-import { AutomationService } from "../automations/service/automation-service.js";
-import "../automations/index.js";
 import { setPairingBroadcastSink } from "../channels/pairing/pairing-events.js";
 import { registerClarifyBridge } from "./clarify-runtime.js";
 import { ChannelManager } from "../channels/manager.js";
@@ -45,7 +57,13 @@ import "../config/index.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
 import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
+import { ConnectedSourceChangePublisher } from "../connectors/source-change-publisher.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.js";
+import { DiscussionService } from "../discussions/service.js";
+import { DiscussionPipeline } from "../discussions/pipeline.js";
+import { DiscussionLiveWorker } from "../discussions/live-worker.js";
+import { DiscussionWorker } from "../discussions/worker.js";
+import "../discussions/index.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { reconcileDreamingAutomations } from "./dreaming-automation-reconciler.js";
 import { NotesStore } from "../notes/store.js";
@@ -54,20 +72,12 @@ import { NotesService } from "../notes/service.js";
 import "../notes/index.js";
 import { buildWorkflowChildTools } from "../agent/workflow/workflow-child-tools.js";
 import { WorkflowRunService } from "../workflows/service/workflow-run-service.js";
-import { WorkItemService } from "../work-items/work-item-service.js";
-import { buildWorkItemAgentContext } from "../work-items/agent-context.js";
-import "../work-items/index.js";
 import { WorkflowSessionBridge } from "../workflows/service/workflow-session-bridge.js";
 import { HeartbeatService, heartbeatRunnerConfigFromConfig } from "./heartbeat/service.js";
 import "./heartbeat/index.js";
-import { wireTunnelEventsToGateway } from "../tunnel/gateway-lifecycle.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
 import { getExposureManager } from "../remote-access/exposure-manager.js";
-import { sanitizeTunnelConfig } from "../tunnel/tunnel-config.js";
 import { assertGatewayAuthNotKnownWeak } from "./security/known-weak-secrets.js";
-import { buckets } from "./rate-limit/buckets.js";
-import { isGatewayStrictSecurityEnabled } from "./rate-limit/env-flags.js";
-import "./rate-limit/index.js";
 import { assertGatewayRuntimeConfig } from "./runtime-config.js";
 import { auditGatewayConfig } from "./security/audit.js";
 import { ModelCatalogSyncService } from "../providers/model-catalog-sync-service.js";
@@ -77,11 +87,12 @@ 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 { mapProductEventToProactive } from "../proactive/events/product-event-bridge.js";
 import { ProactiveEventService } from "../proactive/service.js";
-import { ProactiveScenarioService } from "../proactive/scenarios/service.js";
 import { ReadonlyProactiveAgentExecutor } from "../proactive/execution/agent-executor.js";
 import { listInsights } from "../proactive/execution/repository.js";
 import { ProactiveWorker } from "../proactive/execution/worker.js";
+import { ProactiveTemporalWorker } from "../proactive/temporal/worker.js";
 import { ProactiveInboxService } from "../proactive/inbox/service.js";
 import { ProactiveInboxWorker } from "../proactive/inbox/worker.js";
 import "../proactive/index.js";
@@ -164,6 +175,7 @@ var GatewayService = class {
 	mobileNotifications = null;
 	connectorSupervisor = null;
 	connectorLearningCoordinator = null;
+	connectedSourceChangePublisher = null;
 	connectedKnowledgeCoordinator = null;
 	stopAutomationProductEventBridge = null;
 	stopSessionTranscriptAutomationEvents = null;
@@ -191,6 +203,9 @@ var GatewayService = class {
 	/** First-class project grouping surface. */
 	projects;
 	workItems;
+	discussions;
+	discussionWorker;
+	discussionLiveWorker;
 	/** Local user-created apps, their coder projects, previews, and installs. */
 	localApps;
 	/** Unified durable event spine for proactive scenarios. */
@@ -199,6 +214,7 @@ var GatewayService = class {
 	proactiveInbox = new ProactiveInboxService();
 	proactiveInsights = listInsights;
 	proactiveWorker;
+	proactiveTemporalWorker;
 	proactiveInboxWorker;
 	constructor(serviceConfig = {}) {
 		this.serviceConfig = serviceConfig;
@@ -207,6 +223,7 @@ var GatewayService = class {
 		runBootstrapMigrationsSync(this.configPath);
 		this.config = loadConfig(this.configPath);
 		this.proactiveWorker = new ProactiveWorker(new ReadonlyProactiveAgentExecutor(() => this.config));
+		this.proactiveTemporalWorker = new ProactiveTemporalWorker(this.proactive);
 		this.proactiveInboxWorker = new ProactiveInboxWorker({ deliver: async ({ inboxItem }) => {
 			this.sse.emit("proactive.inbox.created", inboxItem);
 			await this.createMobileNotificationService().deliverGatewayEvent("proactive.inbox.created", inboxItem);
@@ -268,6 +285,50 @@ var GatewayService = class {
 		this.notesService = new NotesService(new NotesStore());
 		this.projects = new ProjectService(void 0, this.proactive);
 		this.workItems = new WorkItemService(void 0, this.proactive);
+		const emitDiscussion = (capture) => {
+			this.sse.emit("discussion.updated", capture);
+		};
+		this.discussions = new DiscussionService(this.notesService, this.projects, (type, payload) => {
+			this.sse.emit(type, payload);
+		});
+		this.discussionWorker = new DiscussionWorker(new DiscussionPipeline({
+			notes: this.notesService,
+			projects: this.projects,
+			getConfig: () => this.config,
+			onUpdated: emitDiscussion,
+			onCompleted: (capture, analysis) => {
+				const payload = {
+					discussionId: capture.id,
+					noteId: capture.noteId,
+					projectId: capture.projectId,
+					completedAt: capture.completedAt,
+					actionCount: analysis.actionItems.length,
+					unownedActionCount: analysis.actionItems.filter((item) => !item.owner).length,
+					undatedActionCount: analysis.actionItems.filter((item) => !item.dueDate).length,
+					riskCount: analysis.risks.length,
+					openQuestionCount: analysis.openQuestions.length
+				};
+				this.sse.emit("discussion.completed", payload);
+				publishAutomationProductEvent({
+					type: "discussion.completed",
+					source: "discussions",
+					payload,
+					occurredAtMs: capture.completedAt
+				});
+			}
+		}), emitDiscussion);
+		this.discussionLiveWorker = new DiscussionLiveWorker({
+			notes: this.notesService,
+			projects: this.projects,
+			getConfig: () => this.config,
+			onDiscussionUpdated: emitDiscussion,
+			onTranscriptUpdated: (discussionId, sequence) => {
+				this.sse.emit("discussion.transcript.updated", {
+					discussionId,
+					sequence
+				});
+			}
+		});
 		this.localApps = new LocalAppService({
 			projects: this.projects,
 			workspaceRoot: this.workspacePath,
@@ -430,7 +491,7 @@ var GatewayService = class {
 		if (!this.goalRunner) this.goalRunner = new GoalRunner({
 			maxConcurrent: 1,
 			defaultMaxRetries: 2,
-			ensureSession: async (goal) => {
+			ensureSession: async (goal, executionContext) => {
 				const existing = goal.activeSessionKey?.trim();
 				if (existing) return existing;
 				const agentId = goal.agentId || getDefaultAgentId(this.config);
@@ -452,6 +513,16 @@ var GatewayService = class {
 						accountId: "default",
 						peerKind: "direct",
 						peerId
+					},
+					projectId: goal.projectId,
+					customData: {
+						goalId: goal.id,
+						origin: "goal",
+						triggerKind: executionContext?.triggerKind ?? "user",
+						...executionContext?.outcomeId ? { outcomeId: executionContext.outcomeId } : {},
+						...executionContext?.workItemId ? { workItemId: executionContext.workItemId } : {},
+						...executionContext?.contextTraceId ? { contextTraceId: executionContext.contextTraceId } : {},
+						...executionContext?.parentRunId ? { parentRunId: executionContext.parentRunId } : {}
 					}
 				} });
 				if (goal.projectId) this.projects.attachSession(sessionKey, goal.projectId);
@@ -459,6 +530,22 @@ var GatewayService = class {
 				new GoalService().attachSession(goal.id, sessionKey);
 				return sessionKey;
 			},
+			bindExecutionContext: async (sessionKey, goal, executionContext) => {
+				const metadata = await this.sessionIndex.getSessionMetadata(sessionKey);
+				await this.sessionIndex.updateSessionMetadata(sessionKey, {
+					projectId: goal.projectId ?? metadata?.projectId,
+					customData: {
+						...metadata?.customData,
+						goalId: goal.id,
+						origin: "goal",
+						triggerKind: executionContext?.triggerKind ?? "user",
+						...executionContext?.outcomeId ? { outcomeId: executionContext.outcomeId } : {},
+						...executionContext?.workItemId ? { workItemId: executionContext.workItemId } : {},
+						...executionContext?.contextTraceId ? { contextTraceId: executionContext.contextTraceId } : {},
+						...executionContext?.parentRunId ? { parentRunId: executionContext.parentRunId } : {}
+					}
+				});
+			},
 			hasActiveRun: (sessionKey) => this.agentRunner.hasActiveRun(sessionKey),
 			runTurn: (sessionKey, userTurn) => this.agentRunner.runScheduledWebchatTurn(sessionKey, userTurn),
 			emit: (type, payload) => this.emit(type, payload)
@@ -628,9 +715,13 @@ var GatewayService = class {
 		});
 		log.debug("Starting gateway service...");
 		openXopcDatabase();
+		new WorkIntakeService(this.projects, { enqueue: (goalId, options) => this.enqueueGoalRun(goalId, options) }).reconcilePendingExecutions();
+		new OutcomeProjectionService().reconcile();
 		this.startTime = Date.now();
 		this.running = true;
+		this.ensureDefaultProactiveScenarioSubscriptions();
 		this.proactiveWorker.start();
+		this.proactiveTemporalWorker.start();
 		this.proactiveInboxWorker.start();
 		prepareConfiguredLocalVoiceModel(this.config);
 		this.startupTrace = createGatewayStartupTrace();
@@ -726,6 +817,8 @@ var GatewayService = class {
 		await trace.measure("automations.initialize", () => this.automationService.initialize());
 		await trace.measure("dreaming.reconcile", () => this.reconcileDreamingAutomations());
 		await this.notesService.initialize();
+		this.discussionWorker.start();
+		this.discussionLiveWorker.start();
 		this.ensureHeartbeatService().start(heartbeatRunnerConfigFromConfig(this.config));
 		this.connectorSupervisor = startConnectorSupervisor({
 			getConfig: () => this.config,
@@ -737,6 +830,8 @@ var GatewayService = class {
 			getMemoryManager: () => this.agentService.getMemoryManager(),
 			emit: (type, payload) => this.emit(type, payload)
 		});
+		this.connectedSourceChangePublisher = new ConnectedSourceChangePublisher(this.proactive);
+		this.connectedSourceChangePublisher.start();
 		this.connectedKnowledgeCoordinator = startConnectedKnowledgeCoordinator({ resolvePipelineOptions: () => ({
 			agentId: resolveDefaultAgentId(this.config),
 			workspaceId: this.currentWorkspacePath
@@ -763,6 +858,18 @@ var GatewayService = class {
 		else trace.mark("service.started-awaiting-http");
 		log.debug("Gateway service started");
 	}
+	ensureDefaultProactiveScenarioSubscriptions() {
+		for (const scenarioKey of ["meeting_preparation", "discussion_follow_up"]) {
+			if (this.proactiveScenarios.subscriptions(scenarioKey).some((subscription) => subscription.workspaceId === this.currentWorkspacePath)) continue;
+			this.proactiveScenarios.subscribe({
+				scenarioKey,
+				workspaceId: this.currentWorkspacePath,
+				scopeKind: "workspace",
+				scopeId: this.currentWorkspacePath,
+				enabled: true
+			});
+		}
+	}
 	/** Called when the HTTP listener is bound (before deferred channel work). */
 	markHttpListening() {
 		this.readiness.markHttpListening();
@@ -850,6 +957,9 @@ var GatewayService = class {
 		log.debug("Stopping gateway service...");
 		this.readiness.markStarting();
 		await this.proactiveWorker.stop();
+		await this.discussionWorker.stop();
+		await this.discussionLiveWorker.stop();
+		this.proactiveTemporalWorker.stop();
 		await this.proactiveInboxWorker.stop();
 		await stopTailscaleExposure().catch((err) => {
 			log.warn({ err }, "Tailscale exposure shutdown failed");
@@ -865,6 +975,8 @@ var GatewayService = class {
 		this.connectorSupervisor = null;
 		this.connectorLearningCoordinator?.stop();
 		this.connectorLearningCoordinator = null;
+		this.connectedSourceChangePublisher?.stop();
+		this.connectedSourceChangePublisher = null;
 		this.connectedKnowledgeCoordinator?.stop();
 		this.connectedKnowledgeCoordinator = null;
 		await this.browserRecipeService?.shutdown();
@@ -1296,6 +1408,21 @@ var GatewayService = class {
 		this.stopAutomationProductEventBridge?.();
 		this.stopSessionTranscriptAutomationEvents?.();
 		this.stopAutomationProductEventBridge = onAutomationProductEvent((event) => {
+			const proactiveEvent = mapProductEventToProactive({
+				event,
+				workspaceId: this.currentWorkspacePath,
+				defaultAgentId: resolveDefaultAgentId(this.config)
+			});
+			if (proactiveEvent) try {
+				this.proactive.publish(proactiveEvent);
+			} catch (err) {
+				const em = err instanceof Error ? err.message : String(err);
+				log.warn({
+					err,
+					eventType: event.type,
+					source: event.source
+				}, `Proactive product event publication failed: ${em}`);
+			}
 			this.automationService.triggerEvent(event).catch((err) => {
 				const em = err instanceof Error ? err.message : String(err);
 				log.warn({

package/dist/src/goals/goal-queue-store.d.ts

@@ -4,6 +4,7 @@ export declare class GoalQueueStore {
     enqueue(input: {
         goalId: string;
         userTurn?: UserTurnInput;
+        executionContext?: GoalQueueItemSnapshot['executionContext'];
         maxRetries: number;
         source: GoalQueueItemSnapshot['source'];
     }): GoalQueueItemSnapshot;

package/dist/src/goals/goal-queue-store.js

@@ -23,6 +23,7 @@ function rowToSnapshot(row) {
 		nextRunAt: row.next_run_at ?? void 0,
 		sessionKey: row.session_key ?? void 0,
 		userTurn: payload.userTurn,
+		executionContext: payload.executionContext,
 		lastError: row.last_error ?? void 0,
 		source: row.source
 	};
@@ -41,7 +42,10 @@ var GoalQueueStore = class {
 				queue_id: randomUUID(),
 				goal_id: input.goalId,
 				status: "queued",
-				payload_json: JSON.stringify({ userTurn: input.userTurn }),
+				payload_json: JSON.stringify({
+					userTurn: input.userTurn,
+					executionContext: input.executionContext
+				}),
 				attempts: 0,
 				max_retries: input.maxRetries,
 				enqueued_at: now,

package/dist/src/goals/goal-queue-types.d.ts

@@ -1,6 +1,13 @@
 import type { GoalWithDetails } from './types.js';
 import type { UserTurnInput } from '../gateway/user-turn-input.js';
 export type GoalQueueStatus = 'queued' | 'running' | 'retry_waiting' | 'succeeded' | 'failed' | 'skipped';
+export interface GoalRunExecutionContext {
+    outcomeId?: string;
+    workItemId?: string;
+    contextTraceId?: string;
+    parentRunId?: string;
+    triggerKind: 'user' | 'schedule' | 'webhook' | 'proactive' | 'retry';
+}
 export interface GoalQueueItemSnapshot {
     id: string;
     goalId: string;
@@ -13,6 +20,7 @@ export interface GoalQueueItemSnapshot {
     nextRunAt?: number;
     sessionKey?: string;
     userTurn?: UserTurnInput;
+    executionContext?: GoalRunExecutionContext;
     lastError?: string;
     source: 'api' | 'cron' | 'workflow' | 'system';
 }
@@ -20,7 +28,8 @@ export interface GoalRunnerOptions {
     maxConcurrent?: number;
     defaultMaxRetries?: number;
     retryBaseMs?: number;
-    ensureSession: (goal: GoalWithDetails) => Promise<string>;
+    ensureSession: (goal: GoalWithDetails, context?: GoalRunExecutionContext) => Promise<string>;
+    bindExecutionContext?: (sessionKey: string, goal: GoalWithDetails, context?: GoalRunExecutionContext) => Promise<void>;
     hasActiveRun: (sessionKey: string) => boolean;
     runTurn: (sessionKey: string, userTurn: UserTurnInput) => Promise<void>;
     emit?: (type: string, payload: unknown) => void;
@@ -29,4 +38,5 @@ export interface EnqueueGoalRunOptions {
     userTurn?: UserTurnInput;
     maxRetries?: number;
     source?: GoalQueueItemSnapshot['source'];
+    executionContext?: GoalRunExecutionContext;
 }

package/dist/src/goals/goal-runner.js

@@ -3,6 +3,7 @@ import { init_logger } from "../utils/logger.js";
 import { GoalService } from "./goal-service.js";
 import { GoalQueueStore } from "./goal-queue-store.js";
 import { mediaRefsToUserTurnAttachments } from "../gateway/user-turn-input.js";
+import { OutcomeRepository } from "../work/outcome-repository.js";
 //#region src/goals/goal-runner.ts
 init_logger();
 const log = createLogger("GoalRunner");
@@ -11,11 +12,12 @@ function terminalGoalStatus(status) {
 }
 function buildInitialGoalTurn(goal) {
 	const context = goal.contextMessage;
-	const parts = [`Goal:\n${goal.contract?.objective || goal.title}`];
-	if (goal.contract?.scopeBoundary) parts.push(`Scope boundary:\n${goal.contract.scopeBoundary}`);
-	if (goal.contract?.evidencePlan.length) parts.push(`Expected completion evidence:\n${goal.contract.evidencePlan.map((item) => `- ${item}`).join("\n")}`);
+	const contract = new OutcomeRepository().getContract(goal.outcomeId, goal.outcomeContractVersion);
+	const parts = [`Outcome:\n${contract?.objective ?? goal.title}`];
+	if (contract?.constraints.length) parts.push(`Constraints:\n${contract.constraints.map((item) => `- ${item}`).join("\n")}`);
+	if (contract?.deliverables.length) parts.push(`Deliverables:\n${contract.deliverables.map((item) => `- ${item}`).join("\n")}`);
 	if (context?.text.trim()) parts.push(`Context:\n${context.text.trim()}`);
-	if (goal.checklist.length > 0) parts.push(`User-provided acceptance criteria:\n${goal.checklist.map((item, index) => `${index + 1}. ${item.text}`).join("\n")}`);
+	if (goal.checklist.length > 0) parts.push(`Acceptance criteria:\n${goal.checklist.map((item, index) => `${index + 1}. ${item.text}`).join("\n")}`);
 	return {
 		text: parts.join("\n\n"),
 		attachments: mediaRefsToUserTurnAttachments(context?.attachments),
@@ -47,7 +49,8 @@ var GoalRunner = class {
 				text: options.userTurn.text.trim(),
 				clientCreatedAtMs: options.userTurn.clientCreatedAtMs ?? Date.now()
 			} : void 0,
-			source: options.source ?? "api"
+			source: options.source ?? "api",
+			executionContext: options.executionContext
 		});
 		this.emit("goal.queue.updated", item);
 		this.schedulePump(0);
@@ -94,11 +97,12 @@ var GoalRunner = class {
 				this.finish(item, "failed", "Goal not found");
 				return;
 			}
-			const sessionKey = activeGoal.activeSessionKey ?? await this.opts.ensureSession(activeGoal);
+			const sessionKey = activeGoal.activeSessionKey ?? await this.opts.ensureSession(activeGoal, item.executionContext);
 			item = this.store.setSessionKey(item.id, sessionKey) ?? {
 				...item,
 				sessionKey
 			};
+			await this.opts.bindExecutionContext?.(sessionKey, activeGoal, item.executionContext);
 			if (this.opts.hasActiveRun(sessionKey)) {
 				this.retry(item, "Goal session already has an active run");
 				return;