@xopcai/xopc 0.0.180 → 0.0.187

package/dist/src/tasks/task-repository.js

@@ -0,0 +1,185 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/tasks/task-repository.ts
+function parseJson(value) {
+	return JSON.parse(value);
+}
+function contractFromRow(row) {
+	return {
+		taskId: row.task_id,
+		version: row.version,
+		objective: row.objective,
+		expectedOutputs: parseJson(row.expected_outputs_json),
+		acceptanceCriteria: parseJson(row.acceptance_criteria_json),
+		constraints: parseJson(row.constraints_json),
+		approvalRequired: parseJson(row.approval_required_json),
+		assumptions: parseJson(row.assumptions_json),
+		risks: parseJson(row.risks_json),
+		acceptancePolicy: row.acceptance_policy,
+		outputDestinations: parseJson(row.output_destinations_json),
+		createdBy: parseJson(row.created_by_json),
+		createdAt: row.created_at
+	};
+}
+function taskFromRow(row, contract) {
+	return {
+		id: row.task_id,
+		title: row.title,
+		...row.body ? { body: row.body } : {},
+		phase: row.phase,
+		...row.resolution ? { resolution: row.resolution } : {},
+		priority: row.priority,
+		...row.due_at === null ? {} : { dueAt: row.due_at },
+		...row.project_id ? { projectId: row.project_id } : {},
+		...row.milestone_id ? { milestoneId: row.milestone_id } : {},
+		...row.parent_task_id ? { parentTaskId: row.parent_task_id } : {},
+		...row.owner_id ? { ownerId: row.owner_id } : {},
+		...row.delegate_agent_id ? { delegateAgentId: row.delegate_agent_id } : {},
+		source: row.source,
+		...row.locale ? { locale: row.locale } : {},
+		latestContractVersion: row.latest_contract_version,
+		version: row.version,
+		...contract ? { contract } : {},
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		...row.closed_at === null ? {} : { closedAt: row.closed_at }
+	};
+}
+var TaskRepository = class {
+	create(input) {
+		const title = input.title.trim();
+		const objective = input.objective.trim();
+		if (!title) throw new Error("Task title is required");
+		if (!objective) throw new Error("Task objective is required");
+		const id = input.id ?? randomUUID();
+		const now = input.now ?? Date.now();
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`INSERT INTO tasks (
+          task_id, creation_idempotency_key, project_id, milestone_id, parent_task_id,
+          title, body, phase, priority, due_at, owner_id, delegate_agent_id,
+          source, locale, latest_contract_version, version, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, 1, ?, ?)`).run(id, input.idempotencyKey ?? null, input.projectId ?? null, input.milestoneId ?? null, input.parentTaskId ?? null, title, input.body?.trim() || null, input.phase ?? "backlog", input.priority ?? "normal", input.dueAt ?? null, input.ownerId ?? null, input.delegateAgentId ?? null, input.source ?? "api", input.locale ?? null, now, now);
+			this.insertContract(db, {
+				taskId: id,
+				version: 1,
+				objective,
+				expectedOutputs: input.expectedOutputs ?? [],
+				acceptanceCriteria: input.acceptanceCriteria ?? [],
+				constraints: input.constraints ?? [],
+				approvalRequired: input.approvalRequired ?? [],
+				assumptions: input.assumptions ?? [],
+				risks: input.risks ?? [],
+				acceptancePolicy: input.acceptancePolicy ?? "verified_then_review",
+				outputDestinations: input.outputDestinations ?? [],
+				createdBy: input.createdBy ?? { kind: "system" },
+				createdAt: now
+			});
+		});
+		return this.require(id);
+	}
+	get(id) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM tasks WHERE task_id = ?").get(id);
+		return row ? taskFromRow(row, this.getContract(id, row.latest_contract_version)) : void 0;
+	}
+	require(id) {
+		const task = this.get(id);
+		if (!task) throw new Error(`Task not found: ${id}`);
+		return task;
+	}
+	getByIdempotencyKey(key) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM tasks WHERE creation_idempotency_key = ?").get(key);
+		return row ? taskFromRow(row, this.getContract(row.task_id, row.latest_contract_version)) : void 0;
+	}
+	getBySession(sessionKey) {
+		const row = getSqliteDatabase().prepare(`SELECT tasks.* FROM tasks
+       JOIN task_sessions ON task_sessions.task_id = tasks.task_id
+       WHERE task_sessions.session_key = ?
+       ORDER BY task_sessions.created_at DESC LIMIT 1`).get(sessionKey);
+		return row ? taskFromRow(row, this.getContract(row.task_id, row.latest_contract_version)) : void 0;
+	}
+	list(input = {}) {
+		const clauses = [];
+		const params = [];
+		if (input.phase) {
+			clauses.push("phase = ?");
+			params.push(input.phase);
+		}
+		if (input.projectId) {
+			clauses.push("project_id = ?");
+			params.push(input.projectId);
+		}
+		const limit = Math.max(1, Math.min(200, Math.floor(input.limit ?? 50)));
+		params.push(limit);
+		return getSqliteDatabase().prepare(`SELECT * FROM tasks${clauses.length ? ` WHERE ${clauses.join(" AND ")}` : ""}
+       ORDER BY updated_at DESC LIMIT ?`).all(...params).map((row) => taskFromRow(row, this.getContract(row.task_id, row.latest_contract_version)));
+	}
+	listByProject(projectId, limit = 50) {
+		return this.list({
+			projectId,
+			limit
+		});
+	}
+	getContract(taskId, version) {
+		const row = version === void 0 ? getSqliteDatabase().prepare("SELECT * FROM task_contracts WHERE task_id = ? ORDER BY version DESC LIMIT 1").get(taskId) : getSqliteDatabase().prepare("SELECT * FROM task_contracts WHERE task_id = ? AND version = ?").get(taskId, version);
+		return row ? contractFromRow(row) : void 0;
+	}
+	update(taskId, patch) {
+		const current = this.get(taskId);
+		if (!current || current.version !== patch.expectedVersion) return void 0;
+		const title = patch.title === void 0 ? current.title : patch.title.trim();
+		if (!title) throw new Error("Task title is required");
+		const now = Math.max(patch.now ?? Date.now(), current.updatedAt + 1);
+		return getSqliteDatabase().prepare(`UPDATE tasks SET title = ?, body = ?, project_id = ?, milestone_id = ?,
+       parent_task_id = ?, priority = ?, due_at = ?, owner_id = ?, delegate_agent_id = ?,
+       version = version + 1, updated_at = ?
+       WHERE task_id = ? AND version = ?`).run(title, patch.body === void 0 ? current.body ?? null : patch.body?.trim() || null, patch.projectId === void 0 ? current.projectId ?? null : patch.projectId, patch.milestoneId === void 0 ? current.milestoneId ?? null : patch.milestoneId, patch.parentTaskId === void 0 ? current.parentTaskId ?? null : patch.parentTaskId, patch.priority ?? current.priority, patch.dueAt === void 0 ? current.dueAt ?? null : patch.dueAt, patch.ownerId === void 0 ? current.ownerId ?? null : patch.ownerId, patch.delegateAgentId === void 0 ? current.delegateAgentId ?? null : patch.delegateAgentId, now, taskId, patch.expectedVersion).changes === 0 ? void 0 : this.get(taskId);
+	}
+	setLifecycle(input) {
+		if (input.phase === "closed" !== Boolean(input.resolution)) throw new Error("Closed tasks require a resolution and open tasks cannot have one");
+		const current = this.get(input.taskId);
+		if (!current || current.version !== input.expectedVersion) return void 0;
+		const now = Math.max(input.now ?? Date.now(), current.updatedAt + 1);
+		return getSqliteDatabase().prepare(`UPDATE tasks SET phase = ?, resolution = ?, closed_at = ?,
+       version = version + 1, updated_at = ?
+       WHERE task_id = ? AND version = ?`).run(input.phase, input.resolution ?? null, input.phase === "closed" ? now : null, now, input.taskId, input.expectedVersion).changes === 0 ? void 0 : this.get(input.taskId);
+	}
+	reviseContract(input) {
+		const current = this.get(input.taskId);
+		if (!current || current.version !== input.expectedVersion) return void 0;
+		const objective = input.objective.trim();
+		if (!objective) throw new Error("Task objective is required");
+		const now = Math.max(input.now ?? Date.now(), current.updatedAt + 1);
+		const contractVersion = current.latestContractVersion + 1;
+		return runSqliteWriteTransaction((db) => {
+			this.insertContract(db, {
+				taskId: input.taskId,
+				version: contractVersion,
+				objective,
+				expectedOutputs: input.expectedOutputs,
+				acceptanceCriteria: input.acceptanceCriteria,
+				constraints: input.constraints,
+				approvalRequired: input.approvalRequired,
+				assumptions: input.assumptions,
+				risks: input.risks,
+				acceptancePolicy: input.acceptancePolicy,
+				outputDestinations: input.outputDestinations,
+				createdBy: input.createdBy,
+				createdAt: now
+			});
+			return db.prepare(`UPDATE tasks SET latest_contract_version = ?, version = version + 1, updated_at = ?
+         WHERE task_id = ? AND version = ?`).run(contractVersion, now, input.taskId, input.expectedVersion).changes === 0 ? void 0 : this.get(input.taskId);
+		});
+	}
+	delete(taskId) {
+		return getSqliteDatabase().prepare("DELETE FROM tasks WHERE task_id = ?").run(taskId).changes > 0;
+	}
+	insertContract(db, contract) {
+		db.prepare(`INSERT INTO task_contracts (
+        task_id, version, objective, expected_outputs_json, acceptance_criteria_json,
+        constraints_json, approval_required_json, assumptions_json, risks_json,
+        acceptance_policy, output_destinations_json, created_by_json, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(contract.taskId, contract.version, contract.objective, JSON.stringify(contract.expectedOutputs), JSON.stringify(contract.acceptanceCriteria), JSON.stringify(contract.constraints), JSON.stringify(contract.approvalRequired), JSON.stringify(contract.assumptions), JSON.stringify(contract.risks), contract.acceptancePolicy, JSON.stringify(contract.outputDestinations), JSON.stringify(contract.createdBy), contract.createdAt);
+	}
+};
+//#endregion
+export { TaskRepository };

package/dist/src/{work/outcome-run-coordinator.d.ts → tasks/task-run-coordinator.d.ts}

@@ -1,17 +1,15 @@
-import { type ExecutionContract, type ExecutionEvidence, type ExecutionReceipt, type ExecutionReceiptStatus } from '../storage/sqlite/index.js';
+import type { TaskEvidence, TaskRunReceipt } from '@xopcai/gateway-contract';
 import type { ExecutionContext } from './execution-context.js';
-export declare class OutcomeRunCoordinator {
+export declare class TaskRunCoordinator {
     #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;
+    }): TaskRunCoordinator | undefined;
+    addEvidence(evidence: TaskEvidence): void;
     capturePlan(items: Array<{
         title: string;
         status: string;
@@ -19,7 +17,7 @@ export declare class OutcomeRunCoordinator {
     capturePatch(added: number, removed: number): void;
     captureCommand(command: string, durationMs?: number): void;
     finalize(input: {
-        status: Exclude<ExecutionReceiptStatus, 'running'>;
+        status: TaskRunReceipt['status'];
         summary: string;
-    }): ExecutionReceipt | undefined;
+    }): void;
 }

package/dist/src/tasks/task-run-coordinator.js

@@ -0,0 +1,130 @@
+import { TaskRepository } from "./task-repository.js";
+import { TaskRunRepository } from "./task-run-repository.js";
+import { TaskContextRepository } from "./task-context-repository.js";
+import { TaskApplicationService } from "./task-application-service.js";
+//#region src/tasks/task-run-coordinator.ts
+var TaskRunCoordinator = class TaskRunCoordinator {
+	#evidence = [];
+	#application = new TaskApplicationService();
+	#runs = new TaskRunRepository();
+	constructor(runId) {
+		this.runId = runId;
+	}
+	static start(input) {
+		if (!input.context.taskId) return void 0;
+		const tasks = new TaskRepository();
+		const task = tasks.get(input.context.taskId);
+		if (!task || task.phase === "closed") return void 0;
+		const runs = new TaskRunRepository();
+		let run = runs.get(input.runId);
+		if (!run) {
+			if (runs.getActiveRoot(task.id)) return void 0;
+			run = runs.create({
+				id: input.runId,
+				taskId: task.id,
+				executorKind: "agent",
+				executorRef: { agentId: input.context.agentId ?? task.delegateAgentId ?? "main" },
+				trigger: { kind: input.context.triggerKind },
+				correlationId: input.runId,
+				idempotencyKey: input.runId,
+				contractVersion: task.latestContractVersion,
+				sessionKey: input.context.sessionKey
+			});
+			if (task.phase !== "active") tasks.setLifecycle({
+				taskId: task.id,
+				expectedVersion: task.version,
+				phase: "active"
+			});
+		}
+		if (run.status === "queued") {
+			const context = new TaskContextRepository();
+			const snapshot = context.captureSnapshot({
+				ownerKind: "task_run",
+				ownerId: run.id,
+				sessionKey: input.context.sessionKey,
+				query: task.contract?.objective ?? input.fallbackObjective,
+				selectedItems: context.list(task.id),
+				authorizationSnapshot: { grants: context.listActiveGrants(task.id) }
+			});
+			run = runs.start({
+				runId: run.id,
+				expectedVersion: run.version,
+				contextSnapshotId: snapshot.id,
+				policySnapshot: { executorKind: "agent" },
+				sessionKey: input.context.sessionKey
+			}) ?? run;
+		}
+		return run.status === "running" ? new TaskRunCoordinator(run.id) : void 0;
+	}
+	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 agent completed this plan item.",
+				provenance: "tool",
+				strength: "observed",
+				observedAt: Date.now()
+			});
+		}
+	}
+	capturePatch(added, removed) {
+		this.addEvidence({
+			kind: "state",
+			title: "Changes applied",
+			summary: `${added} additions and ${removed} removals`,
+			provenance: "tool",
+			strength: "observed",
+			observedAt: Date.now()
+		});
+	}
+	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`,
+			provenance: "tool",
+			strength: "verified",
+			observedAt: Date.now()
+		});
+	}
+	finalize(input) {
+		const run = this.#runs.get(this.runId);
+		if (!run || ![
+			"running",
+			"waiting",
+			"verifying"
+		].includes(run.status)) return;
+		if (run.status === "waiting" && this.#runs.listActiveWaits(run.taskId).length > 0) return;
+		this.#application.completeRun({
+			runId: run.id,
+			expectedRunVersion: run.version,
+			receipt: {
+				status: input.status,
+				summary: input.summary,
+				changes: this.#evidence.filter((item) => item.kind === "state"),
+				evidence: this.#evidence,
+				verification: {
+					status: "unverified",
+					checks: []
+				},
+				remainingWork: [],
+				needsUser: false,
+				completionVerdict: input.status === "succeeded" ? "achieved" : "not_achieved",
+				...input.status === "failed" ? { failure: {
+					code: "agent_run_failed",
+					phase: "execution",
+					recoveryAction: "Retry the task run"
+				} } : {}
+			}
+		});
+	}
+};
+//#endregion
+export { TaskRunCoordinator };

package/dist/src/tasks/task-run-dispatcher.d.ts

@@ -0,0 +1,11 @@
+export declare class TaskRunDispatcher {
+    #private;
+    private readonly deps;
+    constructor(deps: {
+        workerId: string;
+        ensureSession: (taskId: string, runId: string, agentId?: string) => Promise<string>;
+        runAgent: (runId: string, sessionKey: string, message: string) => Promise<void>;
+    });
+    dispatch(): void;
+    drain(): Promise<void>;
+}

package/dist/src/tasks/task-run-dispatcher.js

@@ -0,0 +1,90 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { TaskRepository } from "./task-repository.js";
+import { TaskRunRepository } from "./task-run-repository.js";
+//#region src/tasks/task-run-dispatcher.ts
+init_logger();
+const log = createLogger("TaskRunDispatcher");
+var TaskRunDispatcher = class {
+	#runs = new TaskRunRepository();
+	#tasks = new TaskRepository();
+	#draining = /* @__PURE__ */ new Set();
+	constructor(deps) {
+		this.deps = deps;
+	}
+	dispatch() {
+		this.drain();
+	}
+	async drain() {
+		if (this.#draining.has(this.deps.workerId)) return;
+		this.#draining.add(this.deps.workerId);
+		try {
+			while (true) {
+				const run = this.#runs.claimNext({
+					owner: this.deps.workerId,
+					leaseMs: 6e4,
+					executorKind: "agent"
+				});
+				if (!run) return;
+				const task = this.#tasks.get(run.taskId);
+				if (!task) continue;
+				try {
+					if (!(run.status === "waiting" ? this.#runs.setStatus({
+						runId: run.id,
+						expectedVersion: run.version,
+						from: ["waiting"],
+						to: "running",
+						actor: {
+							kind: "system",
+							id: this.deps.workerId
+						}
+					}) : run)) continue;
+					const agentId = typeof run.executorRef.agentId === "string" ? run.executorRef.agentId : void 0;
+					const sessionKey = await this.deps.ensureSession(task.id, run.id, agentId);
+					await this.deps.runAgent(run.id, sessionKey, task.contract?.objective ?? task.title);
+				} catch (error) {
+					const current = this.#runs.get(run.id);
+					if (current && [
+						"queued",
+						"running",
+						"waiting",
+						"verifying"
+					].includes(current.status)) this.#runs.finalize({
+						runId: current.id,
+						expectedVersion: current.version,
+						terminalCode: "dispatch_failed",
+						terminalMessage: error instanceof Error ? error.message : String(error),
+						receipt: {
+							status: "failed",
+							summary: "TaskRun dispatch failed",
+							changes: [],
+							evidence: [],
+							verification: {
+								status: "unverified",
+								checks: []
+							},
+							remainingWork: [task.contract?.objective ?? task.title],
+							needsUser: false,
+							completionVerdict: "not_achieved",
+							failure: {
+								code: "dispatch_failed",
+								phase: "dispatch",
+								recoveryAction: "Retry the task run"
+							}
+						}
+					});
+					log.warn({
+						err: error,
+						runId: run.id
+					}, "TaskRun dispatch attempt failed");
+				}
+			}
+		} catch (error) {
+			log.error({ err: error }, `TaskRun dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+		} finally {
+			this.#draining.delete(this.deps.workerId);
+		}
+	}
+};
+//#endregion
+export { TaskRunDispatcher };

package/dist/src/tasks/task-run-repository.d.ts

@@ -0,0 +1,102 @@
+import type { ActorRef, TaskExecutorKind, TaskRun, TaskRunEvent, TaskRunReceipt, TaskRunStatus, TaskWait, TaskWaitKind } from '@xopcai/gateway-contract';
+export interface TaskRunCreateInput {
+    id?: string;
+    taskId: string;
+    parentRunId?: string;
+    executorKind: TaskExecutorKind;
+    executorRef: Record<string, unknown>;
+    trigger: Record<string, unknown>;
+    correlationId: string;
+    causationId?: string;
+    idempotencyKey: string;
+    contractVersion: number;
+    scheduledAt?: number;
+    sessionKey?: string;
+    retryPolicy?: Record<string, unknown>;
+    retryOfRunId?: string;
+    now?: number;
+}
+export declare class TaskRunRepository {
+    create(input: TaskRunCreateInput): TaskRun;
+    get(id: string): TaskRun | undefined;
+    require(id: string): TaskRun;
+    getByIdempotencyKey(key: string): TaskRun | undefined;
+    getActiveRoot(taskId: string): TaskRun | undefined;
+    getLatestRoot(taskId: string): TaskRun | undefined;
+    listByTask(taskId: string, limit?: number): TaskRun[];
+    claimNext(input: {
+        owner: string;
+        leaseMs: number;
+        executorKind?: TaskExecutorKind;
+        now?: number;
+    }): TaskRun | undefined;
+    start(input: {
+        runId: string;
+        expectedVersion: number;
+        contextSnapshotId: string;
+        policySnapshot: Record<string, unknown>;
+        sessionKey?: string;
+        timeoutAt?: number;
+        actor?: ActorRef;
+        now?: number;
+    }): TaskRun | undefined;
+    setStatus(input: {
+        runId: string;
+        expectedVersion: number;
+        from: TaskRunStatus[];
+        to: Extract<TaskRunStatus, 'running' | 'waiting' | 'verifying'>;
+        actor?: ActorRef;
+        now?: number;
+    }): TaskRun | undefined;
+    heartbeat(input: {
+        runId: string;
+        owner: string;
+        leaseMs: number;
+        now?: number;
+    }): TaskRun | undefined;
+    finalize(input: {
+        runId: string;
+        expectedVersion: number;
+        receipt: Omit<TaskRunReceipt, 'runId' | 'finalizedAt'>;
+        actor?: ActorRef;
+        terminalCode?: string;
+        terminalMessage?: string;
+        now?: number;
+    }): TaskRun | undefined;
+    getReceipt(runId: string): TaskRunReceipt | undefined;
+    listReceipts(taskId: string, limit?: number): TaskRunReceipt[];
+    recordFeedback(input: {
+        runId: string;
+        rating: 'helpful' | 'not_helpful';
+        reason?: string;
+        now?: number;
+    }): {
+        id: string;
+        runId: string;
+        rating: 'helpful' | 'not_helpful';
+        reason?: string;
+        createdAt: number;
+    };
+    createWait(input: {
+        taskId: string;
+        taskRunId?: string;
+        kind: TaskWaitKind;
+        reason: string;
+        condition?: Record<string, unknown>;
+        resumeAt?: number;
+        actor?: ActorRef;
+        now?: number;
+    }): TaskWait;
+    getWait(waitId: string): TaskWait | undefined;
+    requireWait(waitId: string): TaskWait;
+    listActiveWaits(taskId: string): TaskWait[];
+    resolveWait(input: {
+        waitId: string;
+        actor: ActorRef;
+        resolution?: unknown;
+        now?: number;
+    }): TaskWait | undefined;
+    listEvents(runId: string): TaskRunEvent[];
+    private transition;
+    private appendEvent;
+}