@xopcai/xopc 0.0.353 → 0.0.354

package/dist/src/gateway/hono/routes/voice.js

@@ -7,6 +7,7 @@ import { STTTranscriptionError, transcribe } from "../../../voice/stt/transcribe
 import { isSTTAvailable } from "../../../voice/stt/availability.js";
 import { mergeSttConfigFromAppConfig } from "../../../voice/stt/config.js";
 import "../../../voice/stt/index.js";
+import { isPersonalConversation } from "../../../personal-agent/repository.js";
 import { resolveTtsProviderConfigSlice } from "../../../voice/tts/config-slice.js";
 import { isTTSAvailable, resolveSpeechProvider } from "../../../voice/tts/factory.js";
 import { speak, speakStream } from "../../../voice/tts/speak-core.js";
@@ -268,6 +269,13 @@ function registerVoiceRoutes(authenticated, deps) {
 				message: "Invalid realtime voice session request"
 			}
 		}, 400);
+		if (parsed.data.conversationId && isPersonalConversation(parsed.data.conversationId) && parsed.data.mode !== "assistant") return c.json({
+			ok: false,
+			error: {
+				code: "INVALID_REQUEST",
+				message: "Personal AI voice requires assistant mode"
+			}
+		}, 400);
 		try {
 			const preparation = parsed.data.conversationId ? getSessionPreparation(parsed.data.conversationId) : void 0;
 			if (preparation && preparation.state !== "ready") return c.json({

package/dist/src/gateway/image-generation-setup.js

@@ -1,11 +1,11 @@
 import { normalizeAgentId } from "../agent-catalog/id.js";
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
-import { init_agent_scope } from "../agent/agent-scope.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { ConfigSchema, init_schema } from "../config/schema.js";
+import { init_agent_scope } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentConfigForAgent } from "../config/agent-profile.js";
 import { fetchWithTimeoutGuarded } from "../media-shared/http/provider-http.js";
 import "../media-shared/http/index.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { getImageGenerationProvider, listImageGenerationProvidersSummary } from "../agent/image/generation/provider-registry.js";
 //#region src/gateway/image-generation-setup.ts
 init_repository();

package/dist/src/gateway/lock.js

@@ -1,8 +1,8 @@
 import path from "node:path";
 import fs from "node:fs";
 import { createHash } from "node:crypto";
-import fs$1 from "node:fs/promises";
 import net from "node:net";
+import fs$1 from "node:fs/promises";
 import { homedir } from "os";
 //#region src/gateway/lock.ts
 /**

package/dist/src/gateway/service/session-command-service.js

@@ -1,9 +1,11 @@
 import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
 import { init_session_repository } from "../../storage/sqlite/session-repository.js";
+import { resolveEffectiveAgentConfigForAgent, resolveEffectiveAgentConfigForSession } from "../../config/agent-profile.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
 import { resolveProjectAgentId } from "../../projects/project-agent.js";
 import "../../projects/index.js";
 import { getModelThinking } from "../../providers/model-thinking.js";
+import { getPersonalAgentByConversation } from "../../personal-agent/repository.js";
 import { withModelConfigLock } from "../../session/model-config-lock.js";
 import { SessionCommandError, acceptSessionCommand, getSessionPreparation, matchSessionInputReceipt, sessionCommandHash } from "../../storage/sqlite/session-creation-repository.js";
 //#region src/gateway/service/session-command-service.ts
@@ -24,6 +26,10 @@ function validateCreation(service, creation) {
 }
 async function receiveSessionCommand(service, conversationId, principalId, command, prepareSourceContexts = async () => []) {
 	return withModelConfigLock(conversationId, async () => {
+		const personal = getPersonalAgentByConversation(conversationId);
+		if (personal && "creation" in command && command.creation.agentId !== personal.agentId) throw new SessionCommandError("BAD_REQUEST", "Personal AI identity is fixed");
+		const configuredThinking = ("creation" in command ? resolveEffectiveAgentConfigForAgent(command.creation.agentId) : resolveEffectiveAgentConfigForSession(conversationId)).config.runtime.thinkingLevel;
+		if (configuredThinking && "creation" in command && command.creation.thinkingLevel !== configuredThinking) throw new SessionCommandError("BAD_REQUEST", `This agent uses thinking ${configuredThinking}`);
 		const clientMessageId = "commandId" in command ? command.commandId : command.clientMessageId;
 		const existing = matchSessionInputReceipt(conversationId, clientMessageId, principalId, sessionCommandHash(command));
 		if (existing) return sessionCommandSnapshot(service, existing);
@@ -50,7 +56,7 @@ async function receiveSessionCommand(service, conversationId, principalId, comma
 				attachments: command.input.attachments,
 				contextRefs: command.input.contextRefs,
 				sourceContexts: await prepareSourceContexts(),
-				thinking: command.kind === "start" ? command.creation.thinkingLevel : (await service.sessions.getAgentConfig(conversationId)).thinkingLevel,
+				thinking: configuredThinking ?? (command.kind === "start" ? command.creation.thinkingLevel : (await service.sessions.getAgentConfig(conversationId)).thinkingLevel),
 				origin: command.origin.type === "endpoint" ? {
 					type: "endpoint",
 					endpointId: command.origin.endpointId

package/dist/src/gateway/service/sessions-api.js

@@ -2,6 +2,7 @@ import { init_agent_session_key, resolveAgentIdFromConversationId } from "../../
 import { retireSessionMcpRuntimeForConversationId } from "../../agent/mcp/bundle-mcp-runtime.js";
 import { buildSessionTimeline } from "../../session/transcript-outline.js";
 import { transcriptRowsToClientHistory } from "../../session/client-history.js";
+import { isPersonalConversation } from "../../personal-agent/repository.js";
 import "../../agent/mcp/bundle-mcp-tools.js";
 import { collectMediaUrisFromValues, deleteMediaUris } from "../../media/session-references.js";
 import { withModelConfigLock } from "../../session/model-config-lock.js";
@@ -173,6 +174,7 @@ var GatewaySessionsApi = class {
 		return result;
 	}
 	async delete(key) {
+		if (isPersonalConversation(key)) return { deleted: false };
 		const transcriptRows = await this.opts.sessionIndex.getStore().loadTranscriptHistoryRows(key).catch(() => []);
 		const result = await this.opts.sessionIndex.deleteSession(key);
 		if (result) {
@@ -187,13 +189,21 @@ var GatewaySessionsApi = class {
 	}
 	/** Reset transcript in place (archive + new session id); preserves session key and overrides. */
 	reset(key) {
+		if (isPersonalConversation(key)) return Promise.resolve({
+			ok: false,
+			error: "Personal AI conversation cannot be reset"
+		});
 		return performSessionReset(key, {
 			sessionIndex: this.opts.sessionIndex,
 			getAgentService: this.opts.getAgentService
 		});
 	}
 	deleteMany(keys) {
-		return this.opts.sessionIndex.deleteSessions(keys);
+		const protectedKeys = keys.filter(isPersonalConversation);
+		return this.opts.sessionIndex.deleteSessions(keys.filter((key) => !isPersonalConversation(key))).then((result) => ({
+			success: result.success,
+			failed: [...result.failed, ...protectedKeys]
+		}));
 	}
 	async rename(key, name) {
 		await this.opts.sessionIndex.renameSession(key, name);

package/dist/src/gateway/service.js

@@ -17,9 +17,9 @@ import { init_session_repository, listSessionMetadata, patchSessionMetadata } fr
 import { getSessionConfig, init_config_repository } from "../storage/sqlite/config-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { normalizeAgentId } from "../agent-catalog/id.js";
-import { init_agent_scope, listAgentEntries, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
 import { init_config, resolveKnowledgeReadPolicy } from "../user-context/config.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
+import { init_agent_scope, listAgentEntries, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
 import { init_agent_session_key, resolveAgentMainConversationId } from "../routing/agent-session-key.js";
 import { init_session_key, resolveConversationId, sanitizeSegment } from "../routing/session-key.js";
 import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
@@ -70,24 +70,24 @@ 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 { ChatPreviewService } from "../chat-previews/service.js";
-import "../chat-previews/index.js";
 import { getWorkspacePath } from "../config/workspace-path-helpers.js";
 import "../config/index.js";
+import { ChatPreviewService } from "../chat-previews/service.js";
+import "../chat-previews/index.js";
 import { DiscussionService } from "../discussions/service.js";
 import { DiscussionOrganizer } from "../discussions/organizer.js";
 import { DiscussionLiveWorker } from "../discussions/live-worker.js";
 import { DiscussionOrganizerWorker } from "../discussions/organizer-worker.js";
 import { DiscussionSealer } from "../discussions/sealer.js";
 import "../discussions/index.js";
-import { EndpointToolRuntime } from "../endpoint-tools/runtime.js";
-import "../endpoint-tools/index.js";
 import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
 import { ConnectionRecoveryService } from "../connectors/connection-recovery-service.js";
 import { startConnectorLearningCoordinator } from "../connectors/learning-coordinator.js";
 import { startConnectorSupervisor } from "../connectors/supervisor.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";

package/dist/src/gateway/session-reset-service.js

@@ -2,6 +2,7 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { retireSessionMcpRuntimeForConversationId } from "../agent/mcp/bundle-mcp-runtime.js";
 import { abortEmbeddedRun } from "../agent/embedded/runs.js";
+import { isPersonalConversation } from "../personal-agent/repository.js";
 import "../agent/mcp/bundle-mcp-tools.js";
 //#region src/gateway/session-reset-service.ts
 init_logger();
@@ -17,6 +18,10 @@ async function performSessionReset(conversationId, deps) {
 		ok: false,
 		error: "Session key required"
 	};
+	if (isPersonalConversation(key)) return {
+		ok: false,
+		error: "Personal AI conversation cannot be reset"
+	};
 	await abortEmbeddedRun(key);
 	const task = await deps.sessionIndex.resetSession(key);
 	if (!task) return {

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

@@ -1,7 +1,7 @@
 import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
-import { AgentCatalogService } from "../agent-catalog/service.js";
 import { getModelCatalogStore, init_model_catalog_store } from "../providers/model-catalog-store.js";
 import { compareCatalogModels } from "../providers/model-catalog-ranking.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
 import { prepareUpdateGlobalDefaults } from "./global-defaults-admin.js";
 //#region src/gateway/xopc-cloud-capability-setup.ts
 init_repository();

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/personal-agent/policy.d.ts

@@ -0,0 +1 @@
+export declare const PERSONAL_MAIN_TOOL_IDS: readonly ["personal_task", "personal_preference", "session_recall", "user_context_search", "user_context_get", "knowledge_search", "knowledge_get", "clarify"];

package/dist/src/personal-agent/policy.js

@@ -0,0 +1,13 @@
+//#region src/personal-agent/policy.ts
+const PERSONAL_MAIN_TOOL_IDS = [
+	"personal_task",
+	"personal_preference",
+	"session_recall",
+	"user_context_search",
+	"user_context_get",
+	"knowledge_search",
+	"knowledge_get",
+	"clarify"
+];
+//#endregion
+export { PERSONAL_MAIN_TOOL_IDS };

package/dist/src/personal-agent/repository.d.ts

@@ -0,0 +1,25 @@
+export type PersonalAgentState = 'provisioning' | 'ready' | 'error';
+export type PersonalAppearance = 'spark' | 'cloud' | 'bean';
+export interface PersonalAgentRecord {
+    ownerId: string;
+    agentId: string;
+    conversationId: string;
+    state: PersonalAgentState;
+    displayName: string;
+    appearance: PersonalAppearance;
+    preferences: Record<string, unknown>;
+    revision: number;
+    errorMessage: string | null;
+}
+export declare const DEFAULT_PERSONAL_PREFERENCES: {
+    readonly warmth: "balanced";
+    readonly humor: "none";
+    readonly supportMode: "untangle";
+    readonly detailLevel: "balanced";
+    readonly proactivity: "decisions";
+};
+export declare function personalAgentId(ownerId: string): string;
+export declare function personalConversationId(ownerId: string): string;
+export declare function getPersonalAgent(ownerId: string): PersonalAgentRecord | null;
+export declare function getPersonalAgentByConversation(conversationId: string): PersonalAgentRecord | null;
+export declare function isPersonalConversation(conversationId: string): boolean;

package/dist/src/personal-agent/repository.js

@@ -0,0 +1,68 @@
+import { init_connection, isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
+import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
+import { getSessionConfig, init_config_repository } from "../storage/sqlite/config-repository.js";
+import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
+import { createHash } from "node:crypto";
+//#region src/personal-agent/repository.ts
+init_repository();
+init_connection();
+init_config_repository();
+init_transaction();
+const DEFAULT_PERSONAL_PREFERENCES = {
+	warmth: "balanced",
+	humor: "none",
+	supportMode: "untangle",
+	detailLevel: "balanced",
+	proactivity: "decisions"
+};
+function personalAgentId(ownerId) {
+	return `personal-${createHash("sha256").update(ownerId).digest("hex").slice(0, 12)}`;
+}
+function personalConversationId(ownerId) {
+	const hash = createHash("sha256").update(`personal-conversation:${ownerId}`).digest("hex");
+	return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-5${hash.slice(13, 16)}-8${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
+}
+function personalSession(column, value) {
+	if (!isXopcDatabaseOpen()) return null;
+	return getSqliteDatabase().prepare(`SELECT conversation_id, agent_id
+    FROM sessions WHERE ${column} = ? AND json_extract(custom_data_json, '$.personalAgent') = 1
+    ORDER BY created_at LIMIT 1`).get(value) ?? null;
+}
+function appearanceFrom(agent) {
+	return agent.profile?.emoji === "☁" ? "cloud" : agent.profile?.emoji === "◕" ? "bean" : "spark";
+}
+function toRecord(ownerId, agent, session) {
+	const config = session ? getSessionConfig(session.conversation_id) : null;
+	const ready = agent.provisioningState === "ready" && agent.runtime?.thinkingLevel === "off" && session && config?.thinkingLevel === "off" && config.fixedModel;
+	return {
+		ownerId,
+		agentId: agent.id,
+		conversationId: session?.conversation_id ?? personalConversationId(ownerId),
+		state: agent.provisioningState === "error" ? "error" : ready ? "ready" : "provisioning",
+		displayName: agent.profile?.name ?? "Personal AI",
+		appearance: appearanceFrom(agent),
+		preferences: agent.profile?.responsePreferences ?? DEFAULT_PERSONAL_PREFERENCES,
+		revision: agent.revision,
+		errorMessage: agent.provisioningError ?? null
+	};
+}
+function getPersonalAgent(ownerId) {
+	if (!isXopcDatabaseOpen()) return null;
+	const agent = new AgentCatalogRepository().get(personalAgentId(ownerId));
+	return agent ? toRecord(ownerId, agent, personalSession("agent_id", agent.id)) : null;
+}
+function getPersonalAgentByConversation(conversationId) {
+	const session = personalSession("conversation_id", conversationId);
+	if (!session) return null;
+	const agent = new AgentCatalogRepository().get(session.agent_id);
+	if (!agent) return null;
+	const ownerId = "local-owner";
+	return agent.id === personalAgentId(ownerId) ? toRecord(ownerId, agent, session) : null;
+}
+function isPersonalConversation(conversationId) {
+	if (!isXopcDatabaseOpen()) return false;
+	return Boolean(getSqliteDatabase().prepare(`SELECT 1 FROM sessions WHERE conversation_id = ?
+    AND agent_id = ? AND json_extract(custom_data_json, '$.personalAgent') = 1`).get(conversationId, personalAgentId("local-owner")));
+}
+//#endregion
+export { DEFAULT_PERSONAL_PREFERENCES, getPersonalAgent, getPersonalAgentByConversation, isPersonalConversation, personalAgentId, personalConversationId };

package/dist/src/personal-agent/service.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { GatewayService } from '../gateway/service.js';
+import { type PersonalAgentRecord } from './repository.js';
+export declare const PersonalPreferencesSchema: z.ZodObject<{
+    addressAs: z.ZodOptional<z.ZodString>;
+    warmth: z.ZodOptional<z.ZodEnum<{
+        balanced: "balanced";
+        reserved: "reserved";
+        gentle: "gentle";
+    }>>;
+    humor: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        occasional: "occasional";
+        playful: "playful";
+    }>>;
+    supportMode: z.ZodOptional<z.ZodEnum<{
+        listen: "listen";
+        untangle: "untangle";
+        solutions: "solutions";
+    }>>;
+    detailLevel: z.ZodOptional<z.ZodEnum<{
+        brief: "brief";
+        balanced: "balanced";
+        detailed: "detailed";
+    }>>;
+    proactivity: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        decisions: "decisions";
+        important: "important";
+    }>>;
+}, z.core.$strict>;
+export type PersonalPreferences = z.infer<typeof PersonalPreferencesSchema>;
+export declare const PersonalAppearanceSchema: z.ZodEnum<{
+    cloud: "cloud";
+    spark: "spark";
+    bean: "bean";
+}>;
+export type PersonalAppearance = z.infer<typeof PersonalAppearanceSchema>;
+export declare function personalInstructions(preferences: PersonalPreferences): string;
+export declare function refreshPersonalDelegationGuidance(service: GatewayService, ownerId: string): Promise<void>;
+export declare function listPersonalModels(): Promise<Array<{
+    id: string;
+    name: string;
+}>>;
+export declare function ensurePersonalConversationVisibility(ownerId: string): void;
+export declare function createOrResumePersonalAgent(service: GatewayService, ownerId: string, requestedModel?: string, availableModels?: typeof listPersonalModels): Promise<PersonalAgentRecord>;
+export declare function patchPersonalProfile(service: GatewayService, ownerId: string, revision: number, displayName: string, preferences: PersonalPreferences, appearance: PersonalAppearance): Promise<PersonalAgentRecord | null>;
+export declare function updatePersonalProfileRecord(ownerId: string, revision: number, displayName: string, preferences: PersonalPreferences, appearance: PersonalAppearance): Promise<PersonalAgentRecord | null>;

package/dist/src/personal-agent/service.js

@@ -0,0 +1,222 @@
+import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
+import { init_session_repository, patchSessionMetadata } from "../storage/sqlite/session-repository.js";
+import { init_config_repository, setSessionConfig } from "../storage/sqlite/config-repository.js";
+import { ResponsePreferencesSchema } from "../agent-config/schema.js";
+import { init_agent_config } from "../agent-config/index.js";
+import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
+import { createConversation, init_conversation_repository } from "../storage/sqlite/conversation-repository.js";
+import { getAvailableModels, init_providers } from "../providers/index.js";
+import { getModelThinking } from "../providers/model-thinking.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
+import { DEFAULT_PERSONAL_PREFERENCES, getPersonalAgent, personalAgentId } from "./repository.js";
+import { PERSONAL_MAIN_TOOL_IDS } from "./policy.js";
+import { z } from "zod";
+//#region src/personal-agent/service.ts
+init_agent_config();
+init_repository();
+init_providers();
+init_conversation_repository();
+init_session_repository();
+init_config_repository();
+const PersonalPreferencesSchema = ResponsePreferencesSchema;
+const PersonalAppearanceSchema = z.enum([
+	"spark",
+	"cloud",
+	"bean"
+]);
+function appearanceEmoji(appearance) {
+	return appearance === "cloud" ? "☁" : appearance === "bean" ? "◕" : "✦";
+}
+const LEGACY_DELEGATION_RULE = "Answer simple requests directly. For complex work, use personal_task agents to find a suitable specialist, then create a Task and remain available to talk. Never claim a task was created before the tool confirms it.";
+const PREVIOUS_DELEGATION_RULES = [
+	"Route by required capability, not task length. Answer directly only when your own tools and knowledge are sufficient. For current facts, web pages, or any tool you lack, call personal_task(command=\"agents\"), choose an Agent with the needed availableTools, then create a Task. Your own lack of browsing does not mean xopc cannot browse. Never claim the system cannot help, ask the user to switch models, or ask them to paste sources before checking Agents.",
+	"For current news, delegate to an Agent with web_search. Include the requested date or time window and topic in the brief; require source links, publication dates, and a distinction between confirmed news and uncertain reports. Tell the user briefly that you are checking. Stay available while the Task runs, then summarize verified results in their preferred style.",
+	"If no suitable Agent is available, explain the specific missing capability and offer the next useful option. Never claim a Task was created before the tool confirms it."
+].join("\n");
+const DELEGATION_RULES = [
+	"Own the user’s request through completion. If you cannot reliably do it yourself because of missing tools, access, knowledge, time, or specialist judgment, first call personal_task(command=\"agents\"). Match the request to another Agent’s description and availableTools, then create a Task for a plausible candidate. This applies to short requests too. Your own limitation is not a system limitation. Do not stop at “I cannot” or ask the user to switch models or do your work before checking Agents.",
+	"If the chosen Agent or tool cannot complete the Task, inspect the actual blocker and try another suitable Agent or a reasonable alternative within the user’s authorization. Do not repeat the same failed approach indefinitely. Ask the user only for a decision, access, or information that no available Agent can supply. Explain a concrete blocker only after checking the available paths; never imply that an untried path was attempted.",
+	"For current news or other live facts, find an Agent with web_search and require dated sources. For coding, analysis, writing, media, or connected-app work, choose by the Agent’s role and tools rather than a fixed name. Give the Task a short title and a complete Markdown brief. After Task creation succeeds, tell the user briefly what is happening, stay available, and summarize verified outcomes in their preferred style.",
+	"Never claim a Task was created or completed before its tool result confirms that state. Respect the user’s authorization and the selected Agent’s permissions."
+];
+function personalInstructions(preferences) {
+	const rules = [
+		"You are the user’s personal AI: capable, clear, attentive, and responsive. Match the user’s language. Let the user’s stated preferences and current situation shape how you speak; do not impose a cute or affectionate persona.",
+		...DELEGATION_RULES,
+		"When creating a Task, provide a short title that names the work, a one-sentence objective, and a Markdown description with all detailed instructions. Keep the title free of checklists and long background. Preserve user requirements in the description.",
+		"Adapt to the user’s current words first, then their saved preferences. If the user explicitly changes how they want you to respond in future, save it with personal_preference. Do not infer a lasting emotional trait from one conversation or claim human feelings or experiences.",
+		"Give the accurate answer or next step in the order this user prefers. Acknowledge feelings only when relevant, without guessing how the user feels. Avoid formulaic reassurance, praise, pet names, emojis, or jokes unless the user welcomes them and the moment fits. Be accurate about task state, evidence, and uncertainty."
+	];
+	if (preferences.addressAs) rules.push(`Address the user as ${JSON.stringify(preferences.addressAs)} when a name fits naturally.`);
+	if (preferences.warmth) rules.push({
+		reserved: "Tone: calm and direct; skip emotional preambles.",
+		balanced: "Tone: friendly and natural.",
+		gentle: "Tone: softly supportive without being sentimental."
+	}[preferences.warmth]);
+	if (preferences.humor) rules.push({
+		none: "Do not add jokes.",
+		occasional: "Use an occasional light touch when the moment fits.",
+		playful: "Be lightly playful in easy moments."
+	}[preferences.humor]);
+	if (preferences.supportMode) rules.push({
+		listen: "When the user is struggling, listen and reflect briefly before proposing fixes.",
+		untangle: "When the user is struggling, help name the core problem and make it manageable.",
+		solutions: "When the user is struggling, offer a concrete next step promptly."
+	}[preferences.supportMode]);
+	if (preferences.detailLevel) rules.push({
+		brief: "Keep replies short and lead with the answer.",
+		balanced: "Give the answer and only the context needed to act.",
+		detailed: "Explain reasoning and tradeoffs when useful."
+	}[preferences.detailLevel]);
+	if (preferences.proactivity) rules.push({
+		decisions: "Only proactively surface decisions and outcomes.",
+		important: "Proactively surface important milestones as well as outcomes.",
+		open: "You may offer useful suggestions without flooding the user."
+	}[preferences.proactivity]);
+	return rules.join("\n");
+}
+async function refreshPersonalDelegationGuidance(service, ownerId) {
+	const agent = new AgentCatalogRepository().get(personalAgentId(ownerId));
+	const instructions = agent?.profile?.instructions;
+	if (!agent || !instructions) return;
+	const oldRule = instructions.includes(PREVIOUS_DELEGATION_RULES) ? PREVIOUS_DELEGATION_RULES : instructions.includes(LEGACY_DELEGATION_RULE) ? LEGACY_DELEGATION_RULE : null;
+	if (!oldRule) return;
+	try {
+		await new AgentCatalogService().update(agent.id, { profile: {
+			...agent.profile,
+			instructions: instructions.replace(oldRule, DELEGATION_RULES.join("\n"))
+		} }, agent.revision);
+		service.refreshAgentCatalog?.();
+		const conversationId = getPersonalAgent(ownerId)?.conversationId;
+		if (conversationId) service.agentService?.evictSessionAgent(conversationId);
+	} catch (error) {
+		if (!(error instanceof Error && error.message === "Agent revision conflict")) throw error;
+	}
+}
+async function listPersonalModels() {
+	return (await getAvailableModels()).filter((model) => getModelThinking(model).options.includes("off")).map((model) => ({
+		id: `${model.provider}/${model.id}`,
+		name: model.name ?? model.id
+	}));
+}
+const inFlightProvisioning = /* @__PURE__ */ new Map();
+function ensurePersonalConversationVisibility(ownerId) {
+	const conversationId = getPersonalAgent(ownerId)?.conversationId;
+	if (!conversationId) return;
+	const session = getSessionMetadata(conversationId);
+	if (!session || session.hiddenFromSessionList && session.customData?.keepHiddenFromSessionList === true) return;
+	patchSessionMetadata(conversationId, {
+		hiddenFromSessionList: true,
+		customData: {
+			...session.customData,
+			keepHiddenFromSessionList: true
+		}
+	});
+}
+function createOrResumePersonalAgent(service, ownerId, requestedModel, availableModels = listPersonalModels) {
+	const current = inFlightProvisioning.get(ownerId);
+	if (current) return current;
+	const pending = provisionPersonalAgent(service, ownerId, requestedModel, availableModels);
+	inFlightProvisioning.set(ownerId, pending);
+	pending.finally(() => {
+		if (inFlightProvisioning.get(ownerId) === pending) inFlightProvisioning.delete(ownerId);
+	}).catch(() => {});
+	return pending;
+}
+async function provisionPersonalAgent(service, ownerId, requestedModel, availableModels = listPersonalModels) {
+	const existingIdentity = getPersonalAgent(ownerId);
+	if (existingIdentity?.state === "ready") {
+		await refreshPersonalDelegationGuidance(service, ownerId);
+		ensurePersonalConversationVisibility(ownerId);
+		return getPersonalAgent(ownerId) ?? existingIdentity;
+	}
+	const agentId = personalAgentId(ownerId);
+	const existing = new AgentCatalogRepository().get(agentId);
+	const available = await availableModels();
+	const preferredModel = requestedModel ?? existing?.models?.chat?.primary;
+	const fastModel = preferredModel ? void 0 : new AgentCatalogRepository().getSettings().defaults.models.intents.fast?.primary;
+	const chosen = preferredModel ? available.find((model) => model.id === preferredModel) : available.find((model) => model.id === fastModel) ?? available[0];
+	if (!chosen) throw new Error("Choose a configured model that supports thinking off");
+	const catalog = new AgentCatalogService();
+	if (!existing) await catalog.create({
+		id: agentId,
+		enabled: true,
+		profile: {
+			name: "Personal AI",
+			description: "A personal AI that adapts its responses to the user and coordinates work.",
+			creature: "assistant",
+			language: "zh",
+			emoji: appearanceEmoji("spark"),
+			responsePreferences: DEFAULT_PERSONAL_PREFERENCES,
+			instructions: personalInstructions(DEFAULT_PERSONAL_PREFERENCES)
+		},
+		toolAllowlist: [...PERSONAL_MAIN_TOOL_IDS],
+		skills: {
+			mode: "replace",
+			include: []
+		},
+		runtime: { thinkingLevel: "off" },
+		models: { chat: {
+			primary: chosen.id,
+			fallbacks: []
+		} }
+	});
+	else if (existing.provisioningState !== "ready" || existing.models?.chat?.primary !== chosen.id || existing.runtime?.thinkingLevel !== "off") await catalog.update(agentId, {
+		models: { chat: {
+			primary: chosen.id,
+			fallbacks: []
+		} },
+		runtime: {
+			...existing.runtime,
+			thinkingLevel: "off"
+		}
+	});
+	const record = getPersonalAgent(ownerId);
+	if (!record) throw new Error("Personal Agent provisioning did not complete");
+	const conversationId = record.conversationId;
+	service.refreshAgentCatalog();
+	if (!getSessionMetadata(conversationId)) createConversation({
+		agentId,
+		sourceChannel: "webchat",
+		name: record.displayName,
+		hiddenFromSessionList: true,
+		customData: {
+			personalAgent: true,
+			keepHiddenFromSessionList: true
+		}
+	}, "", conversationId);
+	ensurePersonalConversationVisibility(ownerId);
+	setSessionConfig(conversationId, {
+		modelOverride: chosen.id,
+		fixedModel: true,
+		thinkingLevel: "off"
+	}, process.cwd());
+	return getPersonalAgent(ownerId) ?? record;
+}
+async function patchPersonalProfile(service, ownerId, revision, displayName, preferences, appearance) {
+	const updated = await updatePersonalProfileRecord(ownerId, revision, displayName, preferences, appearance);
+	if (!updated) return null;
+	service.refreshAgentCatalog();
+	service.agentService.evictSessionAgent(updated.conversationId);
+	return updated;
+}
+async function updatePersonalProfileRecord(ownerId, revision, displayName, preferences, appearance) {
+	const current = new AgentCatalogRepository().get(personalAgentId(ownerId));
+	if (!current || current.provisioningState !== "ready" || current.revision !== revision || getPersonalAgent(ownerId)?.state !== "ready") return null;
+	const profile = {
+		...current.profile,
+		name: displayName,
+		emoji: appearanceEmoji(appearance),
+		responsePreferences: preferences,
+		instructions: personalInstructions(preferences)
+	};
+	try {
+		await new AgentCatalogService().update(current.id, { profile }, revision);
+	} catch (error) {
+		if (error instanceof Error && error.message === "Agent revision conflict") return null;
+		throw error;
+	}
+	return getPersonalAgent(ownerId);
+}
+//#endregion
+export { PersonalAppearanceSchema, PersonalPreferencesSchema, createOrResumePersonalAgent, ensurePersonalConversationVisibility, listPersonalModels, patchPersonalProfile, personalInstructions, refreshPersonalDelegationGuidance, updatePersonalProfileRecord };

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 { init_write_file_atomic, writeTextAtomic } from "../infra/write-file-atomic.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 { 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/session/resolve-session.js

@@ -6,6 +6,7 @@ import { findConversationIdByTranscriptId } from "../storage/sqlite/session-repo
 import { getSessionConfig } from "../storage/sqlite/config-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { SessionConfigSchema, init_schema } from "../config/schema.js";
+import { isPersonalConversation } from "../personal-agent/repository.js";
 import { normalizeThinkLevel, normalizeVerboseLevel } from "../agent/transcript/thinking-types.js";
 import { evaluateSessionFreshness, resolveSessionResetPolicy } from "./reset-policy.js";
 import { resolveChannelResetConfig, resolveSessionResetType } from "./reset-type.js";
@@ -51,12 +52,13 @@ async function resolveSession(opts) {
 		sessionStartedAt: sessionMetadata.sessionStartedAt ? Date.parse(sessionMetadata.sessionStartedAt) : void 0,
 		lastInteractionAt: sessionMetadata.lastInteractionAt ? Date.parse(sessionMetadata.lastInteractionAt) : void 0
 	} : void 0 });
-	const fresh = (sessionMetadata ? evaluateSessionFreshness({
+	const freshness = sessionMetadata ? evaluateSessionFreshness({
 		updatedAt: Date.parse(sessionMetadata.updatedAt),
 		...lifecycle,
 		now,
 		policy: resetPolicy
-	}) : { fresh: false }).fresh;
+	}) : { fresh: false };
+	const fresh = Boolean(sessionMetadata && conversationId && isPersonalConversation(conversationId)) || freshness.fresh;
 	const transcriptId = opts.transcriptId?.trim() || (fresh ? sessionMetadata?.transcriptId : void 0) || randomUUID();
 	const isNewSession = !fresh && !opts.transcriptId?.trim();
 	if (isNewSession && conversationId) log.debug({

package/dist/src/storage/sqlite/migrations/229_task_criterion_reviews.sql

@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS task_criterion_reviews (
+  task_id TEXT NOT NULL,
+  contract_version INTEGER NOT NULL,
+  criterion_index INTEGER NOT NULL,
+  criterion_text TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('passed', 'failed')),
+  note TEXT,
+  reviewed_by_json TEXT NOT NULL,
+  reviewed_at INTEGER NOT NULL,
+  PRIMARY KEY (task_id, contract_version, criterion_index),
+  FOREIGN KEY (task_id, contract_version) REFERENCES task_contracts(task_id, version) ON DELETE CASCADE
+);