@xopcai/xopc 0.0.178 → 0.0.180

package/dist/src/work/home-query-service.js

@@ -0,0 +1,389 @@
+import { isHomeAttentionAcknowledged } from "../storage/sqlite/home-attention-repository.js";
+import { getRelationshipSettings } from "../storage/sqlite/relationship-settings-repository.js";
+import { listConnectorApprovals } from "../storage/sqlite/connector-repository.js";
+import "../storage/sqlite/index.js";
+import { GoalService } from "../goals/goal-service.js";
+import { OutcomeRepository } from "./outcome-repository.js";
+import "../goals/index.js";
+import { AttentionGovernor } from "./attention-governor.js";
+import { listGatewayAgents } from "../gateway/agents-admin.js";
+import { getTunnelService } from "../tunnel/tunnel-service.js";
+import "../tunnel/index.js";
+import "../automations/domain/defaults.js";
+import "../automations/index.js";
+import { WorkItemService } from "../work-items/work-item-service.js";
+import "../work-items/index.js";
+import { OutcomeReceiptService } from "./outcome-receipt-service.js";
+//#region src/work/home-query-service.ts
+function workItemAttentionRank(item, nowMs) {
+	if (item.status === "needs_input" || item.status === "in_review" || item.status === "blocked") return 0;
+	if (item.dueAt != null && item.dueAt < nowMs) return 1;
+	if (item.dueAt != null && item.dueAt < nowMs + 1440 * 60 * 1e3) return 2;
+	if (item.priority === "urgent") return 3;
+	return 4;
+}
+function toHomeWorkItem(item, projectName) {
+	return {
+		...item,
+		projectName
+	};
+}
+function toHomeWorkflowRun(run) {
+	return {
+		id: run.id,
+		definitionId: run.definitionId,
+		title: run.title,
+		status: run.status,
+		sessionKey: run.metadata?.sessionKey,
+		createdAtMs: run.createdAtMs,
+		startedAtMs: run.startedAtMs,
+		completedAtMs: run.completedAtMs,
+		metrics: run.metrics
+	};
+}
+function triggerLabel(automation) {
+	const trigger = automation.trigger;
+	if (trigger.kind === "manual") return "manual";
+	if (trigger.kind === "webhook") return "webhook";
+	if (trigger.kind === "event") return `event:${trigger.eventType}`;
+	const schedule = trigger.schedule;
+	if (schedule.kind === "once") return schedule.at;
+	if (schedule.kind === "interval") return `every ${Math.round(schedule.everyMs / 6e4)} minutes`;
+	return schedule.expr;
+}
+function actionLabel(automation) {
+	if (automation.action.kind === "workflow") return `workflow:${automation.action.workflowId}`;
+	if (automation.action.kind === "browser_recipe") return `browser-workflow:${automation.action.recipeId}`;
+	return automation.action.agentId ? `agent:${automation.action.agentId}` : "agent";
+}
+function toHomeAutomation(automation) {
+	if (!automation.enabled || !automation.state.nextRunAtMs) return null;
+	return {
+		id: automation.id,
+		name: automation.name,
+		trigger: triggerLabel(automation),
+		action: actionLabel(automation),
+		nextRunAt: new Date(automation.state.nextRunAtMs).toISOString()
+	};
+}
+function toHomeAutomationRun(run) {
+	return {
+		id: run.id,
+		automationId: run.automationId,
+		automationName: run.automationName,
+		status: run.status,
+		createdAtMs: run.createdAtMs,
+		startedAtMs: run.startedAtMs,
+		endedAtMs: run.endedAtMs,
+		error: run.error,
+		summary: run.summary,
+		sessionKey: run.sessionKey,
+		workflowRunId: run.workflowRunId
+	};
+}
+function effectiveAutomationTimeoutSeconds(run, automation) {
+	return run.actionSnapshot.timeoutSeconds ?? automation?.reliability?.timeoutSeconds ?? 1800;
+}
+function attentionDetail(kind, status, locale, timeoutSeconds) {
+	const isChinese = locale?.toLowerCase().startsWith("zh") ?? false;
+	if (status === "timeout") {
+		const seconds = timeoutSeconds ?? 1800;
+		const duration = seconds % 60 === 0 ? `${seconds / 60} ${isChinese ? "分钟" : seconds === 60 ? "minute" : "minutes"}` : `${seconds} ${isChinese ? "秒" : seconds === 1 ? "second" : "seconds"}`;
+		return isChinese ? `运行超过 ${duration}，系统已停止本次执行。` : `The run exceeded ${duration} and was stopped.`;
+	}
+	if (isChinese) return kind === "automation_run" ? "自动化未能完成，请查看详情后重试。" : "工作流未能完成，请查看详情后重试。";
+	return kind === "automation_run" ? "The automation did not complete. Review the details and retry." : "The workflow did not complete. Review the details and retry.";
+}
+function decisionFromGoal(goal, projectName) {
+	if (goal.status !== "needs_input" && goal.status !== "blocked") return null;
+	return {
+		id: `goal:${goal.id}`,
+		kind: "goal",
+		title: goal.title,
+		detail: goal.blockedReason || goal.nextAction,
+		reason: goal.status,
+		urgency: "now",
+		href: `/work/${encodeURIComponent(goal.outcomeId)}`,
+		projectId: goal.projectId,
+		projectName,
+		updatedAt: goal.updatedAt
+	};
+}
+function decisionFromWorkItem(item, projectName, nowMs) {
+	let reason;
+	let urgency = "now";
+	if (item.status === "needs_input" || item.status === "in_review" || item.status === "blocked") reason = item.status;
+	else if (item.dueAt != null && item.dueAt < nowMs) reason = "overdue";
+	else if (item.dueAt != null && item.dueAt < nowMs + 1440 * 60 * 1e3) {
+		reason = "due_soon";
+		urgency = "soon";
+	}
+	if (!reason) return null;
+	return {
+		id: `work:${item.id}`,
+		kind: "work_item",
+		title: item.title,
+		detail: item.blockedReason || item.nextAction,
+		reason,
+		urgency,
+		href: `/work-items/${encodeURIComponent(item.id)}`,
+		projectId: item.projectId,
+		projectName,
+		updatedAt: item.updatedAt
+	};
+}
+function buildHomeBriefing(input) {
+	const isChinese = input.locale?.toLowerCase().startsWith("zh") ?? false;
+	const movingCount = input.activeWorkCount + input.activeWorkflowCount + input.activeGoalCount;
+	const attentionCount = input.decisions.length + input.attention.length;
+	const summary = attentionCount > 0 ? isChinese ? movingCount > 0 ? `有 ${attentionCount} 件事需要你处理；我正在继续推进 ${movingCount} 件工作。` : `有 ${attentionCount} 件事需要你处理。` : movingCount > 0 ? `${attentionCount} ${attentionCount === 1 ? "item needs" : "items need"} your attention; I’m continuing ${movingCount} in the background.` : `${attentionCount} ${attentionCount === 1 ? "item needs" : "items need"} your attention.` : movingCount > 0 ? isChinese ? `目前没有事情需要你处理；我正在继续推进 ${movingCount} 件工作。` : `Nothing needs you right now; I’m continuing ${movingCount} ${movingCount === 1 ? "item" : "items"} in the background.` : isChinese ? "今天还没有正在推进的事项。把想要的结果交给我，我会从这里开始。" : "Nothing is moving yet today. Hand me an outcome and I’ll take it from here.";
+	return {
+		generatedAt: input.nowMs,
+		summary,
+		focus: input.decisions.slice(0, 3),
+		progress: {
+			activeWorkCount: input.activeWorkCount,
+			activeWorkflowCount: input.activeWorkflowCount,
+			activeGoalCount: input.activeGoalCount,
+			movingCount
+		},
+		wins: input.wins.slice(0, 5),
+		nextScheduled: input.nextScheduled
+	};
+}
+var WorkHomeQueryService = class {
+	#goals = new GoalService();
+	#receipts = new OutcomeReceiptService();
+	#outcomes = new OutcomeRepository();
+	#attentionGovernor = new AttentionGovernor();
+	constructor(service) {
+		this.service = service;
+	}
+	async getSnapshot(locale) {
+		const notes = this.service.notesServiceInstance;
+		const sessions = this.service.sessions;
+		const agents = await listGatewayAgents(this.service.currentConfig);
+		const defaultAgent = agents.agents.find((agent) => agent.id === agents.defaultId) ?? agents.agents[0];
+		const workflowRunStore = this.service.createWorkflowRunService().createRunStore(defaultAgent?.id ?? agents.defaultId);
+		const tunnel = getTunnelService().getStatus();
+		const health = this.service.getHealth();
+		const workItems = new WorkItemService();
+		const nowMs = Date.now();
+		const outcomes = this.#outcomes.list({ limit: 60 });
+		const [recentlyOpened, inbox, pendingTasks, recentSessions, workflowRuns, automations, automationRuns, projects, allWorkItems, activeGoals, connectorApprovals] = await Promise.all([
+			notes.listNotes({
+				sortBy: "lastOpenedAt",
+				sortOrder: "desc",
+				limit: 10
+			}),
+			notes.listNotes({
+				status: "inbox",
+				limit: 0
+			}),
+			notes.listNotes({
+				pendingTasksOnly: true,
+				sortBy: "createdAt",
+				sortOrder: "desc",
+				limit: 10
+			}),
+			sessions.listSessions({
+				channel: "webchat",
+				sortBy: "updatedAt",
+				sortOrder: "desc",
+				limit: 50
+			}),
+			workflowRunStore.listRunSummaries(20),
+			this.service.automationServiceInstance.list(),
+			this.service.automationServiceInstance.listRuns({ limit: 10 }),
+			this.service.projects.list({ limit: 500 }),
+			Promise.resolve(workItems.listWorkItems({ limit: 100 })),
+			Promise.resolve(this.#goals.list({
+				status: [
+					"active",
+					"blocked",
+					"needs_input",
+					"paused"
+				],
+				limit: 100
+			})),
+			Promise.resolve(listConnectorApprovals({
+				principalId: "local-owner",
+				status: "pending",
+				limit: 100
+			}))
+		]);
+		const projectsById = new Map(projects.items.map((project) => [project.id, project]));
+		const workChats = recentSessions.items.filter((session) => (session.messageCount ?? 0) > 0).map((session) => ({
+			key: session.key,
+			name: session.name || "Conversation",
+			updatedAt: session.updatedAt,
+			active: sessions.getActiveRun(session.key).active
+		}));
+		const activeWorkItems = allWorkItems.items.filter((item) => item.status !== "done" && item.status !== "cancelled").sort((left, right) => {
+			return workItemAttentionRank(left, nowMs) - workItemAttentionRank(right, nowMs) || right.updatedAt - left.updatedAt;
+		});
+		const attentionWorkItems = activeWorkItems.filter((item) => workItemAttentionRank(item, nowMs) < 4).slice(0, 8).map((item) => toHomeWorkItem(item, projectsById.get(item.projectId)?.name ?? "Project"));
+		const currentWorkItems = activeWorkItems.slice(0, 30).map((item) => toHomeWorkItem(item, projectsById.get(item.projectId)?.name ?? "Project"));
+		const recentlyCompletedWorkItems = allWorkItems.items.filter((item) => item.status === "done").sort((left, right) => (right.completedAt ?? right.updatedAt) - (left.completedAt ?? left.updatedAt)).slice(0, 8).map((item) => toHomeWorkItem(item, projectsById.get(item.projectId)?.name ?? "Project"));
+		const activeWorkflowRuns = workflowRuns.filter((run) => run.status === "queued" || run.status === "running").slice(0, 5).map(toHomeWorkflowRun);
+		const failedWorkflowRuns = workflowRuns.filter((run) => run.status === "failed" || run.status === "timeout").slice(0, 5).map(toHomeWorkflowRun);
+		const recentWorkflowRuns = workflowRuns.slice(0, 5).map(toHomeWorkflowRun);
+		const upcomingAutomations = automations.map(toHomeAutomation).filter((automation) => Boolean(automation)).sort((a, b) => Date.parse(a.nextRunAt) - Date.parse(b.nextRunAt)).slice(0, 5);
+		const latestAutomationRuns = [...automationRuns].sort((left, right) => right.createdAtMs - left.createdAtMs).filter((run, index, all) => all.findIndex((candidate) => candidate.automationId === run.automationId) === index);
+		const automationsById = new Map(automations.map((automation) => [automation.id, automation]));
+		const decisionCandidates = [
+			...this.service.proactiveInbox.list({ limit: 20 }).filter((item) => item.status === "unread" || item.status === "read").map((item) => ({
+				id: `agent-judgment:${item.id}`,
+				kind: "agent_judgment",
+				title: item.insight.title,
+				detail: item.insight.summary,
+				reason: "decision_needed",
+				urgency: item.insight.urgency === "critical" || item.insight.urgency === "high" ? "now" : "soon",
+				href: `/work?judgment=${encodeURIComponent(item.id)}`,
+				updatedAt: Date.parse(item.updatedAt),
+				judgment: {
+					inboxItemId: item.id,
+					whyNow: item.insight.whyNow,
+					impact: item.insight.impact,
+					workDone: item.insight.workDone,
+					recommendation: item.insight.recommendation,
+					confidence: item.insight.confidence,
+					valueScore: item.insight.valueScore,
+					...item.insight.decision ? { decision: item.insight.decision } : {}
+				}
+			})),
+			...activeWorkItems.map((item) => decisionFromWorkItem(item, projectsById.get(item.projectId)?.name ?? "Project", nowMs)).filter((item) => Boolean(item)),
+			...activeGoals.map((goal) => decisionFromGoal(goal, goal.projectId ? projectsById.get(goal.projectId)?.name : void 0)).filter((item) => Boolean(item)),
+			...connectorApprovals.filter((approval) => Date.parse(approval.expiresAt) > nowMs).map((approval) => ({
+				id: `connector-approval:${approval.id}`,
+				kind: "connector_approval",
+				title: approval.actionId,
+				detail: `${approval.connectorId} · ${approval.scope}`,
+				reason: "approval_required",
+				urgency: "now",
+				href: "/connectors",
+				updatedAt: Date.parse(approval.createdAt),
+				response: {
+					kind: "connector_approval",
+					approvalId: approval.id
+				}
+			}))
+		];
+		const attentionCandidates = [...failedWorkflowRuns.filter((run) => !isHomeAttentionAcknowledged("workflow_run", run.id)).map((run) => ({
+			id: `workflow_run:${run.id}`,
+			kind: "workflow_run",
+			runId: run.id,
+			title: run.title,
+			detail: attentionDetail("workflow_run", run.status === "timeout" ? "timeout" : "failed", locale),
+			reason: run.status === "timeout" ? "run_timeout" : "run_failed",
+			href: `/workflows?runId=${encodeURIComponent(run.id)}`,
+			updatedAt: run.completedAtMs ?? run.startedAtMs ?? run.createdAtMs,
+			sessionKey: run.sessionKey
+		})), ...latestAutomationRuns.filter((run) => run.status === "failed" || run.status === "timeout").filter((run) => !isHomeAttentionAcknowledged("automation_run", run.id)).map((run) => ({
+			id: `automation_run:${run.id}`,
+			kind: "automation_run",
+			runId: run.id,
+			title: run.automationName || run.automationId,
+			detail: attentionDetail("automation_run", run.status === "timeout" ? "timeout" : "failed", locale, effectiveAutomationTimeoutSeconds(run, automationsById.get(run.automationId))),
+			reason: run.status === "timeout" ? "run_timeout" : "run_failed",
+			href: `/automations?run=${encodeURIComponent(run.id)}`,
+			updatedAt: run.endedAtMs ?? run.startedAtMs ?? run.createdAtMs,
+			sessionKey: run.sessionKey
+		}))].sort((left, right) => right.updatedAt - left.updatedAt);
+		const governed = this.#attentionGovernor.project({
+			decisions: decisionCandidates,
+			attention: attentionCandidates,
+			proactiveEnabled: getRelationshipSettings().proactiveEnabled
+		});
+		const decisions = governed.decisions;
+		const attention = governed.attention;
+		const wins = [
+			...recentlyCompletedWorkItems.map((item) => ({
+				id: `work:${item.id}`,
+				kind: "work_item",
+				title: item.title,
+				href: `/work-items/${encodeURIComponent(item.id)}`,
+				completedAt: item.completedAt ?? item.updatedAt
+			})),
+			...workflowRuns.filter((run) => run.status === "succeeded").map((run) => ({
+				id: `workflow:${run.id}`,
+				kind: "workflow_run",
+				title: run.title,
+				href: `/workflows?runId=${encodeURIComponent(run.id)}`,
+				completedAt: run.completedAtMs ?? run.createdAtMs
+			})),
+			...latestAutomationRuns.filter((run) => run.status === "succeeded").map((run) => ({
+				id: `automation:${run.id}`,
+				kind: "automation_run",
+				title: run.automationName || run.automationId,
+				href: "/automations",
+				completedAt: run.endedAtMs ?? run.createdAtMs
+			}))
+		].sort((left, right) => right.completedAt - left.completedAt);
+		const briefing = buildHomeBriefing({
+			locale,
+			decisions,
+			attention,
+			activeWorkCount: activeWorkItems.filter((item) => item.status === "in_progress").length,
+			activeWorkflowCount: activeWorkflowRuns.length,
+			activeGoalCount: activeGoals.filter((goal) => goal.status === "active").length,
+			wins,
+			nextScheduled: upcomingAutomations[0],
+			nowMs
+		});
+		return {
+			recentlyOpened: recentlyOpened.items.filter((note) => note.lastOpenedAt),
+			inboxCount: inbox.total,
+			pendingTasks: pendingTasks.items,
+			pendingTaskCount: pendingTasks.total,
+			recentSessions: recentSessions.items.slice(0, 5),
+			activeAgent: defaultAgent ? {
+				id: defaultAgent.id,
+				name: defaultAgent.name,
+				description: defaultAgent.description
+			} : { id: agents.defaultId },
+			gateway: {
+				status: health.status,
+				ready: health.ready,
+				httpListening: health.httpListening,
+				version: health.version,
+				uptime: health.uptime,
+				tunnel: {
+					state: tunnel.state,
+					publicUrl: tunnel.publicUrl,
+					connected: tunnel.state === "connected"
+				}
+			},
+			workflowRuns: {
+				active: activeWorkflowRuns,
+				recent: recentWorkflowRuns
+			},
+			briefing,
+			decisions,
+			attention,
+			attentionPolicy: governed.policy,
+			chats: {
+				running: workChats.filter((chat) => chat.active),
+				recent: workChats.filter((chat) => !chat.active).slice(0, 8)
+			},
+			work: {
+				attentionCount: activeWorkItems.filter((item) => workItemAttentionRank(item, nowMs) < 3).length,
+				overdueCount: activeWorkItems.filter((item) => item.dueAt != null && item.dueAt < nowMs).length,
+				todayCount: activeWorkItems.filter((item) => item.dueAt != null && item.dueAt >= nowMs && item.dueAt < nowMs + 1440 * 60 * 1e3).length,
+				items: attentionWorkItems,
+				current: currentWorkItems,
+				recentlyCompleted: recentlyCompletedWorkItems
+			},
+			upcomingAutomations,
+			outcomes: {
+				running: outcomes.filter((outcome) => outcome.userStatus === "running").slice(0, 20),
+				needsUser: outcomes.filter((outcome) => outcome.userStatus === "needs_user").slice(0, 20),
+				recentlyCompleted: outcomes.filter((outcome) => outcome.userStatus === "completed").slice(0, 10)
+			},
+			recentOutcomes: this.#receipts.list({ limit: 20 }).filter((receipt) => receipt.status !== "running").slice(0, 8),
+			recentAutomationRuns: automationRuns.slice(0, 5).map(toHomeAutomationRun)
+		};
+	}
+};
+//#endregion
+export { WorkHomeQueryService, buildHomeBriefing, decisionFromGoal, workItemAttentionRank };

package/dist/src/work/index.d.ts

@@ -0,0 +1,14 @@
+export * from './execution-context.js';
+export * from './attention-governor.js';
+export * from './home-query-service.js';
+export * from './outcome-receipt-service.js';
+export * from './outcome-projection-service.js';
+export * from './outcome-repository.js';
+export * from './outcome-execution-service.js';
+export * from './outcome-contract-definition.js';
+export * from './outcome-run-coordinator.js';
+export * from './project-operating-view-service.js';
+export * from './project-monitoring-service.js';
+export * from './work-intake-service.js';
+export * from './work-intake-repository.js';
+export * from './work-value-metrics-service.js';

package/dist/src/work/index.js

@@ -0,0 +1,15 @@
+import { OutcomeRepository } from "./outcome-repository.js";
+import { executionReceiptContext, resolveExecutionContext } from "./execution-context.js";
+import { AttentionGovernor } from "./attention-governor.js";
+import { OutcomeReceiptService, toOutcomeReceipt } from "./outcome-receipt-service.js";
+import { WorkHomeQueryService, buildHomeBriefing, decisionFromGoal, workItemAttentionRank } from "./home-query-service.js";
+import { EXECUTION_RECEIPT_PROJECTION_VERSION, OutcomeProjectionService } from "./outcome-projection-service.js";
+import { OutcomeExecutionService } from "./outcome-execution-service.js";
+import { defineOutcomeContract } from "./outcome-contract-definition.js";
+import { OutcomeRunCoordinator } from "./outcome-run-coordinator.js";
+import { ProjectMonitoringService, decideProactiveDisposition } from "./project-monitoring-service.js";
+import { ProjectOperatingViewService } from "./project-operating-view-service.js";
+import { WorkIntakeRepository } from "./work-intake-repository.js";
+import { WorkIntakeService } from "./work-intake-service.js";
+import { WorkValueMetricsService } from "./work-value-metrics-service.js";
+export { AttentionGovernor, EXECUTION_RECEIPT_PROJECTION_VERSION, OutcomeExecutionService, OutcomeProjectionService, OutcomeReceiptService, OutcomeRepository, OutcomeRunCoordinator, ProjectMonitoringService, ProjectOperatingViewService, WorkHomeQueryService, WorkIntakeRepository, WorkIntakeService, WorkValueMetricsService, buildHomeBriefing, decideProactiveDisposition, decisionFromGoal, defineOutcomeContract, executionReceiptContext, resolveExecutionContext, toOutcomeReceipt, workItemAttentionRank };

package/dist/src/work/outcome-contract-definition.d.ts

@@ -0,0 +1,8 @@
+export interface OutcomeContractDefinition {
+    objective: string;
+    deliverables: string[];
+    acceptanceCriteria: string[];
+    constraints: string[];
+    approvalRequired: string[];
+}
+export declare function defineOutcomeContract(objectiveInput: string): OutcomeContractDefinition;

package/dist/src/work/outcome-contract-definition.js

@@ -0,0 +1,15 @@
+//#region src/work/outcome-contract-definition.ts
+function defineOutcomeContract(objectiveInput) {
+	const objective = objectiveInput.trim();
+	if (!objective) throw new Error("Objective is required");
+	const chinese = /[\u3400-\u9fff]/u.test(objective);
+	return {
+		objective,
+		deliverables: [objective],
+		acceptanceCriteria: chinese ? [`已交付：${objective}`, "结果有可检查的证据，并满足用户明确提出的约束。"] : [`Delivered: ${objective}`, "The result has inspectable evidence and satisfies the user-provided constraints."],
+		constraints: [],
+		approvalRequired: []
+	};
+}
+//#endregion
+export { defineOutcomeContract };

package/dist/src/work/outcome-execution-service.d.ts

@@ -0,0 +1,27 @@
+import { type Goal, type GoalPriority, type GoalSource, type GoalUiLocale } from '../goals/index.js';
+export interface CreateOutcomeExecutionInput {
+    objective: string;
+    description?: string;
+    deliverables?: string[];
+    acceptanceCriteria?: string[];
+    constraints?: string[];
+    approvalRequired?: string[];
+    projectId?: string;
+    sessionKey?: string;
+    agentId?: string;
+    priority?: GoalPriority;
+    deadlineAt?: number;
+    judgeModelRef?: string;
+    maxTurns?: number;
+    uiLocale?: GoalUiLocale;
+    source?: GoalSource;
+}
+export interface OutcomeExecution {
+    outcomeId: string;
+    contractVersion: number;
+    goal: Goal;
+}
+export declare class OutcomeExecutionService {
+    #private;
+    create(input: CreateOutcomeExecutionInput): OutcomeExecution;
+}

package/dist/src/work/outcome-execution-service.js

@@ -0,0 +1,60 @@
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import "../storage/sqlite/index.js";
+import { GoalService } from "../goals/goal-service.js";
+import { OutcomeRepository } from "./outcome-repository.js";
+import "../goals/index.js";
+//#region src/work/outcome-execution-service.ts
+var OutcomeExecutionService = class {
+	#goals = new GoalService();
+	#outcomes = new OutcomeRepository();
+	create(input) {
+		const objective = input.objective.trim();
+		if (!objective) throw new Error("Objective is required");
+		return runSqliteWriteTransaction(() => {
+			const outcome = this.#outcomes.create({
+				objective,
+				deliverables: input.deliverables?.length ? input.deliverables : [objective],
+				acceptanceCriteria: input.acceptanceCriteria ?? [],
+				constraints: input.constraints ?? [],
+				approvalRequired: input.approvalRequired ?? [],
+				createdBy: "user",
+				links: [...input.projectId ? [{
+					kind: "project",
+					id: input.projectId,
+					relation: "contains"
+				}] : [], ...input.sessionKey ? [{
+					kind: "session",
+					id: input.sessionKey,
+					relation: "originated_from"
+				}] : []]
+			});
+			const goal = this.#goals.create({
+				outcomeId: outcome.id,
+				outcomeContractVersion: outcome.latestContractVersion,
+				title: objective,
+				description: input.description,
+				projectId: input.projectId,
+				sessionKey: input.sessionKey,
+				agentId: input.agentId ?? "main",
+				priority: input.priority,
+				deadlineAt: input.deadlineAt,
+				judgeModelRef: input.judgeModelRef,
+				maxTurns: input.maxTurns,
+				uiLocale: input.uiLocale,
+				source: input.source
+			});
+			this.#outcomes.addLink(outcome.id, {
+				kind: "goal",
+				id: goal.id,
+				relation: "drives"
+			});
+			return {
+				outcomeId: outcome.id,
+				contractVersion: outcome.latestContractVersion,
+				goal
+			};
+		});
+	}
+};
+//#endregion
+export { OutcomeExecutionService };

package/dist/src/work/outcome-projection-service.d.ts

@@ -0,0 +1,7 @@
+import { type ExecutionReceipt } from '../storage/sqlite/index.js';
+export declare const EXECUTION_RECEIPT_PROJECTION_VERSION = 4;
+export declare class OutcomeProjectionService {
+    #private;
+    project(outcome: ExecutionReceipt): ExecutionReceipt;
+    reconcile(limit?: number): number;
+}

package/dist/src/work/outcome-projection-service.js

@@ -0,0 +1,51 @@
+import { listUnprojectedExecutionReceipts, markExecutionReceiptProjected } from "../storage/sqlite/execution-receipt-repository.js";
+import "../storage/sqlite/index.js";
+import { OutcomeRepository } from "./outcome-repository.js";
+//#region src/work/outcome-projection-service.ts
+const EXECUTION_RECEIPT_PROJECTION_VERSION = 4;
+const MAX_AUTONOMOUS_ATTEMPTS = 3;
+function canRecoverAutonomously(outcome) {
+	return outcome.status === "failed" && outcome.attempt < MAX_AUTONOMOUS_ATTEMPTS && outcome.failure?.recoveryAction !== "request_user_input" && outcome.failure?.recoveryAction !== "none";
+}
+var OutcomeProjectionService = class {
+	#outcomes = new OutcomeRepository();
+	project(outcome) {
+		if (outcome.status === "running" || outcome.projectionVersion >= 4) return outcome;
+		const verdict = outcome.completionVerdict;
+		const recovering = canRecoverAutonomously(outcome);
+		if (outcome.context.outcomeId) {
+			if (verdict === "achieved") this.#outcomes.updateState({
+				id: outcome.context.outcomeId,
+				userStatus: "completed",
+				internalStatus: "completed",
+				latestReceiptRunId: outcome.runId
+			});
+			else if (verdict === "partial") this.#outcomes.updateState({
+				id: outcome.context.outcomeId,
+				userStatus: outcome.needsUser ? "needs_user" : "running",
+				internalStatus: outcome.needsUser ? "needs_user" : "continuing",
+				latestReceiptRunId: outcome.runId
+			});
+			else if (verdict === "not_achieved") this.#outcomes.updateState({
+				id: outcome.context.outcomeId,
+				userStatus: outcome.status === "cancelled" ? "completed" : recovering ? "running" : "needs_user",
+				internalStatus: outcome.status === "cancelled" ? "cancelled" : recovering ? "continuing" : "blocked",
+				latestReceiptRunId: outcome.runId
+			});
+		}
+		return markExecutionReceiptProjected({
+			runId: outcome.runId,
+			projectionVersion: 4
+		}) ?? outcome;
+	}
+	reconcile(limit = 100) {
+		const pending = listUnprojectedExecutionReceipts({
+			projectionVersion: 4,
+			limit
+		});
+		for (const outcome of pending) this.project(outcome);
+		return pending.length;
+	}
+};
+//#endregion
+export { EXECUTION_RECEIPT_PROJECTION_VERSION, OutcomeProjectionService };

package/dist/src/work/outcome-receipt-service.d.ts

@@ -0,0 +1,13 @@
+import type { OutcomeReceipt } from '@xopcai/gateway-contract';
+import { type ExecutionReceipt } from '../storage/sqlite/index.js';
+export declare function toOutcomeReceipt(outcome: ExecutionReceipt): OutcomeReceipt;
+export declare class OutcomeReceiptService {
+    get(runId: string): OutcomeReceipt | undefined;
+    list(input?: {
+        outcomeId?: string;
+        projectId?: string;
+        workItemId?: string;
+        sessionKey?: string;
+        limit?: number;
+    }): OutcomeReceipt[];
+}

package/dist/src/work/outcome-receipt-service.js

@@ -0,0 +1,55 @@
+import { getExecutionReceipt, listExecutionReceipts } from "../storage/sqlite/execution-receipt-repository.js";
+import "../storage/sqlite/index.js";
+//#region src/work/outcome-receipt-service.ts
+function receiptStatus(outcome) {
+	if (outcome.status === "running") return "running";
+	if (outcome.status === "cancelled") return "cancelled";
+	if (outcome.needsUser) return "needs_user";
+	if (outcome.completionVerdict === "achieved") return "completed";
+	if (outcome.completionVerdict === "partial") return "partial";
+	return "failed";
+}
+function remainingWork(outcome) {
+	const incomplete = outcome.verification.checks.filter((check) => check.status !== "passed").map((check) => check.criterion);
+	if (outcome.nextAction && !incomplete.includes(outcome.nextAction)) incomplete.push(outcome.nextAction);
+	return incomplete;
+}
+function toOutcomeReceipt(outcome) {
+	return {
+		runId: outcome.runId,
+		...outcome.context.outcomeId ? { outcomeId: outcome.context.outcomeId } : {},
+		...outcome.contractVersion ? { contractVersion: outcome.contractVersion } : {},
+		sessionKey: outcome.sessionKey,
+		objective: outcome.objective,
+		status: receiptStatus(outcome),
+		summary: outcome.summary ?? (outcome.status === "running" ? "Work is in progress." : "Work finished without a summary."),
+		projectId: outcome.context.projectId,
+		goalId: outcome.context.goalId,
+		workItemId: outcome.context.workItemId,
+		origin: outcome.context.origin,
+		triggerKind: outcome.context.triggerKind,
+		changes: outcome.evidence.filter((item) => item.kind === "artifact" || item.kind === "state"),
+		evidence: outcome.evidence,
+		verification: outcome.verification,
+		remainingWork: remainingWork(outcome),
+		nextAction: outcome.nextAction,
+		needsUser: outcome.needsUser,
+		completionVerdict: outcome.completionVerdict,
+		correctionText: outcome.correctionText,
+		contextTraceId: outcome.context.contextTraceId,
+		startedAt: outcome.startedAt,
+		completedAt: outcome.completedAt,
+		feedback: outcome.feedback
+	};
+}
+var OutcomeReceiptService = class {
+	get(runId) {
+		const outcome = getExecutionReceipt(runId);
+		return outcome ? toOutcomeReceipt(outcome) : void 0;
+	}
+	list(input = {}) {
+		return listExecutionReceipts(input).map(toOutcomeReceipt);
+	}
+};
+//#endregion
+export { OutcomeReceiptService, toOutcomeReceipt };