@xopcai/xopc 0.0.177 → 0.0.179

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 };

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

@@ -0,0 +1,49 @@
+import type { ConfirmedWork, WorkExecutionMode, WorkIntakeProposal } from '@xopcai/gateway-contract';
+type WorkIntakeStatus = 'proposed' | 'confirmed' | 'expired' | 'cancelled';
+export interface StoredWorkIntake {
+    idempotencyKey: string;
+    requestFingerprint: string;
+    proposal: WorkIntakeProposal;
+    sessionKey?: string;
+    agentId?: string;
+    status: WorkIntakeStatus;
+    executionMode: WorkExecutionMode;
+    projectId?: string;
+    goalId?: string;
+    outcomeId?: string;
+    queueId?: string;
+    createdAt: number;
+    confirmedAt?: number;
+    updatedAt: number;
+}
+export declare class WorkIntakeRepository {
+    create(input: {
+        idempotencyKey: string;
+        requestFingerprint: string;
+        proposal: WorkIntakeProposal;
+        sessionKey?: string;
+        agentId?: string;
+        now?: number;
+    }): StoredWorkIntake;
+    get(intakeId: string, now?: number): StoredWorkIntake | undefined;
+    getByIdempotencyKey(idempotencyKey: string, now?: number): StoredWorkIntake | undefined;
+    listPendingExecution(limit?: number): StoredWorkIntake[];
+    markConfirmed(input: {
+        intakeId: string;
+        executionMode: WorkExecutionMode;
+        projectId?: string;
+        goalId: string;
+        outcomeId: string;
+        sessionKey?: string;
+        queueId?: string;
+        now?: number;
+    }): StoredWorkIntake;
+    setExecution(input: {
+        intakeId: string;
+        sessionKey?: string;
+        queueId: string;
+        now?: number;
+    }): StoredWorkIntake;
+    toConfirmedWork(stored: StoredWorkIntake): ConfirmedWork | undefined;
+}
+export {};

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

@@ -0,0 +1,97 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+//#region src/work/work-intake-repository.ts
+function fromRow(row) {
+	return {
+		idempotencyKey: row.idempotency_key,
+		requestFingerprint: row.request_fingerprint,
+		proposal: JSON.parse(row.proposal_json),
+		...row.session_key ? { sessionKey: row.session_key } : {},
+		...row.agent_id ? { agentId: row.agent_id } : {},
+		status: row.status,
+		executionMode: row.execution_mode,
+		...row.project_id ? { projectId: row.project_id } : {},
+		...row.goal_id ? { goalId: row.goal_id } : {},
+		...row.outcome_id ? { outcomeId: row.outcome_id } : {},
+		...row.queue_id ? { queueId: row.queue_id } : {},
+		createdAt: row.created_at,
+		...row.confirmed_at === null ? {} : { confirmedAt: row.confirmed_at },
+		updatedAt: row.updated_at
+	};
+}
+function selectBy(column, value) {
+	const row = getSqliteDatabase().prepare(`SELECT * FROM work_intakes WHERE ${column} = ?`).get(value);
+	return row ? fromRow(row) : void 0;
+}
+var WorkIntakeRepository = class {
+	create(input) {
+		const now = input.now ?? Date.now();
+		return runSqliteWriteTransaction((db) => {
+			db.prepare(`INSERT INTO work_intakes (
+          intake_id, idempotency_key, request_fingerprint, objective, proposal_json, session_key, agent_id,
+          status, execution_mode, expires_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, 'proposed', 'run_now', ?, ?, ?)
+        ON CONFLICT(idempotency_key) DO NOTHING`).run(input.proposal.id, input.idempotencyKey, input.requestFingerprint, input.proposal.objective, JSON.stringify(input.proposal), input.sessionKey ?? null, input.agentId ?? null, input.proposal.expiresAt, now, now);
+			const stored = selectBy("idempotency_key", input.idempotencyKey);
+			if (!stored) throw new Error("Failed to persist work intake");
+			return stored;
+		});
+	}
+	get(intakeId, now = Date.now()) {
+		const stored = selectBy("intake_id", intakeId);
+		if (!stored || stored.status !== "proposed" || stored.proposal.expiresAt > now) return stored;
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`UPDATE work_intakes SET status = 'expired', updated_at = ?
+         WHERE intake_id = ? AND status = 'proposed'`).run(now, intakeId);
+		});
+		return selectBy("intake_id", intakeId);
+	}
+	getByIdempotencyKey(idempotencyKey, now = Date.now()) {
+		const stored = selectBy("idempotency_key", idempotencyKey);
+		return stored ? this.get(stored.proposal.id, now) : void 0;
+	}
+	listPendingExecution(limit = 100) {
+		return getSqliteDatabase().prepare(`SELECT * FROM work_intakes
+         WHERE status = 'confirmed' AND execution_mode = 'run_now' AND queue_id IS NULL
+         ORDER BY confirmed_at ASC
+         LIMIT ?`).all(Math.min(500, Math.max(1, Math.floor(limit)))).map(fromRow);
+	}
+	markConfirmed(input) {
+		const now = input.now ?? Date.now();
+		getSqliteDatabase().prepare(`UPDATE work_intakes SET
+        status = 'confirmed', execution_mode = ?, project_id = ?, goal_id = ?,
+        outcome_id = ?, session_key = COALESCE(?, session_key), queue_id = ?,
+        confirmed_at = COALESCE(confirmed_at, ?), updated_at = ?
+       WHERE intake_id = ? AND status = 'proposed'`).run(input.executionMode, input.projectId ?? null, input.goalId, input.outcomeId, input.sessionKey ?? null, input.queueId ?? null, now, now, input.intakeId);
+		const stored = selectBy("intake_id", input.intakeId);
+		if (!stored) throw new Error("Work intake not found");
+		return stored;
+	}
+	setExecution(input) {
+		const now = input.now ?? Date.now();
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`UPDATE work_intakes SET session_key = COALESCE(?, session_key), queue_id = ?, updated_at = ?
+         WHERE intake_id = ? AND status = 'confirmed'`).run(input.sessionKey ?? null, input.queueId, now, input.intakeId);
+		});
+		const stored = selectBy("intake_id", input.intakeId);
+		if (!stored) throw new Error("Work intake not found");
+		return stored;
+	}
+	toConfirmedWork(stored) {
+		if (stored.status !== "confirmed" || !stored.outcomeId || !stored.goalId) return void 0;
+		const queue = stored.queueId ? getSqliteDatabase().prepare("SELECT status, session_key FROM goal_queue WHERE queue_id = ?").get(stored.queueId) : void 0;
+		const sessionKey = queue?.session_key ?? stored.sessionKey;
+		return {
+			outcomeId: stored.outcomeId,
+			...stored.projectId ? { projectId: stored.projectId } : {},
+			goalId: stored.goalId,
+			...sessionKey ? { sessionKey } : {},
+			execution: {
+				mode: stored.executionMode,
+				status: queue?.status ?? (stored.queueId ? "queued" : "not_started"),
+				...stored.queueId ? { queueId: stored.queueId } : {}
+			}
+		};
+	}
+};
+//#endregion
+export { WorkIntakeRepository };

package/dist/src/work/work-intake-service.d.ts

@@ -0,0 +1,26 @@
+import type { ConfirmedWork, WorkExecutionMode, WorkIntakeProposal } from '@xopcai/gateway-contract';
+import { type EnqueueGoalRunOptions, type GoalQueueItemSnapshot } from '../goals/index.js';
+import { ProjectService } from '../projects/index.js';
+export interface WorkIntakeExecutionPort {
+    enqueue(goalId: string, options: EnqueueGoalRunOptions): GoalQueueItemSnapshot;
+}
+export declare class WorkIntakeService {
+    #private;
+    private readonly projects;
+    private readonly execution?;
+    constructor(projects: ProjectService, execution?: WorkIntakeExecutionPort);
+    propose(input: {
+        idempotencyKey: string;
+        objective: string;
+        projectId?: string;
+        sessionKey?: string;
+        agentId?: string;
+    }): WorkIntakeProposal;
+    confirm(input: {
+        proposalId: string;
+        executionMode: WorkExecutionMode;
+        projectId?: string;
+    }): ConfirmedWork | undefined;
+    reconcilePendingExecutions(): number;
+    private _ensureExecution;
+}