aiwcli 0.15.7 → 0.17.0

package/dist/lib/hooks/context-monitor-logic.js

@@ -0,0 +1,25 @@
+export const CONTEXT_WARNING_30 = "## Context Window: ~30% Remaining\n\n" +
+    "This session is approaching its context limit. Consider:\n\n" +
+    "- Completing your current task, then pausing for the user to decide next steps\n" +
+    "- If significant work remains, mention that `/aiwcli-shared:handoff` can capture progress " +
+    "for a fresh session\n\n" +
+    "Do not rush or cut corners — finish the current task properly. " +
+    "Just be aware that starting large new tasks may not complete before context runs out.";
+export const CONTEXT_WARNING_15 = "## Context Window: ~15% Remaining — Wrap Up Now\n\n" +
+    "Context is critically low. After completing your current step:\n\n" +
+    "1. **Stop taking on new work**\n" +
+    "2. Summarize what was accomplished and what remains\n" +
+    "3. Offer to run `/aiwcli-shared:handoff` so progress transfers to a fresh session\n\n" +
+    "Do not start new multi-step tasks. Focus on clean closure.";
+const WARNING_THRESHOLDS = [
+    { pct: 15, msg: CONTEXT_WARNING_15 },
+    { pct: 30, msg: CONTEXT_WARNING_30 },
+];
+export function selectWarningMessage(pctRemaining, alreadyFired) {
+    for (const warning of WARNING_THRESHOLDS) {
+        if (pctRemaining <= warning.pct && !alreadyFired.includes(warning.pct)) {
+            return warning;
+        }
+    }
+    return null;
+}

package/dist/lib/hooks/hook-utils.js

@@ -7,6 +7,7 @@ import * as fs from "node:fs";
 import { getContextBySessionId, maybeActivate } from "../context/context-store.js";
 import { getProjectRoot } from "../runtime/constants.js";
 import { logDebug, logWarn, hookLog, setSessionId, getContextPath as _getContextPath } from "../runtime/logger.js";
+import { HookInputSchema } from "../schemas.js";
 // Re-export logger functions for convenience (matches Python hook_utils re-exports)
 // Context window baseline: tokens not visible in hook data §5.9
 export const CONTEXT_BASELINE_TOKENS = 22_600;
@@ -113,6 +114,11 @@ export function loadHookInput() {
         if (!inputData)
             return null;
         const result = JSON.parse(inputData);
+        const validated = HookInputSchema.safeParse(result);
+        if (!validated.success) {
+            logWarn("hook_utils", `Hook input schema validation failed: ${validated.error.message}`);
+            return null;
+        }
         if (result && typeof result === "object") {
             _lastHookEvent = readStringField(result, "hook_event_name");
             _lastToolName = readStringField(result, "tool_name");
@@ -436,6 +442,11 @@ function _earlyReadInput(prefetchedInput) {
         const inputData = fs.readFileSync(0, "utf8").trim();
         if (inputData) {
             const parsed = JSON.parse(inputData);
+            const validated = HookInputSchema.safeParse(parsed);
+            if (!validated.success) {
+                logWarn("hook_utils", `Early input schema validation failed: ${validated.error.message}`);
+                return;
+            }
             if (parsed && typeof parsed === "object") {
                 _prefetchedInput = parsed;
                 _lastHookEvent = readStringField(parsed, "hook_event_name");

package/dist/lib/hooks/prompt-binding-logic.d.ts

@@ -0,0 +1,7 @@
+import type { ContextState } from "../types.js";
+export interface PromptBindingResult {
+    outputs: string[];
+    blockedReason?: string;
+}
+export declare function shouldClearHandoff(state: ContextState): boolean;
+export declare function executePromptBinding(prompt: string | undefined, sessionId: string, permissionMode: string, projectRoot: string): Promise<PromptBindingResult>;

package/dist/lib/hooks/prompt-binding-logic.js

@@ -0,0 +1,50 @@
+import { safeMaybeActivate, logInfo, logWarn } from "./hook-utils.js";
+import { buildContextInventory } from "../context/context-formatter.js";
+import { BlockRequest, determineContext } from "../context/context-selector.js";
+import { bindSession, getContextBySessionId, saveState, } from "../context/context-store.js";
+export function shouldClearHandoff(state) {
+    return Boolean(state.handoff_path);
+}
+export async function executePromptBinding(prompt, sessionId, permissionMode, projectRoot) {
+    const outputs = [];
+    const existingCtx = getContextBySessionId(sessionId, projectRoot);
+    if (existingCtx) {
+        safeMaybeActivate(existingCtx.id, permissionMode, projectRoot, "user_prompt_submit");
+        return { outputs };
+    }
+    if (!prompt)
+        return { outputs };
+    try {
+        const [contextId, method, outputText] = await determineContext(prompt, sessionId, projectRoot);
+        if (contextId) {
+            bindSession(contextId, sessionId, projectRoot);
+            safeMaybeActivate(contextId, permissionMode, projectRoot, "user_prompt_submit");
+            const state = getContextBySessionId(sessionId, projectRoot);
+            if (state && shouldClearHandoff(state)) {
+                state.handoff_path = null;
+                saveState(state.id, state, projectRoot);
+            }
+            logInfo("user_prompt_submit", `Context ${contextId} via ${method}`);
+        }
+        if (outputText)
+            outputs.push(outputText);
+        try {
+            const boundState = getContextBySessionId(sessionId, projectRoot);
+            if (boundState) {
+                const inventory = buildContextInventory(boundState, projectRoot);
+                if (inventory)
+                    outputs.push(inventory);
+            }
+        }
+        catch (error) {
+            logWarn("user_prompt_submit", `Inventory failed (non-critical): ${error}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof BlockRequest) {
+            return { outputs, blockedReason: error.message };
+        }
+        throw error;
+    }
+    return { outputs };
+}

package/dist/lib/hooks/session-end-logic.js

@@ -1,4 +1,5 @@
 import * as crypto from "node:crypto";
+import { determineArtifactType } from "../context/context-store.js";
 import { extractPlanAnchors, generatePlanId, normalizePlanContent, } from "../context/plan-manager.js";
 import { nowIso } from "../runtime/utils.js";
 function formatArchiveTimestamp(date) {
@@ -8,19 +9,6 @@ function formatArchiveTimestamp(date) {
         `${String(date.getHours()).padStart(2, "0")}` +
         `${String(date.getMinutes()).padStart(2, "0")}`);
 }
-function resolveArtifactType(state) {
-    if (state.next_artifact_type)
-        return state.next_artifact_type;
-    const hasPlan = Boolean(state.plan_path && state.plan_hash);
-    const hasHandoff = Boolean(state.handoff_path);
-    if (hasPlan && hasHandoff)
-        return "plan";
-    if (hasPlan)
-        return "plan";
-    if (hasHandoff)
-        return "handoff";
-    return null;
-}
 export function computePlanFallback(state, planContent) {
     const normalized = normalizePlanContent(planContent);
     const planHash = crypto
@@ -37,7 +25,7 @@ export function computePlanFallback(state, planContent) {
     };
 }
 export function shouldStage(state, permissionMode) {
-    const artifactType = resolveArtifactType(state);
+    const artifactType = determineArtifactType(state);
     const canStage = state.mode === "active" || permissionMode === "plan";
     return Boolean(artifactType && canStage && !state.work_consumed);
 }

package/dist/lib/install-state.js

@@ -1,27 +1,20 @@
 import { promises as fs } from 'node:fs';
 import { IdePathResolver } from './ide-path-resolver.js';
+import { readJsonFile, writeJsonFile } from './json-io.js';
 import { pathExists } from './paths.js';
 const CORE_RUNTIME_FOLDERS = new Set(['_core']);
 const RESERVED_AIWCLI_FOLDERS = new Set(['_output', 'state', ...CORE_RUNTIME_FOLDERS]);
 const VERSION = 1;
 export async function readInstallState(targetDir) {
     const statePath = new IdePathResolver(targetDir).getInstallStatePath();
-    try {
-        const content = await fs.readFile(statePath, 'utf8');
-        const parsed = JSON.parse(content);
-        if (parsed.version !== VERSION || !parsed.core || !parsed.methods || !parsed.ides)
-            return undefined;
-        return parsed;
-    }
-    catch {
+    const parsed = await readJsonFile(statePath);
+    if (!parsed || parsed.version !== VERSION || !parsed.core || !parsed.methods || !parsed.ides)
         return undefined;
-    }
+    return parsed;
 }
 export async function writeInstallState(targetDir, state) {
-    const resolver = new IdePathResolver(targetDir);
-    const statePath = resolver.getInstallStatePath();
-    await fs.mkdir(resolver.getAiwcliStateDir(), { recursive: true });
-    await fs.writeFile(statePath, JSON.stringify(state, null, 2), 'utf8');
+    const statePath = new IdePathResolver(targetDir).getInstallStatePath();
+    await writeJsonFile(statePath, state);
 }
 export async function ensureInstallState(targetDir) {
     const existing = await readInstallState(targetDir);

package/dist/lib/json-io.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Read a JSON file and parse it as type T.
+ * Returns undefined if the file doesn't exist or can't be parsed.
+ */
+export declare function readJsonFile<T>(filePath: string): Promise<T | undefined>;
+/**
+ * Write data as JSON to a file, optionally creating a backup of the existing file.
+ * Creates parent directories if needed.
+ */
+export declare function writeJsonFile<T>(filePath: string, data: T, options?: {
+    backup?: boolean;
+}): Promise<void>;

package/dist/lib/json-io.js

@@ -0,0 +1,30 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+import { pathExists } from './paths.js';
+/**
+ * Read a JSON file and parse it as type T.
+ * Returns undefined if the file doesn't exist or can't be parsed.
+ */
+export async function readJsonFile(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Write data as JSON to a file, optionally creating a backup of the existing file.
+ * Creates parent directories if needed.
+ */
+export async function writeJsonFile(filePath, data, options) {
+    const dir = join(filePath, '..');
+    await fs.mkdir(dir, { recursive: true });
+    if (options?.backup && await pathExists(filePath)) {
+        const backupPath = `${filePath}.backup`;
+        await fs.copyFile(filePath, backupPath);
+    }
+    const content = JSON.stringify(data, null, 2);
+    await fs.writeFile(filePath, content, 'utf8');
+}

package/dist/lib/multiplexer.d.ts

@@ -1,56 +1,64 @@
 /**
  * Unified multiplexer abstraction.
- * Single interface for tmux (Unix) and psmux (Windows) backends.
+ * Backends implement the Multiplexer interface: resolveStrategy() for context-aware
+ * decision making, split()/createSession() for pane management.
  * Factory: detectMultiplexer() → Multiplexer | null
  */
-export type MultiplexerBackend = 'psmux' | 'tmux';
-export type SplitDirection = 'auto' | 'h' | 'v';
-export interface SplitPaneOptions {
+export type LaunchStrategy = 'split' | 'create-session' | 'inline' | 'unavailable';
+export interface StrategyContext {
+    calledFromRepl: boolean;
+    platform: NodeJS.Platform;
+    disableMux: boolean;
+}
+export interface ResolvedStrategy {
+    strategy: LaunchStrategy;
+    reason: string;
+}
+export type SplitDirection = 'auto' | 'horizontal' | 'vertical';
+export interface SplitOptions {
+    toolName: string;
     args: string[];
-    autoClose?: boolean | undefined;
-    cwd?: string | undefined;
-    env?: Record<string, string> | undefined;
-    holdMessage?: string | undefined;
-    holdPane?: boolean | undefined;
-    mode?: 'exec' | 'repl' | undefined;
+    cwd: string;
+    env: Record<string, string>;
+    mode: 'exec' | 'repl';
+    split: SplitDirection;
     promptPath?: string | undefined;
-    sentinel?: boolean | undefined;
-    split?: SplitDirection | undefined;
-    splitTarget?: string | undefined;
-    toolName: string;
+    sentinelPath: string;
+    holdPane: boolean;
+    retryOnQuickExit: boolean;
 }
-export interface SplitPaneResult {
-    backend: MultiplexerBackend;
-    exitCode?: number | undefined;
+export interface LaunchResult {
     launched: boolean;
-    paneId?: string | undefined;
-    reason?: string | undefined;
+    backend: string;
+    handle?: string | undefined;
     sentinelPath?: string | undefined;
-    stderr?: string | undefined;
+    exitCode?: number | undefined;
+    reason?: string | undefined;
 }
 export interface CreateSessionOptions {
-    enableMouse?: boolean | undefined;
-    promptText?: string | undefined;
-    reattach?: boolean | undefined;
     sessionName: string;
-    toolArgs: string[];
     toolPath: string;
-}
-export interface CreateSessionResult {
-    exitCode: number;
-    reason?: string | undefined;
-    usedMux: boolean;
+    toolArgs: string[];
+    cwd: string;
+    promptText?: string | undefined;
+    reattach: boolean;
+    enableMouse?: boolean | undefined;
 }
 export interface Multiplexer {
-    readonly backend: MultiplexerBackend;
-    createSession(options: CreateSessionOptions): Promise<CreateSessionResult>;
-    isInsideSession(): boolean;
-    kill(paneId: string): Promise<void>;
-    splitPane(options: SplitPaneOptions): Promise<SplitPaneResult>;
+    readonly backend: string;
+    resolveStrategy(ctx: StrategyContext): ResolvedStrategy;
+    split(options: SplitOptions): Promise<LaunchResult>;
+    createSession(options: CreateSessionOptions): Promise<LaunchResult>;
+    kill(handle: string): Promise<void>;
 }
+/**
+ * Resolve the priority order of multiplexer backends for a given platform.
+ * Pure function — no I/O, no PATH checks. Used by detectMultiplexer().
+ */
+export declare function resolveMultiplexerPriority(platform: NodeJS.Platform, env?: Record<string, string | undefined>): string[];
 /**
  * Detect the best available multiplexer for the current platform.
- * Windows → PsmuxMultiplexer (if installed and meets version requirement)
+ * Windows → WeztermMultiplexer (if inside WezTerm) → PsmuxMultiplexer (fallback)
  * Unix → TmuxMultiplexer (if tmux binary on PATH)
  * Returns null if no multiplexer is available.
  */

package/dist/lib/multiplexer.js

@@ -1,16 +1,35 @@
 /**
  * Unified multiplexer abstraction.
- * Single interface for tmux (Unix) and psmux (Windows) backends.
+ * Backends implement the Multiplexer interface: resolveStrategy() for context-aware
+ * decision making, split()/createSession() for pane management.
  * Factory: detectMultiplexer() → Multiplexer | null
  */
+/**
+ * Resolve the priority order of multiplexer backends for a given platform.
+ * Pure function — no I/O, no PATH checks. Used by detectMultiplexer().
+ */
+export function resolveMultiplexerPriority(platform, env = {}) {
+    if (platform === 'win32') {
+        // Prefer WezTerm if we detect a WezTerm environment
+        if (env.WEZTERM_PANE || env.TERM_PROGRAM === 'WezTerm') {
+            return ['wezterm', 'psmux'];
+        }
+        return ['psmux'];
+    }
+    return ['tmux'];
+}
 /**
  * Detect the best available multiplexer for the current platform.
- * Windows → PsmuxMultiplexer (if installed and meets version requirement)
+ * Windows → WeztermMultiplexer (if inside WezTerm) → PsmuxMultiplexer (fallback)
  * Unix → TmuxMultiplexer (if tmux binary on PATH)
  * Returns null if no multiplexer is available.
  */
 export async function detectMultiplexer(platform = process.platform) {
     if (platform === 'win32') {
+        const { WeztermMultiplexer } = await import('./multiplexers/wezterm.js');
+        const wezterm = WeztermMultiplexer.create();
+        if (wezterm)
+            return wezterm;
         const { PsmuxMultiplexer } = await import('./multiplexers/psmux.js');
         return PsmuxMultiplexer.create();
     }

package/dist/lib/multiplexers/psmux.d.ts

@@ -1,8 +1,10 @@
 /**
  * PsmuxMultiplexer — unified psmux (Windows ConPTY) backend.
- * Consolidates PsmuxLauncher + launchInPsmuxSession + command building from pane-driver.
+ * Composes with PowerShellAdapter for command building.
+ * Owns: version checking, session readiness polling, bootstrap defaults.
  */
-import type { CreateSessionOptions, CreateSessionResult, Multiplexer, SplitPaneOptions, SplitPaneResult } from '../multiplexer.js';
+import type { CreateSessionOptions, LaunchResult, Multiplexer, ResolvedStrategy, SplitOptions, StrategyContext } from '../multiplexer.js';
+import type { ShellAdapter } from '../shell-adapters/shell-adapter.js';
 /** @internal */
 export interface PsmuxVersion {
     major: number;
@@ -13,16 +15,9 @@ export interface PsmuxVersion {
 export declare function meetsMinVersion(v: PsmuxVersion): boolean;
 /** @internal */
 export declare function parseVersionString(stdout: string): null | PsmuxVersion;
-/** @internal */
-export declare function buildCommandArgs(args: string[], mode: 'exec' | 'repl', promptPath?: string): string[];
-/** @internal */
-export declare function buildPowerShellToolCommand(params: {
-    args: string[];
-    env: Record<string, string>;
-    mode: 'exec' | 'repl';
-    promptPath?: string;
-    toolPath: string;
-}): string;
+type PsmuxSplitFlag = '-h' | '-v';
+/** @internal — translate unified SplitDirection to psmux flag. */
+export declare function toPsmuxSplitFlag(direction: 'horizontal' | 'vertical'): PsmuxSplitFlag;
 /** @internal */
 export declare function buildCreateSessionArgs(params: {
     cwd: string;
@@ -41,27 +36,13 @@ export declare function buildAttachArgs(sessionName: string): string[];
 export declare class PsmuxMultiplexer implements Multiplexer {
     readonly backend: "psmux";
     private readonly psmuxPath;
+    private readonly shell;
     private constructor();
-    /**
-     * Check if psmux is installed and meets version requirements.
-     * Checks PATH first, then probes the winget install directory
-     * (winget install doesn't always add packages to PATH).
-     * Returns a PsmuxMultiplexer instance or null.
-     */
     static create(): Promise<null | PsmuxMultiplexer>;
-    /**
-     * Create a new psmux session.
-     * Injects PSMUX_PANE=1 into the PowerShell command so child processes
-     * can detect they're inside a psmux session.
-     */
-    createSession(options: CreateSessionOptions): Promise<CreateSessionResult>;
-    /**
-     * Detect if we're inside a psmux session we created.
-     * Uses PSMUX_PANE env var that we inject in createSession().
-     */
-    isInsideSession(): boolean;
-    kill(paneId: string): Promise<void>;
-    splitPane(options: SplitPaneOptions): Promise<SplitPaneResult>;
+    resolveStrategy(ctx: StrategyContext): ResolvedStrategy;
+    createSession(options: CreateSessionOptions): Promise<LaunchResult>;
+    kill(handle: string): Promise<void>;
+    split(options: SplitOptions): Promise<LaunchResult>;
     private applyBootstrapDefaults;
     private hasSession;
     private resolveAutoSplit;
@@ -70,6 +51,5 @@ export declare class PsmuxMultiplexer implements Multiplexer {
 /** @internal */
 export declare function buildPsmuxBootstrapCommands(enableMouse?: boolean): string[][];
 /** @internal */
-export declare function buildPsmuxShellCommand(opts: CreateSessionOptions, promptFilePath?: string): string;
-/** @internal */
-export declare function formatPromptPathForBootstrap(promptPath: string): string;
+export declare function buildPsmuxShellCommand(shell: ShellAdapter, opts: CreateSessionOptions, promptFilePath?: string): string;
+export {};