@xopcai/xopc 0.0.195 → 0.0.197

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/heartbeat/index.js

@@ -1,6 +1,6 @@
 import { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, shouldSilence, stripHeartbeatToken } from "./tokens.js";
-import { appendCronEventLines } from "./event-prompt.js";
 import { isWithinActiveHours } from "./active-hours.js";
 import { isHeartbeatContentEmpty } from "./content-check.js";
+import { appendCronEventLines } from "./event-prompt.js";
 import { createHeartbeatWake } from "./wake.js";
 export { DEFAULT_ACK_MAX_CHARS, HEARTBEAT_OK, NO_REPLY, appendCronEventLines, createHeartbeatWake, isHeartbeatContentEmpty, isWithinActiveHours, shouldSilence, stripHeartbeatToken };

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/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;
@@ -126,6 +139,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();
@@ -256,6 +523,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 +538,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 +584,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.js

@@ -3,7 +3,7 @@ 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 { TaskDependencyError, TaskDependencyService } from "./task-dependency-service.js";
 import { TaskApplicationService } from "./task-application-service.js";
@@ -13,9 +13,9 @@ import { ModelTaskContractPlanner, parseTaskContractResponse } from "./task-cont
 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 { ProjectOperatingViewService, projectTaskLane, 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, getTaskContextManifest, getTaskExecutionBrief, parseTaskContractResponse, projectTaskLane, resolveExecutionContext, summarizeProjectOperatingView };

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

@@ -1,6 +1,7 @@
-import type { ProjectOperatingView, ProjectTaskCard } from '@xopcai/gateway-contract';
+import type { ProjectOperatingSummary, ProjectOperatingView, ProjectTaskCard } 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;