@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

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

@@ -0,0 +1,134 @@
+/**
+ * Version Command Handler
+ *
+ * Displays version and channel information for the AIWG installation.
+ * Supports --verbose / --json for full environment fingerprint (Phase 4.5 #925).
+ *
+ * @implements @.aiwg/architecture/decisions/ADR-001-unified-extension-system.md
+ * @source @src/cli/router.ts
+ * @issue #33, #925
+ */
+import { getVersionInfo } from '../../channel/manager.mjs';
+import { getLoggerInfo } from '../log.js';
+import * as ui from '../ui.js';
+import { maybePrintCommunityFooter } from '../../community/footer.js';
+import { existsSync, statSync, readdirSync } from 'fs';
+import path from 'path';
+/**
+ * Version command handler
+ */
+export const versionHandler = {
+    id: 'version',
+    name: 'Version',
+    description: 'Show version and channel info (--verbose for full env fingerprint, --json for machine-readable)',
+    category: 'maintenance',
+    aliases: ['-version', '--version'],
+    async execute(ctx) {
+        const verbose = ctx.args.includes('--verbose') || ctx.args.includes('-v') || ctx.args.includes('-vv') || ctx.args.includes('-vvv');
+        const json = ctx.args.includes('--json');
+        await displayVersion({ verbose, json });
+        return { exitCode: 0 };
+    },
+};
+function collectFingerprint(versionInfo) {
+    const loggerInfo = getLoggerInfo();
+    const fp = {
+        version: versionInfo.version,
+        channel: versionInfo.devMode ? 'dev' : versionInfo.channel,
+        packageRoot: versionInfo.packageRoot,
+        node: process.version,
+        platform: {
+            os: process.platform,
+            arch: process.arch,
+            release: loggerInfo.provenance.os_release,
+        },
+        tty: {
+            stdin: !!process.stdin.isTTY,
+            stdout: !!process.stdout.isTTY,
+            stderr: !!process.stderr.isTTY,
+        },
+        logger: {
+            level: loggerInfo.level,
+            disabled: loggerInfo.disabled,
+            logFile: loggerInfo.logFile,
+        },
+        invocation_id: loggerInfo.provenance.invocation_id,
+    };
+    if (versionInfo.gitHash) {
+        fp.git = {
+            sha: versionInfo.gitHash,
+            branch: versionInfo.gitBranch ?? '(unknown)',
+            path: versionInfo.edgePath ?? versionInfo.packageRoot,
+        };
+    }
+    // Locale / timezone are useful for timezone-dependent bug reports.
+    try {
+        fp.locale = Intl.DateTimeFormat().resolvedOptions().locale;
+        fp.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    catch { /* ignore */ }
+    // Log file stats — "you've written N records today, file is X MB".
+    if (loggerInfo.logFile && existsSync(loggerInfo.logFile)) {
+        try {
+            fp.logger.logFileSize = statSync(loggerInfo.logFile).size;
+            // Cheap line count via readdirSync of the log directory — not the line
+            // count itself (avoids reading the whole file).
+            const dir = path.dirname(loggerInfo.logFile);
+            const today = new Date().toISOString().slice(0, 10);
+            const file = readdirSync(dir).find(f => f === `aiwg-${today}.jsonl`);
+            if (file) {
+                // Defer actual line count to aiwg diagnose; here we just signal presence.
+                fp.logger.recordsToday = undefined;
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return fp;
+}
+async function displayVersion(opts) {
+    const info = await getVersionInfo();
+    const fp = collectFingerprint(info);
+    if (opts.json) {
+        console.log(JSON.stringify(fp, null, 2));
+        return;
+    }
+    ui.blank();
+    console.log(`  ${ui.brandMark()} ${ui.bold('aiwg')}  ${ui.bold(fp.version)}  ${ui.channelLabel(fp.channel)}`);
+    if (!opts.verbose) {
+        if (fp.git) {
+            ui.dim(`    git: ${fp.git.sha} (${fp.git.branch})`);
+            ui.dim(`    path: ${fp.git.path}`);
+        }
+        else {
+            ui.dim(`    path: ${fp.packageRoot}`);
+        }
+        maybePrintCommunityFooter();
+        ui.blank();
+        return;
+    }
+    // --verbose: the full environment fingerprint.
+    if (fp.git) {
+        ui.dim(`    git:       ${fp.git.sha} (${fp.git.branch})`);
+        ui.dim(`    path:      ${fp.git.path}`);
+    }
+    else {
+        ui.dim(`    path:      ${fp.packageRoot}`);
+    }
+    ui.dim(`    channel:   ${fp.channel}`);
+    ui.dim(`    node:      ${fp.node}`);
+    ui.dim(`    platform:  ${fp.platform.os} ${fp.platform.arch} (${fp.platform.release})`);
+    ui.dim(`    tty:       stdin=${fp.tty.stdin} stdout=${fp.tty.stdout} stderr=${fp.tty.stderr}`);
+    if (fp.locale)
+        ui.dim(`    locale:    ${fp.locale} (TZ=${fp.timezone})`);
+    const logDesc = fp.logger.disabled
+        ? '(disabled via AIWG_LOG_DISABLE)'
+        : fp.logger.logFile
+            ? `${fp.logger.logFile}${fp.logger.logFileSize !== undefined ? ` (${(fp.logger.logFileSize / 1024).toFixed(1)} KB)` : ''}`
+            : '(stderr only)';
+    ui.dim(`    log:       ${logDesc}`);
+    ui.dim(`    level:     ${fp.logger.level}`);
+    ui.dim(`    invocation:${fp.invocation_id}`);
+    maybePrintCommunityFooter();
+    ui.blank();
+}
+//# sourceMappingURL=version.js.map

package/dist/src/cli/handlers/workspace-context.js

@@ -0,0 +1,93 @@
+import { handlerResultFromError } from '../errors.js';
+import { auditWorkspaceContext, diagnoseWorkspaceContext, migrateWorkspaceContext, rollbackWorkspaceContext, } from '../../smiths/context-pipeline/workspace-context.js';
+function printHelp() {
+    console.log(`
+  aiwg workspace-context — Audit and migrate provider context into WORKSPACE.md
+
+  Usage:
+    aiwg workspace-context audit [--json]
+    aiwg workspace-context migrate --dry-run [--json]
+    aiwg workspace-context migrate --apply [--allow-conflicts] [--json]
+    aiwg workspace-context rollback [transaction-id] [--json]
+    aiwg workspace-context doctor [--json]
+
+  Migration is opt-in. Audit and dry-run never write. Apply records source
+  attribution and preimages under .aiwg/context-migrations/ for rollback.
+`);
+}
+export const workspaceContextHandler = {
+    id: 'workspace-context',
+    name: 'Workspace Context',
+    description: 'Audit, migrate, diagnose, and roll back canonical WORKSPACE.md context',
+    category: 'maintenance',
+    aliases: [],
+    async execute(ctx) {
+        try {
+            if (ctx.args.includes('--help') || ctx.args.includes('-h')) {
+                printHelp();
+                return { exitCode: 0 };
+            }
+            const json = ctx.args.includes('--json');
+            const positional = ctx.args.filter((arg) => !arg.startsWith('-'));
+            const action = positional[0] ?? 'audit';
+            if (action === 'audit') {
+                const audit = await auditWorkspaceContext(ctx.cwd);
+                if (json)
+                    console.log(JSON.stringify(audit, null, 2));
+                else {
+                    console.log(`Workspace context audit: ${audit.sources.length} source(s)`);
+                    console.log(`  WORKSPACE.md: ${audit.workspaceExists ? 'present' : audit.legacyCompatible ? 'legacy layout supported' : 'missing'}`);
+                    console.log(`  Identical directives: ${audit.identical.length}`);
+                    console.log(`  Ambiguous conflicts: ${audit.conflicts.length}`);
+                    console.log(`  Sensitive findings: ${audit.sensitiveFindings.length}`);
+                    console.log(`  Planned outputs: ${audit.plan.outputs.join(', ')}`);
+                }
+                return { exitCode: audit.sensitiveFindings.length > 0 ? 1 : 0 };
+            }
+            if (action === 'migrate') {
+                const apply = ctx.args.includes('--apply');
+                const result = await migrateWorkspaceContext(ctx.cwd, {
+                    apply,
+                    dryRun: ctx.args.includes('--dry-run') || !apply,
+                    allowConflicts: ctx.args.includes('--allow-conflicts'),
+                });
+                if (json)
+                    console.log(JSON.stringify(result, null, 2));
+                else {
+                    console.log(`${result.dryRun ? 'Migration dry run' : 'Migration applied'}: ${result.changed ? 'changes found' : 'already canonical'}`);
+                    for (const file of result.written)
+                        console.log(`  ${result.dryRun ? 'would write' : 'wrote'} ${file}`);
+                    if (result.transactionId)
+                        console.log(`  transaction: ${result.transactionId}`);
+                    if (result.backups.length > 0)
+                        console.log(`  recoverable preimages: ${result.backups.length}`);
+                }
+                return { exitCode: 0 };
+            }
+            if (action === 'rollback') {
+                const result = await rollbackWorkspaceContext(ctx.cwd, positional[1]);
+                if (json)
+                    console.log(JSON.stringify(result, null, 2));
+                else
+                    console.log(`Rolled back ${result.id}: restored ${result.restored.length} file(s).`);
+                return { exitCode: 0 };
+            }
+            if (action === 'doctor') {
+                const diagnostics = await diagnoseWorkspaceContext(ctx.cwd);
+                if (json)
+                    console.log(JSON.stringify(diagnostics, null, 2));
+                else
+                    for (const diagnostic of diagnostics)
+                        console.log(`  ${diagnostic.severity.toUpperCase()} ${diagnostic.code}: ${diagnostic.message}`);
+                return { exitCode: diagnostics.some((item) => item.severity === 'error') ? 1 : 0 };
+            }
+            printHelp();
+            return { exitCode: 2, message: `Unknown workspace-context action: ${action}` };
+        }
+        catch (error) {
+            return handlerResultFromError(error);
+        }
+    },
+};
+export const workspaceContextHandlers = [workspaceContextHandler];
+//# sourceMappingURL=workspace-context.js.map

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

@@ -0,0 +1,126 @@
+/**
+ * Workspace Management Handlers
+ *
+ * Handlers for workspace health, migration, and rollback operations.
+ * Delegates to existing CLI scripts in tools/cli/.
+ *
+ * @implements @.aiwg/architecture/decisions/ADR-001-unified-extension-system.md
+ * @source @src/cli/router.ts
+ * @issue #33
+ */
+import { createScriptRunner } from './script-runner.js';
+import { getFrameworkRoot } from '../../channel/manager.mjs';
+import { maybePrintCommunityFooter } from '../../community/footer.js';
+/**
+ * Handler for workspace status command
+ *
+ * Shows workspace health, installed frameworks, and migration status.
+ *
+ * Usage:
+ *   aiwg -status
+ *   aiwg --status
+ *   aiwg -status --verbose
+ *   aiwg -status --json
+ */
+export const statusHandler = {
+    id: 'status',
+    name: 'Workspace Status',
+    description: 'Show workspace health and installed frameworks',
+    category: 'workspace',
+    aliases: ['-status', '--status'],
+    async execute(ctx) {
+        const frameworkRoot = await getFrameworkRoot();
+        const runner = createScriptRunner(frameworkRoot);
+        const result = await runner.run('tools/cli/workspace-status.mjs', ctx.args, {
+            cwd: ctx.cwd,
+        });
+        const machineReadable = ctx.args.includes('--json') || ctx.args.includes('--probe') || ctx.args.includes('--serve') || ctx.args.includes('--export');
+        if (result.exitCode === 0 && !machineReadable) {
+            maybePrintCommunityFooter();
+        }
+        return result;
+    },
+};
+/**
+ * Handler for the guided onboarding wizard.
+ *
+ * The MVP wizard is a deterministic, no-write planner that walks the user
+ * through provider, project, framework, deploy, and verification steps.
+ */
+export const wizardHandler = {
+    id: 'wizard',
+    name: 'Onboarding Wizard',
+    description: 'Guide first-run provider, project, framework, deploy, and verify steps',
+    category: 'workspace',
+    aliases: [],
+    async execute(ctx) {
+        const frameworkRoot = await getFrameworkRoot();
+        const runner = createScriptRunner(frameworkRoot);
+        return runner.run('tools/cli/wizard.mjs', ctx.args, {
+            cwd: ctx.cwd,
+        });
+    },
+};
+/**
+ * Handler for workspace migration command
+ *
+ * Migrates legacy .aiwg/ workspace structure to framework-scoped structure.
+ * Provides interactive migration workflow with validation, backup, and reporting.
+ *
+ * Usage:
+ *   aiwg -migrate-workspace
+ *   aiwg --migrate-workspace
+ *   aiwg -migrate-workspace --dry-run
+ *   aiwg -migrate-workspace --no-backup
+ *   aiwg -migrate-workspace --force
+ *   aiwg -migrate-workspace --yes
+ */
+export const migrateWorkspaceHandler = {
+    id: 'migrate-workspace',
+    name: 'Migrate Workspace',
+    description: 'Migrate legacy .aiwg/ to framework-scoped structure',
+    category: 'workspace',
+    aliases: ['-migrate-workspace', '--migrate-workspace'],
+    async execute(ctx) {
+        const frameworkRoot = await getFrameworkRoot();
+        const runner = createScriptRunner(frameworkRoot);
+        return runner.run('tools/cli/workspace-migrate.mjs', ctx.args, {
+            cwd: ctx.cwd,
+        });
+    },
+};
+/**
+ * Handler for workspace rollback command
+ *
+ * Rolls back workspace migration from backup.
+ *
+ * Usage:
+ *   aiwg -rollback-workspace
+ *   aiwg --rollback-workspace
+ *   aiwg -rollback-workspace --list
+ *   aiwg -rollback-workspace --backup <backup-path>
+ */
+export const rollbackWorkspaceHandler = {
+    id: 'rollback-workspace',
+    name: 'Rollback Workspace',
+    description: 'Rollback workspace migration from backup',
+    category: 'workspace',
+    aliases: ['-rollback-workspace', '--rollback-workspace'],
+    async execute(ctx) {
+        const frameworkRoot = await getFrameworkRoot();
+        const runner = createScriptRunner(frameworkRoot);
+        return runner.run('tools/cli/workspace-rollback.mjs', ctx.args, {
+            cwd: ctx.cwd,
+        });
+    },
+};
+/**
+ * All workspace management handlers
+ */
+export const workspaceHandlers = [
+    statusHandler,
+    wizardHandler,
+    migrateWorkspaceHandler,
+    rollbackWorkspaceHandler,
+];
+//# sourceMappingURL=workspace.js.map

package/dist/src/cli/help-generator.js

@@ -0,0 +1,178 @@
+/**
+ * Help Generator
+ *
+ * Dynamically generates CLI help text from the extension registry.
+ * Replaces hardcoded displayHelp() with registry-driven approach.
+ *
+ * @implements @.aiwg/architecture/decisions/ADR-001-unified-extension-system.md
+ * @tests @test/unit/cli/help-generator.test.ts
+ * @version 1.0.0
+ */
+/**
+ * Category display order and titles
+ *
+ * Determines the order in which command categories appear in help output.
+ */
+const CATEGORY_ORDER = [
+    { category: 'framework', title: 'Framework Management' },
+    { category: 'project', title: 'Project Setup' },
+    { category: 'workspace', title: 'Workspace Management' },
+    { category: 'mcp', title: 'MCP Server' },
+    { category: 'toolsmith', title: 'Toolsmith (Runtime Discovery)' },
+    { category: 'catalog', title: 'Model Catalog' },
+    { category: 'utility', title: 'Utilities' },
+    { category: 'plugin', title: 'Plugin Packaging' },
+    { category: 'scaffolding', title: 'Scaffolding' },
+    { category: 'channel', title: 'Channel Management' },
+    { category: 'maintenance', title: 'Maintenance' },
+    { category: 'ralph', title: 'Agent Loop (Iterative Execution)' },
+    { category: 'orchestration', title: 'Orchestration (Mission Control)' },
+    { category: 'index', title: 'Artifact Index' },
+    { category: 'daemon', title: 'Daemon & Behaviors' },
+    { category: 'agentic-tools', title: 'Agentic Tools (RLM chunk, fanout, search)' },
+];
+/**
+ * Command name column width for alignment
+ */
+const COMMAND_COL_WIDTH = 24;
+/**
+ * Generate help text from registry
+ *
+ * Dynamically builds CLI help text by querying the extension registry for
+ * command extensions, grouping them by category, and formatting them for display.
+ *
+ * @param registry - Extension registry to query
+ * @returns Formatted help text
+ *
+ * @example
+ * ```typescript
+ * import { getRegistry } from '../extensions/registry.js';
+ * import { generateHelp } from './help-generator.js';
+ *
+ * const registry = getRegistry();
+ * const helpText = generateHelp(registry);
+ * console.log(helpText);
+ * ```
+ */
+export function generateHelp(registry) {
+    const lines = [];
+    // Header
+    lines.push('AIWG CLI');
+    lines.push('');
+    lines.push('Usage: aiwg <command> [options]');
+    lines.push('');
+    // Get commands by category (skills are the canonical source format for CLI commands)
+    const commands = [
+        ...registry.getByType('skill'),
+        ...registry.getByType('command'),
+    ];
+    const byCategory = groupByCategory(commands);
+    // Generate sections in order
+    for (const { category, title } of CATEGORY_ORDER) {
+        const categoryCommands = byCategory.get(category);
+        if (!categoryCommands || categoryCommands.length === 0)
+            continue;
+        lines.push(`${title}:`);
+        for (const cmd of categoryCommands) {
+            const name = formatCommandName(cmd);
+            const desc = cmd.description;
+            lines.push(`  ${name.padEnd(COMMAND_COL_WIDTH)} ${desc}`);
+        }
+        lines.push('');
+    }
+    // Platform options
+    lines.push('Platform Options (--provider):');
+    lines.push('  claude                Claude Code (default)');
+    lines.push('  copilot               GitHub Copilot');
+    lines.push('  factory               Factory AI');
+    lines.push('  codex / openai        OpenAI Codex');
+    lines.push('  cursor                Cursor IDE');
+    lines.push('  opencode              OpenCode');
+    lines.push('  warp                  Warp Terminal');
+    lines.push('  windsurf              Windsurf');
+    lines.push('');
+    // Examples
+    lines.push('Examples:');
+    lines.push('  aiwg use sdlc                    Install SDLC framework');
+    lines.push('  aiwg use sdlc --global           Install user assets + lightweight project wiring');
+    lines.push('  aiwg -new                        Create new project');
+    lines.push('  aiwg doctor                      Check installation health');
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Group commands by category
+ *
+ * Takes a flat list of command extensions and organizes them into a Map
+ * keyed by category, with values being arrays of extensions.
+ *
+ * @param commands - Array of command extensions
+ * @returns Map of category to command extensions
+ *
+ * @example
+ * ```typescript
+ * const commands = registry.getByType('command');
+ * const grouped = groupByCategory(commands);
+ *
+ * const frameworkCommands = grouped.get('framework');
+ * console.log(`${frameworkCommands?.length} framework commands`);
+ * ```
+ */
+function groupByCategory(commands) {
+    const map = new Map();
+    for (const cmd of commands) {
+        const category = cmd.category || 'utility';
+        let list = map.get(category);
+        if (!list) {
+            list = [];
+            map.set(category, list);
+        }
+        list.push(cmd);
+    }
+    // Sort commands within each category by ID
+    // Use Array.from to convert values() iterator to array
+    Array.from(map.values()).forEach((list) => {
+        list.sort((a, b) => a.id.localeCompare(b.id));
+    });
+    return map;
+}
+/**
+ * Format command name with primary alias
+ *
+ * Returns a formatted command name string that includes the primary alias
+ * (if present) for display in help text.
+ *
+ * Format:
+ * - No aliases: "command-name"
+ * - With aliases: "command-name, -alias"
+ *
+ * @param cmd - Command extension
+ * @returns Formatted command name string
+ *
+ * @example
+ * ```typescript
+ * // Command with no aliases
+ * const name1 = formatCommandName(useCmd);
+ * // Returns: "use"
+ *
+ * // Command with aliases
+ * const name2 = formatCommandName(newCmd);
+ * // Returns: "new, -new"
+ *
+ * // Command with multiple aliases
+ * const name3 = formatCommandName(helpCmd);
+ * // Returns: "help, -h"
+ * ```
+ */
+function formatCommandName(cmd) {
+    // Get aliases from metadata
+    const metadata = cmd.metadata;
+    const aliases = metadata?.aliases || [];
+    // If no aliases, just return ID
+    if (aliases.length === 0) {
+        return cmd.id;
+    }
+    // Show command name with first alias
+    return `${cmd.id}, ${aliases[0]}`;
+}
+//# sourceMappingURL=help-generator.js.map

package/dist/src/cli/hooks/builtin/activity-log-hook.js

@@ -0,0 +1,126 @@
+/**
+ * Activity-log auto-append hook
+ *
+ * Post-command hook that automatically appends an activity-log entry
+ * after qualifying CLI commands succeed. Closes the discipline gap
+ * called out in the activity-log rule:
+ *
+ *   "Subagents silently create and delete artifacts with no record
+ *   visible to the parent orchestrator"
+ *
+ * Failures are non-blocking: if the entry can't be written, we log to
+ * stderr and let the primary command's success stand.
+ *
+ * @design @.aiwg/architecture/storage-design.md
+ * @issue #934
+ * @issue #978
+ */
+import { formatEntry } from '../../../activity-log/types.js';
+import { resolveStorage } from '../../../storage/index.js';
+const LOG_PATH = 'activity.log';
+/**
+ * Map of CLI command id → operation token. Commands not in this map
+ * skip the hook (most reads, queries, scaffolding helpers, etc.).
+ */
+const COMMAND_OPERATION_MAP = {
+    // Framework deployment
+    use: 'deploy',
+    refresh: 'deploy',
+    remove: 'delete',
+    // Extension scaffolding
+    'add-agent': 'create',
+    'add-command': 'create',
+    'add-skill': 'create',
+    'add-template': 'create',
+    'add-behavior': 'create',
+    // Validation
+    'validate-metadata': 'lint',
+    // Index updates
+    index: 'update', // Note: 'aiwg index build' is the primary mutating subcommand
+    // Ops ecosystem
+    ops: 'create', // crude — `aiwg ops init` creates; `push`/`adopt` also mutate
+};
+/**
+ * Build a one-line summary from the command + args. Bounded to ≤120
+ * chars per the activity-log rule.
+ */
+function summarize(command, args) {
+    const argString = args.join(' ').trim();
+    const base = argString.length > 0 ? `aiwg ${command} ${argString}` : `aiwg ${command}`;
+    if (base.length <= 120)
+        return base;
+    return base.slice(0, 117) + '...';
+}
+/**
+ * Returns true when AIWG_SKIP_ACTIVITY_LOG is set to a truthy value.
+ * Mirrors the gate in src/activity-log/cli.ts (#975).
+ */
+function isActivityLogSkipped() {
+    const raw = process.env['AIWG_SKIP_ACTIVITY_LOG'];
+    if (!raw)
+        return false;
+    const v = raw.toLowerCase().trim();
+    if (v === '0' || v === 'false' || v === '')
+        return false;
+    return true;
+}
+export const activityLogPostCommandHook = {
+    id: 'aiwg:activity-log-auto-append',
+    event: 'post-command',
+    priority: 100,
+    filter: {
+        // Only fire for the commands we know how to summarize. The map above
+        // is the source of truth.
+        commands: Object.keys(COMMAND_OPERATION_MAP),
+    },
+    async execute(ctx) {
+        // Skip on env-var opt-out
+        if (isActivityLogSkipped()) {
+            return { action: 'continue' };
+        }
+        // Skip if the command failed (post-command runs even on failure for
+        // some hook flows; we never want to log a failure as a successful op)
+        const exitCode = ctx.data?.['exitCode'];
+        if (typeof exitCode === 'number' && exitCode !== 0) {
+            return { action: 'continue' };
+        }
+        const operation = COMMAND_OPERATION_MAP[ctx.command];
+        if (!operation) {
+            // Filter should prevent this, but defensive
+            return { action: 'continue' };
+        }
+        try {
+            const adapter = await resolveStorage('activity_log');
+            const line = formatEntry({
+                timestamp: new Date(),
+                operation,
+                summary: summarize(ctx.command, ctx.args),
+            }) + '\n';
+            // Prefer atomic append (#976) when available
+            if (typeof adapter.append === 'function') {
+                const existing = (await adapter.read(LOG_PATH)) ?? '';
+                if (existing.length > 0 && !existing.endsWith('\n')) {
+                    await adapter.append(LOG_PATH, '\n');
+                }
+                await adapter.append(LOG_PATH, line);
+            }
+            else {
+                const existing = (await adapter.read(LOG_PATH)) ?? '';
+                const trailing = existing.length === 0 || existing.endsWith('\n') ? '' : '\n';
+                await adapter.write(LOG_PATH, existing + trailing + line);
+            }
+        }
+        catch (err) {
+            // Non-blocking — log to stderr and let the primary command's
+            // success stand. Per the activity-log rule's "Rule 4: Non-Blocking".
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`activity-log auto-append failed (non-fatal): ${msg}\n`);
+        }
+        return { action: 'continue' };
+    },
+};
+/**
+ * The list of commands the hook fires for. Exported for tests.
+ */
+export const HOOKED_COMMANDS = Object.keys(COMMAND_OPERATION_MAP);
+//# sourceMappingURL=activity-log-hook.js.map