aiwcli 0.15.7 → 0.17.0

package/dist/capabilities/launch/runtime-core/launch-decisions.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Pure decision functions extracted from execute-launch.ts.
+ * No side effects — all functions are deterministic string/config transforms.
+ */
+import type { LaunchResult } from '../../../platform/launch.js';
+import type { InlineFallbackContext, JsonLaunchResult, LaunchFlags, SessionRequestParams, SplitRequestParams, ToolConfig, ToolMode } from '../contracts.js';
+export declare const QUICK_EXIT_THRESHOLD_MS = 10000;
+/**
+ * Return the debug message for tool mode, or undefined if none (claude has no special message).
+ */
+export declare function resolveToolModeDebugMessage(toolMode: ToolMode): string | undefined;
+/**
+ * Format version check results into debug lines and an optional warning.
+ */
+export declare function formatVersionCheckMessages(versionCheck: {
+    compatible: boolean;
+    version?: null | string;
+    warning?: string;
+}): {
+    debugLines: string[];
+    warning?: string | undefined;
+};
+/**
+ * Format the success message after a split pane launch.
+ */
+export declare function formatSplitSuccessMessage(backend: string, handle?: string): string;
+/**
+ * Format the info message when launching in a session.
+ */
+export declare function formatSessionLaunchMessage(backend: string, sessionName: string, reattach: boolean): string;
+/**
+ * Determine which CLI tool to launch and its configuration.
+ */
+export declare function resolveToolConfig(flags: Pick<LaunchFlags, 'codex' | 'devin'>, platform: NodeJS.Platform): ToolConfig;
+/**
+ * Decide the informational message to log when falling back to inline mode.
+ */
+export declare function resolveInlineFallbackMessage(ctx: InlineFallbackContext): string;
+/**
+ * Build the args array for an inline process spawn.
+ * Always returns a new array — never mutates input.
+ */
+export declare function buildInlineArgs(cliArgs: readonly string[], toolMode: ToolMode, promptText: string | undefined, promptPath: string | undefined): string[];
+/**
+ * Build split pane parameters.
+ * Returns a new toolArgs array — fixes the cliArgs mutation bug.
+ */
+export declare function buildSplitRequest(params: {
+    cliArgs: readonly string[];
+    cwd: string;
+    effectivePromptPath: string | undefined;
+    extraEnv: Record<string, string>;
+    retryOnQuickExit: boolean;
+    sentinelPath: string;
+    split: 'auto' | 'horizontal' | 'vertical';
+    toolMode: ToolMode;
+}): SplitRequestParams;
+/**
+ * Build session creation parameters.
+ */
+export declare function buildSessionRequest(params: {
+    cliArgs: readonly string[];
+    cwd: string;
+    now: number;
+    pid: number;
+    promptPath: string | undefined;
+    promptText: string | undefined;
+    tmuxSessionFlag: string | undefined;
+    toolMode: ToolMode;
+}): SessionRequestParams;
+/**
+ * Decide warning message when session creation fails and we fall back inline.
+ */
+export declare function resolveSessionFallbackWarning(backend: string, reason: string | undefined): string;
+/**
+ * Pure timing decision for retry logic.
+ */
+export declare function shouldRetry(elapsedMs: number, threshold?: number): boolean;
+/**
+ * Convert a LaunchResult to JSON-serializable form.
+ */
+export declare function toJsonLaunchResult(result: LaunchResult, exitCode: null | number): JsonLaunchResult;

package/dist/capabilities/launch/runtime-core/launch-decisions.js

@@ -0,0 +1,202 @@
+/**
+ * Pure decision functions extracted from execute-launch.ts.
+ * No side effects — all functions are deterministic string/config transforms.
+ */
+import path from 'node:path';
+import { buildUniqueSessionName, sanitizeSessionName } from './launch-options.js';
+export const QUICK_EXIT_THRESHOLD_MS = 10_000;
+/**
+ * Return the debug message for tool mode, or undefined if none (claude has no special message).
+ */
+export function resolveToolModeDebugMessage(toolMode) {
+    if (toolMode === 'codex')
+        return 'Launching Codex with --yolo flag';
+    if (toolMode === 'devin')
+        return 'Launching Devin with --permission-mode dangerous';
+    return undefined;
+}
+/**
+ * Format version check results into debug lines and an optional warning.
+ */
+export function formatVersionCheckMessages(versionCheck) {
+    return {
+        debugLines: [
+            `Claude Code version: ${versionCheck.version ?? 'unknown'}`,
+            `Compatibility status: ${versionCheck.compatible ? 'compatible' : 'incompatible'}`,
+        ],
+        ...(versionCheck.warning ? { warning: versionCheck.warning } : {}),
+    };
+}
+/**
+ * Format the success message after a split pane launch.
+ */
+export function formatSplitSuccessMessage(backend, handle) {
+    if (handle) {
+        return `Launched in ${backend} pane: ${handle}`;
+    }
+    return `Launched in ${backend}`;
+}
+/**
+ * Format the info message when launching in a session.
+ */
+export function formatSessionLaunchMessage(backend, sessionName, reattach) {
+    if (reattach) {
+        return `Launching in ${backend} session: ${sessionName} (reuse/attach)`;
+    }
+    return `Launching in new ${backend} session: ${sessionName}`;
+}
+function buildCodexArgs(platform) {
+    if (platform !== 'win32')
+        return ['--yolo'];
+    return ['-c', 'shell_type="bash"', '--yolo'];
+}
+function buildDevinArgs() {
+    return ['--permission-mode', 'dangerous'];
+}
+/**
+ * Determine which CLI tool to launch and its configuration.
+ */
+export function resolveToolConfig(flags, platform) {
+    if (flags.devin) {
+        return {
+            cliCommand: 'devin',
+            cliArgs: buildDevinArgs(),
+            launchFlag: '--devin',
+            toolMode: 'devin',
+            retryOnQuickExit: true,
+            needsLspPatch: false,
+            skipVersionCheck: true,
+        };
+    }
+    if (flags.codex) {
+        return {
+            cliCommand: 'codex',
+            cliArgs: buildCodexArgs(platform),
+            launchFlag: '--codex',
+            toolMode: 'codex',
+            retryOnQuickExit: false,
+            needsLspPatch: false,
+            skipVersionCheck: true,
+        };
+    }
+    return {
+        cliCommand: 'claude',
+        cliArgs: ['--dangerously-skip-permissions'],
+        launchFlag: '',
+        toolMode: 'claude',
+        retryOnQuickExit: false,
+        needsLspPatch: platform === 'win32',
+        skipVersionCheck: false,
+    };
+}
+/**
+ * Decide the informational message to log when falling back to inline mode.
+ */
+export function resolveInlineFallbackMessage(ctx) {
+    if (!ctx.hasMux) {
+        if (ctx.disableMux) {
+            return 'Multiplexer disabled via --no-tmux — launching inline';
+        }
+        if (!ctx.interactiveTty) {
+            return 'Non-interactive terminal — launching inline';
+        }
+        if (ctx.platform === 'win32') {
+            return 'No multiplexer found — launching inline. Run inside WezTerm or install psmux for session management.';
+        }
+        return 'No multiplexer found — launching inline. Install tmux for session management.';
+    }
+    return ctx.resolvedReason ?? 'Launching inline';
+}
+/**
+ * Build the args array for an inline process spawn.
+ * Always returns a new array — never mutates input.
+ */
+export function buildInlineArgs(cliArgs, toolMode, promptText, promptPath) {
+    if (toolMode === 'devin' && promptPath) {
+        return [...cliArgs, '--prompt-file', promptPath];
+    }
+    if (promptText) {
+        return [...cliArgs, promptText];
+    }
+    return [...cliArgs];
+}
+/**
+ * Build split pane parameters.
+ * Returns a new toolArgs array — fixes the cliArgs mutation bug.
+ */
+export function buildSplitRequest(params) {
+    let toolArgs;
+    let splitPromptPath;
+    if (params.toolMode === 'devin' && params.effectivePromptPath) {
+        toolArgs = [...params.cliArgs, '--prompt-file', params.effectivePromptPath];
+        splitPromptPath = undefined;
+    }
+    else {
+        toolArgs = [...params.cliArgs];
+        splitPromptPath = params.effectivePromptPath;
+    }
+    return {
+        toolArgs,
+        splitPromptPath,
+        env: params.extraEnv,
+        cwd: params.cwd,
+        mode: 'repl',
+        split: params.split,
+        sentinelPath: params.sentinelPath,
+        holdPane: false,
+        retryOnQuickExit: params.retryOnQuickExit,
+    };
+}
+/**
+ * Build session creation parameters.
+ */
+export function buildSessionRequest(params) {
+    const sessionFromFlag = params.tmuxSessionFlag?.trim();
+    const reattach = Boolean(sessionFromFlag && sessionFromFlag.length > 0);
+    const sessionName = reattach
+        ? sanitizeSessionName(sessionFromFlag)
+        : buildUniqueSessionName(`aiw-${path.basename(params.cwd)}`, params.now, params.pid);
+    const toolArgs = params.toolMode === 'devin' && params.promptPath
+        ? [...params.cliArgs, '--prompt-file', params.promptPath]
+        : [...params.cliArgs];
+    const promptText = params.toolMode === 'devin' ? undefined : params.promptText;
+    return { sessionName, reattach, toolArgs, promptText };
+}
+/**
+ * Decide warning message when session creation fails and we fall back inline.
+ */
+export function resolveSessionFallbackWarning(backend, reason) {
+    if (!reason)
+        return 'Session creation failed — launching inline';
+    if (reason.includes('not found') || reason.includes('unavailable')) {
+        const hint = backend === 'psmux' ? ' Install with: winget install psmux' : '';
+        return `${backend} unavailable — launching inline.${hint}`;
+    }
+    if (reason.includes('too old')) {
+        const hint = backend === 'psmux' ? ' Update with: winget upgrade psmux' : '';
+        return `${reason} — launching inline.${hint}`;
+    }
+    if (backend === 'psmux' && reason.includes('attach failed')) {
+        return `${reason} — launching inline. Recovery: run "psmux kill-server" and relaunch if this persists.`;
+    }
+    return `${reason} — launching inline`;
+}
+/**
+ * Pure timing decision for retry logic.
+ */
+export function shouldRetry(elapsedMs, threshold = QUICK_EXIT_THRESHOLD_MS) {
+    return elapsedMs < threshold;
+}
+/**
+ * Convert a LaunchResult to JSON-serializable form.
+ */
+export function toJsonLaunchResult(result, exitCode) {
+    return {
+        launched: result.launched,
+        backend: result.backend,
+        handle: result.handle ?? null,
+        sentinelPath: result.sentinelPath ?? null,
+        exitCode,
+        reason: result.reason ?? null,
+    };
+}

package/dist/commands/branch.d.ts

@@ -1,4 +1,4 @@
-import BaseCommand from '../lib/base-command.js';
+import BaseCommand from '../cli/base-command.js';
 /**
  * Manage git branch operations: launch in main/master or delete branch and worktree.
  *

package/dist/commands/branch.js

@@ -1,7 +1,7 @@
 import { Args, Flags } from '@oclif/core';
 import { createBranchCommandDependencies } from '../capabilities/branch/adapters.js';
 import { executeBranchCommand } from '../capabilities/branch/control-plane.js';
-import BaseCommand from '../lib/base-command.js';
+import BaseCommand from '../cli/base-command.js';
 /**
  * Manage git branch operations: launch in main/master or delete branch and worktree.
  *

package/dist/commands/launch.d.ts

@@ -47,9 +47,4 @@ export default class LaunchCommand extends BaseCommand {
         quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private buildUniqueSessionName;
-    private handleJsonOutput;
-    private sanitizeSessionName;
-    private shellQuote;
-    private waitForSentinel;
 }

package/dist/commands/launch.js

@@ -2,9 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import * as os from 'node:os';
 import { Flags } from '@oclif/core';
 import { executeLaunch } from '../capabilities/launch/control-plane/execute-launch.js';
-import { buildUniqueSessionName, sanitizeSessionName } from '../capabilities/launch/runtime-core/launch-options.js';
 import BaseCommand from '../cli/base-command.js';
-import { quoteForSh, readSentinelExitCode, waitForSentinelFile } from '../platform/launch.js';
 /**
  * Launch Claude Code, Codex, or Devin with AIW configuration.
  *
@@ -115,8 +113,8 @@ export default class LaunchCommand extends BaseCommand {
             required: false,
         }),
         split: Flags.string({
-            description: 'Split direction when in tmux (auto|h|v, default: auto)',
-            options: ['auto', 'h', 'v'],
+            description: 'Split direction when in multiplexer (auto|horizontal|vertical, default: auto)',
+            options: ['auto', 'horizontal', 'vertical'],
             required: false,
         }),
         'tmux-session': Flags.string({
@@ -155,37 +153,4 @@ export default class LaunchCommand extends BaseCommand {
             },
         });
     }
-    // Compatibility wrappers kept on the command prototype while launch
-    // orchestration now lives in the capability control-plane.
-    buildUniqueSessionName(base) {
-        return buildUniqueSessionName(base);
-    }
-    async handleJsonOutput(result, wait) {
-        let { exitCode } = result;
-        if (wait && result.launched && result.sentinelPath) {
-            const finished = await waitForSentinelFile(result.sentinelPath, 14_400_000);
-            exitCode = finished ? readSentinelExitCode(result.sentinelPath, 1) : -1;
-        }
-        this.log(JSON.stringify({
-            launched: result.launched,
-            backend: result.backend,
-            paneId: result.paneId ?? null,
-            sentinelPath: result.sentinelPath ?? null,
-            exitCode: exitCode ?? null,
-            reason: result.reason ?? null,
-        }));
-        this.exit(exitCode ?? 0);
-    }
-    sanitizeSessionName(input) {
-        return sanitizeSessionName(input);
-    }
-    shellQuote(input) {
-        return quoteForSh(input);
-    }
-    async waitForSentinel(result) {
-        if (!result.sentinelPath)
-            return;
-        const finished = await waitForSentinelFile(result.sentinelPath, 14_400_000);
-        this.exit(finished ? readSentinelExitCode(result.sentinelPath, 1) : 1);
-    }
 }

package/dist/lib/config.js

@@ -2,7 +2,6 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { debug } from './debug.js';
-import { getAiwDir as getAiwDirFromEnv } from './env-compat.js';
 import { ConfigNotFoundError } from './errors.js';
 /**
  * Resolve AI Workflow CLI home directory.
@@ -10,7 +9,7 @@ import { ConfigNotFoundError } from './errors.js';
  */
 export function getAiwDir() {
     // Try env var first, then default
-    const envHome = getAiwDirFromEnv();
+    const envHome = process.env['AIW_DIR'];
     if (envHome) {
         return envHome;
     }

package/dist/lib/context/context-store.js

@@ -13,6 +13,7 @@ import { getContextDir, getContextsDir, getIndexPath, getArchiveDir, getArchiveC
 import { logInfo, logWarn, logError, setContextPath } from "../runtime/logger.js";
 import { readStateJson, writeStateJson } from "../runtime/state-io.js";
 import { nowIso, generateContextId } from "../runtime/utils.js";
+import { IndexFileSchema } from "../schemas.js";
 const INDEX_VERSION = "3.0";
 // Module-level index cache — safe because each hook is a separate bun process
 let _indexCache = null;
@@ -58,8 +59,15 @@ function loadIndex(projectRoot) {
     if (fs.existsSync(indexPath)) {
         try {
             const raw = fs.readFileSync(indexPath, "utf8");
-            _indexCache = JSON.parse(raw);
-            return _indexCache;
+            const data = JSON.parse(raw);
+            const validated = IndexFileSchema.safeParse(data);
+            if (!validated.success) {
+                logWarn("context_store", `Index schema validation failed, recreating: ${validated.error.message}`);
+            }
+            else {
+                _indexCache = data;
+                return _indexCache;
+            }
         }
         catch (error) {
             logWarn("context_store", `Failed to read index, recreating: ${error}`);
@@ -263,11 +271,29 @@ export function getAllContexts(status, projectRoot) {
     const index = loadIndex(projectRoot);
     const ctxMap = index.contexts;
     if (ctxMap && typeof ctxMap === "object" && Object.keys(ctxMap).length > 0) {
+        const orphanIds = [];
         for (const cid of Object.keys(ctxMap)) {
             const state = loadState(cid, projectRoot);
             if (state && (!status || state.status === status)) {
                 results.push(state);
             }
+            else if (!state) {
+                orphanIds.push(cid);
+            }
+        }
+        if (orphanIds.length > 0) {
+            logWarn("context_store", `Index references ${orphanIds.length} missing context(s): ${orphanIds.join(", ")}. Auto-repairing index.`);
+            const idx = loadIndex(projectRoot);
+            for (const cid of orphanIds) {
+                delete idx.contexts[cid];
+                if (idx.sessions) {
+                    for (const [sid, target] of Object.entries(idx.sessions)) {
+                        if (target === cid)
+                            delete idx.sessions[sid];
+                    }
+                }
+            }
+            saveIndex(idx, projectRoot);
         }
     }
     else {

package/dist/lib/core-installer.d.ts

@@ -2,4 +2,4 @@
  * Install core runtime assets into .aiwcli/_core.
  */
 export declare function installCoreAssets(targetDir: string, ides: string[]): Promise<string[]>;
-export declare function getCoreResolverSourcePath(): string;
+export declare function getCoreResolverSourcePath(): Promise<string>;

package/dist/lib/core-installer.js

@@ -1,9 +1,9 @@
 import { promises as fs } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { join } from 'node:path';
 import { IdePathResolver } from './ide-path-resolver.js';
 import { pathExists } from './paths.js';
-import { copyDir } from './template-installer.js';
+import { copyDir, mergeDirectory } from './template-installer.js';
+import { getTemplatePath } from './template-resolver.js';
 /**
  * Install core runtime assets into .aiwcli/_core.
  */
@@ -12,7 +12,7 @@ export async function installCoreAssets(targetDir, ides) {
     const containerDir = resolver.getAiwcliContainer();
     const coreDir = resolver.getCoreFolder();
     await fs.mkdir(containerDir, { recursive: true });
-    const sourceRoot = getCoreAssetSource();
+    const sourceRoot = await getTemplatePath('core');
     if (!(await pathExists(sourceRoot))) {
         throw new Error(`Core assets not found at ${sourceRoot}. This indicates a corrupted installation.`);
     }
@@ -28,27 +28,6 @@ export async function installCoreAssets(targetDir, ides) {
     }
     return ['_core'];
 }
-export function getCoreResolverSourcePath() {
-    return join(getCoreAssetSource(), 'scripts', 'resolve-run.ts');
-}
-function getCoreAssetSource() {
-    const currentFilePath = fileURLToPath(import.meta.url);
-    const currentDir = dirname(currentFilePath);
-    return join(currentDir, '..', 'templates', 'core');
-}
-async function mergeDirectory(src, dest) {
-    await fs.mkdir(dest, { recursive: true });
-    const entries = await fs.readdir(src, { withFileTypes: true });
-    const operations = entries.map(async (entry) => {
-        const srcPath = join(src, entry.name);
-        const destPath = join(dest, entry.name);
-        if (entry.isDirectory()) {
-            await mergeDirectory(srcPath, destPath);
-            return;
-        }
-        if (!(await pathExists(destPath))) {
-            await fs.copyFile(srcPath, destPath);
-        }
-    });
-    await Promise.all(operations);
+export async function getCoreResolverSourcePath() {
+    return join(await getTemplatePath('core'), 'scripts', 'resolve-run.ts');
 }

package/dist/lib/debug.d.ts

@@ -16,16 +16,6 @@ export declare function setDebugEnabled(enabled: boolean): void;
  * @param message - The message to log
  */
 export declare function debug(message: string): void;
-/**
- * Log configuration details in debug mode.
- * Only logs AIW_DIR path to avoid accidentally logging sensitive data.
- * @param config - Configuration object
- * @param config.aiwDir - AIW_DIR path
- */
-export declare function debugConfig(config: {
-    [key: string]: unknown;
-    aiwDir: string;
-}): void;
 /**
  * Log process spawn details in debug mode.
  * @param command - Command being spawned

package/dist/lib/debug.js

@@ -33,16 +33,6 @@ export function debug(message) {
         }
     }
 }
-/**
- * Log configuration details in debug mode.
- * Only logs AIW_DIR path to avoid accidentally logging sensitive data.
- * @param config - Configuration object
- * @param config.aiwDir - AIW_DIR path
- */
-export function debugConfig(config) {
-    debug(`AIW_DIR resolved to ${config.aiwDir}`);
-    // NOTE: Do NOT log full config - may contain API keys/tokens in future
-}
 /**
  * Log process spawn details in debug mode.
  * @param command - Command being spawned

package/dist/lib/env-sanitizer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Centralized env var management for REPL nesting detection.
+ * Replaces scattered cleanClaudeEnv(), UNSET_NESTING_SH, etc.
+ */
+/**
+ * Env vars set by REPL tools (Claude Code, Codex, Devin) that trigger
+ * nesting detection. Must be cleared when spawning a new REPL pane so
+ * the child tool starts fresh instead of refusing to launch.
+ */
+export declare const REPL_NESTING_VARS: readonly ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT", "CLAUDE_SESSION_ID", "CODEX_THREAD_ID", "AIWCLI_INTERNAL_CALL"];
+/**
+ * Check whether the current process was invoked from a REPL tool.
+ * Must be called BEFORE clearProcessNestingVars().
+ */
+export declare function isCalledFromRepl(): boolean;
+/**
+ * Clear REPL nesting vars from the current process environment.
+ * Call once at orchestrator startup so inline launches don't see them.
+ */
+export declare function clearProcessNestingVars(): void;
+/**
+ * Build a clean process env with nesting vars removed and optional extras merged.
+ * Used for createSession() spawn calls that inherit process.env.
+ */
+export declare function sanitizedProcessEnv(extraEnv?: Record<string, string>): NodeJS.ProcessEnv;

package/dist/lib/env-sanitizer.js

@@ -0,0 +1,46 @@
+/**
+ * Centralized env var management for REPL nesting detection.
+ * Replaces scattered cleanClaudeEnv(), UNSET_NESTING_SH, etc.
+ */
+/**
+ * Env vars set by REPL tools (Claude Code, Codex, Devin) that trigger
+ * nesting detection. Must be cleared when spawning a new REPL pane so
+ * the child tool starts fresh instead of refusing to launch.
+ */
+export const REPL_NESTING_VARS = [
+    'CLAUDECODE',
+    'CLAUDE_CODE_ENTRYPOINT',
+    'CLAUDE_SESSION_ID',
+    'CODEX_THREAD_ID',
+    'AIWCLI_INTERNAL_CALL',
+];
+/**
+ * Check whether the current process was invoked from a REPL tool.
+ * Must be called BEFORE clearProcessNestingVars().
+ */
+export function isCalledFromRepl() {
+    return REPL_NESTING_VARS.some((v) => Boolean(process.env[v]));
+}
+/**
+ * Clear REPL nesting vars from the current process environment.
+ * Call once at orchestrator startup so inline launches don't see them.
+ */
+export function clearProcessNestingVars() {
+    for (const v of REPL_NESTING_VARS) {
+        delete process.env[v];
+    }
+}
+/**
+ * Build a clean process env with nesting vars removed and optional extras merged.
+ * Used for createSession() spawn calls that inherit process.env.
+ */
+export function sanitizedProcessEnv(extraEnv) {
+    const env = {
+        ...process.env,
+        ...extraEnv,
+    };
+    for (const key of REPL_NESTING_VARS) {
+        delete env[key];
+    }
+    return env;
+}

package/dist/lib/errors.d.ts

@@ -111,16 +111,3 @@ export declare class ProcessSpawnError extends AiwError {
     readonly code?: string | undefined;
     constructor(message: string, code?: string | undefined);
 }
-/**
- * Format error message following AI Workflow CLI convention.
- * @param what - Description of what went wrong
- * @param howToFix - Actionable steps to fix the problem
- * @returns Formatted error message in format: "{what}. {howToFix}."
- * @example
- * formatErrorMessage(
- *   'AIW_DIR directory not found',
- *   'Set AIW_DIR env var or run "aiw setup"'
- * )
- * // Returns: "AIW_DIR directory not found. Set AIW_DIR env var or run \"aiw setup\"."
- */
-export declare function formatErrorMessage(what: string, howToFix: string): string;

package/dist/lib/errors.js

@@ -128,18 +128,3 @@ export class ProcessSpawnError extends AiwError {
         this.name = 'ProcessSpawnError';
     }
 }
-/**
- * Format error message following AI Workflow CLI convention.
- * @param what - Description of what went wrong
- * @param howToFix - Actionable steps to fix the problem
- * @returns Formatted error message in format: "{what}. {howToFix}."
- * @example
- * formatErrorMessage(
- *   'AIW_DIR directory not found',
- *   'Set AIW_DIR env var or run "aiw setup"'
- * )
- * // Returns: "AIW_DIR directory not found. Set AIW_DIR env var or run \"aiw setup\"."
- */
-export function formatErrorMessage(what, howToFix) {
-    return `${what}. ${howToFix}.`;
-}

package/dist/lib/git-exclude-manager.js

@@ -9,7 +9,7 @@ const execFileAsync = promisify(execFile);
  */
 const AIW_EXCLUDE_HEADER = '# AIW Installation';
 /** Standard exclude entries managed by AIW */
-export const AIW_EXCLUDE_ENTRIES = ['.aiwcli', '_output', '.claude', '.codex', '.windsurf', '.cognition'];
+export const AIW_EXCLUDE_ENTRIES = ['.aiwcli', '_output', '.claude', '.codex', '.windsurf', '.devin'];
 /** Entries that should NEVER be removed from exclude, even on clear */
 const AIW_PERMANENT_ENTRIES = ['_output'];
 /**

package/dist/lib/hooks/context-monitor-logic.d.ts

@@ -0,0 +1,6 @@
+export declare const CONTEXT_WARNING_30: string;
+export declare const CONTEXT_WARNING_15: string;
+export declare function selectWarningMessage(pctRemaining: number, alreadyFired: number[]): {
+    pct: number;
+    msg: string;
+} | null;