@xopcai/xopc 0.0.178 → 0.0.179

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

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

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

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

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

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

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

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

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

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

package/dist/src/work/outcome-repository.d.ts

@@ -0,0 +1,50 @@
+import type { Outcome, OutcomeContract, OutcomeImportance, OutcomeInternalStatus, OutcomeUserStatus } from '@xopcai/gateway-contract';
+export type OutcomeSubjectKind = 'project' | 'goal' | 'work_item' | 'session' | 'workflow' | 'automation' | 'artifact' | 'source';
+export type OutcomeLinkInput = {
+    kind: OutcomeSubjectKind;
+    id: string;
+    relation?: string;
+};
+export declare class OutcomeRepository {
+    create(input: {
+        id?: string;
+        objective: string;
+        deliverables?: string[];
+        acceptanceCriteria?: string[];
+        constraints?: string[];
+        approvalRequired?: string[];
+        contextSnapshotId?: string;
+        createdBy?: 'user' | 'system';
+        importance?: OutcomeImportance;
+        dueAt?: number;
+        links?: OutcomeLinkInput[];
+        now?: number;
+    }): Outcome;
+    get(id: string): Outcome | undefined;
+    getBySubject(kind: OutcomeSubjectKind, subjectId: string): Outcome | undefined;
+    listLinks(outcomeId: string): OutcomeLinkInput[];
+    list(input?: {
+        status?: OutcomeUserStatus;
+        limit?: number;
+    }): Outcome[];
+    getContract(outcomeId: string, version?: number): OutcomeContract | undefined;
+    reviseContract(input: {
+        outcomeId: string;
+        objective: string;
+        deliverables: string[];
+        acceptanceCriteria: string[];
+        constraints: string[];
+        approvalRequired: string[];
+        contextSnapshotId?: string;
+        createdBy: 'user' | 'system';
+        now?: number;
+    }): Outcome;
+    updateState(input: {
+        id: string;
+        userStatus: OutcomeUserStatus;
+        internalStatus: OutcomeInternalStatus;
+        latestReceiptRunId?: string;
+        now?: number;
+    }): Outcome | undefined;
+    addLink(outcomeId: string, link: OutcomeLinkInput, now?: number): void;
+}

package/dist/src/work/outcome-repository.js

@@ -0,0 +1,112 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/work/outcome-repository.ts
+function contractFromRow(row) {
+	return {
+		outcomeId: row.outcome_id,
+		version: row.version,
+		objective: row.objective,
+		deliverables: JSON.parse(row.deliverables_json),
+		acceptanceCriteria: JSON.parse(row.acceptance_criteria_json),
+		constraints: JSON.parse(row.constraints_json),
+		approvalRequired: JSON.parse(row.approval_required_json),
+		...row.context_snapshot_id ? { contextSnapshotId: row.context_snapshot_id } : {},
+		createdBy: row.created_by,
+		createdAt: row.created_at
+	};
+}
+function outcomeFromRow(row, contract) {
+	return {
+		id: row.outcome_id,
+		objective: row.objective,
+		userStatus: row.user_status,
+		internalStatus: row.internal_status,
+		importance: row.importance,
+		...row.due_at === null ? {} : { dueAt: row.due_at },
+		latestContractVersion: row.latest_contract_version,
+		...row.latest_receipt_run_id ? { latestReceiptRunId: row.latest_receipt_run_id } : {},
+		...contract ? { contract } : {},
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+var OutcomeRepository = class {
+	create(input) {
+		const objective = input.objective.trim();
+		if (!objective) throw new Error("Outcome objective is required");
+		const id = input.id ?? randomUUID();
+		const now = input.now ?? Date.now();
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`INSERT INTO outcomes (
+          outcome_id, objective, user_status, internal_status, importance,
+          due_at, latest_contract_version, created_at, updated_at
+        ) VALUES (?, ?, 'running', 'captured', ?, ?, 1, ?, ?)`).run(id, objective, input.importance ?? "normal", input.dueAt ?? null, now, now);
+			db.prepare(`INSERT INTO outcome_contracts (
+          outcome_id, version, objective, deliverables_json, acceptance_criteria_json,
+          constraints_json, approval_required_json, context_snapshot_id, created_by, created_at
+        ) VALUES (?, 1, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, objective, JSON.stringify(input.deliverables ?? []), JSON.stringify(input.acceptanceCriteria ?? []), JSON.stringify(input.constraints ?? []), JSON.stringify(input.approvalRequired ?? []), input.contextSnapshotId ?? null, input.createdBy ?? "system", now);
+			for (const link of input.links ?? []) this.addLink(id, link, now);
+		});
+		return this.get(id);
+	}
+	get(id) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM outcomes WHERE outcome_id = ?").get(id);
+		if (!row) return void 0;
+		return outcomeFromRow(row, this.getContract(id, row.latest_contract_version));
+	}
+	getBySubject(kind, subjectId) {
+		const row = getSqliteDatabase().prepare(`SELECT outcomes.* FROM outcomes
+       JOIN outcome_links ON outcome_links.outcome_id = outcomes.outcome_id
+       WHERE outcome_links.subject_kind = ? AND outcome_links.subject_id = ?
+       ORDER BY outcomes.updated_at DESC LIMIT 1`).get(kind, subjectId);
+		return row ? outcomeFromRow(row, this.getContract(row.outcome_id, row.latest_contract_version)) : void 0;
+	}
+	listLinks(outcomeId) {
+		return getSqliteDatabase().prepare(`SELECT subject_kind, subject_id, relation FROM outcome_links
+       WHERE outcome_id = ? ORDER BY created_at ASC`).all(outcomeId).map((row) => ({
+			kind: row.subject_kind,
+			id: row.subject_id,
+			relation: row.relation
+		}));
+	}
+	list(input = {}) {
+		const limit = Math.max(1, Math.min(200, Math.floor(input.limit ?? 50)));
+		return (input.status ? getSqliteDatabase().prepare("SELECT * FROM outcomes WHERE user_status = ? ORDER BY updated_at DESC LIMIT ?").all(input.status, limit) : getSqliteDatabase().prepare("SELECT * FROM outcomes ORDER BY updated_at DESC LIMIT ?").all(limit)).map((row) => outcomeFromRow(row, this.getContract(row.outcome_id, row.latest_contract_version)));
+	}
+	getContract(outcomeId, version) {
+		const row = version === void 0 ? getSqliteDatabase().prepare("SELECT * FROM outcome_contracts WHERE outcome_id = ? ORDER BY version DESC LIMIT 1").get(outcomeId) : getSqliteDatabase().prepare("SELECT * FROM outcome_contracts WHERE outcome_id = ? AND version = ?").get(outcomeId, version);
+		return row ? contractFromRow(row) : void 0;
+	}
+	reviseContract(input) {
+		const current = this.get(input.outcomeId);
+		if (!current) throw new Error("Outcome not found");
+		const objective = input.objective.trim();
+		if (!objective) throw new Error("Outcome objective is required");
+		const version = current.latestContractVersion + 1;
+		const now = input.now ?? Date.now();
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`INSERT INTO outcome_contracts (
+          outcome_id, version, objective, deliverables_json, acceptance_criteria_json,
+          constraints_json, approval_required_json, context_snapshot_id, created_by, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.outcomeId, version, objective, JSON.stringify(input.deliverables), JSON.stringify(input.acceptanceCriteria), JSON.stringify(input.constraints), JSON.stringify(input.approvalRequired), input.contextSnapshotId ?? null, input.createdBy, now);
+			db.prepare(`UPDATE outcomes SET objective = ?, latest_contract_version = ?, updated_at = ?
+         WHERE outcome_id = ?`).run(objective, version, now, input.outcomeId);
+		});
+		return this.get(input.outcomeId);
+	}
+	updateState(input) {
+		const now = input.now ?? Date.now();
+		getSqliteDatabase().prepare(`UPDATE outcomes SET user_status = ?, internal_status = ?,
+       latest_receipt_run_id = COALESCE(?, latest_receipt_run_id), updated_at = ?
+       WHERE outcome_id = ?`).run(input.userStatus, input.internalStatus, input.latestReceiptRunId ?? null, now, input.id);
+		return this.get(input.id);
+	}
+	addLink(outcomeId, link, now = Date.now()) {
+		getSqliteDatabase().prepare(`INSERT INTO outcome_links (outcome_id, subject_kind, subject_id, relation, created_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(outcome_id, subject_kind, subject_id)
+       DO UPDATE SET relation = excluded.relation`).run(outcomeId, link.kind, link.id, link.relation ?? "supports", now);
+	}
+};
+//#endregion
+export { OutcomeRepository };

package/dist/src/work/outcome-run-coordinator.d.ts

@@ -0,0 +1,25 @@
+import { type ExecutionContract, type ExecutionEvidence, type ExecutionReceipt, type ExecutionReceiptStatus } from '../storage/sqlite/index.js';
+import type { ExecutionContext } from './execution-context.js';
+export declare class OutcomeRunCoordinator {
+    #private;
+    readonly runId: string;
+    readonly context: ExecutionContext;
+    readonly contract?: ExecutionContract;
+    private constructor();
+    static start(input: {
+        runId: string;
+        context: ExecutionContext;
+        fallbackObjective: string;
+    }): OutcomeRunCoordinator;
+    addEvidence(evidence: ExecutionEvidence): void;
+    capturePlan(items: Array<{
+        title: string;
+        status: string;
+    }>): void;
+    capturePatch(added: number, removed: number): void;
+    captureCommand(command: string, durationMs?: number): void;
+    finalize(input: {
+        status: Exclude<ExecutionReceiptStatus, 'running'>;
+        summary: string;
+    }): ExecutionReceipt | undefined;
+}

package/dist/src/work/outcome-run-coordinator.js

@@ -0,0 +1,117 @@
+import { completeExecutionReceipt, startExecutionReceipt, updateExecutionReceipt } from "../storage/sqlite/execution-receipt-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 { executionReceiptContext } from "./execution-context.js";
+import { OutcomeProjectionService } from "./outcome-projection-service.js";
+import { ContextCompiler } from "../user-context/context-compiler.js";
+//#region src/work/outcome-run-coordinator.ts
+var OutcomeRunCoordinator = class OutcomeRunCoordinator {
+	#evidence = [];
+	#goals = new GoalService();
+	#outcomes = new OutcomeRepository();
+	#projection = new OutcomeProjectionService();
+	#contextCompiler = new ContextCompiler();
+	#startedAt = Date.now();
+	contract;
+	constructor(runId, context, fallbackObjective) {
+		this.runId = runId;
+		this.context = context;
+		const outcome = context.outcomeId ? this.#outcomes.get(context.outcomeId) : void 0;
+		const contract = outcome?.contract;
+		this.contract = contract ? {
+			objective: contract.objective,
+			deliverables: contract.deliverables,
+			acceptanceCriteria: contract.acceptanceCriteria,
+			constraints: contract.constraints,
+			approvalRequired: contract.approvalRequired
+		} : void 0;
+		startExecutionReceipt({
+			runId,
+			sessionKey: context.sessionKey,
+			channel: context.channel,
+			objective: outcome?.objective ?? contract?.objective ?? fallbackObjective.trim(),
+			context: executionReceiptContext(context),
+			...this.contract ? { contract: this.contract } : {},
+			...contract ? { contractVersion: contract.version } : {}
+		});
+		if (outcome) this.#outcomes.updateState({
+			id: outcome.id,
+			userStatus: "running",
+			internalStatus: "running"
+		});
+	}
+	static start(input) {
+		return new OutcomeRunCoordinator(input.runId, input.context, input.fallbackObjective);
+	}
+	addEvidence(evidence) {
+		if (this.#evidence.some((item) => item.kind === evidence.kind && item.title === evidence.title)) return;
+		this.#evidence.push(evidence);
+	}
+	capturePlan(items) {
+		for (const item of items) {
+			if (item.status !== "completed") continue;
+			this.addEvidence({
+				kind: "state",
+				title: `Plan item completed: ${item.title}`,
+				summary: "The execution agent marked this plan item as completed."
+			});
+		}
+	}
+	capturePatch(added, removed) {
+		this.addEvidence({
+			kind: "state",
+			title: "Changes applied",
+			summary: `${added} additions and ${removed} removals`
+		});
+	}
+	captureCommand(command, durationMs) {
+		if (!/(^|\s)(test|vitest|jest|pytest|lint|typecheck|build)(\s|$|:)/i.test(command)) return;
+		this.addEvidence({
+			kind: "test",
+			title: command.slice(0, 120),
+			summary: durationMs === void 0 ? "Command completed successfully" : `Command completed successfully in ${durationMs} ms`
+		});
+	}
+	finalize(input) {
+		const goal = this.context.goalId ? this.#goals.get(this.context.goalId) : void 0;
+		const contextSnapshot = this.#contextCompiler.latestForSession(this.context.sessionKey, this.#startedAt);
+		if (contextSnapshot) this.#contextCompiler.linkToRun({
+			snapshotId: contextSnapshot.id,
+			outcomeId: this.context.outcomeId,
+			runId: this.runId
+		});
+		const criteria = new Set(this.contract?.acceptanceCriteria ?? []);
+		for (const item of goal?.checklist ?? []) {
+			if (item.status !== "completed" || !criteria.has(item.text)) continue;
+			this.addEvidence({
+				kind: "state",
+				title: `Independently verified: ${item.text}`,
+				summary: item.evidenceSummary ?? "The goal judge marked this acceptance criterion complete.",
+				verifies: [item.text]
+			});
+		}
+		if (this.context.outcomeId) this.#outcomes.updateState({
+			id: this.context.outcomeId,
+			userStatus: goal?.status === "needs_input" ? "needs_user" : "running",
+			internalStatus: goal?.status === "needs_input" ? "needs_user" : "verifying"
+		});
+		updateExecutionReceipt({
+			runId: this.runId,
+			...this.contract ? { contract: this.contract } : {},
+			evidence: this.#evidence,
+			nextAction: goal?.nextAction ?? null,
+			needsUser: goal?.status === "needs_input",
+			contextTraceId: contextSnapshot?.id ?? this.context.contextTraceId ?? null
+		});
+		const outcome = completeExecutionReceipt({
+			runId: this.runId,
+			status: input.status,
+			summary: input.summary
+		});
+		return outcome ? this.#projection.project(outcome) : void 0;
+	}
+};
+//#endregion
+export { OutcomeRunCoordinator };

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

@@ -0,0 +1,21 @@
+import type { MonitoringMode, ProjectMonitoringPolicy, QuietHours } from '@xopcai/gateway-contract';
+export type ProactiveDisposition = 'record_silently' | 'show_in_work' | 'request_approval' | 'auto_execute';
+export declare function decideProactiveDisposition(policy: ProjectMonitoringPolicy, input: {
+    confidence: number;
+    valueScore: number;
+    risk: 'low' | 'medium' | 'high';
+    actionId?: string;
+    requiresApproval?: boolean;
+}): ProactiveDisposition;
+export declare class ProjectMonitoringService {
+    #private;
+    get(projectId: string): ProjectMonitoringPolicy;
+    configure(input: {
+        projectId: string;
+        mode: MonitoringMode;
+        quietHours?: QuietHours;
+        allowedActions?: string[];
+        confidenceThreshold?: number;
+        scenarios?: string[];
+    }): ProjectMonitoringPolicy;
+}

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

@@ -0,0 +1,76 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { ProactiveScenarioService } from "../proactive/scenarios/service.js";
+//#region src/work/project-monitoring-service.ts
+const DEFAULT_SCENARIOS = ["project_delivery_risk", "blocked_work"];
+function validHour(value) {
+	return Number.isInteger(value) && value >= 0 && value <= 23;
+}
+function rowToPolicy(row, scenarios) {
+	return {
+		projectId: row.project_id,
+		mode: row.mode,
+		quietHours: row.quiet_hours_json ? JSON.parse(row.quiet_hours_json) : void 0,
+		allowedActions: JSON.parse(row.allowed_actions_json),
+		confidenceThreshold: row.confidence_threshold,
+		scenarios,
+		configured: true,
+		updatedAt: row.updated_at
+	};
+}
+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";
+	return "show_in_work";
+}
+var ProjectMonitoringService = class {
+	#scenarios = new ProactiveScenarioService();
+	get(projectId) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM project_monitoring_policies WHERE project_id = ?").get(projectId);
+		const scenarios = this.#scenarios.subscriptions().filter((item) => item.scopeKind === "project" && item.scopeId === projectId && item.enabled).map((item) => item.scenarioKey).sort();
+		return row ? rowToPolicy(row, scenarios) : {
+			projectId,
+			mode: "observe",
+			allowedActions: [],
+			confidenceThreshold: .75,
+			scenarios: [],
+			configured: false
+		};
+	}
+	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");
+		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);
+		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");
+		const existingSubscriptions = new Set(this.#scenarios.subscriptions().filter((item) => item.scopeKind === "project" && item.scopeId === input.projectId).map((item) => item.scenarioKey));
+		const now = Date.now();
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`INSERT INTO project_monitoring_policies (
+          project_id, mode, quiet_hours_json, allowed_actions_json, confidence_threshold, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(project_id) DO UPDATE SET mode = excluded.mode,
+          quiet_hours_json = excluded.quiet_hours_json,
+          allowed_actions_json = excluded.allowed_actions_json,
+          confidence_threshold = excluded.confidence_threshold,
+          updated_at = excluded.updated_at`).run(input.projectId, input.mode, input.quietHours ? JSON.stringify(input.quietHours) : null, JSON.stringify(allowedActions), threshold, now, now);
+			const selected = new Set(scenarios);
+			for (const scenario of availableScenarios) {
+				if (!selected.has(scenario) && !existingSubscriptions.has(scenario)) continue;
+				this.#scenarios.subscribe({
+					scenarioKey: scenario,
+					workspaceId: "default",
+					scopeKind: "project",
+					scopeId: input.projectId,
+					enabled: selected.has(scenario)
+				});
+			}
+		});
+		return this.get(input.projectId);
+	}
+};
+//#endregion
+export { ProjectMonitoringService, decideProactiveDisposition };

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

@@ -0,0 +1,10 @@
+import type { ProjectOperatingView } from '@xopcai/gateway-contract';
+import { type ProjectService } from '../projects/index.js';
+import type { WorkItemService } from '../work-items/index.js';
+export declare class ProjectOperatingViewService {
+    #private;
+    private readonly projects;
+    private readonly workItems;
+    constructor(projects: ProjectService, workItems: WorkItemService);
+    get(projectId: string): ProjectOperatingView | undefined;
+}

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

@@ -0,0 +1,46 @@
+import { GoalService } from "../goals/goal-service.js";
+import "../goals/index.js";
+import { OutcomeReceiptService } from "./outcome-receipt-service.js";
+import { buildProjectLoopOverview } from "../projects/project-loop.js";
+import "../projects/index.js";
+import { ProjectMonitoringService } from "./project-monitoring-service.js";
+//#region src/work/project-operating-view-service.ts
+var ProjectOperatingViewService = class {
+	#goals = new GoalService();
+	#receipts = new OutcomeReceiptService();
+	#monitoring = new ProjectMonitoringService();
+	constructor(projects, workItems) {
+		this.projects = projects;
+		this.workItems = workItems;
+	}
+	get(projectId) {
+		const project = this.projects.getWithDetails(projectId);
+		if (!project) return void 0;
+		const goals = this.projects.listGoalIds(project.id, 100).map((goalId) => this.#goals.get(goalId)).filter((goal) => Boolean(goal));
+		const actions = this.workItems.listProjectWorkItems(project.id, { limit: 100 }).items.filter((item) => item.status !== "done" && item.status !== "cancelled");
+		const loop = buildProjectLoopOverview({
+			project,
+			goals,
+			recentWorkflowRuns: project.recentWorkflowRuns
+		});
+		return {
+			project,
+			desiredOutcomes: goals.filter((goal) => !goal.archivedAt),
+			currentActions: actions,
+			blockers: loop.attentionItems,
+			running: project.recentWorkflowRuns.filter((run) => run.status === "queued" || run.status === "running"),
+			recentReceipts: this.#receipts.list({
+				projectId: project.id,
+				limit: 10
+			}),
+			digest: {
+				health: loop.digest.status,
+				summary: loop.digest.summary,
+				recommendedAction: loop.recommendedAction
+			},
+			monitoring: this.#monitoring.get(project.id)
+		};
+	}
+};
+//#endregion
+export { ProjectOperatingViewService };