@xopcai/xopc 0.0.353 → 0.0.355

package/dist/src/agent/tools/personal-task-tool.js

@@ -0,0 +1,184 @@
+import { resolveEffectiveAgentConfig } from "../../agent-config/resolver.js";
+import { init_agent_config } from "../../agent-config/index.js";
+import { AgentCatalogRepository, init_repository } from "../../agent-catalog/repository.js";
+import { resolveEffectiveAgentConfigForAgent } from "../../config/agent-profile.js";
+import { init_providers, isProviderConfiguredSync, resolveModel } from "../../providers/index.js";
+import { TaskOriginRepository } from "../../tasks/task-origin-repository.js";
+import { createXopcUseTool } from "./xopc-use-tool.js";
+import { isPersonalConversation } from "../../personal-agent/repository.js";
+import { randomUUID } from "node:crypto";
+import { Type } from "@sinclair/typebox";
+//#region src/agent/tools/personal-task-tool.ts
+init_repository();
+init_agent_config();
+init_providers();
+const PersonalTaskSchema = Type.Object({
+	command: Type.Union([
+		Type.Literal("agents"),
+		Type.Literal("create"),
+		Type.Literal("list"),
+		Type.Literal("get"),
+		Type.Literal("instruct"),
+		Type.Literal("answer")
+	]),
+	title: Type.Optional(Type.String({ description: "Short task title, ideally under 60 characters. Do not put the full instructions here." })),
+	objective: Type.Optional(Type.String({ description: "One-sentence outcome for a new delegated Task." })),
+	description: Type.Optional(Type.String({ description: "Full task brief in Markdown: background, specific requests, source material, and delivery expectations." })),
+	agentId: Type.Optional(Type.String({ description: "Specialist Agent ID. Never use your own ID." })),
+	taskId: Type.Optional(Type.String()),
+	instruction: Type.Optional(Type.String({ description: "The user’s new direction for this delegated Task." })),
+	questionId: Type.Optional(Type.String({ description: "Collaboration question ID to answer." })),
+	expectedOutputs: Type.Optional(Type.Array(Type.String())),
+	acceptanceCriteria: Type.Optional(Type.Array(Type.String())),
+	constraints: Type.Optional(Type.Array(Type.String())),
+	requiredTools: Type.Optional(Type.Array(Type.String({ description: "Tool names needed for this Task. Use names returned by agents; omit when matching by role or expertise." }))),
+	idempotencyKey: Type.Optional(Type.String())
+});
+const MAX_PERSONAL_TASK_TITLE = 60;
+const DISCOVERY_TOOLS = [
+	"web_search",
+	"web_fetch",
+	"browser_use",
+	"read_file",
+	"write_file",
+	"exec_command",
+	"image",
+	"image_generate",
+	"read_media",
+	"automation",
+	"workflow",
+	"xopc_use",
+	"xopc_tool_search",
+	"computer_use",
+	"send_message",
+	"text_to_speech"
+];
+function availableAgentTools(config, deps) {
+	return (config.toolAllowlist ? [...new Set([...DISCOVERY_TOOLS, ...config.toolAllowlist])] : DISCOVERY_TOOLS).filter((name) => (name !== "browser_use" || deps.getConfig?.()?.browser?.enabled !== false) && (!config.toolAllowlist || config.toolAllowlist.includes(name)) && config.tools[name]?.mode !== "deny");
+}
+function agentModelAvailability(config) {
+	for (const ref of [config.models.chat.primary, ...config.models.chat.fallbacks]) try {
+		if (isProviderConfiguredSync(resolveModel(ref).provider)) return { available: true };
+	} catch {}
+	return {
+		available: false,
+		reason: "No configured chat model resolves to an available provider"
+	};
+}
+function buildPersonalTaskBrief(input) {
+	const fullObjective = input.objective.trim();
+	const titleSource = (input.title?.trim() || fullObjective).replace(/\s+/g, " ");
+	const firstClause = titleSource.split(/[。！？\n]|(?<=[.!?])\s/)[0]?.trim() || titleSource;
+	const title = firstClause.length > MAX_PERSONAL_TASK_TITLE ? `${firstClause.slice(0, MAX_PERSONAL_TASK_TITLE - 1).trimEnd()}…` : firstClause;
+	const objective = fullObjective.length > 120 ? title : fullObjective;
+	const description = input.description?.trim();
+	const body = fullObjective !== objective ? [fullObjective, description].filter(Boolean).join("\n\n") : description;
+	return {
+		title,
+		objective,
+		...body ? { body } : {}
+	};
+}
+/** A narrow Task surface for the fast personal conversation. */
+function createPersonalTaskTool(deps) {
+	const productTool = createXopcUseTool(deps);
+	return {
+		name: "personal_task",
+		label: "Personal Task",
+		description: "Find specialist Agents by role, availableTools, and model.available; delegate work, inspect Tasks, send instructions, or answer worker questions. Choose an Agent whose model.available is true. Before saying you cannot do a request, inspect another Agent. If a candidate fails, try another suitable Agent or approach within the user’s authorization. agents can filter by requiredTools; if none match, inspect unfiltered Agents. Return to the user quickly after creation.",
+		parameters: PersonalTaskSchema,
+		mutatesWorkspace: true,
+		mutationScope: "external",
+		requiresExclusiveWorkspaceLock: true,
+		finalGuardRelevant: true,
+		async execute(toolCallId, input, signal) {
+			const conversationId = deps.getCurrentConversationId?.();
+			const ownAgentId = deps.getCurrentAgentId?.();
+			if (!conversationId || !ownAgentId || !isPersonalConversation(conversationId)) throw new Error("Personal conversation context is unavailable");
+			if (input.command === "agents") {
+				const requiredTools = input.requiredTools ?? [];
+				const catalog = new AgentCatalogRepository().snapshot();
+				const agents = catalog.agents.filter((agent) => agent.enabled !== false && agent.id !== ownAgentId && !agent.id.startsWith("personal-")).map((agent) => {
+					const config = resolveEffectiveAgentConfig({
+						defaults: catalog.defaults,
+						agent
+					}).config;
+					const availableTools = availableAgentTools(config, deps);
+					return {
+						id: agent.id,
+						name: agent.profile?.name ?? agent.id,
+						description: agent.profile?.description ?? "",
+						availableTools,
+						model: agentModelAvailability(config)
+					};
+				}).filter((agent) => requiredTools.every((tool) => agent.availableTools.includes(tool)));
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(agents)
+					}],
+					details: {}
+				};
+			}
+			let command = input.command;
+			let args = {};
+			if (command === "create") {
+				const objective = input.objective?.trim();
+				const agentId = input.agentId?.trim();
+				if (!objective || !agentId) throw new Error("objective and specialist agentId are required");
+				if (agentId === ownAgentId || agentId.startsWith("personal-")) throw new Error("Delegate to a specialist Agent, not a personal Agent");
+				const specialist = new AgentCatalogRepository().get(agentId);
+				if (!specialist || specialist.enabled === false || specialist.provisioningState !== "ready") throw new Error(`Specialist Agent is unavailable: ${agentId}`);
+				const config = resolveEffectiveAgentConfigForAgent(agentId).config;
+				const model = agentModelAvailability(config);
+				if (!model.available) throw new Error(`Agent ${agentId} cannot start: ${model.reason}. Find another available Agent.`);
+				const availableTools = availableAgentTools(config, deps);
+				const missingTools = (input.requiredTools ?? []).filter((tool) => !availableTools.includes(tool));
+				if (missingTools.length > 0) throw new Error(`Agent ${agentId} lacks required tools: ${missingTools.join(", ")}. Find another Agent or approach.`);
+				args = {
+					...buildPersonalTaskBrief({
+						title: input.title,
+						objective,
+						description: input.description
+					}),
+					agentId,
+					createMode: "start",
+					includeConversationContext: false,
+					expectedOutputs: input.expectedOutputs ?? [],
+					acceptanceCriteria: input.acceptanceCriteria ?? [],
+					constraints: input.constraints ?? [],
+					idempotencyKey: input.idempotencyKey?.trim() || randomUUID()
+				};
+			} else if (command === "list") {
+				command = "delegated_tasks";
+				args = { limit: 20 };
+			} else {
+				const taskId = input.taskId?.trim();
+				if (!taskId) throw new Error("taskId is required");
+				if (!new TaskOriginRepository().owns(taskId, conversationId)) throw new Error("Task does not belong to this personal conversation");
+				if (command === "instruct" || command === "answer") {
+					const body = input.instruction?.trim();
+					if (!body) throw new Error("instruction is required");
+					if (command === "answer" && !input.questionId?.trim()) throw new Error("questionId is required");
+					command = "collaboration_post";
+					args = {
+						taskId,
+						kind: input.command === "answer" ? "answer" : "instruction",
+						body,
+						...input.command === "answer" ? { causationId: input.questionId.trim() } : {}
+					};
+				} else args = { taskId };
+			}
+			return {
+				content: (await productTool.execute(toolCallId, {
+					mode: "task",
+					command,
+					args
+				}, signal, void 0)).content,
+				details: {}
+			};
+		}
+	};
+}
+//#endregion
+export { buildPersonalTaskBrief, createPersonalTaskTool };

package/dist/src/agent/tools/xopc-use-tool.js

@@ -1464,6 +1464,7 @@ async function handleTask(command, args, deps, dryRun, capabilities) {
 		const input = {
 			idempotencyKey: trimString(args.idempotencyKey) ?? randomUUID(),
 			title: trimString(args.title) ?? objective,
+			...trimString(args.body) ? { body: trimString(args.body) } : {},
 			priority: priority ?? "normal",
 			...dueAt === void 0 ? {} : { dueAt },
 			...projectId ? { projectId } : {},
@@ -1476,7 +1477,7 @@ async function handleTask(command, args, deps, dryRun, capabilities) {
 				outputDestinations: []
 			},
 			dependencies: dependsOnTaskIds,
-			context: conversationId ? [{
+			context: args.includeConversationContext === false ? [] : conversationId ? [{
 				targetKind: "session",
 				targetId: conversationId,
 				role: "input",
@@ -1889,7 +1890,7 @@ function createXopcUseTool(deps) {
 	return {
 		name: "xopc_use",
 		label: "XOPC Use",
-		description: "Operate first-class xopc objects through one safe entry point. To delegate work for immediate execution: mode task, command create, args {objective, createMode:\"start\", agentId:\"researcher\"}; omitting createMode creates a backlog task only. To start an existing Task: mode task, command command, args {taskId, type:\"start\", expectedVersion, commandArgs:{executor:{kind:\"agent\",agentId:\"main\"}}}. Inspect an existing Task and its run before creating another Task for the same objective. For delegated work, task delegated_tasks lists this conversation's tasks; task collaboration reads the shared board; task collaboration_post writes {taskId, kind, body, causationId?, idempotencyKey?}. Workers report progress or questions; the main Agent writes instructions and answers. Use chat_preview for lightweight UI mockups in the current conversation; do not create a Local App unless the user asks for a durable app. Local App capabilities takes extensionId and discovers already granted bindings. Local App invoke requires extensionId, the discovered manifestDigest, capabilityId and a pinned call {majorVersion, descriptorDigest, input, idempotencyKey for writes}. Never manufacture grants or change a retry key after an uncertain write. Use for Agents, scenes, projects, automations, notes, tasks, TaskRuns, chat previews, local apps, and exact settings jump targets instead of editing storage files directly. For non-trivial object changes, load the built-in manual first with tool_manual({ tool: \"xopc_use\" }).",
+		description: "Operate first-class xopc objects through one safe entry point. To delegate work for immediate execution: mode task, command create, args {title:\"Short task name\", objective:\"One-sentence outcome\", body:\"Full Markdown task brief\", createMode:\"start\", agentId:\"researcher\"}; omitting createMode creates a backlog task only. To start an existing Task: mode task, command command, args {taskId, type:\"start\", expectedVersion, commandArgs:{executor:{kind:\"agent\",agentId:\"main\"}}}. Inspect an existing Task and its run before creating another Task for the same objective. For delegated work, task delegated_tasks lists this conversation's tasks; task collaboration reads the shared board; task collaboration_post writes {taskId, kind, body, causationId?, idempotencyKey?}. Workers report progress or questions; the main Agent writes instructions and answers. Use chat_preview for lightweight UI mockups in the current conversation; do not create a Local App unless the user asks for a durable app. Local App capabilities takes extensionId and discovers already granted bindings. Local App invoke requires extensionId, the discovered manifestDigest, capabilityId and a pinned call {majorVersion, descriptorDigest, input, idempotencyKey for writes}. Never manufacture grants or change a retry key after an uncertain write. Use for Agents, scenes, projects, automations, notes, tasks, TaskRuns, chat previews, local apps, and exact settings jump targets instead of editing storage files directly. For non-trivial object changes, load the built-in manual first with tool_manual({ tool: \"xopc_use\" }).",
 		parameters: XopcUseToolSchema,
 		mutatesWorkspace: true,
 		mutationScope: "external",

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

@@ -9,7 +9,7 @@ export declare class AgentCatalogService {
     resumePendingProvisioning(): Promise<void>;
     /** Startup recovery for catalog rows committed before their directories were provisioned. */
     resumePendingProvisioningSync(): void;
-    update(agentIdRaw: string, patch: Partial<Omit<AgentEntry, 'id'>>): Promise<StoredAgent>;
+    update(agentIdRaw: string, patch: Partial<Omit<AgentEntry, 'id'>>, expectedRevision?: number): Promise<StoredAgent>;
     /** Remove data for an Agent that has already been deleted from the catalog. */
     purgeEntryData(entry: AgentEntry, defaultAgentId: string): Promise<void>;
     validatePurgeEntry(entry: AgentEntry, defaultAgentId: string): void;

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

@@ -59,10 +59,11 @@ var AgentCatalogService = class {
 		}
 		this.resumePendingPurgeSync();
 	}
-	async update(agentIdRaw, patch) {
+	async update(agentIdRaw, patch, expectedRevision) {
 		const agentId = normalizeAgentId(agentIdRaw);
 		const current = this.repository.get(agentId);
 		if (!current) throw new Error(`Agent "${agentId}" not found`);
+		if (expectedRevision !== void 0 && current.revision !== expectedRevision) throw new Error("Agent revision conflict");
 		const { revision, provisioningState: _state, provisioningError: _error, createdAt: _created, updatedAt: _updated, deletedAt: _deleted, ...entry } = current;
 		const next = {
 			...entry,

package/dist/src/agent-config/index.js

@@ -1,5 +1,5 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { AgentDefaultsSchema, AgentEntrySchema, AgentIdSchema, AgentModelsDefaultsSchema, AgentModelsOverrideSchema, AgentProfileSchema, ComputerModelRouteSchema, DEFAULT_AGENT_MODEL_REF, DEFAULT_CORE_SKILLS, DEFAULT_SKILL_POLICY, EffectiveAgentConfigSchema, ImageGenerationRouteSchema, ModelIntentSchema, ModelRefSchema, ModelRouteSchema, RuntimePolicySchema, SkillDefaultsSchema, SkillOverrideSchema, ToolModeSchema, ToolPoliciesSchema, ToolPolicySchema, WorkflowPolicySchema, init_schema } from "./schema.js";
+import { AgentDefaultsSchema, AgentEntrySchema, AgentIdSchema, AgentModelsDefaultsSchema, AgentModelsOverrideSchema, AgentProfileSchema, ComputerModelRouteSchema, DEFAULT_AGENT_MODEL_REF, DEFAULT_CORE_SKILLS, DEFAULT_SKILL_POLICY, EffectiveAgentConfigSchema, ImageGenerationRouteSchema, ModelIntentSchema, ModelRefSchema, ModelRouteSchema, ResponsePreferencesSchema, RuntimePolicySchema, SkillDefaultsSchema, SkillOverrideSchema, ToolModeSchema, ToolPoliciesSchema, ToolPolicySchema, WorkflowPolicySchema, init_schema } from "./schema.js";
 import { init_resolver, resolveEffectiveAgentConfig } from "./resolver.js";
 //#region src/agent-config/index.ts
 var init_agent_config = __esmMin((() => {
@@ -8,4 +8,4 @@ var init_agent_config = __esmMin((() => {
 }));
 //#endregion
 init_agent_config();
-export { AgentDefaultsSchema, AgentEntrySchema, AgentIdSchema, AgentModelsDefaultsSchema, AgentModelsOverrideSchema, AgentProfileSchema, ComputerModelRouteSchema, DEFAULT_AGENT_MODEL_REF, DEFAULT_CORE_SKILLS, DEFAULT_SKILL_POLICY, EffectiveAgentConfigSchema, ImageGenerationRouteSchema, ModelIntentSchema, ModelRefSchema, ModelRouteSchema, RuntimePolicySchema, SkillDefaultsSchema, SkillOverrideSchema, ToolModeSchema, ToolPoliciesSchema, ToolPolicySchema, WorkflowPolicySchema, init_agent_config, resolveEffectiveAgentConfig };
+export { AgentDefaultsSchema, AgentEntrySchema, AgentIdSchema, AgentModelsDefaultsSchema, AgentModelsOverrideSchema, AgentProfileSchema, ComputerModelRouteSchema, DEFAULT_AGENT_MODEL_REF, DEFAULT_CORE_SKILLS, DEFAULT_SKILL_POLICY, EffectiveAgentConfigSchema, ImageGenerationRouteSchema, ModelIntentSchema, ModelRefSchema, ModelRouteSchema, ResponsePreferencesSchema, RuntimePolicySchema, SkillDefaultsSchema, SkillOverrideSchema, ToolModeSchema, ToolPoliciesSchema, ToolPolicySchema, WorkflowPolicySchema, init_agent_config, resolveEffectiveAgentConfig };

package/dist/src/agent-config/schema.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare const DEFAULT_AGENT_MODEL_REF = "deepseek/deepseek-v4-flash";
+export declare const DEFAULT_AGENT_MODEL_REF = "deepseek/deepseek-flash";
 export declare const DEFAULT_CORE_SKILLS: readonly ["doc-coauthoring", "define-task", "find-skills", "summarize"];
 export declare const DEFAULT_SKILL_POLICY: {
     mode: "selected";
@@ -136,6 +136,15 @@ export declare const WorkflowPolicySchema: z.ZodObject<{
     allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 export declare const RuntimePolicySchema: z.ZodObject<{
+    thinkingLevel: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        off: "off";
+        medium: "medium";
+        minimal: "minimal";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
     commandIsolation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         mode: z.ZodLiteral<"host">;
     }, z.core.$strict>, z.ZodObject<{
@@ -215,6 +224,15 @@ export declare const AgentDefaultsSchema: z.ZodObject<{
         allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     runtime: z.ZodDefault<z.ZodObject<{
+        thinkingLevel: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            off: "off";
+            medium: "medium";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
         commandIsolation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             mode: z.ZodLiteral<"host">;
         }, z.core.$strict>, z.ZodObject<{
@@ -241,6 +259,35 @@ export declare const AgentDefaultsSchema: z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+export declare const ResponsePreferencesSchema: z.ZodObject<{
+    addressAs: z.ZodOptional<z.ZodString>;
+    guidance: 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 declare const AgentProfileSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
@@ -249,6 +296,35 @@ export declare const AgentProfileSchema: z.ZodObject<{
     language: z.ZodOptional<z.ZodString>;
     emoji: z.ZodOptional<z.ZodString>;
     avatar: z.ZodOptional<z.ZodString>;
+    responsePreferences: z.ZodOptional<z.ZodObject<{
+        addressAs: z.ZodOptional<z.ZodString>;
+        guidance: 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>>;
     instructions: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const AgentEntrySchema: z.ZodObject<{
@@ -263,6 +339,35 @@ export declare const AgentEntrySchema: z.ZodObject<{
         language: z.ZodOptional<z.ZodString>;
         emoji: z.ZodOptional<z.ZodString>;
         avatar: z.ZodOptional<z.ZodString>;
+        responsePreferences: z.ZodOptional<z.ZodObject<{
+            addressAs: z.ZodOptional<z.ZodString>;
+            guidance: 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>>;
         instructions: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     models: z.ZodOptional<z.ZodObject<{
@@ -320,6 +425,15 @@ export declare const AgentEntrySchema: z.ZodObject<{
         allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     runtime: z.ZodOptional<z.ZodObject<{
+        thinkingLevel: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            off: "off";
+            medium: "medium";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
         commandIsolation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             mode: z.ZodLiteral<"host">;
         }, z.core.$strict>, z.ZodObject<{
@@ -358,6 +472,35 @@ export declare const EffectiveAgentConfigSchema: z.ZodObject<{
         language: z.ZodOptional<z.ZodString>;
         emoji: z.ZodOptional<z.ZodString>;
         avatar: z.ZodOptional<z.ZodString>;
+        responsePreferences: z.ZodOptional<z.ZodObject<{
+            addressAs: z.ZodOptional<z.ZodString>;
+            guidance: 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>>;
         instructions: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     models: z.ZodObject<{
@@ -414,6 +557,15 @@ export declare const EffectiveAgentConfigSchema: z.ZodObject<{
         allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>;
     runtime: z.ZodObject<{
+        thinkingLevel: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            off: "off";
+            medium: "medium";
+            minimal: "minimal";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
         commandIsolation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
             mode: z.ZodLiteral<"host">;
         }, z.core.$strict>, z.ZodObject<{

package/dist/src/agent-config/schema.js

@@ -1,9 +1,9 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { z } from "zod";
 //#region src/agent-config/schema.ts
-var DEFAULT_AGENT_MODEL_REF, DEFAULT_CORE_SKILLS, DEFAULT_SKILL_POLICY, AgentIdSchema, ModelRefSchema, ModelRouteSchema, ImageGenerationRouteSchema, ComputerModelRouteSchema, ModelIntentSchema, ModelIntentRoutesSchema, ModelIntentOverridesSchema, AgentModelsDefaultsSchema, AgentModelsOverrideSchema, ToolModeSchema, ToolPolicySchema, ToolPoliciesSchema, SkillDefaultsSchema, SkillOverrideSchema, WorkflowPolicySchema, RuntimePolicySchema, AgentDefaultsSchema, AgentProfileSchema, AgentEntrySchema, EffectiveAgentConfigSchema;
+var DEFAULT_AGENT_MODEL_REF, DEFAULT_CORE_SKILLS, DEFAULT_SKILL_POLICY, AgentIdSchema, ModelRefSchema, ModelRouteSchema, ImageGenerationRouteSchema, ComputerModelRouteSchema, ModelIntentSchema, ModelIntentRoutesSchema, ModelIntentOverridesSchema, AgentModelsDefaultsSchema, AgentModelsOverrideSchema, ToolModeSchema, ToolPolicySchema, ToolPoliciesSchema, SkillDefaultsSchema, SkillOverrideSchema, WorkflowPolicySchema, RuntimePolicySchema, AgentDefaultsSchema, ResponsePreferencesSchema, AgentProfileSchema, AgentEntrySchema, EffectiveAgentConfigSchema;
 var init_schema = __esmMin((() => {
-	DEFAULT_AGENT_MODEL_REF = "deepseek/deepseek-v4-flash";
+	DEFAULT_AGENT_MODEL_REF = "deepseek/deepseek-flash";
 	DEFAULT_CORE_SKILLS = [
 		"doc-coauthoring",
 		"define-task",
@@ -92,6 +92,15 @@ var init_schema = __esmMin((() => {
 		allowed: z.array(z.string().min(1)).optional()
 	}).strict();
 	RuntimePolicySchema = z.object({
+		thinkingLevel: z.enum([
+			"off",
+			"minimal",
+			"low",
+			"medium",
+			"high",
+			"xhigh",
+			"max"
+		]).optional(),
 		commandIsolation: z.discriminatedUnion("mode", [z.object({ mode: z.literal("host") }).strict(), z.object({
 			mode: z.literal("docker"),
 			image: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9./:_-]*@sha256:[a-f0-9]{64}$/),
@@ -113,6 +122,35 @@ var init_schema = __esmMin((() => {
 		workflows: WorkflowPolicySchema.default({}),
 		runtime: RuntimePolicySchema.default({})
 	}).strict();
+	ResponsePreferencesSchema = z.object({
+		addressAs: z.string().trim().max(60).optional(),
+		guidance: z.string().trim().max(500).optional(),
+		warmth: z.enum([
+			"reserved",
+			"balanced",
+			"gentle"
+		]).optional(),
+		humor: z.enum([
+			"none",
+			"occasional",
+			"playful"
+		]).optional(),
+		supportMode: z.enum([
+			"listen",
+			"untangle",
+			"solutions"
+		]).optional(),
+		detailLevel: z.enum([
+			"brief",
+			"balanced",
+			"detailed"
+		]).optional(),
+		proactivity: z.enum([
+			"decisions",
+			"important",
+			"open"
+		]).optional()
+	}).strict();
 	AgentProfileSchema = z.object({
 		name: z.string().trim().min(1),
 		description: z.string().trim().optional(),
@@ -121,6 +159,7 @@ var init_schema = __esmMin((() => {
 		language: z.string().trim().optional(),
 		emoji: z.string().trim().optional(),
 		avatar: z.string().trim().optional(),
+		responsePreferences: ResponsePreferencesSchema.optional(),
 		instructions: z.string().trim().min(1).optional()
 	}).strict();
 	AgentEntrySchema = z.object({
@@ -150,4 +189,4 @@ var init_schema = __esmMin((() => {
 }));
 //#endregion
 init_schema();
-export { AgentDefaultsSchema, AgentEntrySchema, AgentIdSchema, AgentModelsDefaultsSchema, AgentModelsOverrideSchema, AgentProfileSchema, ComputerModelRouteSchema, DEFAULT_AGENT_MODEL_REF, DEFAULT_CORE_SKILLS, DEFAULT_SKILL_POLICY, EffectiveAgentConfigSchema, ImageGenerationRouteSchema, ModelIntentSchema, ModelRefSchema, ModelRouteSchema, RuntimePolicySchema, SkillDefaultsSchema, SkillOverrideSchema, ToolModeSchema, ToolPoliciesSchema, ToolPolicySchema, WorkflowPolicySchema, init_schema };
+export { AgentDefaultsSchema, AgentEntrySchema, AgentIdSchema, AgentModelsDefaultsSchema, AgentModelsOverrideSchema, AgentProfileSchema, ComputerModelRouteSchema, DEFAULT_AGENT_MODEL_REF, DEFAULT_CORE_SKILLS, DEFAULT_SKILL_POLICY, EffectiveAgentConfigSchema, ImageGenerationRouteSchema, ModelIntentSchema, ModelRefSchema, ModelRouteSchema, ResponsePreferencesSchema, RuntimePolicySchema, SkillDefaultsSchema, SkillOverrideSchema, ToolModeSchema, ToolPoliciesSchema, ToolPolicySchema, WorkflowPolicySchema, init_schema };

package/dist/src/chat-commands/builtins/thinking.js

@@ -37,8 +37,18 @@ const thinkCommand = {
 			content: `❌ Invalid thinking level: ${args}\n\nAvailable levels: ${formatThinkingLevels()}\n\nUsage: /think <level>\nExample: /think high`,
 			success: false
 		};
-		await setSessionAgentField(ctx.getSessionConfigStore?.(), ctx.conversationId, "thinkingLevel", level);
-		ctx.syncAgentThinkingLevel?.(level);
+		if (ctx.setThinkingLevel) try {
+			await ctx.setThinkingLevel(level);
+		} catch (error) {
+			return {
+				content: error instanceof Error ? error.message : "Unable to change thinking level",
+				success: false
+			};
+		}
+		else {
+			await setSessionAgentField(ctx.getSessionConfigStore?.(), ctx.conversationId, "thinkingLevel", level);
+			ctx.syncAgentThinkingLevel?.(level);
+		}
 		return {
 			content: `🧠 *Thinking Level Set*\n\nLevel: *${level}*\n${{
 				off: "No thinking",

package/dist/src/chat-commands/context.js

@@ -1,6 +1,7 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
+import { resolveEffectiveAgentConfigForSession } from "../config/agent-profile.js";
 import { effectiveWorkspacePathForSession } from "../session/session-workspace.js";
 import { getProjectForSession } from "../projects/workspace.js";
 import { getSessionDisplayName } from "./session-key.js";
@@ -208,6 +209,8 @@ var CommandContextImpl = class {
 	* Get current thinking level (session override or default)
 	*/
 	async getThinkingLevel() {
+		const configured = resolveEffectiveAgentConfigForSession(this.conversationId).config.runtime.thinkingLevel;
+		if (configured) return configured;
 		const configStore = this.deps.sessionConfigStore;
 		if (configStore) {
 			const sessionConfig = await configStore.get(this.conversationId);
@@ -218,12 +221,15 @@ var CommandContextImpl = class {
 	* Set thinking level for this session
 	*/
 	async setThinkingLevel(level) {
+		const configured = resolveEffectiveAgentConfigForSession(this.conversationId).config.runtime.thinkingLevel;
+		if (configured && level !== configured) throw new Error(`This agent uses thinking ${configured}`);
 		const configStore = this.deps.sessionConfigStore;
 		if (configStore) await configStore.update(this.conversationId, { thinkingLevel: level });
 		this.deps.applySessionThinkingLevel?.(this.conversationId, level);
 	}
 	syncAgentThinkingLevel(level) {
-		this.deps.applySessionThinkingLevel?.(this.conversationId, level);
+		const configured = resolveEffectiveAgentConfigForSession(this.conversationId).config.runtime.thinkingLevel;
+		this.deps.applySessionThinkingLevel?.(this.conversationId, configured ?? level);
 	}
 	async compactSession(options) {
 		if (!this.deps.compactSession) return null;

package/dist/src/cli/commands/auth.js

@@ -4,10 +4,10 @@ import { CredentialResolver, init_credentials } from "../../auth/credentials.js"
 import { getAllProviders, init_providers } from "../../providers/index.js";
 import { formatExamples, register } from "../registry.js";
 import { disconnectProvider } from "../../providers/provider-disconnect.js";
+import { colorizeStatus, colors } from "../utils/colors.js";
 import { listAllProfiles, listProfilesForProvider, removeAuthProfile, upsertAuthProfile } from "../../auth/profiles/profiles.js";
 import "../../auth/profiles/index.js";
 import { getOAuthProvider, getSupportedOAuthProviders } from "../utils/oauth-providers.js";
-import { colorizeStatus, colors } from "../utils/colors.js";
 import { runCliOAuthLogin } from "../utils/oauth-login.js";
 import { Command } from "commander";
 //#region src/cli/commands/auth.ts

package/dist/src/cli/commands/doctor/checks/database-schema.js

@@ -53,7 +53,7 @@ async function checkDatabaseSchema(ctx) {
 		id: "database-schema",
 		label: "Database schema",
 		status: "pass",
-		message: `SQLite schema v${status.dbVersion} (current release v228).`,
+		message: `SQLite schema v${status.dbVersion} (current release v229).`,
 		hints: []
 	};
 }

package/dist/src/cli/commands/models.js

@@ -106,7 +106,7 @@ async function runModelsList(options) {
 		}
 	}
 	console.log("\nUsage:");
-	console.log("   xopc models set deepseek/deepseek-v4-flash");
+	console.log("   xopc models set deepseek/deepseek-flash");
 	console.log("   xopc models auth login --provider anthropic");
 	console.log("   xopc models auth paste-api-key --provider deepseek");
 }
@@ -210,7 +210,7 @@ function createModelsCommand(_ctx) {
 	const cmd = new Command("models").description("List and manage models and model auth").addHelpText("after", formatExamples([
 		"xopc models list",
 		"xopc models status",
-		"xopc models set deepseek/deepseek-v4-flash",
+		"xopc models set deepseek/deepseek-flash",
 		"xopc models auth list",
 		"xopc models auth login --provider anthropic",
 		"xopc models auth paste-api-key --provider deepseek"

package/dist/src/cli/commands/onboard/model.js

@@ -12,10 +12,10 @@ import { discoverProviderModels, isProviderApiDiscoverable } from "../../../prov
 import { getXopcCloudCatalogCoordinator } from "../../../providers/xopc-cloud-catalog-coordinator.js";
 import { getDomesticProviderBaseUrl, getDomesticProviderPreset, getDomesticProviderPresetIds, providerConfigFromDomesticPreset } from "../../../providers/domestic-presets.js";
 import { getProviderHint, getRecommendedModelsForProvider, sortModelsForPicker, sortProvidersForPicker } from "../../../providers/presentation.js";
+import { colors } from "../../utils/colors.js";
 import { listProfilesForProvider } from "../../../auth/profiles/profiles.js";
 import "../../../auth/profiles/index.js";
 import { getOAuthProvider } from "../../utils/oauth-providers.js";
-import { colors } from "../../utils/colors.js";
 import { runCliOAuthLogin } from "../../utils/oauth-login.js";
 import { confirm, input, select } from "@inquirer/prompts";
 //#region src/cli/commands/onboard/model.ts