@actant/core 0.2.0 → 0.2.2

package/dist/index.js

@@ -1,3 +1,7 @@
+import {
+  parseSkillMdContent
+} from "./chunk-DYGZP4MW.js";
+
 // src/builder/cursor-builder.ts
 import { writeFile, mkdir, stat } from "fs/promises";
 import { join } from "path";
@@ -332,9 +336,9 @@ import { createLogger as createLogger3 } from "@actant/shared";
 // src/builder/handlers/skills-handler.ts
 var skillsHandler = {
   contextKey: "skills",
-  resolve(refs, manager) {
+  resolve(refs, manager2) {
     if (!refs || !Array.isArray(refs) || refs.length === 0) return [];
-    return manager?.resolve(refs) ?? refs.map((name) => ({ name, content: `- ${name}` }));
+    return manager2?.resolve(refs) ?? refs.map((name) => ({ name, content: `- ${name}` }));
   },
   async materialize(workspaceDir, definitions, _backendType, builder) {
     await builder.materializeSkills(workspaceDir, definitions);
@@ -344,9 +348,9 @@ var skillsHandler = {
 // src/builder/handlers/prompts-handler.ts
 var promptsHandler = {
   contextKey: "prompts",
-  resolve(refs, manager) {
+  resolve(refs, manager2) {
     if (!refs || !Array.isArray(refs) || refs.length === 0) return [];
-    return manager?.resolve(refs) ?? refs.map((name) => ({ name, content: `- ${name}` }));
+    return manager2?.resolve(refs) ?? refs.map((name) => ({ name, content: `- ${name}` }));
   },
   async materialize(workspaceDir, definitions, _backendType, builder) {
     await builder.materializePrompts(workspaceDir, definitions);
@@ -359,7 +363,7 @@ function isMcpServerRef(obj) {
 }
 var mcpServersHandler = {
   contextKey: "mcpServers",
-  resolve(refs, manager) {
+  resolve(refs, manager2) {
     if (!refs || !Array.isArray(refs) || refs.length === 0) return [];
     const arr = refs;
     if (arr.every(isMcpServerRef)) {
@@ -370,7 +374,7 @@ var mcpServersHandler = {
         env: ref.env
       }));
     }
-    return manager?.resolve(arr) ?? [];
+    return manager2?.resolve(arr) ?? [];
   },
   async materialize(workspaceDir, definitions, _backendType, builder) {
     await builder.materializeMcpConfig(workspaceDir, definitions);
@@ -380,11 +384,11 @@ var mcpServersHandler = {
 // src/builder/handlers/workflow-handler.ts
 var workflowHandler = {
   contextKey: "workflow",
-  resolve(refs, manager) {
+  resolve(refs, manager2) {
     if (refs === void 0 || refs === null) return [];
     const name = typeof refs === "string" ? refs : Array.isArray(refs) && typeof refs[0] === "string" ? refs[0] : void 0;
     if (!name) return [];
-    const resolved = manager?.resolve([name]);
+    const resolved = manager2?.resolve([name]);
     if (resolved && resolved.length > 0) return resolved;
     return [
       {
@@ -407,9 +411,9 @@ var workflowHandler = {
 // src/builder/handlers/plugins-handler.ts
 var pluginsHandler = {
   contextKey: "plugins",
-  resolve(refs, manager) {
+  resolve(refs, manager2) {
     if (!refs || !Array.isArray(refs) || refs.length === 0) return [];
-    return manager?.resolve(refs) ?? [];
+    return manager2?.resolve(refs) ?? [];
   },
   async materialize(workspaceDir, definitions, _backendType, builder) {
     await builder.materializePlugins(workspaceDir, definitions);
@@ -473,8 +477,8 @@ var WorkspaceBuilder = class {
       const refs = domainContext[handler.contextKey];
       if (refs === void 0 || refs === null) continue;
       if (Array.isArray(refs) && refs.length === 0) continue;
-      const manager = this.getManager(handler.contextKey);
-      const definitions = handler.resolve(refs, manager);
+      const manager2 = this.getManager(handler.contextKey);
+      const definitions = handler.resolve(refs, manager2);
       if (definitions.length > 0) {
         await handler.materialize(workspaceDir, definitions, backendType, activeBuilder);
         if (handler.contextKey === "mcpServers") {
@@ -1064,12 +1068,26 @@ var AgentBackendSchema = z2.object({
   type: z2.enum(["cursor", "cursor-agent", "claude-code", "custom", "pi"]),
   config: z2.record(z2.string(), z2.unknown()).optional()
 });
+var ModelApiProtocolEnum = z2.enum(["openai", "anthropic", "custom"]);
+var DEFAULT_PROTOCOL = {
+  anthropic: "anthropic",
+  openai: "openai",
+  deepseek: "openai",
+  ollama: "openai",
+  azure: "openai",
+  bedrock: "anthropic",
+  vertex: "anthropic",
+  custom: "custom"
+};
 var ModelProviderSchema = z2.object({
-  type: z2.enum(["anthropic", "openai", "openai-compatible", "custom"]),
-  protocol: z2.enum(["http", "websocket", "grpc"]).optional().default("http"),
+  type: z2.string().min(1),
+  protocol: ModelApiProtocolEnum.optional(),
   baseUrl: z2.string().optional(),
   config: z2.record(z2.string(), z2.unknown()).optional()
-});
+}).transform((val) => ({
+  ...val,
+  protocol: val.protocol ?? DEFAULT_PROTOCOL[val.type] ?? "custom"
+}));
 var InitializerStepSchema = z2.object({
   type: z2.string().min(1),
   config: z2.record(z2.string(), z2.unknown()).optional()
@@ -1127,7 +1145,7 @@ var AgentTemplateSchema = z2.object({
   origin: ComponentOriginSchema.optional(),
   tags: z2.array(z2.string()).optional(),
   backend: AgentBackendSchema,
-  provider: ModelProviderSchema,
+  provider: ModelProviderSchema.optional(),
   domainContext: DomainContextSchema,
   permissions: PermissionsInputSchema.optional(),
   initializer: InitializerSchema.optional(),
@@ -1255,6 +1273,58 @@ function isNodeError(err) {
   return err instanceof Error && "code" in err;
 }
 
+// src/provider/model-provider-registry.ts
+import { createLogger as createLogger11 } from "@actant/shared";
+var logger11 = createLogger11("model-provider-registry");
+var ModelProviderRegistry = class {
+  descriptors = /* @__PURE__ */ new Map();
+  defaultType;
+  register(descriptor) {
+    this.descriptors.set(descriptor.type, descriptor);
+    logger11.debug({ type: descriptor.type }, "Provider registered");
+  }
+  get(type) {
+    return this.descriptors.get(type);
+  }
+  getOrThrow(type) {
+    const desc = this.descriptors.get(type);
+    if (!desc) {
+      throw new Error(
+        `Provider "${type}" is not registered. Available providers: [${[...this.descriptors.keys()].join(", ")}].`
+      );
+    }
+    return desc;
+  }
+  has(type) {
+    return this.descriptors.has(type);
+  }
+  list() {
+    return [...this.descriptors.values()];
+  }
+  setDefault(type) {
+    if (!this.descriptors.has(type)) {
+      throw new Error(
+        `Cannot set default: provider "${type}" is not registered.`
+      );
+    }
+    this.defaultType = type;
+    logger11.info({ type }, "Default provider set");
+  }
+  getDefault() {
+    if (!this.defaultType) return void 0;
+    return this.descriptors.get(this.defaultType);
+  }
+  getDefaultType() {
+    return this.defaultType;
+  }
+  /** @internal Test-only: clear all registrations. */
+  _reset() {
+    this.descriptors.clear();
+    this.defaultType = void 0;
+  }
+};
+var modelProviderRegistry = new ModelProviderRegistry();
+
 // src/template/schema/config-validators.ts
 function zodToIssues(zodError) {
   return zodError.issues.map((i) => ({
@@ -1278,7 +1348,15 @@ function validateProviderConfig(data) {
   if (!result.success) {
     return { valid: false, errors: zodToIssues(result.error), warnings: [] };
   }
-  return { valid: true, data: result.data, errors: [], warnings: [] };
+  const warnings = [];
+  if (!modelProviderRegistry.has(result.data.type)) {
+    warnings.push(warning(
+      "provider.type",
+      `Provider type "${result.data.type}" is not registered; it will be treated as a custom provider`,
+      "UNKNOWN_PROVIDER_TYPE"
+    ));
+  }
+  return { valid: true, data: result.data, errors: [], warnings };
 }
 function validatePermissionsConfig(data) {
   const result = PermissionsInputSchema.safeParse(data);
@@ -1362,12 +1440,21 @@ function validateTemplate(data) {
       "CUSTOM_BACKEND_NO_CONFIG"
     ));
   }
-  if (template.provider.type === "custom" && !template.provider.config) {
-    warnings.push(warning(
-      "provider.config",
-      "Custom provider type without config; model routing may fail",
-      "CUSTOM_PROVIDER_NO_CONFIG"
-    ));
+  if (template.provider) {
+    if (template.provider.type === "custom" && !template.provider.config) {
+      warnings.push(warning(
+        "provider.config",
+        "Custom provider type without config; model routing may fail",
+        "CUSTOM_PROVIDER_NO_CONFIG"
+      ));
+    }
+    if (!modelProviderRegistry.has(template.provider.type)) {
+      warnings.push(warning(
+        "provider.type",
+        `Provider type "${template.provider.type}" is not registered; it will be treated as a custom provider`,
+        "UNKNOWN_PROVIDER_TYPE"
+      ));
+    }
   }
   return { valid: true, data: template, errors: [], warnings };
 }
@@ -1380,13 +1467,13 @@ import { TemplateNotFoundError, ConfigValidationError as ConfigValidationError3
 // src/domain/base-component-manager.ts
 import { readFile as readFile2, writeFile as writeFile4, readdir as readdir2, stat as stat4, unlink, mkdir as mkdir4 } from "fs/promises";
 import { join as join5, extname as extname2, resolve } from "path";
-import { ComponentReferenceError, ConfigNotFoundError as ConfigNotFoundError2, ConfigValidationError as ConfigValidationError2, createLogger as createLogger11 } from "@actant/shared";
+import { ComponentReferenceError, ConfigNotFoundError as ConfigNotFoundError2, ConfigValidationError as ConfigValidationError2, createLogger as createLogger12 } from "@actant/shared";
 var BaseComponentManager = class {
   components = /* @__PURE__ */ new Map();
   logger;
   persistDir;
   constructor(loggerName) {
-    this.logger = createLogger11(loggerName);
+    this.logger = createLogger12(loggerName);
   }
   setPersistDir(dir) {
     this.persistDir = dir;
@@ -1719,13 +1806,13 @@ var TemplateRegistry = class extends BaseComponentManager {
 import { watch } from "fs";
 import { join as join7 } from "path";
 import { access } from "fs/promises";
-import { createLogger as createLogger12 } from "@actant/shared";
-var logger11 = createLogger12("template-file-watcher");
+import { createLogger as createLogger13 } from "@actant/shared";
+var logger12 = createLogger13("template-file-watcher");
 var DEFAULT_DEBOUNCE_MS = 300;
 var TemplateFileWatcher = class {
-  constructor(templatesDir, registry3, options) {
+  constructor(templatesDir, registry2, options) {
     this.templatesDir = templatesDir;
-    this.registry = registry3;
+    this.registry = registry2;
     this.debounceMs = options?.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   }
   watcher = null;
@@ -1742,12 +1829,12 @@ var TemplateFileWatcher = class {
         this.handleChange(filename);
       });
       this.watcher.on("error", (err) => {
-        logger11.error({ error: err }, "File watcher error");
+        logger12.error({ error: err }, "File watcher error");
       });
       this.buildFileMap();
-      logger11.info({ dir: this.templatesDir }, "Template file watcher started");
+      logger12.info({ dir: this.templatesDir }, "Template file watcher started");
     } catch (err) {
-      logger11.error({ error: err, dir: this.templatesDir }, "Failed to start file watcher");
+      logger12.error({ error: err, dir: this.templatesDir }, "Failed to start file watcher");
     }
   }
   stop() {
@@ -1758,7 +1845,7 @@ var TemplateFileWatcher = class {
       clearTimeout(timer);
     }
     this.debounceTimers.clear();
-    logger11.info("Template file watcher stopped");
+    logger12.info("Template file watcher stopped");
   }
   get isWatching() {
     return this.watcher !== null;
@@ -1777,7 +1864,7 @@ var TemplateFileWatcher = class {
       setTimeout(() => {
         this.debounceTimers.delete(filename);
         this.processChange(filename).catch((err) => {
-          logger11.error({ filename, error: err }, "Error processing template file change");
+          logger12.error({ filename, error: err }, "Error processing template file change");
         });
       }, this.debounceMs)
     );
@@ -1795,7 +1882,7 @@ var TemplateFileWatcher = class {
       if (previousName && this.registry.has(previousName)) {
         this.registry.unregister(previousName);
         this.fileToName.delete(filename);
-        logger11.info({ templateName: previousName, filename }, "Template unregistered (file deleted)");
+        logger12.info({ templateName: previousName, filename }, "Template unregistered (file deleted)");
       }
       return;
     }
@@ -1810,9 +1897,9 @@ var TemplateFileWatcher = class {
       }
       this.registry.register(template);
       this.fileToName.set(filename, template.name);
-      logger11.info({ templateName: template.name, filename }, previousName ? "Template reloaded" : "New template registered");
+      logger12.info({ templateName: template.name, filename }, previousName ? "Template reloaded" : "New template registered");
     } catch (err) {
-      logger11.warn({ filePath, error: err }, "Failed to reload template");
+      logger12.warn({ filePath, error: err }, "Failed to reload template");
     }
   }
 };
@@ -1826,7 +1913,7 @@ import {
   ConfigValidationError as ConfigValidationError4,
   InstanceCorruptedError as InstanceCorruptedError3,
   WorkspaceInitError,
-  createLogger as createLogger15
+  createLogger as createLogger16
 } from "@actant/shared";
 
 // src/state/instance-meta-schema.ts
@@ -1848,7 +1935,7 @@ var LaunchModeSchema = z3.enum([
 ]);
 var ProcessOwnershipSchema = z3.enum(["managed", "external"]);
 var WorkspacePolicySchema = z3.enum(["persistent", "ephemeral"]);
-var AgentBackendTypeSchema = z3.enum(["cursor", "cursor-agent", "claude-code", "custom", "pi"]);
+var AgentBackendTypeSchema = z3.string().min(1);
 var PermissionModeSchema2 = z3.enum([
   "default",
   "acceptEdits",
@@ -1873,6 +1960,13 @@ var PermissionsConfigSchema = z3.object({
   sandbox: SandboxConfigSchema.optional(),
   additionalDirectories: z3.array(z3.string()).optional()
 });
+var ModelApiProtocolSchema = z3.enum(["openai", "anthropic", "custom"]);
+var ModelProviderConfigSchema = z3.object({
+  type: z3.string().min(1),
+  protocol: ModelApiProtocolSchema.optional().default("custom"),
+  baseUrl: z3.string().optional(),
+  config: z3.record(z3.string(), z3.unknown()).optional()
+});
 var AgentInstanceMetaSchema = z3.object({
   id: z3.string().min(1),
   name: z3.string().min(1),
@@ -1880,6 +1974,7 @@ var AgentInstanceMetaSchema = z3.object({
   templateVersion: z3.string().regex(/^\d+\.\d+\.\d+$/),
   backendType: AgentBackendTypeSchema.default("cursor"),
   backendConfig: z3.record(z3.string(), z3.unknown()).optional(),
+  providerConfig: ModelProviderConfigSchema.optional(),
   status: AgentStatusSchema,
   launchMode: LaunchModeSchema,
   workspacePolicy: WorkspacePolicySchema.default("persistent"),
@@ -1896,8 +1991,8 @@ import { readFile as readFile3, writeFile as writeFile5, rename, readdir as read
 import { join as join8, dirname } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 import { InstanceCorruptedError } from "@actant/shared";
-import { createLogger as createLogger13 } from "@actant/shared";
-var logger12 = createLogger13("instance-meta-io");
+import { createLogger as createLogger14 } from "@actant/shared";
+var logger13 = createLogger14("instance-meta-io");
 var META_FILENAME = ".actant.json";
 function metaFilePath(workspaceDir) {
   return join8(workspaceDir, META_FILENAME);
@@ -1949,12 +2044,12 @@ async function updateInstanceMeta(workspaceDir, patch) {
   await writeInstanceMeta(workspaceDir, updated);
   return updated;
 }
-async function scanInstances(instancesBaseDir, registry3) {
+async function scanInstances(instancesBaseDir, registry2) {
   const valid = [];
   const corrupted = [];
   const validNames = /* @__PURE__ */ new Set();
-  if (registry3) {
-    for (const entry of registry3.list()) {
+  if (registry2) {
+    for (const entry of registry2.list()) {
       if (entry.status === "orphaned") continue;
       try {
         const st = await stat5(entry.workspacePath);
@@ -1966,7 +2061,7 @@ async function scanInstances(instancesBaseDir, registry3) {
         valid.push(meta);
         validNames.add(entry.name);
       } catch (err) {
-        logger12.warn({ name: entry.name, path: entry.workspacePath, error: err }, "Registry entry unreachable or corrupted");
+        logger13.warn({ name: entry.name, path: entry.workspacePath, error: err }, "Registry entry unreachable or corrupted");
         corrupted.push(entry.name);
       }
     }
@@ -1991,7 +2086,7 @@ async function scanInstances(instancesBaseDir, registry3) {
       valid.push(meta);
       validNames.add(meta.name);
     } catch (err) {
-      logger12.warn({ dir: entry, error: err }, "Corrupted instance directory");
+      logger13.warn({ dir: entry, error: err }, "Corrupted instance directory");
       corrupted.push(entry);
     }
   }
@@ -2140,13 +2235,13 @@ function isNodeError4(err) {
 }
 
 // src/initializer/pipeline/initialization-pipeline.ts
-import { createLogger as createLogger14 } from "@actant/shared";
-var logger13 = createLogger14("initialization-pipeline");
+import { createLogger as createLogger15 } from "@actant/shared";
+var logger14 = createLogger15("initialization-pipeline");
 var DEFAULT_STEP_TIMEOUT_MS = 6e4;
 var DEFAULT_TOTAL_TIMEOUT_MS = 3e5;
 var InitializationPipeline = class {
-  constructor(registry3, options) {
-    this.registry = registry3;
+  constructor(registry2, options) {
+    this.registry = registry2;
     this.stepTimeoutMs = options?.defaultStepTimeoutMs ?? DEFAULT_STEP_TIMEOUT_MS;
     this.totalTimeoutMs = options?.totalTimeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS;
     this.onProgress = options?.onProgress;
@@ -2175,14 +2270,14 @@ var InitializationPipeline = class {
     const errors = [];
     const executed = [];
     const pipelineStart = Date.now();
-    logger13.info({ stepsCount: steps.length }, "Starting initialization pipeline");
+    logger14.info({ stepsCount: steps.length }, "Starting initialization pipeline");
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
       if (!step) continue;
       if (Date.now() - pipelineStart > this.totalTimeoutMs) {
         const err = new Error(`Pipeline total timeout exceeded (${this.totalTimeoutMs}ms)`);
         errors.push({ stepIndex: i, stepType: step.type, error: err });
-        logger13.error({ stepIndex: i, stepType: step.type }, "Pipeline timeout exceeded");
+        logger14.error({ stepIndex: i, stepType: step.type }, "Pipeline timeout exceeded");
         await this.rollback(executed, context, err);
         return { success: false, stepsExecuted: i, stepsTotal: steps.length, errors, outputs };
       }
@@ -2194,7 +2289,7 @@ var InitializationPipeline = class {
         return { success: false, stepsExecuted: i, stepsTotal: steps.length, errors, outputs };
       }
       this.onProgress?.(i, steps.length, step.type);
-      logger13.debug({ stepIndex: i, stepType: step.type }, "Executing step");
+      logger14.debug({ stepIndex: i, stepType: step.type }, "Executing step");
       try {
         const result = await this.executeWithTimeout(executor, context, step.config ?? {});
         if (!result.success) {
@@ -2209,18 +2304,18 @@ var InitializationPipeline = class {
           outputs.set(`step-${i}-${step.type}`, result.output);
         }
         if (result.message) {
-          logger13.info({ stepIndex: i, stepType: step.type }, result.message);
+          logger14.info({ stepIndex: i, stepType: step.type }, result.message);
         }
       } catch (err) {
         const error = err instanceof Error ? err : new Error(String(err));
         errors.push({ stepIndex: i, stepType: step.type, error });
-        logger13.error({ stepIndex: i, stepType: step.type, error }, "Step execution failed");
+        logger14.error({ stepIndex: i, stepType: step.type, error }, "Step execution failed");
         executed.push({ index: i, executor, config: step.config ?? {} });
         await this.rollback(executed, context, error);
         return { success: false, stepsExecuted: i + 1, stepsTotal: steps.length, errors, outputs };
       }
     }
-    logger13.info({ stepsExecuted: steps.length, elapsedMs: Date.now() - pipelineStart }, "Pipeline completed successfully");
+    logger14.info({ stepsExecuted: steps.length, elapsedMs: Date.now() - pipelineStart }, "Pipeline completed successfully");
     return { success: true, stepsExecuted: steps.length, stepsTotal: steps.length, errors, outputs };
   }
   async executeWithTimeout(executor, context, config) {
@@ -2242,7 +2337,7 @@ var InitializationPipeline = class {
   }
   async rollback(executed, context, triggerError) {
     if (executed.length === 0) return;
-    logger13.info({ stepsToRollback: executed.length }, "Rolling back executed steps");
+    logger14.info({ stepsToRollback: executed.length }, "Rolling back executed steps");
     for (let i = executed.length - 1; i >= 0; i--) {
       const entry = executed[i];
       if (!entry) continue;
@@ -2250,9 +2345,9 @@ var InitializationPipeline = class {
       if (!executor.rollback) continue;
       try {
         await executor.rollback(context, config, triggerError);
-        logger13.debug({ stepIndex: index, stepType: executor.type }, "Step rolled back");
+        logger14.debug({ stepIndex: index, stepType: executor.type }, "Step rolled back");
       } catch (rollbackErr) {
-        logger13.warn(
+        logger14.warn(
           { stepIndex: index, stepType: executor.type, error: rollbackErr },
           "Rollback failed (best-effort)"
         );
@@ -2262,7 +2357,7 @@ var InitializationPipeline = class {
 };
 
 // src/initializer/agent-initializer.ts
-var logger14 = createLogger15("agent-initializer");
+var logger15 = createLogger16("agent-initializer");
 var AgentInitializer = class {
   constructor(templateRegistry, instancesBaseDir, options) {
     this.templateRegistry = templateRegistry;
@@ -2304,10 +2399,10 @@ var AgentInitializer = class {
           );
         case "overwrite":
           await rm(workspaceDir, { recursive: true, force: true });
-          logger14.info({ workspaceDir }, "Existing directory removed (overwrite)");
+          logger15.info({ workspaceDir }, "Existing directory removed (overwrite)");
           break;
         case "append":
-          logger14.info({ workspaceDir }, "Appending to existing directory");
+          logger15.info({ workspaceDir }, "Appending to existing directory");
           break;
       }
     }
@@ -2335,7 +2430,7 @@ var AgentInitializer = class {
           workspaceDir,
           instanceMeta: { name, templateName: template.name },
           template,
-          logger: logger14,
+          logger: logger15,
           state: /* @__PURE__ */ new Map()
         };
         const pipelineResult = await this.pipeline.run(template.initializer.steps, stepContext);
@@ -2348,6 +2443,7 @@ var AgentInitializer = class {
         }
       }
       const effectivePermissions = resolvePermissions(finalPermissions);
+      const resolvedProvider = resolveProviderConfig(template.provider);
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const launchMode = overrides?.launchMode ?? this.options?.defaultLaunchMode ?? "direct";
       const defaultPolicy = launchMode === "one-shot" ? "ephemeral" : "persistent";
@@ -2358,6 +2454,7 @@ var AgentInitializer = class {
         templateVersion: template.version,
         backendType: template.backend.type,
         backendConfig: template.backend.config ? { ...template.backend.config } : void 0,
+        providerConfig: resolvedProvider,
         status: "created",
         launchMode,
         workspacePolicy: overrides?.workspacePolicy ?? defaultPolicy,
@@ -2372,13 +2469,13 @@ var AgentInitializer = class {
         const linkType = process.platform === "win32" ? "junction" : "dir";
         await symlink(workspaceDir, join10(this.instancesBaseDir, name), linkType);
       }
-      logger14.info({ name, templateName, workspaceDir, customWorkDir: !!customWorkDir }, "Agent instance created");
+      logger15.info({ name, templateName, workspaceDir, customWorkDir: !!customWorkDir }, "Agent instance created");
       return meta;
     } catch (err) {
       if (shouldCleanupOnError) {
         await rm(workspaceDir, { recursive: true, force: true }).catch(() => {
         });
-        logger14.debug({ workspaceDir }, "Cleaned up workspace after failed creation");
+        logger15.debug({ workspaceDir }, "Cleaned up workspace after failed creation");
       }
       if (err instanceof ActantError) {
         throw err;
@@ -2397,7 +2494,7 @@ var AgentInitializer = class {
     if (await dirExists(workspaceDir)) {
       try {
         const meta2 = await readInstanceMeta(workspaceDir);
-        logger14.debug({ name }, "Existing instance found");
+        logger15.debug({ name }, "Existing instance found");
         return { meta: meta2, created: false };
       } catch (err) {
         if (err instanceof InstanceCorruptedError3) {
@@ -2418,7 +2515,7 @@ var AgentInitializer = class {
   async destroyInstance(name) {
     const entryPath = join10(this.instancesBaseDir, name);
     if (!await entryExists(entryPath)) {
-      logger14.warn({ name }, "Instance directory not found, nothing to destroy");
+      logger15.warn({ name }, "Instance directory not found, nothing to destroy");
       return;
     }
     if (await isSymlink(entryPath)) {
@@ -2428,13 +2525,30 @@ var AgentInitializer = class {
       } catch {
       }
       await rm(entryPath, { recursive: true, force: true });
-      logger14.info({ name, targetDir }, "Symlinked agent instance unregistered");
+      logger15.info({ name, targetDir }, "Symlinked agent instance unregistered");
     } else {
       await rm(entryPath, { recursive: true, force: true });
-      logger14.info({ name }, "Agent instance destroyed");
+      logger15.info({ name }, "Agent instance destroyed");
     }
   }
 };
+function resolveProviderConfig(templateProvider) {
+  if (templateProvider) {
+    if (templateProvider.protocol) return templateProvider;
+    const desc = modelProviderRegistry.get(templateProvider.type);
+    return {
+      ...templateProvider,
+      protocol: desc?.protocol ?? "custom"
+    };
+  }
+  const defaultDesc = modelProviderRegistry.getDefault();
+  if (!defaultDesc) return void 0;
+  return {
+    type: defaultDesc.type,
+    protocol: defaultDesc.protocol,
+    baseUrl: defaultDesc.defaultBaseUrl
+  };
+}
 async function dirExists(path) {
   try {
     await access2(path);
@@ -2463,8 +2577,8 @@ async function isSymlink(path) {
 // src/initializer/context/context-materializer.ts
 import { writeFile as writeFile7, mkdir as mkdir9 } from "fs/promises";
 import { join as join11 } from "path";
-import { createLogger as createLogger16 } from "@actant/shared";
-var logger15 = createLogger16("context-materializer");
+import { createLogger as createLogger17 } from "@actant/shared";
+var logger16 = createLogger17("context-materializer");
 var BACKEND_CONFIG_DIR = {
   cursor: ".cursor",
   "cursor-agent": ".cursor",
@@ -2477,7 +2591,7 @@ var ContextMaterializer = class {
     this.managers = managers;
   }
   async materialize(workspaceDir, domainContext, backendType = "cursor") {
-    const configDir = BACKEND_CONFIG_DIR[backendType];
+    const configDir = BACKEND_CONFIG_DIR[backendType] ?? ".cursor";
     const tasks = [];
     if (domainContext.skills && domainContext.skills.length > 0) {
       tasks.push(this.materializeSkills(workspaceDir, domainContext.skills));
@@ -2495,7 +2609,7 @@ var ContextMaterializer = class {
       tasks.push(this.materializePrompts(workspaceDir, domainContext.prompts));
     }
     await Promise.all(tasks);
-    logger15.debug({ workspaceDir, backendType, configDir }, "Domain context materialized");
+    logger16.debug({ workspaceDir, backendType, configDir }, "Domain context materialized");
   }
   async materializeSkills(workspaceDir, skillNames) {
     let content;
@@ -2610,16 +2724,16 @@ var InitializerStepExecutor = class {
 };
 
 // src/initializer/pipeline/step-registry.ts
-import { createLogger as createLogger17 } from "@actant/shared";
-var logger16 = createLogger17("step-registry");
+import { createLogger as createLogger18 } from "@actant/shared";
+var logger17 = createLogger18("step-registry");
 var StepRegistry = class {
   executors = /* @__PURE__ */ new Map();
   register(executor) {
     if (this.executors.has(executor.type)) {
-      logger16.warn({ type: executor.type }, "Overwriting existing step executor");
+      logger17.warn({ type: executor.type }, "Overwriting existing step executor");
     }
     this.executors.set(executor.type, executor);
-    logger16.debug({ type: executor.type }, "Step executor registered");
+    logger17.debug({ type: executor.type }, "Step executor registered");
   }
   get(type) {
     return this.executors.get(type);
@@ -2878,10 +2992,10 @@ var NpmInstallStep = class extends InitializerStepExecutor {
     return { valid: issues.length === 0, issues };
   }
   async execute(context, config) {
-    const { packageManager = "npm", cwd = ".", args = [], registry: registry3 } = config;
+    const { packageManager = "npm", cwd = ".", args = [], registry: registry2 } = config;
     const workDir = join16(context.workspaceDir, cwd);
     const cmdArgs = ["install", ...args];
-    if (registry3) cmdArgs.push("--registry", registry3);
+    if (registry2) cmdArgs.push("--registry", registry2);
     context.logger.debug({ packageManager, cwd: workDir, args: cmdArgs }, "Installing dependencies");
     const result = await runInstall(packageManager, cmdArgs, workDir);
     if (result.exitCode !== 0) {
@@ -2923,80 +3037,294 @@ function runInstall(pm, args, cwd) {
 
 // src/initializer/steps/index.ts
 function createDefaultStepRegistry() {
-  const registry3 = new StepRegistry();
-  registry3.register(new MkdirStep());
-  registry3.register(new ExecStep());
-  registry3.register(new FileCopyStep());
-  registry3.register(new GitCloneStep());
-  registry3.register(new NpmInstallStep());
-  return registry3;
+  const registry2 = new StepRegistry();
+  registry2.register(new MkdirStep());
+  registry2.register(new ExecStep());
+  registry2.register(new FileCopyStep());
+  registry2.register(new GitCloneStep());
+  registry2.register(new NpmInstallStep());
+  return registry2;
 }
 
 // src/manager/agent-manager.ts
 import { join as join17 } from "path";
+import { existsSync } from "fs";
 import { rename as rename3, mkdir as mkdir11 } from "fs/promises";
 import {
   AgentNotFoundError,
   AgentAlreadyRunningError,
   AgentAlreadyAttachedError,
   AgentNotAttachedError,
-  createLogger as createLogger23
+  AgentLaunchError,
+  createLogger as createLogger24
 } from "@actant/shared";
 
+// src/domain/backend/backend-manager.ts
+import { execFile } from "child_process";
+
+// src/domain/backend/backend-schema.ts
+import { z as z4 } from "zod/v4";
+var PlatformCommandSchema = z4.object({
+  win32: z4.string().min(1),
+  default: z4.string().min(1)
+});
+var OpenSpawnOptionsSchema = z4.object({
+  stdio: z4.enum(["inherit", "ignore"]).optional(),
+  detached: z4.boolean().optional(),
+  windowsHide: z4.boolean().optional(),
+  shell: z4.boolean().optional()
+});
+var ExistenceCheckSchema = z4.object({
+  command: z4.string().min(1),
+  args: z4.array(z4.string()).optional(),
+  expectedExitCode: z4.number().int().optional(),
+  versionPattern: z4.string().optional()
+});
+var InstallMethodSchema = z4.object({
+  type: z4.enum(["npm", "brew", "winget", "choco", "url", "manual"]),
+  package: z4.string().optional(),
+  platforms: z4.array(z4.string()).optional(),
+  label: z4.string().optional(),
+  instructions: z4.string().optional()
+});
+var BackendDefinitionSchema = z4.object({
+  name: z4.string().min(1),
+  version: z4.string().optional(),
+  description: z4.string().optional(),
+  tags: z4.array(z4.string()).optional(),
+  supportedModes: z4.array(z4.enum(["resolve", "open", "acp"])).min(1),
+  resolveCommand: PlatformCommandSchema.optional(),
+  openCommand: PlatformCommandSchema.optional(),
+  acpCommand: PlatformCommandSchema.optional(),
+  acpOwnsProcess: z4.boolean().optional(),
+  resolvePackage: z4.string().optional(),
+  openWorkspaceDir: z4.enum(["arg", "cwd"]).optional(),
+  openSpawnOptions: OpenSpawnOptionsSchema.optional(),
+  existenceCheck: ExistenceCheckSchema.optional(),
+  install: z4.array(InstallMethodSchema).optional()
+}).passthrough();
+
+// src/domain/backend/backend-manager.ts
+var BackendManager = class extends BaseComponentManager {
+  componentType = "Backend";
+  acpResolvers = /* @__PURE__ */ new Map();
+  constructor() {
+    super("backend-manager");
+  }
+  // ---------------------------------------------------------------------------
+  // ACP resolver (behavioral extension, not serializable)
+  // ---------------------------------------------------------------------------
+  registerAcpResolver(backendName, resolver) {
+    this.acpResolvers.set(backendName, resolver);
+  }
+  getAcpResolver(backendName) {
+    return this.acpResolvers.get(backendName);
+  }
+  // ---------------------------------------------------------------------------
+  // Mode queries
+  // ---------------------------------------------------------------------------
+  supportsMode(backendName, mode) {
+    const def = this.get(backendName);
+    return def != null && def.supportedModes.includes(mode);
+  }
+  requireMode(backendName, mode) {
+    const def = this.get(backendName);
+    if (!def) {
+      throw new Error(
+        `Backend "${backendName}" is not registered. Ensure the backend package is installed and its definition was loaded at startup.`
+      );
+    }
+    if (!def.supportedModes.includes(mode)) {
+      const supported = def.supportedModes.join(", ");
+      throw new Error(
+        `Backend "${backendName}" does not support "${mode}" mode. Supported modes: [${supported}]. ` + (mode === "resolve" ? `Use \`agent start\` or \`agent run\` instead.` : mode === "open" ? `This backend has no native TUI/UI to open.` : `Use \`agent resolve\` or \`agent open\` instead.`)
+      );
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Platform command helper
+  // ---------------------------------------------------------------------------
+  getPlatformCommand(cmd) {
+    return process.platform === "win32" ? cmd.win32 : cmd.default;
+  }
+  // ---------------------------------------------------------------------------
+  // Availability check
+  // ---------------------------------------------------------------------------
+  /**
+   * Probe whether a backend binary is available on the system.
+   * Uses the `existenceCheck` field. Returns `{ available, version? }`.
+   * If no `existenceCheck` is configured, returns `{ available: true }` (assume ok).
+   */
+  async checkAvailability(backendName) {
+    const def = this.get(backendName);
+    if (!def) return { available: false, error: `Backend "${backendName}" not registered` };
+    if (!def.existenceCheck) return { available: true };
+    const { command, args = ["--version"], expectedExitCode = 0, versionPattern } = def.existenceCheck;
+    try {
+      const { stdout, exitCode } = await execCommand(command, args);
+      if (exitCode !== expectedExitCode) {
+        return { available: false, error: `Exit code ${exitCode} (expected ${expectedExitCode})` };
+      }
+      if (versionPattern) {
+        const match = new RegExp(versionPattern).exec(stdout);
+        if (!match) {
+          return { available: false, error: `Version output didn't match pattern: ${versionPattern}` };
+        }
+        return { available: true, version: match[0] };
+      }
+      const version = stdout.trim().split("\n")[0];
+      return { available: true, version: version || void 0 };
+    } catch (err) {
+      return { available: false, error: err.message };
+    }
+  }
+  /**
+   * Get platform-appropriate install methods for a backend.
+   * Filters by `platforms` field; returns all methods if no platform restriction.
+   */
+  getInstallMethods(backendName) {
+    const def = this.get(backendName);
+    if (!def?.install) return [];
+    const plat = process.platform;
+    return def.install.filter((m) => !m.platforms || m.platforms.includes(plat));
+  }
+  // ---------------------------------------------------------------------------
+  // Validation
+  // ---------------------------------------------------------------------------
+  validate(data, _source) {
+    const result = BackendDefinitionSchema.safeParse(data);
+    if (!result.success) {
+      return {
+        valid: false,
+        errors: result.error.issues.map((i) => ({
+          path: i.path.map(String).join("."),
+          message: i.message,
+          severity: "error"
+        })),
+        warnings: []
+      };
+    }
+    return { valid: true, data: result.data, errors: [], warnings: [] };
+  }
+};
+function execCommand(command, args) {
+  return new Promise((resolve3) => {
+    execFile(command, args, { timeout: 1e4, windowsHide: true }, (err, stdout) => {
+      if (err && typeof err.code === "string" && err.code === "ENOENT") {
+        resolve3({ stdout: "", exitCode: -1 });
+        return;
+      }
+      const exitCode = err && "code" in err && typeof err.code === "number" ? err.code : err ? 1 : 0;
+      resolve3({ stdout: stdout ?? "", exitCode });
+    });
+  });
+}
+
 // src/manager/launcher/backend-registry.ts
-var registry = /* @__PURE__ */ new Map();
+var manager = new BackendManager();
+function getBackendManager() {
+  return manager;
+}
 function registerBackend(descriptor) {
-  registry.set(descriptor.type, descriptor);
+  const { type, acpResolver, ...rest } = descriptor;
+  const definition = { ...rest, name: type };
+  manager.register(definition);
+  if (acpResolver) {
+    manager.registerAcpResolver(type, acpResolver);
+  }
+}
+function registerBackendDefinition(definition) {
+  manager.register(definition);
 }
 function getBackendDescriptor(type) {
-  const desc = registry.get(type);
-  if (!desc) {
+  const def = manager.get(type);
+  if (!def) {
     throw new Error(
       `Backend "${type}" is not registered. Ensure the backend package is installed and registerBackend() was called at startup.`
     );
   }
-  return desc;
+  return def;
 }
 function supportsMode(type, mode) {
-  const desc = registry.get(type);
-  return desc != null && desc.supportedModes.includes(mode);
+  return manager.supportsMode(type, mode);
 }
 function requireMode(type, mode) {
-  const desc = getBackendDescriptor(type);
-  if (!desc.supportedModes.includes(mode)) {
-    const supported = desc.supportedModes.join(", ");
-    throw new Error(
-      `Backend "${type}" does not support "${mode}" mode. Supported modes: [${supported}]. ` + (mode === "resolve" ? `Use \`agent start\` or \`agent run\` instead.` : mode === "open" ? `This backend has no native TUI/UI to open.` : `Use \`agent resolve\` or \`agent open\` instead.`)
-    );
-  }
+  manager.requireMode(type, mode);
 }
 function getPlatformCommand(cmd) {
-  return process.platform === "win32" ? cmd.win32 : cmd.default;
+  return manager.getPlatformCommand(cmd);
+}
+function getInstallHint(type) {
+  const methods = manager.getInstallMethods(type);
+  const first = methods[0];
+  return first?.label ?? first?.instructions;
+}
+function getAcpResolver(type) {
+  return manager.getAcpResolver(type);
 }
 
 // src/manager/launcher/builtin-backends.ts
-function registerBuiltinBackends() {
-  registerBackend({
-    type: "cursor",
+var BUILTIN_BACKENDS = [
+  {
+    name: "cursor",
+    version: "1.0.0",
+    description: "Cursor IDE",
+    origin: { type: "builtin" },
     supportedModes: ["resolve", "open"],
     resolveCommand: { win32: "cursor.cmd", default: "cursor" },
-    openCommand: { win32: "cursor.cmd", default: "cursor" }
-  });
-  registerBackend({
-    type: "cursor-agent",
+    openCommand: { win32: "cursor.cmd", default: "cursor" },
+    openSpawnOptions: { shell: process.platform === "win32" },
+    existenceCheck: { command: "cursor", args: ["--version"] },
+    install: [
+      { type: "url", package: "https://cursor.com", label: "Download Cursor", platforms: ["win32", "darwin", "linux"] },
+      { type: "brew", package: "cursor", label: "brew install --cask cursor", platforms: ["darwin"] },
+      { type: "winget", package: "Anysphere.Cursor", label: "winget install Anysphere.Cursor", platforms: ["win32"] }
+    ]
+  },
+  {
+    name: "cursor-agent",
+    version: "1.0.0",
+    description: "Cursor Agent (TUI)",
+    origin: { type: "builtin" },
     supportedModes: ["resolve", "open", "acp"],
-    resolveCommand: { win32: "cursor.cmd", default: "cursor" },
-    openCommand: { win32: "cursor.cmd", default: "cursor" }
-  });
-  registerBackend({
-    type: "claude-code",
-    supportedModes: ["resolve", "acp"],
-    resolveCommand: { win32: "claude-agent-acp.cmd", default: "claude-agent-acp" }
-  });
-  registerBackend({
-    type: "custom",
+    resolveCommand: { win32: "agent", default: "agent" },
+    openCommand: { win32: "agent", default: "agent" },
+    openWorkspaceDir: "cwd",
+    openSpawnOptions: { stdio: "inherit", detached: false, windowsHide: false },
+    existenceCheck: { command: "agent", args: ["--version"] },
+    install: [
+      { type: "manual", label: "Included with Cursor", instructions: "Install Cursor from https://cursor.com \u2014 the `agent` CLI is bundled." }
+    ]
+  },
+  {
+    name: "claude-code",
+    version: "1.0.0",
+    description: "Claude Code CLI",
+    origin: { type: "builtin" },
+    supportedModes: ["resolve", "open", "acp"],
+    resolveCommand: { win32: "claude-agent-acp.cmd", default: "claude-agent-acp" },
+    openCommand: { win32: "claude.exe", default: "claude" },
+    openWorkspaceDir: "cwd",
+    openSpawnOptions: { stdio: "inherit", detached: false, windowsHide: false },
+    resolvePackage: "@zed-industries/claude-agent-acp",
+    existenceCheck: { command: "claude", args: ["--version"] },
+    install: [
+      { type: "npm", package: "@anthropic-ai/claude-code", label: "npm install -g @anthropic-ai/claude-code" }
+    ]
+  },
+  {
+    name: "custom",
+    version: "1.0.0",
+    description: "Custom backend (user-provided executable)",
+    origin: { type: "builtin" },
     supportedModes: ["resolve"]
-  });
+  }
+];
+function registerBuiltinBackends() {
+  const mgr = getBackendManager();
+  for (const def of BUILTIN_BACKENDS) {
+    mgr.register(def);
+  }
 }
 registerBuiltinBackends();
 
@@ -3032,25 +3360,36 @@ function resolveBackend(backendType, workspaceDir, backendConfig) {
   })();
   return {
     command,
-    args: buildArgs(backendType, workspaceDir, backendConfig)
+    args: buildArgs(backendType, workspaceDir, backendConfig),
+    resolvePackage: desc.resolvePackage
   };
 }
+var DEFAULT_OPEN_SPAWN = {
+  stdio: "ignore",
+  detached: true,
+  windowsHide: true,
+  shell: false
+};
 function openBackend(backendType, workspaceDir) {
   requireMode(backendType, "open");
   const desc = getBackendDescriptor(backendType);
   if (!desc.openCommand) {
     throw new Error(`Backend "${backendType}" has no openCommand configured.`);
   }
+  const useCwd = desc.openWorkspaceDir === "cwd";
   return {
     command: getPlatformCommand(desc.openCommand),
-    args: [workspaceDir]
+    args: useCwd ? [] : [workspaceDir],
+    cwd: useCwd ? workspaceDir : void 0,
+    openSpawnOptions: { ...DEFAULT_OPEN_SPAWN, ...desc.openSpawnOptions }
   };
 }
 function resolveAcpBackend(backendType, workspaceDir, backendConfig) {
   requireMode(backendType, "acp");
   const desc = getBackendDescriptor(backendType);
-  if (desc.acpResolver) {
-    return desc.acpResolver(workspaceDir, backendConfig);
+  const resolver = getAcpResolver(backendType);
+  if (resolver) {
+    return resolver(workspaceDir, backendConfig);
   }
   const explicitPath = backendConfig?.executablePath;
   const commandSource = desc.acpCommand ?? desc.resolveCommand;
@@ -3059,12 +3398,13 @@ function resolveAcpBackend(backendType, workspaceDir, backendConfig) {
   })();
   return {
     command,
-    args: buildArgs(backendType, workspaceDir, backendConfig)
+    args: buildArgs(backendType, workspaceDir, backendConfig),
+    resolvePackage: desc.resolvePackage
   };
 }
 
 // src/manager/launcher/process-watcher.ts
-import { createLogger as createLogger18 } from "@actant/shared";
+import { createLogger as createLogger19 } from "@actant/shared";
 
 // src/manager/launcher/process-utils.ts
 function isProcessAlive(pid) {
@@ -3100,7 +3440,7 @@ function isNodeError5(err) {
 }
 
 // src/manager/launcher/process-watcher.ts
-var logger17 = createLogger18("process-watcher");
+var logger18 = createLogger19("process-watcher");
 var DEFAULT_POLL_INTERVAL = 5e3;
 var ProcessWatcher = class {
   constructor(onProcessExit, options) {
@@ -3113,12 +3453,12 @@ var ProcessWatcher = class {
   pollIntervalMs;
   watch(instanceName, pid) {
     this.watches.set(instanceName, { pid });
-    logger17.debug({ instanceName, pid }, "Watching process");
+    logger18.debug({ instanceName, pid }, "Watching process");
   }
   unwatch(instanceName) {
     const removed = this.watches.delete(instanceName);
     if (removed) {
-      logger17.debug({ instanceName }, "Unwatched process");
+      logger18.debug({ instanceName }, "Unwatched process");
     }
     return removed;
   }
@@ -3133,13 +3473,13 @@ var ProcessWatcher = class {
     this.timer = setInterval(() => {
       void this.poll();
     }, this.pollIntervalMs);
-    logger17.info({ pollIntervalMs: this.pollIntervalMs }, "ProcessWatcher started");
+    logger18.info({ pollIntervalMs: this.pollIntervalMs }, "ProcessWatcher started");
   }
   stop() {
     if (this.timer) {
       clearInterval(this.timer);
       this.timer = null;
-      logger17.info("ProcessWatcher stopped");
+      logger18.info("ProcessWatcher stopped");
     }
   }
   dispose() {
@@ -3161,11 +3501,11 @@ var ProcessWatcher = class {
       }
       for (const info of exited) {
         this.watches.delete(info.instanceName);
-        logger17.info(info, "Process exited \u2014 removed from watch list");
+        logger18.info(info, "Process exited \u2014 removed from watch list");
         try {
           await this.onProcessExit(info);
         } catch (err) {
-          logger17.error({ ...info, error: err }, "Error in process exit handler");
+          logger18.error({ ...info, error: err }, "Error in process exit handler");
         }
       }
     } finally {
@@ -3175,8 +3515,8 @@ var ProcessWatcher = class {
 };
 
 // src/manager/launch-mode-handler.ts
-import { createLogger as createLogger19 } from "@actant/shared";
-var logger18 = createLogger19("launch-mode-handler");
+import { createLogger as createLogger20 } from "@actant/shared";
+var logger19 = createLogger20("launch-mode-handler");
 var DirectModeHandler = class {
   mode = "direct";
   getProcessExitAction(_instanceName) {
@@ -3198,11 +3538,11 @@ var AcpBackgroundModeHandler = class {
 var AcpServiceModeHandler = class {
   mode = "acp-service";
   getProcessExitAction(instanceName) {
-    logger18.info({ instanceName }, "acp-service process exited \u2014 restart policy will be checked");
+    logger19.info({ instanceName }, "acp-service process exited \u2014 restart policy will be checked");
     return { type: "restart" };
   }
   getRecoveryAction(instanceName) {
-    logger18.info({ instanceName }, "acp-service stale instance \u2014 will attempt recovery restart");
+    logger19.info({ instanceName }, "acp-service stale instance \u2014 will attempt recovery restart");
     return { type: "restart" };
   }
 };
@@ -3229,8 +3569,8 @@ function getLaunchModeHandler(mode) {
 }
 
 // src/manager/restart-tracker.ts
-import { createLogger as createLogger20 } from "@actant/shared";
-var logger19 = createLogger20("restart-tracker");
+import { createLogger as createLogger21 } from "@actant/shared";
+var logger20 = createLogger21("restart-tracker");
 var DEFAULT_RESTART_POLICY = {
   maxRestarts: 5,
   backoffBaseMs: 1e3,
@@ -3248,12 +3588,12 @@ var RestartTracker = class {
     if (state.lastStartAt > 0) {
       const stableMs = Date.now() - state.lastStartAt;
       if (stableMs >= this.policy.resetAfterMs) {
-        logger19.info({ instanceName, stableMs, resetAfterMs: this.policy.resetAfterMs }, "Resetting restart counter \u2014 agent was stable");
+        logger20.info({ instanceName, stableMs, resetAfterMs: this.policy.resetAfterMs }, "Resetting restart counter \u2014 agent was stable");
         state.count = 0;
       }
     }
     if (state.count >= this.policy.maxRestarts) {
-      logger19.warn({ instanceName, count: state.count, maxRestarts: this.policy.maxRestarts }, "Restart limit exceeded");
+      logger20.warn({ instanceName, count: state.count, maxRestarts: this.policy.maxRestarts }, "Restart limit exceeded");
       return { allowed: false, delayMs: 0, attempt: state.count };
     }
     const delayMs = Math.min(
@@ -3266,7 +3606,7 @@ var RestartTracker = class {
     const state = this.getOrCreate(instanceName);
     state.count++;
     state.lastRestartAt = Date.now();
-    logger19.debug({ instanceName, count: state.count }, "Restart recorded");
+    logger20.debug({ instanceName, count: state.count }, "Restart recorded");
   }
   recordStart(instanceName) {
     const state = this.getOrCreate(instanceName);
@@ -3293,8 +3633,8 @@ var RestartTracker = class {
 
 // src/communicator/claude-code-communicator.ts
 import { spawn as spawn4 } from "child_process";
-import { createLogger as createLogger21 } from "@actant/shared";
-var logger20 = createLogger21("claude-code-communicator");
+import { createLogger as createLogger22 } from "@actant/shared";
+var logger21 = createLogger22("claude-code-communicator");
 var DEFAULT_TIMEOUT_MS = 3e5;
 var ClaudeCodeCommunicator = class {
   executable;
@@ -3303,12 +3643,13 @@ var ClaudeCodeCommunicator = class {
   }
   async runPrompt(workspaceDir, prompt, options) {
     const args = this.buildArgs(prompt, options, "json");
-    logger20.debug({ workspaceDir, args }, "Running claude-code prompt");
+    logger21.debug({ workspaceDir, args }, "Running claude-code prompt");
     return new Promise((resolve3, reject) => {
       const child = spawn4(this.executable, args, {
         cwd: workspaceDir,
         stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env }
+        env: { ...process.env },
+        windowsHide: true
       });
       let stdout = "";
       let stderr = "";
@@ -3326,7 +3667,7 @@ var ClaudeCodeCommunicator = class {
       child.on("close", (code) => {
         clearTimeout(timer);
         if (code !== 0) {
-          logger20.warn({ code, stderr: stderr.slice(0, 500) }, "claude-code exited with error");
+          logger21.warn({ code, stderr: stderr.slice(0, 500) }, "claude-code exited with error");
           reject(new Error(`claude-code exited with code ${code}: ${stderr.slice(0, 500)}`));
           return;
         }
@@ -3336,7 +3677,7 @@ var ClaudeCodeCommunicator = class {
           const sessionId = parsed["session_id"];
           const subtype = parsed["subtype"];
           if (subtype && subtype !== "success") {
-            logger20.warn({ subtype }, "claude-code returned non-success subtype");
+            logger21.warn({ subtype }, "claude-code returned non-success subtype");
           }
           let text;
           if (result && result.length > 0) {
@@ -3344,11 +3685,18 @@ var ClaudeCodeCommunicator = class {
           } else if (subtype === "error_max_turns") {
             text = "[max turns reached \u2014 no final result text]";
           } else {
-            text = stdout.trim();
+            const costUsd = parsed["cost_usd"];
+            const duration = parsed["duration_ms"];
+            const parts = ["[no result text]"];
+            if (subtype) parts.push(`subtype=${subtype}`);
+            if (costUsd != null) parts.push(`cost=$${costUsd.toFixed(4)}`);
+            if (duration != null) parts.push(`duration=${duration}ms`);
+            text = parts.join(" ");
           }
           resolve3({ text, sessionId });
         } catch {
-          resolve3({ text: stdout.trim() });
+          const firstLine = stdout.slice(0, 200).split("\n")[0] ?? "";
+          resolve3({ text: firstLine || "[unparseable response]" });
         }
       });
       child.on("error", (err) => {
@@ -3360,11 +3708,12 @@ var ClaudeCodeCommunicator = class {
   }
   async *streamPrompt(workspaceDir, prompt, options) {
     const args = this.buildArgs(prompt, options, "stream-json");
-    logger20.debug({ workspaceDir, args }, "Streaming claude-code prompt");
+    logger21.debug({ workspaceDir, args }, "Streaming claude-code prompt");
     const child = spawn4(this.executable, args, {
       cwd: workspaceDir,
       stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env }
+      env: { ...process.env },
+      windowsHide: true
     });
     const timeout = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const timer = setTimeout(() => {
@@ -3457,11 +3806,11 @@ function parseStreamEvent(event) {
 }
 
 // src/communicator/cursor-communicator.ts
-import { createLogger as createLogger22 } from "@actant/shared";
-var logger21 = createLogger22("cursor-communicator");
+import { createLogger as createLogger23 } from "@actant/shared";
+var logger22 = createLogger23("cursor-communicator");
 var CursorCommunicator = class {
   async runPrompt(_workspaceDir, _prompt, _options) {
-    logger21.warn("Cursor backend does not yet support programmatic communication");
+    logger22.warn("Cursor backend does not yet support programmatic communication");
     throw new Error(
       "Cursor backend does not support programmatic communication yet. Use claude-code backend for agent.run / agent.chat functionality."
     );
@@ -3475,12 +3824,12 @@ var CursorCommunicator = class {
 };
 
 // src/communicator/create-communicator.ts
-var registry2 = /* @__PURE__ */ new Map();
+var registry = /* @__PURE__ */ new Map();
 function registerCommunicator(backendType, factory) {
-  registry2.set(backendType, factory);
+  registry.set(backendType, factory);
 }
 function createCommunicator(backendType, backendConfig) {
-  const registered = registry2.get(backendType);
+  const registered = registry.get(backendType);
   if (registered) return registered(backendConfig);
   switch (backendType) {
     case "claude-code":
@@ -3488,19 +3837,15 @@ function createCommunicator(backendType, backendConfig) {
     case "cursor":
     case "cursor-agent":
       return new CursorCommunicator();
-    case "custom":
+    default:
       throw new Error(
-        "Custom backend communicator not yet supported. Implement AgentCommunicator for your backend."
-      );
-    case "pi":
-      throw new Error(
-        "Pi backend communicator not registered. Ensure @actant/pi is installed and initialized."
+        `No communicator registered for backend "${backendType}". Register one via registerCommunicator() at startup.`
       );
   }
 }
 
 // src/manager/agent-manager.ts
-var logger22 = createLogger23("agent-manager");
+var logger23 = createLogger24("agent-manager");
 var AgentManager = class {
   constructor(initializer, launcher, instancesBaseDir, options) {
     this.initializer = initializer;
@@ -3541,7 +3886,7 @@ var AgentManager = class {
         const dir = join17(this.instancesBaseDir, meta.name);
         const fixed = await updateInstanceMeta(dir, { status: "stopped", pid: void 0 });
         this.cache.set(meta.name, fixed);
-        logger22.info({ name: meta.name, oldStatus: meta.status, launchMode: meta.launchMode, recoveryAction: action.type }, "Stale status corrected");
+        logger23.info({ name: meta.name, oldStatus: meta.status, launchMode: meta.launchMode, recoveryAction: action.type }, "Stale status corrected");
         if (action.type === "restart") {
           pendingRestarts.push(meta.name);
         }
@@ -3553,7 +3898,7 @@ var AgentManager = class {
       await this.moveToCorrupted(name);
     }
     this.watcher.start();
-    logger22.info({
+    logger23.info({
       valid: valid.length,
       corrupted: corrupted.length,
       pendingRestarts: pendingRestarts.length
@@ -3561,9 +3906,9 @@ var AgentManager = class {
     for (const name of pendingRestarts) {
       try {
         await this.startAgent(name);
-        logger22.info({ name }, "Recovery restart succeeded");
+        logger23.info({ name }, "Recovery restart succeeded");
       } catch (err) {
-        logger22.error({ name, error: err }, "Recovery restart failed");
+        logger23.error({ name, error: err }, "Recovery restart failed");
       }
     }
   }
@@ -3613,14 +3958,19 @@ var AgentManager = class {
         pid = proc.pid;
       }
       if (this.acpManager) {
-        const { command, args } = resolveAcpBackend(meta.backendType, dir, meta.backendConfig);
+        const acpResolved = resolveAcpBackend(meta.backendType, dir, meta.backendConfig);
+        const providerEnv = buildProviderEnv(meta.providerConfig);
         const connResult = await this.acpManager.connect(name, {
-          command,
-          args,
+          command: acpResolved.command,
+          args: acpResolved.args,
           cwd: dir,
-          connectionOptions: { autoApprove: true }
+          resolvePackage: acpResolved.resolvePackage,
+          connectionOptions: {
+            autoApprove: true,
+            ...Object.keys(providerEnv).length > 0 ? { env: providerEnv } : {}
+          }
         });
-        logger22.info({ name, acpOnly }, "ACP connection established");
+        logger23.info({ name, acpOnly, providerType: meta.providerConfig?.type }, "ACP connection established");
         if (acpOnly && "pid" in connResult && typeof connResult.pid === "number") {
           pid = connResult.pid;
           this.processes.set(name, { pid, workspaceDir: dir, instanceName: name });
@@ -3632,7 +3982,7 @@ var AgentManager = class {
         this.watcher.watch(name, pid);
       }
       this.restartTracker.recordStart(name);
-      logger22.info({ name, pid, launchMode: starting.launchMode, acp: true }, "Agent started");
+      logger23.info({ name, pid, launchMode: starting.launchMode, acp: true }, "Agent started");
     } catch (err) {
       if (this.acpManager?.has(name)) {
         await this.acpManager.disconnect(name).catch(() => {
@@ -3640,7 +3990,11 @@ var AgentManager = class {
       }
       const errored = await updateInstanceMeta(dir, { status: "error" });
       this.cache.set(name, errored);
-      throw err;
+      if (err instanceof AgentLaunchError) throw err;
+      const spawnMsg = err instanceof Error ? err.message : String(err);
+      throw new AgentLaunchError(name, new Error(
+        isSpawnNotFound(spawnMsg) ? buildSpawnNotFoundMessage(meta.backendType) : spawnMsg
+      ));
     }
   }
   /**
@@ -3651,7 +4005,7 @@ var AgentManager = class {
     const meta = this.requireAgent(name);
     const dir = join17(this.instancesBaseDir, name);
     if (meta.status !== "running" && meta.status !== "starting") {
-      logger22.warn({ name, status: meta.status }, "Agent is not running, setting to stopped");
+      logger23.warn({ name, status: meta.status }, "Agent is not running, setting to stopped");
       const stopped2 = await updateInstanceMeta(dir, { status: "stopped", pid: void 0 });
       this.cache.set(name, stopped2);
       return;
@@ -3661,7 +4015,7 @@ var AgentManager = class {
     this.cache.set(name, stopping);
     if (this.acpManager?.has(name)) {
       await this.acpManager.disconnect(name).catch((err) => {
-        logger22.warn({ name, error: err }, "Error disconnecting ACP during stop");
+        logger23.warn({ name, error: err }, "Error disconnecting ACP during stop");
       });
     }
     const proc = this.processes.get(name);
@@ -3671,11 +4025,14 @@ var AgentManager = class {
     }
     const stopped = await updateInstanceMeta(dir, { status: "stopped", pid: void 0 });
     this.cache.set(name, stopped);
-    logger22.info({ name }, "Agent stopped");
+    logger23.info({ name }, "Agent stopped");
   }
   /** Destroy an agent — stop it if running, then remove workspace. */
   async destroyAgent(name) {
     const meta = this.cache.get(name);
+    if (!meta && !existsSync(join17(this.instancesBaseDir, name))) {
+      throw new AgentNotFoundError(name);
+    }
     if (meta && (meta.status === "running" || meta.status === "starting")) {
       await this.stopAgent(name);
     }
@@ -3684,7 +4041,7 @@ var AgentManager = class {
     await this.initializer.destroyInstance(name);
     this.cache.delete(name);
     this.processes.delete(name);
-    logger22.info({ name }, "Agent destroyed");
+    logger23.info({ name }, "Agent destroyed");
   }
   /** Get agent metadata by name. */
   getAgent(name) {
@@ -3717,14 +4074,15 @@ var AgentManager = class {
       throw new AgentNotFoundError(name);
     }
     const dir = join17(this.instancesBaseDir, name);
-    const { command, args } = resolveBackend(meta.backendType, dir, meta.backendConfig);
+    const resolved = resolveBackend(meta.backendType, dir, meta.backendConfig);
     return {
       workspaceDir: dir,
-      command,
-      args,
+      command: resolved.command,
+      args: resolved.args,
       instanceName: name,
       backendType: meta.backendType,
-      created
+      created,
+      resolvePackage: resolved.resolvePackage
     };
   }
   /**
@@ -3735,8 +4093,7 @@ var AgentManager = class {
   async openAgent(name) {
     const meta = this.requireAgent(name);
     const dir = join17(this.instancesBaseDir, name);
-    const resolved = openBackend(meta.backendType, dir);
-    return resolved;
+    return openBackend(meta.backendType, dir);
   }
   /**
    * Register an externally-spawned process with the manager.
@@ -3749,6 +4106,17 @@ var AgentManager = class {
     if (meta.status === "running" && meta.pid != null) {
       throw new AgentAlreadyAttachedError(name);
     }
+    try {
+      process.kill(pid, 0);
+    } catch (err) {
+      const code = err.code;
+      if (code === "ESRCH") {
+        throw new AgentLaunchError(
+          name,
+          new Error(`Process with PID ${pid} does not exist`)
+        );
+      }
+    }
     const dir = join17(this.instancesBaseDir, name);
     const mergedMetadata = attachMetadata ? { ...meta.metadata, ...attachMetadata } : meta.metadata;
     const updated = await updateInstanceMeta(dir, {
@@ -3760,7 +4128,7 @@ var AgentManager = class {
     this.cache.set(name, updated);
     this.processes.set(name, { pid, workspaceDir: dir, instanceName: name });
     this.watcher.watch(name, pid);
-    logger22.info({ name, pid }, "External process attached");
+    logger23.info({ name, pid }, "External process attached");
     return updated;
   }
   /**
@@ -3783,7 +4151,7 @@ var AgentManager = class {
       processOwnership: "managed"
     });
     this.cache.set(name, updated);
-    logger22.info({ name }, "External process detached");
+    logger23.info({ name }, "External process detached");
     let workspaceCleaned = false;
     if (options?.cleanup && meta.workspacePolicy === "ephemeral") {
       await this.destroyAgent(name);
@@ -3801,7 +4169,7 @@ var AgentManager = class {
       const conn = this.acpManager.getConnection(name);
       const sessionId = this.acpManager.getPrimarySessionId(name);
       if (conn && sessionId) {
-        logger22.debug({ name, sessionId }, "Sending prompt via ACP");
+        logger23.debug({ name, sessionId }, "Sending prompt via ACP");
         const result = await conn.prompt(sessionId, prompt);
         return { text: result.text, sessionId };
       }
@@ -3820,7 +4188,7 @@ var AgentManager = class {
       const conn = this.acpManager.getConnection(name);
       const sessionId = this.acpManager.getPrimarySessionId(name);
       if (conn && sessionId) {
-        logger22.debug({ name, sessionId }, "Streaming prompt via ACP");
+        logger23.debug({ name, sessionId }, "Streaming prompt via ACP");
         return this.streamFromAcp(conn, sessionId, prompt);
       }
     }
@@ -3892,7 +4260,7 @@ var AgentManager = class {
     }
     const handler = getLaunchModeHandler(meta.launchMode);
     const action = handler.getProcessExitAction(instanceName, meta);
-    logger22.warn({ instanceName, pid, launchMode: meta.launchMode, action: action.type, previousStatus: meta.status }, "Agent process exited unexpectedly");
+    logger23.warn({ instanceName, pid, launchMode: meta.launchMode, action: action.type, previousStatus: meta.status }, "Agent process exited unexpectedly");
     if (this.acpManager?.has(instanceName)) {
       await this.acpManager.disconnect(instanceName).catch(() => {
       });
@@ -3913,28 +4281,28 @@ var AgentManager = class {
         if (!decision.allowed) {
           const errored = await updateInstanceMeta(dir, { status: "error" });
           this.cache.set(instanceName, errored);
-          logger22.error({ instanceName, attempt: decision.attempt }, "Restart limit exceeded \u2014 marking as error");
+          logger23.error({ instanceName, attempt: decision.attempt }, "Restart limit exceeded \u2014 marking as error");
           break;
         }
-        logger22.info({ instanceName, attempt: decision.attempt, delayMs: decision.delayMs }, "Scheduling crash restart with backoff");
+        logger23.info({ instanceName, attempt: decision.attempt, delayMs: decision.delayMs }, "Scheduling crash restart with backoff");
         if (decision.delayMs > 0) {
           await delay(decision.delayMs);
         }
         this.restartTracker.recordRestart(instanceName);
         try {
           await this.startAgent(instanceName);
-          logger22.info({ instanceName, attempt: decision.attempt }, "Crash restart succeeded");
+          logger23.info({ instanceName, attempt: decision.attempt }, "Crash restart succeeded");
         } catch (err) {
-          logger22.error({ instanceName, attempt: decision.attempt, error: err }, "Crash restart failed");
+          logger23.error({ instanceName, attempt: decision.attempt, error: err }, "Crash restart failed");
         }
         break;
       }
       case "destroy":
         try {
           await this.destroyAgent(instanceName);
-          logger22.info({ instanceName }, "One-shot agent destroyed after exit");
+          logger23.info({ instanceName }, "One-shot agent destroyed after exit");
         } catch (err) {
-          logger22.error({ instanceName, error: err }, "One-shot auto-destroy failed");
+          logger23.error({ instanceName, error: err }, "One-shot auto-destroy failed");
         }
         break;
       case "mark-stopped":
@@ -3954,12 +4322,39 @@ var AgentManager = class {
       const src = join17(this.instancesBaseDir, name);
       const dest = join17(this.corruptedDir, `${name}-${Date.now()}`);
       await rename3(src, dest);
-      logger22.warn({ name, dest }, "Corrupted instance moved");
+      logger23.warn({ name, dest }, "Corrupted instance moved");
     } catch (err) {
-      logger22.error({ name, error: err }, "Failed to move corrupted instance");
+      logger23.error({ name, error: err }, "Failed to move corrupted instance");
     }
   }
 };
+function buildProviderEnv(providerConfig) {
+  const env = {};
+  const defaultDesc = modelProviderRegistry.getDefault();
+  const providerType = providerConfig?.type ?? defaultDesc?.type;
+  if (providerType) {
+    env["ACTANT_PROVIDER"] = providerType;
+  }
+  const descriptor = providerType ? modelProviderRegistry.get(providerType) : defaultDesc;
+  const apiKey = descriptor?.apiKey ?? process.env["ACTANT_API_KEY"];
+  if (apiKey) {
+    env["ACTANT_API_KEY"] = apiKey;
+  }
+  const baseUrl = providerConfig?.baseUrl ?? descriptor?.defaultBaseUrl;
+  if (baseUrl) {
+    env["ACTANT_BASE_URL"] = baseUrl;
+  }
+  return env;
+}
+function isSpawnNotFound(msg) {
+  return /ENOENT|EINVAL|is not recognized|not found/i.test(msg);
+}
+function buildSpawnNotFoundMessage(backendType) {
+  const hint = getInstallHint(backendType);
+  const base = `Backend "${backendType}" executable not found.`;
+  return hint ? `${base}
+Install with: ${hint}` : `${base} Ensure the required CLI is installed and in your PATH.`;
+}
 
 // src/manager/launcher/mock-launcher.ts
 var nextPid = 1e4;
@@ -3982,14 +4377,14 @@ var MockLauncher = class {
 
 // src/manager/launcher/process-launcher.ts
 import { spawn as spawn5 } from "child_process";
-import { AgentLaunchError, createLogger as createLogger25 } from "@actant/shared";
+import { AgentLaunchError as AgentLaunchError2, createLogger as createLogger26 } from "@actant/shared";
 
 // src/manager/launcher/process-log-writer.ts
 import { createWriteStream } from "fs";
 import { mkdir as mkdir12, rename as rename4, stat as stat7, readFile as readFile5 } from "fs/promises";
 import { join as join18 } from "path";
-import { createLogger as createLogger24 } from "@actant/shared";
-var logger23 = createLogger24("process-log-writer");
+import { createLogger as createLogger25 } from "@actant/shared";
+var logger24 = createLogger25("process-log-writer");
 var DEFAULT_MAX_SIZE_BYTES = 10 * 1024 * 1024;
 var DEFAULT_MAX_FILES = 3;
 var ProcessLogWriter = class {
@@ -4026,7 +4421,7 @@ var ProcessLogWriter = class {
     } catch {
       this.stderrBytes = 0;
     }
-    logger23.debug({ logsDir: this.logsDir }, "Log writer initialized");
+    logger24.debug({ logsDir: this.logsDir }, "Log writer initialized");
   }
   /**
    * Attach to readable streams from a spawned process.
@@ -4108,7 +4503,7 @@ var ProcessLogWriter = class {
       this.stderrStream = newStream;
       this.stderrBytes = 0;
     }
-    logger23.debug({ filename }, "Log file rotated");
+    logger24.debug({ filename }, "Log file rotated");
   }
   closeStream(stream) {
     if (!stream) return Promise.resolve();
@@ -4119,7 +4514,7 @@ var ProcessLogWriter = class {
 };
 
 // src/manager/launcher/process-launcher.ts
-var logger24 = createLogger25("process-launcher");
+var logger25 = createLogger26("process-launcher");
 var DEFAULT_TERMINATE_TIMEOUT = 5e3;
 var DEFAULT_SPAWN_VERIFY_DELAY = 500;
 var ProcessLauncher = class {
@@ -4141,7 +4536,7 @@ var ProcessLauncher = class {
       meta.backendConfig
     );
     const useAcp = isAcpBackend(meta.backendType);
-    logger24.info({ name: meta.name, command, args, backendType: meta.backendType, acp: useAcp }, "Spawning backend process");
+    logger25.info({ name: meta.name, command, args, backendType: meta.backendType, acp: useAcp }, "Spawning backend process");
     const captureNonAcpLogs = !useAcp && this.enableProcessLogs;
     let stdio;
     if (useAcp) {
@@ -4173,7 +4568,7 @@ var ProcessLauncher = class {
       }
     });
     if ("error" in spawnResult) {
-      throw new AgentLaunchError(meta.name, spawnResult.error);
+      throw new AgentLaunchError2(meta.name, spawnResult.error);
     }
     const pid = spawnResult.pid;
     if (!useAcp) {
@@ -4184,27 +4579,27 @@ var ProcessLauncher = class {
       earlyExit = true;
     });
     child.on("error", (err) => {
-      logger24.error({ name: meta.name, pid, error: err }, "Backend process error after spawn");
+      logger25.error({ name: meta.name, pid, error: err }, "Backend process error after spawn");
     });
     if (this.spawnVerifyDelayMs > 0) {
       await delay(this.spawnVerifyDelayMs);
       if (earlyExit || !isProcessAlive(pid)) {
-        throw new AgentLaunchError(
+        throw new AgentLaunchError2(
           meta.name,
           new Error(`Process exited immediately after spawn (pid=${pid}, command=${command})`)
         );
       }
     }
-    logger24.info({ name: meta.name, pid, command, acp: useAcp }, "Backend process spawned");
+    logger25.info({ name: meta.name, pid, command, acp: useAcp }, "Backend process spawned");
     if (captureNonAcpLogs && child.stdout && child.stderr) {
       const logWriter = new ProcessLogWriter(workspaceDir, this.logWriterOptions);
       try {
         await logWriter.initialize();
         logWriter.attach(child.stdout, child.stderr);
         this.logWriters.set(meta.name, logWriter);
-        logger24.debug({ name: meta.name }, "Process log capture enabled");
+        logger25.debug({ name: meta.name }, "Process log capture enabled");
       } catch (err) {
-        logger24.warn({ name: meta.name, error: err }, "Failed to initialize log writer, continuing without log capture");
+        logger25.warn({ name: meta.name, error: err }, "Failed to initialize log writer, continuing without log capture");
       }
     }
     const result = {
@@ -4233,27 +4628,27 @@ var ProcessLauncher = class {
       this.logWriters.delete(instanceName);
     }
     if (!isProcessAlive(pid)) {
-      logger24.info({ instanceName, pid }, "Process already exited");
+      logger25.info({ instanceName, pid }, "Process already exited");
       return;
     }
-    logger24.info({ instanceName, pid }, "Sending SIGTERM");
+    logger25.info({ instanceName, pid }, "Sending SIGTERM");
     sendSignal(pid, "SIGTERM");
     const deadline = Date.now() + this.terminateTimeoutMs;
     const pollInterval = 200;
     while (Date.now() < deadline) {
       await delay(pollInterval);
       if (!isProcessAlive(pid)) {
-        logger24.info({ instanceName, pid }, "Process terminated gracefully");
+        logger25.info({ instanceName, pid }, "Process terminated gracefully");
         return;
       }
     }
-    logger24.warn({ instanceName, pid }, "Process did not exit after SIGTERM, sending SIGKILL");
+    logger25.warn({ instanceName, pid }, "Process did not exit after SIGTERM, sending SIGKILL");
     sendSignal(pid, "SIGKILL");
     await delay(500);
     if (isProcessAlive(pid)) {
-      logger24.error({ instanceName, pid }, "Process still alive after SIGKILL");
+      logger25.error({ instanceName, pid }, "Process still alive after SIGKILL");
     } else {
-      logger24.info({ instanceName, pid }, "Process killed with SIGKILL");
+      logger25.info({ instanceName, pid }, "Process killed with SIGKILL");
     }
   }
 };
@@ -4270,12 +4665,15 @@ function createLauncher(config) {
 }
 
 // src/domain/skill/skill-manager.ts
-import { z as z4 } from "zod/v4";
-var SkillDefinitionSchema = z4.object({
-  name: z4.string().min(1),
-  description: z4.string().optional(),
-  content: z4.string().min(1),
-  tags: z4.array(z4.string()).optional()
+import { z as z5 } from "zod/v4";
+var SkillDefinitionSchema = z5.object({
+  name: z5.string().min(1),
+  description: z5.string().optional(),
+  content: z5.string().min(1),
+  tags: z5.array(z5.string()).optional(),
+  license: z5.string().optional(),
+  compatibility: z5.string().optional(),
+  allowedTools: z5.array(z5.string()).optional()
 }).passthrough();
 var SkillManager = class extends BaseComponentManager {
   componentType = "Skill";
@@ -4315,12 +4713,12 @@ ${sections.join("\n\n---\n\n")}
 };
 
 // src/domain/prompt/prompt-manager.ts
-import { z as z5 } from "zod/v4";
-var PromptDefinitionSchema = z5.object({
-  name: z5.string().min(1),
-  description: z5.string().optional(),
-  content: z5.string().min(1),
-  variables: z5.array(z5.string()).optional()
+import { z as z6 } from "zod/v4";
+var PromptDefinitionSchema = z6.object({
+  name: z6.string().min(1),
+  description: z6.string().optional(),
+  content: z6.string().min(1),
+  variables: z6.array(z6.string()).optional()
 }).passthrough();
 var PromptManager = class extends BaseComponentManager {
   componentType = "Prompt";
@@ -4372,13 +4770,13 @@ ${sections.join("\n\n---\n\n")}
 };
 
 // src/domain/mcp/mcp-config-manager.ts
-import { z as z6 } from "zod/v4";
-var McpServerDefinitionSchema = z6.object({
-  name: z6.string().min(1),
-  description: z6.string().optional(),
-  command: z6.string().min(1),
-  args: z6.array(z6.string()).optional(),
-  env: z6.record(z6.string(), z6.string()).optional()
+import { z as z7 } from "zod/v4";
+var McpServerDefinitionSchema = z7.object({
+  name: z7.string().min(1),
+  description: z7.string().optional(),
+  command: z7.string().min(1),
+  args: z7.array(z7.string()).optional(),
+  env: z7.record(z7.string(), z7.string()).optional()
 }).passthrough();
 var McpConfigManager = class extends BaseComponentManager {
   componentType = "McpServer";
@@ -4418,11 +4816,11 @@ var McpConfigManager = class extends BaseComponentManager {
 };
 
 // src/domain/workflow/workflow-manager.ts
-import { z as z7 } from "zod/v4";
-var WorkflowDefinitionSchema = z7.object({
-  name: z7.string().min(1),
-  description: z7.string().optional(),
-  content: z7.string().min(1)
+import { z as z8 } from "zod/v4";
+var WorkflowDefinitionSchema = z8.object({
+  name: z8.string().min(1),
+  description: z8.string().optional(),
+  content: z8.string().min(1)
 }).passthrough();
 var WorkflowManager = class extends BaseComponentManager {
   componentType = "Workflow";
@@ -4451,14 +4849,14 @@ var WorkflowManager = class extends BaseComponentManager {
 };
 
 // src/domain/plugin/plugin-manager.ts
-import { z as z8 } from "zod/v4";
-var PluginDefinitionSchema = z8.object({
-  name: z8.string().min(1),
-  description: z8.string().optional(),
-  type: z8.enum(["npm", "file", "config"]),
-  source: z8.string().optional(),
-  config: z8.record(z8.string(), z8.unknown()).optional(),
-  enabled: z8.boolean().optional().default(true)
+import { z as z9 } from "zod/v4";
+var PluginDefinitionSchema = z9.object({
+  name: z9.string().min(1),
+  description: z9.string().optional(),
+  type: z9.enum(["npm", "file", "config"]),
+  source: z9.string().optional(),
+  config: z9.record(z9.string(), z9.unknown()).optional(),
+  enabled: z9.boolean().optional().default(true)
 }).passthrough();
 var PluginManager = class extends BaseComponentManager {
   componentType = "Plugin";
@@ -4503,8 +4901,8 @@ var PluginManager = class extends BaseComponentManager {
 };
 
 // src/permissions/permission-policy-enforcer.ts
-import { createLogger as createLogger26 } from "@actant/shared";
-var logger25 = createLogger26("permission-policy-enforcer");
+import { createLogger as createLogger27 } from "@actant/shared";
+var logger26 = createLogger27("permission-policy-enforcer");
 var KIND_TO_TOOL = {
   read: "Read",
   edit: "Edit",
@@ -4521,7 +4919,7 @@ var PermissionPolicyEnforcer = class {
   }
   updateConfig(config) {
     this.config = { ...config };
-    logger25.info("Permission policy config updated");
+    logger26.info("Permission policy config updated");
   }
   getConfig() {
     return this.config;
@@ -4679,8 +5077,8 @@ function escapeRegex(str) {
 }
 
 // src/permissions/permission-audit.ts
-import { createLogger as createLogger27 } from "@actant/shared";
-var logger26 = createLogger27("permission-audit");
+import { createLogger as createLogger28 } from "@actant/shared";
+var logger27 = createLogger28("permission-audit");
 var PermissionAuditLogger = class {
   instanceName;
   constructor(instanceName) {
@@ -4693,7 +5091,7 @@ var PermissionAuditLogger = class {
       ...detail,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
-    logger26.info(entry, `[audit] ${event}`);
+    logger27.info(entry, `[audit] ${event}`);
   }
   logEvaluation(toolCall, decision) {
     this.log("permission.evaluated", { toolCall, decision });
@@ -4714,8 +5112,8 @@ var PermissionAuditLogger = class {
 
 // src/session/session-registry.ts
 import { randomUUID as randomUUID8 } from "crypto";
-import { createLogger as createLogger28 } from "@actant/shared";
-var logger27 = createLogger28("session-registry");
+import { createLogger as createLogger29 } from "@actant/shared";
+var logger28 = createLogger29("session-registry");
 var DEFAULT_IDLE_TTL_MS = 30 * 60 * 1e3;
 var TTL_CHECK_INTERVAL_MS = 60 * 1e3;
 var SessionRegistry = class {
@@ -4746,7 +5144,7 @@ var SessionRegistry = class {
       idleTtlMs: opts.idleTtlMs ?? this.defaultIdleTtlMs
     };
     this.sessions.set(session.sessionId, session);
-    logger27.info({ sessionId: session.sessionId, agentName: opts.agentName, clientId: opts.clientId }, "Session created");
+    logger28.info({ sessionId: session.sessionId, agentName: opts.agentName, clientId: opts.clientId }, "Session created");
     return session;
   }
   /** Get a session by ID, or undefined if not found. */
@@ -4778,7 +5176,7 @@ var SessionRegistry = class {
     session.clientId = null;
     session.state = "idle";
     session.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-    logger27.info({ sessionId, agentName: session.agentName }, "Session released to idle");
+    logger28.info({ sessionId, agentName: session.agentName }, "Session released to idle");
   }
   /**
    * Resume an idle session, binding it to a (potentially new) client.
@@ -4791,7 +5189,7 @@ var SessionRegistry = class {
     session.clientId = clientId;
     session.state = "active";
     session.lastActivityAt = (/* @__PURE__ */ new Date()).toISOString();
-    logger27.info({ sessionId, clientId, agentName: session.agentName }, "Session resumed");
+    logger28.info({ sessionId, clientId, agentName: session.agentName }, "Session resumed");
     return true;
   }
   /** Explicitly close and remove a session. */
@@ -4799,7 +5197,7 @@ var SessionRegistry = class {
     const session = this.sessions.get(sessionId);
     if (!session) return false;
     this.sessions.delete(sessionId);
-    logger27.info({ sessionId, agentName: session.agentName }, "Session closed");
+    logger28.info({ sessionId, agentName: session.agentName }, "Session closed");
     return true;
   }
   /** Close all sessions for a given agent. */
@@ -4812,7 +5210,7 @@ var SessionRegistry = class {
       }
     }
     if (count > 0) {
-      logger27.info({ agentName, count }, "Sessions closed for agent");
+      logger28.info({ agentName, count }, "Sessions closed for agent");
     }
     return count;
   }
@@ -4836,7 +5234,7 @@ var SessionRegistry = class {
       if (now - lastActivity > session.idleTtlMs) {
         session.state = "expired";
         this.sessions.delete(id);
-        logger27.info({ sessionId: id, agentName: session.agentName, idleMs: now - lastActivity }, "Session expired (TTL)");
+        logger28.info({ sessionId: id, agentName: session.agentName, idleMs: now - lastActivity }, "Session expired (TTL)");
         this.onExpireCallback?.(session);
       }
     }
@@ -4846,15 +5244,15 @@ var SessionRegistry = class {
 // src/source/github-source.ts
 import { join as join20 } from "path";
 import { mkdir as mkdir13, rm as rm5 } from "fs/promises";
-import { execFile } from "child_process";
+import { execFile as execFile2 } from "child_process";
 import { promisify } from "util";
-import { createLogger as createLogger30 } from "@actant/shared";
+import { createLogger as createLogger31 } from "@actant/shared";
 
 // src/source/local-source.ts
 import { readFile as readFile6, readdir as readdir5, stat as stat8 } from "fs/promises";
 import { join as join19, extname as extname3 } from "path";
-import { createLogger as createLogger29 } from "@actant/shared";
-var logger28 = createLogger29("local-source");
+import { createLogger as createLogger30 } from "@actant/shared";
+var logger29 = createLogger30("local-source");
 var LocalSource = class {
   type = "local";
   packageName;
@@ -4863,6 +5261,9 @@ var LocalSource = class {
     this.packageName = packageName;
     this.config = config;
   }
+  getRootDir() {
+    return this.config.path;
+  }
   async fetch() {
     return this.loadPackage();
   }
@@ -4874,16 +5275,17 @@ var LocalSource = class {
   async loadPackage() {
     const rootDir = this.config.path;
     const manifest = await this.loadManifest(rootDir);
-    const [skills, prompts, mcpServers, workflows, presets, templates] = await Promise.all([
+    const [skills, prompts, mcpServers, workflows, backends, presets, templates] = await Promise.all([
       this.loadJsonDir(rootDir, manifest.components?.skills, "skills"),
       this.loadJsonDir(rootDir, manifest.components?.prompts, "prompts"),
       this.loadJsonDir(rootDir, manifest.components?.mcp, "mcp"),
       this.loadJsonDir(rootDir, manifest.components?.workflows, "workflows"),
+      this.loadJsonDir(rootDir, manifest.components?.backends, "backends"),
       this.loadPresets(rootDir, manifest.presets),
       this.loadJsonDir(rootDir, manifest.components?.templates, "templates")
     ]);
-    logger28.info({ packageName: this.packageName, rootDir }, "Local package loaded");
-    return { manifest, skills, prompts, mcpServers, workflows, presets, templates };
+    logger29.info({ packageName: this.packageName, rootDir }, "Local package loaded");
+    return { manifest, skills, prompts, mcpServers, workflows, backends, presets, templates };
   }
   async loadManifest(rootDir) {
     const manifestPath = join19(rootDir, "actant.json");
@@ -4891,7 +5293,7 @@ var LocalSource = class {
       const raw = await readFile6(manifestPath, "utf-8");
       return JSON.parse(raw);
     } catch {
-      logger28.debug({ rootDir }, "No actant.json found, scanning directories");
+      logger29.debug({ rootDir }, "No actant.json found, scanning directories");
       return { name: this.packageName };
     }
   }
@@ -4903,7 +5305,7 @@ var LocalSource = class {
           const raw = await readFile6(join19(rootDir, relPath), "utf-8");
           items2.push(JSON.parse(raw));
         } catch (err) {
-          logger28.warn({ file: relPath, error: err }, `Failed to load from manifest, skipping`);
+          logger29.warn({ file: relPath, error: err }, `Failed to load from manifest, skipping`);
         }
       }
       return items2;
@@ -4926,7 +5328,7 @@ var LocalSource = class {
         const raw = await readFile6(fullPath, "utf-8");
         items.push(JSON.parse(raw));
       } catch (err) {
-        logger28.warn({ file, error: err }, `Failed to load ${subDir} file, skipping`);
+        logger29.warn({ file, error: err }, `Failed to load ${subDir} file, skipping`);
       }
     }
     for (const entry of entries) {
@@ -4951,7 +5353,7 @@ var LocalSource = class {
       }
     }
     if (subDir === "skills") {
-      const { parseSkillMd } = await import("./skill-md-parser-2HXC4AAW.js");
+      const { parseSkillMd } = await import("./skill-md-parser-HXLTZAUU.js");
       for (const entry of entries) {
         if (extname3(entry) === ".json") continue;
         const subDirPath = join19(dirPath, entry);
@@ -4975,8 +5377,8 @@ var LocalSource = class {
 };
 
 // src/source/github-source.ts
-var execFileAsync = promisify(execFile);
-var logger29 = createLogger30("github-source");
+var execFileAsync = promisify(execFile2);
+var logger30 = createLogger31("github-source");
 var GitHubSource = class {
   type = "github";
   packageName;
@@ -4987,6 +5389,9 @@ var GitHubSource = class {
     this.config = config;
     this.cacheDir = join20(cacheDir, packageName);
   }
+  getRootDir() {
+    return this.cacheDir;
+  }
   async fetch() {
     await this.clone();
     return this.readCached();
@@ -4995,21 +5400,21 @@ var GitHubSource = class {
     try {
       await this.pull();
     } catch {
-      logger29.info("Pull failed, re-cloning");
+      logger30.info("Pull failed, re-cloning");
       await this.clone();
     }
     return this.readCached();
   }
   async dispose() {
     await rm5(this.cacheDir, { recursive: true, force: true });
-    logger29.debug({ cacheDir: this.cacheDir }, "Cache cleaned");
+    logger30.debug({ cacheDir: this.cacheDir }, "Cache cleaned");
   }
   async clone() {
     await rm5(this.cacheDir, { recursive: true, force: true });
     await mkdir13(this.cacheDir, { recursive: true });
     const branch = this.config.branch ?? "main";
     const args = ["clone", "--depth", "1", "--branch", branch, this.config.url, this.cacheDir];
-    logger29.info({ url: this.config.url, branch }, "Cloning repository");
+    logger30.info({ url: this.config.url, branch }, "Cloning repository");
     await execFileAsync("git", args, { timeout: 6e4 });
   }
   async pull() {
@@ -5027,7 +5432,7 @@ var GitHubSource = class {
 // src/source/source-manager.ts
 import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir14 } from "fs/promises";
 import { join as join21 } from "path";
-import { createLogger as createLogger31 } from "@actant/shared";
+import { createLogger as createLogger32 } from "@actant/shared";
 
 // src/version/sync-report.ts
 function createEmptySyncReport() {
@@ -5052,7 +5457,7 @@ var DEFAULT_SOURCE_CONFIG = {
   url: "https://github.com/blackplume233/actant-hub.git",
   branch: "main"
 };
-var logger30 = createLogger31("source-manager");
+var logger31 = createLogger32("source-manager");
 var SourceManager = class {
   sources = /* @__PURE__ */ new Map();
   presets = /* @__PURE__ */ new Map();
@@ -5080,7 +5485,7 @@ var SourceManager = class {
     this.sources.set(name, source);
     this.injectComponents(name, result);
     await this.persistSources();
-    logger30.info({ name, type: config.type }, "Source added");
+    logger31.info({ name, type: config.type }, "Source added");
     return result;
   }
   async syncSource(name) {
@@ -5096,7 +5501,7 @@ var SourceManager = class {
     const newSnapshot = this.snapshotComponents(name);
     await this.persistSources();
     const report = this.buildSyncReport(oldSnapshot, newSnapshot);
-    logger30.info({ name, report }, "Source synced");
+    logger31.info({ name, report }, "Source synced");
     return { fetchResult: result, report };
   }
   async syncAll() {
@@ -5109,7 +5514,7 @@ var SourceManager = class {
         const { report } = await this.syncSourceWithReport(name);
         reports.push(report);
       } catch (err) {
-        logger30.warn({ name, error: err }, "Failed to sync source, skipping");
+        logger31.warn({ name, error: err }, "Failed to sync source, skipping");
       }
     }
     return { report: mergeSyncReports(reports) };
@@ -5122,7 +5527,7 @@ var SourceManager = class {
     await source.dispose();
     this.sources.delete(name);
     await this.persistSources();
-    logger30.info({ name }, "Source removed");
+    logger31.info({ name }, "Source removed");
     return true;
   }
   listSources() {
@@ -5135,6 +5540,10 @@ var SourceManager = class {
   hasSource(name) {
     return this.sources.has(name);
   }
+  /** Resolve a registered source name to its filesystem root directory. */
+  getSourceRootDir(name) {
+    return this.getSourceOrThrow(name).getRootDir();
+  }
   // ---------------------------------------------------------------------------
   // Preset operations
   // ---------------------------------------------------------------------------
@@ -5206,7 +5615,7 @@ var SourceManager = class {
       const data = JSON.parse(raw);
       entries = Object.entries(data.sources ?? {}).map(([name, config]) => ({ name, config }));
     } catch {
-      logger30.debug("No sources.json found, starting with empty sources");
+      logger31.debug("No sources.json found, starting with empty sources");
     }
     for (const entry of entries) {
       try {
@@ -5214,9 +5623,9 @@ var SourceManager = class {
         const result = await source.fetch();
         this.sources.set(entry.name, source);
         this.injectComponents(entry.name, result);
-        logger30.info({ name: entry.name }, "Source restored from config");
+        logger31.info({ name: entry.name }, "Source restored from config");
       } catch (err) {
-        logger30.warn({ name: entry.name, error: err }, "Failed to restore source, skipping");
+        logger31.warn({ name: entry.name, error: err }, "Failed to restore source, skipping");
       }
     }
     await this.ensureDefaultSource();
@@ -5230,9 +5639,9 @@ var SourceManager = class {
     if (this.sources.has(DEFAULT_SOURCE_NAME)) return;
     try {
       await this.addSource(DEFAULT_SOURCE_NAME, DEFAULT_SOURCE_CONFIG);
-      logger30.info("Default source registered: %s", DEFAULT_SOURCE_NAME);
+      logger31.info("Default source registered: %s", DEFAULT_SOURCE_NAME);
     } catch (err) {
-      logger30.debug({ error: err }, "Failed to register default source (offline?), skipping");
+      logger31.debug({ error: err }, "Failed to register default source (offline?), skipping");
     }
   }
   // ---------------------------------------------------------------------------
@@ -5262,22 +5671,40 @@ var SourceManager = class {
     for (const wf of result.workflows) {
       this.managers.workflowManager.register(ns(wf));
     }
+    if (this.managers.backendManager) {
+      for (const backend of result.backends) {
+        this.managers.backendManager.register(ns(backend));
+      }
+    }
     for (const preset of result.presets) {
       this.presets.set(`${packageName}@${preset.name}`, preset);
     }
     if (this.managers.templateRegistry && result.templates.length > 0) {
+      const nsRef = (ref) => ref.includes("@") ? ref : `${packageName}@${ref}`;
       for (const template of result.templates) {
-        const nsTemplate = { ...template, name: `${packageName}@${template.name}` };
+        const dc = template.domainContext;
+        const nsTemplate = {
+          ...template,
+          name: `${packageName}@${template.name}`,
+          domainContext: {
+            ...dc,
+            skills: dc.skills?.map(nsRef),
+            prompts: dc.prompts?.map(nsRef),
+            subAgents: dc.subAgents?.map(nsRef),
+            workflow: dc.workflow ? nsRef(dc.workflow) : dc.workflow
+          }
+        };
         this.managers.templateRegistry.register(nsTemplate);
       }
     }
-    logger30.debug(
+    logger31.debug(
       {
         packageName,
         skills: result.skills.length,
         prompts: result.prompts.length,
         mcp: result.mcpServers.length,
         workflows: result.workflows.length,
+        backends: result.backends.length,
         presets: result.presets.length,
         templates: result.templates.length
       },
@@ -5297,6 +5724,9 @@ var SourceManager = class {
     removeFrom(this.managers.promptManager);
     removeFrom(this.managers.mcpConfigManager);
     removeFrom(this.managers.workflowManager);
+    if (this.managers.backendManager) {
+      removeFrom(this.managers.backendManager);
+    }
     if (this.managers.templateRegistry) {
       for (const t of this.managers.templateRegistry.list()) {
         if (t.name.startsWith(prefix)) {
@@ -5404,6 +5834,705 @@ function isMajorVersionChange(oldVersion, newVersion) {
   if (oldMajor === void 0 || newMajor === void 0) return false;
   return newMajor !== oldMajor;
 }
+
+// src/source/source-validator.ts
+import { readFile as readFile8, readdir as readdir6, stat as stat9, access as access4 } from "fs/promises";
+import { join as join22, relative as relative2, extname as extname4 } from "path";
+
+// src/source/source-schemas.ts
+import { z as z10 } from "zod";
+var VersionedComponentFields = {
+  name: z10.string().min(1, "name is required"),
+  version: z10.string().optional(),
+  description: z10.string().optional(),
+  $type: z10.string().optional(),
+  $version: z10.number().optional(),
+  origin: z10.object({
+    type: z10.enum(["builtin", "source", "local"]),
+    sourceName: z10.string().optional(),
+    syncHash: z10.string().optional(),
+    syncedAt: z10.string().optional(),
+    modified: z10.boolean().optional()
+  }).optional(),
+  tags: z10.array(z10.string()).optional()
+};
+var PackageManifestSchema = z10.object({
+  name: z10.string().min(1, "name is required"),
+  version: z10.string().optional(),
+  description: z10.string().optional(),
+  components: z10.object({
+    skills: z10.array(z10.string()).optional(),
+    prompts: z10.array(z10.string()).optional(),
+    mcp: z10.array(z10.string()).optional(),
+    workflows: z10.array(z10.string()).optional(),
+    templates: z10.array(z10.string()).optional(),
+    backends: z10.array(z10.string()).optional()
+  }).optional(),
+  presets: z10.array(z10.string()).optional()
+});
+var SkillDefinitionSchema2 = z10.object({
+  ...VersionedComponentFields,
+  content: z10.string().min(1, "content is required"),
+  license: z10.string().optional(),
+  compatibility: z10.string().optional(),
+  allowedTools: z10.array(z10.string()).optional()
+});
+var PromptDefinitionSchema2 = z10.object({
+  ...VersionedComponentFields,
+  content: z10.string().min(1, "content is required"),
+  variables: z10.array(z10.string()).optional()
+});
+var McpServerDefinitionSchema2 = z10.object({
+  ...VersionedComponentFields,
+  command: z10.string().min(1, "command is required"),
+  args: z10.array(z10.string()).optional(),
+  env: z10.record(z10.string(), z10.string()).optional()
+});
+var WorkflowDefinitionSchema2 = z10.object({
+  ...VersionedComponentFields,
+  content: z10.string().min(1, "content is required")
+});
+var PlatformCommandSchema2 = z10.object({
+  win32: z10.string().min(1),
+  default: z10.string().min(1)
+});
+var SourceBackendDefinitionSchema = z10.object({
+  ...VersionedComponentFields,
+  supportedModes: z10.array(z10.enum(["resolve", "open", "acp"])).min(1),
+  resolveCommand: PlatformCommandSchema2.optional(),
+  openCommand: PlatformCommandSchema2.optional(),
+  acpCommand: PlatformCommandSchema2.optional(),
+  acpOwnsProcess: z10.boolean().optional(),
+  resolvePackage: z10.string().optional(),
+  openWorkspaceDir: z10.enum(["arg", "cwd"]).optional(),
+  openSpawnOptions: z10.object({
+    stdio: z10.enum(["inherit", "ignore"]).optional(),
+    detached: z10.boolean().optional(),
+    windowsHide: z10.boolean().optional(),
+    shell: z10.boolean().optional()
+  }).optional(),
+  existenceCheck: z10.object({
+    command: z10.string().min(1),
+    args: z10.array(z10.string()).optional(),
+    expectedExitCode: z10.number().int().optional(),
+    versionPattern: z10.string().optional()
+  }).optional(),
+  install: z10.array(z10.object({
+    type: z10.enum(["npm", "brew", "winget", "choco", "url", "manual"]),
+    package: z10.string().optional(),
+    platforms: z10.array(z10.string()).optional(),
+    label: z10.string().optional(),
+    instructions: z10.string().optional()
+  })).optional()
+});
+var PresetDefinitionSchema = z10.object({
+  name: z10.string().min(1, "name is required"),
+  version: z10.string().optional(),
+  description: z10.string().optional(),
+  skills: z10.array(z10.string()).optional(),
+  prompts: z10.array(z10.string()).optional(),
+  mcpServers: z10.array(z10.string()).optional(),
+  workflows: z10.array(z10.string()).optional(),
+  templates: z10.array(z10.string()).optional()
+});
+
+// src/source/source-validator.ts
+var COMPONENT_DIR_SCHEMAS = {
+  skills: SkillDefinitionSchema2,
+  prompts: PromptDefinitionSchema2,
+  mcp: McpServerDefinitionSchema2,
+  workflows: WorkflowDefinitionSchema2,
+  presets: PresetDefinitionSchema
+};
+var COMPONENT_DIRS = ["skills", "prompts", "mcp", "workflows", "templates", "presets"];
+var SourceValidator = class {
+  /**
+   * Validate all assets in a source directory.
+   * Returns a report with pass/warn/error counts and detailed issues.
+   */
+  async validate(rootDir, options) {
+    const issues = [];
+    let passCount = 0;
+    const validatedFiles = /* @__PURE__ */ new Set();
+    const compat = options?.compat;
+    const manifest = await this.validateManifest(rootDir, issues);
+    if (manifest) passCount++;
+    const componentNames = /* @__PURE__ */ new Map();
+    if (manifest) {
+      passCount += await this.validateExplicitFiles(rootDir, manifest, issues, componentNames, validatedFiles, compat);
+    }
+    passCount += await this.validateComponentDirs(rootDir, issues, componentNames, validatedFiles, compat);
+    await this.validatePresetReferences(rootDir, manifest, componentNames, issues);
+    const errorCount = issues.filter((i) => i.severity === "error").length;
+    const warnCount = issues.filter((i) => i.severity === "warning").length;
+    const valid = options?.strict ? errorCount === 0 && warnCount === 0 : errorCount === 0;
+    return {
+      valid,
+      sourceName: manifest?.name ?? "unknown",
+      rootDir,
+      summary: { pass: passCount, warn: warnCount, error: errorCount },
+      issues
+    };
+  }
+  // -------------------------------------------------------------------------
+  // Layer 1: Manifest validation
+  // -------------------------------------------------------------------------
+  async validateManifest(rootDir, issues) {
+    const manifestPath = join22(rootDir, "actant.json");
+    let raw;
+    try {
+      raw = await readFile8(manifestPath, "utf-8");
+    } catch {
+      issues.push({
+        severity: "error",
+        path: "actant.json",
+        message: "actant.json not found in source root",
+        code: "MANIFEST_MISSING"
+      });
+      return null;
+    }
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch (err) {
+      issues.push({
+        severity: "error",
+        path: "actant.json",
+        message: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+        code: "MANIFEST_INVALID_JSON"
+      });
+      return null;
+    }
+    const result = PackageManifestSchema.safeParse(data);
+    if (!result.success) {
+      for (const issue of result.error.issues) {
+        issues.push({
+          severity: "error",
+          path: "actant.json",
+          message: `${issue.path.join(".")}: ${issue.message}`,
+          code: "MANIFEST_SCHEMA"
+        });
+      }
+      return null;
+    }
+    const manifest = result.data;
+    await this.verifyManifestFileRefs(rootDir, manifest, issues);
+    return manifest;
+  }
+  async verifyManifestFileRefs(rootDir, manifest, issues) {
+    const allRefs = [];
+    if (manifest.components) {
+      for (const [type, files] of Object.entries(manifest.components)) {
+        if (files) {
+          for (const f of files) {
+            allRefs.push({ ref: f, section: `components.${type}` });
+          }
+        }
+      }
+    }
+    if (manifest.presets) {
+      for (const f of manifest.presets) {
+        allRefs.push({ ref: f, section: "presets" });
+      }
+    }
+    for (const { ref, section } of allRefs) {
+      const fullPath = join22(rootDir, ref);
+      try {
+        await access4(fullPath);
+      } catch {
+        issues.push({
+          severity: "error",
+          path: `actant.json`,
+          component: ref,
+          message: `File referenced in ${section} does not exist: ${ref}`,
+          code: "MANIFEST_FILE_MISSING"
+        });
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Layer 2a: Validate files explicitly listed in manifest
+  // -------------------------------------------------------------------------
+  async validateExplicitFiles(rootDir, manifest, issues, componentNames, validatedFiles, compat) {
+    let passCount = 0;
+    const components = manifest.components;
+    if (!components && !manifest.presets) return 0;
+    if (components) {
+      for (const [type, files] of Object.entries(components)) {
+        if (!files) continue;
+        for (const filePath of files) {
+          validatedFiles.add(filePath);
+          const ok = await this.validateSingleFile(rootDir, filePath, type, issues, componentNames);
+          if (ok) passCount++;
+        }
+      }
+    }
+    const presets = manifest.presets;
+    if (presets) {
+      for (const filePath of presets) {
+        validatedFiles.add(filePath);
+        const ok = await this.validateSingleFile(rootDir, filePath, "presets", issues, componentNames);
+        if (ok) passCount++;
+      }
+    }
+    void compat;
+    return passCount;
+  }
+  // -------------------------------------------------------------------------
+  // Layer 2b: Scan component directories
+  // -------------------------------------------------------------------------
+  async validateComponentDirs(rootDir, issues, componentNames, validatedFiles, compat) {
+    let passCount = 0;
+    for (const dir of COMPONENT_DIRS) {
+      const dirPath = join22(rootDir, dir);
+      try {
+        const dirStat = await stat9(dirPath);
+        if (!dirStat.isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      passCount += await this.scanDirectory(rootDir, dirPath, dir, issues, componentNames, validatedFiles, compat);
+    }
+    return passCount;
+  }
+  async scanDirectory(rootDir, dirPath, componentType, issues, componentNames, validatedFiles, compat) {
+    let passCount = 0;
+    const entries = await readdir6(dirPath);
+    for (const entry of entries) {
+      const fullPath = join22(dirPath, entry);
+      const relPath = relative2(rootDir, fullPath).replace(/\\/g, "/");
+      const entryStat = await stat9(fullPath).catch(() => null);
+      if (!entryStat) continue;
+      if (entryStat.isFile() && extname4(entry) === ".json") {
+        if (validatedFiles.has(relPath)) continue;
+        validatedFiles.add(relPath);
+        const ok = await this.validateSingleFile(rootDir, relPath, componentType, issues, componentNames);
+        if (ok) passCount++;
+      } else if (entryStat.isDirectory()) {
+        if (componentType === "skills") {
+          const skillMdPath = join22(fullPath, "SKILL.md");
+          try {
+            await access4(skillMdPath);
+            const skillRelPath = relative2(rootDir, skillMdPath).replace(/\\/g, "/");
+            if (!validatedFiles.has(skillRelPath)) {
+              validatedFiles.add(skillRelPath);
+              const ok = await this.validateSkillMd(rootDir, skillRelPath, issues, componentNames, entry, compat);
+              if (ok) passCount++;
+            }
+            if (compat === "agent-skills") {
+              await this.validateSkillDirConventions(rootDir, fullPath, entry, issues);
+            }
+          } catch {
+            const manifestJsonPath = join22(fullPath, "manifest.json");
+            try {
+              await access4(manifestJsonPath);
+              const mRelPath = relative2(rootDir, manifestJsonPath).replace(/\\/g, "/");
+              if (!validatedFiles.has(mRelPath)) {
+                validatedFiles.add(mRelPath);
+                const ok = await this.validateSingleFile(rootDir, mRelPath, componentType, issues, componentNames);
+                if (ok) passCount++;
+              }
+            } catch {
+            }
+          }
+        }
+      }
+    }
+    return passCount;
+  }
+  // -------------------------------------------------------------------------
+  // Single file validation
+  // -------------------------------------------------------------------------
+  async validateSingleFile(rootDir, relPath, componentType, issues, componentNames) {
+    const fullPath = join22(rootDir, relPath);
+    let raw;
+    try {
+      raw = await readFile8(fullPath, "utf-8");
+    } catch {
+      issues.push({
+        severity: "error",
+        path: relPath,
+        message: "Cannot read file",
+        code: "FILE_UNREADABLE"
+      });
+      return false;
+    }
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch (err) {
+      issues.push({
+        severity: "error",
+        path: relPath,
+        message: `Invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+        code: "INVALID_JSON"
+      });
+      return false;
+    }
+    if (componentType === "templates") {
+      return this.validateTemplateComponent(relPath, data, issues, componentNames);
+    }
+    const schema = COMPONENT_DIR_SCHEMAS[componentType];
+    if (!schema) return true;
+    const result = schema.safeParse(data);
+    if (!result.success) {
+      for (const issue of result.error.issues) {
+        issues.push({
+          severity: "error",
+          path: relPath,
+          component: data?.name,
+          message: `${issue.path.join(".")}: ${issue.message}`,
+          code: "COMPONENT_SCHEMA"
+        });
+      }
+      return false;
+    }
+    const parsed = result.data;
+    this.trackComponentName(componentNames, componentType, parsed.name);
+    if (!parsed.description) {
+      issues.push({
+        severity: "warning",
+        path: relPath,
+        component: parsed.name,
+        message: `Missing "description" field`,
+        code: "MISSING_DESCRIPTION"
+      });
+    }
+    return true;
+  }
+  validateTemplateComponent(relPath, data, issues, componentNames) {
+    const schemaResult = AgentTemplateSchema.safeParse(data);
+    if (!schemaResult.success) {
+      for (const issue of schemaResult.error.issues) {
+        issues.push({
+          severity: "error",
+          path: relPath,
+          component: data?.name,
+          message: `${issue.path.join(".")}: ${issue.message}`,
+          code: "TEMPLATE_SCHEMA"
+        });
+      }
+      return false;
+    }
+    const semanticResult = validateTemplate(data);
+    for (const w of semanticResult.warnings ?? []) {
+      issues.push({
+        severity: "warning",
+        path: relPath,
+        component: schemaResult.data.name,
+        message: w.message,
+        code: w.code ?? "TEMPLATE_SEMANTIC"
+      });
+    }
+    this.trackComponentName(componentNames, "templates", schemaResult.data.name);
+    return true;
+  }
+  // -------------------------------------------------------------------------
+  // SKILL.md validation
+  // -------------------------------------------------------------------------
+  async validateSkillMd(rootDir, relPath, issues, componentNames, parentDirName, compat) {
+    const fullPath = join22(rootDir, relPath);
+    let raw;
+    try {
+      raw = await readFile8(fullPath, "utf-8");
+    } catch {
+      issues.push({
+        severity: "error",
+        path: relPath,
+        message: "Cannot read SKILL.md file",
+        code: "FILE_UNREADABLE"
+      });
+      return false;
+    }
+    const skill = parseSkillMdContent(raw);
+    if (!skill) {
+      issues.push({
+        severity: "error",
+        path: relPath,
+        message: "Invalid SKILL.md: missing YAML frontmatter or required 'name' field",
+        code: "SKILL_MD_INVALID"
+      });
+      return false;
+    }
+    this.trackComponentName(componentNames, "skills", skill.name);
+    if (compat === "agent-skills") {
+      this.validateAgentSkillsCompat(skill, relPath, issues, parentDirName, raw);
+    } else {
+      if (!skill.description) {
+        issues.push({
+          severity: "warning",
+          path: relPath,
+          component: skill.name,
+          message: `Missing "description" in SKILL.md frontmatter`,
+          code: "SKILL_MD_MISSING_DESCRIPTION"
+        });
+      }
+    }
+    if (!skill.content || skill.content.trim().length === 0) {
+      issues.push({
+        severity: "warning",
+        path: relPath,
+        component: skill.name,
+        message: "SKILL.md has empty content body",
+        code: "SKILL_MD_EMPTY_CONTENT"
+      });
+    }
+    return true;
+  }
+  // -------------------------------------------------------------------------
+  // Agent Skills (agentskills.io) compatibility checks
+  // -------------------------------------------------------------------------
+  validateAgentSkillsCompat(skill, relPath, issues, parentDirName, raw) {
+    const name = skill.name;
+    const NAME_RE = /^[a-z][a-z0-9-]*$/;
+    if (name.length > 64) {
+      issues.push({
+        severity: "error",
+        path: relPath,
+        component: name,
+        message: `Name exceeds 64 characters (${name.length})`,
+        code: "AGENT_SKILLS_NAME_TOO_LONG"
+      });
+    } else if (!NAME_RE.test(name)) {
+      issues.push({
+        severity: "error",
+        path: relPath,
+        component: name,
+        message: `Name must contain only lowercase letters, numbers, and hyphens, starting with a letter`,
+        code: "AGENT_SKILLS_NAME_FORMAT"
+      });
+    } else {
+      if (name.endsWith("-")) {
+        issues.push({
+          severity: "error",
+          path: relPath,
+          component: name,
+          message: "Name must not end with a hyphen",
+          code: "AGENT_SKILLS_NAME_TRAILING_HYPHEN"
+        });
+      }
+      if (name.includes("--")) {
+        issues.push({
+          severity: "error",
+          path: relPath,
+          component: name,
+          message: "Name must not contain consecutive hyphens",
+          code: "AGENT_SKILLS_NAME_CONSECUTIVE_HYPHENS"
+        });
+      }
+    }
+    if (parentDirName && name !== parentDirName) {
+      issues.push({
+        severity: "error",
+        path: relPath,
+        component: name,
+        message: `Name "${name}" does not match parent directory "${parentDirName}"`,
+        code: "AGENT_SKILLS_NAME_DIR_MISMATCH"
+      });
+    }
+    if (!skill.description) {
+      issues.push({
+        severity: "error",
+        path: relPath,
+        component: name,
+        message: `Missing required "description" field (Agent Skills spec)`,
+        code: "AGENT_SKILLS_DESCRIPTION_REQUIRED"
+      });
+    } else if (skill.description.length > 1024) {
+      issues.push({
+        severity: "warning",
+        path: relPath,
+        component: name,
+        message: `Description exceeds 1024 characters (${skill.description.length})`,
+        code: "AGENT_SKILLS_DESCRIPTION_TOO_LONG"
+      });
+    }
+    if (skill.compatibility && skill.compatibility.length > 500) {
+      issues.push({
+        severity: "warning",
+        path: relPath,
+        component: name,
+        message: `Compatibility field exceeds 500 characters (${skill.compatibility.length})`,
+        code: "AGENT_SKILLS_COMPAT_TOO_LONG"
+      });
+    }
+    if (raw) {
+      const frontmatterEnd = raw.indexOf("---", 3);
+      if (frontmatterEnd !== -1) {
+        const body = raw.substring(frontmatterEnd + 3).trim();
+        const lineCount = body.split("\n").length;
+        if (lineCount > 500) {
+          issues.push({
+            severity: "warning",
+            path: relPath,
+            component: name,
+            message: `SKILL.md body has ${lineCount} lines; Agent Skills spec recommends < 500 lines`,
+            code: "AGENT_SKILLS_BODY_TOO_LONG"
+          });
+        }
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Agent Skills directory convention (scripts/, references/, assets/)
+  // -------------------------------------------------------------------------
+  async validateSkillDirConventions(rootDir, skillDir, skillName, issues) {
+    const KNOWN_DIRS = /* @__PURE__ */ new Set(["scripts", "references", "assets"]);
+    const KNOWN_FILES = /* @__PURE__ */ new Set(["SKILL.md", "LICENSE", "LICENSE.txt", "LICENSE.md"]);
+    let entries;
+    try {
+      entries = await readdir6(skillDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join22(skillDir, entry);
+      const relPath = relative2(rootDir, fullPath).replace(/\\/g, "/");
+      const entryStat = await stat9(fullPath).catch(() => null);
+      if (!entryStat) continue;
+      if (entryStat.isDirectory()) {
+        if (KNOWN_DIRS.has(entry)) {
+          issues.push({
+            severity: "info",
+            path: relPath,
+            component: skillName,
+            message: `Agent Skills convention: ${entry}/ directory detected`,
+            code: "AGENT_SKILLS_DIR_FOUND"
+          });
+        }
+      } else if (!KNOWN_FILES.has(entry)) {
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Layer 3: Cross-reference validation
+  // -------------------------------------------------------------------------
+  async validatePresetReferences(rootDir, manifest, componentNames, issues) {
+    const presetsDir = join22(rootDir, "presets");
+    const presetFiles = [];
+    if (manifest?.presets) {
+      for (const p of manifest.presets) {
+        presetFiles.push(p);
+      }
+    } else {
+      try {
+        const entries = await readdir6(presetsDir);
+        for (const e of entries) {
+          if (extname4(e) === ".json") {
+            presetFiles.push(`presets/${e}`);
+          }
+        }
+      } catch {
+        return;
+      }
+    }
+    for (const presetFile of presetFiles) {
+      const fullPath = join22(rootDir, presetFile);
+      let data;
+      try {
+        const raw = await readFile8(fullPath, "utf-8");
+        data = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      const presetName = data.name || presetFile;
+      const refMap = [
+        ["skills", "skills"],
+        ["prompts", "prompts"],
+        ["mcpServers", "mcp"],
+        ["workflows", "workflows"],
+        ["templates", "templates"]
+      ];
+      for (const [field, compType] of refMap) {
+        const refs = data[field];
+        if (!refs) continue;
+        const available = componentNames.get(compType) ?? /* @__PURE__ */ new Set();
+        for (const ref of refs) {
+          if (!available.has(ref)) {
+            issues.push({
+              severity: "warning",
+              path: presetFile,
+              component: presetName,
+              message: `Preset references ${compType} "${ref}" which was not found in this source`,
+              code: "PRESET_REF_MISSING"
+            });
+          }
+        }
+      }
+    }
+  }
+  // -------------------------------------------------------------------------
+  // Helpers
+  // -------------------------------------------------------------------------
+  trackComponentName(componentNames, type, name) {
+    let set = componentNames.get(type);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      componentNames.set(type, set);
+    }
+    set.add(name);
+  }
+};
+
+// src/provider/builtin-providers.ts
+var BUILTIN_PROVIDERS = [
+  {
+    type: "anthropic",
+    displayName: "Anthropic (Claude)",
+    protocol: "anthropic",
+    defaultBaseUrl: "https://api.anthropic.com",
+    models: ["claude-sonnet-4-20250514", "claude-opus-4-20250514"]
+  },
+  {
+    type: "openai",
+    displayName: "OpenAI",
+    protocol: "openai",
+    defaultBaseUrl: "https://api.openai.com/v1",
+    models: ["gpt-4o", "gpt-4o-mini", "o3-mini"]
+  },
+  {
+    type: "deepseek",
+    displayName: "DeepSeek",
+    protocol: "openai",
+    defaultBaseUrl: "https://api.deepseek.com/v1",
+    models: ["deepseek-chat", "deepseek-reasoner"]
+  },
+  {
+    type: "ollama",
+    displayName: "Ollama (Local)",
+    protocol: "openai",
+    defaultBaseUrl: "http://localhost:11434/v1"
+  },
+  {
+    type: "azure",
+    displayName: "Azure OpenAI",
+    protocol: "openai",
+    defaultBaseUrl: "https://<resource>.openai.azure.com"
+  },
+  {
+    type: "bedrock",
+    displayName: "AWS Bedrock",
+    protocol: "anthropic",
+    defaultBaseUrl: "https://bedrock-runtime.<region>.amazonaws.com"
+  },
+  {
+    type: "vertex",
+    displayName: "Google Vertex AI",
+    protocol: "anthropic",
+    defaultBaseUrl: "https://<region>-aiplatform.googleapis.com"
+  },
+  {
+    type: "custom",
+    displayName: "Custom",
+    protocol: "custom",
+    defaultBaseUrl: "http://localhost:8080"
+  }
+];
+function registerBuiltinProviders() {
+  for (const descriptor of BUILTIN_PROVIDERS) {
+    modelProviderRegistry.register(descriptor);
+  }
+}
 export {
   AgentBackendSchema,
   AgentInitializer,
@@ -5411,6 +6540,8 @@ export {
   AgentManager,
   AgentStatusSchema,
   AgentTemplateSchema,
+  BUILTIN_PROVIDERS,
+  BackendManager,
   BaseComponentManager,
   ClaudeCodeBuilder,
   ClaudeCodeCommunicator,
@@ -5447,6 +6578,7 @@ export {
   McpServerRefSchema,
   MkdirStep,
   MockLauncher,
+  ModelProviderRegistry,
   ModelProviderSchema,
   NpmInstallStep,
   PermissionAuditLogger,
@@ -5464,6 +6596,7 @@ export {
   SessionRegistry,
   SkillManager,
   SourceManager,
+  SourceValidator,
   StepRegistry,
   TaskDispatcher,
   TaskQueue,
@@ -5476,15 +6609,20 @@ export {
   createDefaultStepRegistry,
   createLauncher,
   getBackendDescriptor,
+  getBackendManager,
+  getInstallHint,
   getLaunchModeHandler,
   globMatch,
   isAcpBackend,
   isAcpOnlyBackend,
   isProcessAlive,
   metaFilePath,
+  modelProviderRegistry,
   openBackend,
   readInstanceMeta,
   registerBackend,
+  registerBackendDefinition,
+  registerBuiltinProviders,
   registerCommunicator,
   requireMode,
   resolveAcpBackend,