@xopcai/xopc 0.0.332 → 0.0.334

package/dist/src/storage/sqlite/session-creation-repository.d.ts

@@ -0,0 +1,50 @@
+import { type SessionCreation, type SessionInputCommand, type SessionMaterializeCommand, type SessionPreparationState } from '@xopcai/gateway-contract';
+import type { SessionAgentConfig } from '../../session/config-types.js';
+import { insertSessionInput } from './session-input-repository.js';
+export declare class SessionCommandError extends Error {
+    readonly code: 'IDEMPOTENCY_CONFLICT' | 'CONVERSATION_EXISTS' | 'SESSION_DELETED' | 'FORBIDDEN' | 'SESSION_CHANGED' | 'CONFIG_CHANGED' | 'NOT_FOUND' | 'BAD_REQUEST' | 'SESSION_BUSY' | 'QUEUE_FULL';
+    constructor(code: 'IDEMPOTENCY_CONFLICT' | 'CONVERSATION_EXISTS' | 'SESSION_DELETED' | 'FORBIDDEN' | 'SESSION_CHANGED' | 'CONFIG_CHANGED' | 'NOT_FOUND' | 'BAD_REQUEST' | 'SESSION_BUSY' | 'QUEUE_FULL', message: string);
+}
+export type SessionInputReceipt = {
+    conversationId: string;
+    clientMessageId: string;
+    principalId: string;
+    requestHash: string;
+    inputId: string | null;
+    transcriptId: string;
+    acceptedAt: number;
+};
+export type SessionPreparation = {
+    conversationId: string;
+    operationId: string;
+    creation: SessionCreation;
+    state: SessionPreparationState;
+    environmentId: string;
+    baseCommit: string | null;
+    revision: number;
+    leaseUntil: number;
+    lastError: string | null;
+};
+export declare function sessionCommandHash(command: SessionInputCommand | SessionMaterializeCommand): string;
+export declare function isConversationDeleted(conversationId: string): boolean;
+export declare function getSessionInputReceipt(conversationId: string, clientMessageId: string, principalId: string): SessionInputReceipt | undefined;
+export declare function matchSessionInputReceipt(conversationId: string, clientMessageId: string, principalId: string, hash: string): SessionInputReceipt | undefined;
+export declare function getSessionPreparation(conversationId: string): SessionPreparation | undefined;
+/** Commit the identity, configuration, input and replay receipt together. All preparation happens before entry. */
+export declare function acceptSessionCommand(input: {
+    conversationId: string;
+    principalId: string;
+    command: SessionInputCommand | SessionMaterializeCommand;
+    preparedInput?: Omit<Parameters<typeof insertSessionInput>[0], 'conversationId' | 'id' | 'clientMessageId' | 'expectedTranscriptId'>;
+    config?: SessionAgentConfig;
+    sourceChannel?: 'webchat' | 'tui';
+    attachProject?: (conversationId: string, projectId: string) => void;
+}): SessionInputReceipt;
+export declare function claimSessionPreparation(conversationId: string, now?: number): SessionPreparation | undefined;
+export declare function finishSessionPreparation(operation: SessionPreparation, error?: string): boolean;
+export declare function pendingSessionPreparations(): string[];
+export declare function retrySessionPreparation(conversationId: string, principalId: string, input: {
+    operationId: string;
+    expectedRevision: number;
+    idempotencyKey: string;
+}): SessionPreparation;

package/dist/src/storage/sqlite/session-creation-repository.js

@@ -0,0 +1,166 @@
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
+import { sessionCommandIdentity } from "../../../packages/gateway-contract/src/session-input-command.js";
+import { init_src } from "../../../packages/gateway-contract/src/index.js";
+import { init_session_input_repository, insertSessionInput } from "./session-input-repository.js";
+import { init_clarification_wait_repository, supersedeActiveClarification } from "./clarification-wait-repository.js";
+import { init_connection_wait_repository, invalidateConnectionResumeIntent } from "./connection-wait-repository.js";
+import { getSessionMetadata } from "./session-read-repository.js";
+import { init_session_repository } from "./session-repository.js";
+import { init_config_repository, setSessionConfig } from "./config-repository.js";
+import { createConversation, init_conversation_repository } from "./conversation-repository.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/storage/sqlite/session-creation-repository.ts
+init_src();
+init_conversation_repository();
+init_config_repository();
+init_session_repository();
+init_session_input_repository();
+init_connection_wait_repository();
+init_clarification_wait_repository();
+init_transaction();
+var SessionCommandError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+function sessionCommandHash(command) {
+	return createHash("sha256").update(sessionCommandIdentity(command)).digest("hex");
+}
+function isConversationDeleted(conversationId) {
+	return Boolean(getSqliteDatabase().prepare("SELECT 1 FROM session_tombstones WHERE conversation_id=?").get(conversationId));
+}
+function getSessionInputReceipt(conversationId, clientMessageId, principalId) {
+	const row = getSqliteDatabase().prepare(`SELECT conversation_id AS conversationId, client_message_id AS clientMessageId,
+    principal_id AS principalId, request_hash AS requestHash, input_id AS inputId,
+    transcript_id AS transcriptId, accepted_at AS acceptedAt FROM session_input_receipts
+    WHERE conversation_id=? AND client_message_id=?`).get(conversationId, clientMessageId);
+	if (row && row.principalId !== principalId) throw new SessionCommandError("FORBIDDEN", "Input belongs to another principal");
+	return row;
+}
+function matchSessionInputReceipt(conversationId, clientMessageId, principalId, hash) {
+	const receipt = getSessionInputReceipt(conversationId, clientMessageId, principalId);
+	if (receipt && receipt.requestHash !== hash) throw new SessionCommandError("IDEMPOTENCY_CONFLICT", "Input identity was reused with different content");
+	if (isConversationDeleted(conversationId)) throw new SessionCommandError("SESSION_DELETED", "Conversation was deleted");
+	return receipt;
+}
+function getSessionPreparation(conversationId) {
+	const row = getSqliteDatabase().prepare(`SELECT conversation_id AS conversationId, operation_id AS operationId,
+    creation_json AS creationJson, state, environment_id AS environmentId, base_commit AS baseCommit,
+    revision, lease_until AS leaseUntil, last_error AS lastError FROM session_preparations WHERE conversation_id=?`).get(conversationId);
+	if (!row) return void 0;
+	const { creationJson, ...rest } = row;
+	return {
+		...rest,
+		creation: JSON.parse(creationJson)
+	};
+}
+/** Commit the identity, configuration, input and replay receipt together. All preparation happens before entry. */
+function acceptSessionCommand(input) {
+	return runSqliteWriteTransaction((db) => {
+		const { conversationId, command, principalId } = input;
+		const clientMessageId = "commandId" in command ? command.commandId : command.clientMessageId;
+		const requestHash = sessionCommandHash(command);
+		const existing = matchSessionInputReceipt(conversationId, clientMessageId, principalId, requestHash);
+		if (existing) return existing;
+		if ("input" in command !== Boolean(input.preparedInput)) throw new SessionCommandError("BAD_REQUEST", "Prepared input is required for input commands only");
+		const pending = db.prepare(`SELECT count(*) AS count FROM session_inputs WHERE conversation_id=?
+      AND status IN ('queued','running','injecting','interrupted')`).get(conversationId);
+		if (input.preparedInput && pending.count >= 10) throw new SessionCommandError("QUEUE_FULL", "Input queue is full");
+		const creation = "creation" in command ? command.creation : void 0;
+		let session = getSessionMetadata(conversationId);
+		if (creation) {
+			if (session) throw new SessionCommandError("CONVERSATION_EXISTS", "Conversation already exists");
+			session = createConversation({
+				agentId: creation.agentId,
+				sourceChannel: input.sourceChannel ?? "webchat",
+				sourceChatId: conversationId,
+				sessionType: "chat",
+				hiddenFromSessionList: !input.preparedInput,
+				routing: {
+					agentId: creation.agentId,
+					source: input.sourceChannel ?? "webchat",
+					accountId: "default",
+					peerKind: "direct",
+					peerId: conversationId
+				}
+			}, "", conversationId);
+			setSessionConfig(conversationId, input.config ?? {
+				modelOverride: creation.model,
+				fixedModel: true,
+				thinkingLevel: creation.thinkingLevel,
+				userContextMode: creation.temporary ? "temporary" : "enabled"
+			}, "");
+			if (creation.projectId) {
+				if (!input.attachProject) throw new Error("Project attachment is required");
+				input.attachProject(conversationId, creation.projectId);
+			}
+			if (creation.execution) db.prepare(`INSERT INTO session_preparations
+        (conversation_id,operation_id,creation_json,state,environment_id,created_at,updated_at)
+        VALUES (?,?,?,'preparing',?,?,?)`).run(conversationId, randomUUID(), JSON.stringify(creation), randomUUID(), Date.now(), Date.now());
+		} else {
+			if (!session) throw new SessionCommandError("NOT_FOUND", "Conversation not found");
+			if (!("kind" in command) || command.kind !== "append" || command.expectedTranscriptId !== session.transcriptId) throw new SessionCommandError("SESSION_CHANGED", "Conversation transcript changed");
+			if ((db.prepare("SELECT updated_at FROM session_config WHERE conversation_id=?").get(conversationId)?.updated_at ?? 0) !== command.configVersion) throw new SessionCommandError("CONFIG_CHANGED", "Model configuration changed");
+		}
+		const transcriptId = session.transcriptId;
+		const inputId = input.preparedInput ? randomUUID() : null;
+		if (input.preparedInput && inputId) insertSessionInput({
+			...input.preparedInput,
+			conversationId,
+			id: inputId,
+			clientMessageId,
+			expectedTranscriptId: transcriptId
+		});
+		if (inputId) {
+			invalidateConnectionResumeIntent(conversationId);
+			supersedeActiveClarification(conversationId);
+		}
+		const receipt = {
+			conversationId,
+			clientMessageId,
+			principalId,
+			requestHash,
+			inputId,
+			transcriptId,
+			acceptedAt: Date.now()
+		};
+		db.prepare(`INSERT INTO session_input_receipts
+      (conversation_id,client_message_id,principal_id,request_hash,input_id,transcript_id,accepted_at)
+      VALUES (?,?,?,?,?,?,?)`).run(conversationId, clientMessageId, principalId, requestHash, inputId, transcriptId, receipt.acceptedAt);
+		return receipt;
+	});
+}
+function claimSessionPreparation(conversationId, now = Date.now()) {
+	return runSqliteWriteTransaction((db) => {
+		return db.prepare(`UPDATE session_preparations SET lease_until=?,revision=revision+1,updated_at=?
+      WHERE conversation_id=? AND state='preparing' AND lease_until<=?`).run(now + 6e4, now, conversationId, now).changes ? getSessionPreparation(conversationId) : void 0;
+	});
+}
+function finishSessionPreparation(operation, error) {
+	return runSqliteWriteTransaction((db) => Boolean(db.prepare(`UPDATE session_preparations
+    SET state=?,last_error=?,lease_until=0,revision=revision+1,updated_at=?
+    WHERE conversation_id=? AND operation_id=? AND revision=? AND state='preparing'`).run(error ? "preparation_failed" : "ready", error ?? null, Date.now(), operation.conversationId, operation.operationId, operation.revision).changes));
+}
+function pendingSessionPreparations() {
+	return getSqliteDatabase().prepare("SELECT conversation_id FROM session_preparations WHERE state='preparing' AND lease_until<=?").all(Date.now()).map((row) => row.conversation_id);
+}
+function retrySessionPreparation(conversationId, principalId, input) {
+	return runSqliteWriteTransaction((db) => {
+		if (isConversationDeleted(conversationId)) throw new SessionCommandError("SESSION_DELETED", "Conversation was deleted");
+		const operation = getSessionPreparation(conversationId);
+		if (!operation) throw new SessionCommandError("NOT_FOUND", "Preparation not found");
+		if (db.prepare("SELECT principal_id FROM session_input_receipts WHERE conversation_id=? ORDER BY accepted_at LIMIT 1").get(conversationId)?.principal_id !== principalId) throw new SessionCommandError("FORBIDDEN", "Preparation belongs to another principal");
+		const previous = db.prepare("SELECT * FROM session_preparation_retries WHERE conversation_id=? AND idempotency_key=?").get(conversationId, input.idempotencyKey);
+		if (previous) {
+			if (previous.operation_id !== input.operationId || previous.expected_revision !== input.expectedRevision || previous.principal_id !== principalId) throw new SessionCommandError("IDEMPOTENCY_CONFLICT", "Retry identity was reused");
+			return operation;
+		}
+		if (!db.prepare(`UPDATE session_preparations SET state='preparing', revision=revision+1,
+      lease_until=0,last_error=NULL,updated_at=? WHERE conversation_id=? AND operation_id=? AND revision=? AND state='preparation_failed'`).run(Date.now(), conversationId, input.operationId, input.expectedRevision).changes) throw new SessionCommandError("SESSION_CHANGED", "Preparation state changed");
+		db.prepare("INSERT INTO session_preparation_retries VALUES (?,?,?,?,?)").run(conversationId, input.idempotencyKey, input.operationId, input.expectedRevision, principalId);
+		return getSessionPreparation(conversationId);
+	});
+}
+//#endregion
+export { SessionCommandError, acceptSessionCommand, claimSessionPreparation, finishSessionPreparation, getSessionInputReceipt, getSessionPreparation, isConversationDeleted, matchSessionInputReceipt, pendingSessionPreparations, retrySessionPreparation, sessionCommandHash };

package/dist/src/storage/sqlite/session-input-repository.d.ts

@@ -1,5 +1,6 @@
 import { getSqliteDatabase } from './transaction.js';
 import { type TurnOrigin } from '@xopcai/endpoint-tools-protocol';
+import type { SessionPreparationView } from '@xopcai/gateway-contract';
 import type { AgentSourceContext, SourceContextRefSummary } from '../../agent/source-context/types.js';
 export type SessionInputDelivery = 'next' | 'steer';
 export type SessionInputStatus = 'queued' | 'running' | 'injecting' | 'completed' | 'cancelled' | 'failed' | 'interrupted' | 'suspended';
@@ -38,6 +39,7 @@ export type SessionInput = {
     updatedAtMs: number;
 };
 export type SessionInputState = {
+    preparation?: SessionPreparationView;
     conversationId: string;
     revision: number;
     activeRunId?: string;
@@ -51,6 +53,14 @@ export declare function listActiveSessionInputRuns(): Array<{
     conversationId: string;
     runId: string;
 }>;
+/** Durable active runs with the claimed input metadata needed by runtime policy surfaces. */
+export declare function listActiveSessionInputExecutions(): Array<{
+    conversationId: string;
+    runId: string;
+    origin: TurnOrigin;
+    taskRunId?: string;
+    startedAt: number;
+}>;
 export declare function findSessionInput(conversationId: string, clientMessageId: string): SessionInput | undefined;
 export declare function getSessionInputById(conversationId: string, id: string): SessionInput | undefined;
 export declare class SessionInstanceChangedError extends Error {
@@ -75,8 +85,8 @@ export declare function insertSessionInput(input: {
     origin: TurnOrigin;
     targetRunId?: string;
 }): SessionInput;
-export declare function claimNextSessionInput(conversationId: string, runId: string): SessionInput | undefined;
-export declare function finishSessionInputRun(conversationId: string, runId: string, status: 'completed' | 'failed' | 'cancelled' | 'suspended', error?: string): boolean;
+export declare function claimNextSessionInput(conversationId: string, runId: string, expectedInputId?: string): SessionInput | undefined;
+export declare function finishSessionInputRun(conversationId: string, runId: string, status: 'completed' | 'failed' | 'cancelled' | 'suspended' | 'interrupted', error?: string): boolean;
 export declare function setSessionInputStatus(id: string, status: SessionInputStatus, patch?: {
     effectiveDelivery?: SessionInputDelivery;
     targetRunId?: string | null;

package/dist/src/storage/sqlite/session-input-repository.js

@@ -42,12 +42,14 @@ function bumpSessionInputRevision(db, conversationId) {
 }
 function getSessionInputState(conversationId) {
 	const db = getSqliteDatabase();
+	const preparation = db.prepare("SELECT operation_id AS operationId, revision, state, last_error AS lastError FROM session_preparations WHERE conversation_id=?").get(conversationId);
 	const runtime = db.prepare(`SELECT revision, active_run_id, active_input_id
     FROM session_input_runtime WHERE conversation_id = ?`).get(conversationId);
 	const rows = db.prepare(`${SELECT_INPUTS} WHERE conversation_id = ? AND status IN
     ('queued','running','injecting','interrupted') ORDER BY position, created_at_ms, id`).all(conversationId);
 	return {
 		conversationId,
+		...preparation ? { preparation } : {},
 		revision: runtime?.revision ?? 0,
 		activeRunId: runtime?.active_run_id ?? void 0,
 		activeInputId: runtime?.active_input_id ?? void 0,
@@ -65,6 +67,23 @@ function listActiveSessionInputRuns() {
 		runId: row.active_run_id
 	}));
 }
+/** Durable active runs with the claimed input metadata needed by runtime policy surfaces. */
+function listActiveSessionInputExecutions() {
+	return getSqliteDatabase().prepare(`SELECT runtime.conversation_id, runtime.active_run_id,
+      input.origin_json, input.task_run_id, input.updated_at_ms
+    FROM session_input_runtime runtime
+    LEFT JOIN session_inputs input ON input.id = runtime.active_input_id
+    WHERE runtime.active_run_id IS NOT NULL`).all().map((row) => ({
+		conversationId: row.conversation_id,
+		runId: row.active_run_id,
+		origin: row.origin_json ? turnOriginSchema.parse(JSON.parse(row.origin_json)) : {
+			type: "system",
+			source: "internal"
+		},
+		...row.task_run_id ? { taskRunId: row.task_run_id } : {},
+		startedAt: row.updated_at_ms ?? Date.now()
+	}));
+}
 function findSessionInput(conversationId, clientMessageId) {
 	const row = getSqliteDatabase().prepare(`${SELECT_INPUTS} WHERE conversation_id = ? AND client_message_id = ?`).get(conversationId, clientMessageId);
 	return row ? mapInput(row) : void 0;
@@ -90,8 +109,11 @@ function insertSessionInput(input) {
 		return mapInput(db.prepare(`${SELECT_INPUTS} WHERE id = ?`).get(input.id));
 	});
 }
-function claimNextSessionInput(conversationId, runId) {
+function claimNextSessionInput(conversationId, runId, expectedInputId) {
 	return runSqliteWriteTransaction((db) => {
+		const preparation = db.prepare("SELECT state FROM session_preparations WHERE conversation_id=?").get(conversationId);
+		if (preparation && preparation.state !== "ready") return void 0;
+		if (db.prepare("SELECT 1 FROM session_tombstones WHERE conversation_id=?").get(conversationId)) return void 0;
 		ensureRuntime(db, conversationId);
 		if (db.prepare(`SELECT active_run_id FROM session_input_runtime WHERE conversation_id = ?`).get(conversationId).active_run_id) return void 0;
 		if (db.prepare(`UPDATE session_inputs SET status = 'interrupted', error = 'Session changed before delivery',
@@ -100,6 +122,7 @@ function claimNextSessionInput(conversationId, runId) {
 		const row = db.prepare(`${SELECT_INPUTS} WHERE conversation_id = ? AND effective_delivery = 'next'
       AND status = 'queued' ORDER BY position, created_at_ms, id LIMIT 1`).get(conversationId);
 		if (!row) return void 0;
+		if (expectedInputId && row.id !== expectedInputId) return void 0;
 		const now = Date.now();
 		db.prepare(`UPDATE session_inputs SET status = 'running', run_id = ?, version = version + 1,
       updated_at_ms = ? WHERE id = ?`).run(runId, now, row.id);
@@ -188,4 +211,4 @@ var init_session_input_repository = __esmMin((() => {
 }));
 //#endregion
 init_session_input_repository();
-export { SessionInstanceChangedError, bumpSessionInputRevision, cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, init_session_input_repository, insertSessionInput, listActiveSessionInputRuns, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus };
+export { SessionInstanceChangedError, bumpSessionInputRevision, cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, init_session_input_repository, insertSessionInput, listActiveSessionInputExecutions, listActiveSessionInputRuns, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus };

package/dist/src/storage/sqlite/session-read-repository.d.ts

@@ -1,7 +1,7 @@
 import type { DatabaseSync } from 'node:sqlite';
 import type { SessionMetadata } from '../../session/types.js';
 import { type SessionRow } from './row-mappers.js';
-export declare const SESSION_COLUMNS = "\n  s.conversation_id, s.agent_id, s.active_transcript_id, s.status, s.name, s.tags_json,\n  s.created_at, s.updated_at, s.last_accessed_at, s.session_started_at, s.last_interaction_at,\n  s.source_channel, s.source_chat_id, s.session_type, s.hidden_from_session_list,\n  s.parent_conversation_id, s.workflow_run_id, s.workflow_definition_id, s.workflow_agent_id, s.workflow_agent_label,\n  s.project_id, s.routing_json, s.custom_data_json,\n  s.message_count, s.estimated_tokens, s.compacted_count,\n  s.last_flushed_at, s.flush_count,\n  s.thinking_level, s.verbose_level,\n  t.cwd AS cwd\n";
+export declare const SESSION_COLUMNS = "\n  s.conversation_id, s.agent_id, s.active_transcript_id, s.status, s.name, s.tags_json,\n  s.created_at, s.updated_at, s.last_accessed_at, s.session_started_at, s.last_interaction_at,\n  s.source_channel, s.source_chat_id, s.session_type, s.hidden_from_session_list,\n  s.parent_conversation_id, s.workflow_run_id, s.workflow_definition_id, s.workflow_agent_id, s.workflow_agent_label,\n  s.project_id, s.routing_json, s.custom_data_json,\n  s.message_count, s.estimated_tokens, s.compacted_count,\n  s.last_flushed_at, s.flush_count,\n  t.cwd AS cwd\n";
 export declare const SESSION_FROM_JOIN = "\n  FROM sessions s\n  LEFT JOIN transcripts t ON t.transcript_id = s.active_transcript_id\n";
 export declare function readSessionRow(db: DatabaseSync, conversationId: string): SessionRow | undefined;
 /** Read metadata without importing session lifecycle operations. */

package/dist/src/storage/sqlite/session-read-repository.js

@@ -22,7 +22,6 @@ var init_session_read_repository = __esmMin((() => {
   s.project_id, s.routing_json, s.custom_data_json,
   s.message_count, s.estimated_tokens, s.compacted_count,
   s.last_flushed_at, s.flush_count,
-  s.thinking_level, s.verbose_level,
   t.cwd AS cwd
 `;
 	SESSION_FROM_JOIN = `

package/dist/src/storage/sqlite/session-repository.d.ts

@@ -21,10 +21,6 @@ export declare function resetSessionRecord(conversationId: string, cwd: string):
 } | null;
 export declare function deleteSessionRecord(conversationId: string): boolean;
 export declare function listSessionsByAgent(agentId: string): SessionMetadata[];
-export declare function getSessionPersistedLevels(conversationId: string): {
-    thinkingLevel: string | null;
-    verboseLevel: string | null;
-} | null;
 export declare function findConversationIdByTranscriptId(transcriptId: string): string | null;
 export declare function getGlobalSessionStats(): ReturnType<typeof buildGlobalSessionStats>;
 export declare function resolveSessionAgentId(conversationId: string): string;

package/dist/src/storage/sqlite/session-repository.js

@@ -4,6 +4,7 @@ import { validateConversationId, validateTranscriptId } from "../../../packages/
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { init_session_instance_repository, readCurrentTranscriptId } from "./session-instance-repository.js";
 import { buildDefaultSessionMetadata, init_session_metadata } from "./session-metadata.js";
+import { init_timestamps, optionalTimestampToMs } from "./timestamps.js";
 import { buildGlobalSessionStats, init_row_mappers, metadataToSessionInsert, sessionRowToMetadata } from "./row-mappers.js";
 import { cancelConnectionObjective, init_connection_wait_repository } from "./connection-wait-repository.js";
 import { init_changes, notifyUserContextChange } from "../../user-context/changes.js";
@@ -21,17 +22,15 @@ function insertSessionAndTranscript(db, conversationId, transcriptId, cwd, metad
       parent_conversation_id, workflow_run_id, workflow_definition_id, workflow_agent_id, workflow_agent_label,
       project_id, routing_json, custom_data_json,
       message_count, estimated_tokens, compacted_count,
-      last_flushed_at, flush_count,
-      thinking_level, verbose_level
+      last_flushed_at, flush_count
     ) VALUES (
       ?, ?, ?, ?, ?,
       ?, ?, ?, ?, ?,
       ?, ?, ?, ?,
       ?, ?, ?, ?, ?,
       ?, ?, ?,
-      ?, ?, ?, ?, ?, ?,
-      ?, ?
-    )`).run(row.conversationId, row.agentId, row.transcriptId, row.status, row.name, row.tagsJson, row.createdAt, row.updatedAt, row.lastAccessedAt, row.sessionStartedAt, row.lastInteractionAt, row.sourceChannel, row.sourceChatId, row.sessionType, row.hiddenFromSessionList, row.parentConversationId, row.workflowRunId, row.workflowDefinitionId, row.workflowAgentId, row.workflowAgentLabel, row.projectId, row.routingJson, row.customDataJson, row.messageCount, row.estimatedTokens, row.compactedCount, row.lastFlushedAt, row.flushCount, row.thinkingLevel, row.verboseLevel);
+      ?, ?, ?, ?, ?, ?
+    )`).run(row.conversationId, row.agentId, row.transcriptId, row.status, row.name, row.tagsJson, row.createdAt, row.updatedAt, row.lastAccessedAt, row.sessionStartedAt, row.lastInteractionAt, row.sourceChannel, row.sourceChatId, row.sessionType, row.hiddenFromSessionList, row.parentConversationId, row.workflowRunId, row.workflowDefinitionId, row.workflowAgentId, row.workflowAgentLabel, row.projectId, row.routingJson, row.customDataJson, row.messageCount, row.estimatedTokens, row.compactedCount, row.lastFlushedAt, row.flushCount);
 	const now = Date.now();
 	db.prepare(`INSERT INTO transcripts (transcript_id, conversation_id, status, created_at, cwd)
      VALUES (?, ?, 'active', ?, ?)`).run(transcriptId, conversationId, now, cwd);
@@ -224,10 +223,8 @@ function patchSessionMetadata(conversationId, updates) {
         estimated_tokens = ?,
         compacted_count = ?,
         last_flushed_at = ?,
-        flush_count = ?,
-        thinking_level = ?,
-        verbose_level = ?
-      WHERE conversation_id = ?`).run(merged.status, merged.name ?? null, JSON.stringify(merged.tags ?? []), Date.parse(merged.updatedAt) || now, Date.parse(merged.lastAccessedAt) || now, merged.sessionStartedAt ? Date.parse(merged.sessionStartedAt) : existing.session_started_at, merged.lastInteractionAt ? Date.parse(merged.lastInteractionAt) : existing.last_interaction_at, merged.sourceChannel, merged.sourceChatId, merged.sessionType, merged.hiddenFromSessionList ? 1 : 0, merged.parentConversationId ?? null, merged.workflowRunId ?? null, merged.workflowDefinitionId ?? null, merged.workflowAgentId ?? null, merged.workflowAgentLabel ?? null, merged.projectId ?? null, merged.routing ? JSON.stringify(merged.routing) : null, merged.customData ? JSON.stringify(merged.customData) : null, merged.messageCount, merged.estimatedTokens, merged.compactedCount, merged.lastFlushedAt ?? null, merged.flushCount ?? 0, existing.thinking_level, existing.verbose_level, conversationId);
+        flush_count = ?
+      WHERE conversation_id = ?`).run(merged.status, merged.name ?? null, JSON.stringify(merged.tags ?? []), Date.parse(merged.updatedAt) || now, Date.parse(merged.lastAccessedAt) || now, merged.sessionStartedAt ? Date.parse(merged.sessionStartedAt) : existing.session_started_at, merged.lastInteractionAt ? Date.parse(merged.lastInteractionAt) : existing.last_interaction_at, merged.sourceChannel, merged.sourceChatId, merged.sessionType, merged.hiddenFromSessionList ? 1 : 0, merged.parentConversationId ?? null, merged.workflowRunId ?? null, merged.workflowDefinitionId ?? null, merged.workflowAgentId ?? null, merged.workflowAgentLabel ?? null, merged.projectId ?? null, merged.routing ? JSON.stringify(merged.routing) : null, merged.customData ? JSON.stringify(merged.customData) : null, merged.messageCount, merged.estimatedTokens, merged.compactedCount, optionalTimestampToMs(merged.lastFlushedAt), merged.flushCount ?? 0, conversationId);
 		const row = readSessionRow(db, conversationId);
 		if (!row) throw new Error(`Session not found after patch: ${conversationId}`);
 		return sessionRowToMetadata(conversationId, row);
@@ -308,14 +305,6 @@ function listSessionsByAgent(agentId) {
        WHERE s.agent_id = ?
        ORDER BY s.updated_at DESC`).all(agentId.toLowerCase()).map((row) => sessionRowToMetadata(row.conversation_id, row));
 }
-function getSessionPersistedLevels(conversationId) {
-	const row = getSqliteDatabase().prepare(`SELECT thinking_level, verbose_level FROM sessions WHERE conversation_id = ?`).get(conversationId);
-	if (!row) return null;
-	return {
-		thinkingLevel: row.thinking_level,
-		verboseLevel: row.verbose_level
-	};
-}
 function findConversationIdByTranscriptId(transcriptId) {
 	return getSqliteDatabase().prepare(`SELECT conversation_id FROM sessions WHERE active_transcript_id = ?`).get(transcriptId)?.conversation_id ?? null;
 }
@@ -335,6 +324,7 @@ var init_session_repository = __esmMin((() => {
 	init_session_metadata();
 	init_session_instance_repository();
 	init_row_mappers();
+	init_timestamps();
 	init_transaction();
 	init_session_identity_sql();
 	init_fts();
@@ -342,4 +332,4 @@ var init_session_repository = __esmMin((() => {
 }));
 //#endregion
 init_session_repository();
-export { deleteSessionRecord, ensureSessionInTransaction, ensureSessionRecord, findConversationIdByTranscriptId, getCurrentTranscriptId, getGlobalSessionStats, getSessionMetadata, getSessionPersistedLevels, incrementSessionStatsOnAppend, init_session_repository, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, readCurrentTranscriptId, resetSessionRecord, resolveSessionAgentId, updateSessionStats };
+export { deleteSessionRecord, ensureSessionInTransaction, ensureSessionRecord, findConversationIdByTranscriptId, getCurrentTranscriptId, getGlobalSessionStats, getSessionMetadata, incrementSessionStatsOnAppend, init_session_repository, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, readCurrentTranscriptId, resetSessionRecord, resolveSessionAgentId, updateSessionStats };

package/dist/src/storage/sqlite/timestamps.d.ts

@@ -0,0 +1,4 @@
+export declare function timestampToMs(value: string): number;
+export declare function optionalTimestampToMs(value: string | undefined): number | null;
+export declare function timestampToIso(value: number): string;
+export declare function optionalTimestampToIso(value: number | null): string | undefined;

package/dist/src/storage/sqlite/timestamps.js

@@ -0,0 +1,20 @@
+import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
+//#region src/storage/sqlite/timestamps.ts
+function timestampToMs(value) {
+	const timestamp = Date.parse(value);
+	if (!Number.isFinite(timestamp)) throw new Error(`Invalid ISO timestamp: ${value}`);
+	return timestamp;
+}
+function optionalTimestampToMs(value) {
+	return value === void 0 ? null : timestampToMs(value);
+}
+function timestampToIso(value) {
+	return new Date(value).toISOString();
+}
+function optionalTimestampToIso(value) {
+	return value === null ? void 0 : timestampToIso(value);
+}
+var init_timestamps = __esmMin((() => {}));
+//#endregion
+init_timestamps();
+export { init_timestamps, optionalTimestampToIso, optionalTimestampToMs, timestampToIso, timestampToMs };

package/dist/src/storage/sqlite/transcript-repository.d.ts

@@ -52,6 +52,7 @@ export declare function paginateTranscriptMessages(conversationId: string, optio
     total: number;
     startSeq: number;
     endSeq: number;
+    revision: number;
 };
 export declare function listCompactionBoundaries(conversationId: string): CompactionBoundarySummary[];
 export declare function restoreBeforeCompactionBoundary(conversationId: string, compactionId: string): void;

package/dist/src/storage/sqlite/transcript-repository.js

@@ -50,24 +50,27 @@ function withSessionInputContextMetadata(db, conversationId, row) {
 	const turnId = typeof message.turnId === "string" ? message.turnId.trim() : "";
 	if (!turnId) return row;
 	const metadata = message.metadata && typeof message.metadata === "object" && !Array.isArray(message.metadata) ? message.metadata : {};
-	if (Array.isArray(metadata.sourceContexts) && metadata.sourceContexts.length > 0) return row;
-	const input = db.prepare(`SELECT context_refs_json FROM session_inputs
-     WHERE conversation_id = ? AND run_id = ? AND context_refs_json IS NOT NULL
+	const input = db.prepare(`SELECT client_message_id, context_refs_json FROM session_inputs
+     WHERE conversation_id = ? AND run_id = ?
      LIMIT 1`).get(conversationId, turnId);
 	if (!input) return row;
+	let sourceContexts = metadata.sourceContexts;
 	try {
-		const sourceContexts = JSON.parse(input.context_refs_json);
-		if (!Array.isArray(sourceContexts) || sourceContexts.length === 0) return row;
-		return {
-			...message,
-			metadata: {
-				...metadata,
-				sourceContexts
-			}
-		};
+		if ((!Array.isArray(sourceContexts) || sourceContexts.length === 0) && input.context_refs_json) {
+			const parsed = JSON.parse(input.context_refs_json);
+			if (Array.isArray(parsed) && parsed.length > 0) sourceContexts = parsed;
+		}
 	} catch {
-		return row;
+		sourceContexts = metadata.sourceContexts;
 	}
+	return {
+		...message,
+		metadata: {
+			...metadata,
+			clientMessageId: input.client_message_id,
+			...Array.isArray(sourceContexts) && sourceContexts.length > 0 ? { sourceContexts } : {}
+		}
+	};
 }
 function appendTranscriptEntry(conversationId, row, opts) {
 	if (isRuntimeOnlyTranscriptMessage(row)) throw new Error("Runtime-only messages cannot be persisted in a session transcript");
@@ -281,7 +284,8 @@ function paginateTranscriptMessages(conversationId, options = {}) {
 		messages: [],
 		total: 0,
 		startSeq: 0,
-		endSeq: 0
+		endSeq: 0,
+		revision: 0
 	};
 	const db = getSqliteDatabase();
 	const kinds = options.includeContext ? ["message", "context"] : ["message"];
@@ -293,6 +297,9 @@ function paginateTranscriptMessages(conversationId, options = {}) {
        FROM transcript_entries e
        JOIN transcripts t ON t.transcript_id = e.transcript_id
        WHERE ${transcriptWhere} AND e.entry_kind IN (${kindPlaceholders})`).get(transcriptArg, ...kinds).total;
+	const revisionRow = db.prepare(`SELECT COALESCE(MAX(seq), 0) AS revision
+     FROM transcript_entries
+     WHERE transcript_id = ? AND entry_kind IN (${kindPlaceholders})`).get(transcriptId, ...kinds);
 	const limit = Math.min(200, Math.max(1, Math.trunc(options.limit ?? 50)));
 	const offset = Math.max(0, Math.trunc(options.offset ?? 0));
 	let rows;
@@ -324,7 +331,8 @@ function paginateTranscriptMessages(conversationId, options = {}) {
 		messages: buildSessionContextForLlm(storedRows),
 		total,
 		startSeq: rows[0]?.seq ?? 0,
-		endSeq: rows[rows.length - 1]?.seq ?? 0
+		endSeq: rows[rows.length - 1]?.seq ?? 0,
+		revision: revisionRow.revision
 	};
 }
 function listCompactionBoundaries(conversationId) {

package/dist/src/storage/sqlite/user-trust-repository.js

@@ -1,12 +1,13 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
 import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "./transaction.js";
+import { init_timestamps, timestampToIso } from "./timestamps.js";
 import { DEFAULT_USER_TRUST_LEVEL, init_trust_policy, isUserTrustLevel } from "../../user-context/trust-policy.js";
 //#region src/storage/sqlite/user-trust-repository.ts
 function fromRow(row) {
 	return {
 		principalId: row.principal_id,
 		defaultActionLevel: isUserTrustLevel(row.default_action_level) ? row.default_action_level : DEFAULT_USER_TRUST_LEVEL,
-		updatedAt: row.updated_at
+		updatedAt: timestampToIso(row.updated_at)
 	};
 }
 function getUserTrustPolicy(principalId = "local-owner") {
@@ -17,7 +18,7 @@ function getUserTrustPolicy(principalId = "local-owner") {
 	};
 }
 function setUserTrustPolicy(defaultActionLevel, principalId = "local-owner") {
-	const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const updatedAt = Date.now();
 	return runSqliteWriteTransaction((db) => {
 		db.prepare(`
       INSERT INTO user_trust_policies (principal_id, default_action_level, updated_at)
@@ -31,6 +32,7 @@ function setUserTrustPolicy(defaultActionLevel, principalId = "local-owner") {
 }
 var init_user_trust_repository = __esmMin((() => {
 	init_trust_policy();
+	init_timestamps();
 	init_transaction();
 }));
 //#endregion

package/dist/src/tasks/capabilities/read.js

@@ -2,10 +2,10 @@ import { ProductReadContracts } from "../../../packages/gateway-contract/src/cap
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { TaskRepository, init_task_repository } from "../task-repository.js";
 import { TaskRunRepository, init_task_run_repository } from "../task-run-repository.js";
-import { TaskConversationRepository } from "../task-conversation-repository.js";
-import { TaskReadModelProjector } from "../task-read-model-projector.js";
 import { CapabilityError } from "../../capabilities/runtime/errors.js";
 import { defineReadCapability } from "../../capabilities/runtime/dispatcher.js";
+import { TaskConversationRepository } from "../task-conversation-repository.js";
+import { TaskReadModelProjector } from "../task-read-model-projector.js";
 import { TaskContextRepository } from "../task-context-repository.js";
 import { TaskDependencyService } from "../task-dependency-service.js";
 import { TaskValueMetricsService } from "../task-value-metrics-service.js";

package/dist/src/tasks/capabilities/write.d.ts

@@ -101,8 +101,8 @@ export declare const TaskMutationOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObj
     ok: z.ZodLiteral<false>;
     reason: z.ZodEnum<{
         blocked: "blocked";
-        not_found: "not_found";
         conflict: "conflict";
+        not_found: "not_found";
         invalid_transition: "invalid_transition";
     }>;
     model: z.ZodOptional<z.ZodObject<{

package/dist/src/tasks/home-query-service.js

@@ -51,7 +51,7 @@ function toHomeAutomation(automation) {
 	};
 }
 function effectiveAutomationTimeoutSeconds(run, automation) {
-	return ("timeoutSeconds" in run.actionSnapshot ? run.actionSnapshot.timeoutSeconds : void 0) ?? automation?.reliability?.timeoutSeconds ?? 1800;
+	return ("timeoutSeconds" in run.actionSnapshot ? run.actionSnapshot.timeoutSeconds : void 0) ?? automation?.reliability?.executionTimeoutSeconds ?? 1800;
 }
 function attentionDetail(kind, status, locale, timeoutSeconds) {
 	const isChinese = locale?.toLowerCase().startsWith("zh") ?? false;
@@ -327,7 +327,7 @@ var HomeQueryService = class {
 		const projectsById = new Map(projects.items.map((project) => [project.id, project]));
 		const activeWorkflowRuns = workflowRuns.filter((run) => run.status === "queued" || run.status === "running").map(toHomeWorkflowRun);
 		const failedWorkflowRuns = workflowRuns.filter((run) => run.status === "failed" || run.status === "timeout").slice(0, 5).map(toHomeWorkflowRun);
-		const upcomingAutomations = automations.filter((automation) => automation.notificationPolicy !== "none").map(toHomeAutomation).filter((automation) => Boolean(automation)).sort((a, b) => Date.parse(a.nextRunAt) - Date.parse(b.nextRunAt));
+		const upcomingAutomations = automations.filter((automation) => automation.delivery.notificationPolicy !== "none").map(toHomeAutomation).filter((automation) => Boolean(automation)).sort((a, b) => Date.parse(a.nextRunAt) - Date.parse(b.nextRunAt));
 		const latestAutomationRuns = [...automationRuns].sort((left, right) => right.createdAtMs - left.createdAtMs).filter((run, index, all) => all.findIndex((candidate) => candidate.automationId === run.automationId) === index);
 		const automationsById = new Map(automations.map((automation) => [automation.id, automation]));
 		const decisionCandidates = [...activeTasks.map((task) => decisionFromTask(this.#projector.project(task), task.projectId ? projectsById.get(task.projectId)?.name : void 0, locale)).filter((item) => Boolean(item)), ...connectorApprovals.filter((approval) => Date.parse(approval.expiresAt) > nowMs).map((approval) => ({
@@ -354,7 +354,7 @@ var HomeQueryService = class {
 			href: `/workflows?runId=${encodeURIComponent(run.id)}`,
 			updatedAt: run.completedAtMs ?? run.startedAtMs ?? run.createdAtMs,
 			conversationId: run.conversationId
-		})), ...latestAutomationRuns.filter((run) => run.status === "failed" || run.status === "timeout").filter((run) => automationsById.get(run.automationId)?.notificationPolicy !== "none").filter((run) => !isHomeAttentionAcknowledged("automation_run", run.id)).map((run) => ({
+		})), ...latestAutomationRuns.filter((run) => run.status === "failed" || run.status === "timeout").filter((run) => automationsById.get(run.automationId)?.delivery.notificationPolicy !== "none").filter((run) => !isHomeAttentionAcknowledged("automation_run", run.id)).map((run) => ({
 			id: `automation_run:${run.id}`,
 			kind: "automation_run",
 			runId: run.id,

package/dist/src/tasks/task-contract-planner.js

@@ -69,7 +69,7 @@ var ModelTaskContractPlanner = class {
 				apiKey: await resolveModelCallApiKey(model),
 				maxTokens: 2e3,
 				temperature: 0
-			})).content));
+			}, void 0, { operation: "task.plan_contract" })).content));
 			return planned ? {
 				...planned,
 				objective: fallback.objective