@xopcai/xopc 0.0.333 → 0.0.335

package/dist/src/local-apps/service.js

@@ -5,10 +5,10 @@ import { currentOperationId, init_operation_context } from "../infra/operation-c
 import { afterSqliteCommit, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { ExtensionCapabilityBindingsSchema, extensionCapabilityPermissions } from "../../packages/gateway-contract/src/extension-capabilities.js";
 import { init_src } from "../../packages/gateway-contract/src/index.js";
+import { CapabilityError } from "../capabilities/runtime/errors.js";
 import { init_paths, resolveExtensionsDir } from "../config/paths.js";
 import { LocalAppStore } from "./store.js";
 import { slugifyProjectName } from "../projects/project-store.js";
-import { CapabilityError } from "../capabilities/runtime/errors.js";
 import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
 import { validateLocalAppCapabilityContracts } from "./capabilities/contracts.js";
 import { buildLocalAppFixGuidance } from "./fix-guidance.js";

package/dist/src/mcp/channel-bridge.js

@@ -144,10 +144,20 @@ var XopcChannelBridge = class {
 		return null;
 	}
 	async sendMessage(params) {
-		return this.client.postJson(`/api/sessions/${encodeURIComponent(params.conversationId)}/inputs`, {
+		const client = this.client;
+		const path = `/api/sessions/${encodeURIComponent(params.conversationId)}`;
+		const [detail, config] = await Promise.all([client.getJson(path), client.getJson(`${path}/agent-config`)]);
+		return client.postJson(`/api/sessions/${encodeURIComponent(params.conversationId)}/inputs`, {
+			kind: "append",
 			clientMessageId: crypto.randomUUID(),
+			expectedTranscriptId: detail.session.transcriptId,
+			configVersion: config.configVersion,
 			delivery: "next",
-			content: params.text
+			input: { content: params.text },
+			origin: {
+				type: "system",
+				source: "cli"
+			}
 		});
 	}
 	listPendingApprovals() {

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

@@ -20,8 +20,8 @@ function registerNoteReadCapabilities(dispatcher, getNotes) {
 		id: "xopc.notes.preview_edit",
 		description: "Build a local edit suggestion without modifying the note or calling a model.",
 		...ProductReadContracts["xopc.notes.preview_edit"],
-		async execute({ id, instruction, markdown }) {
-			const result = await getNotes().createAiEditPatch(id, instruction, markdown);
+		async execute({ id, instruction, markdown, context }) {
+			const result = await getNotes().createAiEditPatch(id, instruction, markdown, context?.range);
 			if (!result) throw new CapabilityError("NOT_FOUND", "Note not found");
 			return ProductReadContracts["xopc.notes.preview_edit"].output.parse(result);
 		}

package/dist/src/notes/service.d.ts

@@ -23,7 +23,10 @@ export declare class NotesService {
         note: Note | null;
         conflict: boolean;
     }>;
-    createAiEditPatch(id: string, instruction: string, markdownOverride?: string): Promise<{
+    createAiEditPatch(id: string, instruction: string, markdownOverride?: string, requestedRange?: {
+        start: number;
+        end: number;
+    }): Promise<{
         message: string;
         patch: NoteAiPatch;
     } | null>;

package/dist/src/notes/service.js

@@ -7,8 +7,8 @@ import { init_note_markdown, parseNoteMarkdown } from "./note-markdown.js";
 import { init_notes_repository, listNoteProjectSummaries } from "../storage/sqlite/notes-repository.js";
 import { changedFieldsFromPatch, emitActivity, previewText, systemActivityActor, systemActivitySource } from "../activity/emitter.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
-import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
 import { completeWithResolvedCredentials } from "../providers/model-call.js";
+import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
 import { partitionAttachmentsByReference } from "./note-attachment-sync.js";
 import { buildNoteAgentContextArtifact, getCachedNoteAgentContextArtifact } from "./agent-context.js";
 import { revokeNoteShareRecords } from "../share/note-share-revocation.js";
@@ -333,19 +333,22 @@ var NotesService = class {
 			throw error;
 		}
 	}
-	async createAiEditPatch(id, instruction, markdownOverride) {
+	async createAiEditPatch(id, instruction, markdownOverride, requestedRange) {
 		const note = await this.store.getNote(id);
 		if (!note) return null;
 		const source = markdownOverride ?? note.markdown;
-		const parsed = parseNoteMarkdown(source, id);
+		const start = Math.max(0, Math.min(source.length, requestedRange?.start ?? 0));
+		const end = Math.max(start, Math.min(source.length, requestedRange?.end ?? source.length));
+		const target = source.slice(start, end);
+		const parsed = parseNoteMarkdown(target, id);
 		const wantsTodos = /待办|todo|task|行动|提醒/i.test(instruction);
 		const wantsSummary = /摘要|总结|summary|压缩/i.test(instruction);
 		let generated = "";
 		if (wantsTodos) {
-			const lines = source.split(/\n|。|；|;/).map((line) => line.trim()).filter(Boolean);
+			const lines = target.split(/\n|。|；|;/).map((line) => line.trim()).filter(Boolean);
 			generated = (lines.length ? lines : [parsed.plainText]).slice(0, 12).map((line) => `- [ ] ${line.replace(/^[-*\d.\s\[\]x]+/i, "").trim()}`).join("\n");
 		} else if (wantsSummary) generated = `> [!SUMMARY]\n> ${parsed.plainText.slice(0, 220)}`;
-		else generated = `${source.trimEnd()}\n\n## AI 整理\n\n${instruction.trim()}`;
+		else generated = `${target.trimEnd()}\n\n## AI 整理\n\n${instruction.trim()}`;
 		return {
 			message: "AI edit patch generated",
 			patch: {
@@ -353,9 +356,9 @@ var NotesService = class {
 				summary: instruction,
 				operations: [{
 					type: "replaceRange",
-					from: 0,
-					to: source.length,
-					markdown: generated || source
+					from: start,
+					to: end,
+					markdown: generated || target
 				}]
 			}
 		};

package/dist/src/providers/auth-runtime/resolve-auth.js

@@ -1,5 +1,5 @@
-import { init_sync_provider_auth, resolveProviderApiKeyForAgentSync } from "../../auth/sync-provider-auth.js";
 import { getApiKeyFromEnv, init_env_keys } from "../env-keys.js";
+import { init_sync_provider_auth, resolveProviderApiKeyForAgentSync } from "../../auth/sync-provider-auth.js";
 import { getDefaultAuthProfileStore } from "./auth-profile-store.js";
 //#region src/providers/auth-runtime/resolve-auth.ts
 init_env_keys();

package/dist/src/providers/index.js

@@ -1,11 +1,11 @@
 import { __esmMin, __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
-import { getModelOAuthProviderIds, init_registry } from "../auth/oauth/registry.js";
-import { hasProviderAuthOnDiskSync, init_sync_provider_auth } from "../auth/sync-provider-auth.js";
 import { PROVIDER_ENV_MAP, getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { init_model_ref, splitProviderModelRef } from "./model-ref.js";
 import { ModelRegistry, getModelRegistry, init_model_registry, prewarmModelRegistry, resetModelRegistry } from "./model-registry.js";
+import { getModelOAuthProviderIds, init_registry } from "../auth/oauth/registry.js";
 import { CredentialResolver, hasCredentials, init_credentials } from "../auth/credentials.js";
+import { hasProviderAuthOnDiskSync, init_sync_provider_auth } from "../auth/sync-provider-auth.js";
 import { EXTENSION_PROVIDER_BASE_URL, init_constants } from "./constants.js";
 import { applyOfficialModelMetadataCorrections, getSupplementalModels, init_model_supplements } from "./model-supplements.js";
 import { getProviderRegistry, init_plugin_registry } from "./plugin-registry.js";

package/dist/src/providers/model-catalog-persistence.js

@@ -1,7 +1,7 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { init_paths_state, resolveXopcCloudCatalogCachePath } from "../config/paths-state.js";
-import { ComputerProfileSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
 import { init_write_file_atomic, writeTextAtomic } from "../infra/write-file-atomic.js";
+import { ComputerProfileSchema, init_src } from "../../packages/computer-control-contract/src/index.js";
 import { voiceManifestSchema } from "../../packages/realtime-protocol/src/voice-catalog.js";
 import { init_voice } from "../../packages/realtime-protocol/src/voice.js";
 import { readFileSync, rmSync } from "node:fs";

package/dist/src/providers/register-runtime-providers.js

@@ -1,6 +1,6 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { getOAuthProviderDefinition, init_registry } from "../auth/oauth/registry.js";
 import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
+import { getOAuthProviderDefinition, init_registry } from "../auth/oauth/registry.js";
 import { XOPC_CLOUD_PROVIDER_ID, init_xopc_cloud_config, resolveXopcModelRouterUrl } from "./xopc-cloud-config.js";
 //#region src/providers/register-runtime-providers.ts
 function registerRuntimeProvider(modelRuntime, source) {

package/dist/src/session/store.js

@@ -794,7 +794,6 @@ var SessionStore = class {
 				customData: {
 					...sourceMetadata.customData ?? {},
 					...options.targetMetadata.customData ?? {},
-					genericNewChatShell: false,
 					forkedFromConversationId: sourceKey,
 					forkedFromTranscriptId: sourceMetadata.transcriptId,
 					forkedFromSessionName: sourceMetadata.name,

package/dist/src/storage/sqlite/ai-usage-repository.d.ts

@@ -29,6 +29,9 @@ export type AiUsageTotals = {
     knownCostUsd: string;
     costCompleteness: 'complete' | 'partial' | 'unknown';
 };
+export type ConversationAiUsageTotals = Pick<AiUsageTotals, 'calls' | 'unknownCostCalls' | 'totalTokens' | 'knownCostUsd' | 'costCompleteness'>;
+/** Aggregate all retained AI usage records for the requested conversations. */
+export declare function summarizeAiUsageByConversations(conversationIds: readonly string[]): Map<string, ConversationAiUsageTotals>;
 export declare function summarizeAiUsage(query: AiUsageQuery): {
     totals: AiUsageTotals;
     byCategory: Array<{

package/dist/src/storage/sqlite/ai-usage-repository.js

@@ -94,6 +94,30 @@ const TOTALS_SQL = `COUNT(*) AS calls,
   COALESCE(SUM(cache_write_tokens), 0) AS cache_write_tokens,
   COALESCE(SUM(total_tokens), 0) AS total_tokens,
   COALESCE(SUM(estimated_cost_microusd), 0) AS known_cost_microusd`;
+/** Aggregate all retained AI usage records for the requested conversations. */
+function summarizeAiUsageByConversations(conversationIds) {
+	const uniqueIds = [...new Set(conversationIds.filter(Boolean))];
+	const result = /* @__PURE__ */ new Map();
+	const db = getSqliteDatabase();
+	for (let offset = 0; offset < uniqueIds.length; offset += 500) {
+		const batch = uniqueIds.slice(offset, offset + 500);
+		const rows = db.prepare(`SELECT conversation_id, ${TOTALS_SQL}
+      FROM ai_usage_events
+      WHERE conversation_id IN (${batch.map(() => "?").join(", ")})
+      GROUP BY conversation_id`).all(...batch);
+		for (const row of rows) {
+			const totals = totalsFromRow(row);
+			result.set(String(row.conversation_id), {
+				calls: totals.calls,
+				unknownCostCalls: totals.unknownCostCalls,
+				totalTokens: totals.totalTokens,
+				knownCostUsd: totals.knownCostUsd,
+				costCompleteness: totals.costCompleteness
+			});
+		}
+	}
+	return result;
+}
 function summarizeAiUsage(query) {
 	const { sql, values } = queryWhere(query);
 	const db = getSqliteDatabase();
@@ -172,4 +196,4 @@ function listAiUsageTrace(traceId) {
     ORDER BY started_at ASC, id ASC`).all(traceId).map(eventFromRow);
 }
 //#endregion
-export { AI_USAGE_RETENTION_MS, finishAiUsageEvent, getAiUsageEvent, getAiUsageEventView, insertAiUsageEvent, listAiUsageEvents, listAiUsageTrace, markStaleAiUsageEventsUnknown, pruneAiUsageEvents, summarizeAiUsage };
+export { AI_USAGE_RETENTION_MS, finishAiUsageEvent, getAiUsageEvent, getAiUsageEventView, insertAiUsageEvent, listAiUsageEvents, listAiUsageTrace, markStaleAiUsageEventsUnknown, pruneAiUsageEvents, summarizeAiUsage, summarizeAiUsageByConversations };

package/dist/src/storage/sqlite/migrations/223_session_creation_receipts.sql

@@ -0,0 +1,59 @@
+UPDATE sessions SET custom_data_json=json_remove(custom_data_json, '$.genericNewChatShell')
+WHERE json_type(custom_data_json, '$.genericNewChatShell') IS NOT NULL;
+
+CREATE TABLE session_input_receipts (
+  conversation_id TEXT NOT NULL,
+  client_message_id TEXT NOT NULL,
+  principal_id TEXT NOT NULL,
+  request_hash TEXT NOT NULL,
+  input_id TEXT,
+  transcript_id TEXT NOT NULL,
+  accepted_at INTEGER NOT NULL,
+  PRIMARY KEY (conversation_id, client_message_id)
+);
+
+CREATE TABLE session_tombstones (
+  conversation_id TEXT PRIMARY KEY,
+  deleted_at INTEGER NOT NULL
+);
+
+CREATE TABLE session_preparation_retries (
+  conversation_id TEXT NOT NULL,
+  idempotency_key TEXT NOT NULL,
+  operation_id TEXT NOT NULL,
+  expected_revision INTEGER NOT NULL,
+  principal_id TEXT NOT NULL,
+  PRIMARY KEY (conversation_id, idempotency_key)
+);
+
+CREATE TABLE session_preparations (
+  conversation_id TEXT PRIMARY KEY REFERENCES sessions(conversation_id) ON DELETE CASCADE,
+  operation_id TEXT NOT NULL UNIQUE,
+  creation_json TEXT NOT NULL CHECK(json_valid(creation_json)),
+  state TEXT NOT NULL CHECK(state IN ('preparing', 'ready', 'preparation_failed')),
+  environment_id TEXT NOT NULL,
+  base_commit TEXT,
+  revision INTEGER NOT NULL DEFAULT 1,
+  lease_until INTEGER NOT NULL DEFAULT 0,
+  last_error TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE session_preparation_cleanup (
+  environment_id TEXT PRIMARY KEY,
+  conversation_id TEXT NOT NULL,
+  not_before INTEGER NOT NULL,
+  last_error TEXT
+);
+
+CREATE TRIGGER session_creation_tombstone BEFORE DELETE ON sessions BEGIN
+  INSERT INTO session_tombstones(conversation_id, deleted_at)
+  VALUES (OLD.conversation_id, CAST(unixepoch('subsec') * 1000 AS INTEGER))
+  ON CONFLICT(conversation_id) DO NOTHING;
+  INSERT INTO session_preparation_cleanup(environment_id, conversation_id, not_before)
+  SELECT environment_id, conversation_id, max(lease_until, CAST(unixepoch('subsec') * 1000 AS INTEGER)) + 5000
+  FROM session_preparations WHERE conversation_id=OLD.conversation_id
+    AND json_extract(creation_json, '$.execution.mode')='managed_worktree'
+  ON CONFLICT(environment_id) DO NOTHING;
+END;

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 222;
+export declare const XOPC_DB_SCHEMA_VERSION = 223;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -57,7 +57,7 @@ function applySingleMigration(db, migration, discardOldScenes = false) {
 */
 function applyPendingMigrations(db, options = {}) {
 	db.function("xopc_operation_id", () => currentOperationId() ?? null);
-	const targetVersion = options.targetVersion ?? 222;
+	const targetVersion = options.targetVersion ?? 223;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (!options.migrationsDir && currentVersion < 165) throw new DatabaseSchemaTooOldError(currentVersion, 165);
@@ -95,7 +95,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 222;
+	const appVersion = options.targetVersion ?? 223;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,
@@ -137,7 +137,7 @@ var init_runner = __esmMin((() => {
 	init_errors();
 	log = createLogger("Sqlite:Migrations");
 	XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
-	XOPC_DB_SCHEMA_VERSION = 222;
+	XOPC_DB_SCHEMA_VERSION = 223;
 }));
 //#endregion
 init_runner();

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

@@ -28,7 +28,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 165;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 222,
+		targetVersion: 223,
 		databasePath: fresh ? void 0 : options.databasePath
 	});
 }

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;
@@ -83,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,
@@ -107,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',
@@ -117,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);

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