@xopcai/xopc 0.0.180 → 0.0.188

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

@@ -0,0 +1,312 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/tasks/task-run-repository.ts
+const ACTIVE_RUN_STATUSES = [
+	"queued",
+	"running",
+	"waiting",
+	"verifying"
+];
+function parseJson(value) {
+	return JSON.parse(value);
+}
+function fromRow(row) {
+	return {
+		id: row.run_id,
+		taskId: row.task_id,
+		rootRunId: row.root_run_id,
+		...row.parent_run_id ? { parentRunId: row.parent_run_id } : {},
+		attempt: row.attempt,
+		status: row.status,
+		executorKind: row.executor_kind,
+		executorRef: parseJson(row.executor_ref_json),
+		trigger: parseJson(row.trigger_json),
+		correlationId: row.correlation_id,
+		...row.causation_id ? { causationId: row.causation_id } : {},
+		idempotencyKey: row.idempotency_key,
+		contractVersion: row.contract_version,
+		...row.context_snapshot_id ? { contextSnapshotId: row.context_snapshot_id } : {},
+		...row.policy_snapshot_json ? { policySnapshot: parseJson(row.policy_snapshot_json) } : {},
+		...row.session_key ? { sessionKey: row.session_key } : {},
+		queuedAt: row.queued_at,
+		...row.scheduled_at === null ? {} : { scheduledAt: row.scheduled_at },
+		...row.started_at === null ? {} : { startedAt: row.started_at },
+		...row.heartbeat_at === null ? {} : { heartbeatAt: row.heartbeat_at },
+		...row.completed_at === null ? {} : { completedAt: row.completed_at },
+		...row.timeout_at === null ? {} : { timeoutAt: row.timeout_at },
+		...row.lease_owner ? { leaseOwner: row.lease_owner } : {},
+		...row.lease_expires_at === null ? {} : { leaseExpiresAt: row.lease_expires_at },
+		retryPolicy: parseJson(row.retry_policy_json),
+		...row.retry_of_run_id ? { retryOfRunId: row.retry_of_run_id } : {},
+		...row.terminal_code ? { terminalCode: row.terminal_code } : {},
+		...row.terminal_message ? { terminalMessage: row.terminal_message } : {},
+		version: row.version
+	};
+}
+function waitFromRow(row) {
+	return {
+		id: row.wait_id,
+		taskId: row.task_id,
+		...row.task_run_id ? { taskRunId: row.task_run_id } : {},
+		kind: row.kind,
+		status: row.status,
+		reason: row.reason,
+		condition: parseJson(row.condition_json),
+		...row.resume_at === null ? {} : { resumeAt: row.resume_at },
+		...row.resolved_by_json ? { resolvedBy: parseJson(row.resolved_by_json) } : {},
+		...row.resolution_json ? { resolution: parseJson(row.resolution_json) } : {},
+		createdAt: row.created_at,
+		...row.resolved_at === null ? {} : { resolvedAt: row.resolved_at }
+	};
+}
+function receiptFromRow(row) {
+	return {
+		runId: row.run_id,
+		status: row.status,
+		summary: row.summary,
+		changes: parseJson(row.changes_json),
+		evidence: parseJson(row.evidence_json),
+		verification: parseJson(row.verification_json),
+		remainingWork: parseJson(row.remaining_work_json),
+		...row.next_action ? { nextAction: row.next_action } : {},
+		needsUser: row.needs_user === 1,
+		...row.completion_verdict ? { completionVerdict: row.completion_verdict } : {},
+		...row.failure_json ? { failure: parseJson(row.failure_json) } : {},
+		...row.judgment_json ? { judgment: parseJson(row.judgment_json) } : {},
+		...row.context_trace_id ? { contextTraceId: row.context_trace_id } : {},
+		finalizedAt: row.finalized_at
+	};
+}
+var TaskRunRepository = class {
+	create(input) {
+		const id = input.id ?? randomUUID();
+		const rootRunId = input.parentRunId ? this.require(input.parentRunId).rootRunId : id;
+		const now = input.now ?? Date.now();
+		return runSqliteWriteTransaction((db) => {
+			const attemptRow = db.prepare(`SELECT COALESCE(MAX(attempt), 0) + 1 AS attempt FROM task_runs
+         WHERE task_id = ? AND parent_run_id IS NULL`).get(input.taskId);
+			db.prepare(`INSERT INTO task_runs (
+          run_id, task_id, root_run_id, parent_run_id, attempt, status,
+          executor_kind, executor_ref_json, trigger_json, correlation_id,
+          causation_id, idempotency_key, contract_version, session_key,
+          queued_at, scheduled_at, retry_policy_json, retry_of_run_id, version
+        ) VALUES (?, ?, ?, ?, ?, 'queued', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)`).run(id, input.taskId, rootRunId, input.parentRunId ?? null, input.parentRunId ? 1 : attemptRow.attempt, input.executorKind, JSON.stringify(input.executorRef), JSON.stringify(input.trigger), input.correlationId, input.causationId ?? null, input.idempotencyKey, input.contractVersion, input.sessionKey ?? null, now, input.scheduledAt ?? null, JSON.stringify(input.retryPolicy ?? {}), input.retryOfRunId ?? null);
+			this.appendEvent(db, id, "task_run.created", {
+				executorKind: input.executorKind,
+				scheduledAt: input.scheduledAt
+			}, { kind: "system" }, now);
+			return this.require(id);
+		});
+	}
+	get(id) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM task_runs WHERE run_id = ?").get(id);
+		return row ? fromRow(row) : void 0;
+	}
+	require(id) {
+		const run = this.get(id);
+		if (!run) throw new Error(`TaskRun not found: ${id}`);
+		return run;
+	}
+	getByIdempotencyKey(key) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM task_runs WHERE idempotency_key = ?").get(key);
+		return row ? fromRow(row) : void 0;
+	}
+	getActiveRoot(taskId) {
+		const row = getSqliteDatabase().prepare(`SELECT * FROM task_runs WHERE task_id = ? AND parent_run_id IS NULL
+       AND status IN ('queued', 'running', 'waiting', 'verifying')
+       ORDER BY queued_at DESC LIMIT 1`).get(taskId);
+		return row ? fromRow(row) : void 0;
+	}
+	getLatestRoot(taskId) {
+		const row = getSqliteDatabase().prepare(`SELECT * FROM task_runs WHERE task_id = ? AND parent_run_id IS NULL
+       ORDER BY queued_at DESC LIMIT 1`).get(taskId);
+		return row ? fromRow(row) : void 0;
+	}
+	listByTask(taskId, limit = 100) {
+		return getSqliteDatabase().prepare(`SELECT * FROM task_runs WHERE task_id = ? ORDER BY queued_at DESC LIMIT ?`).all(taskId, Math.max(1, Math.min(500, Math.floor(limit)))).map(fromRow);
+	}
+	claimNext(input) {
+		const now = input.now ?? Date.now();
+		return runSqliteWriteTransaction((db) => {
+			const row = db.prepare(`SELECT * FROM task_runs
+         WHERE (
+           status = 'queued'
+           OR (status = 'waiting' AND NOT EXISTS (
+             SELECT 1 FROM task_waits wait
+             WHERE wait.task_run_id = task_runs.run_id AND wait.status = 'active'
+           ))
+         )
+           AND (? IS NULL OR executor_kind = ?)
+           AND COALESCE(scheduled_at, 0) <= ?
+           AND (lease_expires_at IS NULL OR lease_expires_at <= ?)
+         ORDER BY COALESCE(scheduled_at, queued_at), queued_at LIMIT 1`).get(input.executorKind ?? null, input.executorKind ?? null, now, now);
+			if (!row) return void 0;
+			return db.prepare(`UPDATE task_runs SET lease_owner = ?, lease_expires_at = ?, version = version + 1
+         WHERE run_id = ? AND version = ?
+           AND (lease_expires_at IS NULL OR lease_expires_at <= ?)`).run(input.owner, now + input.leaseMs, row.run_id, row.version, now).changes === 0 ? void 0 : this.get(row.run_id);
+		});
+	}
+	start(input) {
+		const now = input.now ?? Date.now();
+		return this.transition({
+			runId: input.runId,
+			expectedVersion: input.expectedVersion,
+			from: ["queued"],
+			to: "running",
+			fields: {
+				context_snapshot_id: input.contextSnapshotId,
+				policy_snapshot_json: JSON.stringify(input.policySnapshot),
+				session_key: input.sessionKey ?? null,
+				started_at: now,
+				heartbeat_at: now,
+				timeout_at: input.timeoutAt ?? null
+			},
+			actor: input.actor ?? { kind: "system" },
+			now
+		});
+	}
+	setStatus(input) {
+		return this.transition({
+			...input,
+			fields: input.to === "running" ? { heartbeat_at: input.now ?? Date.now() } : input.to === "waiting" ? {
+				lease_owner: null,
+				lease_expires_at: null
+			} : {},
+			actor: input.actor ?? { kind: "system" },
+			now: input.now ?? Date.now()
+		});
+	}
+	heartbeat(input) {
+		const now = input.now ?? Date.now();
+		return getSqliteDatabase().prepare(`UPDATE task_runs SET heartbeat_at = ?, lease_expires_at = ?, version = version + 1
+       WHERE run_id = ? AND lease_owner = ?
+         AND status IN ('running', 'waiting', 'verifying')`).run(now, now + input.leaseMs, input.runId, input.owner).changes === 0 ? void 0 : this.get(input.runId);
+	}
+	finalize(input) {
+		const now = input.now ?? Date.now();
+		return runSqliteWriteTransaction((db) => {
+			const run = this.get(input.runId);
+			if (!run || run.version !== input.expectedVersion || !ACTIVE_RUN_STATUSES.includes(run.status)) return;
+			if (db.prepare(`UPDATE task_runs SET status = ?, completed_at = ?, terminal_code = ?,
+         terminal_message = ?, lease_owner = NULL, lease_expires_at = NULL,
+         version = version + 1 WHERE run_id = ? AND version = ?`).run(input.receipt.status, now, input.terminalCode ?? null, input.terminalMessage ?? null, input.runId, input.expectedVersion).changes === 0) return void 0;
+			db.prepare(`INSERT INTO task_run_receipts (
+          run_id, status, summary, changes_json, evidence_json, verification_json,
+          remaining_work_json, next_action, needs_user, completion_verdict,
+          failure_json, judgment_json, context_trace_id, finalized_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.runId, input.receipt.status, input.receipt.summary, JSON.stringify(input.receipt.changes), JSON.stringify(input.receipt.evidence), JSON.stringify(input.receipt.verification), JSON.stringify(input.receipt.remainingWork), input.receipt.nextAction ?? null, input.receipt.needsUser ? 1 : 0, input.receipt.completionVerdict ?? null, input.receipt.failure ? JSON.stringify(input.receipt.failure) : null, input.receipt.judgment ? JSON.stringify(input.receipt.judgment) : null, input.receipt.contextTraceId ?? null, now);
+			this.appendEvent(db, input.runId, `task_run.${input.receipt.status}`, { completionVerdict: input.receipt.completionVerdict }, input.actor ?? { kind: "system" }, now);
+			return this.get(input.runId);
+		});
+	}
+	getReceipt(runId) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM task_run_receipts WHERE run_id = ?").get(runId);
+		return row ? receiptFromRow(row) : void 0;
+	}
+	listReceipts(taskId, limit = 100) {
+		return getSqliteDatabase().prepare(`SELECT receipt.* FROM task_run_receipts receipt
+       JOIN task_runs run ON run.run_id = receipt.run_id
+       WHERE run.task_id = ? ORDER BY receipt.finalized_at DESC LIMIT ?`).all(taskId, Math.max(1, Math.min(500, Math.floor(limit)))).map(receiptFromRow);
+	}
+	recordFeedback(input) {
+		this.require(input.runId);
+		const id = randomUUID();
+		const createdAt = input.now ?? Date.now();
+		getSqliteDatabase().prepare(`INSERT INTO task_run_feedback (
+        feedback_id, run_id, rating, reason, needs_correction, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?)`).run(id, input.runId, input.rating, input.reason?.trim() || null, input.rating === "not_helpful" ? 1 : 0, createdAt);
+		return {
+			id,
+			runId: input.runId,
+			rating: input.rating,
+			...input.reason?.trim() ? { reason: input.reason.trim() } : {},
+			createdAt
+		};
+	}
+	createWait(input) {
+		const id = randomUUID();
+		const now = input.now ?? Date.now();
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`INSERT INTO task_waits (
+          wait_id, task_id, task_run_id, kind, status, reason,
+          condition_json, resume_at, created_at
+        ) VALUES (?, ?, ?, ?, 'active', ?, ?, ?, ?)`).run(id, input.taskId, input.taskRunId ?? null, input.kind, input.reason.trim(), JSON.stringify(input.condition ?? {}), input.resumeAt ?? null, now);
+			if (input.taskRunId) this.appendEvent(db, input.taskRunId, "task_run.wait_created", {
+				waitId: id,
+				kind: input.kind,
+				reason: input.reason.trim(),
+				resumeAt: input.resumeAt
+			}, input.actor ?? { kind: "system" }, now);
+		});
+		return this.requireWait(id);
+	}
+	getWait(waitId) {
+		const row = getSqliteDatabase().prepare("SELECT * FROM task_waits WHERE wait_id = ?").get(waitId);
+		return row ? waitFromRow(row) : void 0;
+	}
+	requireWait(waitId) {
+		const wait = this.getWait(waitId);
+		if (!wait) throw new Error(`TaskWait not found: ${waitId}`);
+		return wait;
+	}
+	listActiveWaits(taskId) {
+		return getSqliteDatabase().prepare(`SELECT * FROM task_waits WHERE task_id = ? AND status = 'active'
+       ORDER BY created_at ASC`).all(taskId).map(waitFromRow);
+	}
+	resolveWait(input) {
+		const now = input.now ?? Date.now();
+		return runSqliteWriteTransaction((db) => {
+			const wait = this.getWait(input.waitId);
+			if (!wait || wait.status !== "active") return void 0;
+			if (db.prepare(`UPDATE task_waits SET status = 'resolved', resolved_by_json = ?,
+         resolution_json = ?, resolved_at = ? WHERE wait_id = ? AND status = 'active'`).run(JSON.stringify(input.actor), input.resolution === void 0 ? null : JSON.stringify(input.resolution), now, input.waitId).changes === 0) return void 0;
+			if (wait.taskRunId) this.appendEvent(db, wait.taskRunId, "task_run.wait_resolved", {
+				waitId: wait.id,
+				resolution: input.resolution
+			}, input.actor, now);
+			return this.getWait(input.waitId);
+		});
+	}
+	listEvents(runId) {
+		return getSqliteDatabase().prepare(`SELECT event_id, run_id, sequence, type, payload_json, actor_json, occurred_at
+       FROM task_run_events WHERE run_id = ? ORDER BY sequence`).all(runId).map((row) => ({
+			id: row.event_id,
+			runId: row.run_id,
+			sequence: row.sequence,
+			type: row.type,
+			payload: parseJson(row.payload_json),
+			actor: parseJson(row.actor_json),
+			occurredAt: row.occurred_at
+		}));
+	}
+	transition(input) {
+		const allowedColumns = new Set([
+			"context_snapshot_id",
+			"policy_snapshot_json",
+			"session_key",
+			"started_at",
+			"heartbeat_at",
+			"timeout_at",
+			"lease_owner",
+			"lease_expires_at"
+		]);
+		const entries = Object.entries(input.fields);
+		for (const [column] of entries) if (!allowedColumns.has(column)) throw new Error(`Unsupported TaskRun field: ${column}`);
+		return runSqliteWriteTransaction((db) => {
+			const placeholders = input.from.map(() => "?").join(", ");
+			const assignments = entries.map(([column]) => `${column} = ?`);
+			if (db.prepare(`UPDATE task_runs SET status = ?, ${assignments.length ? `${assignments.join(", ")}, ` : ""}
+         version = version + 1 WHERE run_id = ? AND version = ? AND status IN (${placeholders})`).run(input.to, ...entries.map(([, value]) => value), input.runId, input.expectedVersion, ...input.from).changes === 0) return void 0;
+			this.appendEvent(db, input.runId, `task_run.${input.to}`, {}, input.actor, input.now);
+			return this.get(input.runId);
+		});
+	}
+	appendEvent(db, runId, type, payload, actor, occurredAt) {
+		const row = db.prepare("SELECT COALESCE(MAX(sequence), 0) + 1 AS sequence FROM task_run_events WHERE run_id = ?").get(runId);
+		db.prepare(`INSERT INTO task_run_events (
+        event_id, run_id, sequence, type, payload_json, actor_json, occurred_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, row.sequence, type, JSON.stringify(payload), JSON.stringify(actor), occurredAt);
+	}
+};
+//#endregion
+export { TaskRunRepository };

package/dist/src/tasks/task-signal-service.d.ts

@@ -0,0 +1,8 @@
+export declare class TaskSignalService {
+    #private;
+    private readonly dispatch?;
+    constructor(dispatch?: () => void);
+    dependencyClosed(dependencyTaskId: string): number;
+    tick(now?: number): number;
+    private resolveAndResume;
+}

package/dist/src/tasks/task-signal-service.js

@@ -0,0 +1,72 @@
+import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import { TaskRepository } from "./task-repository.js";
+import { TaskRunRepository } from "./task-run-repository.js";
+import { TaskExecutorSelectionSchema } from "../../packages/gateway-contract/src/tasks.js";
+import { TaskApplicationService } from "./task-application-service.js";
+import { randomUUID } from "node:crypto";
+//#region src/tasks/task-signal-service.ts
+var TaskSignalService = class {
+	#runs = new TaskRunRepository();
+	#tasks = new TaskRepository();
+	#application = new TaskApplicationService();
+	constructor(dispatch) {
+		this.dispatch = dispatch;
+	}
+	dependencyClosed(dependencyTaskId) {
+		const rows = getSqliteDatabase().prepare(`SELECT wait_id FROM task_waits WHERE status = 'active' AND kind = 'dependency'
+       AND json_extract(condition_json, '$.dependsOnTaskId') = ?`).all(dependencyTaskId);
+		return this.resolveAndResume(rows.map((row) => row.wait_id), { dependencyTaskId });
+	}
+	tick(now = Date.now()) {
+		const rows = getSqliteDatabase().prepare(`SELECT wait_id FROM task_waits WHERE status = 'active'
+       AND kind IN ('scheduled_time', 'retry_backoff') AND resume_at <= ?`).all(now);
+		return this.resolveAndResume(rows.map((row) => row.wait_id), { resumedAt: now });
+	}
+	resolveAndResume(waitIds, resolution) {
+		const candidates = /* @__PURE__ */ new Map();
+		for (const waitId of waitIds) {
+			const wait = this.#runs.getWait(waitId);
+			if (!wait) continue;
+			candidates.set(wait.taskId, wait.condition.executor);
+			this.#runs.resolveWait({
+				waitId,
+				actor: {
+					kind: "system",
+					id: "task-signal"
+				},
+				resolution
+			});
+		}
+		let resumed = 0;
+		for (const [taskId, rawExecutor] of candidates) {
+			if (this.#runs.listActiveWaits(taskId).length > 0) continue;
+			const activeRun = this.#runs.getActiveRoot(taskId);
+			if (activeRun?.status === "waiting") {
+				resumed += 1;
+				continue;
+			}
+			if (activeRun) continue;
+			const task = this.#tasks.get(taskId);
+			const executor = TaskExecutorSelectionSchema.safeParse(rawExecutor);
+			if (!task || task.phase === "closed" || !executor.success) continue;
+			const result = this.#application.execute({
+				taskId,
+				expectedVersion: task.version,
+				idempotencyKey: randomUUID(),
+				command: {
+					type: "start",
+					executor: executor.data
+				},
+				actor: {
+					kind: "system",
+					id: "task-signal"
+				}
+			});
+			if (result.ok && result.runId) resumed += 1;
+		}
+		if (resumed > 0) this.dispatch?.();
+		return resumed;
+	}
+};
+//#endregion
+export { TaskSignalService };

package/dist/src/tasks/task-value-metrics-service.d.ts

@@ -0,0 +1,4 @@
+import type { TaskValueMetrics } from '@xopcai/gateway-contract';
+export declare class TaskValueMetricsService {
+    get(): TaskValueMetrics;
+}

package/dist/src/tasks/task-value-metrics-service.js

@@ -0,0 +1,78 @@
+import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import "../storage/sqlite/index.js";
+//#region src/tasks/task-value-metrics-service.ts
+function ratio(numerator, denominator) {
+	return denominator > 0 ? numerator / denominator : 0;
+}
+function count(value) {
+	return Number(value ?? 0);
+}
+var TaskValueMetricsService = class {
+	get() {
+		const weekStart = Date.now() - 10080 * 60 * 1e3;
+		const tasks = getSqliteDatabase().prepare(`WITH ranked_receipts AS (
+         SELECT receipt.*, run.task_id,
+                ROW_NUMBER() OVER (
+                  PARTITION BY run.task_id
+                  ORDER BY receipt.finalized_at DESC
+                ) AS rank
+         FROM task_run_receipts receipt
+         JOIN task_runs run ON run.run_id = receipt.run_id
+       ), latest_receipts AS (
+         SELECT * FROM ranked_receipts WHERE rank = 1
+       )
+       SELECT
+         COUNT(tasks.task_id) AS total,
+         SUM(CASE WHEN latest_receipts.completion_verdict = 'achieved' THEN 1 ELSE 0 END) AS achieved,
+         SUM(CASE WHEN latest_receipts.completion_verdict = 'partial' THEN 1 ELSE 0 END) AS partial,
+         SUM(CASE WHEN latest_receipts.completion_verdict = 'not_achieved' THEN 1 ELSE 0 END) AS not_achieved,
+         SUM(CASE WHEN EXISTS (
+           SELECT 1 FROM task_run_feedback feedback
+           JOIN task_runs feedback_run ON feedback_run.run_id = feedback.run_id
+           WHERE feedback_run.task_id = tasks.task_id AND feedback.needs_correction = 1
+         ) THEN 1 ELSE 0 END) AS user_corrected,
+         SUM(CASE WHEN tasks.phase = 'closed' AND tasks.resolution = 'done'
+                    AND latest_receipts.completion_verdict = 'achieved'
+                    AND json_extract(latest_receipts.verification_json, '$.status') = 'passed'
+                    AND NOT EXISTS (SELECT 1 FROM task_run_feedback feedback
+                      WHERE feedback.run_id = latest_receipts.run_id AND feedback.rating = 'not_helpful')
+                  THEN 1 ELSE 0 END) AS trusted,
+         SUM(CASE WHEN tasks.updated_at >= ?
+                    AND tasks.phase = 'closed' AND tasks.resolution = 'done'
+                    AND latest_receipts.completion_verdict = 'achieved'
+                    AND json_extract(latest_receipts.verification_json, '$.status') = 'passed'
+                    AND NOT EXISTS (SELECT 1 FROM task_run_feedback feedback
+                      WHERE feedback.run_id = latest_receipts.run_id AND feedback.rating = 'not_helpful')
+                  THEN 1 ELSE 0 END) AS weekly_trusted
+       FROM tasks
+       LEFT JOIN latest_receipts ON latest_receipts.task_id = tasks.task_id`).get(weekStart);
+		const taskTotal = count(tasks.total);
+		const achieved = count(tasks.achieved);
+		const userCorrected = count(tasks.user_corrected);
+		const trusted = count(tasks.trusted);
+		const weeklyTrustedProgress = count(tasks.weekly_trusted);
+		const weeklyActiveUsers = getSqliteDatabase().prepare(`SELECT 1 FROM sessions
+       WHERE COALESCE(last_interaction_at, updated_at) >= ?
+       LIMIT 1`).get(weekStart) !== void 0 ? 1 : 0;
+		return {
+			northStar: {
+				weeklyTrustedProgress,
+				weeklyActiveUsers,
+				trustedProgressPerWeeklyActiveUser: ratio(weeklyTrustedProgress, weeklyActiveUsers)
+			},
+			tasks: {
+				total: taskTotal,
+				achieved,
+				partial: count(tasks.partial),
+				notAchieved: count(tasks.not_achieved),
+				userCorrected,
+				achievementRate: ratio(achieved, taskTotal),
+				correctionRate: ratio(userCorrected, taskTotal),
+				trusted,
+				trustedRate: ratio(trusted, taskTotal)
+			}
+		};
+	}
+};
+//#endregion
+export { TaskValueMetricsService };

package/dist/src/tasks/task-workflow-coordinator.d.ts

@@ -0,0 +1,5 @@
+import type { WorkflowRunView } from '../workflows/domain/index.js';
+export declare class TaskWorkflowCoordinator {
+    #private;
+    handleTerminalRun(view: WorkflowRunView): void;
+}

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

@@ -0,0 +1,54 @@
+import { TaskRunRepository } from "./task-run-repository.js";
+import { TaskApplicationService } from "./task-application-service.js";
+//#region src/tasks/task-workflow-coordinator.ts
+var TaskWorkflowCoordinator = class {
+	#runs = new TaskRunRepository();
+	#application = new TaskApplicationService();
+	handleTerminalRun(view) {
+		const taskRunId = view.run.metadata?.taskRunId?.trim();
+		if (!taskRunId) return;
+		const run = this.#runs.get(taskRunId);
+		if (!run || ![
+			"running",
+			"waiting",
+			"verifying"
+		].includes(run.status)) return;
+		const succeeded = view.run.status === "succeeded";
+		const summary = view.run.result?.summary || view.run.error?.message || `Workflow ${view.run.status}`;
+		const workflowId = typeof run.executorRef.workflowId === "string" ? run.executorRef.workflowId : view.run.definitionId;
+		this.#application.completeRun({
+			runId: run.id,
+			expectedRunVersion: run.version,
+			terminalCode: succeeded ? void 0 : "workflow_failed",
+			terminalMessage: succeeded ? void 0 : summary,
+			receipt: {
+				status: succeeded ? "succeeded" : "failed",
+				summary,
+				changes: [],
+				evidence: [{
+					kind: "artifact",
+					title: `Workflow ${view.run.definitionId} ${view.run.status}`,
+					summary,
+					uri: `workflow:${view.run.id}`,
+					provenance: "tool",
+					strength: "observed",
+					observedAt: Date.now()
+				}],
+				verification: {
+					status: "unverified",
+					checks: []
+				},
+				remainingWork: succeeded ? [] : [workflowId],
+				needsUser: false,
+				completionVerdict: succeeded ? "achieved" : "not_achieved",
+				...succeeded ? {} : { failure: {
+					code: "workflow_failed",
+					phase: "workflow",
+					recoveryAction: "Retry the TaskRun"
+				} }
+			}
+		});
+	}
+};
+//#endregion
+export { TaskWorkflowCoordinator };

package/dist/src/tui/backends/embedded-backend.d.ts

@@ -66,11 +66,21 @@ export declare class EmbeddedBackend implements TuiBackend {
     }): Promise<{
         ok: boolean;
     }>;
-    steerChat(opts: {
+    submitChatInput(opts: {
         sessionKey: string;
         message: string;
+        delivery: 'next' | 'steer';
     }): Promise<{
         ok: boolean;
+        effectiveDelivery?: 'next' | 'steer';
+    }>;
+    getChatInputState(sessionKey: string): Promise<{
+        sessionKey: string;
+        revision: number;
+        inputs: {
+            id: string;
+            status: string;
+        }[];
     }>;
     loadHistory(opts: {
         sessionKey: string;

package/dist/src/tui/backends/embedded-backend.js

@@ -10,10 +10,10 @@ import { init_agent_scope, listAgentEntries, normalizeAgentId } from "../../agen
 import { loadConfig, saveConfig } from "../../config/loader.js";
 import { effectiveWorkspacePathForSession } from "../../session/session-workspace.js";
 import { createCreateShareTool, isShareToolAvailable } from "../../agent/tools/create-share-tool.js";
-import { setTuiDefaultAgentConfig } from "../../commands/agents.config.js";
 import { ProjectService } from "../../projects/project-service.js";
 import { inferSuggestedProjectDefaultAgentId } from "../../projects/project-agent-suggestion.js";
 import "../../projects/index.js";
+import { setTuiDefaultAgentConfig } from "../../commands/agents.config.js";
 import { evictEmbeddedSessionRunner } from "../../agent/embedded/session-runner.js";
 import { prependEnvelopeTimestamp } from "../../channels/envelope-timestamp.js";
 import { buildSessionTimeline } from "../../session/transcript-outline.js";
@@ -353,9 +353,35 @@ var EmbeddedBackend = class {
 		}
 		return { ok: false };
 	}
-	async steerChat(opts) {
+	async submitChatInput(opts) {
 		if (!this.agent) return { ok: false };
-		return { ok: await this.agent.turnDispatcher.steerWebchatSession(opts.sessionKey, opts.message) };
+		if (opts.delivery === "steer") {
+			const ok = await this.agent.turnDispatcher.steerWebchatSession(opts.sessionKey, opts.message);
+			return {
+				ok,
+				effectiveDelivery: ok ? "steer" : void 0
+			};
+		}
+		const { getEmbeddedRunBySessionKey } = await import("../../agent/embedded/runs.js");
+		const handle = getEmbeddedRunBySessionKey(opts.sessionKey);
+		if (!handle) return { ok: false };
+		await handle.session.followUp(opts.message);
+		return {
+			ok: true,
+			effectiveDelivery: "next"
+		};
+	}
+	async getChatInputState(sessionKey) {
+		const { getEmbeddedRunBySessionKey } = await import("../../agent/embedded/runs.js");
+		const handle = getEmbeddedRunBySessionKey(sessionKey);
+		return {
+			sessionKey,
+			revision: 0,
+			inputs: Array.from({ length: handle?.session.pendingMessageCount ?? 0 }, (_, index) => ({
+				id: String(index),
+				status: "queued"
+			}))
+		};
 	}
 	async loadHistory(opts) {
 		if (!this.agent) return { messages: [] };

package/dist/src/tui/backends/gateway-sse-backend.d.ts

@@ -1,6 +1,6 @@
 import type { ExportFormat } from '../../session/types.js';
 import type { SessionTimelineItem } from '../../session/transcript-outline.js';
-import type { ChatSendOptions, HistoryMessage, TuiBackend, TuiCompactionResult, TuiComposerHistoryItem, TuiEvent, TuiModelChoice, TuiShareRequest, TuiShareResult, TuiSessionStats, TuiSessionItem, TuiStartupResources, TuiTranscriptTreeEntry, TuiAgentInfo, TuiWorkspaceFileSearchEntry, TuiWorkflowRunStartRequest, TuiWorkflowRunStartResult, TuiStartupProjectResult } from '../tui-backend.js';
+import type { ChatSendOptions, HistoryMessage, TuiBackend, TuiCompactionResult, TuiChatInputState, TuiComposerHistoryItem, TuiEvent, TuiModelChoice, TuiShareRequest, TuiShareResult, TuiSessionStats, TuiSessionItem, TuiStartupResources, TuiTranscriptTreeEntry, TuiAgentInfo, TuiWorkspaceFileSearchEntry, TuiWorkflowRunStartRequest, TuiWorkflowRunStartResult, TuiStartupProjectResult } from '../tui-backend.js';
 import type { SessionInfo } from '../tui-types.js';
 import type { ReviewContext } from '../../review/review-git.js';
 import { type GatewayCredential } from '../../gateway/credential.js';
@@ -12,7 +12,7 @@ export declare function normalizeGatewaySseEvent(evt: TuiEvent): TuiEvent;
 /**
  * TUI backend that communicates with a running xopc gateway via HTTP + SSE.
  *
- * - Agent streaming: `POST /api/agent` with `Accept: text/event-stream`
+ * - Agent input: durable session input REST plus resumable run SSE
  * - Broadcast events: `GET /api/events` via long-lived SSE
  * - REST calls for sessions, models, etc.
  */
@@ -62,12 +62,15 @@ export declare class GatewaySseBackend implements TuiBackend {
     }): Promise<{
         ok: boolean;
     }>;
-    steerChat(opts: {
+    submitChatInput(opts: {
         sessionKey: string;
         message: string;
+        delivery: 'next' | 'steer';
     }): Promise<{
         ok: boolean;
+        effectiveDelivery?: 'next' | 'steer';
     }>;
+    getChatInputState(sessionKey: string): Promise<TuiChatInputState>;
     getStartupResources(sessionKey: string): Promise<TuiStartupResources>;
     loadHistory(opts: {
         sessionKey: string;