@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/cli/handlers/regenerate.js

@@ -0,0 +1,336 @@
+/**
+ * Regenerate Context Files Handler (#1266)
+ *
+ * `aiwg regenerate` — regenerates the cross-provider context files
+ * (WORKSPACE.md + AIWG.md + provider adapters) without redeploying frameworks, agents, skills, or
+ * commands. Use when context drifts (e.g., editing CLAUDE.md, adding a
+ * framework manifest entry) and you want a fast, focused refresh.
+ *
+ * Scope: context-only. For full redeploy use `aiwg refresh` or `aiwg use`.
+ *
+ * Flags:
+ *   --dry-run                Print what would change without writing
+ *   --provider <name>        Target provider (default: auto-detect)
+ *   --force                  Overwrite operator-modified context files (backs up first)
+ *   --no-aiwg-md             Skip AIWG.md emission
+ *   --no-agents-md           Skip AGENTS.md emission
+ *
+ * @source @src/cli/router.ts
+ * @issue #1266
+ */
+import * as path from 'path';
+import { promises as fs } from 'node:fs';
+import { AiwgError, EXIT_CODES, handlerResultFromError } from '../errors.js';
+import * as ui from '../ui.js';
+import { generate as generateContextFiles, discoverDeployedArtifacts, shouldEmitContextFiles, buildNormalizedAiwgMd, writeNormalizedAiwgMd, injectLegacyContext, migrateWorkspaceContext, extractExistingProjectContext, } from '../../smiths/context-pipeline/index.js';
+import { resolveActiveProvider } from '../provider-resolution.js';
+import { getProviderContextDiscoveryPathStrings } from '../../providers/provider-definitions.js';
+import { projectAiwgPath } from '../../config/project-artifacts.js';
+async function handleRegenerate(args, cwd) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`
+  aiwg regenerate — Regenerate canonical workspace context and provider adapters
+
+  Usage:
+    aiwg regenerate [options]
+
+  Scope:
+    Context-only. Refreshes WORKSPACE.md, AIWG.md, and provider adapters using the
+    canonical context pipeline. Does NOT redeploy frameworks, agents, skills,
+    or commands — use 'aiwg refresh' for that.
+
+  Options:
+    --workspace             Canonical WORKSPACE.md → AIWG.md graph (default)
+    --existing-project      Transactionally extract an established project into WORKSPACE.md
+    --legacy, --full-inject Legacy inline compatibility branch
+    --apply                 Apply --existing-project after its mandatory preflight
+    --dry-run               Print what would change; no writes
+    --provider <name>       Target provider (default: auto-detect from env)
+    --force                 Overwrite operator-modified files (backs up first)
+    --no-aiwg-md            Skip AIWG.md emission
+    --no-agents-md          Skip AGENTS.md emission
+    --no-workspace-md       Skip WORKSPACE.md emission
+    --help, -h              Show this help
+
+  Examples:
+    aiwg regenerate
+    aiwg regenerate --workspace
+    aiwg regenerate --existing-project --dry-run
+    aiwg regenerate --existing-project --apply
+    aiwg regenerate --full-inject
+    aiwg regenerate --dry-run
+    aiwg regenerate --provider codex
+    aiwg regenerate --force --no-agents-md
+`);
+        return;
+    }
+    const dryRun = args.includes('--dry-run');
+    const force = args.includes('--force');
+    const skipAiwgMd = args.includes('--no-aiwg-md');
+    const skipAgentsMd = args.includes('--no-agents-md');
+    const skipWorkspaceMd = args.includes('--no-workspace-md');
+    const legacy = args.includes('--legacy') || args.includes('--full-inject');
+    const workspace = args.includes('--workspace');
+    const existingProject = args.includes('--existing-project');
+    const apply = args.includes('--apply');
+    const valueFlags = new Set(['--provider']);
+    const booleanFlags = new Set([
+        '--help', '-h', '--dry-run', '--force', '--no-aiwg-md', '--no-agents-md',
+        '--no-workspace-md', '--legacy', '--full-inject', '--workspace',
+        '--existing-project', '--apply',
+    ]);
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (valueFlags.has(arg)) {
+            if (!args[index + 1] || args[index + 1].startsWith('-'))
+                throw new AiwgError({
+                    code: 'ERR_USAGE_MISSING_VALUE', message: `${arg} requires a value`, exitCode: EXIT_CODES.USAGE,
+                });
+            index += 1;
+        }
+        else if (!booleanFlags.has(arg)) {
+            throw new AiwgError({
+                code: 'ERR_USAGE_UNKNOWN_FLAG', message: `Unknown regenerate option: ${arg}`,
+                hint: 'Run aiwg regenerate --help for supported branches and flags.', exitCode: EXIT_CODES.USAGE,
+            });
+        }
+    }
+    const selectedBranches = Number(legacy) + Number(workspace) + Number(existingProject);
+    if (selectedBranches > 1)
+        throw new AiwgError({
+            code: 'ERR_USAGE_CONFLICTING_FLAGS',
+            message: 'Choose exactly one regenerate branch: --workspace, --existing-project, or --full-inject.',
+            exitCode: EXIT_CODES.USAGE,
+        });
+    if (apply && !existingProject)
+        throw new AiwgError({
+            code: 'ERR_USAGE_CONFLICTING_FLAGS',
+            message: '--apply is only valid with --existing-project.',
+            exitCode: EXIT_CODES.USAGE,
+        });
+    if (existingProject && dryRun && apply)
+        throw new AiwgError({
+            code: 'ERR_USAGE_CONFLICTING_FLAGS',
+            message: 'Choose either --dry-run or --apply for --existing-project.',
+            exitCode: EXIT_CODES.USAGE,
+        });
+    if (existingProject && (force || skipAiwgMd || skipAgentsMd || skipWorkspaceMd))
+        throw new AiwgError({
+            code: 'ERR_USAGE_CONFLICTING_FLAGS',
+            message: '--existing-project is a complete transaction and cannot be combined with --force or --no-*-md flags.',
+            exitCode: EXIT_CODES.USAGE,
+        });
+    const providerFlag = args.indexOf('--provider');
+    const explicitProvider = providerFlag >= 0 ? args[providerFlag + 1] : undefined;
+    const resolution = await resolveActiveProvider({ cwd, explicitProvider, detectProcess: true });
+    if (!resolution.provider) {
+        throw new AiwgError({
+            code: 'ERR_USAGE_PROVIDER_AMBIGUOUS',
+            message: 'Could not determine provider for regenerate: ' + resolution.reason,
+            hint: resolution.candidates.length
+                ? 'Specify --provider (' + resolution.candidates.join(', ') + ')'
+                : 'Specify --provider <name>',
+            exitCode: EXIT_CODES.USAGE,
+        });
+    }
+    const provider = resolution.provider;
+    const target = cwd;
+    const effectiveDryRun = dryRun || (existingProject && !apply);
+    console.log(`${ui.brandMark()} aiwg regenerate${effectiveDryRun ? '  (dry run)' : ''}`);
+    console.log(`  Provider: ${provider}`);
+    console.log(`  Target:   ${target}`);
+    console.log(`  Branch:   ${legacy ? 'legacy full injection' : existingProject ? 'canonical existing-project extraction' : 'canonical workspace graph'}`);
+    if (existingProject) {
+        const preflight = await migrateWorkspaceContext(target, {
+            dryRun: true,
+            extractProject: true,
+            includeGeneratedContext: true,
+        });
+        const hasExistingSignals = preflight.audit.plan.projectSources.length > 0
+            || preflight.audit.sources.some((source) => source.path !== 'WORKSPACE.md' && source.operatorContent.trim().length > 0);
+        console.log('');
+        console.log(`  Stable project sources: ${preflight.audit.plan.projectSources.length}`);
+        for (const source of preflight.audit.plan.projectSources)
+            console.log(`    - ${source}`);
+        if (!hasExistingSignals) {
+            console.log('  No stable existing-project signals found; no files changed.');
+            console.log('  Use `aiwg regenerate --workspace` to initialize a fresh project.');
+            return;
+        }
+        const extractedProject = await extractExistingProjectContext(target);
+        console.log('  Synthesized WORKSPACE project block:');
+        for (const line of extractedProject.content.split('\n'))
+            console.log(`    ${line}`);
+        console.log('  Transaction plan:');
+        for (const file of preflight.written)
+            console.log(`    - ${file}`);
+        if (!apply) {
+            console.log('');
+            console.log('  Dry run complete — no changes made. Re-run with --apply to commit this transaction.');
+            return;
+        }
+        const migration = await migrateWorkspaceContext(target, {
+            apply: true,
+            extractProject: true,
+            includeGeneratedContext: true,
+        });
+        for (const file of migration.written)
+            console.log(`  OK Wrote ${file}`);
+        if (migration.transactionId) {
+            console.log(`  Transaction: ${migration.transactionId}`);
+            console.log(`  Rollback: aiwg workspace-context rollback ${migration.transactionId}`);
+        }
+        if (!migration.changed)
+            console.log('  Existing-project context is already current.');
+        console.log('  Existing-project regenerate complete');
+        return;
+    }
+    if (legacy) {
+        if (skipWorkspaceMd)
+            console.log('  Note: --no-workspace-md is implicit in legacy mode.');
+        const normalizedPath = projectAiwgPath(target, 'AIWG.md');
+        let existing = '';
+        try {
+            existing = await fs.readFile(normalizedPath, 'utf8');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const normalizedContent = await buildNormalizedAiwgMd(target, existing);
+        const result = skipAgentsMd
+            ? { targets: [], backups: [], changed: [], dryRun, warnings: [] }
+            : await injectLegacyContext(provider, target, normalizedContent, { dryRun });
+        if (dryRun) {
+            console.log('');
+            console.log('  Would regenerate:');
+            if (!skipAiwgMd)
+                console.log(`    - ${normalizedPath} (normalized framework source)`);
+            for (const changed of result.changed)
+                console.log(`    - ${changed} (legacy inline markers)`);
+            for (const warning of result.warnings)
+                console.log(`  WARNING: ${warning}`);
+            console.log('');
+            console.log('  Dry run complete — no changes made');
+            return;
+        }
+        if (!skipAiwgMd)
+            await writeNormalizedAiwgMd(target);
+        for (const changed of result.changed)
+            console.log(`  OK Injected AIWG context into ${path.relative(target, changed)}`);
+        for (const backup of result.backups)
+            console.log(`  Backup created: ${backup}`);
+        for (const warning of result.warnings)
+            console.log(`  WARNING: ${warning}`);
+        console.log('  Legacy regenerate complete');
+        return;
+    }
+    if (!shouldEmitContextFiles(provider)) {
+        console.log(`  Adapter:  provider '${provider}' has no verified project startup loader; WORKSPACE.md is still maintained.`);
+    }
+    if (dryRun) {
+        const aiwgMd = path.join(target, 'AIWG.md');
+        const agentsMd = path.join(target, 'AGENTS.md');
+        const claudeMd = path.join(target, 'CLAUDE.md');
+        console.log('');
+        console.log(`  Would regenerate:`);
+        if (!skipWorkspaceMd)
+            console.log(`    - ${path.join(target, 'WORKSPACE.md')} (managed graph; operator section preserved)`);
+        console.log(`    - ${projectAiwgPath(target, 'AIWG.md')}`);
+        if (!skipAiwgMd)
+            console.log(`    - ${aiwgMd}`);
+        if (provider === 'claude') {
+            console.log(`    - ${claudeMd} (managed @WORKSPACE.md then @AIWG.md hook; operator content preserved)`);
+        }
+        else {
+            if (!skipAgentsMd)
+                console.log(`    - ${agentsMd}`);
+            if (provider === 'copilot' && !skipAgentsMd)
+                console.log(`    - ${path.join(target, '.github', 'copilot-instructions.md')}`);
+        }
+        if (force)
+            console.log(`    (with --force: any operator-modified files are backed up first)`);
+        console.log('');
+        console.log(`  Dry run complete — no changes made`);
+        return;
+    }
+    const paths = getProviderContextDiscoveryPathStrings(provider) ?? getProviderContextDiscoveryPathStrings('claude');
+    if (!paths)
+        throw new Error(`Missing context discovery paths for provider ${provider}`);
+    const sections = await discoverDeployedArtifacts(target, {
+        agents: paths.agents,
+        rules: paths.rules,
+        skills: paths.skills,
+        behaviors: paths.behaviors,
+    });
+    const result = await generateContextFiles({
+        provider: provider,
+        projectPath: target,
+        sections,
+        detectExistingFiles: true,
+        force,
+        skip: { workspaceMd: skipWorkspaceMd, aiwgMd: skipAiwgMd, agentsMd: skipAgentsMd },
+    });
+    if (result.workspaceMdPath) {
+        console.log(`  OK ${result.workspaceMdAction === 'created' ? 'Created' : 'Refreshed'} WORKSPACE.md`);
+    }
+    if (result.agentsMdPath) {
+        console.log(`  OK Wrote AGENTS.md (${result.agentsMdBytes} bytes)`);
+    }
+    if (result.aiwgMdPath) {
+        console.log(`  OK Wrote AIWG.md`);
+    }
+    if (result.normalizedAiwgMdPath) {
+        console.log(`  OK Wrote ${path.relative(target, result.normalizedAiwgMdPath) || result.normalizedAiwgMdPath}`);
+    }
+    if (result.claudeMdHookPath && result.claudeMdHookAction && result.claudeMdHookAction !== 'unchanged' && result.claudeMdHookAction !== 'skipped') {
+        const verb = result.claudeMdHookAction === 'created' ? 'Created' :
+            result.claudeMdHookAction === 'inserted' ? 'Inserted hook into' :
+                'Updated hook in';
+        console.log(`  OK ${verb} CLAUDE.md (@WORKSPACE.md then @AIWG.md block managed by AIWG)`);
+    }
+    else if (result.claudeMdHookPath && result.claudeMdHookAction === 'unchanged') {
+        console.log(`  OK CLAUDE.md hook already up to date`);
+    }
+    for (const w of result.warnings) {
+        // #1579: loud warnings (non-managed twin/bridge left untouched) are prefixed
+        // `WARNING:` and rendered prominently so the consequence + remediation isn't
+        // buried among the routine OK lines.
+        if (w.startsWith('WARNING:')) {
+            console.log(`  ⚠ context-pipeline: ${w.slice('WARNING:'.length).trim()}`);
+        }
+        else {
+            console.log(`  context-pipeline: ${w}`);
+        }
+    }
+    for (const b of result.backupPaths) {
+        console.log(`  Backup created: ${b}`);
+    }
+    for (const registration of result.contextRegistrationPaths) {
+        console.log(`  OK Registered context graph in ${path.relative(target, registration)}`);
+    }
+    if (!result.agentsMdPath && !result.aiwgMdPath && !result.claudeMdHookPath) {
+        console.log(`  No files regenerated (all skipped or refused without --force).`);
+    }
+    else {
+        console.log(`  Regenerate complete`);
+    }
+}
+export const regenerateHandler = {
+    id: 'regenerate',
+    name: 'Regenerate Context Files',
+    description: 'Regenerate WORKSPACE.md, AIWG.md, and provider adapters without redeploying',
+    category: 'maintenance',
+    aliases: [],
+    async execute(ctx) {
+        try {
+            await handleRegenerate(ctx.args, ctx.cwd);
+            return { exitCode: 0 };
+        }
+        catch (error) {
+            return handlerResultFromError(error);
+        }
+    },
+};
+export const regenerateHandlers = [regenerateHandler];
+//# sourceMappingURL=regenerate.js.map

package/dist/src/cli/handlers/repo-access.js

@@ -0,0 +1,109 @@
+import { checkRepoAccess, findRepoEntry, formatRepoAccessEntry, loadRepoAccessManifest, } from '../../policy/repo-access.js';
+import { resolveWorkspace } from '../../config/workspace.js';
+function valueAfter(args, flag) {
+    const index = args.indexOf(flag);
+    if (index < 0)
+        return null;
+    return args[index + 1] ?? null;
+}
+function printHelp() {
+    console.log(`
+  aiwg repo-access — repo authorization manifest preflight
+
+  Usage:
+    aiwg repo-access list
+    aiwg repo-access status
+    aiwg repo-access explain --path <repo-or-file>
+    aiwg repo-access check --path <repo-or-file> --action <read|write|commit|push|issue-comment|service-action|destructive>
+
+  Manifest:
+    .aiwg/aiwg.config workspace + repos blocks (preferred)
+    .aiwg/ops/security/repo-access.manifest.yaml
+    .aiwg/security/repo-access.manifest.yaml (fallback)
+`);
+}
+async function handleRepoAccess(ctx) {
+    const [subcommand = 'help', ...args] = ctx.args;
+    if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+        printHelp();
+        return { exitCode: 0 };
+    }
+    try {
+        const manifest = loadRepoAccessManifest(ctx.cwd);
+        if (subcommand === 'list' || subcommand === 'status') {
+            console.log(`Repo access manifest: ${manifest.path}`);
+            console.log(`Source: ${manifest.source}`);
+            if (manifest.workspaceName)
+                console.log(`Workspace: ${manifest.workspaceName}`);
+            console.log(`Default policy: ${manifest.defaultPolicy}`);
+            if (manifest.source === 'workspace-config') {
+                const workspace = await resolveWorkspace(manifest.workspaceProjectRoot, manifest.workspaceProjectRoot);
+                for (const member of workspace.members) {
+                    const route = `${member.primary.provider}@${member.primary.domain ?? 'unknown-domain'}`;
+                    const tracker = `${member.issueTracker.provider}@${member.issueTracker.domain ?? 'unknown-domain'}`;
+                    const drift = member.drift.length > 0 ? ` DRIFT: ${member.drift.join('; ')}` : ' OK';
+                    console.log(`- ${member.name}: ${member.path} [${member.allowed.join(', ')}]`);
+                    console.log(`  config: ${member.configPath}${member.config ? '' : ' (missing)'}`);
+                    console.log(`  delivery: ${member.delivery.mode} -> ${member.remotes.primary} (${route})`);
+                    console.log(`  tracker: ${member.remotes.issue_tracker} (${tracker})`);
+                    console.log(`  status:${drift}`);
+                }
+            }
+            else {
+                for (const repo of manifest.repos) {
+                    console.log(`- ${formatRepoAccessEntry(repo)}`);
+                }
+            }
+            return { exitCode: 0 };
+        }
+        if (subcommand === 'explain') {
+            const requestedPath = valueAfter(args, '--path');
+            if (!requestedPath)
+                return { exitCode: 2, message: 'repo-access explain requires --path <repo-or-file>' };
+            const entry = findRepoEntry(manifest, requestedPath, ctx.cwd);
+            if (!entry) {
+                console.log(`Path: ${requestedPath}`);
+                console.log('Matched repo: none');
+                console.log('Decision: unlisted repo/path defaults to denied');
+                return { exitCode: 0 };
+            }
+            console.log(`Path: ${requestedPath}`);
+            console.log(`Matched repo: ${formatRepoAccessEntry(entry)}`);
+            return { exitCode: 0 };
+        }
+        if (subcommand === 'check') {
+            const requestedPath = valueAfter(args, '--path');
+            const action = valueAfter(args, '--action');
+            if (!requestedPath)
+                return { exitCode: 2, message: 'repo-access check requires --path <repo-or-file>' };
+            if (!action)
+                return { exitCode: 2, message: 'repo-access check requires --action <action>' };
+            const decision = checkRepoAccess(manifest, requestedPath, action, ctx.cwd);
+            const status = decision.allowed ? 'ALLOW' : 'DENY';
+            console.log(`${status} ${decision.action} ${decision.requestedPath}`);
+            console.log(decision.reason);
+            if (decision.matchedRepo) {
+                console.log(`matched: ${formatRepoAccessEntry(decision.matchedRepo)}`);
+            }
+            return { exitCode: decision.allowed ? 0 : 1 };
+        }
+        return { exitCode: 2, message: `Unknown repo-access subcommand: ${subcommand}` };
+    }
+    catch (error) {
+        return {
+            exitCode: 2,
+            message: error instanceof Error ? error.message : String(error),
+            error: error instanceof Error ? error : undefined,
+        };
+    }
+}
+export const repoAccessHandler = {
+    id: 'repo-access',
+    name: 'Repo Access',
+    description: 'Validate and query repo access manifest permissions',
+    category: 'utility',
+    aliases: [],
+    execute: handleRepoAccess,
+};
+export const repoAccessHandlers = [repoAccessHandler];
+//# sourceMappingURL=repo-access.js.map

package/dist/src/cli/handlers/run.js

@@ -0,0 +1,165 @@
+/**
+ * Run Command Handler
+ *
+ * Implements `aiwg run <script>` — executes user-defined scripts from
+ * `.aiwg/aiwg.config` `scripts` section.
+ *
+ * Modelled on `npm run`. With no arguments, lists available scripts.
+ *
+ * Environment variables available in scripts:
+ *   $AIWG_PROJECT   — absolute path to the project root
+ *   $AIWG_PROVIDERS — comma-separated list of configured providers
+ *
+ * @implements #621
+ */
+import { spawn } from 'child_process';
+import { readAiwgConfig, getProjectDir } from '../../config/aiwg-config.js';
+import { handlerResultFromError } from '../errors.js';
+import * as ui from '../ui.js';
+/**
+ * Execute a shell command with inherited stdio.
+ * Returns the exit code.
+ */
+function runScript(command, env, cwd) {
+    return new Promise((resolve, reject) => {
+        const isWindows = process.platform === 'win32';
+        const shell = isWindows ? 'cmd' : 'sh';
+        const shellFlag = isWindows ? '/c' : '-c';
+        const child = spawn(shell, [shellFlag, command], {
+            stdio: 'inherit',
+            env: { ...process.env, ...env },
+            cwd,
+        });
+        child.on('error', reject);
+        child.on('close', (code) => resolve(code ?? 1));
+    });
+}
+export const runHandler = {
+    id: 'run',
+    name: 'Run Script',
+    description: 'Run a user-defined script from aiwg.config',
+    category: 'utility',
+    aliases: [],
+    async execute(ctx) {
+        const scriptName = ctx.args[0];
+        const projectDir = getProjectDir(ctx, ctx.args);
+        // #1231 — intercept --help/-h before script lookup so the user sees
+        // help for both run forms, not "No script named '--help'".
+        if (scriptName === '--help' || scriptName === '-h') {
+            printRunUsage();
+            return { exitCode: 0 };
+        }
+        // #1227 — `aiwg run skill <name>` dispatches to the script-bearing
+        // skill executor in src/skills/run.ts. Routed here so we don't have
+        // two handlers competing for `id: "run"` in the dispatch table.
+        if (scriptName === 'skill') {
+            try {
+                const { main } = await import('../../skills/run.js');
+                const exitCode = await main(ctx.args);
+                return { exitCode };
+            }
+            catch (error) {
+                const result = handlerResultFromError(error);
+                return { ...result, message: `Skill run failed: ${result.message}` };
+            }
+        }
+        const config = await readAiwgConfig(projectDir);
+        if (!config) {
+            return {
+                exitCode: 1,
+                message: [
+                    "Error: No .aiwg/aiwg.config found in this project.",
+                    '',
+                    "Run 'aiwg init' to create one, then ask your AIWG agent to establish project policy.",
+                ].join('\n'),
+            };
+        }
+        const scripts = config.scripts ?? {};
+        // No script name — list available scripts AND mention `run skill <name>`
+        // (#1231) so users discover the sibling form.
+        if (!scriptName) {
+            ui.blank();
+            console.log(`  ${ui.brandMark()} ${ui.bold('Available Scripts')}`);
+            ui.rule();
+            const entries = Object.entries(scripts);
+            if (entries.length === 0) {
+                ui.dim('  No scripts defined in .aiwg/aiwg.config');
+                ui.blank();
+                ui.dim('  Add scripts to the "scripts" section, e.g.:');
+                ui.dim('    "deploy": "aiwg use all"');
+                ui.blank();
+            }
+            else {
+                const nameWidth = Math.max(...entries.map(([n]) => n.length), 6);
+                for (const [name, cmd] of entries) {
+                    console.log(`  ${name.padEnd(nameWidth)}  ${ui.dimText(cmd)}`);
+                }
+                ui.blank();
+                ui.dim(`  Run with: aiwg run <script-name>`);
+                ui.blank();
+            }
+            ui.dim(`  Or run a script-bearing skill: aiwg run skill <name>`);
+            ui.dim(`  See \`aiwg run --help\` for both forms.`);
+            ui.blank();
+            return { exitCode: 0 };
+        }
+        // Look up the script
+        const command = scripts[scriptName];
+        if (!command) {
+            const available = Object.keys(scripts);
+            const hint = available.length > 0
+                ? `\nAvailable: ${available.join(', ')}`
+                : '\nNo scripts defined. Run `aiwg init`, then ask your AIWG agent to finish project setup.';
+            return {
+                exitCode: 1,
+                message: `Error: No script named '${scriptName}'${hint}`,
+            };
+        }
+        // Build environment
+        const env = {
+            AIWG_PROJECT: projectDir,
+            AIWG_PROVIDERS: config.providers.join(','),
+        };
+        ui.blank();
+        console.log(`  ${ui.brandMark()} ${ui.bold(`aiwg run ${scriptName}`)}`);
+        ui.dim(`  > ${command}`);
+        console.log('');
+        let exitCode;
+        try {
+            exitCode = await runScript(command, env, projectDir);
+        }
+        catch (error) {
+            const result = handlerResultFromError(error);
+            return { ...result, message: `Error executing script: ${result.message}` };
+        }
+        if (exitCode !== 0) {
+            console.log('');
+            ui.warn(`Script '${scriptName}' exited with code ${exitCode}`);
+        }
+        return { exitCode };
+    },
+};
+function printRunUsage() {
+    console.log('Usage: aiwg run <script-name> [args...]');
+    console.log('       aiwg run skill <skill-name> [--cwd <path>] [-- <args forwarded to script>]');
+    console.log('');
+    console.log('Two forms share the `run` namespace:');
+    console.log('');
+    console.log('  aiwg run <script-name>');
+    console.log('    Execute a user-defined script from .aiwg/aiwg.config (modeled on `npm run`).');
+    console.log('    With no arguments, lists available scripts.');
+    console.log('');
+    console.log('  aiwg run skill <skill-name>');
+    console.log('    Execute a script-bearing skill via the artifact index. Skills with a');
+    console.log('    `script:` frontmatter declaration are dispatched through the runtime');
+    console.log('    registry (node/python3/bash/sh/pwsh/ruby/auto). Find skills with');
+    console.log('    `aiwg discover "<phrase>"` — executable skills are flagged `executable: true`.');
+    console.log('');
+    console.log('Examples:');
+    console.log('  aiwg run                                # list available user scripts');
+    console.log('  aiwg run deploy                         # run user script "deploy"');
+    console.log('  aiwg run skill voice-apply -- --voice technical-authority --input draft.md');
+    console.log('  aiwg run skill template-engine -- render adr-template.md --vars vars.yaml');
+    console.log('  aiwg run skill <name> --cwd <path>      # explicit CWD override');
+}
+//# sourceMappingURL=run.js.map