@xopcai/xopc 0.0.178 → 0.0.180

package/dist/src/tui/tui-oauth-login.js

@@ -169,13 +169,7 @@ async function runTuiOAuthLogin(provider, deps) {
 			deps,
 			activeCleanups
 		}));
-		await new CredentialResolver().saveOAuthToken(selectedProvider, {
-			access: config.provider.getApiKey(credentials),
-			refresh: credentials.refresh,
-			expiresAt: credentials.expires,
-			scope: Array.isArray(credentials.scope) ? credentials.scope.filter((value) => typeof value === "string") : void 0,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString()
-		});
+		await new CredentialResolver().saveOAuthCredentials(selectedProvider, credentials);
 		deps.chatLog.addSystem(`OAuth login completed for ${selectedProvider}.`);
 	} finally {
 		for (const cleanup of [...activeCleanups]) cleanup();

package/dist/src/tui/tui-picker-overlay.js

@@ -611,6 +611,7 @@ function openProjectTrustOverlay(svc) {
 			trustStore.setMany(selected.updates);
 			svc.setProjectTrustSessionDecision(null);
 		} else svc.setProjectTrustSessionDecision(selected.trusted);
+		svc.onProjectTrustChanged();
 		svc.closeOverlay();
 		svc.tui.setFocus(svc.editor);
 		const scope = selected.savedPath ? `saved for ${selected.savedPath}` : "this session only";

package/dist/src/tui/tui-picker-services.d.ts

@@ -50,5 +50,6 @@ export type PickerServices = {
     getProjectTrustStore: () => ProjectTrustStore;
     getProjectTrustSessionDecision: () => boolean | null;
     setProjectTrustSessionDecision: (decision: boolean | null) => void;
+    onProjectTrustChanged: () => void;
     keybindings: KeybindingsManager;
 };

package/dist/src/tui/tui-skills-autocomplete.d.ts

@@ -1,8 +1,12 @@
 import type { TuiAutocompleteProvider } from '../extensions/types/tui.js';
 /** `@skill` autocomplete from workspace + global + bundled skill directories. */
-export declare function createSkillsAutocompleteProvider(): TuiAutocompleteProvider;
+export declare function createSkillsAutocompleteProvider(options?: {
+    isWorkspaceTrusted?: (workspaceDir: string) => boolean;
+}): TuiAutocompleteProvider;
 /** Test helper — build skill list without caching. */
-export declare function listSkillAutocompleteSuggestions(): Array<{
+export declare function listSkillAutocompleteSuggestions(options?: {
+    isWorkspaceTrusted?: (workspaceDir: string) => boolean;
+}): Array<{
     name: string;
     description?: string;
 }>;

package/dist/src/tui/tui-skills-autocomplete.js

@@ -7,13 +7,15 @@ import "../config/index.js";
 //#region src/tui/tui-skills-autocomplete.ts
 init_paths();
 /** `@skill` autocomplete from workspace + global + bundled skill directories. */
-function createSkillsAutocompleteProvider() {
+function createSkillsAutocompleteProvider(options = {}) {
 	let cached = null;
 	const refresh = () => {
+		const workspaceDir = getWorkspacePath(loadConfig());
 		cached = loadSkills({
-			workspaceDir: getWorkspacePath(loadConfig()),
+			workspaceDir,
 			builtinDir: resolveBundledSkillsDir(),
-			globalDir: resolveStateDir()
+			globalDir: resolveStateDir(),
+			workspaceTrust: options.isWorkspaceTrusted?.(workspaceDir) === true ? "trusted" : "untrusted"
 		}).skills.map((skill) => ({
 			name: skill.name,
 			description: skill.description ? `skill · ${skill.description.slice(0, 112)}` : "skill"
@@ -27,11 +29,13 @@ function createSkillsAutocompleteProvider() {
 	};
 }
 /** Test helper — build skill list without caching. */
-function listSkillAutocompleteSuggestions() {
+function listSkillAutocompleteSuggestions(options = {}) {
+	const workspaceDir = getWorkspacePath(loadConfig());
 	return loadSkills({
-		workspaceDir: getWorkspacePath(loadConfig()),
+		workspaceDir,
 		builtinDir: resolveBundledSkillsDir(),
-		globalDir: resolveStateDir()
+		globalDir: resolveStateDir(),
+		workspaceTrust: options.isWorkspaceTrusted?.(workspaceDir) === true ? "trusted" : "untrusted"
 	}).skills.map((s) => ({
 		name: s.name,
 		description: s.description

package/dist/src/tui/tui-startup-resources.d.ts

@@ -1,3 +1,5 @@
 import type { Config } from '../config/schema.js';
 import type { TuiStartupResources } from './tui-backend.js';
-export declare function collectTuiStartupResources(config: Config, sessionKey?: string): TuiStartupResources;
+export declare function collectTuiStartupResources(config: Config, sessionKey?: string, options?: {
+    isWorkspaceTrusted?: (workspaceDir: string) => boolean;
+}): TuiStartupResources;

package/dist/src/tui/tui-startup-resources.js

@@ -1,6 +1,6 @@
 import { resolveStateDir } from "../config/paths-state.js";
-import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { init_paths, resolveAgentProfileDir, resolveBundledSkillsDir, resolveUserProfilePath } from "../config/paths.js";
+import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { resolveBootstrapFilesSync } from "../agent/bootstrap/bootstrap-files.js";
 import { createSkillConfigManager, isSkillEnabled } from "../agent/skills/config.js";
 import { loadSkills } from "../agent/skills/index.js";
@@ -14,7 +14,7 @@ init_paths();
 function uniqueSorted(values) {
 	return [...new Set([...values].map((value) => value.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
 }
-function collectTuiStartupResources(config, sessionKey) {
+function collectTuiStartupResources(config, sessionKey, options = {}) {
 	const profile = resolveEffectiveAgentProfileForSession(config, sessionKey);
 	const profileDir = resolveAgentProfileDir(config, profile.agentId);
 	const workspaceDir = profile.resolvedWorkspacePath || getWorkspacePath(config);
@@ -28,7 +28,8 @@ function collectTuiStartupResources(config, sessionKey) {
 		context,
 		skills: uniqueSorted(loadSkills({
 			workspaceDir,
-			builtinDir: resolveBundledSkillsDir() ?? void 0
+			builtinDir: resolveBundledSkillsDir() ?? void 0,
+			workspaceTrust: options.isWorkspaceTrusted?.(workspaceDir) === true ? "trusted" : "untrusted"
 		}).skills.filter((skill) => !skill.disableModelInvocation && isSkillEnabled(skill, skillsConfig)).map((skill) => skill.name)),
 		workflows: uniqueSorted(createWorkflowCatalog().list().map((entry) => entry.name)),
 		connectors: uniqueSorted(listConnectorInstances(config).map((instance) => instance.displayName || instance.connectorId || instance.instanceId))

package/dist/src/tui/tui.js

@@ -2,10 +2,10 @@ import { version } from "../../package.js";
 import { resolveStateDir, resolveXopcDatabasePath } from "../config/paths-state.js";
 import { parseAgentSessionKey } from "../routing/session-key-utils.js";
 import { init_agent_session_key, normalizeAgentId } from "../routing/agent-session-key.js";
-import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { init_paths } from "../config/paths.js";
 import { loadConfig } from "../config/loader.js";
 import { getAllModels, getAllProviders, getApiKey, init_providers, isProviderConfiguredSync } from "../providers/index.js";
+import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { renderWorkflowFinalSummary, renderWorkflowPanel } from "../agent/workflow/snapshot.js";
 import { runViewToSnapshot } from "../workflows/service/run-view-to-snapshot.js";
 import { ProjectTrustStore, hasTrustRequiringProjectResources } from "../project-trust/trust-store.js";
@@ -1936,6 +1936,9 @@ async function runTui(opts) {
 		setProjectTrustSessionDecision: (decision) => {
 			projectTrustSessionDecision = decision;
 		},
+		onProjectTrustChanged: () => {
+			client.refreshWorkspaceTrust?.();
+		},
 		keybindings
 	};
 	uiOverlays.openModelPicker = (initialSearch) => void openModelPickerOverlay(pickerSvc, initialSearch);

package/dist/src/tunnel/frpc-binary.js

@@ -6,8 +6,8 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { chmodSync, createWriteStream, existsSync, mkdirSync, rmSync } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
 //#region src/tunnel/frpc-binary.ts
 init_paths();
 init_logger();

package/dist/src/tunnel/frpc-extract.js

@@ -3,8 +3,8 @@ import { init_logger } from "../utils/logger.js";
 import { dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { spawn } from "node:child_process";
-import AdmZip from "adm-zip";
 import { gunzipSync } from "node:zlib";
+import AdmZip from "adm-zip";
 //#region src/tunnel/frpc-extract.ts
 init_logger();
 const log = createLogger("TunnelFrpcExtract");

package/dist/src/tunnel/index.js

@@ -1,8 +1,9 @@
 import { loadTunnelState, resolveTunnelStatePath, saveTunnelState } from "./tunnel-state.js";
 import { buildMobileConnectQrPayload, resolveLanGatewayUrl } from "./tunnel-qr.js";
 import { CURRENT_TUNNEL_CONSENT_VERSION, TUNNEL_CONSENT_REQUIRED_CODE, TUNNEL_RISK_SUMMARY_LINES, TunnelConsentError, assertTunnelMayStart, getTunnelConsentState, hasValidTunnelConsent } from "./consent.js";
-import { getTunnelRegistrationSecretMeta, isMaskedTunnelSecretPatchValue, isProductionTunnelBroker, resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret } from "./env.js";
 import { TunnelBrokerClient, resolveBrokerApiBase } from "./broker-client.js";
+import { getTunnelRegistrationSecretMeta, isMaskedTunnelSecretPatchValue, isProductionTunnelBroker, resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret } from "./env.js";
+import { applyTunnelConsentToConfig, mergeTunnelConfigPatch, sanitizeTunnelConfig, setTunnelEnabledInConfig } from "./tunnel-config.js";
 import { FRPC_VERSION, clearFrpcPathForProcess, ensureFrpcBinary, publishFrpcPathForProcess } from "./frpc-binary.js";
 import { consumePairingSecret, createPairingSecret, resetPairingSessionsForTests } from "./pairing.js";
 import { logTunnelAudit } from "./tunnel-audit.js";
@@ -10,6 +11,5 @@ import { TunnelService, getTunnelService, hashGatewayToken } from "./tunnel-serv
 import { resolveFrpSubdomainHost } from "./frp-subdomain-host.js";
 import { clearTunnelWellKnownCache, fetchTunnelWellKnown } from "./well-known.js";
 import { configureTunnelFromGatewayConfig, maybeAutoStartTunnelFromConfig, wireTunnelEventsToGateway } from "./gateway-lifecycle.js";
-import { applyTunnelConsentToConfig, mergeTunnelConfigPatch, sanitizeTunnelConfig, setTunnelEnabledInConfig } from "./tunnel-config.js";
 import { consumeTunnelMutationLimit, resetTunnelMutationLimitsForTests } from "./tunnel-rate-limit.js";
 export { CURRENT_TUNNEL_CONSENT_VERSION, FRPC_VERSION, TUNNEL_CONSENT_REQUIRED_CODE, TUNNEL_RISK_SUMMARY_LINES, TunnelBrokerClient, TunnelConsentError, TunnelService, applyTunnelConsentToConfig, assertTunnelMayStart, buildMobileConnectQrPayload, clearFrpcPathForProcess, clearTunnelWellKnownCache, configureTunnelFromGatewayConfig, consumePairingSecret, consumeTunnelMutationLimit, createPairingSecret, ensureFrpcBinary, fetchTunnelWellKnown, getTunnelConsentState, getTunnelRegistrationSecretMeta, getTunnelService, hasValidTunnelConsent, hashGatewayToken, isMaskedTunnelSecretPatchValue, isProductionTunnelBroker, loadTunnelState, logTunnelAudit, maybeAutoStartTunnelFromConfig, mergeTunnelConfigPatch, publishFrpcPathForProcess, resetPairingSessionsForTests, resetTunnelMutationLimitsForTests, resolveBrokerApiBase, resolveFrpSubdomainHost, resolveLanGatewayUrl, resolveTunnelBrokerUrl, resolveTunnelRegistrationSecret, resolveTunnelStatePath, sanitizeTunnelConfig, saveTunnelState, setTunnelEnabledInConfig, wireTunnelEventsToGateway };

package/dist/src/user-context/context-compiler.d.ts

@@ -0,0 +1,31 @@
+import type { UserContextPlan } from '../agent/memory/context/types.js';
+import { type RelationshipSettings } from '../storage/sqlite/index.js';
+export interface ContextSnapshot {
+    id: string;
+    traceId: string;
+    sessionKey: string;
+    query: string;
+    selectedItems: UserContextPlan['items'];
+    rejectedItems: UserContextPlan['rejected'];
+    consentRequests: UserContextPlan['consentRequests'];
+    relationshipPolicy: RelationshipSettings;
+    estimatedTokens: number;
+    outcomeId?: string;
+    runId?: string;
+    createdAt: number;
+}
+export declare class ContextCompiler {
+    capture(input: {
+        sessionKey: string;
+        query: string;
+        plan: UserContextPlan;
+        now?: number;
+    }): ContextSnapshot;
+    get(id: string): ContextSnapshot | undefined;
+    latestForSession(sessionKey: string, since?: number): ContextSnapshot | undefined;
+    linkToRun(input: {
+        snapshotId: string;
+        outcomeId?: string;
+        runId: string;
+    }): ContextSnapshot | undefined;
+}

package/dist/src/user-context/context-compiler.js

@@ -0,0 +1,51 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { getRelationshipSettings } from "../storage/sqlite/relationship-settings-repository.js";
+import "../storage/sqlite/index.js";
+import { randomUUID } from "node:crypto";
+//#region src/user-context/context-compiler.ts
+function fromRow(row) {
+	return {
+		id: row.snapshot_id,
+		traceId: row.trace_id,
+		sessionKey: row.session_key,
+		query: row.query,
+		selectedItems: JSON.parse(row.selected_items_json),
+		rejectedItems: JSON.parse(row.rejected_items_json),
+		consentRequests: JSON.parse(row.consent_requests_json),
+		relationshipPolicy: JSON.parse(row.relationship_policy_json),
+		estimatedTokens: row.estimated_tokens,
+		...row.outcome_id ? { outcomeId: row.outcome_id } : {},
+		...row.run_id ? { runId: row.run_id } : {},
+		createdAt: row.created_at
+	};
+}
+var ContextCompiler = class {
+	capture(input) {
+		const now = input.now ?? Date.now();
+		const id = randomUUID();
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`INSERT INTO context_snapshots (
+          snapshot_id, trace_id, session_key, query, selected_items_json,
+          rejected_items_json, consent_requests_json, relationship_policy_json,
+          estimated_tokens, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, input.plan.traceId, input.sessionKey, input.query.trim(), JSON.stringify(input.plan.items), JSON.stringify(input.plan.rejected), JSON.stringify(input.plan.consentRequests), JSON.stringify(getRelationshipSettings()), input.plan.estimatedTokens, now);
+		});
+		return this.get(id);
+	}
+	get(id) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM context_snapshots WHERE snapshot_id = ?").get(id);
+		return row ? fromRow(row) : void 0;
+	}
+	latestForSession(sessionKey, since = 0) {
+		const row = getSqliteDatabase().prepare(`SELECT * FROM context_snapshots
+       WHERE session_key = ? AND created_at >= ?
+       ORDER BY created_at DESC LIMIT 1`).get(sessionKey, since);
+		return row ? fromRow(row) : void 0;
+	}
+	linkToRun(input) {
+		getSqliteDatabase().prepare(`UPDATE context_snapshots SET outcome_id = ?, run_id = ? WHERE snapshot_id = ?`).run(input.outcomeId ?? null, input.runId, input.snapshotId);
+		return this.get(input.snapshotId);
+	}
+};
+//#endregion
+export { ContextCompiler };

package/dist/src/voice/local/model-files.js

@@ -2,8 +2,8 @@ import { dirname, join } from "node:path";
 import { createReadStream, createWriteStream } from "node:fs";
 import { createHash } from "node:crypto";
 import { mkdir, rm, stat } from "node:fs/promises";
-import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
 //#region src/voice/local/model-files.ts
 function resolveModelFileUrl(remoteHost, model, file) {
 	const base = remoteHost.endsWith("/") ? remoteHost : `${remoteHost}/`;

package/dist/src/voice/stt/config.d.ts

@@ -0,0 +1,4 @@
+import type { STTConfig } from './types.js';
+export declare function mergeSttConfigFromAppConfig(stt: Partial<STTConfig> | undefined, toolsMedia?: {
+    models?: STTConfig['sharedModels'];
+}): STTConfig;

package/dist/src/voice/stt/config.js

@@ -0,0 +1,26 @@
+import { DEFAULT_STT_CONFIG } from "./types.js";
+//#region src/voice/stt/config.ts
+function mergeSttProviders(base, patch) {
+	if (!base && !patch) return void 0;
+	const merged = { ...base ?? {} };
+	for (const [id, slice] of Object.entries(patch ?? {})) merged[id] = {
+		...merged[id] ?? {},
+		...slice
+	};
+	return merged;
+}
+function mergeSttConfigFromAppConfig(stt, toolsMedia) {
+	const patch = stt ?? {};
+	return {
+		...DEFAULT_STT_CONFIG,
+		...patch,
+		providers: mergeSttProviders(DEFAULT_STT_CONFIG.providers, patch.providers),
+		fallback: {
+			...DEFAULT_STT_CONFIG.fallback,
+			...patch.fallback
+		},
+		...toolsMedia?.models?.length ? { sharedModels: toolsMedia.models } : {}
+	};
+}
+//#endregion
+export { mergeSttConfigFromAppConfig };

package/dist/src/voice/stt/index.d.ts

@@ -9,6 +9,7 @@ import './providers/index.js';
 import type { STTConfig, STTOptions, STTResult } from './types.js';
 export { transcribe } from './transcribe-core.js';
 export { isSTTAvailable } from './availability.js';
+export { mergeSttConfigFromAppConfig } from './config.js';
 /**
  * Single-provider transcription helper. Used by chat-commands /stt so a user
  * can force a specific provider regardless of fallback config.

package/dist/src/voice/stt/index.js

@@ -4,6 +4,7 @@ import "./providers/index.js";
 import { resolveSTTProviderChain, resolveSTTProviderConfig, resolveSTTProviderOrder } from "./factory.js";
 import { transcribe } from "./transcribe-core.js";
 import { isSTTAvailable } from "./availability.js";
+import { mergeSttConfigFromAppConfig } from "./config.js";
 import { checkMentionInTranscription } from "./mention.js";
 import { audioPreflightTranscribe } from "./preflight.js";
 //#region src/voice/stt/index.ts
@@ -28,4 +29,4 @@ async function transcribeWithProvider(audioBuffer, providerName, config, options
 	};
 }
 //#endregion
-export { alibabaTranscriptionProvider, audioPreflightTranscribe, checkMentionInTranscription, isSTTAvailable, openAiTranscriptionProvider, resolveSTTProviderChain, resolveSTTProviderConfig, resolveSTTProviderOrder, transcribe, transcribeWithProvider };
+export { alibabaTranscriptionProvider, audioPreflightTranscribe, checkMentionInTranscription, isSTTAvailable, mergeSttConfigFromAppConfig, openAiTranscriptionProvider, resolveSTTProviderChain, resolveSTTProviderConfig, resolveSTTProviderOrder, transcribe, transcribeWithProvider };

package/dist/src/voice/stt/list-providers.js

@@ -1,6 +1,6 @@
 import { listMediaUnderstandingProviders } from "../../media-understanding/registry.js";
 import { resolveSTTProviderConfig } from "./factory.js";
-import { mergeSttConfigFromAppConfig } from "../../channels/attachments/voice-stt-webchat.js";
+import { mergeSttConfigFromAppConfig } from "./config.js";
 import { getVoiceProviderMetadata } from "../metadata/registry.js";
 import "../metadata/index.js";
 //#region src/voice/stt/list-providers.ts

package/dist/src/work/attention-governor.d.ts

@@ -0,0 +1,20 @@
+import type { WorkHomeAttention, WorkHomeDecision } from '@xopcai/gateway-contract';
+export interface AttentionProjection {
+    decisions: WorkHomeDecision[];
+    attention: WorkHomeAttention[];
+    policy: {
+        visibleDecisionCount: number;
+        suppressedDecisionCount: number;
+        visibleAttentionCount: number;
+        suppressedAttentionCount: number;
+    };
+}
+export declare class AttentionGovernor {
+    project(input: {
+        decisions: WorkHomeDecision[];
+        attention: WorkHomeAttention[];
+        proactiveEnabled: boolean;
+        maxDecisions?: number;
+        maxAttention?: number;
+    }): AttentionProjection;
+}

package/dist/src/work/attention-governor.js

@@ -0,0 +1,46 @@
+//#region src/work/attention-governor.ts
+function decisionScore(item) {
+	if (item.reason === "approval_required") return 100;
+	if (item.reason === "needs_input") return 95;
+	if (item.reason === "blocked") return 85;
+	if (item.reason === "in_review") return 80;
+	if (item.kind === "agent_judgment") return Math.round((item.judgment?.valueScore ?? 0) * 70) + (item.urgency === "now" ? 20 : 0);
+	if (item.reason === "overdue") return 70;
+	return 50;
+}
+function decisionKey(item) {
+	const title = item.title.trim().toLocaleLowerCase();
+	return item.response ? item.id : `${item.projectId ?? "global"}:${title}:${item.reason === "approval_required" ? item.id : ""}`;
+}
+function keepDecision(item, proactiveEnabled) {
+	if (item.kind !== "agent_judgment") return true;
+	if (!proactiveEnabled) return false;
+	return (item.judgment?.confidence ?? 0) >= .65 && (item.judgment?.valueScore ?? 0) >= .6;
+}
+var AttentionGovernor = class {
+	project(input) {
+		const maxDecisions = Math.max(1, Math.min(20, input.maxDecisions ?? 7));
+		const maxAttention = Math.max(1, Math.min(10, input.maxAttention ?? 5));
+		const seen = /* @__PURE__ */ new Set();
+		const eligible = [...input.decisions].filter((item) => keepDecision(item, input.proactiveEnabled)).sort((left, right) => decisionScore(right) - decisionScore(left) || right.updatedAt - left.updatedAt).filter((item) => {
+			const key = decisionKey(item);
+			if (seen.has(key)) return false;
+			seen.add(key);
+			return true;
+		});
+		const attention = [...input.attention].sort((left, right) => right.updatedAt - left.updatedAt).slice(0, maxAttention);
+		const decisions = eligible.slice(0, maxDecisions);
+		return {
+			decisions,
+			attention,
+			policy: {
+				visibleDecisionCount: decisions.length,
+				suppressedDecisionCount: Math.max(0, input.decisions.length - decisions.length),
+				visibleAttentionCount: attention.length,
+				suppressedAttentionCount: Math.max(0, input.attention.length - attention.length)
+			}
+		};
+	}
+};
+//#endregion
+export { AttentionGovernor };

package/dist/src/work/execution-context.d.ts

@@ -0,0 +1,16 @@
+import type { SessionMetadata } from '../session/types.js';
+import type { ExecutionReceiptContext } from '../storage/sqlite/execution-receipt-repository.js';
+export interface ExecutionContext extends ExecutionReceiptContext {
+    runId: string;
+    sessionKey: string;
+    channel: string;
+    agentId?: string;
+}
+export declare function resolveExecutionContext(input: {
+    runId: string;
+    sessionKey: string;
+    channel: string;
+    metadata: SessionMetadata;
+    agentId?: string;
+}): ExecutionContext;
+export declare function executionReceiptContext(context: ExecutionContext): ExecutionReceiptContext;

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,147 @@
+import type { WorkHomeResponse } from '@xopcai/gateway-contract';
+import { type AutomationRun } from '../automations/index.js';
+import type { AutomationService } from '../automations/service/automation-service.js';
+import type { Config } from '../config/schema.js';
+import { type GoalWithDetails } from '../goals/index.js';
+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 { WorkflowRunService } from '../workflows/service/workflow-run-service.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[];
+};
+interface WorkHomeGatewayPort {
+    readonly notesServiceInstance: NotesService;
+    readonly sessions: Pick<SessionIndex, 'listSessions'> & {
+        getActiveRun(sessionKey: string): {
+            active: boolean;
+            runId?: string;
+        };
+    };
+    readonly currentConfig: Config;
+    readonly automationServiceInstance: AutomationService;
+    readonly projects: ProjectService;
+    readonly proactiveInbox: ProactiveInboxService;
+    createWorkflowRunService(): WorkflowRunService;
+    getHealth(): {
+        status: string;
+        ready: boolean;
+        httpListening: boolean;
+        version: string;
+        uptime: number;
+    };
+}
+export declare function workItemAttentionRank(item: {
+    status: string;
+    dueAt?: number;
+    priority: string;
+    updatedAt: number;
+}, nowMs: number): number;
+export declare function decisionFromGoal(goal: GoalWithDetails, projectName?: string): HomeDecision | null;
+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: WorkHomeGatewayPort);
+    getSnapshot(locale?: string): Promise<HomeSnapshot>;
+}
+export {};