@xopcai/xopc 0.0.197 → 0.0.200

package/dist/src/gateway/service/task-conversation-query-service.d.ts

@@ -0,0 +1,58 @@
+import type { SessionTimelineItem } from '../../session/transcript-outline.js';
+import { TaskConversationRepository } from '../../tasks/task-conversation-repository.js';
+import type { GatewaySessionsApi } from './sessions-api.js';
+export declare class TaskConversationQueryService {
+    #private;
+    private readonly sessions;
+    private readonly conversations;
+    constructor(sessions: Pick<GatewaySessionsApi, 'getMessagePage' | 'getTimeline'>, conversations?: Pick<TaskConversationRepository, 'listSessions'>);
+    getMessagePage(taskId: string, options: {
+        limit: number;
+        offset: number;
+        before?: number;
+    }): Promise<{
+        session: {
+            messages: import("../../session/types.js").Message[];
+            transcriptSummary?: import("../../session/types.js").SessionTranscriptSummary;
+            transcriptRows?: import("../../session/session-context-for-llm.js").TranscriptStoredRow[];
+            key: string;
+            name?: string;
+            status: import("../../session/types.js").SessionStatus;
+            tags: string[];
+            createdAt: string;
+            updatedAt: string;
+            lastAccessedAt: string;
+            messageCount: number;
+            estimatedTokens: number;
+            compactedCount: number;
+            lastFlushedAt?: string;
+            flushCount?: number;
+            sourceChannel: string;
+            sourceChatId: string;
+            customData?: Record<string, unknown>;
+            projectId?: string;
+            routing?: import("../../session/types.js").SessionRoutingMeta;
+            stats?: import("../../session/types.js").SessionStats;
+            sessionType: import("../../session/types.js").SessionType;
+            hiddenFromSessionList?: boolean;
+            parentSessionKey?: string;
+            workflowRunId?: string;
+            workflowDefinitionId?: string;
+            workflowAgentId?: string;
+            workflowAgentLabel?: string;
+            sessionId?: string;
+            cwd?: string;
+            sessionStartedAt?: string;
+            lastInteractionAt?: string;
+        };
+        pagination: {
+            nextBeforeCursor?: string;
+            before?: string;
+            total: number;
+            limit: number;
+            offset: number;
+            hasMore: boolean;
+        };
+    }>;
+    getTimeline(taskId: string): Promise<SessionTimelineItem[] | null>;
+}

package/dist/src/gateway/service/task-conversation-query-service.js

@@ -0,0 +1,84 @@
+import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
+//#region src/gateway/service/task-conversation-query-service.ts
+var TaskConversationQueryService = class {
+	constructor(sessions, conversations = new TaskConversationRepository()) {
+		this.sessions = sessions;
+		this.conversations = conversations;
+	}
+	async getMessagePage(taskId, options) {
+		const links = this.#executionSessions(taskId);
+		if (links.length === 0) return null;
+		const probes = await Promise.all(links.map((link) => this.sessions.getMessagePage(link.sessionKey, { limit: 1 })));
+		if (probes.some((page) => !page)) return null;
+		const pages = probes;
+		const total = pages.reduce((sum, page) => sum + page.pagination.total, 0);
+		const end = Math.min(total, Math.max(0, options.before ?? total - options.offset));
+		const start = Math.max(0, end - options.limit);
+		const messages = [];
+		let cursor = 0;
+		for (let index = 0; index < links.length; index += 1) {
+			const sessionTotal = pages[index].pagination.total;
+			const localStart = Math.max(0, start - cursor);
+			const localEnd = Math.min(sessionTotal, end - cursor);
+			if (localStart < localEnd) {
+				const page = await this.sessions.getMessagePage(links[index].sessionKey, {
+					offset: sessionTotal - localEnd,
+					limit: localEnd - localStart
+				});
+				if (!page) return null;
+				messages.push(...page.session.messages);
+			}
+			cursor += sessionTotal;
+		}
+		const activeIndex = links.findIndex((link) => link.status === "active");
+		return {
+			session: {
+				...pages[activeIndex >= 0 ? activeIndex : pages.length - 1].session,
+				messages
+			},
+			pagination: {
+				total,
+				limit: options.limit,
+				offset: options.offset,
+				hasMore: start > 0,
+				...options.before === void 0 ? {} : { before: String(end) },
+				...start > 0 ? { nextBeforeCursor: String(start) } : {}
+			}
+		};
+	}
+	async getTimeline(taskId) {
+		const links = this.#executionSessions(taskId);
+		if (links.length === 0) return null;
+		const output = [];
+		let displayOffset = 0;
+		let turnOffset = 0;
+		for (const [index, link] of links.entries()) {
+			const [items, page] = await Promise.all([this.sessions.getTimeline(link.sessionKey), this.sessions.getMessagePage(link.sessionKey, { limit: 1 })]);
+			if (!items || !page) return null;
+			if (index > 0) output.push({
+				id: `assignment:${link.id}`,
+				kind: "branch",
+				title: link.agentId ? `Execution continued by ${link.agentId}` : "Execution continued",
+				timestamp: link.startedAt,
+				depth: 0,
+				turn: turnOffset,
+				displayIndex: displayOffset
+			});
+			output.push(...items.map((item) => ({
+				...item,
+				id: `${link.id}:${item.id}`,
+				turn: item.turn + turnOffset,
+				...item.displayIndex === void 0 ? {} : { displayIndex: item.displayIndex + displayOffset }
+			})));
+			displayOffset += page.pagination.total;
+			const highestTurn = items.reduce((max, item) => Math.max(max, item.turn), -1);
+			turnOffset += highestTurn + 1;
+		}
+		return output;
+	}
+	#executionSessions(taskId) {
+		return this.conversations.listSessions(taskId).filter((link) => link.role === "execution").sort((a, b) => a.assignmentEpoch - b.assignmentEpoch || a.startedAt - b.startedAt);
+	}
+};
+//#endregion
+export { TaskConversationQueryService };

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

@@ -12,6 +12,7 @@ import { type ResolvedGatewayAuth } from './auth.js';
 import { ModelCatalogSyncService } from '../providers/model-catalog-sync-service.js';
 import { ProjectService } from '../projects/index.js';
 import { LocalAppService } from '../local-apps/index.js';
+import { TaskConversationRepository } from '../tasks/task-conversation-repository.js';
 import { type BrowserRecipeService } from '../browser/recipes/index.js';
 import { listInsights, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker } from '../proactive/index.js';
 import { GatewaySessionsApi } from './service/sessions-api.js';
@@ -120,6 +121,16 @@ export declare class GatewayService {
     private createTaskRunDispatcher;
     private createMobileNotificationService;
     dispatchTaskRuns(): void;
+    ensureTaskConversation(taskId: string, options?: {
+        runId?: string;
+        requestedAgentId?: string;
+    }): Promise<{
+        sessionKey: string;
+        agentId: string;
+        created: boolean;
+        conversation: ReturnType<TaskConversationRepository['requireState']>;
+    }>;
+    dispatchTaskEvents(): void;
     runAgent(...args: Parameters<GatewayAgentRunner['runAgent']>): ReturnType<GatewayAgentRunner['runAgent']>;
     submitSessionInput(...args: Parameters<GatewayAgentRunner['submitSessionInput']>): Promise<{
         ok: true;

package/dist/src/gateway/service.js

@@ -19,19 +19,20 @@ import { loadConfig, saveConfig } from "../config/loader.js";
 import { prewarmModelRegistry } from "../providers/model-registry.js";
 import { init_providers, providers_exports } from "../providers/index.js";
 import { TaskRepository } from "../tasks/task-repository.js";
+import { TaskConversationRepository } from "../tasks/task-conversation-repository.js";
 import { disposeAllSessionMcpRuntimes } from "../agent/mcp/bundle-mcp-runtime.js";
 import { resolveEffectiveGatewayPort } from "./host.js";
 import { AutomationService } from "../automations/service/automation-service.js";
 import { onAutomationProductEvent, publishAutomationProductEvent } from "../automations/product-events.js";
 import "../automations/index.js";
 import { ProjectService } from "../projects/project-service.js";
+import { resolveProjectAgentId } from "../projects/project-agent.js";
 import "../projects/index.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 { TaskContextRepository } from "../tasks/task-context-repository.js";
 import { TaskApplicationService } from "../tasks/task-application-service.js";
 import { ProactiveScenarioService } from "../proactive/scenarios/service.js";
 import { TaskOutboxDispatcher } from "../tasks/task-outbox-dispatcher.js";
@@ -460,6 +461,7 @@ var GatewayService = class {
 			getNotesService: () => this.notesService,
 			getProjectService: () => this.projects,
 			getLocalAppService: () => this.localApps,
+			dispatchTaskEvents: () => this.dispatchTaskEvents(),
 			dispatchTaskRuns: () => this.dispatchTaskRuns(),
 			getWorkflowRunService: () => this.createWorkflowRunService(),
 			sourceContextResolver: async (binding) => {
@@ -540,42 +542,10 @@ var GatewayService = class {
 		if (!this.taskRunDispatcher) this.taskRunDispatcher = new TaskRunDispatcher({
 			workerId: "gateway-agent",
 			ensureSession: async (taskId, runId, requestedAgentId) => {
-				const task = new TaskRepository().require(taskId);
-				const agentId = requestedAgentId || task.delegateAgentId || getDefaultAgentId(this.config);
-				const peerId = `task-${sanitizeSegment(taskId) || Date.now()}`;
-				const sessionKey = buildSessionKey({
-					agentId,
-					source: "webchat",
-					accountId: "default",
-					peerKind: "direct",
-					peerId
-				});
-				if (!await this.sessionIndex.getSessionMetadata(sessionKey)) await this.sessionIndex.saveMessages(sessionKey, [], { metadata: {
-					sourceChannel: "webchat",
-					sourceChatId: `default:direct:${peerId}`,
-					sessionType: "chat",
-					routing: {
-						agentId,
-						source: "webchat",
-						accountId: "default",
-						peerKind: "direct",
-						peerId
-					},
-					projectId: task.projectId,
-					customData: {
-						taskId,
-						origin: "task",
-						triggerKind: "user",
-						taskRunId: runId
-					}
-				} });
-				if (task.projectId) this.projects.attachSession(sessionKey, task.projectId);
-				new TaskContextRepository().linkSession({
-					taskId,
-					sessionKey,
-					role: "execution"
-				});
-				return sessionKey;
+				return (await this.ensureTaskConversation(taskId, {
+					runId,
+					requestedAgentId
+				})).sessionKey;
 			},
 			runAgent: async (runId, sessionKey, message) => {
 				const stream = this.agentRunner.runAgent(message, "webchat", sessionKey, {
@@ -593,10 +563,77 @@ var GatewayService = class {
 	}
 	dispatchTaskRuns() {
 		new TaskSignalService().tick();
-		new TaskOutboxDispatcher(publishAutomationProductEvent).drain();
+		this.dispatchTaskEvents();
 		this.createTaskRunDispatcher().dispatch();
 		this.createWorkflowRunService().dispatchTaskRuns();
 	}
+	async ensureTaskConversation(taskId, options = {}) {
+		const task = new TaskRepository().require(taskId);
+		const agentId = resolveProjectAgentId({
+			config: this.config,
+			projects: this.projects,
+			explicitAgentId: options.requestedAgentId ?? task.delegateAgentId,
+			projectId: task.projectId
+		});
+		const conversations = new TaskConversationRepository();
+		const active = conversations.getActiveSession(task.id);
+		if (active) {
+			if (active.agentId && active.agentId !== agentId) throw new Error("Task executor differs from the active conversation");
+			const conversation = conversations.activateExecutionSession({
+				taskId: task.id,
+				sessionKey: active.sessionKey,
+				agentId,
+				runId: options.runId
+			});
+			return {
+				sessionKey: active.sessionKey,
+				agentId,
+				created: false,
+				conversation
+			};
+		}
+		const peerId = `task-${sanitizeSegment(task.id) || Date.now()}`;
+		const sessionKey = buildSessionKey({
+			agentId,
+			source: "webchat",
+			accountId: "default",
+			peerKind: "direct",
+			peerId
+		});
+		if (!await this.sessionIndex.getSessionMetadata(sessionKey)) await this.sessionIndex.saveMessages(sessionKey, [], { metadata: {
+			sourceChannel: "webchat",
+			sourceChatId: `default:direct:${peerId}`,
+			sessionType: "chat",
+			routing: {
+				agentId,
+				source: "webchat",
+				accountId: "default",
+				peerKind: "direct",
+				peerId
+			},
+			projectId: task.projectId,
+			customData: {
+				origin: "task",
+				triggerKind: "user",
+				...options.runId ? { taskRunId: options.runId } : {}
+			}
+		} });
+		if (task.projectId) this.projects.attachSession(sessionKey, task.projectId);
+		return {
+			sessionKey,
+			agentId,
+			created: true,
+			conversation: conversations.activateExecutionSession({
+				taskId: task.id,
+				sessionKey,
+				agentId,
+				runId: options.runId
+			})
+		};
+	}
+	dispatchTaskEvents() {
+		new TaskOutboxDispatcher(publishAutomationProductEvent).drain();
+	}
 	runAgent(...args) {
 		return this.agentRunner.runAgent(...args);
 	}

package/dist/src/proactive/actions/service.d.ts

@@ -0,0 +1,2 @@
+export declare function executePendingProactiveActions(now?: Date): number;
+export declare function resolveProactiveActionDecision(inboxItemId: string, choice: string, now?: Date): void;

package/dist/src/proactive/actions/service.js

@@ -0,0 +1,80 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { TaskApplicationService } from "../../tasks/task-application-service.js";
+//#region src/proactive/actions/service.ts
+function projectIdFromAggregationKey(value) {
+	if (!value.startsWith("project:") || value.length === 8) throw new Error("Proactive action has no project scope");
+	return value.slice(8);
+}
+function executeClaimedAction(row, now = /* @__PURE__ */ new Date()) {
+	const action = JSON.parse(row.proposed_action_json);
+	try {
+		if (action.id !== "create_project_task") throw new Error(`Unsupported proactive action: ${action.id}`);
+		const result = new TaskApplicationService().create({
+			idempotencyKey: `proactive:${row.insight_id}:${action.id}`,
+			title: action.input.title,
+			projectId: projectIdFromAggregationKey(row.aggregation_key),
+			priority: "normal",
+			contract: {
+				objective: action.input.objective,
+				expectedOutputs: [],
+				acceptanceCriteria: [],
+				constraints: [],
+				approvalRequired: [],
+				assumptions: [],
+				risks: [],
+				acceptancePolicy: "manual",
+				outputDestinations: []
+			},
+			dependencies: [],
+			context: [],
+			authorityGrants: [],
+			activation: {
+				mode: "capture",
+				phase: "backlog"
+			}
+		}, {
+			kind: "system",
+			id: "proactive"
+		});
+		if (!result.ok) throw new Error(`Task creation failed: ${"reason" in result ? result.reason : "unknown"}`);
+		getSqliteDatabase().prepare(`UPDATE proactive_insights
+      SET action_status = 'completed', action_result_json = ?, action_error = NULL, action_updated_at = ?
+      WHERE insight_id = ? AND action_status = 'executing'`).run(JSON.stringify({ taskId: result.model.task.id }), now.toISOString(), row.insight_id);
+	} catch (error) {
+		getSqliteDatabase().prepare(`UPDATE proactive_insights
+      SET action_status = 'failed', action_error = ?, action_updated_at = ?
+      WHERE insight_id = ? AND action_status = 'executing'`).run(String(error instanceof Error ? error.message : error).slice(0, 2e3), now.toISOString(), row.insight_id);
+	}
+}
+function executePendingProactiveActions(now = /* @__PURE__ */ new Date()) {
+	const expired = (/* @__PURE__ */ new Date(now.getTime() - 5 * 6e4)).toISOString();
+	getSqliteDatabase().prepare(`UPDATE proactive_insights SET action_status = 'pending', action_updated_at = ?
+    WHERE action_status = 'executing' AND action_updated_at <= ?`).run(now.toISOString(), expired);
+	let executed = 0;
+	while (true) {
+		const row = runSqliteWriteTransaction((db) => {
+			const candidate = db.prepare(`SELECT x.insight_id, b.aggregation_key, x.proposed_action_json
+        FROM proactive_insights x
+        JOIN proactive_runs r ON r.run_id = x.run_id
+        JOIN proactive_signal_batches b ON b.batch_id = r.batch_id
+        WHERE x.action_status = 'pending' ORDER BY x.created_at LIMIT 1`).get();
+			if (!candidate) return void 0;
+			return db.prepare(`UPDATE proactive_insights SET action_status = 'executing', action_updated_at = ?
+        WHERE insight_id = ? AND action_status = 'pending'`).run(now.toISOString(), candidate.insight_id).changes === 1 ? candidate : void 0;
+		});
+		if (!row) return executed;
+		executeClaimedAction(row, now);
+		executed += 1;
+	}
+}
+function resolveProactiveActionDecision(inboxItemId, choice, now = /* @__PURE__ */ new Date()) {
+	const row = getSqliteDatabase().prepare(`SELECT x.insight_id, x.action_status
+    FROM proactive_inbox_items i JOIN proactive_insights x ON x.insight_id = i.insight_id
+    WHERE i.inbox_item_id = ?`).get(inboxItemId);
+	if (!row || row.action_status !== "approval_required") return;
+	getSqliteDatabase().prepare(`UPDATE proactive_insights SET action_status = ?, action_updated_at = ?
+    WHERE insight_id = ? AND action_status = 'approval_required'`).run(choice === "approve" ? "pending" : "rejected", now.toISOString(), row.insight_id);
+	if (choice === "approve") executePendingProactiveActions(now);
+}
+//#endregion
+export { executePendingProactiveActions, resolveProactiveActionDecision };

package/dist/src/proactive/execution/insight.js

@@ -30,6 +30,23 @@ function parseDecision(value) {
 		options
 	};
 }
+function parseProposedAction(value) {
+	if (value == null) return void 0;
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Insight proposedAction is invalid");
+	const row = value;
+	if (row.id !== "create_project_task" || row.risk !== "low") throw new Error("Insight proposedAction is not supported");
+	if (!row.input || typeof row.input !== "object" || Array.isArray(row.input)) throw new Error("Insight proposedAction input is invalid");
+	const input = row.input;
+	return {
+		id: "create_project_task",
+		risk: "low",
+		rationale: boundedText(row.rationale, "proposedAction rationale", 600),
+		input: {
+			title: boundedText(input.title, "proposedAction title", 160),
+			objective: boundedText(input.objective, "proposedAction objective", 1200)
+		}
+	};
+}
 function parseInsightCandidate(raw, allowedEvidenceIds) {
 	let value;
 	try {
@@ -45,6 +62,8 @@ function parseInsightCandidate(raw, allowedEvidenceIds) {
 	const evidenceIds = [...new Set(row.evidenceIds.map(String))];
 	if (evidenceIds.some((id) => !allowedEvidenceIds.has(id))) throw new Error("Insight cites unknown evidence");
 	const decision = parseDecision(row.decision);
+	const proposedAction = parseProposedAction(row.proposedAction);
+	if (proposedAction && (!decision || decision.options.length !== 2 || decision.options[0]?.id !== "approve" || decision.options[1]?.id !== "reject")) throw new Error("Insight proposedAction requires approve and reject decision options");
 	return {
 		title: boundedText(row.title, "title", 160),
 		summary: boundedText(row.summary, "summary", 1200),
@@ -53,6 +72,7 @@ function parseInsightCandidate(raw, allowedEvidenceIds) {
 		recommendation: boundedText(row.recommendation, "recommendation", 800),
 		workDone: boundedText(row.workDone, "workDone", 800),
 		...decision ? { decision } : {},
+		...proposedAction ? { proposedAction } : {},
 		urgency: String(row.urgency),
 		confidence: row.confidence,
 		evidenceIds

package/dist/src/proactive/execution/repository.js

@@ -96,9 +96,9 @@ function finishRun(input, now = /* @__PURE__ */ new Date()) {
 			createdAt: nowIso
 		};
 		db.prepare(`INSERT INTO proactive_insights (insight_id, run_id, subscription_id, scenario_key, title, summary,
-      why_now, impact, recommendation, work_done, decision_json, urgency, confidence, value_score,
+      why_now, impact, recommendation, work_done, decision_json, proposed_action_json, urgency, confidence, value_score,
       evidence_ids_json, content_fingerprint, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(insight.id, insight.runId, insight.subscriptionId, insight.scenarioKey, insight.title, insight.summary, insight.whyNow, insight.impact, insight.recommendation, insight.workDone, insight.decision ? JSON.stringify(insight.decision) : null, insight.urgency, insight.confidence, insight.valueScore, JSON.stringify(insight.evidenceIds), fingerprint, insight.createdAt);
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(insight.id, insight.runId, insight.subscriptionId, insight.scenarioKey, insight.title, insight.summary, insight.whyNow, insight.impact, insight.recommendation, insight.workDone, insight.decision ? JSON.stringify(insight.decision) : null, insight.proposedAction ? JSON.stringify(insight.proposedAction) : null, insight.urgency, insight.confidence, insight.valueScore, JSON.stringify(insight.evidenceIds), fingerprint, insight.createdAt);
 		return insight;
 	});
 }
@@ -124,9 +124,15 @@ function listInsights(limit = 50) {
 		recommendation: str(row, "recommendation"),
 		workDone: str(row, "work_done"),
 		...row.decision_json ? { decision: JSON.parse(str(row, "decision_json")) } : {},
+		...row.proposed_action_json ? { proposedAction: JSON.parse(str(row, "proposed_action_json")) } : {},
 		urgency: str(row, "urgency"),
 		confidence: Number(row.confidence),
 		valueScore: Number(row.value_score),
+		...row.disposition ? { disposition: str(row, "disposition") } : {},
+		...row.disposition_reason ? { dispositionReason: str(row, "disposition_reason") } : {},
+		...row.action_status ? { actionStatus: str(row, "action_status") } : {},
+		...row.action_result_json ? { actionResult: JSON.parse(str(row, "action_result_json")) } : {},
+		...row.action_error ? { actionError: str(row, "action_error") } : {},
 		evidenceIds: JSON.parse(str(row, "evidence_ids_json")),
 		createdAt: str(row, "created_at")
 	}));

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

@@ -20,6 +20,15 @@ export interface InsightCandidate {
             consequence: string;
         }>;
     };
+    proposedAction?: {
+        id: 'create_project_task';
+        risk: 'low';
+        rationale: string;
+        input: {
+            title: string;
+            objective: string;
+        };
+    };
     urgency: 'low' | 'medium' | 'high' | 'critical';
     confidence: number;
     evidenceIds: string[];
@@ -30,6 +39,11 @@ export interface ProactiveInsight extends InsightCandidate {
     subscriptionId: string;
     scenarioKey: string;
     valueScore: number;
+    disposition?: 'record_silently' | 'show_in_work' | 'request_approval' | 'auto_execute';
+    dispositionReason?: string;
+    actionStatus?: 'not_authorized' | 'approval_required' | 'pending' | 'executing' | 'completed' | 'rejected' | 'failed';
+    actionResult?: Record<string, unknown>;
+    actionError?: string;
     createdAt: string;
 }
 export interface ProactiveAgentExecutor {

package/dist/src/proactive/inbox/repository.js

@@ -1,4 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { decideProactiveDisposition, nextQuietHoursEnd, proactiveDispositionReason } from "../../tasks/project-monitoring-service.js";
 import { randomUUID } from "node:crypto";
 //#region src/proactive/inbox/repository.ts
 const s = (row, key) => String(row[key]);
@@ -20,6 +21,12 @@ function itemFromRow(row) {
 			recommendation: s(row, "recommendation"),
 			workDone: s(row, "work_done"),
 			...row.decision_json ? { decision: JSON.parse(s(row, "decision_json")) } : {},
+			...row.proposed_action_json ? { proposedAction: JSON.parse(s(row, "proposed_action_json")) } : {},
+			disposition: s(row, "disposition"),
+			dispositionReason: s(row, "disposition_reason"),
+			...row.action_status ? { actionStatus: s(row, "action_status") } : {},
+			...row.action_result_json ? { actionResult: JSON.parse(s(row, "action_result_json")) } : {},
+			...row.action_error ? { actionError: s(row, "action_error") } : {},
 			urgency: s(row, "urgency"),
 			confidence: Number(row.confidence),
 			valueScore: Number(row.value_score),
@@ -28,27 +35,70 @@ function itemFromRow(row) {
 	};
 }
 const SELECT_ITEM = `SELECT i.*, x.subscription_id, x.scenario_key, x.title, x.summary, x.why_now, x.impact, x.recommendation,
-  x.work_done, x.decision_json, x.urgency, x.confidence, x.value_score, x.evidence_ids_json FROM proactive_inbox_items i
+  x.work_done, x.decision_json, x.proposed_action_json, x.disposition, x.disposition_reason,
+  x.action_status, x.action_result_json, x.action_error, x.urgency, x.confidence, x.value_score, x.evidence_ids_json FROM proactive_inbox_items i
   JOIN proactive_insights x ON x.insight_id = i.insight_id`;
 function projectInsightsToInbox(now = /* @__PURE__ */ new Date()) {
 	return runSqliteWriteTransaction((db) => {
-		const missing = db.prepare(`SELECT x.insight_id FROM proactive_insights x
+		const missing = db.prepare(`SELECT x.insight_id, x.confidence, x.value_score, x.decision_json,
+      x.proposed_action_json, b.aggregation_key, p.project_id, p.mode, p.quiet_hours_json,
+      p.allowed_actions_json, p.confidence_threshold FROM proactive_insights x
       JOIN proactive_runs r ON r.run_id = x.run_id
       JOIN proactive_signal_batches b ON b.batch_id = r.batch_id
       LEFT JOIN project_monitoring_policies p
         ON b.aggregation_key = 'project:' || p.project_id
-      WHERE x.insight_id NOT IN (SELECT insight_id FROM proactive_inbox_items)
-        AND (p.project_id IS NULL OR (p.mode != 'observe' AND x.confidence >= p.confidence_threshold))
-      ORDER BY x.created_at`).all();
+      WHERE x.disposition IS NULL ORDER BY x.created_at`).all();
+		let projected = 0;
 		for (const row of missing) {
-			const id = randomUUID();
+			const aggregationKey = String(row.aggregation_key);
+			const projectId = aggregationKey.startsWith("project:") ? aggregationKey.slice(8) : void 0;
+			const policy = projectId ? row.project_id ? {
+				projectId,
+				mode: String(row.mode),
+				...row.quiet_hours_json ? { quietHours: JSON.parse(String(row.quiet_hours_json)) } : {},
+				allowedActions: JSON.parse(String(row.allowed_actions_json)),
+				confidenceThreshold: Number(row.confidence_threshold),
+				scenarios: [],
+				configured: true
+			} : {
+				projectId,
+				mode: "observe",
+				allowedActions: [],
+				confidenceThreshold: .75,
+				scenarios: [],
+				configured: false
+			} : {
+				projectId: "",
+				mode: "ask_before_action",
+				allowedActions: [],
+				confidenceThreshold: 0,
+				scenarios: [],
+				configured: false
+			};
+			const action = row.proposed_action_json ? JSON.parse(String(row.proposed_action_json)) : void 0;
+			const dispositionInput = {
+				confidence: Number(row.confidence),
+				valueScore: Number(row.value_score),
+				risk: action?.risk ?? "low",
+				...action ? { actionId: action.id } : {},
+				requiresApproval: !action && Boolean(row.decision_json)
+			};
+			const disposition = action && !projectId ? "show_in_work" : decideProactiveDisposition(policy, dispositionInput);
+			const reason = action && !projectId ? "Proposed project action cannot run outside a project scope" : proactiveDispositionReason(policy, dispositionInput, disposition);
+			const actionStatus = action ? disposition === "auto_execute" ? "pending" : disposition === "request_approval" ? "approval_required" : disposition === "show_in_work" ? "not_authorized" : null : null;
 			const nowIso = now.toISOString();
+			db.prepare(`UPDATE proactive_insights SET disposition = ?, disposition_reason = ?, action_status = ?,
+        disposition_at = ?, action_updated_at = ? WHERE insight_id = ? AND disposition IS NULL`).run(disposition, reason, actionStatus, nowIso, actionStatus ? nowIso : null, String(row.insight_id));
+			if (disposition === "record_silently") continue;
+			const id = randomUUID();
 			db.prepare(`INSERT INTO proactive_inbox_items (inbox_item_id, insight_id, status, created_at, updated_at)
-        VALUES (?, ?, 'unread', ?, ?)`).run(id, row.insight_id, nowIso, nowIso);
+        VALUES (?, ?, 'unread', ?, ?)`).run(id, String(row.insight_id), nowIso, nowIso);
+			const nextAttemptAt = nextQuietHoursEnd(policy.quietHours, now)?.toISOString() ?? nowIso;
 			db.prepare(`INSERT INTO proactive_delivery_outbox (delivery_id, inbox_item_id, status, attempt, next_attempt_at, created_at, updated_at)
-        VALUES (?, ?, 'pending', 0, ?, ?, ?)`).run(randomUUID(), id, nowIso, nowIso, nowIso);
+        VALUES (?, ?, 'pending', 0, ?, ?, ?)`).run(randomUUID(), id, nextAttemptAt, nowIso, nowIso);
+			projected += 1;
 		}
-		return missing.length;
+		return projected;
 	});
 }
 function wakeSnoozedItems(now = /* @__PURE__ */ new Date()) {

package/dist/src/proactive/inbox/service.d.ts

@@ -1,11 +1,11 @@
-import { listInbox, projectInsightsToInbox, recordDecision, recordFeedback, wakeSnoozedItems } from './repository.js';
+import { listInbox, projectInsightsToInbox, recordFeedback, wakeSnoozedItems } from './repository.js';
 import type { InboxStatus } from './types.js';
 export declare class ProactiveInboxService {
     list: typeof listInbox;
     project: typeof projectInsightsToInbox;
     wakeSnoozed: typeof wakeSnoozedItems;
-    decide: typeof recordDecision;
     feedback: typeof recordFeedback;
+    decide(id: string, choice: string, note?: string): import("./types.js").InboxItem;
     instruct(id: string, instruction: string): {
         revisionId: string;
     };

package/dist/src/proactive/inbox/service.js

@@ -1,12 +1,17 @@
 import { publishInstructionFeedback } from "../scenarios/repository.js";
-import { getInboxSubscriptionId, listInbox, projectInsightsToInbox, recordDecision, recordFeedback, transitionInboxItem, wakeSnoozedItems } from "./repository.js";
+import { resolveProactiveActionDecision } from "../actions/service.js";
+import { getInboxItem, getInboxSubscriptionId, listInbox, projectInsightsToInbox, recordDecision, recordFeedback, transitionInboxItem, wakeSnoozedItems } from "./repository.js";
 //#region src/proactive/inbox/service.ts
 var ProactiveInboxService = class {
 	list = listInbox;
 	project = projectInsightsToInbox;
 	wakeSnoozed = wakeSnoozedItems;
-	decide = recordDecision;
 	feedback = recordFeedback;
+	decide(id, choice, note = "") {
+		const item = recordDecision(id, choice, note);
+		resolveProactiveActionDecision(id, choice);
+		return getInboxItem(id) ?? item;
+	}
 	instruct(id, instruction) {
 		return { revisionId: publishInstructionFeedback({
 			subscriptionId: getInboxSubscriptionId(id),

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

@@ -23,6 +23,20 @@ export interface InboxItem {
                 consequence: string;
             }>;
         };
+        proposedAction?: {
+            id: 'create_project_task';
+            risk: 'low';
+            rationale: string;
+            input: {
+                title: string;
+                objective: string;
+            };
+        };
+        disposition: 'show_in_work' | 'request_approval' | 'auto_execute';
+        dispositionReason: string;
+        actionStatus?: 'not_authorized' | 'approval_required' | 'pending' | 'executing' | 'completed' | 'rejected' | 'failed';
+        actionResult?: Record<string, unknown>;
+        actionError?: string;
         urgency: 'low' | 'medium' | 'high' | 'critical';
         confidence: number;
         valueScore: number;