@xopcai/xopc 0.0.323 → 0.0.324

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

@@ -5,6 +5,7 @@ export declare const DEFAULT_SKILL_POLICY: {
     mode: "selected";
     include: ("doc-coauthoring" | "define-task" | "find-skills" | "summarize")[];
 };
+export declare const AgentIdSchema: z.ZodString;
 export declare const ModelRefSchema: z.ZodString;
 export declare const ModelRouteSchema: z.ZodObject<{
     primary: z.ZodString;
@@ -332,177 +333,6 @@ export declare const AgentEntrySchema: z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export declare const AgentsConfigSchema: z.ZodObject<{
-    default: z.ZodDefault<z.ZodString>;
-    defaults: z.ZodDefault<z.ZodObject<{
-        models: z.ZodObject<{
-            chat: z.ZodObject<{
-                primary: z.ZodString;
-                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>;
-            intents: z.ZodDefault<z.ZodRecord<z.ZodEnum<{
-                review: "review";
-                coding: "coding";
-                fast: "fast";
-                reasoning: "reasoning";
-                vision: "vision";
-                understanding: "understanding";
-            }> & z.core.$partial, z.ZodObject<{
-                primary: z.ZodString;
-                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>>;
-            imageUnderstanding: z.ZodOptional<z.ZodObject<{
-                primary: z.ZodString;
-                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>;
-            computerUse: z.ZodOptional<z.ZodObject<{
-                primary: z.ZodString;
-                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>;
-            imageGeneration: z.ZodOptional<z.ZodObject<{
-                primary: z.ZodString;
-                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-                timeoutMs: z.ZodOptional<z.ZodNumber>;
-                autoProviderFallback: z.ZodDefault<z.ZodBoolean>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>;
-        skills: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            mode: z.ZodLiteral<"all-enabled">;
-            exclude: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>, z.ZodObject<{
-            mode: z.ZodLiteral<"selected">;
-            include: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>], "mode">>;
-        tools: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-            mode: z.ZodEnum<{
-                allow: "allow";
-                deny: "deny";
-                ask: "ask";
-            }>;
-            readOnly: z.ZodOptional<z.ZodBoolean>;
-            maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
-            timeoutMs: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>>;
-        workflows: z.ZodDefault<z.ZodObject<{
-            default: z.ZodOptional<z.ZodString>;
-            allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
-        runtime: z.ZodDefault<z.ZodObject<{
-            commandIsolation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                mode: z.ZodLiteral<"host">;
-            }, z.core.$strict>, z.ZodObject<{
-                mode: z.ZodLiteral<"docker">;
-                image: z.ZodString;
-                network: z.ZodDefault<z.ZodBoolean>;
-                workspaceAccess: z.ZodDefault<z.ZodEnum<{
-                    "read-only": "read-only";
-                    "read-write": "read-write";
-                }>>;
-            }, z.core.$strict>], "mode">>;
-            maxTurns: z.ZodOptional<z.ZodNumber>;
-            timeoutMs: z.ZodOptional<z.ZodNumber>;
-            maxToolFailuresPerTurn: z.ZodOptional<z.ZodNumber>;
-            promptCache: z.ZodOptional<z.ZodObject<{
-                mode: z.ZodDefault<z.ZodEnum<{
-                    off: "off";
-                    auto: "auto";
-                }>>;
-                lifetime: z.ZodDefault<z.ZodEnum<{
-                    short: "short";
-                    long: "long";
-                }>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>;
-    list: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        enabled: z.ZodDefault<z.ZodBoolean>;
-        workspace: z.ZodOptional<z.ZodString>;
-        profile: z.ZodOptional<z.ZodObject<{
-            name: z.ZodString;
-            instructions: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
-        models: z.ZodOptional<z.ZodObject<{
-            chat: z.ZodOptional<z.ZodObject<{
-                primary: z.ZodString;
-                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>;
-            intents: z.ZodOptional<z.ZodRecord<z.ZodEnum<{
-                review: "review";
-                coding: "coding";
-                fast: "fast";
-                reasoning: "reasoning";
-                vision: "vision";
-                understanding: "understanding";
-            }> & z.core.$partial, z.ZodNullable<z.ZodObject<{
-                primary: z.ZodString;
-                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>>>;
-            imageUnderstanding: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-                primary: z.ZodString;
-                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>>;
-            computerUse: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-                primary: z.ZodString;
-                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            }, z.core.$strict>>>;
-            imageGeneration: z.ZodOptional<z.ZodNullable<z.ZodObject<{
-                primary: z.ZodString;
-                fallbacks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-                timeoutMs: z.ZodOptional<z.ZodNumber>;
-                autoProviderFallback: z.ZodDefault<z.ZodBoolean>;
-            }, z.core.$strict>>>;
-        }, z.core.$strict>>;
-        skills: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            mode: z.ZodLiteral<"merge">;
-            add: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            remove: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>, z.ZodObject<{
-            mode: z.ZodLiteral<"replace">;
-            include: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>], "mode">>;
-        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            mode: z.ZodEnum<{
-                allow: "allow";
-                deny: "deny";
-                ask: "ask";
-            }>;
-            readOnly: z.ZodOptional<z.ZodBoolean>;
-            maxCallsPerTurn: z.ZodOptional<z.ZodNumber>;
-            timeoutMs: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>>>;
-        workflows: z.ZodOptional<z.ZodObject<{
-            default: z.ZodOptional<z.ZodString>;
-            allowed: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
-        runtime: z.ZodOptional<z.ZodObject<{
-            commandIsolation: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-                mode: z.ZodLiteral<"host">;
-            }, z.core.$strict>, z.ZodObject<{
-                mode: z.ZodLiteral<"docker">;
-                image: z.ZodString;
-                network: z.ZodDefault<z.ZodBoolean>;
-                workspaceAccess: z.ZodDefault<z.ZodEnum<{
-                    "read-only": "read-only";
-                    "read-write": "read-write";
-                }>>;
-            }, z.core.$strict>], "mode">>;
-            maxTurns: z.ZodOptional<z.ZodNumber>;
-            timeoutMs: z.ZodOptional<z.ZodNumber>;
-            maxToolFailuresPerTurn: z.ZodOptional<z.ZodNumber>;
-            promptCache: z.ZodOptional<z.ZodObject<{
-                mode: z.ZodDefault<z.ZodEnum<{
-                    off: "off";
-                    auto: "auto";
-                }>>;
-                lifetime: z.ZodDefault<z.ZodEnum<{
-                    short: "short";
-                    long: "long";
-                }>>;
-            }, z.core.$strict>>;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
 export declare const EffectiveAgentConfigSchema: z.ZodObject<{
     id: z.ZodString;
     enabled: z.ZodBoolean;
@@ -595,7 +425,6 @@ export type AgentModelsOverride = z.infer<typeof AgentModelsOverrideSchema>;
 export type ModelIntent = z.infer<typeof ModelIntentSchema>;
 export type AgentDefaults = z.infer<typeof AgentDefaultsSchema>;
 export type AgentEntry = z.infer<typeof AgentEntrySchema>;
-export type AgentsConfig = z.infer<typeof AgentsConfigSchema>;
 export type EffectiveAgentConfig = z.infer<typeof EffectiveAgentConfigSchema>;
 export type SkillDefaults = z.infer<typeof SkillDefaultsSchema>;
 export type SkillOverride = z.infer<typeof SkillOverrideSchema>;

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

@@ -1,7 +1,7 @@
 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, AgentsConfigSchema, 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, AgentProfileSchema, AgentEntrySchema, EffectiveAgentConfigSchema;
 var init_schema = __esmMin((() => {
 	DEFAULT_AGENT_MODEL_REF = "deepseek/deepseek-v4-flash";
 	DEFAULT_CORE_SKILLS = [
@@ -128,45 +128,6 @@ var init_schema = __esmMin((() => {
 		workflows: WorkflowPolicySchema.optional(),
 		runtime: RuntimePolicySchema.optional()
 	}).strict();
-	AgentsConfigSchema = z.object({
-		default: AgentIdSchema.default("main"),
-		defaults: AgentDefaultsSchema.default({
-			models: {
-				chat: {
-					primary: DEFAULT_AGENT_MODEL_REF,
-					fallbacks: []
-				},
-				intents: {}
-			},
-			skills: DEFAULT_SKILL_POLICY,
-			tools: {},
-			workflows: {},
-			runtime: {}
-		}),
-		list: z.array(AgentEntrySchema).default([{
-			id: "main",
-			enabled: true
-		}])
-	}).strict().superRefine((value, context) => {
-		const seen = /* @__PURE__ */ new Set();
-		value.list.forEach((agent, index) => {
-			if (seen.has(agent.id)) context.addIssue({
-				code: "custom",
-				path: [
-					"list",
-					index,
-					"id"
-				],
-				message: `duplicate agent id "${agent.id}"`
-			});
-			seen.add(agent.id);
-		});
-		if (!value.list.some((agent) => agent.id === value.default && agent.enabled)) context.addIssue({
-			code: "custom",
-			path: ["default"],
-			message: `default agent "${value.default}" must reference an enabled entry`
-		});
-	});
 	EffectiveAgentConfigSchema = z.object({
 		id: AgentIdSchema,
 		enabled: z.boolean(),
@@ -184,4 +145,4 @@ var init_schema = __esmMin((() => {
 }));
 //#endregion
 init_schema();
-export { AgentDefaultsSchema, AgentEntrySchema, AgentModelsDefaultsSchema, AgentModelsOverrideSchema, AgentProfileSchema, AgentsConfigSchema, 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, RuntimePolicySchema, SkillDefaultsSchema, SkillOverrideSchema, ToolModeSchema, ToolPoliciesSchema, ToolPolicySchema, WorkflowPolicySchema, init_schema };

package/dist/src/auth/credentials.js

@@ -400,7 +400,7 @@ var init_credentials = __esmMin((() => {
 				version: 2,
 				profiles: {}
 			};
-			const path = resolveAgentAuthProfilesPath(this.appConfig, this.agentId);
+			const path = resolveAgentAuthProfilesPath(this.agentId);
 			try {
 				const content = await readFile(path, "utf-8");
 				const data = JSON.parse(content);
@@ -424,7 +424,7 @@ var init_credentials = __esmMin((() => {
 		}
 		async saveAgentAuthProfile(profileId, profile) {
 			if (!this.agentId || !this.appConfig) throw new Error("Agent ID and appConfig required for agent-private profiles");
-			const path = resolveAgentAuthProfilesPath(this.appConfig, this.agentId);
+			const path = resolveAgentAuthProfilesPath(this.agentId);
 			await mkdir(dirname(path), { recursive: true });
 			const file = await this.loadAgentAuthProfilesFile();
 			file.profiles[profileId] = profile;
@@ -438,7 +438,7 @@ var init_credentials = __esmMin((() => {
 		}
 		async deleteAgentAuthProfile(profileId) {
 			if (!this.agentId || !this.appConfig) throw new Error("Agent ID and appConfig required for agent-private profiles");
-			const path = resolveAgentAuthProfilesPath(this.appConfig, this.agentId);
+			const path = resolveAgentAuthProfilesPath(this.agentId);
 			const file = await this.loadAgentAuthProfilesFile();
 			delete file.profiles[profileId];
 			await writeTextAtomic(path, JSON.stringify(file, null, 2));

package/dist/src/auth/oauth/xopc-cloud.js

@@ -1,6 +1,6 @@
 import { __esmMin } from "../../../_virtual/_rolldown/runtime.js";
-import { init_resolution, resolveConnectedPlatformEndpoint } from "../../platform/resolution.js";
 import { generatePKCE, init_pkce } from "./pkce.js";
+import { init_resolution, resolveConnectedPlatformEndpoint } from "../../platform/resolution.js";
 import { hostname } from "node:os";
 import { randomBytes } from "node:crypto";
 import http from "node:http";

package/dist/src/auth/sync-provider-auth.d.ts

@@ -10,7 +10,7 @@ import type { Config } from '../config/schema.js';
  */
 export declare function resolveProviderApiKeySync(provider: string): string | undefined;
 /** Resolve one agent's private credential, then the shared credential and OAuth token. */
-export declare function resolveProviderApiKeyForAgentSync(provider: string, agentId?: string, config?: Config): string | undefined;
+export declare function resolveProviderApiKeyForAgentSync(provider: string, agentId?: string, _config?: Config): string | undefined;
 /**
  * True if credentials exist in auth profiles (global or agent) or OAuth store,
  * matching async CredentialResolver resolution (excluding env — callers check env separately).

package/dist/src/auth/sync-provider-auth.js

@@ -1,7 +1,6 @@
 import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
-import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 import { init_paths, resolveAgentAuthProfilesPath, resolveAuthProfilesPath, resolveOAuthPath } from "../config/paths.js";
-import { init_loader, loadConfig } from "../config/loader.js";
+import { getDefaultAgentId, init_resolve_route } from "../routing/resolve-route.js";
 import { init_registry, isOAuthOnlyProvider } from "./oauth/registry.js";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/auth/sync-provider-auth.ts
@@ -83,19 +82,18 @@ function readOAuthAccessTokenSync(provider) {
 function resolveProviderApiKeySync(provider) {
 	const normalized = provider.toLowerCase();
 	if (isOAuthOnlyProvider(normalized)) return readOAuthAccessTokenSync(normalized);
-	const cfg = loadConfig();
-	const fromAgent = readApiKeyFromProfilesFile(resolveAgentAuthProfilesPath(cfg, getDefaultAgentId(cfg)), normalized);
+	const fromAgent = readApiKeyFromProfilesFile(resolveAgentAuthProfilesPath(getDefaultAgentId()), normalized);
 	if (fromAgent) return fromAgent;
 	const fromGlobal = readApiKeyFromProfilesFile(resolveAuthProfilesPath(), normalized);
 	if (fromGlobal) return fromGlobal;
 	return readOAuthAccessTokenSync(normalized);
 }
 /** Resolve one agent's private credential, then the shared credential and OAuth token. */
-function resolveProviderApiKeyForAgentSync(provider, agentId, config) {
+function resolveProviderApiKeyForAgentSync(provider, agentId, _config) {
 	const normalized = provider.toLowerCase();
 	if (isOAuthOnlyProvider(normalized)) return readOAuthAccessTokenSync(normalized);
 	if (agentId?.trim()) {
-		const fromAgent = readApiKeyFromProfilesFile(resolveAgentAuthProfilesPath(config ?? loadConfig(), agentId.trim()), normalized);
+		const fromAgent = readApiKeyFromProfilesFile(resolveAgentAuthProfilesPath(agentId.trim()), normalized);
 		if (fromAgent) return fromAgent;
 	}
 	const fromGlobal = readApiKeyFromProfilesFile(resolveAuthProfilesPath(), normalized);
@@ -108,15 +106,13 @@ function resolveProviderApiKeyForAgentSync(provider, agentId, config) {
 */
 function hasProviderAuthOnDiskSync(provider) {
 	if (isOAuthOnlyProvider(provider.toLowerCase())) return hasOAuthTokenSync(provider);
-	const cfg = loadConfig();
-	if (hasApiKeyInProfilesFile(resolveAgentAuthProfilesPath(cfg, getDefaultAgentId(cfg)), provider)) return true;
+	if (hasApiKeyInProfilesFile(resolveAgentAuthProfilesPath(getDefaultAgentId()), provider)) return true;
 	if (hasApiKeyInProfilesFile(resolveAuthProfilesPath(), provider)) return true;
 	if (hasOAuthTokenSync(provider)) return true;
 	return false;
 }
 var init_sync_provider_auth = __esmMin((() => {
 	init_paths();
-	init_loader();
 	init_resolve_route();
 	init_registry();
 }));

package/dist/src/automations/capabilities/drafts.js

@@ -1,12 +1,12 @@
 import { AutomationDraftOutputSchema, AutomationDraftRequestSchema, AutomationRepairDraftOutputSchema, AutomationSimulationSchema } from "../../../packages/gateway-contract/src/capabilities.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
-import { resolveAutomationSafetyForTrust } from "../../user-context/trust-policy.js";
+import { init_trust_policy, resolveAutomationSafetyForTrust } from "../../user-context/trust-policy.js";
 import { getUserTrustPolicy } from "../../storage/sqlite/user-trust-repository.js";
-import "../../storage/sqlite/index.js";
-import { init_agent_scope, resolveDefaultAgentId } from "../../agent/agent-scope.js";
+import { init_sqlite } from "../../storage/sqlite/index.js";
 import { CapabilityError } from "../../capabilities/runtime/errors.js";
 import { ExternalEffectNotAppliedError } from "../../capabilities/runtime/external-operations.js";
 import { defineExternalCapability, defineReadCapability } from "../../capabilities/runtime/dispatcher.js";
+import { init_agent_scope, resolveDefaultAgentId } from "../../agent/agent-scope.js";
 import { AutomationCreateCapabilityInputSchema } from "./write.js";
 import { simulateAutomation } from "../draft/automation-draft-validator.js";
 import { AutomationDraftService } from "../draft/automation-draft-service.js";
@@ -15,6 +15,8 @@ import { z } from "zod";
 //#region src/automations/capabilities/drafts.ts
 init_src();
 init_agent_scope();
+init_sqlite();
+init_trust_policy();
 function registerAutomationDraftCapabilities(dispatcher, service, getConfig) {
 	const policy = {
 		majorVersion: 1,
@@ -52,10 +54,9 @@ function registerAutomationDraftCapabilities(dispatcher, service, getConfig) {
 		input: AutomationDraftRequestSchema.extend({ prompt: z.string().trim().min(1).max(5e4) }),
 		output: z.object({ draft: AutomationDraftOutputSchema }),
 		async execute(input, context) {
-			const config = configuration();
-			const draft = await new AutomationDraftService({ config }).createDraft({
+			const draft = await new AutomationDraftService({ config: configuration() }).createDraft({
 				...input,
-				agentId: input.agentId ?? resolveDefaultAgentId(config)
+				agentId: input.agentId ?? resolveDefaultAgentId()
 			}, context.signal);
 			draft.automation.safety = { mode: resolveAutomationSafetyForTrust(getUserTrustPolicy().defaultActionLevel, draft.automation.safety?.mode) };
 			draft.simulation = simulateAutomation(draft.automation);
@@ -81,7 +82,7 @@ function registerAutomationDraftCapabilities(dispatcher, service, getConfig) {
 			if (!automation) throw new ExternalEffectNotAppliedError("Automation not found", { cause: new CapabilityError("NOT_FOUND", "Automation not found") });
 			const events = await service.listRunEvents(id);
 			const repair = await new AutomationDraftService({ config }).createRepairDraft({
-				agentId: agentId ?? resolveDefaultAgentId(config),
+				agentId: agentId ?? resolveDefaultAgentId(),
 				automation,
 				run,
 				events,

package/dist/src/automations/service/action-executor.js

@@ -1,6 +1,7 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { init_agent_scope, normalizeAgentId } from "../../agent/agent-scope.js";
+import { normalizeAgentId } from "../../agent-catalog/id.js";
+import { init_agent_scope } from "../../agent/agent-scope.js";
 import { init_session_key, resolveConversationId } from "../../routing/session-key.js";
 import { resolveAutomationTimeoutSeconds } from "../domain/defaults.js";
 //#region src/automations/service/action-executor.ts

package/dist/src/bootstrap/application-state.d.ts

@@ -0,0 +1,10 @@
+import { type AgentCatalogCutoverResult } from '../agent-catalog/index.js';
+export type ApplicationStateBootstrapResult = {
+    agentCatalog: AgentCatalogCutoverResult;
+    configChanged: boolean;
+};
+/**
+ * Bring durable application state to the current shape before strict config loading.
+ * Ordering is intentional: legacy Agent fields must leave JSON before ConfigSchema sees it.
+ */
+export declare function bootstrapApplicationStateSync(configPath: string): ApplicationStateBootstrapResult;

package/dist/src/bootstrap/application-state.js

@@ -0,0 +1,26 @@
+import { requireXopcDatabase } from "../storage/sqlite/connection.js";
+import { init_sqlite } from "../storage/sqlite/index.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
+import { cutoverLegacyAgentConfig } from "../agent-catalog/migrations/legacy-config-cutover.js";
+import "../agent-catalog/index.js";
+import { ensureStarterAgentsInitialized } from "../agent/starter-agents.js";
+import { runBootstrapMigrationsSync } from "../migrations/runner.js";
+//#region src/bootstrap/application-state.ts
+init_sqlite();
+/**
+* Bring durable application state to the current shape before strict config loading.
+* Ordering is intentional: legacy Agent fields must leave JSON before ConfigSchema sees it.
+*/
+function bootstrapApplicationStateSync(configPath) {
+	requireXopcDatabase();
+	const agentCatalog = cutoverLegacyAgentConfig({ configPath });
+	const configMigration = runBootstrapMigrationsSync(configPath);
+	ensureStarterAgentsInitialized();
+	new AgentCatalogService().resumePendingProvisioningSync();
+	return {
+		agentCatalog,
+		configChanged: configMigration.changed
+	};
+}
+//#endregion
+export { bootstrapApplicationStateSync };

package/dist/src/browser/automations/repository.js

@@ -1,6 +1,7 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
-import "../../storage/sqlite/index.js";
+import { init_sqlite } from "../../storage/sqlite/index.js";
 //#region src/browser/automations/repository.ts
+init_sqlite();
 const AUTOMATION_SELECT = "SELECT automation_id, revision, status, definition_json, created_at_ms, updated_at_ms FROM browser_automations";
 const RUN_SELECT = "SELECT run_id, automation_id, automation_revision, definition_json, status, inputs_json, result_json, error, created_at_ms, started_at_ms, ended_at_ms, duration_ms FROM browser_automation_runs";
 const parseAutomation = (row) => ({

package/dist/src/browser/automations/schema.d.ts

@@ -8,8 +8,8 @@ export declare const BrowserAutomationDefinitionSchema: z.ZodObject<{
         read: "read";
         draft: "draft";
         destructive: "destructive";
-        sensitive: "sensitive";
         external_effect: "external_effect";
+        sensitive: "sensitive";
     }>;
     inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
         type: z.ZodEnum<{

package/dist/src/browser/automations/service.d.ts

@@ -25,7 +25,7 @@ export declare class BrowserAutomationService {
         id: string;
         name: string;
         allowedDomains: string[];
-        risk: "read" | "draft" | "destructive" | "sensitive" | "external_effect";
+        risk: "read" | "draft" | "destructive" | "external_effect" | "sensitive";
         inputs: Record<string, {
             type: "string" | "number" | "boolean";
             required?: boolean;

package/dist/src/browser/native-messaging-host.js

@@ -1,16 +1,17 @@
 import { closeXopcDatabase, init_connection, openXopcDatabase } from "../storage/sqlite/connection.js";
 import { browserPairingInvitationPayloadSchema, formatBrowserPairingInvitation } from "../../packages/gateway-contract/src/device-pairing.js";
 import { init_src } from "../../packages/gateway-contract/src/index.js";
-import { getGatewayIdentityPublicKeyRaw, getOrCreateGatewayIdentity } from "../storage/sqlite/gateway-identity-repository.js";
-import { createDevicePairingSetup } from "../storage/sqlite/device-pairing-repository.js";
-import { init_loader, loadConfig } from "../config/loader.js";
+import { getGatewayIdentityPublicKeyRaw, getOrCreateGatewayIdentity, init_gateway_identity_repository } from "../storage/sqlite/gateway-identity-repository.js";
+import { createDevicePairingSetup, init_device_pairing_repository } from "../storage/sqlite/device-pairing-repository.js";
+import { loadConfig } from "../config/loader.js";
 import { browserEnrollmentPublicKeyThumbprint } from "./enrollment.js";
 import { BROWSER_EXTENSION_ID, BROWSER_NATIVE_HOST_NAME } from "./extension-identity.js";
 import os from "node:os";
 //#region src/browser/native-messaging-host.ts
 init_src();
-init_loader();
 init_connection();
+init_device_pairing_repository();
+init_gateway_identity_repository();
 function gatewayLoopbackUrl(port) {
 	return `http://127.0.0.1:${port}`;
 }

package/dist/src/browser/providers/extension.js

@@ -1,7 +1,7 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { deleteBrowserTabBindingsByPrincipal, getBrowserTabBindingById } from "../../storage/sqlite/browser-tab-binding-repository.js";
-import { getDevice } from "../../storage/sqlite/device-access-repository.js";
+import { deleteBrowserTabBindingsByPrincipal, getBrowserTabBindingById, init_browser_tab_binding_repository } from "../../storage/sqlite/browser-tab-binding-repository.js";
+import { getDevice, init_device_access_repository } from "../../storage/sqlite/device-access-repository.js";
 import { browserWireAuthenticationPayload } from "../../../packages/browser-control-contract/src/index.js";
 import { isChromeExtensionOrigin } from "../../gateway/security/origin-check.js";
 import crypto from "node:crypto";
@@ -13,6 +13,8 @@ import crypto from "node:crypto";
 * Commands are sent over the WS connection and results are returned asynchronously.
 */
 init_logger();
+init_device_access_repository();
+init_browser_tab_binding_repository();
 const log = createLogger("ExtensionProvider");
 const DEFAULT_PORT = 19820;
 const DEFAULT_HOST = "127.0.0.1";

package/dist/src/browser/providers/realtime-extension.js

@@ -1,7 +1,8 @@
-import { getBrowserTabBindingById } from "../../storage/sqlite/browser-tab-binding-repository.js";
+import { getBrowserTabBindingById, init_browser_tab_binding_repository } from "../../storage/sqlite/browser-tab-binding-repository.js";
 import { BROWSER_CONTROL_ENDPOINT_TOOL_NAME } from "../../../packages/browser-control-contract/src/index.js";
 import crypto from "node:crypto";
 //#region src/browser/providers/realtime-extension.ts
+init_browser_tab_binding_repository();
 var RealtimeExtensionBrowserProvider = class {
 	name = "extension";
 	connectionTimeout;

package/dist/src/capabilities/readiness/from-config.js

@@ -1,3 +1,4 @@
+import { AgentCatalogRepository, init_repository } from "../../agent-catalog/repository.js";
 import { getAgentDefaultImageGenerationModelConfig, getAgentDefaultImageModelConfig, init_schema, parseModelRef } from "../../config/schema.js";
 import { init_model_policy, isComputerModel, isDedicatedComputerProfile } from "../../computer/model-policy.js";
 import { getModelCatalogStore, init_model_catalog_store } from "../../providers/model-catalog-store.js";
@@ -7,6 +8,7 @@ import { DEFAULT_LOCAL_VOICE_MODEL_ID, hasInstalledLocalVoiceModel } from "../..
 import { planCapabilities } from "./planner.js";
 //#region src/capabilities/readiness/from-config.ts
 init_model_policy();
+init_repository();
 init_schema();
 init_model_catalog_store();
 init_providers();
@@ -15,13 +17,14 @@ function buildCapabilityPlansForConfig(config, options = {}) {
 	const cloud = catalog.sources["xopc-cloud"];
 	const providerReady = options.providerReady ?? defaultProviderReady;
 	const cloudReady = providerReady("xopc-cloud");
-	const agentId = config.agents.default ?? config.agents.list[0]?.id ?? "main";
+	const agentCatalog = new AgentCatalogRepository().snapshot();
+	const agentId = agentCatalog.defaultAgentId;
 	const stt = config.tools?.media?.audio;
 	const tts = config.messages?.tts;
 	const policies = {
-		vision: { explicit: refs(getAgentDefaultImageModelConfig(config)) },
-		"computer-use": { explicit: refs(config.agents.defaults.models.computerUse) },
-		"image-generation": { explicit: refs(getAgentDefaultImageGenerationModelConfig(config, agentId)) },
+		vision: { explicit: refs(getAgentDefaultImageModelConfig()) },
+		"computer-use": { explicit: refs(agentCatalog.defaults.models.computerUse) },
+		"image-generation": { explicit: refs(getAgentDefaultImageGenerationModelConfig(agentId)) },
 		stt: {
 			disabled: stt?.enabled === false,
 			explicit: stt ? sttRefs(stt) : void 0

package/dist/src/capabilities/runtime/dispatcher.d.ts

@@ -58,6 +58,7 @@ export declare class CapabilityDispatcher {
     private visible;
     list(context: CapabilityContext): CapabilityDescriptor[];
     describe(id: string, context: CapabilityContext): CapabilityDescriptor;
+    validateInput(id: string, input: unknown, context: CapabilityContext): Promise<unknown>;
     call(id: string, input: unknown, context: CapabilityContext, expected?: {
         majorVersion: number;
         descriptorDigest: string;

package/dist/src/capabilities/runtime/dispatcher.js

@@ -1,7 +1,7 @@
 import { SqliteCommitEffectError, init_transaction } from "../../storage/sqlite/transaction.js";
+import { OperationConflictError, executeAtomicOperation } from "./atomic-operations.js";
 import { CapabilityError } from "./errors.js";
 import { executeExternalOperation } from "./external-operations.js";
-import { OperationConflictError, executeAtomicOperation } from "./atomic-operations.js";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 //#region src/capabilities/runtime/dispatcher.ts
@@ -67,15 +67,21 @@ var CapabilityDispatcher = class {
 		if (!entry || !this.visible(entry.definition, context)) throw new CapabilityError("NOT_FOUND", "Capability not available");
 		return structuredClone(entry.descriptor);
 	}
-	async call(id, input, context, expected) {
-		const descriptor = this.describe(id, context);
-		if (expected && (expected.majorVersion !== descriptor.majorVersion || expected.descriptorDigest !== descriptor.descriptorDigest)) throw new CapabilityError("CONTRACT_CHANGED", "Capability contract changed; describe it again");
+	async validateInput(id, input, context) {
+		this.describe(id, context);
 		const { definition } = this.entries.get(id);
 		const parsed = definition.input.safeParse(input);
 		if (!parsed.success) throw new CapabilityError("INVALID_INPUT", parsed.error.message);
 		if (!await context.authorize(id, parsed.data)) throw new CapabilityError("FORBIDDEN", "Capability resource access denied");
 		context.assertCurrent?.();
 		if (context.signal?.aborted) throw new CapabilityError("CANCELLED", "Capability call cancelled");
+		return parsed.data;
+	}
+	async call(id, input, context, expected) {
+		const descriptor = this.describe(id, context);
+		if (expected && (expected.majorVersion !== descriptor.majorVersion || expected.descriptorDigest !== descriptor.descriptorDigest)) throw new CapabilityError("CONTRACT_CHANGED", "Capability contract changed; describe it again");
+		const { definition } = this.entries.get(id);
+		const parsed = { data: await this.validateInput(id, input, context) };
 		if (definition.effect === "external-write") {
 			const key = expected?.idempotencyKey;
 			if (!key?.trim() || key.length > 200) throw new CapabilityError("INVALID_INPUT", "A stable idempotencyKey is required");

package/dist/src/capabilities/runtime/product.js

@@ -1,5 +1,6 @@
 import { CapabilityError } from "./errors.js";
 import { CapabilityDispatcher } from "./dispatcher.js";
+import { registerAgentCapabilities } from "../../agent-catalog/capabilities.js";
 import { registerLocalAppReadCapabilities } from "../../local-apps/capabilities/read.js";
 import { registerNoteReadCapabilities } from "../../notes/capabilities/read.js";
 import { registerNoteWriteCapabilities } from "../../notes/capabilities/write.js";
@@ -23,6 +24,7 @@ function createProductDispatcher(getNotes, taskWrites) {
 	const dispatcher = new CapabilityDispatcher();
 	registerSettingsCapability(dispatcher);
 	registerAppContextCapability(dispatcher);
+	registerAgentCapabilities(dispatcher);
 	if (taskWrites?.getSceneAccess) {
 		registerSceneReadCapabilities(dispatcher, taskWrites.getSceneAccess);
 		registerSceneWriteCapabilities(dispatcher, taskWrites.getSceneAccess);