@xopcai/xopc 0.0.196 → 0.0.199

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

@@ -19,7 +19,7 @@ const log = createLogger('Sqlite:Migrations');
 export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 
 /** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 117;
+export const XOPC_DB_SCHEMA_VERSION = 119;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

package/dist/src/storage/sqlite/schema.js

@@ -32,7 +32,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 11;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 117,
+		targetVersion: 119,
 		databasePath: options.databasePath
 	});
 }

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

@@ -6,12 +6,25 @@ import type { NotesService } from '../notes/service.js';
 import type { ProactiveInboxService } from '../proactive/inbox/service.js';
 import type { ProjectService } from '../projects/project-service.js';
 import type { SessionIndex } from '../session/manager.js';
+import type { WorkflowRunSummary } from '../workflows/domain/index.js';
 import type { WorkflowRunService } from '../workflows/service/workflow-run-service.js';
 import { type TaskReadModel } from './task-read-model-projector.js';
 type HomeDecision = HomeResponse['decisions'][number];
 type HomeAttention = HomeResponse['attention'][number];
 type HomeBriefingWin = HomeResponse['briefing']['wins'][number];
 type HomeAutomation = HomeResponse['upcomingAutomations'][number];
+type HomeFocusItem = HomeResponse['focusItems'][number];
+type HomeWorkflowRun = {
+    id: string;
+    definitionId: string;
+    title: string;
+    status: WorkflowRunSummary['status'];
+    sessionKey?: string;
+    createdAtMs: number;
+    startedAtMs?: number;
+    completedAtMs?: number;
+    metrics: WorkflowRunSummary['metrics'];
+};
 type HomeAutomationRun = {
     id: string;
     automationId: string;
@@ -92,6 +105,11 @@ export declare function buildHomeBriefing(input: {
             recommendation: string;
             confidence: number;
             valueScore?: number;
+            disposition?: "show_in_work" | "request_approval" | "auto_execute";
+            dispositionReason?: string;
+            actionStatus?: "failed" | "completed" | "rejected" | "pending" | "approval_required" | "not_authorized" | "executing";
+            proposedActionTitle?: string;
+            actionError?: string;
             decision?: {
                 question: string;
                 options: {
@@ -126,6 +144,17 @@ export declare function buildHomeBriefing(input: {
         name?: string;
     };
 };
+export declare function buildHomeFocusItems(input: {
+    locale?: string;
+    decisions: HomeDecision[];
+    attention: HomeAttention[];
+    activeWorkflowRuns: HomeWorkflowRun[];
+    runningTasks: HomeResponse['tasks']['running'];
+    wins: HomeBriefingWin[];
+    nextScheduled?: HomeAutomation;
+    inboxCount: number;
+    nowMs: number;
+}): HomeFocusItem[];
 export declare class HomeQueryService {
     #private;
     private readonly service;

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

@@ -114,6 +114,273 @@ function buildHomeBriefing(input) {
 		nextScheduled: input.nextScheduled
 	};
 }
+function homeActionCopy(locale) {
+	return locale?.toLowerCase().startsWith("zh") ?? false ? {
+		approve: "允许并继续",
+		deny: "拒绝",
+		review: "查看并处理",
+		retry: "重试",
+		acknowledge: "暂时忽略",
+		viewProgress: "查看进度",
+		viewResult: "查看结果",
+		viewSchedule: "查看计划",
+		runningTask: "任务正在推进",
+		runningWorkflow: "工作流正在推进",
+		scheduled: "下一项定时工作",
+		organizeInbox: "整理收件箱",
+		organizeInboxSummary: "把刚捕获的内容整理成笔记、任务或后续行动。",
+		openInbox: "去整理",
+		startSomething: "今天想推进什么？",
+		startSomethingSummary: "把想要的结果交给我，我会从这里开始。",
+		askAi: "交给 Agent"
+	} : {
+		approve: "Allow and continue",
+		deny: "Deny",
+		review: "Review",
+		retry: "Retry",
+		acknowledge: "Dismiss",
+		viewProgress: "View progress",
+		viewResult: "View result",
+		viewSchedule: "View schedule",
+		runningTask: "Task in progress",
+		runningWorkflow: "Workflow in progress",
+		scheduled: "Next scheduled work",
+		organizeInbox: "Organize your inbox",
+		organizeInboxSummary: "Turn recent captures into notes, tasks, or next actions.",
+		openInbox: "Organize",
+		startSomething: "What would you like to move forward?",
+		startSomethingSummary: "Hand me the outcome you want and I’ll take it from here.",
+		askAi: "Ask an agent"
+	};
+}
+function buildHomeFocusItems(input) {
+	const copy = homeActionCopy(input.locale);
+	const decisions = input.decisions.map((decision) => {
+		const openAction = decision.kind === "agent_judgment" && decision.judgment ? {
+			type: "open",
+			label: copy.review,
+			target: "inbox_judgment",
+			targetId: decision.judgment.inboxItemId
+		} : decision.kind === "task" ? {
+			type: "open",
+			label: copy.review,
+			target: "task",
+			targetId: decision.id.replace(/^task:/, "")
+		} : {
+			type: "open",
+			label: copy.review,
+			target: "work"
+		};
+		const connectorActions = decision.response?.kind === "connector_approval" ? {
+			primaryAction: {
+				type: "connector_decision",
+				label: copy.approve,
+				approvalId: decision.response.approvalId,
+				decision: "approve"
+			},
+			secondaryActions: [{
+				type: "connector_decision",
+				label: copy.deny,
+				approvalId: decision.response.approvalId,
+				decision: "deny"
+			}]
+		} : {
+			primaryAction: openAction,
+			secondaryActions: []
+		};
+		return {
+			id: decision.id,
+			kind: "decision",
+			priority: decision.urgency === "now" ? 100 : 90,
+			title: decision.title,
+			summary: decision.detail || copy.review,
+			statusLabel: copy.review,
+			updatedAt: decision.updatedAt,
+			pinnable: false,
+			openAction,
+			...connectorActions
+		};
+	});
+	const failures = input.attention.map((item) => ({
+		id: item.id,
+		kind: "failure",
+		priority: 80,
+		title: item.title,
+		summary: item.detail,
+		updatedAt: item.updatedAt,
+		pinnable: false,
+		openAction: item.kind === "workflow_run" ? item.sessionKey ? {
+			type: "open",
+			label: copy.review,
+			target: "session",
+			sessionKey: item.sessionKey
+		} : {
+			type: "open",
+			label: copy.review,
+			target: "workflow_run",
+			targetId: item.runId
+		} : {
+			type: "open",
+			label: copy.review,
+			target: "automation",
+			targetId: item.runId
+		},
+		primaryAction: {
+			type: "retry_run",
+			label: copy.retry,
+			subjectKind: item.kind,
+			runId: item.runId
+		},
+		secondaryActions: [{
+			type: "acknowledge_run",
+			label: copy.acknowledge,
+			subjectKind: item.kind,
+			runId: item.runId
+		}]
+	}));
+	const workflows = input.activeWorkflowRuns.map((run) => {
+		const openAction = run.sessionKey ? {
+			type: "open",
+			label: copy.viewProgress,
+			target: "session",
+			sessionKey: run.sessionKey
+		} : {
+			type: "open",
+			label: copy.viewProgress,
+			target: "workflow_run",
+			targetId: run.id
+		};
+		return {
+			id: `workflow:${run.id}`,
+			kind: "running",
+			priority: 60,
+			title: run.title,
+			summary: copy.runningWorkflow,
+			statusLabel: run.metrics.agentCount > 0 ? `${run.metrics.doneAgentCount}/${run.metrics.agentCount}` : void 0,
+			updatedAt: run.startedAtMs ?? run.createdAtMs,
+			pinnable: true,
+			openAction,
+			primaryAction: openAction,
+			secondaryActions: []
+		};
+	});
+	const tasks = input.runningTasks.map((task) => {
+		const openAction = {
+			type: "open",
+			label: copy.viewProgress,
+			target: "task",
+			targetId: task.id
+		};
+		return {
+			id: `task:${task.id}`,
+			kind: "running",
+			priority: 55,
+			title: task.title,
+			summary: copy.runningTask,
+			updatedAt: task.updatedAt,
+			pinnable: true,
+			openAction,
+			primaryAction: openAction,
+			secondaryActions: []
+		};
+	});
+	const results = input.wins.map((win) => {
+		const openAction = win.kind === "workflow_run" ? {
+			type: "open",
+			label: copy.viewResult,
+			target: "workflow_run",
+			targetId: win.id.replace(/^workflow:/, "")
+		} : win.kind === "automation_run" ? {
+			type: "open",
+			label: copy.viewResult,
+			target: "automation",
+			targetId: win.id.replace(/^automation:/, "")
+		} : {
+			type: "open",
+			label: copy.viewResult,
+			target: "task",
+			targetId: win.id.replace(/^task:/, "")
+		};
+		return {
+			id: win.id,
+			kind: "result",
+			priority: 40,
+			title: win.title,
+			summary: copy.viewResult,
+			updatedAt: win.completedAt,
+			pinnable: true,
+			openAction,
+			primaryAction: openAction,
+			secondaryActions: []
+		};
+	});
+	const scheduled = input.nextScheduled ? [{
+		id: `automation:${input.nextScheduled.id}:scheduled`,
+		kind: "scheduled",
+		priority: 30,
+		title: input.nextScheduled.name || input.nextScheduled.id,
+		summary: copy.scheduled,
+		statusLabel: new Date(input.nextScheduled.nextRunAt).toLocaleString(input.locale),
+		updatedAt: Date.parse(input.nextScheduled.nextRunAt),
+		pinnable: true,
+		openAction: {
+			type: "open",
+			label: copy.viewSchedule,
+			target: "automation",
+			targetId: input.nextScheduled.id
+		},
+		primaryAction: {
+			type: "open",
+			label: copy.viewSchedule,
+			target: "automation",
+			targetId: input.nextScheduled.id
+		},
+		secondaryActions: []
+	}] : [];
+	const items = [
+		...decisions,
+		...failures,
+		...workflows,
+		...tasks,
+		...results,
+		...scheduled
+	].sort((left, right) => right.priority - left.priority || right.updatedAt - left.updatedAt);
+	if (items.length > 0) return items;
+	if (input.inboxCount > 0) return [{
+		id: "suggestion:organize-inbox",
+		kind: "suggestion",
+		priority: 10,
+		title: `${copy.organizeInbox} · ${input.inboxCount}`,
+		summary: copy.organizeInboxSummary,
+		updatedAt: input.nowMs,
+		pinnable: false,
+		openAction: {
+			type: "open",
+			label: copy.openInbox,
+			target: "inbox"
+		},
+		primaryAction: {
+			type: "open",
+			label: copy.openInbox,
+			target: "inbox"
+		},
+		secondaryActions: []
+	}];
+	return [{
+		id: "suggestion:ask-agent",
+		kind: "suggestion",
+		priority: 10,
+		title: copy.startSomething,
+		summary: copy.startSomethingSummary,
+		updatedAt: input.nowMs,
+		pinnable: false,
+		primaryAction: {
+			type: "ask_ai",
+			label: copy.askAi
+		},
+		secondaryActions: []
+	}];
+}
 var HomeQueryService = class {
 	#runs = new TaskRunRepository();
 	#tasks = new TaskRepository();
@@ -184,7 +451,7 @@ var HomeQueryService = class {
 				kind: "agent_judgment",
 				title: item.insight.title,
 				detail: item.insight.summary,
-				reason: "decision_needed",
+				reason: item.insight.disposition === "request_approval" ? "approval_required" : "decision_needed",
 				urgency: item.insight.urgency === "critical" || item.insight.urgency === "high" ? "now" : "soon",
 				href: `/?judgment=${encodeURIComponent(item.id)}`,
 				updatedAt: Date.parse(item.updatedAt),
@@ -196,7 +463,12 @@ var HomeQueryService = class {
 					recommendation: item.insight.recommendation,
 					confidence: item.insight.confidence,
 					valueScore: item.insight.valueScore,
-					...item.insight.decision ? { decision: item.insight.decision } : {}
+					disposition: item.insight.disposition,
+					dispositionReason: item.insight.dispositionReason,
+					...item.insight.actionStatus ? { actionStatus: item.insight.actionStatus } : {},
+					...item.insight.proposedAction ? { proposedActionTitle: item.insight.proposedAction.input.title } : {},
+					...item.insight.actionError ? { actionError: item.insight.actionError } : {},
+					...item.insight.decision && (!item.insight.proposedAction || item.insight.actionStatus === "approval_required") ? { decision: item.insight.decision } : {}
 				}
 			})),
 			...activeTasks.map((task) => decisionFromTask(this.#projector.project(task), task.projectId ? projectsById.get(task.projectId)?.name : void 0)).filter((item) => Boolean(item)),
@@ -256,6 +528,10 @@ var HomeQueryService = class {
 			href: "/automations",
 			completedAt: run.endedAtMs ?? run.createdAtMs
 		}))].sort((left, right) => right.completedAt - left.completedAt);
+		const runningTasks = tasks.filter((task) => {
+			const state = this.#projector.project(task).operationalState;
+			return state === "queued" || state === "running" || state === "verifying";
+		}).slice(0, 20);
 		const briefing = buildHomeBriefing({
 			locale,
 			decisions,
@@ -267,6 +543,17 @@ var HomeQueryService = class {
 			nowMs
 		});
 		return {
+			focusItems: buildHomeFocusItems({
+				locale,
+				decisions,
+				attention,
+				activeWorkflowRuns,
+				runningTasks,
+				wins,
+				nextScheduled: upcomingAutomations[0],
+				inboxCount: inbox.total,
+				nowMs
+			}),
 			recentlyOpened: recentlyOpened.items.filter((note) => note.lastOpenedAt),
 			inboxCount: inbox.total,
 			pendingTasks: pendingTasks.items,
@@ -302,14 +589,11 @@ var HomeQueryService = class {
 				recent: workChats.filter((chat) => !chat.active).slice(0, 8)
 			},
 			upcomingAutomations,
-			tasks: { running: tasks.filter((task) => {
-				const state = this.#projector.project(task).operationalState;
-				return state === "queued" || state === "running" || state === "verifying";
-			}).slice(0, 20) },
+			tasks: { running: runningTasks },
 			recentTasks: tasks.flatMap((task) => this.#runs.listReceipts(task.id, 3)).sort((a, b) => b.finalizedAt - a.finalizedAt).slice(0, 8),
 			recentAutomationRuns: automationRuns.slice(0, 5).map(toHomeAutomationRun)
 		};
 	}
 };
 //#endregion
-export { HomeQueryService, buildHomeBriefing, decisionFromTask };
+export { HomeQueryService, buildHomeBriefing, buildHomeFocusItems, decisionFromTask };

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

@@ -11,6 +11,7 @@ export * from './project-operating-view-service.js';
 export * from './project-monitoring-service.js';
 export * from './task-value-metrics-service.js';
 export * from './task-application-service.js';
+export * from './task-change-events.js';
 export * from './task-context-repository.js';
 export * from './task-dependency-service.js';
 export * from './task-read-model-projector.js';

package/dist/src/tasks/index.js

@@ -3,8 +3,9 @@ import { TaskRunRepository } from "./task-run-repository.js";
 import { TaskReadModelProjector } from "./task-read-model-projector.js";
 import { resolveExecutionContext } from "./execution-context.js";
 import { AttentionGovernor } from "./attention-governor.js";
-import { HomeQueryService, buildHomeBriefing, decisionFromTask } from "./home-query-service.js";
+import { HomeQueryService, buildHomeBriefing, buildHomeFocusItems, decisionFromTask } from "./home-query-service.js";
 import { TaskContextRepository } from "./task-context-repository.js";
+import { enqueueTaskChanged, enqueueTaskChangedEvent } from "./task-change-events.js";
 import { TaskDependencyError, TaskDependencyService } from "./task-dependency-service.js";
 import { TaskApplicationService } from "./task-application-service.js";
 import { TaskWorkflowCoordinator } from "./task-workflow-coordinator.js";
@@ -12,10 +13,10 @@ import { defineTaskContract } from "./task-contract-definition.js";
 import { ModelTaskContractPlanner, parseTaskContractResponse } from "./task-contract-planner.js";
 import { assembleTaskContext, buildTaskExecutionDirective, getTaskContextManifest, getTaskExecutionBrief } from "./task-context-assembler.js";
 import { TaskRunCoordinator } from "./task-run-coordinator.js";
-import { ProjectMonitoringService, decideProactiveDisposition } from "./project-monitoring-service.js";
-import { ProjectOperatingViewService, projectTaskLane } from "./project-operating-view-service.js";
+import { ProjectMonitoringService, decideProactiveDisposition, isInQuietHours, nextQuietHoursEnd, proactiveDispositionReason } from "./project-monitoring-service.js";
+import { ProjectOperatingViewService, summarizeProjectOperatingView } from "./project-operating-view-service.js";
 import { TaskValueMetricsService } from "./task-value-metrics-service.js";
 import { TaskOutboxDispatcher } from "./task-outbox-dispatcher.js";
 import { TaskRunDispatcher } from "./task-run-dispatcher.js";
 import { TaskSignalService } from "./task-signal-service.js";
-export { AttentionGovernor, HomeQueryService, ModelTaskContractPlanner, ProjectMonitoringService, ProjectOperatingViewService, TaskApplicationService, TaskContextRepository, TaskDependencyError, TaskDependencyService, TaskOutboxDispatcher, TaskReadModelProjector, TaskRepository, TaskRunCoordinator, TaskRunDispatcher, TaskRunRepository, TaskSignalService, TaskValueMetricsService, TaskWorkflowCoordinator, assembleTaskContext, buildHomeBriefing, buildTaskExecutionDirective, decideProactiveDisposition, decisionFromTask, defineTaskContract, getTaskContextManifest, getTaskExecutionBrief, parseTaskContractResponse, projectTaskLane, resolveExecutionContext };
+export { AttentionGovernor, HomeQueryService, ModelTaskContractPlanner, ProjectMonitoringService, ProjectOperatingViewService, TaskApplicationService, TaskContextRepository, TaskDependencyError, TaskDependencyService, TaskOutboxDispatcher, TaskReadModelProjector, TaskRepository, TaskRunCoordinator, TaskRunDispatcher, TaskRunRepository, TaskSignalService, TaskValueMetricsService, TaskWorkflowCoordinator, assembleTaskContext, buildHomeBriefing, buildHomeFocusItems, buildTaskExecutionDirective, decideProactiveDisposition, decisionFromTask, defineTaskContract, enqueueTaskChanged, enqueueTaskChangedEvent, getTaskContextManifest, getTaskExecutionBrief, isInQuietHours, nextQuietHoursEnd, parseTaskContractResponse, proactiveDispositionReason, resolveExecutionContext, summarizeProjectOperatingView };

package/dist/src/tasks/project-monitoring-service.d.ts

@@ -7,6 +7,15 @@ export declare function decideProactiveDisposition(policy: ProjectMonitoringPoli
     actionId?: string;
     requiresApproval?: boolean;
 }): ProactiveDisposition;
+export declare function proactiveDispositionReason(policy: ProjectMonitoringPolicy, input: {
+    confidence: number;
+    valueScore: number;
+    risk: 'low' | 'medium' | 'high';
+    actionId?: string;
+    requiresApproval?: boolean;
+}, disposition: ProactiveDisposition): string;
+export declare function isInQuietHours(quietHours: QuietHours | undefined, now?: Date): boolean;
+export declare function nextQuietHoursEnd(quietHours: QuietHours | undefined, now?: Date): Date | undefined;
 export declare class ProjectMonitoringService {
     #private;
     get(projectId: string): ProjectMonitoringPolicy;

package/dist/src/tasks/project-monitoring-service.js

@@ -2,6 +2,7 @@ import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/
 import { ProactiveScenarioService } from "../proactive/scenarios/service.js";
 //#region src/tasks/project-monitoring-service.ts
 const DEFAULT_SCENARIOS = ["project_delivery_risk", "blocked_work"];
+const SUPPORTED_ACTIONS = new Set(["create_project_task"]);
 function validHour(value) {
 	return Number.isInteger(value) && value >= 0 && value <= 23;
 }
@@ -19,10 +20,45 @@ function rowToPolicy(row, scenarios) {
 }
 function decideProactiveDisposition(policy, input) {
 	if (policy.mode === "observe" || input.confidence < policy.confidenceThreshold || input.valueScore < .5) return "record_silently";
-	if (input.requiresApproval || input.risk !== "low") return "request_approval";
-	if (policy.mode === "auto_low_risk" && input.actionId && policy.allowedActions.includes(input.actionId)) return "auto_execute";
+	if (input.actionId) {
+		if (input.requiresApproval || input.risk !== "low" || policy.mode === "ask_before_action") return "request_approval";
+		if (policy.mode === "auto_low_risk" && policy.allowedActions.includes(input.actionId)) return "auto_execute";
+		return "show_in_work";
+	}
+	if (input.requiresApproval) return "request_approval";
 	return "show_in_work";
 }
+function proactiveDispositionReason(policy, input, disposition) {
+	if (policy.mode === "observe") return "Project monitoring is observe-only";
+	if (input.confidence < policy.confidenceThreshold) return `Confidence ${input.confidence} is below threshold ${policy.confidenceThreshold}`;
+	if (input.valueScore < .5) return `Value score ${input.valueScore} is below 0.5`;
+	if (disposition === "request_approval") return input.risk === "low" ? "Project policy requires approval before acting" : `${input.risk} risk requires approval`;
+	if (disposition === "auto_execute") return `Low-risk action ${input.actionId} is explicitly allowed`;
+	if (input.actionId && !policy.allowedActions.includes(input.actionId)) return `Action ${input.actionId} is not in the project allowlist`;
+	return "Insight passed the project confidence and value gates";
+}
+function hourInTimezone(now, timezone) {
+	const hour = new Intl.DateTimeFormat("en-US", {
+		timeZone: timezone,
+		hour: "2-digit",
+		hourCycle: "h23"
+	}).formatToParts(now).find((part) => part.type === "hour")?.value;
+	return Number(hour);
+}
+function isInQuietHours(quietHours, now = /* @__PURE__ */ new Date()) {
+	if (!quietHours || quietHours.startHour === quietHours.endHour) return false;
+	const hour = hourInTimezone(now, quietHours.timezone);
+	return quietHours.startHour < quietHours.endHour ? hour >= quietHours.startHour && hour < quietHours.endHour : hour >= quietHours.startHour || hour < quietHours.endHour;
+}
+function nextQuietHoursEnd(quietHours, now = /* @__PURE__ */ new Date()) {
+	if (!isInQuietHours(quietHours, now)) return void 0;
+	const minute = new Date(now);
+	minute.setUTCSeconds(0, 0);
+	for (let offset = 1; offset <= 2880; offset += 1) {
+		const candidate = new Date(minute.getTime() + offset * 6e4);
+		if (!isInQuietHours(quietHours, candidate)) return candidate;
+	}
+}
 var ProjectMonitoringService = class {
 	#scenarios = new ProactiveScenarioService();
 	get(projectId) {
@@ -40,9 +76,11 @@ var ProjectMonitoringService = class {
 	configure(input) {
 		if (!getSqliteDatabase().prepare("SELECT 1 FROM projects WHERE project_id = ?").get(input.projectId)) throw new Error("Project not found");
 		if (input.quietHours && (!validHour(input.quietHours.startHour) || !validHour(input.quietHours.endHour) || !input.quietHours.timezone.trim())) throw new Error("Quiet hours need a timezone and integer hours from 0 through 23");
+		if (input.quietHours) hourInTimezone(/* @__PURE__ */ new Date(), input.quietHours.timezone);
 		const threshold = input.confidenceThreshold ?? .75;
 		if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) throw new Error("confidenceThreshold must be between 0 and 1");
 		const allowedActions = [...new Set(input.allowedActions ?? [])].map((action) => action.trim()).filter(Boolean);
+		if (allowedActions.some((action) => !SUPPORTED_ACTIONS.has(action))) throw new Error("Unknown proactive action");
 		const scenarios = [...new Set(input.scenarios ?? DEFAULT_SCENARIOS)];
 		const availableScenarios = new Set(this.#scenarios.list().map((scenario) => scenario.key));
 		if (scenarios.some((scenario) => !availableScenarios.has(scenario))) throw new Error("Unknown proactive scenario");
@@ -73,4 +111,4 @@ var ProjectMonitoringService = class {
 	}
 };
 //#endregion
-export { ProjectMonitoringService, decideProactiveDisposition };
+export { ProjectMonitoringService, decideProactiveDisposition, isInQuietHours, nextQuietHoursEnd, proactiveDispositionReason };

package/dist/src/tasks/project-operating-view-service.d.ts

@@ -1,6 +1,6 @@
-import type { ProjectOperatingView, ProjectTaskCard } from '@xopcai/gateway-contract';
+import type { ProjectOperatingSummary, ProjectOperatingView } from '@xopcai/gateway-contract';
 import type { ProjectService } from '../projects/index.js';
-export declare function projectTaskLane(card: Pick<ProjectTaskCard, 'phase' | 'operationalState' | 'attention'>): ProjectTaskCard['lane'];
+export declare function summarizeProjectOperatingView(view: ProjectOperatingView): ProjectOperatingSummary;
 export declare class ProjectOperatingViewService {
     #private;
     private readonly projects;

package/dist/src/tasks/project-operating-view-service.js

@@ -4,16 +4,33 @@ import { TaskReadModelProjector } from "./task-read-model-projector.js";
 import { TaskDependencyService } from "./task-dependency-service.js";
 import { ProjectMonitoringService } from "./project-monitoring-service.js";
 //#region src/tasks/project-operating-view-service.ts
-function projectTaskLane(card) {
-	if (card.phase === "closed") return "done";
-	if (card.attention.some((item) => item.kind === "input_required" || item.kind === "approval_required")) return "needs_user";
-	if ([
-		"queued",
-		"running",
-		"verifying"
-	].includes(card.operationalState)) return "moving";
-	if (card.operationalState === "waiting" || card.operationalState === "blocked") return "waiting";
-	return "ready";
+function summarizeProjectOperatingView(view) {
+	const counts = {
+		ready: 0,
+		moving: 0,
+		waiting: 0,
+		needsUser: 0,
+		done: 0
+	};
+	for (const task of view.tasks) {
+		if (task.attention.some((item) => item.kind === "input_required" || item.kind === "approval_required")) {
+			counts.needsUser += 1;
+			continue;
+		}
+		if (task.phase === "closed") counts.done += 1;
+		else if ([
+			"queued",
+			"running",
+			"verifying"
+		].includes(task.operationalState)) counts.moving += 1;
+		else if (task.operationalState === "waiting" || task.operationalState === "blocked") counts.waiting += 1;
+		else counts.ready += 1;
+	}
+	return {
+		...view.digest,
+		counts,
+		updatedAt: Math.max(view.project.updatedAt, ...view.tasks.map((task) => task.updatedAt))
+	};
 }
 var ProjectOperatingViewService = class {
 	#tasks = new TaskRepository();
@@ -32,7 +49,7 @@ var ProjectOperatingViewService = class {
 			const model = this.#projector.project(task);
 			const latest = this.#runs.getLatestRoot(task.id);
 			const receipt = latest ? this.#runs.getReceipt(latest.id) : void 0;
-			const base = {
+			return {
 				id: task.id,
 				title: task.title,
 				phase: task.phase,
@@ -47,33 +64,42 @@ var ProjectOperatingViewService = class {
 				...receipt ? { latestVerification: receipt.verification.status } : {},
 				updatedAt: task.updatedAt
 			};
-			return {
-				...base,
-				lane: projectTaskLane(base)
-			};
 		});
-		const recentReceipts = projectTasks.flatMap((task) => this.#runs.listReceipts(task.id, 10)).sort((a, b) => b.finalizedAt - a.finalizedAt).slice(0, 10);
-		const attentionCount = cards.filter((card) => card.lane === "needs_user").length;
+		const recentResults = projectTasks.flatMap((task) => this.#runs.listReceipts(task.id, 10).map((receipt) => ({
+			taskId: task.id,
+			taskTitle: task.title,
+			receipt
+		}))).sort((a, b) => b.receipt.finalizedAt - a.receipt.finalizedAt).slice(0, 10);
+		const needsUser = (card) => card.attention.some((item) => item.kind === "input_required" || item.kind === "approval_required");
+		const moving = (card) => [
+			"queued",
+			"running",
+			"verifying"
+		].includes(card.operationalState);
+		const attentionCount = cards.filter((card) => card.attention.length > 0).length;
 		return {
 			project,
-			tasks: cards.sort((a, b) => b.updatedAt - a.updatedAt),
+			tasks: cards,
 			dependencyEdges: this.#dependencies.listProjectEdges(project.id),
 			blockers: cards.flatMap((card) => card.attention.map((item) => ({
 				id: item.sourceId ?? `${card.id}:${item.kind}`,
+				taskId: card.id,
 				kind: item.kind,
 				title: card.title,
 				detail: item.summary,
+				href: `/tasks/${encodeURIComponent(card.id)}`,
 				updatedAt: card.updatedAt
 			}))),
 			running: project.recentWorkflowRuns.filter((run) => run.status === "queued" || run.status === "running"),
-			recentReceipts,
+			recentResults,
 			digest: {
 				health: cards.length === 0 ? "empty" : attentionCount > 0 ? "attention" : "healthy",
-				summary: cards.length === 0 ? "No tasks yet" : `${cards.filter((card) => card.lane === "moving").length} moving, ${attentionCount} need attention`
+				summary: cards.length === 0 ? "No tasks yet" : `${cards.filter(moving).length} moving, ${attentionCount} need attention`,
+				recommendedAction: cards.find(needsUser)?.attention[0]?.summary ?? cards.find((card) => card.attention.length > 0)?.attention[0]?.summary ?? cards.find(moving)?.title ?? cards.find((card) => card.phase === "ready")?.title ?? cards.find((card) => card.phase === "backlog")?.title
 			},
 			monitoring: this.#monitoring.get(project.id)
 		};
 	}
 };
 //#endregion
-export { ProjectOperatingViewService, projectTaskLane };
+export { ProjectOperatingViewService, summarizeProjectOperatingView };