aiwcli 0.15.5 → 0.17.0

package/dist/lib/schemas.d.ts

@@ -0,0 +1,250 @@
+/**
+ * Zod schemas mirroring types.ts for runtime validation at JSON.parse boundaries.
+ * All object schemas use .passthrough() to preserve method-specific extension fields.
+ * See types.ts for corresponding TypeScript interfaces.
+ */
+import { z } from "zod";
+export declare const ModeSchema: z.ZodEnum<{
+    idle: "idle";
+    active: "active";
+    has_staged_work: "has_staged_work";
+}>;
+export declare const GitStateSchema: z.ZodObject<{
+    branch: z.ZodOptional<z.ZodString>;
+    last_commit_short: z.ZodOptional<z.ZodString>;
+    uncommitted_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export declare const LastSessionSchema: z.ZodObject<{
+    context_remaining_pct: z.ZodOptional<z.ZodNumber>;
+    context_warnings_fired: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    git_state: z.ZodOptional<z.ZodObject<{
+        branch: z.ZodOptional<z.ZodString>;
+        last_commit_short: z.ZodOptional<z.ZodString>;
+        uncommitted_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
+    save_reason: z.ZodOptional<z.ZodString>;
+    saved_at: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    transcript_path: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const TaskSchema: z.ZodObject<{
+    active_form: z.ZodString;
+    completed_at: z.ZodNullable<z.ZodString>;
+    created_at: z.ZodString;
+    description: z.ZodString;
+    evidence: z.ZodString;
+    files_changed: z.ZodArray<z.ZodString>;
+    id: z.ZodString;
+    session_id: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        blocked: "blocked";
+        completed: "completed";
+        in_progress: "in_progress";
+        pending: "pending";
+    }>;
+    subject: z.ZodString;
+    work_summary: z.ZodString;
+}, z.core.$loose>;
+export declare const ContextStateSchema: z.ZodObject<{
+    created_at: z.ZodString;
+    handoff_consumed: z.ZodOptional<z.ZodBoolean>;
+    handoff_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    id: z.ZodString;
+    last_active: z.ZodString;
+    last_session: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        context_remaining_pct: z.ZodOptional<z.ZodNumber>;
+        context_warnings_fired: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        git_state: z.ZodOptional<z.ZodObject<{
+            branch: z.ZodOptional<z.ZodString>;
+            last_commit_short: z.ZodOptional<z.ZodString>;
+            uncommitted_files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$loose>>;
+        save_reason: z.ZodOptional<z.ZodString>;
+        saved_at: z.ZodOptional<z.ZodString>;
+        session_id: z.ZodOptional<z.ZodString>;
+        transcript_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>>;
+    method: z.ZodString;
+    mode: z.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        has_staged_work: "has_staged_work";
+    }>;
+    next_artifact_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        handoff: "handoff";
+        plan: "plan";
+    }>>>;
+    plan_anchors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    plan_consumed: z.ZodOptional<z.ZodBoolean>;
+    plan_hash: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    plan_hash_consumed: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    plan_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    plan_path: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    plan_signature: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    session_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    status: z.ZodEnum<{
+        active: "active";
+        completed: "completed";
+    }>;
+    summary: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        active_form: z.ZodString;
+        completed_at: z.ZodNullable<z.ZodString>;
+        created_at: z.ZodString;
+        description: z.ZodString;
+        evidence: z.ZodString;
+        files_changed: z.ZodArray<z.ZodString>;
+        id: z.ZodString;
+        session_id: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            completed: "completed";
+            in_progress: "in_progress";
+            pending: "pending";
+        }>;
+        subject: z.ZodString;
+        work_summary: z.ZodString;
+    }, z.core.$loose>>>;
+    work_consumed: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const IndexEntrySchema: z.ZodObject<{
+    last_active: z.ZodString;
+    mode: z.ZodString;
+    summary: z.ZodString;
+}, z.core.$loose>;
+export declare const IndexFileSchema: z.ZodObject<{
+    contexts: z.ZodRecord<z.ZodString, z.ZodObject<{
+        last_active: z.ZodString;
+        mode: z.ZodString;
+        summary: z.ZodString;
+    }, z.core.$loose>>;
+    sessions: z.ZodRecord<z.ZodString, z.ZodString>;
+    updated_at: z.ZodString;
+    version: z.ZodLiteral<"3.0">;
+}, z.core.$loose>;
+export declare const LogEntrySchema: z.ZodObject<{
+    component: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodUnknown>;
+    hook: z.ZodString;
+    level: z.ZodEnum<{
+        error: "error";
+        warn: "warn";
+        debug: "debug";
+        info: "info";
+    }>;
+    msg: z.ZodString;
+    tb: z.ZodOptional<z.ZodString>;
+    ts: z.ZodString;
+}, z.core.$loose>;
+export declare const HookInputSchema: z.ZodObject<{
+    context_window: z.ZodOptional<z.ZodObject<{
+        context_window_size: z.ZodOptional<z.ZodNumber>;
+        current_usage: z.ZodOptional<z.ZodObject<{
+            cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+            cache_read_input_tokens: z.ZodOptional<z.ZodNumber>;
+            input_tokens: z.ZodOptional<z.ZodNumber>;
+            output_tokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+    cwd: z.ZodOptional<z.ZodString>;
+    hook_event_name: z.ZodString;
+    permission_mode: z.ZodOptional<z.ZodString>;
+    session_id: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    tool_input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tool_name: z.ZodOptional<z.ZodString>;
+    tool_result: z.ZodOptional<z.ZodString>;
+    transcript_path: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const HookOutputSchema: z.ZodObject<{
+    decision: z.ZodOptional<z.ZodLiteral<"block">>;
+    hookSpecificOutput: z.ZodOptional<z.ZodObject<{
+        additionalContext: z.ZodOptional<z.ZodString>;
+        hookEventName: z.ZodOptional<z.ZodString>;
+        permissionDecision: z.ZodOptional<z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+            ask: "ask";
+        }>>;
+        permissionDecisionReason: z.ZodOptional<z.ZodString>;
+        updatedInput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const PermissionRequestOutputSchema: z.ZodObject<{
+    decision: z.ZodObject<{
+        behavior: z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+        updatedInput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        updatedPermissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$loose>;
+export declare const InferenceResultSchema: z.ZodObject<{
+    error: z.ZodOptional<z.ZodString>;
+    latency_ms: z.ZodNumber;
+    output: z.ZodString;
+    success: z.ZodBoolean;
+}, z.core.$loose>;
+export declare const HandoffDocumentSchema: z.ZodObject<{
+    active_tasks: z.ZodArray<z.ZodObject<{
+        active_form: z.ZodString;
+        completed_at: z.ZodNullable<z.ZodString>;
+        created_at: z.ZodString;
+        description: z.ZodString;
+        evidence: z.ZodString;
+        files_changed: z.ZodArray<z.ZodString>;
+        id: z.ZodString;
+        session_id: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            blocked: "blocked";
+            completed: "completed";
+            in_progress: "in_progress";
+            pending: "pending";
+        }>;
+        subject: z.ZodString;
+        work_summary: z.ZodString;
+    }, z.core.$loose>>;
+    completed_tasks_this_session: z.ZodArray<z.ZodObject<{
+        subject: z.ZodString;
+    }, z.core.$loose>>;
+    context_folder: z.ZodString;
+    context_id: z.ZodString;
+    context_summary: z.ZodString;
+    created_at: z.ZodString;
+    events_log_path: z.ZodString;
+    file_path: z.ZodNullable<z.ZodString>;
+    important_notes: z.ZodArray<z.ZodString>;
+    next_steps: z.ZodArray<z.ZodString>;
+    plan_path: z.ZodNullable<z.ZodString>;
+    reason: z.ZodString;
+    session_id: z.ZodString;
+    work_summary: z.ZodString;
+}, z.core.$loose>;
+export declare const HandoffSectionsSchema: z.ZodObject<{
+    completedWork: z.ZodNullable<z.ZodString>;
+    context: z.ZodNullable<z.ZodString>;
+    deadEnds: z.ZodNullable<z.ZodString>;
+    decisions: z.ZodNullable<z.ZodString>;
+    index: z.ZodNullable<z.ZodString>;
+    pending: z.ZodNullable<z.ZodString>;
+    plan: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+export declare const CaretCommandSchema: z.ZodObject<{
+    ends: z.ZodArray<z.ZodString>;
+    new_context_desc: z.ZodNullable<z.ZodString>;
+    remaining_prompt: z.ZodString;
+    select: z.ZodNullable<z.ZodString>;
+}, z.core.$loose>;
+export declare const AgentConfigSchema: z.ZodObject<{
+    categories: z.ZodArray<z.ZodString>;
+    description: z.ZodString;
+    focus: z.ZodString;
+    model: z.ZodString;
+    name: z.ZodString;
+    provider: z.ZodString;
+    system_prompt: z.ZodString;
+}, z.core.$loose>;

package/dist/lib/schemas.js

@@ -0,0 +1,216 @@
+/**
+ * Zod schemas mirroring types.ts for runtime validation at JSON.parse boundaries.
+ * All object schemas use .passthrough() to preserve method-specific extension fields.
+ * See types.ts for corresponding TypeScript interfaces.
+ */
+import { z } from "zod";
+// §1.1
+export const ModeSchema = z.enum(["active", "has_staged_work", "idle"]);
+// §1.2
+export const GitStateSchema = z
+    .object({
+    branch: z.string().optional(),
+    last_commit_short: z.string().optional(),
+    uncommitted_files: z.array(z.string()).optional(),
+})
+    .passthrough();
+export const LastSessionSchema = z
+    .object({
+    context_remaining_pct: z.number().optional(),
+    context_warnings_fired: z.array(z.number()).optional(),
+    git_state: GitStateSchema.optional(),
+    save_reason: z.string().optional(),
+    saved_at: z.string().optional(),
+    session_id: z.string().optional(),
+    transcript_path: z.string().optional(),
+})
+    .passthrough();
+// §1.3
+export const TaskSchema = z
+    .object({
+    active_form: z.string(),
+    completed_at: z.string().nullable(),
+    created_at: z.string(),
+    description: z.string(),
+    evidence: z.string(),
+    files_changed: z.array(z.string()),
+    id: z.string(),
+    session_id: z.string().optional(),
+    status: z.enum(["blocked", "completed", "in_progress", "pending"]),
+    subject: z.string(),
+    work_summary: z.string(),
+})
+    .passthrough();
+// §1.1 (continued)
+export const ContextStateSchema = z
+    .object({
+    created_at: z.string(),
+    handoff_consumed: z.boolean().optional(), // deprecated
+    handoff_path: z.string().nullable().optional(),
+    id: z.string(),
+    last_active: z.string(),
+    last_session: LastSessionSchema.nullable().optional(),
+    method: z.string(),
+    mode: ModeSchema,
+    next_artifact_type: z.enum(["handoff", "plan"]).nullable().optional(),
+    plan_anchors: z.array(z.string()).optional(),
+    plan_consumed: z.boolean().optional(), // deprecated
+    plan_hash: z.string().nullable().optional(),
+    plan_hash_consumed: z.string().nullable().optional(),
+    plan_id: z.string().nullable().optional(),
+    plan_path: z.string().nullable().optional(),
+    plan_signature: z.string().nullable().optional(),
+    session_ids: z.array(z.string()).optional(),
+    status: z.enum(["active", "completed"]),
+    summary: z.string(),
+    tags: z.array(z.string()).optional(),
+    tasks: z.array(TaskSchema).optional(),
+    work_consumed: z.boolean().optional(),
+})
+    .passthrough();
+// §1.4
+export const IndexEntrySchema = z
+    .object({
+    last_active: z.string(),
+    mode: z.string(),
+    summary: z.string(),
+})
+    .passthrough();
+export const IndexFileSchema = z
+    .object({
+    contexts: z.record(z.string(), IndexEntrySchema),
+    sessions: z.record(z.string(), z.string()),
+    updated_at: z.string(),
+    version: z.literal("3.0"),
+})
+    .passthrough();
+// §1.5
+export const LogEntrySchema = z
+    .object({
+    component: z.string().optional(),
+    data: z.unknown().optional(),
+    hook: z.string(),
+    level: z.enum(["debug", "error", "info", "warn"]),
+    msg: z.string(),
+    tb: z.string().optional(),
+    ts: z.string(),
+})
+    .passthrough();
+// §1.6
+export const HookInputSchema = z
+    .object({
+    context_window: z
+        .object({
+        context_window_size: z.number().optional(),
+        current_usage: z
+            .object({
+            cache_creation_input_tokens: z.number().optional(),
+            cache_read_input_tokens: z.number().optional(),
+            input_tokens: z.number().optional(),
+            output_tokens: z.number().optional(),
+        })
+            .passthrough()
+            .optional(),
+    })
+        .passthrough()
+        .optional(),
+    cwd: z.string().optional(),
+    hook_event_name: z.string(),
+    permission_mode: z.string().optional(),
+    session_id: z.string().optional(),
+    source: z.string().optional(),
+    tool_input: z.record(z.string(), z.unknown()).optional(),
+    tool_name: z.string().optional(),
+    tool_result: z.string().optional(),
+    transcript_path: z.string().optional(),
+})
+    .passthrough();
+// §1.7
+export const HookOutputSchema = z
+    .object({
+    decision: z.literal("block").optional(),
+    hookSpecificOutput: z
+        .object({
+        additionalContext: z.string().optional(),
+        hookEventName: z.string().optional(),
+        permissionDecision: z.enum(["allow", "ask", "deny"]).optional(),
+        permissionDecisionReason: z.string().optional(),
+        updatedInput: z.record(z.string(), z.unknown()).optional(),
+    })
+        .passthrough()
+        .optional(),
+    reason: z.string().optional(),
+})
+    .passthrough();
+// §1.7b
+export const PermissionRequestOutputSchema = z
+    .object({
+    decision: z.object({
+        behavior: z.enum(["allow", "deny"]),
+        message: z.string().optional(),
+        updatedInput: z.record(z.string(), z.unknown()).optional(),
+        updatedPermissions: z.record(z.string(), z.unknown()).optional(),
+    }),
+})
+    .passthrough();
+// §1.8
+export const InferenceResultSchema = z
+    .object({
+    error: z.string().optional(),
+    latency_ms: z.number(),
+    output: z.string(),
+    success: z.boolean(),
+})
+    .passthrough();
+// §1.9
+export const HandoffDocumentSchema = z
+    .object({
+    active_tasks: z.array(TaskSchema),
+    completed_tasks_this_session: z.array(z.object({ subject: z.string() }).passthrough()),
+    context_folder: z.string(),
+    context_id: z.string(),
+    context_summary: z.string(),
+    created_at: z.string(),
+    events_log_path: z.string(),
+    file_path: z.string().nullable(),
+    important_notes: z.array(z.string()),
+    next_steps: z.array(z.string()),
+    plan_path: z.string().nullable(),
+    reason: z.string(),
+    session_id: z.string(),
+    work_summary: z.string(),
+})
+    .passthrough();
+// §1.10
+export const HandoffSectionsSchema = z
+    .object({
+    completedWork: z.string().nullable(),
+    context: z.string().nullable(),
+    deadEnds: z.string().nullable(),
+    decisions: z.string().nullable(),
+    index: z.string().nullable(),
+    pending: z.string().nullable(),
+    plan: z.string().nullable(),
+})
+    .passthrough();
+// §1.11
+export const CaretCommandSchema = z
+    .object({
+    ends: z.array(z.string()),
+    new_context_desc: z.string().nullable(),
+    remaining_prompt: z.string(),
+    select: z.string().nullable(),
+})
+    .passthrough();
+// §1.13
+export const AgentConfigSchema = z
+    .object({
+    categories: z.array(z.string()),
+    description: z.string(),
+    focus: z.string(),
+    model: z.string(),
+    name: z.string(),
+    provider: z.string(),
+    system_prompt: z.string(),
+})
+    .passthrough();

package/dist/lib/sentinel-manager.d.ts

@@ -0,0 +1,32 @@
+/**
+ * SentinelManager — owns sentinel IPC lifecycle (creation, wait, cleanup).
+ * Replaces scattered createSentinelIpcPaths + cleanupSentinelIpc across backends.
+ */
+import { type SentinelIpcPaths } from './runtime/sentinel-ipc.js';
+export interface SentinelIO {
+    create(toolName: string): SentinelIpcPaths;
+    waitForExit(sentinelPath: string, timeoutMs: number): Promise<number | null>;
+    cleanup(paths: SentinelIpcPaths): void;
+}
+export declare class SentinelManager {
+    private readonly tracked;
+    private readonly io;
+    constructor(io?: SentinelIO);
+    /**
+     * Create a sentinel IPC path set for tracking a pane's exit code.
+     * Returns the sentinelPath string, or undefined if disabled.
+     */
+    create(toolName: string, enabled?: boolean): string | undefined;
+    /**
+     * Wait for the sentinel file to be written, then read the exit code.
+     */
+    waitForExit(sentinelPath: string, timeoutMs?: number): Promise<number | null>;
+    /**
+     * Clean up a specific sentinel by its path.
+     */
+    cleanup(sentinelPath: string): void;
+    /**
+     * Clean up all tracked sentinels. Call in finally block.
+     */
+    cleanupAll(): void;
+}

package/dist/lib/sentinel-manager.js

@@ -0,0 +1,62 @@
+/**
+ * SentinelManager — owns sentinel IPC lifecycle (creation, wait, cleanup).
+ * Replaces scattered createSentinelIpcPaths + cleanupSentinelIpc across backends.
+ */
+import { cleanupSentinelIpc, createSentinelIpcPaths, readSentinelExitCode, waitForSentinelFile, } from './runtime/sentinel-ipc.js';
+const defaultIO = {
+    create(toolName) {
+        return createSentinelIpcPaths(`aiwcli-pane-${toolName}`);
+    },
+    async waitForExit(sentinelPath, timeoutMs) {
+        const found = await waitForSentinelFile(sentinelPath, timeoutMs);
+        return found ? readSentinelExitCode(sentinelPath, 1) : null;
+    },
+    cleanup(paths) {
+        cleanupSentinelIpc(paths);
+    },
+};
+export class SentinelManager {
+    tracked = [];
+    io;
+    constructor(io) {
+        this.io = io ?? defaultIO;
+    }
+    /**
+     * Create a sentinel IPC path set for tracking a pane's exit code.
+     * Returns the sentinelPath string, or undefined if disabled.
+     */
+    create(toolName, enabled = true) {
+        if (!enabled)
+            return undefined;
+        const paths = this.io.create(toolName);
+        this.tracked.push(paths);
+        return paths.sentinelPath;
+    }
+    /**
+     * Wait for the sentinel file to be written, then read the exit code.
+     */
+    async waitForExit(sentinelPath, timeoutMs = 14_400_000) {
+        return this.io.waitForExit(sentinelPath, timeoutMs);
+    }
+    /**
+     * Clean up a specific sentinel by its path.
+     */
+    cleanup(sentinelPath) {
+        const entry = this.tracked.find((p) => p.sentinelPath === sentinelPath);
+        if (entry) {
+            this.io.cleanup(entry);
+            const index = this.tracked.indexOf(entry);
+            if (index >= 0)
+                this.tracked.splice(index, 1);
+        }
+    }
+    /**
+     * Clean up all tracked sentinels. Call in finally block.
+     */
+    cleanupAll() {
+        for (const paths of this.tracked) {
+            this.io.cleanup(paths);
+        }
+        this.tracked.length = 0;
+    }
+}

package/dist/lib/sentinel-wrapper.d.ts

@@ -0,0 +1,10 @@
+export interface SentinelWrapParams {
+    autoClose: boolean;
+    autoCloseCommand?: string | undefined;
+    command: string;
+    holdMessage: string;
+    holdPane: boolean;
+    sentinelPath: string;
+}
+export declare function wrapSentinelSh(params: SentinelWrapParams): string;
+export declare function wrapSentinelPowerShell(params: SentinelWrapParams): string;

package/dist/lib/sentinel-wrapper.js

@@ -0,0 +1,29 @@
+import { quoteForPowerShell, quoteForSh } from './shell-quoting.js';
+export function wrapSentinelSh(params) {
+    const { command, sentinelPath, autoClose, holdPane, holdMessage } = params;
+    const quoted = quoteForSh(sentinelPath);
+    // Trap HUP/INT/TERM so the sentinel is written even if the pane is killed.
+    const trap = `trap 'printf "%s" "130" > ${quoted}; exit 130' HUP INT TERM`;
+    const base = `${trap}; ${command}; code=$?; printf '%s' "$code" > ${quoted}`;
+    if (autoClose) {
+        const killCmd = params.autoCloseCommand
+            ?? 'tmux kill-pane -t "$TMUX_PANE" >/dev/null 2>&1 || true';
+        return `${base}; ${killCmd}; exit $code`;
+    }
+    if (holdPane) {
+        // Launch an interactive login shell to hold the pane open.
+        // Use "$BASH" (current bash) to avoid resolving to WSL's bash.
+        // Do NOT use 'exec' — on MSYS2/Windows exec emulates by spawning a new
+        // process and exiting the original, which causes WezTerm to close the pane.
+        return `${base}; echo; echo ${quoteForSh(holdMessage)}; "$BASH" -li`;
+    }
+    return `${base}; exit $code`;
+}
+export function wrapSentinelPowerShell(params) {
+    const { command, sentinelPath, autoClose, holdPane, holdMessage } = params;
+    const base = `${command}; $code = $LASTEXITCODE; Set-Content -Path ${quoteForPowerShell(sentinelPath)} -Value $code -NoNewline`;
+    if (holdPane && !autoClose) {
+        return `${base}; Write-Host ''; Write-Host ${quoteForPowerShell(holdMessage)}; Read-Host -Prompt 'Press Enter to close' | Out-Null`;
+    }
+    return `${base}; exit $code`;
+}

package/dist/lib/settings-hierarchy.js

@@ -1,7 +1,7 @@
-import { promises as fs } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { IdePathResolver } from './ide-path-resolver.js';
+import { readJsonFile, writeJsonFile } from './json-io.js';
 import { pathExists } from './paths.js';
 /**
  * Discover Claude settings files in the hierarchy
@@ -46,14 +46,7 @@ export async function discoverSettingsFiles(projectDir) {
  * @returns Parsed settings or undefined if file doesn't exist or is invalid
  */
 export async function readClaudeSettings(path) {
-    try {
-        const content = await fs.readFile(path, 'utf8');
-        return JSON.parse(content);
-    }
-    catch {
-        // File doesn't exist or invalid JSON
-        return undefined;
-    }
+    return readJsonFile(path);
 }
 /**
  * Write Claude settings to file
@@ -66,17 +59,7 @@ export async function readClaudeSettings(path) {
  * @throws Error if write fails
  */
 export async function writeClaudeSettings(path, settings) {
-    // Create parent directory if it doesn't exist
-    const dir = join(path, '..');
-    await fs.mkdir(dir, { recursive: true });
-    // Backup existing file if it exists
-    if (await pathExists(path)) {
-        const backupPath = `${path}.backup`;
-        await fs.copyFile(path, backupPath);
-    }
-    // Write settings with pretty formatting
-    const content = JSON.stringify(settings, null, 2);
-    await fs.writeFile(path, content, 'utf8');
+    return writeJsonFile(path, settings, { backup: true });
 }
 /**
  * Get the target settings file for template hook merging

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

@@ -0,0 +1,18 @@
+/**
+ * BashAdapter — ShellAdapter for bash (Unix + MSYS2/Git Bash on Windows).
+ * 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 BashAdapter implements ShellAdapter {
+    readonly dialect: "bash";
+    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;
+}