@xopcai/xopc 0.0.384 → 0.0.386

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

@@ -2,12 +2,16 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { TaskRepository, init_task_repository } from "./task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "./task-run-repository.js";
+import { loadTranscriptRowsForSession } from "../storage/sqlite/transcript-repository.js";
+import { init_sqlite } from "../storage/sqlite/index.js";
+import { canResumeAfterModelFailure } from "../agent/orchestration/turn-recovery.js";
 import { resolveTaskLocale } from "./task-language.js";
 import { TaskApplicationService } from "./task-application-service.js";
 //#region src/tasks/task-run-dispatcher.ts
 init_logger();
 init_task_repository();
 init_task_run_repository();
+init_sqlite();
 const log = createLogger("TaskRunDispatcher");
 const LEASE_MS = 6e4;
 const HEARTBEAT_MS = 15e3;
@@ -35,6 +39,7 @@ var TaskRunDispatcher = class {
 	}
 	async drain() {
 		if (this.#stopped) return;
+		this.#runs.reconcileCancelledRuns();
 		this.reconcileExpiredRuns();
 		const count = Math.max(1, Math.min(8, this.deps.maxConcurrency ?? 3));
 		await Promise.all(Array.from({ length: count }, (_, slot) => this.drainSlot(`${this.deps.workerId}:${slot}`)));
@@ -43,6 +48,12 @@ var TaskRunDispatcher = class {
 		for (const run of this.#runs.listExpiredLeasedRunning()) {
 			if (this.#activeRunIds.has(run.id)) continue;
 			try {
+				if (run.conversationId && canResumeAfterModelFailure(loadTranscriptRowsForSession(run.conversationId)) && this.#runs.scheduleContinuation({
+					runId: run.id,
+					expectedVersion: run.version,
+					reason: "process_restart",
+					message: "Execution was interrupted by a process restart. Continue this same task from confirmed tool results. Do not repeat completed operations. If any external effect cannot be confirmed, ask for verification instead of replaying it."
+				})) continue;
 				const zh = resolveTaskLocale(this.#tasks.require(run.taskId)) === "zh";
 				this.#application.completeRun({
 					runId: run.id,
@@ -126,6 +137,7 @@ var TaskRunDispatcher = class {
 				} catch (error) {
 					if (this.#stopped) return;
 					const current = this.#runs.get(run.id);
+					if (current?.status === "waiting" && current.policySnapshot.continuation) continue;
 					if (current && [
 						"queued",
 						"running",

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

@@ -56,6 +56,17 @@ export declare class TaskRunRepository {
         now?: number;
     }): TaskRun | undefined;
     listExpiredLeasedRunning(now?: number, limit?: number): TaskRun[];
+    /** Finish cancellations persisted before an earlier process could observe execution exit. */
+    reconcileCancelledRuns(): number;
+    /** Resume the same TaskRun and conversation within its original deadline and attempt budget. */
+    scheduleContinuation(input: {
+        runId: string;
+        expectedVersion: number;
+        message: string;
+        reason: string;
+        repairFingerprint?: string;
+        now?: number;
+    }): boolean;
     finalize(input: {
         runId: string;
         expectedVersion: number;
@@ -93,6 +104,8 @@ export declare class TaskRunRepository {
     getWait(waitId: string): TaskWait | undefined;
     requireWait(waitId: string): TaskWait;
     listActiveWaits(taskId: string): TaskWait[];
+    /** A Run's cancellation owns all its waits, never those of another Run on the same Task. */
+    resolveCancelledRunWaits(runId: string, actor: ActorRef): number;
     resolveWait(input: {
         waitId: string;
         actor: ActorRef;

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

@@ -74,7 +74,7 @@ function receiptFromRow(row) {
 		finalizedAt: row.finalized_at
 	};
 }
-var ACTIVE_RUN_STATUSES, TaskRunRepository;
+var ACTIVE_RUN_STATUSES, CANCELLED_ACTIVE_RUNS, TaskRunRepository;
 var init_task_run_repository = __esmMin((() => {
 	init_transaction();
 	init_task_change_events();
@@ -85,10 +85,23 @@ var init_task_run_repository = __esmMin((() => {
 		"waiting",
 		"verifying"
 	];
+	CANCELLED_ACTIVE_RUNS = `SELECT run.run_id FROM task_runs run
+  WHERE ((run.status = 'cancelled' AND EXISTS (SELECT 1 FROM task_waits remaining
+    WHERE remaining.task_run_id = run.run_id AND remaining.status = 'active'))
+    OR (run.status IN ('queued','running','waiting','verifying') AND (
+    EXISTS (SELECT 1 FROM session_connection_waits wait WHERE wait.status = 'closed'
+      AND json_extract(wait.data_json, '$.resolution') = 'cancelled' AND (
+        json_extract(wait.data_json, '$.taskRunId') = run.run_id
+        OR EXISTS (SELECT 1 FROM session_inputs origin WHERE origin.id = json_extract(wait.data_json, '$.originInputId')
+          AND origin.task_run_id = run.run_id)
+        OR EXISTS (SELECT 1 FROM task_waits task_wait WHERE task_wait.task_run_id = run.run_id
+          AND json_extract(task_wait.condition_json, '$.connectionWaitId') = wait.id)))
+    OR EXISTS (SELECT 1 FROM command_deduplication command WHERE command.command_type = 'task.close'
+      AND command.subject_id = run.task_id AND json_extract(command.result_json, '$.cancellationRunId') = run.run_id))))`;
 	TaskRunRepository = class {
 		nextAgentInputClientMessageId(runId) {
 			const finished = getSqliteDatabase().prepare(`SELECT COUNT(*) AS count FROM session_inputs
-      WHERE task_run_id = ? AND status IN ('completed', 'suspended')`).get(runId);
+      WHERE task_run_id = ? AND status IN ('completed', 'suspended', 'failed', 'interrupted', 'cancelled')`).get(runId);
 			return finished.count === 0 ? `task:${runId}` : `task:${runId}:resume:${finished.count}`;
 		}
 		create(input) {
@@ -204,6 +217,87 @@ var init_task_run_repository = __esmMin((() => {
         AND lease_expires_at IS NOT NULL AND lease_expires_at <= ?
       ORDER BY lease_expires_at LIMIT ?`).all(now, Math.max(1, Math.min(200, Math.floor(limit)))).map(fromRow);
 		}
+		/** Finish cancellations persisted before an earlier process could observe execution exit. */
+		reconcileCancelledRuns() {
+			return runSqliteWriteTransaction((db) => {
+				const rows = db.prepare(CANCELLED_ACTIVE_RUNS).all();
+				let completed = 0;
+				for (const row of rows) {
+					const run = this.get(row.run_id);
+					if (!run) continue;
+					const cleared = this.resolveCancelledRunWaits(run.id, { kind: "system" });
+					if (run.status === "cancelled") {
+						if (cleared) completed++;
+						continue;
+					}
+					if (run && this.finalize({
+						runId: run.id,
+						expectedVersion: run.version,
+						actor: { kind: "system" },
+						terminalCode: "cancelled_by_user",
+						receipt: {
+							status: "cancelled",
+							summary: "Task cancelled",
+							changes: [],
+							evidence: [],
+							verification: {
+								status: "unverified",
+								checks: []
+							},
+							remainingWork: [],
+							needsUser: false,
+							completionVerdict: "not_achieved"
+						}
+					})) {
+						const task = new TaskRepository().require(run.taskId);
+						enqueueTaskChangedEvent(db, {
+							taskId: task.id,
+							projectId: task.projectId,
+							version: task.version,
+							changedFields: ["runs", "receipts"],
+							actor: { kind: "system" },
+							source: "runtime"
+						});
+						completed++;
+					}
+				}
+				return completed;
+			});
+		}
+		/** Resume the same TaskRun and conversation within its original deadline and attempt budget. */
+		scheduleContinuation(input) {
+			const now = input.now ?? Date.now();
+			return runSqliteWriteTransaction((db) => {
+				const run = this.get(input.runId);
+				if (db.prepare(`${CANCELLED_ACTIVE_RUNS} AND run.run_id = ?`).get(input.runId)) return false;
+				if (!run || run.version !== input.expectedVersion || !["running", "verifying"].includes(run.status) || run.parentRunId || !run.conversationId || run.timeoutAt !== void 0 && run.timeoutAt <= now || this.listActiveWaits(run.taskId).length > 0) return false;
+				const execution = db.prepare("SELECT active_conversation_id FROM task_conversation_state WHERE task_id = ?").get(run.taskId);
+				if (execution?.active_conversation_id && execution.active_conversation_id !== run.conversationId) return false;
+				const task = new TaskRepository().require(run.taskId);
+				if (task.phase !== "active" || run.contractVersion !== task.latestContractVersion) return false;
+				const attempts = Number(run.policySnapshot.continuationAttempts ?? 0);
+				const maxAttempts = Math.max(1, Math.min(3, Number(run.retryPolicy.maxAttempts ?? 1)));
+				if (!Number.isFinite(attempts) || !Number.isFinite(maxAttempts) || attempts >= maxAttempts - 1) return false;
+				if (input.repairFingerprint && run.policySnapshot.repairFingerprint === input.repairFingerprint) return false;
+				const policy = {
+					...run.policySnapshot,
+					continuationAttempts: attempts + 1,
+					...input.repairFingerprint ? { repairFingerprint: input.repairFingerprint } : {},
+					continuation: {
+						message: input.message,
+						reason: input.reason,
+						transcriptId: db.prepare("SELECT active_transcript_id FROM sessions WHERE conversation_id = ?").get(run.conversationId)?.active_transcript_id
+					}
+				};
+				if (!db.prepare(`UPDATE task_runs SET status = 'waiting', policy_snapshot_json = ?,
+        lease_owner = NULL, lease_expires_at = NULL, version = version + 1 WHERE run_id = ? AND version = ?`).run(JSON.stringify(policy), run.id, run.version).changes) return false;
+				this.appendEvent(db, run.id, "task_run.continuation_scheduled", {
+					reason: input.reason,
+					attempt: attempts + 2
+				}, { kind: "system" }, now);
+				return true;
+			});
+		}
 		finalize(input) {
 			const now = input.now ?? Date.now();
 			return runSqliteWriteTransaction((db) => {
@@ -301,6 +395,30 @@ var init_task_run_repository = __esmMin((() => {
 			return getSqliteDatabase().prepare(`SELECT * FROM task_waits WHERE task_id = ? AND status = 'active'
        ORDER BY created_at ASC`).all(taskId).map(waitFromRow);
 		}
+		/** A Run's cancellation owns all its waits, never those of another Run on the same Task. */
+		resolveCancelledRunWaits(runId, actor) {
+			return runSqliteWriteTransaction((db) => {
+				const run = this.get(runId);
+				if (!run) return 0;
+				let resolved = 0;
+				for (const wait of this.listActiveWaits(run.taskId)) if (wait.taskRunId === run.id && this.resolveWait({
+					waitId: wait.id,
+					actor,
+					resolution: { cancelled: true }
+				})) resolved++;
+				if (resolved) {
+					const task = new TaskRepository().require(run.taskId);
+					enqueueTaskChangedEvent(db, {
+						taskId: task.id,
+						projectId: task.projectId,
+						version: task.version,
+						changedFields: ["runs"],
+						actor
+					});
+				}
+				return resolved;
+			});
+		}
 		resolveWait(input) {
 			const now = input.now ?? Date.now();
 			return runSqliteWriteTransaction((db) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xopcai/xopc",
-  "version": "0.0.384",
+  "version": "0.0.386",
   "description": "Local-first personal AI with Ada, task delegation, files, projects, workflows, and automations. Use cloud or local models.",
   "type": "module",
   "main": "dist/src/index.js",
@@ -170,10 +170,10 @@
     "vue": "^3.5.35",
     "@xopcai/browser-control-contract": "0.1.0",
     "@xopcai/computer-control-contract": "0.1.0",
-    "@xopcai/endpoint-tools-client": "0.0.0",
     "@xopcai/endpoint-tools-protocol": "0.0.0",
-    "@xopcai/image-providers": "0.1.0",
+    "@xopcai/endpoint-tools-client": "0.0.0",
     "@xopcai/gateway-contract": "0.0.0",
+    "@xopcai/image-providers": "0.1.0",
     "@xopcai/realtime-client": "0.0.0",
     "@xopcai/realtime-protocol": "0.0.0"
   },
@@ -242,6 +242,10 @@
     "test:startup:gateway:check": "node --import tsx scripts/bench-gateway-startup.ts --runs 2 --warmup 0 --ready-budget-ms 20000",
     "test:startup:imports": "node scripts/check-cli-bootstrap-imports.mjs",
     "eval:coder": "tsx evals/coder/apps/cli/src/main.ts",
+    "eval:personal:p0": "tsx scripts/personal-delivery-benchmark.mts",
+    "eval:personal:p1": "tsx scripts/personal-delivery-benchmark.mts --suite p1",
+    "eval:personal:p2": "tsx scripts/personal-delivery-benchmark.mts --suite p2",
+    "eval:personal:live-repair": "tsx scripts/personal-repair-live-benchmark.mts",
     "eval:coder:check": "pnpm -C evals/coder run check",
     "eval:coder:smoke": "pnpm -C evals/coder run smoke",
     "eval:coder:web": "tsx evals/coder/apps/web/src/server.ts",

package/dist/gateway/static/root/assets/constants-Dy8Gw0sF.js

@@ -1 +0,0 @@
-import{i as e,l as t,p as n,r,s as i,t as a,u as o}from"./schemas-CObaziC7.js";var s=a([`document`,`spreadsheet`,`presentation`,`pdf`,`image`,`video`,`audio`,`site`,`archive`,`file`]),c=a([`workspace`,`external_host`,`worktree`,`remote_runtime`,`artifact_store`]),l=a([`materializing`,`available`,`expired`,`missing`,`failed`]),u=a([`preview`,`download`,`open`,`import`,`share`,`regenerate`]),d=o({artifactId:n().min(1),sourceFileId:n().min(1).optional(),title:n().min(1),kind:s,mimeType:n().optional(),sizeBytes:t().nonnegative().optional(),availability:l,location:c,capabilities:r(u),uri:n().optional(),workspaceRelativePath:n().optional(),shareUrl:n().url().optional(),thumbnailUrl:n().optional(),expiresAt:n().optional()}),f=o({path:n().min(1),status:a([`added`,`modified`,`deleted`,`renamed`]).optional(),added:t().nonnegative().optional(),removed:t().nonnegative().optional()}),p=o({changeSetId:n().min(1),files:r(f),added:t().nonnegative(),removed:t().nonnegative(),diff:n(),diffTruncated:e().optional(),environment:a([`workspace`,`worktree`,`remote_runtime`])}),m=o({evidenceId:n().min(1),kind:a([`check`,`screenshot`,`video`,`log`]),label:n().min(1),status:a([`passed`,`failed`,`warning`]),durationMs:t().nonnegative().optional(),command:n().optional(),artifactId:n().optional(),revision:n().optional(),logPath:n().optional()}),h=o({version:i(1),outcomeId:n().min(1),runId:n().min(1),turnId:n().min(1),status:a([`succeeded`,`partial`,`failed`]),summary:n().optional(),deliverables:r(d),changeSet:p.optional(),evidence:r(m),createdAt:n()}),g=`xopc-file:`;function _(e){if(!e.startsWith(g))return null;try{return decodeURIComponent(e.slice(10)).trim()||null}catch{return null}}function v(e){let t=new Map(e.map(e=>[e.artifactId,e])),n=new Map,r=e=>e.availability===`available`?e.location===`artifact_store`?2:1:0;for(let e of t.values()){let t=e.sourceFileId??_(e.uri??``),i=t?`source:${t}`:`artifact:${e.artifactId}`,a=n.get(i);(!a||r(e)>=r(a))&&n.set(i,e)}return[...n.values()]}function y(e){let t=h.safeParse(e);return t.success?{...t.data,deliverables:v(t.data.deliverables)}:null}var b=32*1024*1024;export{y as i,h as n,_ as r,b as t};