@webpresso/agent-kit 0.25.0 → 0.26.0

package/.claude-plugin/marketplace.json

@@ -6,7 +6,7 @@
   },
   "metadata": {
     "description": "Webpresso agent-kit Claude Code plugin: blueprints, skills, hooks, MCP server",
-    "version": "0.25.0"
+    "version": "0.26.0"
   },
   "plugins": [
     {
@@ -23,5 +23,5 @@
       ]
     }
   ],
-  "version": "0.25.0"
+  "version": "0.26.0"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "webpresso",
-  "version": "0.25.0",
+  "version": "0.26.0",
   "description": "Webpresso agent-kit: blueprints, skills, lore commit protocol, tech-debt lifecycle",
   "skills": "./skills",
   "commands": "./commands",

package/dist/esm/audit/toolchain-isolation.d.ts

@@ -0,0 +1,3 @@
+import type { RepoAuditResult } from './repo-guardrails.js';
+export declare function auditToolchainIsolation(root: string): RepoAuditResult;
+//# sourceMappingURL=toolchain-isolation.d.ts.map

package/dist/esm/audit/toolchain-isolation.js

@@ -0,0 +1,134 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+const FORBIDDEN_DEPENDENCY_PATTERNS = [
+    /^typescript$/u,
+    /^vite$/u,
+    /^vitest$/u,
+    /^@stryker-mutator\//u,
+    /^@playwright\/test$/u,
+    /^wrangler$/u,
+    /^oxlint$/u,
+    /^oxfmt$/u,
+    /^tsx$/u,
+];
+const FORBIDDEN_SCRIPT_PATTERNS = [
+    /(^|\s)(tsc|vite|vitest|stryker|playwright|wrangler|oxlint|oxfmt|tsx)(\s|$)/u,
+    /node\s+\.\/node_modules\/(typescript|vite|vitest|wrangler|oxlint|tsx)\//u,
+];
+const ALLOWED_SCRIPT_PREFIXES = ['wp ', 'vp run ', 'vp run -r '];
+export function auditToolchainIsolation(root) {
+    const packagePaths = findPackageJsonFiles(root);
+    const violations = [];
+    for (const packagePath of packagePaths) {
+        const pkg = readPackageJson(packagePath);
+        if (!pkg) {
+            violations.push({ file: packagePath, message: 'package.json must be valid JSON' });
+            continue;
+        }
+        if (isExemptPackage(root, packagePath, pkg))
+            continue;
+        for (const field of [
+            'dependencies',
+            'devDependencies',
+            'optionalDependencies',
+            'peerDependencies',
+        ]) {
+            for (const depName of Object.keys(pkg[field] ?? {})) {
+                if (!isForbiddenDependency(depName))
+                    continue;
+                violations.push({
+                    file: packagePath,
+                    message: `${field}.${depName} is toolchain-owned; route it through @webpresso/agent-kit/wp instead of declaring it directly`,
+                });
+            }
+        }
+        for (const [scriptName, scriptValue] of Object.entries(pkg.scripts ?? {})) {
+            if (typeof scriptValue !== 'string')
+                continue;
+            if (isAllowedScript(scriptValue))
+                continue;
+            if (!FORBIDDEN_SCRIPT_PATTERNS.some((pattern) => pattern.test(scriptValue)))
+                continue;
+            violations.push({
+                file: packagePath,
+                message: `script "${scriptName}" invokes a toolchain binary directly; use wp-managed commands instead`,
+            });
+        }
+    }
+    return {
+        ok: violations.length === 0,
+        title: 'Toolchain isolation',
+        checked: packagePaths.length,
+        violations,
+    };
+}
+function isExemptPackage(root, packagePath, pkg) {
+    if (pkg.name === '@webpresso/agent-kit')
+        return true;
+    const relativePath = path.relative(root, packagePath).split(path.sep).join('/');
+    // Catalog skill templates are sample project manifests shipped by agent-kit,
+    // not live consumer package manifests. They intentionally demonstrate raw
+    // framework CLIs in generated starter content and should not make agent-kit's
+    // own audit fail.
+    const unpackedPath = relativePath.replace(/^\.webpresso-packed-surface\//u, '');
+    if (unpackedPath.startsWith('catalog/') && unpackedPath.includes('/templates/'))
+        return true;
+    return false;
+}
+function findPackageJsonFiles(root) {
+    const files = [];
+    walk(root, files);
+    return files.sort();
+}
+function walk(dir, files) {
+    for (const entry of safeReadDir(dir)) {
+        const absolute = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!shouldSkipDirectory(entry.name))
+                walk(absolute, files);
+            continue;
+        }
+        if (entry.isFile() && entry.name === 'package.json')
+            files.push(absolute);
+    }
+}
+function safeReadDir(dir) {
+    try {
+        return existsSync(dir) ? readdirSync(dir, { withFileTypes: true }) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function shouldSkipDirectory(name) {
+    return [
+        '.git',
+        'node_modules',
+        'dist',
+        'build',
+        '.turbo',
+        '.next',
+        '.wrangler',
+        '.agent',
+        '.agents',
+        '.omx',
+        '.omc',
+        '.codex',
+    ].includes(name);
+}
+function readPackageJson(file) {
+    try {
+        return JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function isForbiddenDependency(depName) {
+    return FORBIDDEN_DEPENDENCY_PATTERNS.some((pattern) => pattern.test(depName));
+}
+function isAllowedScript(script) {
+    const trimmed = script.trim();
+    return ALLOWED_SCRIPT_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
+}
+//# sourceMappingURL=toolchain-isolation.js.map

package/dist/esm/cli/cli.d.ts

@@ -5,7 +5,7 @@
  * Lazy-loads subcommand modules based on the first argv to keep startup
  * cheap. Modeled on apps/cli-wp/src/cli.ts.
  */
-declare const SUPPORTED_COMMANDS: readonly ["blueprint", "config", "roadmap", "sync", "audit", "compile", "rule", "skill", "skills", "docs", "setup", "init", "dev", "doctor", "err", "test", "e2e", "ci", "typecheck", "lint", "format", "tech-debt", "worktree", "mcp", "hook", "hooks", "gain", "bench", "install", "add", "remove", "update", "exec", "run"];
+declare const SUPPORTED_COMMANDS: readonly ["blueprint", "config", "roadmap", "sync", "audit", "compile", "rule", "skill", "skills", "docs", "setup", "init", "dev", "deploy", "doctor", "err", "test", "e2e", "ci", "typecheck", "lint", "format", "tech-debt", "worktree", "mcp", "hook", "hooks", "gain", "bench", "install", "add", "remove", "update", "exec", "run"];
 export { SUPPORTED_COMMANDS };
 export declare function main(): Promise<number>;
 //# sourceMappingURL=cli.d.ts.map

package/dist/esm/cli/cli.js

@@ -27,6 +27,7 @@ const SUPPORTED_COMMANDS = [
     'setup',
     'init',
     'dev',
+    'deploy',
     'doctor',
     'err',
     'test',
@@ -209,6 +210,11 @@ export async function main() {
             registerDevCommand(cli);
             break;
         }
+        case 'deploy': {
+            const { registerDeployCommand } = await import('./commands/deploy.js');
+            registerDeployCommand(cli);
+            break;
+        }
         case 'doctor': {
             const { registerDoctorCommand } = await import('./commands/doctor.js');
             registerDoctorCommand(cli);

package/dist/esm/cli/commands/audit-core.d.ts

@@ -1,5 +1,5 @@
 import type { RepoAuditResult } from '#audit/repo-guardrails';
-export type AuditKind = 'tph' | 'tph-e2e' | 'bundle-budget' | 'commit-message' | 'blueprint-lifecycle' | 'roadmap-links' | 'docs-frontmatter' | 'catalog-drift' | 'package-surface' | 'agents' | 'tech-debt' | 'no-relative-parent-imports' | 'no-link-protocol' | 'vision' | 'bucket-boundary' | 'skill-sizes' | 'broken-refs' | 'memory-rotation' | 'gitignore-agent-surfaces' | 'memory-unified' | 'compile-drift' | 'architecture-drift' | 'cloudflare-deploy-contract' | 'absolute-path-policy' | 'agent-cost' | 'blueprint-db-consistency' | 'blueprint-lifecycle-sql' | 'tech-debt-cadence' | 'cross-repo-correlation' | 'ai-contracts' | 'mutation' | 'quality' | 'guardrails' | 'hook-surface' | 'no-relative-package-scripts';
+export type AuditKind = 'tph' | 'tph-e2e' | 'bundle-budget' | 'commit-message' | 'blueprint-lifecycle' | 'roadmap-links' | 'docs-frontmatter' | 'catalog-drift' | 'package-surface' | 'agents' | 'tech-debt' | 'no-relative-parent-imports' | 'no-link-protocol' | 'vision' | 'bucket-boundary' | 'skill-sizes' | 'broken-refs' | 'memory-rotation' | 'gitignore-agent-surfaces' | 'memory-unified' | 'compile-drift' | 'architecture-drift' | 'cloudflare-deploy-contract' | 'toolchain-isolation' | 'absolute-path-policy' | 'agent-cost' | 'blueprint-db-consistency' | 'blueprint-lifecycle-sql' | 'tech-debt-cadence' | 'cross-repo-correlation' | 'ai-contracts' | 'mutation' | 'quality' | 'guardrails' | 'hook-surface' | 'no-relative-package-scripts';
 export type AuditOutcome = {
     kind: 'invalid-usage';
     message: string;

package/dist/esm/cli/commands/audit.js

@@ -59,6 +59,7 @@ const REPO_AUDIT_REGISTRY = {
     'no-legacy-cli-bin': async (root) => (await import('#audit/no-legacy-cli-bin')).auditNoLegacyCliBin(root),
     'architecture-drift': async (root) => (await import('#audit/architecture-drift')).auditArchitectureDrift(root),
     'cloudflare-deploy-contract': async (root) => (await import('#audit/cloudflare-deploy-contract')).auditCloudflareDeployContract(root),
+    'toolchain-isolation': async (root) => (await import('#audit/toolchain-isolation')).auditToolchainIsolation(root),
     'absolute-path-policy': async (root) => (await import('#audit/absolute-path-policy')).auditAbsolutePathPolicy(root),
     'agent-cost': async (root) => (await import('#audit/agent-cost')).auditAgentCost(root),
     'blueprint-db-consistency': async (root) => (await import('#audit/blueprint-db-consistency')).auditBlueprintDbConsistency(root),

package/dist/esm/cli/commands/deploy.d.ts

@@ -0,0 +1,4 @@
+import type { CAC } from 'cac';
+export declare const DEPLOY_COMMAND_HELP: string;
+export declare function registerDeployCommand(cli: CAC): void;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/esm/cli/commands/deploy.js

@@ -0,0 +1,35 @@
+import { runDeployPlan } from '#deploy/run.js';
+export const DEPLOY_COMMAND_HELP = [
+    'Run a consumer-owned deploy adapter through the managed wp deploy surface.',
+    '',
+    'Examples:',
+    '  wp deploy --lane prd --dry-run',
+    '  wp deploy --lane preview_pr_123 --plan-json',
+].join('\n');
+export function registerDeployCommand(cli) {
+    cli
+        .command('deploy', DEPLOY_COMMAND_HELP)
+        .option('--lane <lane>', 'Deploy lane: dev, preview_main, preview_pr_<n>, or prd')
+        .option('--dry-run', 'Ask the adapter for its dry-run deploy plan')
+        .option('--plan-json', 'Print the validated deploy plan JSON without executing steps')
+        .action(async (options) => {
+        const lane = typeof options.lane === 'string' ? options.lane : undefined;
+        if (!lane) {
+            console.error('Usage: wp deploy --lane <dev|preview_main|preview_pr_<n>|prd>');
+            return 1;
+        }
+        try {
+            return await runDeployPlan({
+                cwd: process.cwd(),
+                lane,
+                dryRun: Boolean(options.dryRun),
+                planJson: Boolean(options.planJson),
+            });
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            return 1;
+        }
+    });
+}
+//# sourceMappingURL=deploy.js.map

package/dist/esm/cli/commands/init/gitignore-patcher.d.ts

@@ -3,7 +3,24 @@ export interface GitignoreBlock {
     id: string;
     patterns: readonly string[];
 }
+export type GeneratedIndexCleanupResult = {
+    kind: 'skipped-dry-run';
+    pathspecs: readonly string[];
+} | {
+    kind: 'skipped-not-git';
+    pathspecs: readonly string[];
+} | {
+    kind: 'ok';
+    pathspecs: readonly string[];
+    removedPaths: readonly string[];
+} | {
+    kind: 'failed';
+    pathspecs: readonly string[];
+    exitCode: number | null;
+    stderr: string;
+};
 /** Canonical gitignore block for webpresso generated/transient paths. */
 export declare const GENERATED_PATHS_BLOCK: GitignoreBlock;
+export declare function untrackGeneratedGitignoredPaths(repoRoot: string, block?: GitignoreBlock, opts?: Pick<MergeOptions, 'dryRun'>): GeneratedIndexCleanupResult;
 export declare function patchGitignore(targetPath: string, block: GitignoreBlock, opts?: MergeOptions): MergeResult;
 //# sourceMappingURL=gitignore-patcher.d.ts.map

package/dist/esm/cli/commands/init/gitignore-patcher.js

@@ -11,6 +11,7 @@
  * drift). Other content in `.gitignore` — including unrelated managed blocks
  * from other scaffolders — is preserved verbatim.
  */
+import { spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 const BEGIN = (id) => `# >>> managed by webpresso (${id})`;
@@ -55,6 +56,7 @@ export const GENERATED_PATHS_BLOCK = {
         '.opencode/',
         '.codex/',
         '.claude/settings.json',
+        '.claude/settings.local.json',
         '.claude/agents/',
         '.claude/hooks/',
         '.claude/rules/',
@@ -77,6 +79,46 @@ export const GENERATED_PATHS_BLOCK = {
         '.agent/.tail-hint-history.jsonl',
     ],
 };
+function generatedPathspecs(block) {
+    return block.patterns
+        .map((pattern) => pattern.trim())
+        .filter((pattern) => pattern.length > 0)
+        .filter((pattern) => !pattern.startsWith('#'))
+        .filter((pattern) => !pattern.startsWith('!'));
+}
+function parseGitRmStdout(stdout) {
+    return stdout
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('rm '))
+        .map((line) => line.replace(/^rm ['"]?/, '').replace(/['"]?$/, ''));
+}
+export function untrackGeneratedGitignoredPaths(repoRoot, block = GENERATED_PATHS_BLOCK, opts = {}) {
+    const pathspecs = generatedPathspecs(block);
+    if (opts.dryRun)
+        return { kind: 'skipped-dry-run', pathspecs };
+    if (pathspecs.length === 0)
+        return { kind: 'ok', pathspecs, removedPaths: [] };
+    const gitProbe = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+    });
+    if (gitProbe.status !== 0)
+        return { kind: 'skipped-not-git', pathspecs };
+    const gitRm = spawnSync('git', ['rm', '--cached', '-r', '--ignore-unmatch', '--', ...pathspecs], {
+        cwd: repoRoot,
+        encoding: 'utf8',
+    });
+    if (gitRm.status !== 0) {
+        return {
+            kind: 'failed',
+            pathspecs,
+            exitCode: gitRm.status,
+            stderr: String(gitRm.stderr ?? '').trim(),
+        };
+    }
+    return { kind: 'ok', pathspecs, removedPaths: parseGitRmStdout(String(gitRm.stdout ?? '')) };
+}
 export function patchGitignore(targetPath, block, opts = {}) {
     const exists = existsSync(targetPath);
     const original = exists ? readFileSync(targetPath, 'utf8') : '';

package/dist/esm/cli/commands/init/index.js

@@ -22,7 +22,7 @@ import { scaffoldAgent, RENDERED_SKILLS, TIER1_SKILLS, TIER2_SKILLS } from './sc
 import { scaffoldAgentRules } from './scaffold-agent-rules.js';
 import { scaffoldAgentSkills } from './scaffold-agent-skills.js';
 import { scaffoldCatalogIgnore } from './scaffold-catalog-ignore.js';
-import { GENERATED_PATHS_BLOCK, patchGitignore } from './gitignore-patcher.js';
+import { GENERATED_PATHS_BLOCK, patchGitignore, untrackGeneratedGitignoredPaths, } from './gitignore-patcher.js';
 import { scaffoldAgentsMd } from './scaffold-agents-md.js';
 import { scaffoldBlueprints } from './scaffold-blueprints.js';
 import { scaffoldDocs } from './scaffold-docs.js';
@@ -244,6 +244,7 @@ export async function runInit(flags) {
             overwrite: options.overwrite,
         });
         const generatedSurfaceIgnoreResult = patchGitignore(join(consumer.repoRoot, '.gitignore'), GENERATED_PATHS_BLOCK, { dryRun: options.dryRun, overwrite: true });
+        const generatedIndexCleanupResult = untrackGeneratedGitignoredPaths(consumer.repoRoot, GENERATED_PATHS_BLOCK, { dryRun: options.dryRun });
         const baseKitResults = tier3Selection.includes('base-kit')
             ? scaffoldBaseKit({
                 catalogDir,
@@ -669,6 +670,15 @@ export async function runInit(flags) {
         console.log(`  drifted:         ${summary.drifted}`);
         if (options.dryRun)
             console.log(`  would-change:    ${summary['skipped-dry']}`);
+        if (generatedIndexCleanupResult.kind === 'ok') {
+            console.log(`  git index cleanup: ${generatedIndexCleanupResult.removedPaths.length} untracked`);
+        }
+        else if (generatedIndexCleanupResult.kind === 'failed') {
+            console.warn(`  git index cleanup: failed (git rm --cached exited ${generatedIndexCleanupResult.exitCode})`);
+            if (generatedIndexCleanupResult.stderr.length > 0) {
+                console.warn(`  git index cleanup stderr: ${generatedIndexCleanupResult.stderr}`);
+            }
+        }
         if (tier3Selection.includes('base-kit')) {
             const qualityTargets = new Set(BASE_KIT_QUALITY_TARGETS);
             const qualityResults = baseKitResults.filter((result) => qualityTargets.has(relative(consumer.repoRoot, result.targetPath).replaceAll('\\', '/')));

package/dist/esm/cli/commands/init/scaffold-base-kit.js

@@ -138,7 +138,7 @@ function mergePackageJson(repoRoot, options, globalInstall = false) {
     const devDeps = (pkg['devDependencies'] ?? {});
     const hasAgentKitDevDep = typeof devDeps['@webpresso/agent-kit'] === 'string';
     const hasLegacyAgentKitDevDep = typeof devDeps['webpresso'] === 'string';
-    const shouldSkipSelfInstall = packageName === '@webpresso/agent-kit' || packageName === 'webpresso';
+    const shouldSkipSelfInstall = isSelfPackageName(packageName);
     const shouldManageAgentKitAsGlobal = globalInstall && !shouldSkipSelfInstall;
     const requiredAuthoringDeps = {
         '@playwright/test': 'latest',
@@ -236,10 +236,35 @@ function mergePackageJson(repoRoot, options, globalInstall = false) {
     writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
     return { targetPath: pkgPath, action: 'overwritten' };
 }
+/** agent-kit's own package identities: scoped canonical + legacy unscoped. */
+const SELF_PACKAGE_NAMES = ['@webpresso/agent-kit', 'webpresso'];
+/** True when `name` is one of agent-kit's own package identities. */
+function isSelfPackageName(name) {
+    return name !== undefined && SELF_PACKAGE_NAMES.includes(name);
+}
+/**
+ * True when `repoRoot` is agent-kit's own source repo (by package.json name).
+ * agent-kit dogfoods base-kit's scripts and shared templates, but the QUALITY
+ * starter samples (quality-sample.ts, e2e/smoke, sample configs) are teaching
+ * artifacts for FRESH consumer repos — scaffolding them into agent-kit's own
+ * source tree is pollution. This flag skips ONLY those samples.
+ */
+function isAgentKitSelfRepo(repoRoot) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(repoRoot, 'package.json'), 'utf8'));
+        return isSelfPackageName(pkg.name);
+    }
+    catch {
+        return false;
+    }
+}
 export function scaffoldBaseKit(input) {
     const { catalogDir, repoRoot, options, globalInstall = false } = input;
     const baseKitDir = join(catalogDir, 'base-kit');
     const results = [];
+    // Dogfooding boundary: agent-kit gets base-kit's scripts/templates but not the
+    // starter quality samples scaffolded into its own source tree.
+    const skipStarterSamples = isAgentKitSelfRepo(repoRoot);
     for (const [tmplRel, targetRel] of TEMPLATE_MAP) {
         const tmplPath = join(baseKitDir, tmplRel);
         if (!existsSync(tmplPath))
@@ -269,23 +294,25 @@ export function scaffoldBaseKit(input) {
         writeFileSync(targetPath, content);
         results.push({ targetPath, action: 'created' });
     }
-    for (const [tmplRel, targetRel] of QUALITY_BOOTSTRAP_ONLY_MAP) {
-        const tmplPath = join(baseKitDir, tmplRel);
-        if (!existsSync(tmplPath))
-            continue;
-        const targetPath = join(repoRoot, targetRel);
-        if (existsSync(targetPath)) {
-            results.push({ targetPath, action: 'identical' });
-            continue;
-        }
-        const content = readFileSync(tmplPath, 'utf8');
-        if (options.dryRun) {
-            results.push({ targetPath, action: 'skipped-dry' });
-            continue;
+    if (!skipStarterSamples) {
+        for (const [tmplRel, targetRel] of QUALITY_BOOTSTRAP_ONLY_MAP) {
+            const tmplPath = join(baseKitDir, tmplRel);
+            if (!existsSync(tmplPath))
+                continue;
+            const targetPath = join(repoRoot, targetRel);
+            if (existsSync(targetPath)) {
+                results.push({ targetPath, action: 'identical' });
+                continue;
+            }
+            const content = readFileSync(tmplPath, 'utf8');
+            if (options.dryRun) {
+                results.push({ targetPath, action: 'skipped-dry' });
+                continue;
+            }
+            mkdirSync(dirname(targetPath), { recursive: true });
+            writeFileSync(targetPath, content);
+            results.push({ targetPath, action: 'created' });
         }
-        mkdirSync(dirname(targetPath), { recursive: true });
-        writeFileSync(targetPath, content);
-        results.push({ targetPath, action: 'created' });
     }
     // Make husky hook files executable
     if (!options.dryRun) {

package/dist/esm/deploy/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './schema.js';
+export * from './load-adapter.js';
+export * from './run.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/deploy/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './schema.js';
+export * from './load-adapter.js';
+export * from './run.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/deploy/load-adapter.d.ts

@@ -0,0 +1,6 @@
+import type { LoadedDeployAdapter } from './types.js';
+export declare class DeployAdapterConfigError extends Error {
+    constructor(message: string);
+}
+export declare function loadDeployAdapter(cwd?: string): Promise<LoadedDeployAdapter | null>;
+//# sourceMappingURL=load-adapter.d.ts.map

package/dist/esm/deploy/load-adapter.js

@@ -0,0 +1,57 @@
+import { dirname, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { loadWebpressoConfigSafe } from '#e2e/load-host-adapter';
+const DEFAULT_DEPLOY_ADAPTER_EXPORTS = [
+    'webpressoDeployAdapter',
+    'deployAdapter',
+    'default',
+];
+export class DeployAdapterConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DeployAdapterConfigError';
+    }
+}
+export async function loadDeployAdapter(cwd = process.cwd()) {
+    const loadedConfig = await loadWebpressoConfigSafe({ cwd });
+    const deployConfig = loadedConfig?.config.deploy;
+    if (!loadedConfig || !deployConfig?.adapterModule)
+        return null;
+    const moduleSpecifier = resolveModuleSpecifier(deployConfig.adapterModule, loadedConfig.configPath);
+    let moduleNamespace;
+    try {
+        moduleNamespace = (await import(moduleSpecifier));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new DeployAdapterConfigError(`Failed to load deploy adapter module "${deployConfig.adapterModule}" from ${loadedConfig.configPath}: ${message}`);
+    }
+    const exportNames = deployConfig.adapterExport
+        ? [deployConfig.adapterExport, ...DEFAULT_DEPLOY_ADAPTER_EXPORTS]
+        : [...DEFAULT_DEPLOY_ADAPTER_EXPORTS];
+    for (const exportName of exportNames) {
+        const candidate = moduleNamespace[exportName];
+        if (isDeployAdapter(candidate)) {
+            return {
+                adapter: candidate,
+                config: loadedConfig.config,
+                configPath: loadedConfig.configPath,
+                moduleSpecifier,
+                exportName,
+            };
+        }
+    }
+    throw new DeployAdapterConfigError(`Deploy adapter module "${deployConfig.adapterModule}" does not export a deploy adapter. Tried ${exportNames.join(', ')}.`);
+}
+function isDeployAdapter(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.createPlan === 'function');
+}
+function resolveModuleSpecifier(moduleSpecifier, configPath) {
+    if (moduleSpecifier.startsWith('file:'))
+        return moduleSpecifier;
+    if (moduleSpecifier.startsWith('.') || moduleSpecifier.startsWith('/')) {
+        return pathToFileURL(resolve(dirname(configPath), moduleSpecifier)).href;
+    }
+    return moduleSpecifier;
+}
+//# sourceMappingURL=load-adapter.js.map

package/dist/esm/deploy/run.d.ts

@@ -0,0 +1,12 @@
+import type { DeployPlan } from './types.js';
+export interface CreateDeployPlanOptions {
+    readonly cwd?: string;
+    readonly lane: string;
+    readonly dryRun?: boolean;
+}
+export interface RunDeployPlanOptions extends CreateDeployPlanOptions {
+    readonly planJson?: boolean;
+}
+export declare function createDeployPlan(options: CreateDeployPlanOptions): Promise<DeployPlan>;
+export declare function runDeployPlan(options: RunDeployPlanOptions): Promise<number>;
+//# sourceMappingURL=run.d.ts.map

package/dist/esm/deploy/run.js

@@ -0,0 +1,52 @@
+import { spawnSync } from 'node:child_process';
+import { loadDeployAdapter } from './load-adapter.js';
+import { parseDeployLane, validateDeployPlan } from './schema.js';
+import { getManagedRunner } from '#tool-runtime';
+export async function createDeployPlan(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const loadedAdapter = await loadDeployAdapter(cwd);
+    if (!loadedAdapter) {
+        throw new Error('No deploy adapter configured. Add deploy.adapterModule to agent-kit.config.ts.');
+    }
+    const lane = parseDeployLane(options.lane);
+    const request = {
+        cwd,
+        lane,
+        dryRun: Boolean(options.dryRun),
+        env: process.env,
+        cloudflare: loadedAdapter.config.deploy?.cloudflare,
+    };
+    return validateDeployPlan(await loadedAdapter.adapter.createPlan(request));
+}
+export async function runDeployPlan(options) {
+    const plan = await createDeployPlan(options);
+    if (options.planJson) {
+        console.log(JSON.stringify(plan, null, 2));
+        return 0;
+    }
+    for (const step of plan.steps) {
+        const code = runDeployStep(step);
+        if (code !== 0)
+            return code;
+    }
+    return 0;
+}
+function runDeployStep(step) {
+    const label = step.label ?? step.id;
+    console.error(`[deploy] ${label}`);
+    const command = resolveStepCommand(step);
+    const result = spawnSync(command.command, command.args, {
+        cwd: step.cwd,
+        env: { ...process.env, ...step.env },
+        stdio: 'inherit',
+    });
+    return result.status ?? 1;
+}
+function resolveStepCommand(step) {
+    if (step.kind === 'command') {
+        return { command: step.command, args: [...(step.args ?? [])] };
+    }
+    const resolution = getManagedRunner(step.tool, { outputPolicy: 'structured' });
+    return { command: resolution.command, args: [...resolution.args, ...(step.args ?? [])] };
+}
+//# sourceMappingURL=run.js.map

package/dist/esm/deploy/schema.d.ts

@@ -0,0 +1,6 @@
+import type { DeployLane, DeployPlan } from './types.js';
+export declare const DEPLOY_PLAN_SCHEMA_VERSION = 1;
+export declare function isDeployLane(value: string): value is DeployLane;
+export declare function parseDeployLane(value: string): DeployLane;
+export declare function validateDeployPlan(plan: unknown): DeployPlan;
+//# sourceMappingURL=schema.d.ts.map