@xopcai/xopc 0.0.196 → 0.0.199

package/dist/src/gateway/side-chat/run-service.js

@@ -0,0 +1,110 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { abortEmbeddedRun } from "../../agent/embedded/runs.js";
+import { SideChatError } from "./manager.js";
+import { ChatStreamMapper } from "../chat-stream/mapper.js";
+import { randomUUID } from "node:crypto";
+//#region src/gateway/side-chat/run-service.ts
+init_logger();
+const log = createLogger("Gateway:SideChatRun");
+var SideChatRunService = class {
+	activeBySideChat = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	submit(sideChatId, clientInstanceId, content) {
+		const text = content.trim();
+		if (!text) throw new SideChatError("content is required", "INVALID_REQUEST");
+		const sideChat = this.options.manager.get(sideChatId, clientInstanceId);
+		if (this.activeBySideChat.has(sideChatId)) throw new SideChatError("A side chat run is already active", "CONFLICT");
+		const run = {
+			sideChatId,
+			clientInstanceId,
+			executionSessionKey: this.options.manager.getRuntime(sideChatId, clientInstanceId).runtimeId,
+			runId: randomUUID(),
+			abortController: new AbortController()
+		};
+		this.activeBySideChat.set(sideChatId, run);
+		this.options.manager.setStatus(sideChatId, clientInstanceId, "running");
+		this.execute(run, text, sideChat.config).catch((err) => {
+			log.error({
+				err,
+				sideChatId,
+				runId: run.runId
+			}, "Side chat run cleanup failed");
+		});
+		return { runId: run.runId };
+	}
+	async abort(sideChatId, clientInstanceId, runId) {
+		this.options.manager.get(sideChatId, clientInstanceId);
+		const active = this.activeBySideChat.get(sideChatId);
+		if (!active || runId && active.runId !== runId) return false;
+		this.options.agentRunner.cancelClarificationForRun(active.runId);
+		active.abortController.abort();
+		await abortEmbeddedRun(active.executionSessionKey).catch(() => false);
+		return true;
+	}
+	async dispose(sideChatId, clientInstanceId) {
+		await this.abort(sideChatId, clientInstanceId).catch(() => false);
+		return this.options.manager.dispose(sideChatId, clientInstanceId);
+	}
+	submitClarification(sideChatId, clientInstanceId, requestId, answer) {
+		this.options.manager.get(sideChatId, clientInstanceId);
+		return this.options.agentRunner.submitClarifyResponse(requestId, answer);
+	}
+	async execute(run, content, config) {
+		const topic = `run:${run.runId}`;
+		const mapper = new ChatStreamMapper({
+			runId: run.runId,
+			sessionKey: run.sideChatId,
+			channel: "side-chat"
+		});
+		const publish = (event) => {
+			this.options.publishRealtime(topic, event.type, event);
+		};
+		const publishMapped = (event) => {
+			for (const mapped of mapper.map(event)) publish(mapped);
+		};
+		try {
+			for (const event of mapper.start()) publish(event);
+			publishMapped({
+				type: "user_message",
+				message: {
+					role: "user",
+					content,
+					timestamp: Date.now()
+				}
+			});
+			this.options.agentRunner.registerExternalWebchatRun(run.executionSessionKey, run.runId, (event) => publishMapped(event));
+			const result = await this.options.getAgentService().runEphemeralTurn({
+				executionSessionKey: run.executionSessionKey,
+				parentSessionKey: this.options.manager.get(run.sideChatId, run.clientInstanceId).parentSessionKey,
+				runId: run.runId,
+				content,
+				modelRef: config.modelRef,
+				thinkingLevel: config.thinkingLevel,
+				transcriptRuntime: this.options.manager.getRuntime(run.sideChatId, run.clientInstanceId),
+				abortSignal: run.abortController.signal,
+				onEvent: publishMapped
+			});
+			const cancelled = run.abortController.signal.aborted;
+			const status = cancelled ? "cancelled" : result.ok ? "success" : "error";
+			if (!result.ok && result.errorMessage) for (const event of mapper.error(result.errorMessage)) publish(event);
+			for (const event of mapper.end(status, cancelled ? "Interrupted" : result.errorMessage)) publish(event);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			for (const event of mapper.error(message)) publish(event);
+			for (const event of mapper.end("error", message)) publish(event);
+		} finally {
+			this.options.agentRunner.unregisterExternalWebchatRun(run.executionSessionKey, run.runId);
+			this.activeBySideChat.delete(run.sideChatId);
+			try {
+				this.options.manager.getMessages(run.sideChatId, run.clientInstanceId);
+				this.options.manager.setStatus(run.sideChatId, run.clientInstanceId, "idle");
+			} catch {}
+			this.options.completeRealtimeTopic(topic);
+		}
+	}
+};
+//#endregion
+export { SideChatRunService };

package/dist/src/gateway/side-chat/types.d.ts

@@ -0,0 +1,61 @@
+import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
+export type SideChatStatus = 'idle' | 'running' | 'waiting-approval' | 'waiting-input' | 'closing';
+export type SideChatSelection = {
+    id: string;
+    type: 'message';
+    messageId: string;
+    role: string;
+    content: string;
+    label?: string;
+} | {
+    id: string;
+    type: 'text';
+    text: string;
+    sourceMessageId?: string;
+    label?: string;
+} | {
+    id: string;
+    type: 'file-range';
+    path: string;
+    startLine: number;
+    endLine: number;
+    text: string;
+    contentHash?: string;
+    label?: string;
+} | {
+    id: string;
+    type: 'diff';
+    diff: string;
+    path?: string;
+    label?: string;
+};
+export interface SideChatContextSnapshot {
+    parentSessionKey: string;
+    parentSessionId: string;
+    parentMessageCount: number;
+    createdAt: string;
+    selections: SideChatSelection[];
+    contentHash: string;
+}
+export interface SideChatConfig {
+    modelRef: string;
+    thinkingLevel?: ThinkingLevel;
+}
+export interface SideChatView {
+    id: string;
+    parentSessionKey: string;
+    clientInstanceId: string;
+    status: SideChatStatus;
+    createdAt: string;
+    lastActiveAt: string;
+    expiresAt: string;
+    messageCount: number;
+    context: SideChatContextSnapshot;
+    config: SideChatConfig;
+}
+export interface CreateSideChatInput {
+    parentSessionKey: string;
+    clientInstanceId: string;
+    selections?: SideChatSelection[];
+    config?: Partial<SideChatConfig>;
+}

package/dist/src/gateway/side-chat/types.js

@@ -0,0 +1 @@
+export {};

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;

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

@@ -1,5 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { executePendingProactiveActions } from "../actions/service.js";
 import { claimDelivery, finishDelivery, projectInsightsToInbox, recoverExpiredDeliveries, wakeSnoozedItems } from "./repository.js";
 //#region src/proactive/inbox/worker.ts
 init_logger();
@@ -28,6 +29,7 @@ var ProactiveInboxWorker = class {
 		this.running = true;
 		try {
 			projectInsightsToInbox();
+			executePendingProactiveActions();
 			wakeSnoozedItems();
 			recoverExpiredDeliveries();
 			const claim = claimDelivery();

package/dist/src/proactive/scenarios/prompt-composer.js

@@ -5,8 +5,8 @@ Use only supplied evidence identifiers. Separate observations from inferences.
 Do not invent dates, owners, dependencies, impact, or actions.
 Return only the protected output schema.`;
 const OUTPUT_CONTRACT = `Return JSON only with these fields:
-{"title":"...","summary":"...","whyNow":"...","impact":"...","workDone":"What you investigated or ruled out","recommendation":"...","decision":{"question":"The exact user decision","options":[{"id":"stable-id","label":"short choice","consequence":"likely consequence"}]},"urgency":"low|medium|high|critical","confidence":0.0,"evidenceIds":["event-id"]}
-Use decision only when the user must choose; otherwise set decision to null. Provide 2-3 mutually exclusive options. If evidence does not support a timely and actionable insight, return the same shape with urgency "low" and confidence below 0.65. Never add unknown fields.`;
+{"title":"...","summary":"...","whyNow":"...","impact":"...","workDone":"What you investigated or ruled out","recommendation":"...","decision":{"question":"The exact user decision","options":[{"id":"stable-id","label":"short choice","consequence":"likely consequence"}]},"proposedAction":{"id":"create_project_task","risk":"low","rationale":"why this is safe and useful","input":{"title":"...","objective":"..."}},"urgency":"low|medium|high|critical","confidence":0.0,"evidenceIds":["event-id"]}
+Use proposedAction only when the evidence clearly supports creating a follow-up task in the current project; otherwise set it to null. A proposed action must include exactly two decision options in this order: approve, reject. Use decision without proposedAction only when the user must choose; otherwise set decision to null. Provide 2-3 mutually exclusive options. If evidence does not support a timely and actionable insight, return the same shape with urgency "low" and confidence below 0.65. Never add unknown fields.`;
 function composeScenarioPrompt(input) {
 	const parts = {
 		platformSafety: PLATFORM_SAFETY,

package/dist/src/routing/session-key-utils.d.ts

@@ -14,7 +14,6 @@ export type RawSessionConversationRef = {
 };
 /** Parse `agent:{agentId}:{rest}` session keys (OpenClaw canonical form). */
 export declare function parseAgentSessionKey(sessionKey: string | undefined | null): ParsedAgentSessionKey | null;
-export declare function isCronRunSessionKey(sessionKey: string | undefined | null): boolean;
 export declare function isCronSessionKey(sessionKey: string | undefined | null): boolean;
 export declare function isSubagentSessionKey(sessionKey: string | undefined | null): boolean;
 export declare function getSubagentDepth(sessionKey: string | undefined | null): number;

package/dist/src/routing/session-key-utils.js

@@ -16,11 +16,6 @@ function parseAgentSessionKey(sessionKey) {
 		rest
 	};
 }
-function isCronRunSessionKey(sessionKey) {
-	const parsed = parseAgentSessionKey(sessionKey);
-	if (!parsed) return false;
-	return /^cron:[^:]+:run:[^:]+$/.test(parsed.rest);
-}
 function isCronSessionKey(sessionKey) {
 	const parsed = parseAgentSessionKey(sessionKey);
 	if (!parsed) return false;
@@ -87,4 +82,4 @@ var init_session_key_utils = __esmMin((() => {
 }));
 //#endregion
 init_session_key_utils();
-export { getSubagentDepth, init_session_key_utils, isAcpSessionKey, isCronRunSessionKey, isCronSessionKey, isSubagentSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseThreadSessionSuffix, resolveThreadParentSessionKey };
+export { getSubagentDepth, init_session_key_utils, isAcpSessionKey, isCronSessionKey, isSubagentSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseThreadSessionSuffix, resolveThreadParentSessionKey };

package/dist/src/routing/session-key.js

@@ -1,6 +1,6 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId, normalizeOptionalAccountId } from "./account-id.js";
-import { getSubagentDepth, init_session_key_utils, isAcpSessionKey, isCronRunSessionKey, isCronSessionKey, isSubagentSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseThreadSessionSuffix, resolveThreadParentSessionKey } from "./session-key-utils.js";
+import { getSubagentDepth, init_session_key_utils, isAcpSessionKey, isCronSessionKey, isSubagentSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseThreadSessionSuffix, resolveThreadParentSessionKey } from "./session-key-utils.js";
 import { DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, assertAgentSessionKey, buildAgentMainSessionKey, buildAgentPeerSessionKey, buildGroupHistoryKey, classifySessionKeyShape, defaultMainSessionKey, init_agent_session_key, isValidAgentId, normalizeAgentId, normalizeMainKey, normalizeSessionKey, resolveAgentIdFromSessionKey, resolveThreadSessionKeys, sanitizeAgentId, scopedHeartbeatWakeOptions, toAgentRequestSessionKey, toAgentStoreSessionKey } from "./agent-session-key.js";
 //#region src/routing/session-key.ts
 function sanitizeSegment(value, options) {
@@ -188,4 +188,4 @@ var init_session_key = __esmMin((() => {
 }));
 //#endregion
 init_session_key();
-export { DEFAULT_ACCOUNT_ID, DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, assertAgentSessionKey, buildAgentMainSessionKey, buildAgentPeerSessionKey, buildGroupHistoryKey, buildSessionKey, buildSubagentSessionKey, classifySessionKeyShape, defaultMainSessionKey, getParentSessionKey, getSubagentDepth, init_session_key, isAcpSessionKey, isCronRunSessionKey, isCronSessionKey, isSubagentSessionKey, isValidAgentId, isValidSegment, normalizeAccountId, normalizeAgentId, normalizeMainKey, normalizeOptionalAccountId, normalizeSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseSessionKey, parseThreadSessionSuffix, resolveAgentIdFromSessionKey, resolveThreadParentSessionKey, resolveThreadSessionKeys, sanitizeAgentId, sanitizeSegment, scopedHeartbeatWakeOptions, toAgentRequestSessionKey, toAgentStoreSessionKey };
+export { DEFAULT_ACCOUNT_ID, DEFAULT_AGENT_ID, DEFAULT_MAIN_KEY, assertAgentSessionKey, buildAgentMainSessionKey, buildAgentPeerSessionKey, buildGroupHistoryKey, buildSessionKey, buildSubagentSessionKey, classifySessionKeyShape, defaultMainSessionKey, getParentSessionKey, getSubagentDepth, init_session_key, isAcpSessionKey, isCronSessionKey, isSubagentSessionKey, isValidAgentId, isValidSegment, normalizeAccountId, normalizeAgentId, normalizeMainKey, normalizeOptionalAccountId, normalizeSessionKey, parseAgentSessionKey, parseRawSessionConversationRef, parseSessionKey, parseThreadSessionSuffix, resolveAgentIdFromSessionKey, resolveThreadParentSessionKey, resolveThreadSessionKeys, sanitizeAgentId, sanitizeSegment, scopedHeartbeatWakeOptions, toAgentRequestSessionKey, toAgentStoreSessionKey };

package/dist/src/storage/sqlite/migrations/118_task_board_rank.sql

@@ -0,0 +1,6 @@
+ALTER TABLE tasks ADD COLUMN board_rank INTEGER NOT NULL DEFAULT 0;
+
+UPDATE tasks SET board_rank = created_at;
+
+CREATE INDEX idx_tasks_project_phase_rank
+  ON tasks(project_id, phase, board_rank, created_at);

package/dist/src/storage/sqlite/migrations/119_proactive_disposition.sql

@@ -0,0 +1,13 @@
+ALTER TABLE proactive_insights ADD COLUMN proposed_action_json TEXT;
+ALTER TABLE proactive_insights ADD COLUMN disposition TEXT
+  CHECK (disposition IN ('record_silently', 'show_in_work', 'request_approval', 'auto_execute'));
+ALTER TABLE proactive_insights ADD COLUMN disposition_reason TEXT;
+ALTER TABLE proactive_insights ADD COLUMN action_status TEXT
+  CHECK (action_status IN ('not_authorized', 'approval_required', 'pending', 'executing', 'completed', 'rejected', 'failed'));
+ALTER TABLE proactive_insights ADD COLUMN action_result_json TEXT;
+ALTER TABLE proactive_insights ADD COLUMN action_error TEXT;
+ALTER TABLE proactive_insights ADD COLUMN disposition_at TEXT;
+ALTER TABLE proactive_insights ADD COLUMN action_updated_at TEXT;
+
+CREATE INDEX idx_proactive_insights_action_status
+  ON proactive_insights(action_status, created_at);

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 117;
+export declare const XOPC_DB_SCHEMA_VERSION = 119;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -12,7 +12,7 @@ const log = createLogger("Sqlite:Migrations");
 /** Baseline schema version applied from schema.sql on first open. */
 const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-const XOPC_DB_SCHEMA_VERSION = 117;
+const XOPC_DB_SCHEMA_VERSION = 119;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function backupBeforeTaskCutover(db, databasePath) {
 	db.exec("PRAGMA wal_checkpoint(FULL)");
@@ -57,7 +57,7 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 117;
+	const targetVersion = options.targetVersion ?? 119;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -94,7 +94,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 117;
+	const appVersion = options.targetVersion ?? 119;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,