@xopcai/xopc 0.0.395 → 0.0.397

package/dist/src/gateway/service.js

@@ -81,13 +81,10 @@ import "../infra/bus/index.js";
 import { collectMediaUrisFromMessages, deleteMediaUris } from "../media/session-references.js";
 import { AgentService } from "../agent/service.js";
 import { bootstrapApplicationStateSync } from "../bootstrap/application-state.js";
-import { setPairingBroadcastSink } from "../channels/pairing/pairing-events.js";
-import { registerClarificationChannelRuntime } from "./clarify-runtime.js";
-import { ChannelManager } from "../channels/manager.js";
-import { configureGatewayHttpProxy } from "../infra/http-proxy-env.js";
-import "../config/index.js";
 import { ChatPreviewService } from "../chat-previews/service.js";
 import "../chat-previews/index.js";
+import { configureGatewayHttpProxy } from "../infra/http-proxy-env.js";
+import "../config/index.js";
 import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
@@ -103,8 +100,13 @@ import { DiscussionSealer } from "../discussions/sealer.js";
 import "../discussions/index.js";
 import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
 import "../endpoint-tools/index.js";
+import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
+import { HomeAdviceGenerator } from "../home-intelligence/generator.js";
+import { HomeIntelligenceHost } from "../home-intelligence/host.js";
+import { HomeSnapshotBuilder } from "../home-intelligence/snapshot.js";
 import { assertGatewayAuthConfigured, extractToken, resolveGatewayAuth, validateToken } from "./auth.js";
 import { prepareAutomationAgentSession } from "./automation-agent-session.js";
+import { registerClarificationChannelRuntime } from "./clarify-runtime.js";
 import { stopTailscaleExposure } from "./tailscale-lifecycle.js";
 import { getGatewayFileSpaceService } from "./file-space-service.js";
 import { reconcileHomeIntelligenceAutomation } from "./home-intelligence-automation-reconciler.js";
@@ -118,6 +120,8 @@ import { WorkDiscoveryService } from "../work-discovery/service.js";
 import { buildVoiceMemoryContext } from "../voice/realtime/memory-context.js";
 import { buildVoicePersonaContext } from "../voice/realtime/persona-context.js";
 import { voiceMemoryBudget, voicePersonaBudget } from "../voice/realtime/conversation-context.js";
+import { setPairingBroadcastSink } from "../channels/pairing/pairing-events.js";
+import { ChannelManager } from "../channels/manager.js";
 import "../notes/index.js";
 import { buildWorkflowChildTools } from "../agent/workflow/workflow-child-tools.js";
 import { WorkflowRunService } from "../workflows/service/workflow-run-service.js";
@@ -163,10 +167,6 @@ import { TaskMainUpdateDecisionService } from "../tasks/task-main-update-decisio
 import { selectTaskMainUpdateAttempt, submitAndConfirmTaskMainUpdate } from "../tasks/task-main-update-input.js";
 import { checkAppContextAccess, prepareAppContext } from "./service/app-context-access.js";
 import { applyAutomaticVoiceLanguage, inferProductLanguageFromEnvironment, initializeVoiceDefaults } from "../voice/language-profile.js";
-import { HomeAdviceGenerator } from "../home-intelligence/generator.js";
-import { HomeIntelligenceHost } from "../home-intelligence/host.js";
-import { HomeSnapshotBuilder } from "../home-intelligence/snapshot.js";
-import { HomeCapabilityPreflightService } from "../home-intelligence/capability-preflight.js";
 import crypto from "node:crypto";
 //#region src/gateway/service.ts
 init_session_repository();
@@ -1572,6 +1572,8 @@ var GatewayService = class {
 		await flushTracing();
 		if (!this.running) return;
 		this.stopping = true;
+		const { cancelAllPluginCliAuthorizations } = await import("../extensions/agent-plugins/cli-authorization.js");
+		cancelAllPluginCliAuthorizations();
 		this.taskAllocationDispatcher?.stop();
 		this.taskRunDispatcher?.stop();
 		if (this.taskRunDispatchTimer) {

package/dist/src/gateway/session-context-summary.js

@@ -11,8 +11,8 @@ import { effectiveWorkspacePathForSession } from "../session/session-workspace.j
 import { ProjectStore } from "../projects/project-store.js";
 import { TaskOriginRepository } from "../tasks/task-origin-repository.js";
 import { TaskConversationRepository } from "../tasks/task-conversation-repository.js";
-import { TaskCollaborationRepository } from "../tasks/task-collaboration-repository.js";
 import { runExec } from "../infra/exec.js";
+import { TaskCollaborationRepository } from "../tasks/task-collaboration-repository.js";
 import { isSessionSourceBinding } from "../agent/source-context/types.js";
 import { realpath, stat } from "node:fs/promises";
 //#region src/gateway/session-context-summary.ts

package/dist/src/gateway/xopc-cloud-capability-setup.d.ts

@@ -42,6 +42,8 @@ export declare function selectXopcCloudCapabilities(source: CatalogSource): {
     selection?: XopcCloudCapabilitySelection;
     missing: CloudCapability[];
 };
+/** Fill model uses without enabling desktop control or replacing explicit routes. */
+export declare function completeXopcCloudModelRoutes(models: AgentDefaults['models'], source: CatalogSource): AgentDefaults['models'];
 /** Build one atomic config update for the managed XOPC Cloud chat and media capabilities. */
 export declare function prepareXopcCloudCapabilitySetup(config: Config, source: CatalogSource): PrepareXopcCloudCapabilitySetupResult;
 export declare function applyXopcCloudCapabilitySetup(service: {
@@ -50,5 +52,7 @@ export declare function applyXopcCloudCapabilitySetup(service: {
         saved: boolean;
         error?: string;
     }>;
+}, options?: {
+    enableAvailable?: boolean;
 }): Promise<ApplyXopcCloudCapabilitySetupResult>;
 export {};

package/dist/src/gateway/xopc-cloud-capability-setup.js

@@ -3,16 +3,21 @@ import { init_agent_config } from "../agent-config/index.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
 import { AgentCatalogService } from "../agent-catalog/service.js";
 import { ConfigSchema, init_schema } from "../config/schema.js";
+import { init_model_policy, isComputerModel, isDedicatedComputerProfile } from "../computer/model-policy.js";
+import { voiceSupportsMode } from "../../packages/realtime-protocol/src/voice-catalog.js";
+import { init_voice } from "../../packages/realtime-protocol/src/voice.js";
 import { getModelCatalogStore, init_model_catalog_store } from "../providers/model-catalog-store.js";
 import { compareCatalogModels } from "../providers/model-catalog-ranking.js";
 import { prepareUpdateGlobalDefaults } from "./global-defaults-admin.js";
 //#region src/gateway/xopc-cloud-capability-setup.ts
+init_voice();
+init_model_policy();
 init_schema();
 init_agent_config();
 init_repository();
 init_model_catalog_store();
 function supportsCapability(model, capability) {
-	if (model.availability !== "available") return false;
+	if (model.availability !== "available" || isDedicatedComputerProfile(model.computerUse?.profile)) return false;
 	if (capability === "chat") return model.kind === "language" && (model.operations.includes("chat.completions") || model.operations.includes("responses"));
 	if (capability === "vision") return model.kind === "language" && model.input.includes("image");
 	if (capability === "image-generation") return model.kind === "image" && model.operations.includes("images.generate");
@@ -25,10 +30,10 @@ function recommendedModel(source, capability) {
 }
 function recommendedVoiceModel(source, mode) {
 	const recommendation = mode === "transcription.stream" ? source.recommended?.stt : mode === "speech.stream" ? source.recommended?.tts : void 0;
-	return source.models.filter((model) => model.availability === "available" && model.voice?.modes.includes(mode) && (mode === "transcription.stream" || Boolean(model.voice.voices.length))).sort((left, right) => compareCatalogModels(left, right, recommendation))[0];
+	return source.models.filter((model) => model.availability === "available" && model.voice?.modes.includes(mode) && (mode === "transcription.stream" || model.voice.voices.some((voice) => voiceSupportsMode(voice, mode)))).sort((left, right) => compareCatalogModels(left, right, recommendation))[0];
 }
-function selectedVoice(model) {
-	const voices = model.voice?.voices ?? [];
+function selectedVoice(model, mode) {
+	const voices = model.voice?.voices.filter((voice) => voiceSupportsMode(voice, mode)) ?? [];
 	return voices.find((voice) => voice.id === "Cherry")?.id ?? voices.find((voice) => voice.id === model.voice?.defaultVoice)?.id ?? voices[0].id;
 }
 function selectXopcCloudCapabilities(source) {
@@ -59,15 +64,44 @@ function selectXopcCloudCapabilities(source) {
 			...realtimeStt ? { realtimeStt: realtimeStt.id } : {},
 			...realtimeTts ? { realtimeTts: {
 				model: realtimeTts.id,
-				voice: selectedVoice(realtimeTts)
+				voice: selectedVoice(realtimeTts, "speech.stream")
 			} } : {},
 			...realtimeOmni ? { realtimeOmni: {
 				model: realtimeOmni.id,
-				voice: selectedVoice(realtimeOmni)
+				voice: selectedVoice(realtimeOmni, "conversation")
 			} } : {}
 		}
 	};
 }
+/** Fill model uses without enabling desktop control or replacing explicit routes. */
+function completeXopcCloudModelRoutes(models, source) {
+	const next = structuredClone(models);
+	const chat = recommendedModel(source, "chat");
+	const vision = recommendedModel(source, "vision");
+	const reasoning = source.models.filter((model) => supportsCapability(model, "chat") && model.reasoning).sort((left, right) => compareCatalogModels(left, right, "advanced"))[0] ?? chat;
+	const route = (model) => ({
+		primary: `xopc-cloud/${model.id}`,
+		fallbacks: []
+	});
+	if (chat) {
+		next.background ??= route(chat);
+		next.intents.fast ??= route(chat);
+		next.intents.understanding ??= structuredClone(next.background);
+	}
+	if (reasoning) for (const intent of [
+		"reasoning",
+		"coding",
+		"review"
+	]) next.intents[intent] ??= route(reasoning);
+	if (vision) next.intents.vision ??= route(vision);
+	const computer = source.models.filter((model) => model.availability === "available" && isComputerModel({
+		...model,
+		provider: source.providerId,
+		api: source.api
+	})).sort((left, right) => compareCatalogModels(left, right))[0];
+	if (computer) next.computerUse ??= route(computer);
+	return next;
+}
 /** Build one atomic config update for the managed XOPC Cloud chat and media capabilities. */
 function prepareXopcCloudCapabilitySetup(config, source) {
 	const selected = selectXopcCloudCapabilities(source);
@@ -81,7 +115,7 @@ function prepareXopcCloudCapabilitySetup(config, source) {
 	const currentModels = currentDefaults.models;
 	const defaultsUpdate = prepareUpdateGlobalDefaults({ defaults: {
 		...currentDefaults,
-		models: {
+		models: completeXopcCloudModelRoutes({
 			...currentModels,
 			chat: {
 				primary: `xopc-cloud/${selection.chat}`,
@@ -97,7 +131,7 @@ function prepareXopcCloudCapabilitySetup(config, source) {
 				primary: `xopc-cloud/${selection.imageGeneration}`,
 				fallbacks: currentModels.imageGeneration?.fallbacks ?? []
 			}
-		}
+		}, source)
 	} });
 	if (defaultsUpdate.ok === false) return {
 		ok: false,
@@ -176,7 +210,7 @@ function prepareXopcCloudCapabilitySetup(config, source) {
 		}
 	};
 }
-async function applyXopcCloudCapabilitySetup(service) {
+async function applyXopcCloudCapabilitySetup(service, options = {}) {
 	const source = getModelCatalogStore().getSource("xopc-cloud");
 	if (!source) return {
 		configured: false,
@@ -207,49 +241,78 @@ async function applyXopcCloudCapabilitySetup(service) {
 		fallbacks: [],
 		autoProviderFallback: false
 	};
-	if (stt && !nextConfig.tools?.media?.audio) {
+	if (stt && (options.enableAvailable || !nextConfig.tools?.media?.audio)) {
 		nextConfig.tools ??= {};
 		nextConfig.tools.media ??= {};
+		const current = nextConfig.tools.media.audio;
 		nextConfig.tools.media.audio = {
+			...current,
 			enabled: true,
 			provider: "xopc-cloud",
 			fallback: {
 				enabled: false,
 				order: ["xopc-cloud"]
 			},
-			providers: { "xopc-cloud": { model: stt.id } }
+			models: [{
+				provider: "xopc-cloud",
+				model: stt.id,
+				capabilities: ["audio"]
+			}],
+			providers: {
+				...current?.providers,
+				"xopc-cloud": {
+					...current?.providers?.["xopc-cloud"],
+					model: stt.id
+				}
+			}
 		};
 	}
-	if (tts && tts.tts?.defaultVoice && !nextConfig.messages?.tts) {
+	if (tts && tts.tts?.defaultVoice && (options.enableAvailable || !nextConfig.messages?.tts)) {
 		nextConfig.messages ??= {};
+		const current = nextConfig.messages.tts;
 		nextConfig.messages.tts = {
+			...current,
 			enabled: true,
 			provider: "xopc-cloud",
-			trigger: "off",
+			trigger: current?.trigger ?? "off",
+			fallback: {
+				enabled: false,
+				order: []
+			},
 			maxTextLength: 512,
 			timeoutMs: 6e4,
-			providers: { "xopc-cloud": {
-				model: tts.id,
-				voice: tts.tts.defaultVoice
-			} }
+			providers: {
+				...current?.providers,
+				"xopc-cloud": {
+					...current?.providers?.["xopc-cloud"],
+					model: tts.id,
+					voice: tts.tts.defaultVoice
+				}
+			}
 		};
 	}
-	if (!nextConfig.voice && (realtimeStt || realtimeTts || realtimeOmni)) nextConfig.voice = ConfigSchema.parse({ voice: { realtime: { enabled: true } } }).voice;
+	if ((options.enableAvailable || !nextConfig.voice) && (realtimeStt || realtimeTts || realtimeOmni)) nextConfig.voice = ConfigSchema.parse({ voice: {
+		...nextConfig.voice,
+		realtime: {
+			...nextConfig.voice?.realtime,
+			enabled: true
+		}
+	} }).voice;
 	const realtime = nextConfig.voice?.realtime;
 	if (realtime?.enabled) {
-		if (realtimeStt && !realtime.stt) realtime.stt = {
+		if (realtimeStt && (options.enableAvailable || !realtime.stt)) realtime.stt = {
 			provider: "xopc-cloud",
 			model: realtimeStt.id
 		};
-		if (realtimeTts && !realtime.tts) realtime.tts = {
+		if (realtimeTts && (options.enableAvailable || !realtime.tts)) realtime.tts = {
 			provider: "xopc-cloud",
 			model: realtimeTts.id,
-			voice: selectedVoice(realtimeTts)
+			voice: selectedVoice(realtimeTts, "speech.stream")
 		};
-		if (realtimeOmni && !realtime.omni) realtime.omni = {
+		if (realtimeOmni && (options.enableAvailable || !realtime.omni)) realtime.omni = {
 			provider: "xopc-cloud",
 			model: realtimeOmni.id,
-			voice: selectedVoice(realtimeOmni),
+			voice: selectedVoice(realtimeOmni, "conversation"),
 			instructions: "Keep replies conversational and concise. You cannot execute tools."
 		};
 	}
@@ -258,6 +321,7 @@ async function applyXopcCloudCapabilitySetup(service) {
 		error: "XOPC Cloud published no usable models",
 		missing: selection.missing
 	};
+	nextDefaults.models = completeXopcCloudModelRoutes(nextDefaults.models, source);
 	const defaultsUpdate = prepareUpdateGlobalDefaults({ defaults: nextDefaults });
 	if (defaultsUpdate.ok === false) return {
 		configured: false,
@@ -284,14 +348,14 @@ async function applyXopcCloudCapabilitySetup(service) {
 			...realtimeStt ? { realtimeStt: realtimeStt.id } : {},
 			...realtimeTts ? { realtimeTts: {
 				model: realtimeTts.id,
-				voice: selectedVoice(realtimeTts)
+				voice: selectedVoice(realtimeTts, "speech.stream")
 			} } : {},
 			...realtimeOmni ? { realtimeOmni: {
 				model: realtimeOmni.id,
-				voice: selectedVoice(realtimeOmni)
+				voice: selectedVoice(realtimeOmni, "conversation")
 			} } : {}
 		}
 	};
 }
 //#endregion
-export { applyXopcCloudCapabilitySetup, prepareXopcCloudCapabilitySetup, selectXopcCloudCapabilities };
+export { applyXopcCloudCapabilitySetup, completeXopcCloudModelRoutes, prepareXopcCloudCapabilitySetup, selectXopcCloudCapabilities };

package/dist/src/home-intelligence/host.js

@@ -1,10 +1,10 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { HomeAdviceBudgetExceededError, isHomeProseLocalized } from "./generator.js";
 import { homePatternKey } from "./strategy.js";
-import { HomeAdvicePolicy } from "./policy.js";
 import { HomeIntelligenceRepository } from "./repository.js";
 import { HomeOpportunityApplicationService } from "./application-service.js";
+import { HomeAdvicePolicy } from "./policy.js";
+import { HomeAdviceBudgetExceededError, isHomeProseLocalized } from "./generator.js";
 import { buildHomeOpportunityNotification } from "./notification.js";
 import { createHash } from "node:crypto";
 //#region src/home-intelligence/host.ts

package/dist/src/providers/setup/engine.js

@@ -93,7 +93,8 @@ function previewProviderSetup(snapshot, request = {}) {
 				coding: complex,
 				review: complex
 			} : {},
-			...recommended.vision ? { vision: recommended.vision } : {}
+			...recommended.vision ? { vision: recommended.vision } : {},
+			...recommended.background ? { understanding: recommended.background } : {}
 		},
 		uses: [...uses, ...snapshot.voice ? [
 			"transcription",
@@ -139,15 +140,8 @@ function applyProviderSetup(snapshot, request, revision) {
 	for (const use of preview.uses) {
 		if (!use.selected) continue;
 		if (!use.recommended) throw new Error(`Choose a model for ${use.id}`);
-		if (use.id === "chat") {
-			models.chat = route(use.recommended);
-			for (const [intent, ref] of Object.entries(preview.taskModels)) {
-				const key = intent;
-				const existing = models.intents[key];
-				const keep = request.mode !== "replace" && existing && snapshot.configuredProviders.has(existing.primary.split("/")[0]);
-				if (ref && !keep && (intent !== "vision" || preview.uses.some((use) => use.id === "vision" && use.selected))) models.intents[key] = route(ref);
-			}
-		} else if (use.id === "vision") models.imageUnderstanding = route(use.recommended);
+		if (use.id === "chat") models.chat = route(use.recommended);
+		else if (use.id === "vision") models.imageUnderstanding = route(use.recommended);
 		else if (use.id === "image") models.imageGeneration = {
 			...models.imageGeneration,
 			...route(use.recommended),
@@ -164,6 +158,14 @@ function applyProviderSetup(snapshot, request, revision) {
 			});
 		}
 	}
+	for (const [intent, ref] of Object.entries(preview.taskModels)) {
+		const key = intent;
+		const useId = intent === "vision" ? "vision" : intent === "understanding" ? "background" : "chat";
+		if (!preview.uses.some((use) => use.id === useId && use.selected)) continue;
+		const existing = models.intents[key];
+		const keep = request.mode !== "replace" && existing && snapshot.configuredProviders.has(existing.primary.split("/")[0]);
+		if (ref && !keep) models.intents[key] = route(ref);
+	}
 	return {
 		defaults: {
 			...snapshot.defaults,

package/dist/src/providers/setup/voice.js

@@ -2,6 +2,7 @@ import { ConfigSchema, init_schema } from "../../config/schema.js";
 import { voiceSupportsMode } from "../../../packages/realtime-protocol/src/voice-catalog.js";
 import { init_voice } from "../../../packages/realtime-protocol/src/voice.js";
 import { getModelCatalogStore, init_model_catalog_store } from "../model-catalog-store.js";
+import { compareCatalogModels } from "../model-catalog-ranking.js";
 import { BAILIAN_PLAN_HOST, BAILIAN_PLAN_OMNI_MODEL, BAILIAN_PLAN_OMNI_VOICE, BAILIAN_PLAN_PROVIDER, BAILIAN_PLAN_STT_MODEL, BAILIAN_PLAN_TTS_MODEL, BAILIAN_PLAN_TTS_VOICE } from "../../voice/token-plan.js";
 import { listSttProvidersForApi } from "../../voice/stt/list-providers.js";
 import { listTtsProvidersForApi } from "../../voice/tts/list-providers.js";
@@ -70,6 +71,14 @@ function readSetupVoiceState(provider, config) {
 				});
 			}
 		}
+		for (const use of voiceSetupUses) {
+			const candidates = choices[use];
+			const recommendation = use === "conversation" ? void 0 : source?.recommended?.[use === "speech" ? "tts" : "stt"];
+			candidates.sort((left, right) => {
+				return compareCatalogModels(source.models.find((entry) => entry.id === left.model), source.models.find((entry) => entry.id === right.model), recommendation);
+			});
+			if (candidates[0]) candidates[0].recommended = true;
+		}
 	}
 	if (provider !== "qwen-token-plan-cn" && provider !== "xopc-cloud") for (const [use, entries] of [["transcription", listSttProvidersForApi(config).providers], ["speech", listTtsProvidersForApi(config).providers]]) {
 		const entry = entries.find((entry) => entry.id === provider && entry.configured);
@@ -109,12 +118,21 @@ function readSetupVoiceState(provider, config) {
 function applySetupVoice(config, assignments) {
 	let next = structuredClone(config);
 	for (const { use, model } of assignments) {
-		if (model.provider === "xopc-cloud") next = selectPlatformVoice(next, {
-			mode: use,
-			model: model.model,
-			...model.voice ? { voice: model.voice } : {}
-		});
-		else if (model.provider === "qwen-token-plan-cn") if (use === "speech") {
+		if (model.provider === "xopc-cloud") {
+			next = selectPlatformVoice(next, {
+				mode: use,
+				model: model.model,
+				...model.voice ? { voice: model.voice } : {}
+			});
+			const streamMode = use === "speech" ? "speech.stream" : use === "transcription" ? "transcription.stream" : void 0;
+			if (streamMode) {
+				const stream = getModelCatalogStore().getSource("xopc-cloud")?.models.filter((entry) => entry.availability === "available" && entry.voice?.modes.includes(streamMode) && (use === "transcription" || entry.voice.voices.some((voice) => voiceSupportsMode(voice, streamMode)))).sort((left, right) => compareCatalogModels(left, right, model.model))[0];
+				if (stream) next = selectPlatformVoice(next, {
+					mode: streamMode,
+					model: stream.id
+				});
+			}
+		} else if (model.provider === "qwen-token-plan-cn") if (use === "speech") {
 			const current = next.messages?.tts;
 			const previous = current?.providers?.[model.provider];
 			const voice = (!previous?.model || previous.model === model.model) && typeof previous?.voice === "string" ? previous.voice : model.voice;

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

@@ -1,12 +1,13 @@
 export declare const COMPOSER_INPUT_HISTORY_LIMIT = 100;
 export interface ComposerInputHistoryItem {
+    conversationId: string;
     id: number;
     text: string;
     createdAt: number;
 }
-export declare function listComposerInputHistory(limit?: number): ComposerInputHistoryItem[];
-export declare function appendComposerInputHistory(text: string, now?: number): {
+export declare function listComposerInputHistory(conversationId: string, limit?: number): ComposerInputHistoryItem[];
+export declare function appendComposerInputHistory(conversationId: string, text: string, now?: number): {
     item: ComposerInputHistoryItem;
     inserted: boolean;
 };
-export declare function clearComposerInputHistory(): number;
+export declare function clearComposerInputHistory(conversationId: string): number;

package/dist/src/storage/sqlite/composer-input-history-repository.js

@@ -3,30 +3,32 @@ import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "
 //#region src/storage/sqlite/composer-input-history-repository.ts
 function fromRow(row) {
 	return {
+		conversationId: row.conversation_id,
 		id: row.id,
 		text: row.text,
 		createdAt: row.created_at
 	};
 }
-function listComposerInputHistory(limit = 100) {
+function listComposerInputHistory(conversationId, limit = 100) {
 	const boundedLimit = Number.isFinite(limit) ? Math.min(100, Math.max(1, Math.trunc(limit))) : 100;
-	return getSqliteDatabase().prepare("SELECT id, text, created_at FROM composer_input_history ORDER BY id DESC LIMIT ?").all(boundedLimit).map(fromRow);
+	return getSqliteDatabase().prepare("SELECT conversation_id, id, text, created_at FROM composer_input_history WHERE conversation_id = ? ORDER BY id DESC LIMIT ?").all(conversationId, boundedLimit).map(fromRow);
 }
-function appendComposerInputHistory(text, now = Date.now()) {
+function appendComposerInputHistory(conversationId, text, now = Date.now()) {
 	const normalized = text.trim();
 	if (!normalized) throw new Error("Composer history text is required");
 	return runSqliteWriteTransaction((db) => {
-		const latest = db.prepare("SELECT id, text, created_at FROM composer_input_history ORDER BY id DESC LIMIT 1").get();
+		const latest = db.prepare("SELECT conversation_id, id, text, created_at FROM composer_input_history WHERE conversation_id = ? ORDER BY id DESC LIMIT 1").get(conversationId);
 		if (latest?.text === normalized) return {
 			item: fromRow(latest),
 			inserted: false
 		};
-		const result = db.prepare("INSERT INTO composer_input_history (text, created_at) VALUES (?, ?)").run(normalized, now);
+		const result = db.prepare("INSERT INTO composer_input_history (conversation_id, text, created_at) VALUES (?, ?, ?)").run(conversationId, normalized, now);
 		const id = Number(result.lastInsertRowid);
 		db.prepare(`DELETE FROM composer_input_history
-       WHERE id NOT IN (SELECT id FROM composer_input_history ORDER BY id DESC LIMIT ?)`).run(100);
+       WHERE conversation_id = ? AND id NOT IN (SELECT id FROM composer_input_history WHERE conversation_id = ? ORDER BY id DESC LIMIT ?)`).run(conversationId, conversationId, 100);
 		return {
 			item: {
+				conversationId,
 				id,
 				text: normalized,
 				createdAt: now
@@ -35,8 +37,8 @@ function appendComposerInputHistory(text, now = Date.now()) {
 		};
 	});
 }
-function clearComposerInputHistory() {
-	return Number(runSqliteWriteTransaction((db) => db.prepare("DELETE FROM composer_input_history").run().changes));
+function clearComposerInputHistory(conversationId) {
+	return Number(runSqliteWriteTransaction((db) => db.prepare("DELETE FROM composer_input_history WHERE conversation_id = ?").run(conversationId).changes));
 }
 var COMPOSER_INPUT_HISTORY_LIMIT;
 var init_composer_input_history_repository = __esmMin((() => {

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

@@ -5,8 +5,8 @@ import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { init_gateway_scopes } from "../../gateway/security/gateway-scopes.js";
 import { createDevice, getDevice, init_device_access_repository, registerInitialDeviceRefreshToken, revokeDevice } from "./device-access-repository.js";
 import { getOrCreateGatewayIdentity, init_gateway_identity_repository } from "./gateway-identity-repository.js";
-import { browserEnrollmentPublicKeyThumbprint } from "../../browser/enrollment.js";
 import "../../browser/extension-identity.js";
+import { browserEnrollmentPublicKeyThumbprint } from "../../browser/enrollment.js";
 import crypto from "node:crypto";
 //#region src/storage/sqlite/device-pairing-approval.ts
 init_src();

package/dist/src/storage/sqlite/migrations/257_session_composer_history.sql

@@ -0,0 +1,11 @@
+-- Keep unscoped legacy entries out of session recall.
+ALTER TABLE composer_input_history RENAME TO composer_input_history_legacy;
+DROP INDEX idx_composer_input_history_recent;
+CREATE TABLE composer_input_history (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  conversation_id TEXT NOT NULL REFERENCES sessions(conversation_id) ON DELETE CASCADE,
+  text TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX idx_composer_input_history_recent
+  ON composer_input_history(conversation_id, id 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 = 217;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 256;
+export declare const XOPC_DB_SCHEMA_VERSION = 257;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

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

@@ -48,7 +48,7 @@ function applySingleMigration(db, migration) {
 function applyPendingMigrations(db, options = {}) {
 	db.function("xopc_memory_search_text", { deterministic: true }, (value) => memorySearchText(String(value ?? "")));
 	db.function("xopc_operation_id", () => currentOperationId() ?? null);
-	const targetVersion = options.targetVersion ?? 256;
+	const targetVersion = options.targetVersion ?? 257;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (!options.migrationsDir && currentVersion < 217) throw new DatabaseSchemaTooOldError(currentVersion, 217);
@@ -65,7 +65,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 256;
+	const appVersion = options.targetVersion ?? 257;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,
@@ -105,7 +105,7 @@ var init_runner = __esmMin((() => {
 	init_errors();
 	log = createLogger("Sqlite:Migrations");
 	XOPC_DB_BASELINE_SCHEMA_VERSION = 217;
-	XOPC_DB_SCHEMA_VERSION = 256;
+	XOPC_DB_SCHEMA_VERSION = 257;
 }));
 //#endregion
 init_runner();

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

@@ -26,7 +26,7 @@ function ensureXopcDatabaseSchema(db) {
 		bootstrapFreshDatabase(db);
 		currentVersion = 217;
 	}
-	applyPendingMigrations(db, { targetVersion: 256 });
+	applyPendingMigrations(db, { targetVersion: 257 });
 }
 var init_schema = __esmMin((() => {
 	init_sql_assets();

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

@@ -36,9 +36,9 @@ export declare class EmbeddedBackend implements TuiBackend {
     onDisconnected?: (reason: string) => void;
     constructor(opts?: EmbeddedBackendOptions);
     get connectionLabel(): string;
-    getComposerInputHistory(): Promise<TuiComposerHistoryItem[]>;
+    getComposerInputHistory(conversationId: string): Promise<TuiComposerHistoryItem[]>;
     getComposerDraftDirectory(): Promise<string>;
-    recordComposerInputHistory(text: string): Promise<TuiComposerHistoryItem>;
+    recordComposerInputHistory(conversationId: string, text: string): Promise<TuiComposerHistoryItem>;
     start(): void;
     private ensureAgent;
     private createAgent;

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

@@ -104,14 +104,14 @@ var EmbeddedBackend = class {
 	get connectionLabel() {
 		return "local embedded";
 	}
-	async getComposerInputHistory() {
-		return listComposerInputHistory();
+	async getComposerInputHistory(conversationId) {
+		return listComposerInputHistory(conversationId);
 	}
 	async getComposerDraftDirectory() {
 		return join(resolveStateDir(), "client-drafts", "embedded", "composers");
 	}
-	async recordComposerInputHistory(text) {
-		return appendComposerInputHistory(text).item;
+	async recordComposerInputHistory(conversationId, text) {
+		return appendComposerInputHistory(conversationId, text).item;
 	}
 	start() {
 		if (this.running) return;

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

@@ -42,8 +42,8 @@ export declare class GatewayRealtimeBackend implements TuiBackend {
     start(): void;
     stop(): void;
     getActiveSignal(): AbortSignal | undefined;
-    getComposerInputHistory(): Promise<TuiComposerHistoryItem[]>;
-    recordComposerInputHistory(text: string): Promise<TuiComposerHistoryItem>;
+    getComposerInputHistory(conversationId: string): Promise<TuiComposerHistoryItem[]>;
+    recordComposerInputHistory(conversationId: string, text: string): Promise<TuiComposerHistoryItem>;
     private acceptReceipt;
     private reconcileInput;
     private prepareInput;

package/dist/src/tui/backends/gateway-realtime-backend.js

@@ -133,15 +133,18 @@ var GatewayRealtimeBackend = class {
 		const signal = this.chatAbort?.signal;
 		return signal && !signal.aborted ? signal : void 0;
 	}
-	async getComposerInputHistory() {
-		const res = await gatewayFetch(this.baseUrl, "/api/composer-history", this.credential);
+	async getComposerInputHistory(conversationId) {
+		const res = await gatewayFetch(this.baseUrl, `/api/composer-history?conversationId=${encodeURIComponent(conversationId)}`, this.credential);
 		if (!res.ok) throw new Error(`Failed to load composer history (${res.status})`);
 		return (await res.json()).items ?? [];
 	}
-	async recordComposerInputHistory(text) {
+	async recordComposerInputHistory(conversationId, text) {
 		const res = await gatewayFetch(this.baseUrl, "/api/composer-history", this.credential, {
 			method: "POST",
-			body: JSON.stringify({ text })
+			body: JSON.stringify({
+				conversationId,
+				text
+			})
 		});
 		if (!res.ok) throw new Error(`Failed to save composer history (${res.status})`);
 		return (await res.json()).item;