@xopcai/xopc 0.0.178 → 0.0.179

package/dist/src/work/execution-context.js

@@ -0,0 +1,66 @@
+//#region src/work/execution-context.ts
+const ORIGINS = new Set([
+	"chat",
+	"goal",
+	"workflow",
+	"automation",
+	"browser",
+	"proactive"
+]);
+const TRIGGERS = new Set([
+	"user",
+	"schedule",
+	"webhook",
+	"proactive",
+	"retry"
+]);
+function optionalString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function metadataOrigin(metadata) {
+	const explicit = optionalString(metadata.customData?.origin);
+	if (explicit && ORIGINS.has(explicit)) return explicit;
+	if (optionalString(metadata.customData?.goalId)) return "goal";
+	if (metadata.sessionType === "workflow-run" || metadata.sessionType === "workflow-subagent") return "workflow";
+	if (metadata.sessionType === "cron") return "automation";
+	if (metadata.sessionType === "heartbeat") return "proactive";
+	if (optionalString(metadata.customData?.browserRecipeId)) return "browser";
+	return "chat";
+}
+function metadataTrigger(metadata) {
+	const explicit = optionalString(metadata.customData?.triggerKind);
+	if (explicit && TRIGGERS.has(explicit)) return explicit;
+	if (metadata.sessionType === "cron") return "schedule";
+	if (metadata.sessionType === "heartbeat") return "proactive";
+	return "user";
+}
+function resolveExecutionContext(input) {
+	return {
+		runId: input.runId,
+		sessionKey: input.sessionKey,
+		channel: input.channel,
+		agentId: input.agentId,
+		projectId: input.metadata.projectId,
+		outcomeId: optionalString(input.metadata.customData?.outcomeId),
+		goalId: optionalString(input.metadata.customData?.goalId),
+		workItemId: optionalString(input.metadata.customData?.workItemId),
+		origin: metadataOrigin(input.metadata),
+		triggerKind: metadataTrigger(input.metadata),
+		parentRunId: optionalString(input.metadata.customData?.parentRunId),
+		contextTraceId: optionalString(input.metadata.customData?.contextTraceId)
+	};
+}
+function executionReceiptContext(context) {
+	return {
+		outcomeId: context.outcomeId,
+		projectId: context.projectId,
+		goalId: context.goalId,
+		workItemId: context.workItemId,
+		origin: context.origin,
+		triggerKind: context.triggerKind,
+		parentRunId: context.parentRunId,
+		contextTraceId: context.contextTraceId
+	};
+}
+//#endregion
+export { executionReceiptContext, resolveExecutionContext };

package/dist/src/work/home-query-service.d.ts

@@ -0,0 +1,118 @@
+import type { WorkHomeResponse } from '@xopcai/gateway-contract';
+import type { GatewayService } from '../gateway/service.js';
+import { type AutomationRun } from '../automations/index.js';
+type HomeDecision = WorkHomeResponse['decisions'][number];
+type HomeAttention = WorkHomeResponse['attention'][number];
+type HomeBriefingWin = WorkHomeResponse['briefing']['wins'][number];
+type HomeAutomation = WorkHomeResponse['upcomingAutomations'][number];
+type HomeAutomationRun = {
+    id: string;
+    automationId: string;
+    automationName?: string;
+    status: AutomationRun['status'];
+    createdAtMs: number;
+    startedAtMs?: number;
+    endedAtMs?: number;
+    error?: string;
+    summary?: string;
+    sessionKey?: string;
+    workflowRunId?: string;
+};
+type HomeSnapshot = WorkHomeResponse & {
+    recentlyOpened: unknown[];
+    inboxCount: number;
+    pendingTasks: unknown[];
+    pendingTaskCount: number;
+    recentSessions: unknown[];
+    activeAgent: {
+        id: string;
+        name?: string;
+        description?: string;
+    };
+    gateway: Record<string, unknown>;
+    recentAutomationRuns: HomeAutomationRun[];
+};
+export declare function workItemAttentionRank(item: {
+    status: string;
+    dueAt?: number;
+    priority: string;
+    updatedAt: number;
+}, nowMs: number): number;
+export declare function buildHomeBriefing(input: {
+    locale?: string;
+    decisions: HomeDecision[];
+    attention: HomeAttention[];
+    activeWorkCount: number;
+    activeWorkflowCount: number;
+    activeGoalCount: number;
+    wins: HomeBriefingWin[];
+    nextScheduled?: HomeAutomation;
+    nowMs: number;
+}): {
+    generatedAt: number;
+    summary: string;
+    focus: {
+        id: string;
+        kind: "work_item" | "goal" | "agent_judgment" | "connector_approval" | "goal_evidence";
+        title: string;
+        reason: "approval_required" | "blocked" | "needs_input" | "in_review" | "overdue" | "due_soon" | "decision_needed";
+        urgency: "now" | "soon";
+        href: string;
+        updatedAt: number;
+        detail?: string;
+        projectId?: string;
+        projectName?: string;
+        judgment?: {
+            inboxItemId: string;
+            whyNow: string;
+            impact: string;
+            workDone: string;
+            recommendation: string;
+            confidence: number;
+            valueScore?: number;
+            decision?: {
+                question: string;
+                options: {
+                    id: string;
+                    label: string;
+                    consequence: string;
+                }[];
+            };
+        };
+        response?: {
+            kind: "connector_approval";
+            approvalId: string;
+        } | {
+            kind: "goal_evidence";
+            goalId: string;
+            requirementId: string;
+        };
+    }[];
+    progress: {
+        activeWorkCount: number;
+        activeWorkflowCount: number;
+        activeGoalCount: number;
+        movingCount: number;
+    };
+    wins: {
+        id: string;
+        kind: "work_item" | "workflow_run" | "automation_run";
+        title: string;
+        href: string;
+        completedAt: number;
+    }[];
+    nextScheduled: {
+        id: string;
+        trigger: string;
+        action: string;
+        nextRunAt: string;
+        name?: string;
+    };
+};
+export declare class WorkHomeQueryService {
+    #private;
+    private readonly service;
+    constructor(service: GatewayService);
+    getSnapshot(locale?: string): Promise<HomeSnapshot>;
+}
+export {};

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 ?? 300;
+}
+function attentionDetail(kind, status, locale, timeoutSeconds) {
+	const isChinese = locale?.toLowerCase().startsWith("zh") ?? false;
+	if (status === "timeout") {
+		const seconds = timeoutSeconds ?? 300;
+		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: `/goals/${encodeURIComponent(goal.id)}`,
+		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, 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, 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, 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;
+}