aiwcli 0.15.5 → 0.17.0

package/dist/lib/shell-adapters/bash-adapter.js

@@ -0,0 +1,69 @@
+/**
+ * BashAdapter — ShellAdapter for bash (Unix + MSYS2/Git Bash on Windows).
+ * Delegates to low-level primitives in shell-quoting.ts, sentinel-wrapper.ts, etc.
+ */
+import { REPL_NESTING_VARS } from '../env-sanitizer.js';
+import { execFileAsync, findExecutable } from '../runtime/subprocess-utils.js';
+import { wrapSentinelSh } from '../sentinel-wrapper.js';
+import { quoteForSh } from '../shell-quoting.js';
+import { toMsysPosixPath } from '../tmux-primitives.js';
+export class BashAdapter {
+    dialect = 'bash';
+    quote(value) {
+        return quoteForSh(value);
+    }
+    buildEnvPreamble(env) {
+        return Object.entries(env)
+            .map(([key, value]) => `${key}=${this.quote(value)}`)
+            .join(' ');
+    }
+    buildToolCommand(params) {
+        const { toolPath, args, env, mode, promptPath, promptText } = params;
+        const envPrefix = this.buildEnvPreamble(env);
+        const commandArgs = this.appendPromptArg(args, mode, promptText);
+        const argPart = commandArgs.map((arg) => this.quote(arg)).join(' ');
+        const base = [envPrefix, this.quote(toolPath), argPart]
+            .filter(Boolean)
+            .join(' ');
+        if (mode === 'exec' && promptPath) {
+            return `${base} < ${this.quote(promptPath)}`;
+        }
+        return base;
+    }
+    wrapSentinel(params) {
+        return wrapSentinelSh(params);
+    }
+    async resolveToolPath(toolName, nativePath) {
+        if (process.platform !== 'win32')
+            return nativePath;
+        // On Windows, resolve tool from bash's perspective (MSYS2/Git Bash PATH)
+        const bash = findExecutable('bash');
+        if (!bash)
+            return null;
+        const result = await execFileAsync(bash, ['-lc', `command -v ${toolName}`], {
+            timeout: 3000,
+            env: { ...process.env, MSYS_NO_PATHCONV: '1' },
+        });
+        return result.exitCode === 0 ? result.stdout.trim() || null : null;
+    }
+    buildNestingCleanup() {
+        const pathFix = 'export PATH="/usr/bin:/usr/local/bin:/mingw64/bin:$PATH";';
+        const unset = `unset ${REPL_NESTING_VARS.join(' ')};`;
+        return `${pathFix} ${unset}`;
+    }
+    normalizeCwd(cwd) {
+        return toMsysPosixPath(cwd);
+    }
+    wrapQuickExitRetry(command, toolPath, thresholdSec = 10) {
+        const warmup = `${toolPath} --version >/dev/null 2>&1`;
+        return `${warmup}; _qr_t0=$SECONDS; ${command}; if [ $((SECONDS - _qr_t0)) -lt ${thresholdSec} ]; then ${command}; fi`;
+    }
+    encodeForExecution(command) {
+        return command;
+    }
+    appendPromptArg(args, mode, promptText) {
+        if (mode !== 'repl' || promptText === undefined)
+            return args;
+        return [...args, promptText];
+    }
+}

package/dist/lib/shell-adapters/index.d.ts

@@ -0,0 +1,5 @@
+export { BashAdapter } from './bash-adapter.js';
+export { PowerShellAdapter } from './powershell-adapter.js';
+export type { SentinelWrapOptions, ShellAdapter, ToolCommandParams } from './shell-adapter.js';
+import type { ShellAdapter } from './shell-adapter.js';
+export declare function shellAdapterForBackend(backend: string): ShellAdapter;

package/dist/lib/shell-adapters/index.js

@@ -0,0 +1,7 @@
+export { BashAdapter } from './bash-adapter.js';
+export { PowerShellAdapter } from './powershell-adapter.js';
+import { BashAdapter } from './bash-adapter.js';
+import { PowerShellAdapter } from './powershell-adapter.js';
+export function shellAdapterForBackend(backend) {
+    return backend === 'psmux' ? new PowerShellAdapter() : new BashAdapter();
+}

package/dist/lib/shell-adapters/powershell-adapter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * PowerShellAdapter — ShellAdapter for PowerShell (Windows, psmux backend).
+ * Delegates to low-level primitives in shell-quoting.ts, sentinel-wrapper.ts, etc.
+ */
+import type { SentinelWrapOptions, ShellAdapter, ToolCommandParams } from './shell-adapter.js';
+export declare class PowerShellAdapter implements ShellAdapter {
+    readonly dialect: "powershell";
+    quote(value: string): string;
+    buildEnvPreamble(env: Record<string, string>): string;
+    buildToolCommand(params: ToolCommandParams): string;
+    wrapSentinel(params: SentinelWrapOptions): string;
+    resolveToolPath(_toolName: string, nativePath: string): Promise<string | null>;
+    buildNestingCleanup(): string;
+    normalizeCwd(cwd: string): string;
+    wrapQuickExitRetry(command: string, _toolPath: string, _thresholdSec?: number): string;
+    encodeForExecution(command: string): string;
+    private appendPromptArg;
+}

package/dist/lib/shell-adapters/powershell-adapter.js

@@ -0,0 +1,62 @@
+/**
+ * PowerShellAdapter — ShellAdapter for PowerShell (Windows, psmux backend).
+ * Delegates to low-level primitives in shell-quoting.ts, sentinel-wrapper.ts, etc.
+ */
+import path from 'node:path';
+import { REPL_NESTING_VARS } from '../env-sanitizer.js';
+import { buildBootstrapPrompt } from '../mux-utils.js';
+import { wrapSentinelPowerShell } from '../sentinel-wrapper.js';
+import { quoteForPowerShell, toEncodedPowerShell } from '../shell-quoting.js';
+export class PowerShellAdapter {
+    dialect = 'powershell';
+    quote(value) {
+        return quoteForPowerShell(value);
+    }
+    buildEnvPreamble(env) {
+        return Object.entries(env)
+            .map(([key, value]) => `$env:${key}=${this.quote(value)}`)
+            .join('; ');
+    }
+    buildToolCommand(params) {
+        const { toolPath, args, env, mode, promptPath } = params;
+        const envPrefix = this.buildEnvPreamble(env);
+        const commandArgs = this.appendPromptArg(args, mode, promptPath);
+        const argArray = commandArgs.map((arg) => this.quote(arg)).join(', ');
+        const invocation = `& ${this.quote(toolPath)}${argArray ? ` @(${argArray})` : ''}`;
+        const body = mode === 'exec' && promptPath
+            ? `Get-Content -Raw -Path ${this.quote(promptPath)} | ${invocation}`
+            : invocation;
+        return [envPrefix, body].filter(Boolean).join('; ');
+    }
+    wrapSentinel(params) {
+        return wrapSentinelPowerShell(params);
+    }
+    async resolveToolPath(_toolName, nativePath) {
+        return nativePath;
+    }
+    buildNestingCleanup() {
+        return REPL_NESTING_VARS
+            .map((v) => `Remove-Item Env:\\${v} -ErrorAction SilentlyContinue`)
+            .join('; ') + ';';
+    }
+    normalizeCwd(cwd) {
+        return cwd;
+    }
+    wrapQuickExitRetry(command, _toolPath, _thresholdSec) {
+        // Quick-exit retry not implemented for PowerShell — inline retry handles it
+        return command;
+    }
+    encodeForExecution(command) {
+        return toEncodedPowerShell(command);
+    }
+    appendPromptArg(args, mode, promptPath) {
+        if (mode !== 'repl' || !promptPath)
+            return args;
+        const absolutePromptPath = path.resolve(promptPath);
+        const formatted = process.platform === 'win32'
+            ? absolutePromptPath.replaceAll('\\', '/')
+            : absolutePromptPath;
+        const bootstrap = buildBootstrapPrompt(formatted);
+        return [...args, bootstrap];
+    }
+}

package/dist/lib/shell-adapters/shell-adapter.d.ts

@@ -0,0 +1,45 @@
+/**
+ * ShellAdapter interface — abstracts shell-dialect differences for command building.
+ * BashAdapter and PowerShellAdapter implement this for their respective shells.
+ */
+export interface ToolCommandParams {
+    toolPath: string;
+    args: string[];
+    env: Record<string, string>;
+    mode: 'exec' | 'repl';
+    promptPath?: string | undefined;
+    promptText?: string | undefined;
+}
+export interface SentinelWrapOptions {
+    command: string;
+    sentinelPath: string;
+    autoClose: boolean;
+    autoCloseCommand?: string | undefined;
+    holdPane: boolean;
+    holdMessage: string;
+}
+export interface ShellAdapter {
+    readonly dialect: 'bash' | 'powershell';
+    /** Quote a value for safe inclusion in a shell command. */
+    quote(value: string): string;
+    /** Build env var assignments as a command preamble (KEY=val for bash, $env:KEY=val for PS). */
+    buildEnvPreamble(env: Record<string, string>): string;
+    /** Build a complete tool invocation command (env + tool + args + prompt handling). */
+    buildToolCommand(params: ToolCommandParams): string;
+    /** Wrap a command with sentinel exit-code tracking and optional pane hold. */
+    wrapSentinel(params: SentinelWrapOptions): string;
+    /**
+     * Resolve a tool path for the shell dialect.
+     * On Windows with bash, resolves via `command -v` in bash.
+     * On Unix or PowerShell, returns nativePath as-is.
+     */
+    resolveToolPath(toolName: string, nativePath: string): Promise<string | null>;
+    /** Build a shell snippet that clears REPL nesting env vars. */
+    buildNestingCleanup(): string;
+    /** Normalize a cwd path for the shell dialect (e.g. Windows→POSIX for bash). */
+    normalizeCwd(cwd: string): string;
+    /** Wrap a command with warmup + quick-exit retry logic. */
+    wrapQuickExitRetry(command: string, toolPath: string, thresholdSec?: number): string;
+    /** Encode a command for safe execution (identity for bash, Base64 for PowerShell). */
+    encodeForExecution(command: string): string;
+}

package/dist/lib/shell-adapters/shell-adapter.js

@@ -0,0 +1,5 @@
+/**
+ * ShellAdapter interface — abstracts shell-dialect differences for command building.
+ * BashAdapter and PowerShellAdapter implement this for their respective shells.
+ */
+export {};

package/dist/lib/shell-quoting.d.ts

@@ -0,0 +1,5 @@
+export declare function quoteForSh(input: string): string;
+export declare function quoteForPowerShell(input: string): string;
+/** Wrap a PowerShell command using -EncodedCommand to avoid all quoting issues. */
+export declare function toEncodedPowerShell(command: string): string;
+export declare function escapeSingleQuotedPath(path: string, dialect: 'bash' | 'powershell'): string;

package/dist/lib/shell-quoting.js

@@ -0,0 +1,17 @@
+export function quoteForSh(input) {
+    return `'${input.replaceAll("'", "'\"'\"'")}'`;
+}
+export function quoteForPowerShell(input) {
+    return `'${input.replaceAll("'", "''")}'`;
+}
+/** Wrap a PowerShell command using -EncodedCommand to avoid all quoting issues. */
+export function toEncodedPowerShell(command) {
+    const encoded = Buffer.from(command, 'utf16le').toString('base64');
+    return `powershell.exe -NoProfile -EncodedCommand ${encoded}`;
+}
+export function escapeSingleQuotedPath(path, dialect) {
+    if (dialect === 'powershell') {
+        return path.replaceAll("'", "''");
+    }
+    return path.replaceAll("'", String.raw `'\''`);
+}

package/dist/lib/spawn-errors.d.ts

@@ -0,0 +1,9 @@
+import { ProcessSpawnError } from './errors.js';
+export declare function getInstallInstruction(command: string): string;
+export declare function formatCommandNotFoundMessage(command: string): string;
+export declare function formatPathWarning(command: string): string;
+export declare function classifySpawnError(command: string, error: NodeJS.ErrnoException): ProcessSpawnError;
+export declare function resolveWindowsSpawnArgs(command: string, args: string[], cmdExists: (commandName: string) => boolean): null | {
+    args: string[];
+    command: string;
+};

package/dist/lib/spawn-errors.js

@@ -0,0 +1,29 @@
+import { ProcessSpawnError } from './errors.js';
+const INSTALL_INSTRUCTIONS = {
+    claude: 'Install Claude Code from https://claude.ai/download.',
+    codex: 'Install Codex from npm.',
+    devin: 'Install Devin from https://cli.devin.ai.',
+};
+export function getInstallInstruction(command) {
+    return INSTALL_INSTRUCTIONS[command] ?? 'Check that the command exists and is executable.';
+}
+export function formatCommandNotFoundMessage(command) {
+    return `Command not found: ${command}. ${getInstallInstruction(command)}`;
+}
+export function formatPathWarning(command) {
+    return `${command} not found on PATH (${getInstallInstruction(command).replace(/\.$/, '')})`;
+}
+export function classifySpawnError(command, error) {
+    if (error.code === 'ENOENT') {
+        return new ProcessSpawnError(formatCommandNotFoundMessage(command), 'ENOENT');
+    }
+    if (error.code === 'EACCES') {
+        return new ProcessSpawnError(`Permission denied: ${command}. Check file permissions.`, 'EACCES');
+    }
+    return new ProcessSpawnError(`Failed to spawn ${command}: ${error.message}. Check that the command exists and is executable.`, error.code);
+}
+export function resolveWindowsSpawnArgs(command, args, cmdExists) {
+    if (!cmdExists(`${command}.cmd`))
+        return null;
+    return { command: 'cmd.exe', args: ['/c', command, ...args] };
+}

package/dist/lib/spawn.js

@@ -41,6 +41,7 @@
 import { execSync, spawn as nodeSpawn } from 'node:child_process';
 import { debug, debugSpawn } from './debug.js';
 import { ProcessSpawnError } from './errors.js';
+import { classifySpawnError, resolveWindowsSpawnArgs } from './spawn-errors.js';
 /**
  * Spawn an external process and return its exit code.
  *
@@ -94,9 +95,10 @@ export async function spawnProcess(command, args = [], options = {}) {
         catch (error) {
             // If command not found and .cmd file exists, use cmd.exe wrapper
             // This avoids DEP0190 deprecation warning while supporting npm-installed commands
-            if (error instanceof ProcessSpawnError && error.code === 'ENOENT' && commandExistsInPath(`${command}.cmd`)) {
+            const windowsSpawnArgs = resolveWindowsSpawnArgs(command, args, commandExistsInPath);
+            if (error instanceof ProcessSpawnError && error.code === 'ENOENT' && windowsSpawnArgs) {
                 // Use cmd.exe /c to execute .cmd file without shell mode or deprecation warning
-                return attemptSpawn('cmd.exe', ['/c', command, ...args], { cwd, stdio, detached, shell: false });
+                return attemptSpawn(windowsSpawnArgs.command, windowsSpawnArgs.args, { cwd, stdio, detached, shell: false });
             }
             throw error;
         }
@@ -126,15 +128,7 @@ function attemptSpawn(command, args, spawnOptions) {
             const childProcess = nodeSpawn(command, args, spawnOptions);
             // Handle spawn errors (ENOENT, EACCES, etc.)
             childProcess.on('error', (error) => {
-                if (error.code === 'ENOENT') {
-                    reject(new ProcessSpawnError(`Command not found: ${command}. Install Claude Code from https://claude.ai/download.`, 'ENOENT'));
-                }
-                else if (error.code === 'EACCES') {
-                    reject(new ProcessSpawnError(`Permission denied: ${command}. Check file permissions.`, 'EACCES'));
-                }
-                else {
-                    reject(new ProcessSpawnError(`Failed to spawn ${command}: ${error.message}. Check that the command exists and is executable.`, error.code));
-                }
+                reject(classifySpawnError(command, error));
             });
             // Capture exit code on process close
             childProcess.on('close', (code, signal) => {

package/dist/lib/spinner.d.ts

@@ -12,8 +12,3 @@ import { type Ora } from 'ora';
 export declare function createSpinner(text: string, flags?: {
     quiet?: boolean;
 }): Ora;
-/**
- * Helper for common "loading" operations with spinner.
- * Automatically handles success/failure and cleanup.
- */
-export declare function withSpinner<T>(text: string, operation: () => Promise<T>): Promise<T>;

package/dist/lib/spinner.js

@@ -16,19 +16,3 @@ export function createSpinner(text, flags) {
         text,
     });
 }
-/**
- * Helper for common "loading" operations with spinner.
- * Automatically handles success/failure and cleanup.
- */
-export async function withSpinner(text, operation) {
-    const spinner = createSpinner(text).start();
-    try {
-        const result = await operation();
-        spinner.succeed();
-        return result;
-    }
-    catch (error) {
-        spinner.fail();
-        throw error;
-    }
-}

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

@@ -34,10 +34,10 @@ interface TemplateInstallationStatus {
     existing: TemplateItemStatus[];
     /** Items that are missing from target directory */
     missing: TemplateItemStatus[];
-    /** The method-specific workflow folder name (e.g., '_gsd', '_bmad') */
-    workflowFolder: null | string;
-    /** Whether the workflow folder exists */
-    workflowFolderExists: boolean;
+    /** The method-specific runtime folder name (e.g., '_gsd', '_bmad') */
+    runtimeFolder: null | string;
+    /** Whether the runtime folder exists */
+    runtimeFolderExists: boolean;
 }
 /**
  * Result of template installation
@@ -74,12 +74,21 @@ export declare function shouldExclude(name: string): boolean;
  * @param excludeIdeFolders - If true, exclude IDE config folders (.claude, .windsurf, etc.)
  */
 export declare function copyDir(src: string, dest: string, excludeIdeFolders?: boolean): Promise<void>;
+/**
+ * Merge source directory into destination, skipping existing files.
+ * Unlike copyDir, this preserves existing files in destination.
+ *
+ * @param src - Source directory path
+ * @param dest - Destination directory path
+ */
+export declare function mergeDirectory(src: string, dest: string, options?: {
+    exclude?: (name: string) => boolean;
+}): Promise<void>;
 /**
  * Install template with IDE-specific folder selection.
  *
  * Template structure:
  * - Non-dot folders (e.g., _bmad/, GSR/) → .aiwcli/ (always overwritten)
- * - _shared/ → .aiwcli/_shared/ (always overwritten)
  * - IDE dot folders (e.g., .claude/) → decomposed into method-owned subdirs
  *
  * Settings reconstruction is handled separately by the caller via reconstructIdeSettings().

package/dist/lib/template-installer.js

@@ -1,5 +1,5 @@
 import { promises as fs } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
 import { IdePathResolver } from './ide-path-resolver.js';
 import { pathExists } from './paths.js';
 /**
@@ -17,11 +17,11 @@ export async function checkTemplateStatus(templatePath, targetDir, ides, templat
     const missing = [];
     // Scan template directory
     const entries = await fs.readdir(templatePath, { withFileTypes: true });
-    // Identify workflow folder based on template name
+    // Identify method runtime folder based on template name
     // Convention: _templatename (e.g., _gsd, _bmad)
-    const workflowFolderName = `_${templateName}`;
-    let workflowFolder = null;
-    let workflowFolderExists = false;
+    const runtimeFolderName = `_${templateName}`;
+    let runtimeFolder = null;
+    let runtimeFolderExists = false;
     // Filter entries to only include relevant items (skip non-selected IDE folders and excluded patterns)
     const relevantEntries = entries.filter((entry) => {
         // Skip excluded patterns (test files, cache, etc.)
@@ -58,17 +58,17 @@ export async function checkTemplateStatus(templatePath, targetDir, ides, templat
         else {
             missing.push(status);
         }
-        // Track workflow folder
-        if (status.name === workflowFolderName) {
-            workflowFolder = workflowFolderName;
-            workflowFolderExists = status.exists;
+        // Track method runtime folder
+        if (status.name === runtimeFolderName) {
+            runtimeFolder = runtimeFolderName;
+            runtimeFolderExists = status.exists;
         }
     }
     return {
         existing,
         missing,
-        workflowFolder,
-        workflowFolderExists,
+        runtimeFolder,
+        runtimeFolderExists,
     };
 }
 /**
@@ -101,7 +101,7 @@ export async function copyDir(src, dest, excludeIdeFolders = false) {
         if (shouldExclude(entry.name)) {
             return false;
         }
-        // Exclude IDE config folders if requested (used for _shared folder)
+        // Exclude IDE config folders if requested (used for core folder)
         // These folders are used for settings merging, not direct installation
         if (excludeIdeFolders && entry.isDirectory() && entry.name.startsWith('.')) {
             return false;
@@ -128,16 +128,16 @@ export async function copyDir(src, dest, excludeIdeFolders = false) {
  * @param src - Source directory path
  * @param dest - Destination directory path
  */
-async function mergeDirectory(src, dest) {
+export async function mergeDirectory(src, dest, options) {
     await fs.mkdir(dest, { recursive: true });
     const entries = await fs.readdir(src, { withFileTypes: true });
     const ops = entries
-        .filter((entry) => !shouldExclude(entry.name))
+        .filter((entry) => !(options?.exclude?.(entry.name)))
         .map(async (entry) => {
         const srcPath = join(src, entry.name);
         const destPath = join(dest, entry.name);
         if (entry.isDirectory()) {
-            await mergeDirectory(srcPath, destPath);
+            await mergeDirectory(srcPath, destPath, options);
         }
         else if (!(await pathExists(destPath))) {
             await fs.copyFile(srcPath, destPath);
@@ -150,7 +150,6 @@ async function mergeDirectory(src, dest) {
  *
  * Template structure:
  * - Non-dot folders (e.g., _bmad/, GSR/) → .aiwcli/ (always overwritten)
- * - _shared/ → .aiwcli/_shared/ (always overwritten)
  * - IDE dot folders (e.g., .claude/) → decomposed into method-owned subdirs
  *
  * Settings reconstruction is handled separately by the caller via reconstructIdeSettings().
@@ -205,27 +204,6 @@ export async function installTemplate(config) {
     });
     const nonDotResults = await Promise.all(nonDotInstalls);
     installedFolders.push(...nonDotResults);
-    // Install root-level _shared directory (shared across all templates)
-    // Exclude IDE config folders (.claude, .windsurf) - they are used for settings merging only
-    const templatesRoot = dirname(templatePath);
-    const rootSharedSrc = join(templatesRoot, '_shared');
-    const rootSharedDest = join(containerDir, '_shared');
-    if (await pathExists(rootSharedSrc)) {
-        await copyDir(rootSharedSrc, rootSharedDest, true); // excludeIdeFolders = true
-        installedFolders.push('_shared');
-        // Copy shared IDE content (e.g., _shared/.claude/commands/handoff.md)
-        // These are non-method-owned files that live in IDE folders
-        const sharedIdeInstalls = ides.map(async (ide) => {
-            const sharedIdeFolder = join(rootSharedSrc, `.${ide}`);
-            if (await pathExists(sharedIdeFolder)) {
-                const destIdeFolder = resolver.getIdeDir(ide);
-                await fs.mkdir(destIdeFolder, { recursive: true });
-                // Merge shared IDE content, skipping files that already exist
-                await mergeDirectory(sharedIdeFolder, destIdeFolder);
-            }
-        });
-        await Promise.all(sharedIdeInstalls);
-    }
     // Install method-owned IDE content (decomposed approach)
     // Instead of copying entire .claude/ from template, only copy method-namespaced subdirectories
     const ideInstalls = ides.map(async (ide) => {
@@ -251,7 +229,7 @@ export async function installTemplate(config) {
             }
             else {
                 // No method-namespaced child — copy the entire subdirectory, merging with existing
-                await mergeDirectory(subdirSrc, subdirDest);
+                await mergeDirectory(subdirSrc, subdirDest, { exclude: shouldExclude });
             }
         });
         await Promise.all(subdirOps);
@@ -260,9 +238,33 @@ export async function installTemplate(config) {
     const ideResults = (await Promise.all(ideInstalls)).filter((result) => result !== null);
     installedFolders.push(...ideResults);
     // Settings reconstruction is handled by the caller via reconstructIdeSettings()
+    // Write resolved CLI binary path so template scripts can shell out to `aiw`
+    await writeAiwBinPath(containerDir);
     return {
         installedFolders,
         sharedSettingsMerged: false,
         templatePath,
     };
 }
+/**
+ * Write the resolved `aiw` binary path to `.aiwcli/.aiw-bin-path`.
+ * Template scripts read this file to find the CLI binary for `aiw launch`.
+ */
+async function writeAiwBinPath(containerDir) {
+    try {
+        // process.argv[1] is the main script entry point (e.g., /path/to/aiw/bin/run.js)
+        // Resolve to the bin directory to find the actual `aiw` executable
+        const { execSync } = await import('node:child_process');
+        const cmd = process.platform === 'win32' ? 'where aiw' : 'which aiw';
+        const resolved = execSync(cmd, { encoding: 'utf8', timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] })
+            .trim()
+            .split(/\r?\n/)[0]
+            ?.trim();
+        if (resolved) {
+            await fs.writeFile(join(containerDir, '.aiw-bin-path'), resolved, 'utf8');
+        }
+    }
+    catch {
+        // Best-effort — aiw will still be found on PATH at runtime
+    }
+}

package/dist/lib/template-resolver.d.ts

@@ -12,15 +12,14 @@
  */
 export declare function getTemplatePath(templateName: string): Promise<string>;
 /**
- * Get list of available template names by scanning the templates directory.
+ * Get list of available method template names by scanning the templates directory.
  *
- * @returns Array of template names (e.g., ['bmad', 'gsr'])
+ * @returns Array of method template names (e.g., ['bmad', 'cc-native'])
  * @throws Error if templates directory cannot be read (indicates corrupted installation)
  */
+export declare function getAvailableTemplates(): Promise<string[]>;
 /**
- * Get the absolute path to the _shared template directory.
- *
- * @returns Absolute path to the _shared template
+ * Discover IDE names available in a template path by scanning top-level dot-folders.
+ * Example: .claude, .codex -> ['claude', 'codex']
  */
-export declare function getSharedTemplatePath(): string;
-export declare function getAvailableTemplates(): Promise<string[]>;
+export declare function getTemplateIdeNamesByPath(templatePath: string): Promise<string[]>;

package/dist/lib/template-resolver.js

@@ -1,6 +1,12 @@
 import { promises as fs } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+function getTemplatesRootDir() {
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = fileURLToPath(currentFileUrl);
+    const currentDir = dirname(currentFilePath);
+    return join(currentDir, '..', 'templates');
+}
 /**
  * Resolve the absolute path to a bundled template root.
  * Works in both development (src/) and production (dist/) contexts.
@@ -21,13 +27,10 @@ export async function getTemplatePath(templateName) {
     // Get the directory of this file
     // In dev: .../aiwcli/src/lib/
     // In prod: .../aiwcli/dist/lib/
-    const currentFileUrl = import.meta.url;
-    const currentFilePath = fileURLToPath(currentFileUrl);
-    const currentDir = dirname(currentFilePath);
     // Go up one level and into templates/<templateName>
     // src/lib/ → src/templates/<templateName>/
     // dist/lib/ → dist/templates/<templateName>/
-    const templatePath = join(currentDir, '..', 'templates', templateName);
+    const templatePath = join(getTemplatesRootDir(), templateName);
     // Validate template exists
     try {
         await fs.access(templatePath);
@@ -38,29 +41,18 @@ export async function getTemplatePath(templateName) {
     return templatePath;
 }
 /**
- * Get list of available template names by scanning the templates directory.
+ * Get list of available method template names by scanning the templates directory.
  *
- * @returns Array of template names (e.g., ['bmad', 'gsr'])
+ * @returns Array of method template names (e.g., ['bmad', 'cc-native'])
  * @throws Error if templates directory cannot be read (indicates corrupted installation)
  */
-/**
- * Get the absolute path to the _shared template directory.
- *
- * @returns Absolute path to the _shared template
- */
-export function getSharedTemplatePath() {
-    const currentFilePath = fileURLToPath(import.meta.url);
-    const currentDir = dirname(currentFilePath);
-    return join(currentDir, '..', 'templates', '_shared');
-}
 export async function getAvailableTemplates() {
-    const currentFileUrl = import.meta.url;
-    const currentFilePath = fileURLToPath(currentFileUrl);
-    const currentDir = dirname(currentFilePath);
-    const templatesDir = join(currentDir, '..', 'templates');
+    const templatesDir = getTemplatesRootDir();
     try {
         const entries = await fs.readdir(templatesDir, { withFileTypes: true });
-        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+        return entries
+            .filter((entry) => entry.isDirectory() && !entry.name.startsWith('_') && !RESERVED_TEMPLATE_NAMES.has(entry.name))
+            .map((entry) => entry.name);
     }
     catch (error) {
         const err = error;
@@ -68,3 +60,16 @@ export async function getAvailableTemplates() {
             `This indicates a corrupted installation. Please reinstall aiwcli.`);
     }
 }
+/**
+ * Discover IDE names available in a template path by scanning top-level dot-folders.
+ * Example: .claude, .codex -> ['claude', 'codex']
+ */
+export async function getTemplateIdeNamesByPath(templatePath) {
+    const entries = await fs.readdir(templatePath, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith('.'))
+        .map((entry) => entry.name.slice(1))
+        .filter((name) => name.length > 0)
+        .sort((a, b) => a.localeCompare(b));
+}
+const RESERVED_TEMPLATE_NAMES = new Set(['core']);