@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

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

@@ -0,0 +1,302 @@
+/**
+ * CLI Handler Index
+ *
+ * Aggregates all extracted command handlers for registry-based routing.
+ *
+ * @implements @.aiwg/architecture/decisions/ADR-001-unified-extension-system.md
+ * @tests @test/unit/cli/handlers/index.test.ts
+ * @issue #42
+ */
+// Re-export types
+export * from './types.js';
+export { createScriptRunner, DefaultScriptRunner } from './script-runner.js';
+// Import all handlers
+import { helpHandler } from './help.js';
+import { versionHandler } from './version.js';
+import { useHandler } from './use.js';
+import { statusHandler, wizardHandler, migrateWorkspaceHandler, rollbackWorkspaceHandler, workspaceHandlers, } from './workspace.js';
+import { prefillCardsHandler, contributeStartHandler, validateMetadataHandler, doctorHandler, updateHandler, utilityHandlers, } from './utilities.js';
+import { skillLintHandler } from './skill-lint.js';
+import { addAgentHandler, addCommandHandler, addSkillHandler, addBehaviorHandler, addTemplateHandler, scaffoldAddonHandler, scaffoldExtensionHandler, scaffoldFrameworkHandler, scaffoldingHandlers, } from './scaffolding.js';
+import { behaviorHandler, daemonInitHandler, daemonHandlers, } from './daemon.js';
+import { ralphHandler, ralphStatusHandler, ralphAbortHandler, ralphResumeHandler, ralphAttachHandler, ralphExternalHandler, ralphMemoryHandler, ralphConfigHandler, ralphHandlers, } from './ralph.js';
+import { mcpHandler, catalogHandler, listHandler, removeHandler, promoteHandler, newBundleHandler, quickrefHandler, newProjectHandler, installPluginHandler, uninstallPluginHandler, pluginStatusHandler, packagePluginHandler, packageAllPluginsHandler, indexHandler, corpusHandler, discoverHandler, showHandler, featuresHandler, skillsHandler, configHandler, opsHandler, storageHandler, activityLogHandler, kbHandler, memoryHandler, reflectionsHandler, provenanceHandler, researchStoreHandler, researchQueryHandler, chunkHandler, fanoutHandler, rlmPrepHandler, rlmSearchHandler, rlmStatusCliHandler, rlmCacheHandler, subcommandHandlers, } from './subcommands.js';
+import { runtimeInfoHandler } from './runtime-info.js';
+import { agentcardHandler } from './agentcard.js';
+import { bestPracticesAuditHandler } from './best-practices-audit.js';
+// sync was renamed to refresh (#694). refreshHandler exposes both 'refresh'
+// (primary) and 'sync' (deprecated alias) to preserve backward compatibility.
+import { refreshHandler } from './refresh.js';
+import { regenerateHandler, regenerateHandlers } from './regenerate.js';
+import { workspaceContextHandler, workspaceContextHandlers } from './workspace-context.js';
+import { artifactsHandler, artifactsHandlers } from './artifacts.js';
+import { mcHandler, mcHandlers } from './mc.js';
+import { sdlcAccelerateHandler } from './sdlc-accelerate.js';
+import { teamHandler, teamHandlers } from './team.js';
+import { installHandler } from './install.js';
+import { packagesHandler } from './packages.js';
+import { marketplaceHandler } from './marketplace.js';
+import { initHandler } from './init.js';
+import { setupHandler } from './setup.js';
+import { runHandler } from './run.js';
+import { stewardHandler, stewardHandlers } from './steward.js';
+import { serveHandler } from './serve.js';
+import { lintHandler } from './lint.js';
+import { feedbackHandler } from './feedback.js';
+import { sessionHandler } from './session.js';
+import { sandboxHandler, sandboxHandlers } from './sandbox.js';
+import { diagnoseHandler } from './diagnose.js';
+import { localExecutorHandler, localExecutorServeHandler } from './local-executor.js';
+import { executionModeHandler } from './execution-mode.js';
+import { repoAccessHandler, repoAccessHandlers } from './repo-access.js';
+import { issueHandler, issueAuditHandler } from './issues.js';
+import { cockpitHandler } from './cockpit.js';
+import { commandLogHandler } from './command-log.js';
+import { skillUsageHandler } from './skill-usage.js';
+import { modelsHandler } from './models.js';
+// Re-export individual handlers
+export { 
+// Maintenance
+helpHandler, versionHandler, doctorHandler, updateHandler, refreshHandler, regenerateHandler, workspaceContextHandler, 
+// Framework management
+useHandler, listHandler, removeHandler, promoteHandler, installHandler, packagesHandler, marketplaceHandler, initHandler, setupHandler, issueHandler, issueAuditHandler, runHandler, 
+// Project
+newBundleHandler, quickrefHandler, newProjectHandler, 
+// Workspace
+statusHandler, wizardHandler, migrateWorkspaceHandler, rollbackWorkspaceHandler, 
+// Subcommands
+mcpHandler, catalogHandler, modelsHandler, indexHandler, artifactsHandler, corpusHandler, discoverHandler, showHandler, featuresHandler, skillsHandler, configHandler, opsHandler, storageHandler, activityLogHandler, commandLogHandler, skillUsageHandler, kbHandler, memoryHandler, reflectionsHandler, provenanceHandler, researchStoreHandler, researchQueryHandler, runtimeInfoHandler, agentcardHandler, 
+// Agentic Tools (RLM)
+chunkHandler, fanoutHandler, rlmPrepHandler, rlmSearchHandler, rlmStatusCliHandler, rlmCacheHandler, 
+// Utilities
+prefillCardsHandler, contributeStartHandler, validateMetadataHandler, skillLintHandler, cockpitHandler, 
+// Plugin
+installPluginHandler, uninstallPluginHandler, pluginStatusHandler, packagePluginHandler, packageAllPluginsHandler, 
+// Scaffolding
+addAgentHandler, addCommandHandler, addSkillHandler, addBehaviorHandler, addTemplateHandler, scaffoldAddonHandler, scaffoldExtensionHandler, scaffoldFrameworkHandler, 
+// Daemon
+behaviorHandler, daemonInitHandler, 
+// Ralph
+ralphHandler, ralphStatusHandler, ralphAbortHandler, ralphResumeHandler, ralphAttachHandler, ralphExternalHandler, ralphMemoryHandler, ralphConfigHandler, 
+// Mission Control
+mcHandler, 
+// SDLC Orchestration
+sdlcAccelerateHandler, 
+// Research / Validation
+bestPracticesAuditHandler, 
+// Agent Teams
+teamHandler, 
+// Steward
+stewardHandler, 
+// Serve
+serveHandler, 
+// Local Executor (#1181)
+localExecutorHandler, localExecutorServeHandler, 
+// Sandbox management
+sandboxHandler, 
+// Diagnose
+diagnoseHandler, executionModeHandler, 
+// Repo Access
+repoAccessHandler, 
+// Lint
+lintHandler, };
+// Re-export handler arrays
+export { workspaceHandlers, utilityHandlers, scaffoldingHandlers, ralphHandlers, subcommandHandlers, mcHandlers, teamHandlers, stewardHandlers, regenerateHandlers, workspaceContextHandlers, artifactsHandlers, daemonHandlers, sandboxHandlers, repoAccessHandlers, };
+/**
+ * All registered command handlers
+ *
+ * Used by the registry to build the command routing table.
+ */
+export const allHandlers = [
+    // Maintenance (shown first in help)
+    helpHandler,
+    versionHandler,
+    doctorHandler,
+    updateHandler,
+    refreshHandler,
+    regenerateHandler,
+    workspaceContextHandler,
+    // Framework management
+    useHandler,
+    listHandler,
+    removeHandler,
+    promoteHandler,
+    installHandler,
+    packagesHandler,
+    marketplaceHandler,
+    // Project setup
+    newBundleHandler,
+    quickrefHandler,
+    newProjectHandler,
+    initHandler,
+    setupHandler,
+    issueHandler,
+    issueAuditHandler,
+    runHandler,
+    // Workspace management
+    ...workspaceHandlers,
+    // Subcommand handlers (MCP, catalog, index, skills)
+    mcpHandler,
+    catalogHandler,
+    modelsHandler,
+    indexHandler,
+    artifactsHandler,
+    corpusHandler,
+    discoverHandler,
+    showHandler,
+    featuresHandler,
+    skillsHandler,
+    runtimeInfoHandler,
+    agentcardHandler,
+    // Utilities
+    prefillCardsHandler,
+    contributeStartHandler,
+    validateMetadataHandler,
+    skillLintHandler,
+    cockpitHandler,
+    // Plugin packaging
+    installPluginHandler,
+    uninstallPluginHandler,
+    pluginStatusHandler,
+    packagePluginHandler,
+    packageAllPluginsHandler,
+    // Scaffolding
+    ...scaffoldingHandlers,
+    // Agent loop
+    ...ralphHandlers,
+    // Mission Control
+    ...mcHandlers,
+    // Agent Teams
+    ...teamHandlers,
+    // Steward (capability awareness)
+    ...stewardHandlers,
+    // SDLC Orchestration
+    sdlcAccelerateHandler,
+    // Research / Validation
+    bestPracticesAuditHandler,
+    // Daemon
+    ...daemonHandlers,
+    // Config
+    configHandler,
+    executionModeHandler,
+    // Ops
+    opsHandler,
+    // Storage (#934)
+    storageHandler,
+    // Activity Log (#934, #964)
+    activityLogHandler,
+    // Command invocation log (#1614)
+    commandLogHandler,
+    // Skill usage telemetry (#1649)
+    skillUsageHandler,
+    // Knowledge Base (#934, #965)
+    kbHandler,
+    // Memory subsystem (#934, #966)
+    memoryHandler,
+    // Reflections subsystem (#934, #967)
+    reflectionsHandler,
+    // Provenance subsystem (#934, #968)
+    provenanceHandler,
+    // Research subsystem (#934, #968)
+    researchStoreHandler,
+    researchQueryHandler,
+    // Agentic Tools (RLM support tools)
+    chunkHandler,
+    fanoutHandler,
+    rlmPrepHandler,
+    rlmSearchHandler,
+    rlmStatusCliHandler,
+    rlmCacheHandler,
+    // Web dashboard
+    serveHandler,
+    // Local Executor (#1181)
+    localExecutorHandler,
+    localExecutorServeHandler,
+    // Sandbox management (#917)
+    ...sandboxHandlers,
+    // Diagnose bundle (#925)
+    diagnoseHandler,
+    // Lint
+    lintHandler,
+    // Feedback (#885)
+    feedbackHandler,
+    // Session (#884)
+    sessionHandler,
+    // Repo access policy (#1376)
+    ...repoAccessHandlers,
+];
+/**
+ * Build alias map from all handlers
+ *
+ * Maps command aliases to canonical handler IDs.
+ *
+ * @returns Map of alias -> handler ID
+ */
+export function buildAliasMap() {
+    const aliasMap = new Map();
+    for (const handler of allHandlers) {
+        // Add canonical ID
+        aliasMap.set(handler.id, handler.id);
+        // Add all aliases
+        for (const alias of handler.aliases) {
+            aliasMap.set(alias, handler.id);
+        }
+    }
+    return aliasMap;
+}
+/**
+ * Build handler map for O(1) lookup
+ *
+ * @returns Map of handler ID -> handler
+ */
+export function buildHandlerMap() {
+    const handlerMap = new Map();
+    for (const handler of allHandlers) {
+        handlerMap.set(handler.id, handler);
+    }
+    return handlerMap;
+}
+/**
+ * Resolve a command to its handler
+ *
+ * @param command - Raw command from CLI (may be alias)
+ * @param aliasMap - Alias map from buildAliasMap()
+ * @param handlerMap - Handler map from buildHandlerMap()
+ * @returns Handler or undefined if not found
+ */
+export function resolveHandler(command, aliasMap, handlerMap) {
+    const canonicalId = aliasMap.get(command);
+    if (!canonicalId)
+        return undefined;
+    return handlerMap.get(canonicalId);
+}
+/**
+ * Get handlers grouped by category
+ *
+ * Used for generating organized help text.
+ *
+ * @returns Map of category -> handlers
+ */
+export function getHandlersByCategory() {
+    const categoryMap = new Map();
+    for (const handler of allHandlers) {
+        const category = handler.category;
+        const handlers = categoryMap.get(category) || [];
+        handlers.push(handler);
+        categoryMap.set(category, handlers);
+    }
+    return categoryMap;
+}
+/**
+ * Get total handler count
+ */
+export function getHandlerCount() {
+    return allHandlers.length;
+}
+/**
+ * Get total alias count (including canonical IDs)
+ */
+export function getAliasCount() {
+    return buildAliasMap().size;
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,179 @@
+/**
+ * Init Command Handler
+ *
+ * Implements `aiwg init` — the first-run wizard that creates
+ * `.aiwg/aiwg.config` for the current project.
+ *
+ * Prompts:
+ *   1. Which AI provider toolchains does this project target?
+ *   2. Would you like to add any scripts? (optional)
+ *
+ * Runs automatically on first `aiwg use` when no config exists.
+ * Can also be run explicitly to reconfigure.
+ *
+ * @implements #621
+ */
+import readline from 'readline';
+import { readAiwgConfig, writeAiwgConfig, emptyConfig, populateDeployedTo, VALID_PROVIDERS, getConfigPath, } from '../../config/aiwg-config.js';
+import * as ui from '../ui.js';
+import { askString as sharedAskString, askYesNo as sharedAskYesNo } from '../prompt-utils.js';
+import { writeNormalizedAiwgMd } from '../../smiths/context-pipeline/finalization.js';
+import { ensureWorkspaceContext } from '../../smiths/context-pipeline/workspace-context.js';
+const PROVIDER_LABELS = {
+    claude: 'Claude Code       .claude/',
+    copilot: 'GitHub Copilot    .github/',
+    cursor: 'Cursor            .cursor/',
+    opencode: 'OpenCode          .opencode/',
+    warp: 'Warp Terminal     .warp/',
+    windsurf: 'Windsurf          AGENTS.md',
+    factory: 'Factory AI        .factory/',
+    codex: 'OpenAI Codex      ~/.codex/',
+    openclaw: 'OpenClaw          ~/.openclaw/',
+    hermes: 'Hermes (MCP)      aiwg mcp',
+};
+// Local aliases for the shared prompt utilities. These preserve existing
+// call sites (askYesNo/askString) while routing through a single timeout
+// and unref-discipline implementation in `src/cli/prompt-utils.ts`.
+// Phase 3 (#920) will replace these with @clack/prompts.
+const askYesNo = sharedAskYesNo;
+const askString = sharedAskString;
+/**
+ * Prompt for a comma-separated provider selection
+ */
+async function askProviders(rl, signal) {
+    const list = VALID_PROVIDERS.map((p, i) => `  ${i + 1}. ${PROVIDER_LABELS[p] ?? p}`).join('\n');
+    console.log('');
+    console.log('  Available providers:');
+    console.log(list);
+    console.log('');
+    // Multi-select (comma-separated) — stays hand-rolled rather than adopting
+    // listSelect because #926's POC targets single-select only. `signal`
+    // threading is the full migration from the spike.
+    const answer = await askString(rl, '  Enter provider numbers (comma-separated) or names [1]: ', '', signal);
+    if (!answer)
+        return ['claude']; // default
+    const parts = answer.split(',').map(s => s.trim()).filter(Boolean);
+    const selected = [];
+    for (const part of parts) {
+        const num = parseInt(part, 10);
+        if (!isNaN(num) && num >= 1 && num <= VALID_PROVIDERS.length) {
+            selected.push(VALID_PROVIDERS[num - 1]);
+        }
+        else if (VALID_PROVIDERS.includes(part)) {
+            selected.push(part);
+        }
+        else {
+            ui.warn(`  Unknown provider '${part}' — skipped`);
+        }
+    }
+    return selected.length > 0 ? selected : ['claude'];
+}
+export const initHandler = {
+    id: 'init',
+    name: 'Init',
+    description: 'Initialise the baseline .aiwg/aiwg.config for an agent-led project setup',
+    category: 'project',
+    aliases: [],
+    async execute(ctx) {
+        const force = ctx.args.includes('--force');
+        // Treat a missing stdin TTY as non-interactive so piped/backgrounded
+        // invocations never attempt to create a readline interface. This is a
+        // single authoritative check — downstream code MUST NOT re-derive
+        // interactive-ness from process.stdin.isTTY again.
+        const nonInteractive = ctx.args.includes('--non-interactive') ||
+            ctx.args.includes('--yes') ||
+            !process.stdin.isTTY ||
+            !process.stdout.isTTY ||
+            process.env['CI'] === 'true';
+        const projectDir = ctx.cwd;
+        ui.blank();
+        console.log(`  ${ui.brandMark()} ${ui.bold('AIWG Baseline Config')}`);
+        ui.rule();
+        // Check for existing config
+        const existing = await readAiwgConfig(projectDir);
+        if (existing && !force) {
+            ui.info(`Config already exists: ${getConfigPath(projectDir)}`);
+            await writeNormalizedAiwgMd(projectDir);
+            console.log(`  Providers: ${existing.providers.join(', ')}`);
+            const scriptCount = Object.keys(existing.scripts).length;
+            if (scriptCount > 0) {
+                console.log(`  Scripts: ${Object.keys(existing.scripts).join(', ')}`);
+            }
+            ui.blank();
+            ui.dim('  Ask your AIWG agent to review repo, tracker, delivery, signing, and provider policy.');
+            ui.dim('  Agents may use `aiwg setup project --dry-run` as the CLI helper for that review.');
+            ui.dim('  Run `aiwg init --force` only when you need to recreate the baseline config.');
+            ui.blank();
+            return { exitCode: 0 };
+        }
+        let providers;
+        let scripts = {};
+        if (nonInteractive) {
+            // Non-interactive: use defaults
+            providers = ['claude'];
+            scripts = {
+                deploy: 'aiwg use all',
+                doctor: 'aiwg doctor',
+                sync: 'aiwg sync',
+            };
+        }
+        else {
+            // Interactive wizard
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            try {
+                // Thread ctx.signal through every prompt so Ctrl-C during the wizard
+                // cancels cleanly instead of being absorbed by readline (POC #926).
+                providers = await askProviders(rl, ctx.signal);
+                console.log('');
+                const addScripts = await askYesNo(rl, '  Add default scripts (deploy, doctor, sync)? [Y/n]: ', true, ctx.signal);
+                if (addScripts) {
+                    scripts = {
+                        deploy: 'aiwg use all',
+                        doctor: 'aiwg doctor',
+                        sync: 'aiwg sync',
+                    };
+                    const addCustom = await askYesNo(rl, '  Add a custom script? [y/N]: ', false, ctx.signal);
+                    if (addCustom) {
+                        const name = await askString(rl, '  Script name: ', '', ctx.signal);
+                        const cmd = await askString(rl, '  Command: ', '', ctx.signal);
+                        if (name && cmd) {
+                            scripts[name] = cmd;
+                        }
+                    }
+                }
+            }
+            finally {
+                rl.close();
+            }
+        }
+        // Build config
+        let config = emptyConfig(providers);
+        config.scripts = scripts;
+        // Populate deployedTo from disk for entries with empty deployedTo (#721)
+        config = await populateDeployedTo(config, projectDir);
+        // Write
+        await writeAiwgConfig(projectDir, config);
+        const normalizedAiwgMdPath = await writeNormalizedAiwgMd(projectDir);
+        const workspace = await ensureWorkspaceContext(projectDir);
+        ui.blank();
+        ui.success(`Created ${getConfigPath(projectDir)}`);
+        ui.success(`Created ${normalizedAiwgMdPath}`);
+        ui.success(`${workspace.action === 'created' ? 'Created' : 'Preserved'} WORKSPACE.md`);
+        ui.success(`Providers: ${providers.join(', ')}`);
+        if (Object.keys(scripts).length > 0) {
+            ui.success(`Scripts: ${Object.keys(scripts).join(', ')}`);
+        }
+        ui.blank();
+        console.log('  Next steps:');
+        console.log('    Ask your AIWG agent: "Help me set up this project for AIWG."');
+        console.log('    The agent may use `aiwg setup project --dry-run` to preview policy choices.');
+        console.log('    aiwg use sdlc                 Deploy SDLC framework to configured providers');
+        console.log('    aiwg run                      List all defined scripts');
+        ui.blank();
+        return { exitCode: 0 };
+    },
+};
+//# sourceMappingURL=init.js.map

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

@@ -0,0 +1,129 @@
+/**
+ * Install Command Handler
+ *
+ * Implements `aiwg install <ref>` for installing frameworks, addons, and
+ * extensions from Git repositories into the local package cache.
+ *
+ * Supported ref formats:
+ *   owner/name                 → Gitea shorthand (configured host)
+ *   owner/name@v1.2.0          → Gitea shorthand with version
+ *   github:owner/name          → GitHub shorthand
+ *   github:owner/name@v1.2.0   → GitHub shorthand with version
+ *   clawhub:owner/name         → ClawHub / OpenClaw registry
+ *   openclaw:owner/name        → ClawHub alias
+ *   https://...                → direct Git URL
+ *   git@host:owner/name.git    → SSH URL
+ *
+ * @implements #557
+ * @implements #804
+ */
+import path from 'path';
+import { installPackage } from '../../packages/registry.js';
+import { recordDeployment } from '../../packages/package-registry.js';
+import { createScriptRunner } from './script-runner.js';
+import { handlerResultFromError } from '../errors.js';
+import * as ui from '../ui.js';
+function parseFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    return args[idx + 1];
+}
+function hasFlag(args, flag) {
+    return args.includes(flag);
+}
+export const installHandler = {
+    id: 'install',
+    name: 'Install Package',
+    description: 'Install a framework, addon, or extension from a Git repository',
+    category: 'framework',
+    aliases: [],
+    async execute(ctx) {
+        const rawRef = ctx.args[0];
+        if (!rawRef) {
+            return {
+                exitCode: 1,
+                message: [
+                    'Error: Package reference required',
+                    '',
+                    'Usage:',
+                    '  aiwg install owner/name                    # Gitea shorthand',
+                    '  aiwg install github:owner/name             # GitHub shorthand',
+                    '  aiwg install clawhub:owner/name            # ClawHub / OpenClaw registry',
+                    '  aiwg install openclaw:owner/name           # ClawHub alias',
+                    '  aiwg install owner/name@v1.2.0             # Pin to version',
+                    '  aiwg install https://git.example.com/a/b   # Direct URL',
+                    '',
+                    'Options:',
+                    '  --deploy                Deploy immediately after install',
+                    '  --provider <name>       Target provider (claude, copilot, cursor...)',
+                    '  --target <dir>          Project directory to deploy into',
+                    '  --refresh               Force re-pull even if cached',
+                ].join('\n'),
+            };
+        }
+        const deploy = hasFlag(ctx.args, '--deploy');
+        const refresh = hasFlag(ctx.args, '--refresh');
+        const provider = parseFlag(ctx.args, '--provider') ?? 'claude';
+        const target = parseFlag(ctx.args, '--target') ?? ctx.cwd;
+        ui.blank();
+        console.log(`  ${ui.brandMark()} ${ui.bold('aiwg install')}  ${ui.dimText(rawRef)}`);
+        ui.rule();
+        // Fetch package
+        ui.info(`Resolving ${rawRef}...`);
+        let cachePath;
+        let key;
+        let type;
+        let namespace;
+        try {
+            ({ cachePath, key, type, namespace } = await installPackage(rawRef, { refresh }));
+        }
+        catch (error) {
+            // Preserve AiwgError.exitCode while keeping the "Error: " prefix users
+            // are used to seeing from `aiwg install`.
+            const result = handlerResultFromError(error);
+            return { ...result, message: `Error: ${result.message}` };
+        }
+        ui.success(`Installed: ${key} (${type})`);
+        ui.dimText(`  Cache: ${cachePath}`);
+        if (namespace !== 'aiwg') {
+            ui.dimText(`  Namespace: ${namespace}`);
+        }
+        // Optionally deploy
+        if (deploy) {
+            ui.info(`Deploying ${key} to ${provider}...`);
+            const runner = createScriptRunner(ctx.frameworkRoot);
+            const deployArgs = [
+                '--source', cachePath,
+                '--deploy-commands',
+                '--deploy-skills',
+                '--deploy-rules',
+                '--provider', provider,
+                '--target', target,
+                '--namespace', namespace,
+                '--quiet',
+            ];
+            const deployResult = await runner.run('tools/agents/deploy-agents.mjs', deployArgs, { capture: true });
+            if (deployResult.exitCode !== 0) {
+                ui.warn(`Deploy failed (exit ${deployResult.exitCode})`);
+                if (deployResult.message)
+                    ui.dim(`  ${deployResult.message}`);
+            }
+            else {
+                ui.success(`Deployed to ${provider} in ${path.relative(process.cwd(), target) || '.'}`);
+                // Record deployment
+                await recordDeployment(key, {
+                    projectPath: target,
+                    provider,
+                    deployedAt: new Date().toISOString(),
+                });
+            }
+        }
+        ui.blank();
+        if (!deploy) {
+            ui.info(`To deploy: aiwg use ${key.split('/').pop() ?? key}`);
+        }
+        return { exitCode: 0 };
+    },
+};
+//# sourceMappingURL=install.js.map

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

@@ -0,0 +1,46 @@
+/**
+ * Issue command handler.
+ *
+ * Routes `aiwg issue ...` to the local issue CLI. External tracker operations
+ * remain governed by `.aiwg/aiwg.config` `remotes.issue_tracker`.
+ *
+ * @issue #1462
+ */
+import { handlerResultFromError } from '../errors.js';
+export const issueHandler = {
+    id: 'issue',
+    name: 'Issue',
+    description: 'Local issue storage commands under .aiwg/issues/',
+    category: 'project',
+    aliases: ['issues'],
+    async execute(ctx) {
+        try {
+            const { main } = await import('../../issues/cli.js');
+            await main(ctx.args, ctx.cwd);
+            return { exitCode: 0 };
+        }
+        catch (error) {
+            const result = handlerResultFromError(error);
+            return { ...result, message: `Issue command failed: ${result.message}` };
+        }
+    },
+};
+export const issueAuditHandler = {
+    id: 'issue-audit',
+    name: 'Issue Audit',
+    description: 'Audit local issues under .aiwg/issues/ when --provider local is supplied',
+    category: 'project',
+    aliases: ['audit-issues'],
+    async execute(ctx) {
+        try {
+            const { auditLocalIssuesCli } = await import('../../issues/workflows.js');
+            await auditLocalIssuesCli(ctx.args, ctx.cwd);
+            return { exitCode: 0 };
+        }
+        catch (error) {
+            const result = handlerResultFromError(error);
+            return { ...result, message: `Issue audit failed: ${result.message}` };
+        }
+    },
+};
+//# sourceMappingURL=issues.js.map