@actant/core 0.1.2 → 0.2.1

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";
@@ -1061,13 +1065,29 @@ var DomainContextSchema = z2.object({
   extensions: z2.record(z2.string(), z2.array(z2.unknown())).optional()
 });
 var AgentBackendSchema = z2.object({
-  type: z2.enum(["cursor", "claude-code", "custom"]),
+  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", "custom"]),
+  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()
@@ -1125,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(),
@@ -1253,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) => ({
@@ -1276,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);
@@ -1360,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 };
 }
@@ -1378,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;
@@ -1717,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, registry, options) {
+  constructor(templatesDir, registry3, options) {
     this.templatesDir = templatesDir;
-    this.registry = registry;
+    this.registry = registry3;
     this.debounceMs = options?.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   }
   watcher = null;
@@ -1740,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() {
@@ -1756,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;
@@ -1775,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)
     );
@@ -1793,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;
     }
@@ -1808,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");
     }
   }
 };
@@ -1824,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
@@ -1846,7 +1935,7 @@ var LaunchModeSchema = z3.enum([
 ]);
 var ProcessOwnershipSchema = z3.enum(["managed", "external"]);
 var WorkspacePolicySchema = z3.enum(["persistent", "ephemeral"]);
-var AgentBackendTypeSchema = z3.enum(["cursor", "claude-code", "custom"]);
+var AgentBackendTypeSchema = z3.enum(["cursor", "cursor-agent", "claude-code", "custom", "pi"]);
 var PermissionModeSchema2 = z3.enum([
   "default",
   "acceptEdits",
@@ -1871,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),
@@ -1878,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"),
@@ -1894,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);
@@ -1947,12 +2044,12 @@ async function updateInstanceMeta(workspaceDir, patch) {
   await writeInstanceMeta(workspaceDir, updated);
   return updated;
 }
-async function scanInstances(instancesBaseDir, registry) {
+async function scanInstances(instancesBaseDir, registry3) {
   const valid = [];
   const corrupted = [];
   const validNames = /* @__PURE__ */ new Set();
-  if (registry) {
-    for (const entry of registry.list()) {
+  if (registry3) {
+    for (const entry of registry3.list()) {
       if (entry.status === "orphaned") continue;
       try {
         const st = await stat5(entry.workspacePath);
@@ -1964,7 +2061,7 @@ async function scanInstances(instancesBaseDir, registry) {
         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);
       }
     }
@@ -1989,7 +2086,7 @@ async function scanInstances(instancesBaseDir, registry) {
       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);
     }
   }
@@ -2138,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(registry, options) {
-    this.registry = registry;
+  constructor(registry3, options) {
+    this.registry = registry3;
     this.stepTimeoutMs = options?.defaultStepTimeoutMs ?? DEFAULT_STEP_TIMEOUT_MS;
     this.totalTimeoutMs = options?.totalTimeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS;
     this.onProgress = options?.onProgress;
@@ -2173,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 };
       }
@@ -2192,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) {
@@ -2207,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) {
@@ -2240,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;
@@ -2248,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)"
         );
@@ -2260,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;
@@ -2273,6 +2370,9 @@ var AgentInitializer = class {
   }
   builder;
   pipeline;
+  get workspaceBuilder() {
+    return this.builder;
+  }
   /**
    * Create a new Agent Instance.
    * 1. Resolve template from registry
@@ -2299,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;
       }
     }
@@ -2330,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);
@@ -2343,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";
@@ -2353,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,
@@ -2367,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;
@@ -2392,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) {
@@ -2413,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)) {
@@ -2423,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);
@@ -2458,11 +2577,13 @@ 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",
   "claude-code": ".claude",
+  pi: ".pi",
   custom: ".cursor"
 };
 var ContextMaterializer = class {
@@ -2488,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;
@@ -2603,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);
@@ -2871,10 +2992,10 @@ var NpmInstallStep = class extends InitializerStepExecutor {
     return { valid: issues.length === 0, issues };
   }
   async execute(context, config) {
-    const { packageManager = "npm", cwd = ".", args = [], registry } = config;
+    const { packageManager = "npm", cwd = ".", args = [], registry: registry3 } = config;
     const workDir = join16(context.workspaceDir, cwd);
     const cmdArgs = ["install", ...args];
-    if (registry) cmdArgs.push("--registry", registry);
+    if (registry3) cmdArgs.push("--registry", registry3);
     context.logger.debug({ packageManager, cwd: workDir, args: cmdArgs }, "Installing dependencies");
     const result = await runInstall(packageManager, cmdArgs, workDir);
     if (result.exitCode !== 0) {
@@ -2916,56 +3037,151 @@ function runInstall(pm, args, cwd) {
 
 // src/initializer/steps/index.ts
 function createDefaultStepRegistry() {
-  const registry = new StepRegistry();
-  registry.register(new MkdirStep());
-  registry.register(new ExecStep());
-  registry.register(new FileCopyStep());
-  registry.register(new GitCloneStep());
-  registry.register(new NpmInstallStep());
-  return registry;
+  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;
 }
 
 // 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/manager/launcher/backend-resolver.ts
-var IS_WINDOWS = process.platform === "win32";
-var DEFAULT_COMMANDS = {
-  cursor: () => IS_WINDOWS ? "cursor.cmd" : "cursor",
-  "claude-code": () => IS_WINDOWS ? "claude-agent-acp.cmd" : "claude-agent-acp",
-  custom: () => {
-    throw new Error("Custom backend requires explicit executablePath in backend config");
+// src/manager/launcher/backend-registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerBackend(descriptor) {
+  registry.set(descriptor.type, descriptor);
+}
+function getBackendDescriptor(type) {
+  const desc = registry.get(type);
+  if (!desc) {
+    throw new Error(
+      `Backend "${type}" is not registered. Ensure the backend package is installed and registerBackend() was called at startup.`
+    );
   }
-};
+  return desc;
+}
+function supportsMode(type, mode) {
+  const desc = registry.get(type);
+  return desc != null && desc.supportedModes.includes(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.`)
+    );
+  }
+}
+function getPlatformCommand(cmd) {
+  return process.platform === "win32" ? cmd.win32 : cmd.default;
+}
+var installHints = /* @__PURE__ */ new Map([
+  ["claude-code", "npm install -g @zed-industries/claude-agent-acp"],
+  ["cursor", "Install Cursor from https://cursor.com"],
+  ["cursor-agent", "Install Cursor from https://cursor.com"]
+]);
+function getInstallHint(type) {
+  return installHints.get(type);
+}
+
+// src/manager/launcher/builtin-backends.ts
+function registerBuiltinBackends() {
+  registerBackend({
+    type: "cursor",
+    supportedModes: ["resolve", "open"],
+    resolveCommand: { win32: "cursor.cmd", default: "cursor" },
+    openCommand: { win32: "cursor.cmd", default: "cursor" }
+  });
+  registerBackend({
+    type: "cursor-agent",
+    supportedModes: ["resolve", "open", "acp"],
+    resolveCommand: { win32: "cursor.cmd", default: "cursor" },
+    openCommand: { win32: "cursor.cmd", default: "cursor" }
+  });
+  registerBackend({
+    type: "claude-code",
+    supportedModes: ["resolve", "open", "acp"],
+    resolveCommand: { win32: "claude-agent-acp.cmd", default: "claude-agent-acp" },
+    openCommand: { win32: "claude.cmd", default: "claude" }
+  });
+  registerBackend({
+    type: "custom",
+    supportedModes: ["resolve"]
+  });
+}
+registerBuiltinBackends();
+
+// src/manager/launcher/backend-resolver.ts
 function isAcpBackend(backendType) {
-  return backendType === "claude-code";
+  return supportsMode(backendType, "acp");
+}
+function isAcpOnlyBackend(backendType) {
+  const desc = getBackendDescriptor(backendType);
+  return supportsMode(backendType, "acp") && desc.acpOwnsProcess === true;
 }
 function buildArgs(backendType, workspaceDir, backendConfig) {
-  switch (backendType) {
-    case "cursor":
-      return [workspaceDir];
-    case "claude-code":
-      return [];
-    case "custom": {
-      const configArgs = backendConfig?.args;
-      if (Array.isArray(configArgs)) {
-        return configArgs.map(String);
-      }
-      return [workspaceDir];
-    }
+  const desc = getBackendDescriptor(backendType);
+  if (backendType === "custom") {
+    const configArgs = backendConfig?.args;
+    if (Array.isArray(configArgs)) return configArgs.map(String);
+    return [workspaceDir];
+  }
+  if (desc.supportedModes.includes("open") && !desc.supportedModes.includes("acp")) {
+    return [workspaceDir];
   }
+  if (desc.supportedModes.includes("acp")) {
+    return [];
+  }
+  return [workspaceDir];
 }
 function resolveBackend(backendType, workspaceDir, backendConfig) {
+  requireMode(backendType, "resolve");
+  const desc = getBackendDescriptor(backendType);
+  const explicitPath = backendConfig?.executablePath;
+  const command = typeof explicitPath === "string" && explicitPath.length > 0 ? explicitPath : desc.resolveCommand ? getPlatformCommand(desc.resolveCommand) : (() => {
+    throw new Error(`Backend "${backendType}" has no resolveCommand configured.`);
+  })();
+  return {
+    command,
+    args: buildArgs(backendType, workspaceDir, backendConfig)
+  };
+}
+function openBackend(backendType, workspaceDir) {
+  requireMode(backendType, "open");
+  const desc = getBackendDescriptor(backendType);
+  if (!desc.openCommand) {
+    throw new Error(`Backend "${backendType}" has no openCommand configured.`);
+  }
+  return {
+    command: getPlatformCommand(desc.openCommand),
+    args: [workspaceDir]
+  };
+}
+function resolveAcpBackend(backendType, workspaceDir, backendConfig) {
+  requireMode(backendType, "acp");
+  const desc = getBackendDescriptor(backendType);
+  if (desc.acpResolver) {
+    return desc.acpResolver(workspaceDir, backendConfig);
+  }
   const explicitPath = backendConfig?.executablePath;
-  const command = typeof explicitPath === "string" && explicitPath.length > 0 ? explicitPath : DEFAULT_COMMANDS[backendType]();
+  const commandSource = desc.acpCommand ?? desc.resolveCommand;
+  const command = typeof explicitPath === "string" && explicitPath.length > 0 ? explicitPath : commandSource ? getPlatformCommand(commandSource) : (() => {
+    throw new Error(`Backend "${backendType}" has no command configured for ACP spawn.`);
+  })();
   return {
     command,
     args: buildArgs(backendType, workspaceDir, backendConfig)
@@ -2973,7 +3189,7 @@ function resolveBackend(backendType, workspaceDir, backendConfig) {
 }
 
 // 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) {
@@ -3009,7 +3225,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) {
@@ -3022,12 +3238,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;
   }
@@ -3042,13 +3258,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() {
@@ -3070,11 +3286,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 {
@@ -3084,8 +3300,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) {
@@ -3107,11 +3323,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" };
   }
 };
@@ -3138,8 +3354,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,
@@ -3157,12 +3373,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(
@@ -3175,7 +3391,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);
@@ -3202,8 +3418,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;
@@ -3212,7 +3428,7 @@ 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,
@@ -3235,7 +3451,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;
         }
@@ -3245,7 +3461,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) {
@@ -3269,7 +3485,7 @@ 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"],
@@ -3366,11 +3582,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."
     );
@@ -3384,21 +3600,32 @@ var CursorCommunicator = class {
 };
 
 // src/communicator/create-communicator.ts
-function createCommunicator(backendType) {
+var registry2 = /* @__PURE__ */ new Map();
+function registerCommunicator(backendType, factory) {
+  registry2.set(backendType, factory);
+}
+function createCommunicator(backendType, backendConfig) {
+  const registered = registry2.get(backendType);
+  if (registered) return registered(backendConfig);
   switch (backendType) {
     case "claude-code":
       return new ClaudeCodeCommunicator();
     case "cursor":
+    case "cursor-agent":
       return new CursorCommunicator();
     case "custom":
       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."
+      );
   }
 }
 
 // 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;
@@ -3439,7 +3666,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);
         }
@@ -3451,7 +3678,7 @@ var AgentManager = class {
       await this.moveToCorrupted(name);
     }
     this.watcher.start();
-    logger22.info({
+    logger23.info({
       valid: valid.length,
       corrupted: corrupted.length,
       pendingRestarts: pendingRestarts.length
@@ -3459,9 +3686,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");
       }
     }
   }
@@ -3486,13 +3713,16 @@ var AgentManager = class {
     return { meta, created };
   }
   /**
-   * Start an agent — launch the backend process.
-   * For ACP backends, also establishes ACP connection (initialize + session/new).
+   * Start an agent — launch the backend process via ACP.
+   * Requires the backend to support "acp" mode.
+   * For acpOwnsProcess backends, ProcessLauncher is skipped.
    * @throws {AgentNotFoundError} if agent is not in cache
    * @throws {AgentAlreadyRunningError} if agent is already running
+   * @throws {Error} if backend does not support "acp" mode
    */
   async startAgent(name) {
     const meta = this.requireAgent(name);
+    requireMode(meta.backendType, "acp");
     if (meta.status === "running" || meta.status === "starting") {
       throw new AgentAlreadyRunningError(name);
     }
@@ -3500,23 +3730,38 @@ var AgentManager = class {
     const starting = await updateInstanceMeta(dir, { status: "starting" });
     this.cache.set(name, starting);
     try {
-      const proc = await this.launcher.launch(dir, starting);
-      this.processes.set(name, proc);
-      if (isAcpBackend(meta.backendType) && this.acpManager) {
-        const { command, args } = resolveBackend(meta.backendType, dir, meta.backendConfig);
-        await this.acpManager.connect(name, {
+      const acpOnly = isAcpOnlyBackend(meta.backendType);
+      let pid;
+      if (!acpOnly) {
+        const proc = await this.launcher.launch(dir, starting);
+        this.processes.set(name, proc);
+        pid = proc.pid;
+      }
+      if (this.acpManager) {
+        const { command, args } = resolveAcpBackend(meta.backendType, dir, meta.backendConfig);
+        const providerEnv = buildProviderEnv(meta.providerConfig);
+        const connResult = await this.acpManager.connect(name, {
           command,
           args,
           cwd: dir,
-          connectionOptions: { autoApprove: true }
+          connectionOptions: {
+            autoApprove: true,
+            ...Object.keys(providerEnv).length > 0 ? { env: providerEnv } : {}
+          }
         });
-        logger22.info({ name }, "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 });
+        }
       }
-      const running = await updateInstanceMeta(dir, { status: "running", pid: proc.pid });
+      const running = await updateInstanceMeta(dir, { status: "running", pid });
       this.cache.set(name, running);
-      this.watcher.watch(name, proc.pid);
+      if (pid) {
+        this.watcher.watch(name, pid);
+      }
       this.restartTracker.recordStart(name);
-      logger22.info({ name, pid: proc.pid, launchMode: starting.launchMode, acp: isAcpBackend(meta.backendType) }, "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(() => {
@@ -3524,7 +3769,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
+      ));
     }
   }
   /**
@@ -3535,7 +3784,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;
@@ -3545,7 +3794,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);
@@ -3555,11 +3804,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);
     }
@@ -3568,7 +3820,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) {
@@ -3611,6 +3863,17 @@ var AgentManager = class {
       created
     };
   }
+  /**
+   * Open an agent's native TUI/UI (e.g. `cursor <dir>`).
+   * Requires the backend to support "open" mode.
+   * @throws if backend does not support "open" mode
+   */
+  async openAgent(name) {
+    const meta = this.requireAgent(name);
+    const dir = join17(this.instancesBaseDir, name);
+    const resolved = openBackend(meta.backendType, dir);
+    return resolved;
+  }
   /**
    * Register an externally-spawned process with the manager.
    * Sets processOwnership to "external" and registers ProcessWatcher monitoring.
@@ -3622,6 +3885,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, {
@@ -3633,7 +3907,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;
   }
   /**
@@ -3656,7 +3930,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);
@@ -3674,7 +3948,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 };
       }
@@ -3685,14 +3959,46 @@ var AgentManager = class {
   }
   /**
    * Send a prompt to an agent and stream the response.
-   * Uses ACP connection if available, otherwise falls back to CLI pipe mode.
+   * Uses ACP connection if available, otherwise falls back to communicator.
    */
   streamPrompt(name, prompt, options) {
     const meta = this.requireAgent(name);
+    if (this.acpManager?.has(name)) {
+      const conn = this.acpManager.getConnection(name);
+      const sessionId = this.acpManager.getPrimarySessionId(name);
+      if (conn && sessionId) {
+        logger23.debug({ name, sessionId }, "Streaming prompt via ACP");
+        return this.streamFromAcp(conn, sessionId, prompt);
+      }
+    }
     const dir = join17(this.instancesBaseDir, name);
     const communicator = createCommunicator(meta.backendType);
     return communicator.streamPrompt(dir, prompt, options);
   }
+  async *streamFromAcp(conn, sessionId, prompt) {
+    try {
+      for await (const event of conn.streamPrompt(sessionId, prompt)) {
+        const record = event;
+        const type = record["type"];
+        if (type === "text" || type === "assistant") {
+          const content = record["content"] ?? record["message"] ?? "";
+          yield { type: "text", content };
+        } else if (type === "tool_use") {
+          const toolName = record["name"];
+          yield { type: "tool_use", content: toolName ? `[Tool: ${toolName}]` : "" };
+        } else if (type === "result") {
+          yield { type: "result", content: record["result"] ?? "" };
+        } else if (type === "error") {
+          const errMsg = record["error"]?.["message"];
+          yield { type: "error", content: errMsg ?? "Unknown error" };
+        } else if (typeof record["content"] === "string") {
+          yield { type: "text", content: record["content"] };
+        }
+      }
+    } catch (err) {
+      yield { type: "error", content: err instanceof Error ? err.message : String(err) };
+    }
+  }
   /**
    * Send a message to a running agent via its ACP session.
    * Unlike runPrompt, this requires the agent to be started with ACP.
@@ -3733,7 +4039,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(() => {
       });
@@ -3754,28 +4060,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":
@@ -3795,12 +4101,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;
@@ -3823,14 +4156,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 {
@@ -3867,7 +4200,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.
@@ -3949,7 +4282,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();
@@ -3960,7 +4293,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 {
@@ -3982,7 +4315,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) {
@@ -4014,7 +4347,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) {
@@ -4025,27 +4358,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 = {
@@ -4074,27 +4407,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");
     }
   }
 };
@@ -4116,7 +4449,10 @@ var SkillDefinitionSchema = z4.object({
   name: z4.string().min(1),
   description: z4.string().optional(),
   content: z4.string().min(1),
-  tags: z4.array(z4.string()).optional()
+  tags: z4.array(z4.string()).optional(),
+  license: z4.string().optional(),
+  compatibility: z4.string().optional(),
+  allowedTools: z4.array(z4.string()).optional()
 }).passthrough();
 var SkillManager = class extends BaseComponentManager {
   componentType = "Skill";
@@ -4344,8 +4680,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",
@@ -4362,7 +4698,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;
@@ -4520,8 +4856,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) {
@@ -4534,7 +4870,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 });
@@ -4555,8 +4891,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 {
@@ -4587,7 +4923,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. */
@@ -4619,7 +4955,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.
@@ -4632,7 +4968,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. */
@@ -4640,7 +4976,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. */
@@ -4653,7 +4989,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;
   }
@@ -4677,7 +5013,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);
       }
     }
@@ -4689,13 +5025,13 @@ import { join as join20 } from "path";
 import { mkdir as mkdir13, rm as rm5 } from "fs/promises";
 import { execFile } 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;
@@ -4704,6 +5040,9 @@ var LocalSource = class {
     this.packageName = packageName;
     this.config = config;
   }
+  getRootDir() {
+    return this.config.path;
+  }
   async fetch() {
     return this.loadPackage();
   }
@@ -4723,7 +5062,7 @@ var LocalSource = class {
       this.loadPresets(rootDir, manifest.presets),
       this.loadJsonDir(rootDir, manifest.components?.templates, "templates")
     ]);
-    logger28.info({ packageName: this.packageName, rootDir }, "Local package loaded");
+    logger29.info({ packageName: this.packageName, rootDir }, "Local package loaded");
     return { manifest, skills, prompts, mcpServers, workflows, presets, templates };
   }
   async loadManifest(rootDir) {
@@ -4732,7 +5071,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 };
     }
   }
@@ -4744,7 +5083,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;
@@ -4767,7 +5106,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) {
@@ -4792,7 +5131,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);
@@ -4817,7 +5156,7 @@ var LocalSource = class {
 
 // src/source/github-source.ts
 var execFileAsync = promisify(execFile);
-var logger29 = createLogger30("github-source");
+var logger30 = createLogger31("github-source");
 var GitHubSource = class {
   type = "github";
   packageName;
@@ -4828,6 +5167,9 @@ var GitHubSource = class {
     this.config = config;
     this.cacheDir = join20(cacheDir, packageName);
   }
+  getRootDir() {
+    return this.cacheDir;
+  }
   async fetch() {
     await this.clone();
     return this.readCached();
@@ -4836,21 +5178,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() {
@@ -4868,7 +5210,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() {
@@ -4893,7 +5235,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();
@@ -4901,11 +5243,13 @@ var SourceManager = class {
   homeDir;
   sourcesFilePath;
   cacheDir;
-  constructor(homeDir, managers) {
+  skipDefaultSource;
+  constructor(homeDir, managers, options) {
     this.homeDir = homeDir;
     this.managers = managers;
     this.sourcesFilePath = join21(homeDir, "sources.json");
     this.cacheDir = join21(homeDir, "sources-cache");
+    this.skipDefaultSource = options?.skipDefaultSource ?? false;
   }
   // ---------------------------------------------------------------------------
   // Source CRUD
@@ -4919,7 +5263,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) {
@@ -4935,7 +5279,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() {
@@ -4948,7 +5292,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) };
@@ -4961,7 +5305,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() {
@@ -4974,6 +5318,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
   // ---------------------------------------------------------------------------
@@ -5039,14 +5387,13 @@ var SourceManager = class {
   // Initialization (load persisted sources on startup)
   // ---------------------------------------------------------------------------
   async initialize() {
-    let entries;
+    let entries = [];
     try {
       const raw = await readFile7(this.sourcesFilePath, "utf-8");
       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");
-      return;
+      logger31.debug("No sources.json found, starting with empty sources");
     }
     for (const entry of entries) {
       try {
@@ -5054,11 +5401,26 @@ 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();
+  }
+  /**
+   * Registers the official actant-hub as the default source if not already present.
+   * Fails silently when offline or the repo is unreachable.
+   */
+  async ensureDefaultSource() {
+    if (this.skipDefaultSource) return;
+    if (this.sources.has(DEFAULT_SOURCE_NAME)) return;
+    try {
+      await this.addSource(DEFAULT_SOURCE_NAME, DEFAULT_SOURCE_CONFIG);
+      logger31.info("Default source registered: %s", DEFAULT_SOURCE_NAME);
+    } catch (err) {
+      logger31.debug({ error: err }, "Failed to register default source (offline?), skipping");
+    }
   }
   // ---------------------------------------------------------------------------
   // Internals
@@ -5091,12 +5453,24 @@ var SourceManager = class {
       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,
@@ -5229,6 +5603,671 @@ 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 z9 } from "zod";
+var VersionedComponentFields = {
+  name: z9.string().min(1, "name is required"),
+  version: z9.string().optional(),
+  description: z9.string().optional(),
+  $type: z9.string().optional(),
+  $version: z9.number().optional(),
+  origin: z9.object({
+    type: z9.enum(["builtin", "source", "local"]),
+    sourceName: z9.string().optional(),
+    syncHash: z9.string().optional(),
+    syncedAt: z9.string().optional(),
+    modified: z9.boolean().optional()
+  }).optional(),
+  tags: z9.array(z9.string()).optional()
+};
+var PackageManifestSchema = z9.object({
+  name: z9.string().min(1, "name is required"),
+  version: z9.string().optional(),
+  description: z9.string().optional(),
+  components: z9.object({
+    skills: z9.array(z9.string()).optional(),
+    prompts: z9.array(z9.string()).optional(),
+    mcp: z9.array(z9.string()).optional(),
+    workflows: z9.array(z9.string()).optional(),
+    templates: z9.array(z9.string()).optional()
+  }).optional(),
+  presets: z9.array(z9.string()).optional()
+});
+var SkillDefinitionSchema2 = z9.object({
+  ...VersionedComponentFields,
+  content: z9.string().min(1, "content is required"),
+  license: z9.string().optional(),
+  compatibility: z9.string().optional(),
+  allowedTools: z9.array(z9.string()).optional()
+});
+var PromptDefinitionSchema2 = z9.object({
+  ...VersionedComponentFields,
+  content: z9.string().min(1, "content is required"),
+  variables: z9.array(z9.string()).optional()
+});
+var McpServerDefinitionSchema2 = z9.object({
+  ...VersionedComponentFields,
+  command: z9.string().min(1, "command is required"),
+  args: z9.array(z9.string()).optional(),
+  env: z9.record(z9.string(), z9.string()).optional()
+});
+var WorkflowDefinitionSchema2 = z9.object({
+  ...VersionedComponentFields,
+  content: z9.string().min(1, "content is required")
+});
+var PresetDefinitionSchema = z9.object({
+  name: z9.string().min(1, "name is required"),
+  version: z9.string().optional(),
+  description: z9.string().optional(),
+  skills: z9.array(z9.string()).optional(),
+  prompts: z9.array(z9.string()).optional(),
+  mcpServers: z9.array(z9.string()).optional(),
+  workflows: z9.array(z9.string()).optional(),
+  templates: z9.array(z9.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,
@@ -5236,6 +6275,7 @@ export {
   AgentManager,
   AgentStatusSchema,
   AgentTemplateSchema,
+  BUILTIN_PROVIDERS,
   BaseComponentManager,
   ClaudeCodeBuilder,
   ClaudeCodeCommunicator,
@@ -5272,6 +6312,7 @@ export {
   McpServerRefSchema,
   MkdirStep,
   MockLauncher,
+  ModelProviderRegistry,
   ModelProviderSchema,
   NpmInstallStep,
   PermissionAuditLogger,
@@ -5289,6 +6330,7 @@ export {
   SessionRegistry,
   SkillManager,
   SourceManager,
+  SourceValidator,
   StepRegistry,
   TaskDispatcher,
   TaskQueue,
@@ -5300,16 +6342,26 @@ export {
   createCommunicator,
   createDefaultStepRegistry,
   createLauncher,
+  getBackendDescriptor,
   getLaunchModeHandler,
   globMatch,
   isAcpBackend,
+  isAcpOnlyBackend,
   isProcessAlive,
   metaFilePath,
+  modelProviderRegistry,
+  openBackend,
   readInstanceMeta,
+  registerBackend,
+  registerBuiltinProviders,
+  registerCommunicator,
+  requireMode,
+  resolveAcpBackend,
   resolveBackend,
   resolvePermissions,
   resolvePermissionsWithMcp,
   scanInstances,
+  supportsMode,
   toAgentTemplate,
   updateInstanceMeta,
   validateBackendConfig,