@xopcai/xopc 0.0.235 → 0.0.239

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

@@ -5,7 +5,7 @@ import { ensureSessionInTransaction } from "./session-repository.js";
 function readConfigRow(db, sessionKey) {
 	return db.prepare(`SELECT session_key, thinking_level, reasoning_level, verbose_level, elevated_mode,
               model_override, provider_override, working_directory_override, response_language,
-              user_context_mode, updated_at
+              user_context_mode, fixed_model, updated_at
        FROM session_config WHERE session_key = ?`).get(sessionKey);
 }
 function getSessionConfig(sessionKey) {
@@ -23,15 +23,15 @@ function listSessionWorkspaceOverrides() {
 function setSessionConfig(sessionKey, config, cwd) {
 	return runSqliteWriteTransaction((db) => {
 		ensureSessionInTransaction(db, sessionKey, cwd);
-		const updatedAt = Date.now();
+		const updatedAt = Math.max(Date.now(), (readConfigRow(db, sessionKey)?.updated_at ?? 0) + 1);
 		const next = {
 			...config,
 			updatedAt
 		};
 		db.prepare(`INSERT INTO session_config (
         session_key, thinking_level, reasoning_level, verbose_level, elevated_mode,
-        model_override, provider_override, working_directory_override, response_language, user_context_mode, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        model_override, provider_override, working_directory_override, response_language, user_context_mode, fixed_model, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(session_key) DO UPDATE SET
         thinking_level = excluded.thinking_level,
         reasoning_level = excluded.reasoning_level,
@@ -42,7 +42,8 @@ function setSessionConfig(sessionKey, config, cwd) {
         working_directory_override = excluded.working_directory_override,
         response_language = excluded.response_language,
         user_context_mode = excluded.user_context_mode,
-        updated_at = excluded.updated_at`).run(sessionKey, next.thinkingLevel ?? null, next.reasoningLevel ?? null, next.verboseLevel ?? null, next.elevatedMode ?? null, next.modelOverride ?? null, next.providerOverride ?? null, next.workingDirectoryOverride ?? null, next.responseLanguage ?? null, next.userContextMode ?? null, updatedAt);
+        fixed_model = excluded.fixed_model,
+        updated_at = excluded.updated_at`).run(sessionKey, next.thinkingLevel ?? null, next.reasoningLevel ?? null, next.verboseLevel ?? null, next.elevatedMode ?? null, next.modelOverride ?? null, next.providerOverride ?? null, next.workingDirectoryOverride ?? null, next.responseLanguage ?? null, next.userContextMode ?? null, next.fixedModel ? 1 : 0, updatedAt);
 		return next;
 	});
 }

package/dist/src/storage/sqlite/device-access-repository.d.ts

@@ -34,6 +34,8 @@ export declare function createDevice(input: {
 export declare function getDevice(deviceId: string): DeviceRecord | undefined;
 export declare function listDevices(): DeviceRecord[];
 export declare function issueDeviceTokenPair(deviceId: string, now?: number): DeviceTokenPair;
+/** Registers a phone-generated bootstrap credential without persisting its secret. */
+export declare function registerInitialDeviceRefreshToken(deviceId: string, token: string, now?: number): number;
 export declare function authenticateDeviceAccessToken(token: string, now?: number): DeviceAccessIdentity | undefined;
 export declare function buildRefreshProofMessage(input: {
     credentialId: string;

package/dist/src/storage/sqlite/device-access-repository.js

@@ -1,4 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { initialDeviceRefreshTokenSchema } from "../../../packages/gateway-contract/src/device-pairing.js";
 import { parseGatewayScopes } from "../../gateway/security/gateway-scopes.js";
 import crypto from "node:crypto";
 //#region src/storage/sqlite/device-access-repository.ts
@@ -82,6 +83,15 @@ function issueDeviceTokenPair(deviceId, now = Date.now()) {
 		refreshTokenExpiresAt
 	};
 }
+/** Registers a phone-generated bootstrap credential without persisting its secret. */
+function registerInitialDeviceRefreshToken(deviceId, token, now = Date.now()) {
+	initialDeviceRefreshTokenSchema.parse(token);
+	const parsed = parseToken(token, REFRESH_TOKEN_PREFIX);
+	const expiresAt = now + REFRESH_TOKEN_TTL_MS;
+	getSqliteDatabase().prepare(`INSERT INTO device_refresh_credentials
+    (credential_id, device_id, token_hash, expires_at, created_at) VALUES (?, ?, ?, ?, ?)`).run(parsed.id, deviceId, tokenHash(token), expiresAt, now);
+	return expiresAt;
+}
 function authenticateDeviceAccessToken(token, now = Date.now()) {
 	const parsed = parseToken(token, ACCESS_TOKEN_PREFIX);
 	if (!parsed) return void 0;
@@ -147,7 +157,7 @@ function rotateDeviceRefreshToken(input) {
                rotation_request_id, revoked_at
         FROM device_refresh_credentials WHERE credential_id = ?
       `).get(nextParsed.id);
-			if (nextCredential?.token_hash === tokenHash(input.nextRefreshToken)) return {
+			if (nextCredential?.token_hash === tokenHash(input.nextRefreshToken) && nextCredential.revoked_at === null && nextCredential.replaced_by === null && nextCredential.expires_at > now) return {
 				...issueAccessToken(credential.device_id, now),
 				refreshToken: input.nextRefreshToken,
 				refreshTokenExpiresAt: nextCredential.expires_at
@@ -191,4 +201,4 @@ function revokeDevice(deviceId, now = Date.now()) {
 	});
 }
 //#endregion
-export { authenticateDeviceAccessToken, buildRefreshProofMessage, createDevice, getDevice, issueDeviceTokenPair, listDevices, revokeDevice, rotateDeviceRefreshToken };
+export { authenticateDeviceAccessToken, buildRefreshProofMessage, createDevice, getDevice, issueDeviceTokenPair, listDevices, registerInitialDeviceRefreshToken, revokeDevice, rotateDeviceRefreshToken };

package/dist/src/storage/sqlite/device-pairing-approval.d.ts

@@ -0,0 +1,19 @@
+import { type DevicePairingAction, type DevicePairingStatus } from '@xopcai/gateway-contract';
+import type { DeviceRoute } from './device-pairing-repository.js';
+export declare class DevicePairingError extends Error {
+    readonly code: string;
+    readonly status: 400 | 401 | 404 | 409;
+    constructor(code: string, status?: 400 | 401 | 404 | 409);
+}
+export declare function submitDevicePairingRequest(body: Record<string, unknown>, now?: number): DevicePairingStatus;
+export declare function readDevicePairingSetup(setupId: string, now?: number): {
+    request: DevicePairingStatus | null;
+    serverTime: number;
+};
+export declare function decideDevicePairingRequest(id: string, decision: 'approve' | 'reject', revision: number, now?: number): DevicePairingStatus;
+export declare function cancelDevicePairingSetup(id: string, now?: number): void;
+export declare function operateDevicePairingRequest(action: Exclude<DevicePairingAction, 'request'>, body: Record<string, unknown>, now?: number): {
+    request: DevicePairingStatus;
+    routes: DeviceRoute[];
+    scopes?: readonly string[];
+};

package/dist/src/storage/sqlite/device-pairing-approval.js

@@ -0,0 +1,154 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { buildDevicePairingProof, devicePairingCompleteSchema, devicePairingDeviceSchema } from "../../../packages/gateway-contract/src/device-pairing.js";
+import { DEFAULT_MOBILE_SCOPES } from "../../gateway/security/gateway-scopes.js";
+import { createDevice, getDevice, registerInitialDeviceRefreshToken, revokeDevice } from "./device-access-repository.js";
+import { getOrCreateGatewayIdentity } from "./gateway-identity-repository.js";
+import crypto from "node:crypto";
+//#region src/storage/sqlite/device-pairing-approval.ts
+const PROOF_WINDOW_MS = 5 * 6e4;
+const APPROVAL_WINDOW_MS = 2 * 6e4;
+const RECOVERY_WINDOW_MS = 1440 * 6e4;
+var DevicePairingError = class extends Error {
+	constructor(code, status = 409) {
+		super(code);
+		this.code = code;
+		this.status = status;
+	}
+};
+const hash = (value) => crypto.createHash("sha256").update(value).digest("hex");
+const fail = (code, status) => {
+	throw new DevicePairingError(code, status);
+};
+function requestRow(id, now) {
+	const db = getSqliteDatabase();
+	db.prepare(`UPDATE device_pairing_requests SET status = 'expired', revision = revision + 1
+    WHERE request_id = ? AND expires_at <= ? AND status IN ('pending', 'approved')`).run(id, now);
+	const row = db.prepare("SELECT * FROM device_pairing_requests WHERE request_id = ?").get(id);
+	if (!row) return fail("PAIRING_NOT_FOUND", 404);
+	return row;
+}
+function statusFromRow(row, now) {
+	const device = devicePairingDeviceSchema.parse(JSON.parse(row.device_json));
+	return {
+		requestId: row.request_id,
+		setupId: row.pairing_id,
+		status: row.status,
+		revision: row.revision,
+		displayName: device.displayName,
+		platform: device.platform,
+		confirmationCode: row.confirmation_code,
+		expiresAt: row.expires_at,
+		serverTime: now,
+		...row.device_id ? { deviceId: row.device_id } : {}
+	};
+}
+function verifiedSetup(token, now) {
+	const id = /^xopc_pair_([0-9a-f-]{36})_/i.exec(token)?.[1];
+	if (!id) return fail("PAIRING_DENIED", 401);
+	const row = getSqliteDatabase().prepare("SELECT * FROM device_pairing_sessions WHERE pairing_id = ?").get(id);
+	if (!row || row.protocol_version !== 3 || row.attempts_remaining <= 0) return fail("PAIRING_DENIED", 401);
+	if (!crypto.timingSafeEqual(Buffer.from(row.secret_hash, "hex"), Buffer.from(hash(token), "hex"))) {
+		getSqliteDatabase().prepare("UPDATE device_pairing_sessions SET attempts_remaining = attempts_remaining - 1 WHERE pairing_id = ?").run(id);
+		return fail("PAIRING_DENIED", 401);
+	}
+	if (now > row.expires_at + RECOVERY_WINDOW_MS) return fail("PAIRING_EXPIRED");
+	return row;
+}
+function verifyProof(action, body, deviceJson, now) {
+	if (body.gatewayId !== getOrCreateGatewayIdentity().id) fail("PAIRING_IDENTITY_MISMATCH", 401);
+	if (typeof body.timestamp !== "number" || Math.abs(now - body.timestamp) > PROOF_WINDOW_MS) fail("PAIRING_PROOF_EXPIRED", 401);
+	const device = devicePairingDeviceSchema.parse(JSON.parse(deviceJson));
+	let valid = false;
+	try {
+		valid = crypto.verify("sha256", Buffer.from(buildDevicePairingProof(action, body)), {
+			key: crypto.createPublicKey({
+				key: device.publicKeyJwk,
+				format: "jwk"
+			}),
+			dsaEncoding: "ieee-p1363"
+		}, Buffer.from(String(body.signature), "base64url"));
+	} catch {}
+	if (!valid) fail("PAIRING_DENIED", 401);
+}
+function submitDevicePairingRequest(body, now = Date.now()) {
+	const setup = verifiedSetup(String(body.pairingToken), now);
+	const device = devicePairingDeviceSchema.parse(body.device);
+	const deviceJson = JSON.stringify(device);
+	verifyProof("request", body, deviceJson, now);
+	return runSqliteWriteTransaction((db) => {
+		const existing = db.prepare("SELECT request_id, device_json FROM device_pairing_requests WHERE pairing_id = ?").get(setup.pairing_id);
+		if (existing) {
+			if (existing.request_id !== body.requestId || existing.device_json !== deviceJson) return fail("PAIRING_BUSY");
+			return statusFromRow(requestRow(existing.request_id, now), now);
+		}
+		if (setup.consumed_at !== null) return fail("PAIRING_CANCELLED");
+		if (setup.expires_at <= now) return fail("PAIRING_EXPIRED");
+		const expiresAt = Math.min(setup.expires_at, now + APPROVAL_WINDOW_MS);
+		db.prepare(`INSERT INTO device_pairing_requests (request_id, pairing_id, device_json, status,
+      confirmation_code, expires_at, recovery_until, created_at) VALUES (?, ?, ?, 'pending', ?, ?, ?, ?)`).run(String(body.requestId), setup.pairing_id, deviceJson, crypto.randomInt(0, 1e6).toString().padStart(6, "0"), expiresAt, setup.expires_at + RECOVERY_WINDOW_MS, now);
+		return statusFromRow(requestRow(String(body.requestId), now), now);
+	});
+}
+function readDevicePairingSetup(setupId, now = Date.now()) {
+	if (!getSqliteDatabase().prepare("SELECT pairing_id FROM device_pairing_sessions WHERE pairing_id = ?").get(setupId)) return fail("PAIRING_NOT_FOUND", 404);
+	const row = getSqliteDatabase().prepare("SELECT request_id FROM device_pairing_requests WHERE pairing_id = ?").get(setupId);
+	return {
+		request: row ? statusFromRow(requestRow(row.request_id, now), now) : null,
+		serverTime: now
+	};
+}
+function decideDevicePairingRequest(id, decision, revision, now = Date.now()) {
+	return runSqliteWriteTransaction((db) => {
+		const row = requestRow(id, now);
+		if (row.revision !== revision || row.status !== "pending") return fail("PAIRING_CHANGED");
+		db.prepare(`UPDATE device_pairing_requests SET status = ?, revision = revision + 1 WHERE request_id = ?`).run(decision === "approve" ? "approved" : "rejected", id);
+		return statusFromRow(requestRow(id, now), now);
+	});
+}
+function cancelDevicePairingSetup(id, now = Date.now()) {
+	runSqliteWriteTransaction((db) => {
+		db.prepare("UPDATE device_pairing_sessions SET consumed_at = ? WHERE pairing_id = ? AND consumed_at IS NULL").run(now, id);
+		db.prepare(`UPDATE device_pairing_requests SET status = 'cancelled', revision = revision + 1
+      WHERE pairing_id = ? AND status IN ('pending', 'approved')`).run(id);
+	});
+}
+function operateDevicePairingRequest(action, body, now = Date.now()) {
+	const setup = verifiedSetup(String(body.pairingToken), now);
+	const row = requestRow(String(body.requestId), now);
+	if (row.pairing_id !== setup.pairing_id) return fail("PAIRING_DENIED", 401);
+	verifyProof(action, body, row.device_json, now);
+	if (action !== "cancel" && row.device_id && getDevice(row.device_id)?.revokedAt !== void 0) return fail("DEVICE_REVOKED", 401);
+	if (now >= row.recovery_until) return fail("PAIRING_EXPIRED");
+	if (action === "cancel") runSqliteWriteTransaction((db) => {
+		if (row.device_id) revokeDevice(row.device_id, now);
+		cancelDevicePairingSetup(row.pairing_id, now);
+		db.prepare("UPDATE device_pairing_requests SET status = 'cancelled' WHERE request_id = ?").run(row.request_id);
+	});
+	else if (action === "complete") {
+		const complete = devicePairingCompleteSchema.parse(body);
+		runSqliteWriteTransaction((db) => {
+			const current = requestRow(row.request_id, now);
+			if (current.status === "completed") {
+				if (current.completion_key !== complete.idempotencyKey || current.initial_token_hash !== hash(complete.initialRefreshToken)) fail("PAIRING_CHANGED");
+				return;
+			}
+			if (current.status !== "approved") fail("PAIRING_NOT_APPROVED");
+			const created = createDevice({
+				...devicePairingDeviceSchema.parse(JSON.parse(current.device_json)),
+				scopes: DEFAULT_MOBILE_SCOPES,
+				now
+			});
+			registerInitialDeviceRefreshToken(created.id, complete.initialRefreshToken, now);
+			db.prepare(`UPDATE device_pairing_requests SET status = 'completed', revision = revision + 1,
+        completion_key = ?, initial_token_hash = ?, device_id = ? WHERE request_id = ?`).run(complete.idempotencyKey, hash(complete.initialRefreshToken), created.id, current.request_id);
+			db.prepare("UPDATE device_pairing_sessions SET consumed_at = ? WHERE pairing_id = ?").run(now, setup.pairing_id);
+		});
+	}
+	return {
+		request: statusFromRow(requestRow(row.request_id, now), now),
+		routes: JSON.parse(setup.routes_json),
+		...action === "complete" ? { scopes: DEFAULT_MOBILE_SCOPES } : {}
+	};
+}
+//#endregion
+export { DevicePairingError, cancelDevicePairingSetup, decideDevicePairingRequest, operateDevicePairingRequest, readDevicePairingSetup, submitDevicePairingRequest };

package/dist/src/storage/sqlite/device-pairing-repository.d.ts

@@ -17,6 +17,6 @@ export type PairingConsumeResult = {
     ok: false;
     reason: 'invalid' | 'expired' | 'consumed';
 };
-export declare function createDevicePairingSetup(routes: readonly DeviceRoute[], now?: number): DevicePairingSetup;
+export declare function createDevicePairingSetup(routes: readonly DeviceRoute[], now?: number, protocolVersion?: 2 | 3): DevicePairingSetup;
 export declare function consumeDevicePairingToken(token: string, now?: number): PairingConsumeResult;
 export declare function isDevicePairingSetupActive(pairingId: string, now?: number): boolean;

package/dist/src/storage/sqlite/device-pairing-repository.js

@@ -16,18 +16,21 @@ function tokenId(token) {
 	if (separator <= 10 || separator === token.length - 1) return void 0;
 	return token.slice(10, separator);
 }
-function createDevicePairingSetup(routes, now = Date.now()) {
+function createDevicePairingSetup(routes, now = Date.now(), protocolVersion = 2) {
 	if (routes.length === 0) throw new Error("No secure mobile route is available");
 	const id = crypto.randomUUID();
 	const token = `${PAIRING_TOKEN_PREFIX}${id}_${crypto.randomBytes(32).toString("base64url")}`;
 	const expiresAt = now + PAIRING_TTL_MS;
 	runSqliteWriteTransaction((db) => {
-		db.prepare("DELETE FROM device_pairing_sessions WHERE expires_at <= ? OR consumed_at IS NOT NULL").run(now);
+		db.prepare(`DELETE FROM device_pairing_sessions WHERE
+      (protocol_version = 2 AND (expires_at <= ? OR consumed_at IS NOT NULL)) OR
+      (protocol_version = 3 AND expires_at < ?)`).run(now, now - 1440 * 6e4);
 		db.prepare(`
       INSERT INTO device_pairing_sessions (
         pairing_id, secret_hash, routes_json, expires_at, attempts_remaining, created_at
-      ) VALUES (?, ?, ?, ?, ?, ?)
-    `).run(id, hashToken(token), JSON.stringify(routes), expiresAt, PAIRING_ATTEMPTS, now);
+        , protocol_version
+      ) VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(id, hashToken(token), JSON.stringify(routes), expiresAt, PAIRING_ATTEMPTS, now, protocolVersion);
 	});
 	return {
 		id,
@@ -48,6 +51,10 @@ function consumeDevicePairingToken(token, now = Date.now()) {
 			ok: false,
 			reason: "invalid"
 		};
+		if (row.protocol_version !== 2) return {
+			ok: false,
+			reason: "invalid"
+		};
 		if (row.consumed_at !== null) return {
 			ok: false,
 			reason: "consumed"

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

@@ -16,9 +16,10 @@ import { finishContextConsolidationRun, getContextConsolidationRun, listContextC
 import { summarizeUnderstandingFeedback, summarizeUserUnderstandingQuality } from "./user-context-quality-repository.js";
 import { closeUnderstandingValidity, consumeContextConsent, createCollaborationRule, createContextEvidence, createUnderstanding, decideContextConsent, deleteCollaborationRule, deleteUnderstanding, ensureContextConsent, getCollaborationRule, getTurnPersonalization, getUnderstanding, getUserProfile, hasContextConsent, isUnderstandingSuppressed, linkUnderstandingEvidence, listCollaborationRules, listUnderstandingEvidence, listUnderstandingStatusEvents, listUnderstandings, recordContextFeedback, recordContextRun, rejectUnderstanding, reviseCollaborationRule, reviseUnderstanding, searchActiveUnderstandings, setCollaborationRuleStatus, setUnderstandingStatus, updateUserProfile } from "./user-context-repository.js";
 import { getUserPeopleIndexState, getUserPerson, listUserPeople, mergeUserPeople, replaceUserPeopleIndex, summarizeUserPeople, updateUserPerson } from "./user-people-repository.js";
-import { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, insertSessionInput, listActiveSessionInputRuns, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus } from "./session-input-repository.js";
 import { buildDefaultSessionMetadata } from "./session-metadata.js";
 import { buildGlobalSessionStats, classifyStoredRow, estimateTokensFromMessages, extractFtsContent, metadataToSessionInsert, sessionConfigRowToConfig, sessionRowToMetadata, transcriptEntryRowToStoredRow } from "./row-mappers.js";
+import { deleteSessionRecord, ensureSessionRecord, findSessionKeyBySessionId, getCurrentSessionId, getGlobalSessionStats, getSessionMetadata, getSessionPersistedLevels, incrementSessionStatsOnAppend, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, resetSessionRecord, resolveSessionAgentId, updateSessionStats } from "./session-repository.js";
+import { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, insertSessionInput, listActiveSessionInputRuns, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus } from "./session-input-repository.js";
 import { replaceLatestSessionTurnAndQueueInput, validateLatestSessionTurnTarget } from "./session-turn-replace-repository.js";
 import { acknowledgeHomeAttention, isHomeAttentionAcknowledged } from "./home-attention-repository.js";
 import { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob } from "./connector-learning-repository.js";
@@ -26,7 +27,6 @@ import { COMPOSER_INPUT_HISTORY_LIMIT, appendComposerInputHistory, clearComposer
 import { bindEndpointPrincipal, createEndpointPrincipal, getEndpointPrincipal, listEndpointPrincipals, revokeEndpointPrincipal, touchEndpointPrincipal } from "./endpoint-principal-repository.js";
 import { finishEndpointToolInvocationAudit, listEndpointToolInvocationAudits, startEndpointToolInvocationAudit } from "./endpoint-tool-invocation-repository.js";
 import { getInteractionState, setInteractionState, updateInteractionStateFromMessage } from "./interaction-state-repository.js";
-import { deleteSessionRecord, ensureSessionRecord, findSessionKeyBySessionId, getCurrentSessionId, getGlobalSessionStats, getSessionMetadata, getSessionPersistedLevels, incrementSessionStatsOnAppend, listSessionMetadata, listSessionsByAgent, patchSessionMetadata, resetSessionRecord, resolveSessionAgentId, updateSessionStats } from "./session-repository.js";
 import { getSessionTaskPlan, setSessionTaskPlan } from "./session-task-plan-repository.js";
 import { buildRelationshipPrompt, getRelationshipSettings, isProactiveSupportAllowed, updateRelationshipSettings } from "./relationship-settings-repository.js";
 import { appendCompactionBoundaryIfUnchanged, appendTranscriptEntry, listCompactionBoundaries, loadCompactionSourceSnapshot, loadLlmMessagesForSession, loadTranscriptHistoryRowsForSession, loadTranscriptRows, loadTranscriptRowsForSession, paginateTranscriptMessages, replaceTranscriptRows, restoreBeforeCompactionBoundary, searchSessionTranscript } from "./transcript-repository.js";

package/dist/src/storage/sqlite/migrations/141_device_pairing_approval.sql

@@ -0,0 +1,17 @@
+ALTER TABLE device_pairing_sessions ADD COLUMN protocol_version INTEGER NOT NULL DEFAULT 2;
+
+CREATE TABLE device_pairing_requests (
+  request_id TEXT PRIMARY KEY,
+  pairing_id TEXT NOT NULL UNIQUE REFERENCES device_pairing_sessions(pairing_id) ON DELETE CASCADE,
+  device_json TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('pending', 'approved', 'completed', 'rejected', 'cancelled', 'expired')),
+  revision INTEGER NOT NULL DEFAULT 1,
+  confirmation_code TEXT NOT NULL,
+  expires_at INTEGER NOT NULL,
+  recovery_until INTEGER NOT NULL,
+  completion_key TEXT,
+  initial_token_hash TEXT,
+  device_id TEXT REFERENCES devices(device_id),
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX idx_device_pairing_requests_expiry ON device_pairing_requests(recovery_until);

package/dist/src/storage/sqlite/migrations/142_session_input_instance.sql

@@ -0,0 +1 @@
+ALTER TABLE session_inputs ADD COLUMN expected_session_id TEXT;

package/dist/src/storage/sqlite/migrations/143_fixed_session_model.sql

@@ -0,0 +1 @@
+ALTER TABLE session_config ADD COLUMN fixed_model INTEGER NOT NULL DEFAULT 0 CHECK (fixed_model IN (0, 1));

package/dist/src/storage/sqlite/migrations/144_execution_environments.sql

@@ -0,0 +1,59 @@
+CREATE TABLE execution_environments (
+  environment_id TEXT PRIMARY KEY,
+  project_id TEXT REFERENCES projects(project_id) ON DELETE SET NULL,
+  kind TEXT NOT NULL CHECK (kind IN ('local_checkout', 'managed_worktree')),
+  status TEXT NOT NULL CHECK (status IN (
+    'requested', 'provisioning', 'ready', 'degraded', 'deleting', 'deleted', 'error'
+  )),
+  root_path TEXT NOT NULL CHECK (length(root_path) > 0),
+  repository_root TEXT,
+  git_common_dir TEXT,
+  base_ref TEXT,
+  base_sha TEXT,
+  branch_ref TEXT,
+  version INTEGER NOT NULL DEFAULT 1 CHECK (version > 0),
+  last_error TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  last_used_at INTEGER,
+  deleted_at INTEGER
+);
+
+CREATE UNIQUE INDEX idx_execution_environments_active_root
+  ON execution_environments(root_path)
+  WHERE deleted_at IS NULL;
+
+CREATE INDEX idx_execution_environments_project
+  ON execution_environments(project_id, updated_at DESC);
+
+CREATE TABLE execution_environment_bindings (
+  binding_id TEXT PRIMARY KEY,
+  session_key TEXT NOT NULL,
+  environment_id TEXT NOT NULL REFERENCES execution_environments(environment_id) ON DELETE CASCADE,
+  created_at INTEGER NOT NULL,
+  released_at INTEGER
+);
+
+CREATE UNIQUE INDEX idx_execution_environment_bindings_active_session
+  ON execution_environment_bindings(session_key)
+  WHERE released_at IS NULL;
+
+CREATE INDEX idx_execution_environment_bindings_environment
+  ON execution_environment_bindings(environment_id, created_at DESC);
+
+CREATE TABLE execution_environment_events (
+  event_id TEXT PRIMARY KEY,
+  environment_id TEXT NOT NULL REFERENCES execution_environments(environment_id) ON DELETE CASCADE,
+  from_status TEXT CHECK (from_status IS NULL OR from_status IN (
+    'requested', 'provisioning', 'ready', 'degraded', 'deleting', 'deleted', 'error'
+  )),
+  to_status TEXT NOT NULL CHECK (to_status IN (
+    'requested', 'provisioning', 'ready', 'degraded', 'deleting', 'deleted', 'error'
+  )),
+  reason TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created_at INTEGER NOT NULL
+);
+
+CREATE INDEX idx_execution_environment_events_environment
+  ON execution_environment_events(environment_id, created_at DESC);

package/dist/src/storage/sqlite/migrations/145_project_execution_mode.sql

@@ -0,0 +1,5 @@
+ALTER TABLE projects ADD COLUMN execution_mode TEXT NOT NULL DEFAULT 'local_checkout'
+  CHECK (execution_mode IN ('local_checkout', 'managed_worktree'));
+
+CREATE INDEX idx_projects_execution_mode
+  ON projects(execution_mode, updated_at DESC);

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 = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 140;
+export declare const XOPC_DB_SCHEMA_VERSION = 145;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

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

@@ -12,7 +12,7 @@ const log = createLogger("Sqlite:Migrations");
 /** Baseline schema version applied from schema.sql on first open. */
 const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 /** Latest schema version this release supports (increment when adding migrations). */
-const XOPC_DB_SCHEMA_VERSION = 140;
+const XOPC_DB_SCHEMA_VERSION = 145;
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 function backupBeforeTaskCutover(db, databasePath) {
 	db.exec("PRAGMA wal_checkpoint(FULL)");
@@ -57,7 +57,7 @@ function applySingleMigration(db, migration) {
 * Each step runs in its own transaction and updates schema_meta on success.
 */
 function applyPendingMigrations(db, options = {}) {
-	const targetVersion = options.targetVersion ?? 140;
+	const targetVersion = options.targetVersion ?? 145;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (currentVersion >= targetVersion) return currentVersion;
@@ -94,7 +94,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 140;
+	const appVersion = options.targetVersion ?? 145;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,

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

@@ -19,7 +19,7 @@ const log = createLogger('Sqlite:Migrations');
 export const XOPC_DB_BASELINE_SCHEMA_VERSION = 11;
 
 /** Latest schema version this release supports (increment when adding migrations). */
-export const XOPC_DB_SCHEMA_VERSION = 140;
+export const XOPC_DB_SCHEMA_VERSION = 145;
 
 const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
 

package/dist/src/storage/sqlite/row-mappers.d.ts

@@ -51,6 +51,7 @@ export type SessionConfigRow = {
     verbose_level: string | null;
     elevated_mode: string | null;
     model_override: string | null;
+    fixed_model?: number;
     provider_override: string | null;
     working_directory_override: string | null;
     response_language: string | null;

package/dist/src/storage/sqlite/row-mappers.js

@@ -1,7 +1,7 @@
-import { isTranscriptContextEntry } from "../../session/session-context-for-llm.js";
 import "../../session/types.js";
-import { init_agent_session_key, resolveAgentIdFromSessionKey } from "../../routing/agent-session-key.js";
 import { buildDefaultSessionMetadata } from "./session-metadata.js";
+import { isTranscriptContextEntry } from "../../session/session-context-for-llm.js";
+import { init_agent_session_key, resolveAgentIdFromSessionKey } from "../../routing/agent-session-key.js";
 //#region src/storage/sqlite/row-mappers.ts
 init_agent_session_key();
 function parseJson(raw) {
@@ -107,6 +107,7 @@ function sessionConfigRowToConfig(row) {
 		...row.working_directory_override ? { workingDirectoryOverride: row.working_directory_override } : {},
 		...row.response_language ? { responseLanguage: row.response_language } : {},
 		...row.user_context_mode ? { userContextMode: row.user_context_mode } : {},
+		...row.fixed_model === 1 ? { fixedModel: true } : {},
 		updatedAt: row.updated_at
 	};
 }

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

@@ -32,7 +32,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 11;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 140,
+		targetVersion: 145,
 		databasePath: options.databasePath
 	});
 }

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

@@ -6,6 +6,7 @@ export type SessionInput = {
     id: string;
     sessionKey: string;
     clientMessageId: string;
+    expectedSessionId?: string;
     requestedDelivery: SessionInputDelivery;
     effectiveDelivery: SessionInputDelivery;
     status: SessionInputStatus;
@@ -38,10 +39,14 @@ export declare function listActiveSessionInputRuns(): Array<{
 }>;
 export declare function findSessionInput(sessionKey: string, clientMessageId: string): SessionInput | undefined;
 export declare function getSessionInputById(sessionKey: string, id: string): SessionInput | undefined;
+export declare class SessionInstanceChangedError extends Error {
+    constructor();
+}
 export declare function insertSessionInput(input: {
     id: string;
     sessionKey: string;
     clientMessageId: string;
+    expectedSessionId?: string;
     requestedDelivery: SessionInputDelivery;
     effectiveDelivery: SessionInputDelivery;
     status: 'queued' | 'injecting';

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

@@ -1,4 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { readCurrentSessionId } from "./session-repository.js";
 import { turnOriginSchema } from "../../../packages/endpoint-tools-protocol/src/index.js";
 //#region src/storage/sqlite/session-input-repository.ts
 function mapInput(row) {
@@ -6,6 +7,7 @@ function mapInput(row) {
 		id: row.id,
 		sessionKey: row.session_key,
 		clientMessageId: row.client_message_id,
+		expectedSessionId: row.expected_session_id ?? void 0,
 		requestedDelivery: row.requested_delivery,
 		effectiveDelivery: row.effective_delivery,
 		status: row.status,
@@ -24,7 +26,7 @@ function mapInput(row) {
 		updatedAtMs: row.updated_at_ms
 	};
 }
-const SELECT_INPUTS = `SELECT id, session_key, client_message_id, requested_delivery,
+const SELECT_INPUTS = `SELECT id, session_key, client_message_id, expected_session_id, requested_delivery,
   effective_delivery, status, content, attachments_json, context_refs_json, context_snapshots_json,
   thinking, origin_json, position,
   target_run_id, run_id, version, error, created_at_ms, updated_at_ms
@@ -72,18 +74,24 @@ function getSessionInputById(sessionKey, id) {
 	const row = getSqliteDatabase().prepare(`${SELECT_INPUTS} WHERE session_key = ? AND id = ?`).get(sessionKey, id);
 	return row ? mapInput(row) : void 0;
 }
+var SessionInstanceChangedError = class extends Error {
+	constructor() {
+		super("Session instance changed");
+	}
+};
 function insertSessionInput(input) {
 	return runSqliteWriteTransaction((db) => {
 		const existing = db.prepare(`${SELECT_INPUTS} WHERE session_key = ? AND client_message_id = ?`).get(input.sessionKey, input.clientMessageId);
 		if (existing) return mapInput(existing);
+		if (input.expectedSessionId && readCurrentSessionId(db, input.sessionKey) !== input.expectedSessionId) throw new SessionInstanceChangedError();
 		const now = Date.now();
 		const max = db.prepare(`SELECT COALESCE(MAX(position), 0) AS value FROM session_inputs
       WHERE session_key = ? AND status IN ('queued','running','injecting','interrupted')`).get(input.sessionKey);
-		db.prepare(`INSERT INTO session_inputs(id, session_key, client_message_id,
+		db.prepare(`INSERT INTO session_inputs(id, session_key, client_message_id, expected_session_id,
       requested_delivery, effective_delivery, status, content, attachments_json,
       context_refs_json, context_snapshots_json, thinking, origin_json, position,
       target_run_id, version, created_at_ms, updated_at_ms)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`).run(input.id, input.sessionKey, input.clientMessageId, input.requestedDelivery, input.effectiveDelivery, input.status, input.content, input.attachments ? JSON.stringify(input.attachments) : null, input.contextRefs ? JSON.stringify(input.contextRefs) : null, input.contextSnapshots ? JSON.stringify(input.contextSnapshots) : null, input.thinking ?? null, JSON.stringify(input.origin), max.value + 1, input.targetRunId ?? null, now, now);
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`).run(input.id, input.sessionKey, input.clientMessageId, input.expectedSessionId ?? null, input.requestedDelivery, input.effectiveDelivery, input.status, input.content, input.attachments ? JSON.stringify(input.attachments) : null, input.contextRefs ? JSON.stringify(input.contextRefs) : null, input.contextSnapshots ? JSON.stringify(input.contextSnapshots) : null, input.thinking ?? null, JSON.stringify(input.origin), max.value + 1, input.targetRunId ?? null, now, now);
 		bumpRevision(db, input.sessionKey);
 		return mapInput(db.prepare(`${SELECT_INPUTS} WHERE id = ?`).get(input.id));
 	});
@@ -92,6 +100,9 @@ function claimNextSessionInput(sessionKey, runId) {
 	return runSqliteWriteTransaction((db) => {
 		ensureRuntime(db, sessionKey);
 		if (db.prepare(`SELECT active_run_id FROM session_input_runtime WHERE session_key = ?`).get(sessionKey).active_run_id) return void 0;
+		if (db.prepare(`UPDATE session_inputs SET status = 'interrupted', error = 'Session changed before delivery',
+      version = version + 1, updated_at_ms = ? WHERE session_key = ? AND status = 'queued'
+      AND expected_session_id IS NOT NULL AND expected_session_id IS NOT ?`).run(Date.now(), sessionKey, readCurrentSessionId(db, sessionKey)).changes) bumpRevision(db, sessionKey);
 		const row = db.prepare(`${SELECT_INPUTS} WHERE session_key = ? AND effective_delivery = 'next'
       AND status = 'queued' ORDER BY position, created_at_ms, id LIMIT 1`).get(sessionKey);
 		if (!row) return void 0;
@@ -166,4 +177,4 @@ function recoverSessionInputState() {
 	});
 }
 //#endregion
-export { cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, insertSessionInput, listActiveSessionInputRuns, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus };
+export { SessionInstanceChangedError, cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, finishSessionInputRun, getSessionInputById, getSessionInputState, insertSessionInput, listActiveSessionInputRuns, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus };

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

@@ -1,8 +1,8 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
 import { buildFts5SearchQuery } from "./fts.js";
+import { validateSessionId } from "../../session/session-id.js";
 import { buildDefaultSessionMetadata } from "./session-metadata.js";
 import { buildGlobalSessionStats, metadataToSessionInsert, sessionRowToMetadata } from "./row-mappers.js";
-import { validateSessionId } from "../../session/session-id.js";
 import { randomUUID } from "node:crypto";
 //#region src/storage/sqlite/session-repository.ts
 const SESSION_COLUMNS = `

package/dist/src/tasks/execution-context.d.ts

@@ -1,4 +1,5 @@
 import type { SessionMetadata } from '../session/types.js';
+import type { ExecutionEnvironmentKind } from '../execution-environments/types.js';
 export type ExecutionOrigin = 'chat' | 'task' | 'workflow' | 'automation' | 'browser' | 'proactive';
 export type ExecutionTrigger = 'user' | 'schedule' | 'webhook' | 'proactive' | 'retry';
 export interface ExecutionContext {
@@ -6,7 +7,8 @@ export interface ExecutionContext {
     sessionKey: string;
     channel: string;
     agentId?: string;
-    strategy?: string;
+    executionEnvironmentId?: string;
+    executionKind?: ExecutionEnvironmentKind;
     taskId?: string;
     projectId?: string;
     origin: ExecutionOrigin;