@xopcai/xopc 0.0.180 → 0.0.187

package/dist/src/agent/transcript/thinking-types.d.ts

@@ -4,6 +4,7 @@
  * Defines types for thinking ability management across the application.
  * Thinking-level labels for transcript hygiene.
  */
+import type { ResponseLanguage } from '../../i18n/response-language.js';
 /**
  * Thinking level for models that support extended thinking.
  * - off: No thinking
@@ -56,6 +57,8 @@ export interface SessionAgentConfig {
     providerOverride?: string;
     /** Per-session markdown workspace root override (immutable once set) */
     workingDirectoryOverride?: string;
+    /** Preferred language for user-visible responses in this session. */
+    responseLanguage?: ResponseLanguage;
 }
 /**
  * Normalize a raw string to ThinkLevel.

package/dist/src/agent/workflow/builtins/index.js

@@ -107,7 +107,7 @@ const BUILTIN_SPECS = [
 		description: "Package expertise into sellable offers with tiers, pricing, boundaries, and positioning.",
 		whenToUse: "Use when productizing a service or subscription.",
 		tags: ["planning", "architecture"],
-		perspectives: perspectives("Customer problem and outcome", "Packaging and delivery boundaries", "Pricing and positioning")
+		perspectives: perspectives("Customer problem and task", "Packaging and delivery boundaries", "Pricing and positioning")
 	},
 	{
 		name: "pr_review",
@@ -139,7 +139,7 @@ const BUILTIN_SPECS = [
 		description: "Review the week and produce a short, prioritized action plan for next week.",
 		whenToUse: "Use for a weekly retrospective and planning session.",
 		tags: ["productivity", "brainstorm"],
-		perspectives: perspectives("Outcomes and progress", "Friction and unfinished work", "Priorities and capacity")
+		perspectives: perspectives("Tasks and progress", "Friction and unfinished work", "Priorities and capacity")
 	}
 ];
 const BUILTIN_WORKFLOWS = Object.freeze(BUILTIN_SPECS.map((spec) => createBuiltinWorkflow(spec)));

package/dist/src/agent/workflow/index.js

@@ -1,8 +1,8 @@
-import { emptySnapshotFor } from "./snapshot-empty.js";
-import { createWorkflowSnapshot, previewValue, recomputeCounts, renderWorkflowText } from "./snapshot.js";
 import { BUILTIN_WORKFLOWS } from "./builtins/index.js";
 import { createWorkflowCatalog, defaultUserDir } from "./catalog.js";
 import { applySubagentProgress } from "./agent-progress.js";
+import { emptySnapshotFor } from "./snapshot-empty.js";
+import { createWorkflowSnapshot, previewValue, recomputeCounts, renderWorkflowText } from "./snapshot.js";
 import { WorkflowProgressBroker, _resetWorkflowProgressBrokerForTests, getWorkflowProgressBroker } from "./progress-broker.js";
 import { STRUCTURED_OUTPUT_TOOL_NAME, createStructuredOutputTool } from "./structured-output-tool.js";
 import { DelegateSubagentRunner } from "./subagent-runner.js";

package/dist/src/agent/workflow/subagent-runner.js

@@ -48,6 +48,7 @@ var DelegateSubagentRunner = class {
 		const childOptions = {
 			workspace: this.deps.workspace,
 			goal: fullPrompt,
+			requesterSessionKey: opts.sessionMetadata?.parentSessionKey,
 			allowedToolNames: allowed,
 			maxIterations: opts.maxIterations ?? DEFAULT_MAX_ITERATIONS,
 			model,

package/dist/src/agent/workflow/workflow-child-tools.js

@@ -1,9 +1,7 @@
-import { resolveDreamingRoot } from "../memory/dreaming/scope.js";
 import { AgentToolsFactory } from "../tools/factory.js";
 //#region src/agent/workflow/workflow-child-tools.ts
 /** Builds the tool set for workflow child agents (wired from gateway to avoid cycles). */
 function buildWorkflowChildTools(childOptions) {
-	const dreamingRoot = childOptions.getConfig() ? resolveDreamingRoot() : void 0;
 	return new AgentToolsFactory({
 		workspace: childOptions.workspace,
 		bus: childOptions.bus,
@@ -15,7 +13,6 @@ function buildWorkflowChildTools(childOptions) {
 		workspace: childOptions.workspace,
 		getPrimaryModel: () => childOptions.model,
 		agentId: childOptions.agentId,
-		dreamingRoot,
 		disabledTools: new Set(["extensions"])
 	});
 }

package/dist/src/agent/workspace-runtime/registry.d.ts

@@ -1,8 +1,8 @@
 /**
  * WorkspaceRuntimeRegistry — lazy per-workspace cache of agent execution runtimes.
  *
- * Previously these four collaborators (`SkillManager`, `SystemPromptBuilder`,
- * `BuiltinMemoryStore`, `MemoryManager`) were created inline inside
+ * Previously these collaborators (`SkillManager`, `SystemPromptBuilder`,
+ * `MemoryManager`) were created inline inside
  * `AgentManager.getWorkspaceRuntime` and cached in a private Map. They live
  * outside `AgentInstance` because multiple session keys for the same agent may
  * share a workspace. Skill, prompt, and code-intelligence state stays keyed by
@@ -15,7 +15,6 @@
  *     through `getOrCreate` without touching `AgentManager`.
  */
 import type { Config } from '../../config/schema.js';
-import { BuiltinMemoryStore } from '../memory/builtin-memory-store.js';
 import type { MemoryManager } from '../memory/manager.js';
 import { SkillManager } from '../skills/skill-manager.js';
 import { SystemPromptBuilder } from '../prompt/service-prompt-builder.js';
@@ -23,7 +22,6 @@ import { CodeIntelligenceRuntime } from '../code-intelligence/index.js';
 export interface WorkspaceRuntime {
     skillManager: SkillManager;
     systemPromptBuilder: SystemPromptBuilder;
-    builtinMemoryStore: BuiltinMemoryStore;
     memoryManager: MemoryManager;
     codeIntelligence: CodeIntelligenceRuntime;
 }

package/dist/src/agent/workspace-runtime/registry.js

@@ -32,7 +32,7 @@ var WorkspaceRuntimeRegistry = class {
 		const runtimeKey = `${normalizeAgentId(requestedAgentId?.trim() || resolveAgentIdForWorkspacePath(cfg, resolvedPath))}\u0000${resolvedPath}`;
 		const existing = this.runtimes.get(runtimeKey);
 		if (existing) return existing;
-		const { builtinMemoryStore, memoryManager } = this.userContextRuntimes.getOrCreate(cfg);
+		const { memoryManager } = this.userContextRuntimes.getOrCreate(cfg);
 		const skillManager = new SkillManager(resolvedPath, this.bundledSkillsDir, { isWorkspaceTrusted: () => this.isWorkspaceTrusted?.(resolvedPath) === true });
 		const rt = {
 			skillManager,
@@ -41,7 +41,6 @@ var WorkspaceRuntimeRegistry = class {
 				config: cfg,
 				skillManager
 			}),
-			builtinMemoryStore,
 			memoryManager,
 			codeIntelligence: new CodeIntelligenceRuntime({
 				workspace: resolvedPath,

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

@@ -1,10 +1,10 @@
-import { AgentConfigEntrySchema, AgentIdentitySchema, AgentManifestSchema, AgentResponsibilitiesSchema, AgentToolModelSchema, BoundaryPolicySchema, CapabilityPresetSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, ModelPolicyPatchSchema, ModelPolicySchema, PromptPolicySchema, RuntimePolicySchema, SkillPolicySchema, ToolModeSchema, ToolPolicySchema, ToolPolicySetSchema, ToolScopeSchema, WorkflowPolicySchema, WorkspacePolicySchema, init_schema } from "./schema.js";
+import { AgentConfigEntrySchema, AgentIdentitySchema, AgentManifestSchema, AgentResponsibilitiesSchema, AgentToolModelSchema, BoundaryPolicyPatchSchema, BoundaryPolicySchema, CapabilityPresetSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, ModelPolicyPatchSchema, ModelPolicySchema, PromptPolicySchema, RuntimePolicySchema, SkillPolicyPatchSchema, SkillPolicySchema, ToolModeSchema, ToolPolicySchema, ToolPolicySetPatchSchema, ToolPolicySetSchema, ToolScopeSchema, WorkflowPolicyPatchSchema, WorkflowPolicySchema, WorkspacePolicySchema, init_schema } from "./schema.js";
 import { init_preset_chain, linearizePresetIds } from "./preset-chain.js";
-import { getManifestSource, resolveEffectiveAgentManifest } from "./resolver.js";
+import { getManifestSource, resolveCapabilityPresetLayer, resolveEffectiveAgentManifest } from "./resolver.js";
 import { validateAgentManifest } from "./validator.js";
 import { buildAgentManifestPromptSection } from "./prompt.js";
 //#region src/agent-manifest/index.ts
 init_schema();
 init_preset_chain();
 //#endregion
-export { AgentConfigEntrySchema, AgentIdentitySchema, AgentManifestSchema, AgentResponsibilitiesSchema, AgentToolModelSchema, BoundaryPolicySchema, CapabilityPresetSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, ModelPolicyPatchSchema, ModelPolicySchema, PromptPolicySchema, RuntimePolicySchema, SkillPolicySchema, ToolModeSchema, ToolPolicySchema, ToolPolicySetSchema, ToolScopeSchema, WorkflowPolicySchema, WorkspacePolicySchema, buildAgentManifestPromptSection, getManifestSource, linearizePresetIds, resolveEffectiveAgentManifest, validateAgentManifest };
+export { AgentConfigEntrySchema, AgentIdentitySchema, AgentManifestSchema, AgentResponsibilitiesSchema, AgentToolModelSchema, BoundaryPolicyPatchSchema, BoundaryPolicySchema, CapabilityPresetSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, ModelPolicyPatchSchema, ModelPolicySchema, PromptPolicySchema, RuntimePolicySchema, SkillPolicyPatchSchema, SkillPolicySchema, ToolModeSchema, ToolPolicySchema, ToolPolicySetPatchSchema, ToolPolicySetSchema, ToolScopeSchema, WorkflowPolicyPatchSchema, WorkflowPolicySchema, WorkspacePolicySchema, buildAgentManifestPromptSection, getManifestSource, linearizePresetIds, resolveCapabilityPresetLayer, resolveEffectiveAgentManifest, validateAgentManifest };

package/dist/src/agent-manifest/resolver.d.ts

@@ -1,13 +1,32 @@
-import { type AgentConfigEntry, type CapabilityPreset, type EffectiveAgentManifest } from './schema.js';
+import { type AgentConfigEntry, type CapabilityPreset, type CapabilityPresetPatch, type EffectiveAgentManifest } from './schema.js';
 export interface ResolveManifestResult {
     manifest: EffectiveAgentManifest;
     presetChain: string[];
     sources: Record<string, string>;
+    overrides: ManifestOverride[];
+    locks: string[];
+}
+export interface ManifestOverride {
+    path: string;
+    from: string;
+    to: string;
 }
 export interface ResolveManifestParams {
     agent: AgentConfigEntry;
     presets?: Record<string, CapabilityPreset>;
     defaultPresetId?: string;
 }
+export interface ResolvePresetLayerResult {
+    patch: CapabilityPresetPatch;
+    presetChain: string[];
+    sources: Record<string, string>;
+    locks: string[];
+    overrides: ManifestOverride[];
+}
 export declare function resolveEffectiveAgentManifest(params: ResolveManifestParams): ResolveManifestResult;
+export declare function resolveCapabilityPresetLayer(params: {
+    presetIds?: readonly string[];
+    presets?: Record<string, CapabilityPreset>;
+    defaultPresetId?: string;
+}): ResolvePresetLayerResult;
 export declare function getManifestSource(result: ResolveManifestResult, path: string): string | undefined;

package/dist/src/agent-manifest/resolver.js

@@ -34,12 +34,17 @@ function mergeInto(target, patch, params) {
 			});
 			continue;
 		}
+		for (const [sourcePath, previousSource] of Object.entries(params.sources)) {
+			if (sourcePath !== path && !sourcePath.startsWith(`${path}.`)) continue;
+			if (previousSource !== params.source) params.overrides.push({
+				path: sourcePath,
+				from: previousSource,
+				to: params.source
+			});
+			delete params.sources[sourcePath];
+		}
 		target[key] = clone(patchValue);
 		collectLeafSources(patchValue, params.source, path, params.sources);
-		for (const lock of params.patchLocks ?? []) {
-			const lockPath = pathJoin(path, lock);
-			params.locks.add(lockPath);
-		}
 	}
 }
 function presetPatch(preset) {
@@ -48,40 +53,62 @@ function presetPatch(preset) {
 }
 function resolveEffectiveAgentManifest(params) {
 	const agent = AgentConfigEntrySchema.parse(params.agent);
+	const presetLayer = resolveCapabilityPresetLayer({
+		presetIds: agent.extends,
+		presets: params.presets,
+		defaultPresetId: params.defaultPresetId
+	});
+	const merged = clone(presetLayer.patch);
+	const sources = { ...presetLayer.sources };
+	const locks = new Set(presetLayer.locks);
+	const overrides = [...presetLayer.overrides];
+	const { extends: _extends, ...agentPatch } = agent;
+	mergeInto(merged, agentPatch, {
+		source: `agent:${agent.id}`,
+		sources,
+		locks,
+		overrides
+	});
+	return {
+		manifest: AgentManifestSchema.parse({
+			...merged,
+			id: agent.id,
+			enabled: agent.enabled,
+			extends: agent.extends
+		}),
+		presetChain: presetLayer.presetChain,
+		sources,
+		overrides,
+		locks: [...locks]
+	};
+}
+function resolveCapabilityPresetLayer(params) {
 	const presets = Object.fromEntries(Object.entries(params.presets ?? {}).map(([id, preset]) => [id, CapabilityPresetSchema.parse(preset)]));
 	const defaultPresetId = params.defaultPresetId ?? "default";
-	const chain = linearizePresetIds([...presets[defaultPresetId] ? [defaultPresetId] : [], ...(agent.extends ?? []).filter((id) => id !== defaultPresetId)], presets).map((presetId) => presets[presetId]);
+	const chain = linearizePresetIds([...presets[defaultPresetId] ? [defaultPresetId] : [], ...(params.presetIds ?? []).filter((id) => id !== defaultPresetId)], presets).map((presetId) => presets[presetId]);
 	const merged = {};
 	const sources = {};
 	const locks = /* @__PURE__ */ new Set();
+	const overrides = [];
 	for (const preset of chain) {
 		mergeInto(merged, presetPatch(preset), {
 			source: `preset:${preset.id}@${preset.version}`,
 			sources,
 			locks,
-			patchLocks: preset.locks
+			overrides
 		});
 		for (const lock of preset.locks ?? []) locks.add(lock);
 	}
-	const { extends: _extends, ...agentPatch } = agent;
-	mergeInto(merged, agentPatch, {
-		source: `agent:${agent.id}`,
-		sources,
-		locks
-	});
 	return {
-		manifest: AgentManifestSchema.parse({
-			...merged,
-			id: agent.id,
-			enabled: agent.enabled,
-			extends: agent.extends
-		}),
+		patch: merged,
 		presetChain: chain.map((preset) => preset.id),
-		sources
+		sources,
+		locks: [...locks],
+		overrides
 	};
 }
 function getManifestSource(result, path) {
 	return result.sources[path];
 }
 //#endregion
-export { getManifestSource, resolveEffectiveAgentManifest };
+export { getManifestSource, resolveCapabilityPresetLayer, resolveEffectiveAgentManifest };

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

@@ -145,6 +145,58 @@ export declare const ToolPolicySetSchema: z.ZodDefault<z.ZodObject<{
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>>;
+export declare const ToolPolicySetPatchSchema: z.ZodObject<{
+    builtin: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        mode: z.ZodEnum<{
+            allow: "allow";
+            confirm: "confirm";
+            deny: "deny";
+        }>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            workspace: "workspace";
+            readonly: "readonly";
+            unrestricted: "unrestricted";
+        }>>;
+        limits: z.ZodOptional<z.ZodObject<{
+            maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    mcp: z.ZodOptional<z.ZodObject<{
+        servers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            mode: z.ZodEnum<{
+                allow: "allow";
+                confirm: "confirm";
+                deny: "deny";
+            }>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                workspace: "workspace";
+                readonly: "readonly";
+                unrestricted: "unrestricted";
+            }>>;
+            limits: z.ZodOptional<z.ZodObject<{
+                maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            mode: z.ZodEnum<{
+                allow: "allow";
+                confirm: "confirm";
+                deny: "deny";
+            }>;
+            scope: z.ZodOptional<z.ZodEnum<{
+                workspace: "workspace";
+                readonly: "readonly";
+                unrestricted: "unrestricted";
+            }>>;
+            limits: z.ZodOptional<z.ZodObject<{
+                maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
 export declare const SkillPolicySchema: z.ZodDefault<z.ZodObject<{
     mode: z.ZodDefault<z.ZodEnum<{
         off: "off";
@@ -155,6 +207,16 @@ export declare const SkillPolicySchema: z.ZodDefault<z.ZodObject<{
     allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
     deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>>;
+export declare const SkillPolicyPatchSchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        off: "off";
+        all: "all";
+        allowlist: "allowlist";
+        denylist: "denylist";
+    }>;
+    allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 export declare const WorkflowPolicySchema: z.ZodDefault<z.ZodObject<{
     default: z.ZodOptional<z.ZodString>;
     allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -163,11 +225,24 @@ export declare const WorkflowPolicySchema: z.ZodDefault<z.ZodObject<{
         workflow: z.ZodString;
     }, z.core.$strict>>>;
 }, z.core.$strict>>;
+export declare const WorkflowPolicyPatchSchema: z.ZodObject<{
+    default: z.ZodOptional<z.ZodString>;
+    allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    suggested: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        intent: z.ZodString;
+        workflow: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
 export declare const BoundaryPolicySchema: z.ZodDefault<z.ZodObject<{
     requiresConfirmation: z.ZodDefault<z.ZodArray<z.ZodString>>;
     forbidden: z.ZodDefault<z.ZodArray<z.ZodString>>;
     escalation: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>>;
+export declare const BoundaryPolicyPatchSchema: z.ZodObject<{
+    requiresConfirmation: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    forbidden: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    escalation: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 export declare const WorkspacePolicySchema: z.ZodObject<{
     root: z.ZodString;
 }, z.core.$strict>;
@@ -344,8 +419,36 @@ export declare const AgentConfigEntrySchema: z.ZodObject<{
     workspace: z.ZodObject<{
         root: z.ZodString;
     }, z.core.$strict>;
-    tools: z.ZodDefault<z.ZodObject<{
-        builtin: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+    models: z.ZodOptional<z.ZodObject<{
+        defaultRole: z.ZodOptional<z.ZodString>;
+        roles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodString;
+            fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        imageModel: z.ZodOptional<z.ZodObject<{
+            primary: z.ZodString;
+            fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            autoProviderFallback: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        imageGenerationModel: z.ZodOptional<z.ZodObject<{
+            primary: z.ZodString;
+            fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            autoProviderFallback: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        policy: z.ZodOptional<z.ZodObject<{
+            allowFallbacks: z.ZodOptional<z.ZodBoolean>;
+            maxCostTier: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                medium: "medium";
+            }>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    tools: z.ZodOptional<z.ZodObject<{
+        builtin: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             mode: z.ZodEnum<{
                 allow: "allow";
                 confirm: "confirm";
@@ -396,17 +499,17 @@ export declare const AgentConfigEntrySchema: z.ZodObject<{
             }, z.core.$strict>>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
-    skills: z.ZodDefault<z.ZodObject<{
-        mode: z.ZodDefault<z.ZodEnum<{
+    skills: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
             off: "off";
             all: "all";
             allowlist: "allowlist";
             denylist: "denylist";
-        }>>;
+        }>;
         allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
         deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
-    workflows: z.ZodDefault<z.ZodObject<{
+    workflows: z.ZodOptional<z.ZodObject<{
         default: z.ZodOptional<z.ZodString>;
         allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
         suggested: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -414,10 +517,10 @@ export declare const AgentConfigEntrySchema: z.ZodObject<{
             workflow: z.ZodString;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
-    boundaries: z.ZodDefault<z.ZodObject<{
-        requiresConfirmation: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        forbidden: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        escalation: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    boundaries: z.ZodOptional<z.ZodObject<{
+        requiresConfirmation: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        forbidden: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        escalation: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
     runtime: z.ZodOptional<z.ZodObject<{
         maxTurns: z.ZodOptional<z.ZodNumber>;
@@ -427,34 +530,6 @@ export declare const AgentConfigEntrySchema: z.ZodObject<{
     prompt: z.ZodOptional<z.ZodObject<{
         customInstructions: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
-    models: z.ZodOptional<z.ZodObject<{
-        defaultRole: z.ZodString;
-        roles: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-            model: z.ZodString;
-            fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            description: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>>;
-        imageModel: z.ZodOptional<z.ZodObject<{
-            primary: z.ZodString;
-            fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            timeoutMs: z.ZodOptional<z.ZodNumber>;
-            autoProviderFallback: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>;
-        imageGenerationModel: z.ZodOptional<z.ZodObject<{
-            primary: z.ZodString;
-            fallbacks: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            timeoutMs: z.ZodOptional<z.ZodNumber>;
-            autoProviderFallback: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>;
-        policy: z.ZodOptional<z.ZodObject<{
-            allowFallbacks: z.ZodOptional<z.ZodBoolean>;
-            maxCostTier: z.ZodOptional<z.ZodEnum<{
-                low: "low";
-                high: "high";
-                medium: "medium";
-            }>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const CapabilityPresetSchema: z.ZodObject<{
     id: z.ZodString;
@@ -490,8 +565,8 @@ export declare const CapabilityPresetSchema: z.ZodObject<{
             }>>;
         }, z.core.$strict>>;
     }, z.core.$strict>>;
-    tools: z.ZodOptional<z.ZodDefault<z.ZodObject<{
-        builtin: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+    tools: z.ZodOptional<z.ZodObject<{
+        builtin: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             mode: z.ZodEnum<{
                 allow: "allow";
                 confirm: "confirm";
@@ -541,30 +616,30 @@ export declare const CapabilityPresetSchema: z.ZodObject<{
                 }, z.core.$strict>>;
             }, z.core.$strict>>>;
         }, z.core.$strict>>;
-    }, z.core.$strict>>>;
-    skills: z.ZodOptional<z.ZodDefault<z.ZodObject<{
-        mode: z.ZodDefault<z.ZodEnum<{
+    }, z.core.$strict>>;
+    skills: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
             off: "off";
             all: "all";
             allowlist: "allowlist";
             denylist: "denylist";
-        }>>;
+        }>;
         allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
         deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>>;
-    workflows: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+    }, z.core.$strict>>;
+    workflows: z.ZodOptional<z.ZodObject<{
         default: z.ZodOptional<z.ZodString>;
         allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
         suggested: z.ZodOptional<z.ZodArray<z.ZodObject<{
             intent: z.ZodString;
             workflow: z.ZodString;
         }, z.core.$strict>>>;
-    }, z.core.$strict>>>;
-    boundaries: z.ZodOptional<z.ZodDefault<z.ZodObject<{
-        requiresConfirmation: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        forbidden: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        escalation: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    boundaries: z.ZodOptional<z.ZodObject<{
+        requiresConfirmation: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        forbidden: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        escalation: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
     runtime: z.ZodOptional<z.ZodObject<{
         maxTurns: z.ZodOptional<z.ZodNumber>;
         timeoutMs: z.ZodOptional<z.ZodNumber>;
@@ -575,5 +650,6 @@ export declare const CapabilityPresetSchema: z.ZodObject<{
 export type AgentManifest = z.infer<typeof AgentManifestSchema>;
 export type AgentConfigEntry = z.infer<typeof AgentConfigEntrySchema>;
 export type CapabilityPreset = z.infer<typeof CapabilityPresetSchema>;
+export type CapabilityPresetPatch = Omit<CapabilityPreset, 'id' | 'name' | 'description' | 'version' | 'extends' | 'locks'>;
 export type EffectiveAgentManifest = AgentManifest;
 export type ToolPolicy = z.infer<typeof ToolPolicySchema>;

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

@@ -1,9 +1,10 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
 import { z } from "zod";
 //#region src/agent-manifest/schema.ts
-var IdSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, AgentToolModelSchema, ModelPolicySchema, ModelPolicyPatchSchema, ToolModeSchema, ToolScopeSchema, ToolPolicySchema, ToolPolicySetSchema, SkillPolicySchema, WorkflowPolicySchema, BoundaryPolicySchema, WorkspacePolicySchema, RuntimePolicySchema, PromptPolicySchema, AgentIdentitySchema, AgentResponsibilitiesSchema, AgentManifestSchema, AgentConfigEntrySchema, CapabilityPresetSchema;
+var IdSchema, LockPathSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, AgentToolModelSchema, ModelPolicySchema, ModelPolicyPatchSchema, ToolModeSchema, ToolScopeSchema, ToolPolicySchema, ToolPolicySetSchema, ToolPolicySetPatchSchema, SkillPolicySchema, SkillPolicyPatchSchema, WorkflowPolicySchema, WorkflowPolicyPatchSchema, BoundaryPolicySchema, BoundaryPolicyPatchSchema, WorkspacePolicySchema, RuntimePolicySchema, PromptPolicySchema, AgentIdentitySchema, AgentResponsibilitiesSchema, AgentManifestSchema, AgentConfigEntrySchema, CapabilityPresetSchema;
 var init_schema = __esmMin((() => {
 	IdSchema = z.string().regex(/^[a-z][a-z0-9_-]{0,63}$/);
+	LockPathSchema = z.string().regex(/^(models|tools|skills|workflows|boundaries|runtime)(?:\.[^.\s]+)*$/, "lock path must target a capability policy field");
 	DEFAULT_CAPABILITY_PRESET_ID = "default";
 	ManifestModelRoleSchema = z.object({
 		model: z.string().min(1),
@@ -101,6 +102,13 @@ var init_schema = __esmMin((() => {
 			tools: z.record(z.string().min(1), ToolPolicySchema).optional()
 		}).strict().optional()
 	}).strict().default({ builtin: {} });
+	ToolPolicySetPatchSchema = z.object({
+		builtin: z.record(z.string().min(1), ToolPolicySchema).optional(),
+		mcp: z.object({
+			servers: z.record(z.string().min(1), ToolPolicySchema).optional(),
+			tools: z.record(z.string().min(1), ToolPolicySchema).optional()
+		}).strict().optional()
+	}).strict();
 	SkillPolicySchema = z.object({
 		mode: z.enum([
 			"all",
@@ -111,6 +119,16 @@ var init_schema = __esmMin((() => {
 		allow: z.array(z.string().min(1)).optional(),
 		deny: z.array(z.string().min(1)).optional()
 	}).strict().default({ mode: "all" });
+	SkillPolicyPatchSchema = z.object({
+		mode: z.enum([
+			"all",
+			"allowlist",
+			"denylist",
+			"off"
+		]),
+		allow: z.array(z.string().min(1)).optional(),
+		deny: z.array(z.string().min(1)).optional()
+	}).strict();
 	WorkflowPolicySchema = z.object({
 		default: z.string().min(1).optional(),
 		allowed: z.array(z.string().min(1)).optional(),
@@ -119,6 +137,7 @@ var init_schema = __esmMin((() => {
 			workflow: z.string().min(1)
 		}).strict()).optional()
 	}).strict().default({});
+	WorkflowPolicyPatchSchema = WorkflowPolicySchema.removeDefault();
 	BoundaryPolicySchema = z.object({
 		requiresConfirmation: z.array(z.string().min(1)).default([]),
 		forbidden: z.array(z.string().min(1)).default([]),
@@ -128,6 +147,11 @@ var init_schema = __esmMin((() => {
 		forbidden: [],
 		escalation: []
 	});
+	BoundaryPolicyPatchSchema = z.object({
+		requiresConfirmation: z.array(z.string().min(1)).optional(),
+		forbidden: z.array(z.string().min(1)).optional(),
+		escalation: z.array(z.string().min(1)).optional()
+	}).strict();
 	WorkspacePolicySchema = z.object({ root: z.string().min(1) }).strict();
 	RuntimePolicySchema = z.object({
 		maxTurns: z.number().int().positive().optional(),
@@ -163,7 +187,21 @@ var init_schema = __esmMin((() => {
 		runtime: RuntimePolicySchema,
 		prompt: PromptPolicySchema
 	}).strict();
-	AgentConfigEntrySchema = AgentManifestSchema.extend({ models: ModelPolicySchema.optional() }).strict();
+	AgentConfigEntrySchema = z.object({
+		id: IdSchema,
+		enabled: z.boolean().default(true),
+		extends: z.array(IdSchema).optional(),
+		identity: AgentIdentitySchema,
+		responsibilities: AgentResponsibilitiesSchema,
+		workspace: WorkspacePolicySchema,
+		models: ModelPolicyPatchSchema.optional(),
+		tools: ToolPolicySetPatchSchema.optional(),
+		skills: SkillPolicyPatchSchema.optional(),
+		workflows: WorkflowPolicyPatchSchema.optional(),
+		boundaries: BoundaryPolicyPatchSchema.optional(),
+		runtime: RuntimePolicySchema,
+		prompt: PromptPolicySchema
+	}).strict();
 	CapabilityPresetSchema = z.object({
 		id: IdSchema,
 		name: z.string().min(1),
@@ -171,14 +209,14 @@ var init_schema = __esmMin((() => {
 		version: z.number().int().positive().default(1),
 		extends: z.array(IdSchema).optional(),
 		models: ModelPolicyPatchSchema.optional(),
-		tools: ToolPolicySetSchema.optional(),
-		skills: SkillPolicySchema.optional(),
-		workflows: WorkflowPolicySchema.optional(),
-		boundaries: BoundaryPolicySchema.optional(),
+		tools: ToolPolicySetPatchSchema.optional(),
+		skills: SkillPolicyPatchSchema.optional(),
+		workflows: WorkflowPolicyPatchSchema.optional(),
+		boundaries: BoundaryPolicyPatchSchema.optional(),
 		runtime: RuntimePolicySchema,
-		locks: z.array(z.string().min(1)).optional()
+		locks: z.array(LockPathSchema).optional()
 	}).strict();
 }));
 //#endregion
 init_schema();
-export { AgentConfigEntrySchema, AgentIdentitySchema, AgentManifestSchema, AgentResponsibilitiesSchema, AgentToolModelSchema, BoundaryPolicySchema, CapabilityPresetSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, ModelPolicyPatchSchema, ModelPolicySchema, PromptPolicySchema, RuntimePolicySchema, SkillPolicySchema, ToolModeSchema, ToolPolicySchema, ToolPolicySetSchema, ToolScopeSchema, WorkflowPolicySchema, WorkspacePolicySchema, init_schema };
+export { AgentConfigEntrySchema, AgentIdentitySchema, AgentManifestSchema, AgentResponsibilitiesSchema, AgentToolModelSchema, BoundaryPolicyPatchSchema, BoundaryPolicySchema, CapabilityPresetSchema, DEFAULT_CAPABILITY_PRESET_ID, ManifestModelRoleSchema, ModelPolicyPatchSchema, ModelPolicySchema, PromptPolicySchema, RuntimePolicySchema, SkillPolicyPatchSchema, SkillPolicySchema, ToolModeSchema, ToolPolicySchema, ToolPolicySetPatchSchema, ToolPolicySetSchema, ToolScopeSchema, WorkflowPolicyPatchSchema, WorkflowPolicySchema, WorkspacePolicySchema, init_schema };

package/dist/src/agent-runtime/memory-runtime.d.ts

@@ -1,6 +1,6 @@
 import type { UserContextConfig } from '../user-context/config.js';
-export type MemorySource = 'session' | 'userProfile' | 'agentProfile' | 'curated' | 'workspace' | 'connectedSources';
-export type MemoryWriteTarget = 'userProfile' | 'agentProfile' | 'curated' | 'workspace';
+export type MemorySource = 'session' | 'userProfile' | 'agentProfile' | 'understanding' | 'workspace' | 'connectedSources';
+export type MemoryWriteTarget = 'userProfile' | 'agentProfile' | 'understanding' | 'workspace';
 export type MemoryWriteDecision = 'allow' | 'confirm' | 'deny';
 export interface MemoryCandidate {
     target: MemoryWriteTarget;