@oka-core/reason 0.2.15 → 0.2.16

package/dist/abort-controller.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AbortController factory with listener-limit management and
+ * memory-safe parent→child propagation via WeakRef.
+ *
+ * Inspired by Claude Code's `src/utils/abortController.ts`.
+ */
+/**
+ * Create an AbortController with raised listener limit to prevent
+ * MaxListenersExceededWarning when many consumers share one signal.
+ */
+export declare function createAbortController(maxListeners?: number): AbortController;
+/**
+ * Create a child AbortController that aborts when its parent aborts.
+ * Aborting the child does NOT affect the parent.
+ *
+ * Memory-safe: uses WeakRef so the parent doesn't retain abandoned children.
+ */
+export declare function createChildAbortController(parent: AbortController, maxListeners?: number): AbortController;
+//# sourceMappingURL=abort-controller.d.ts.map

package/dist/abort-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort-controller.d.ts","sourceRoot":"","sources":["../src/abort-controller.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,GAAE,MAA8B,GAC3C,eAAe,CAQjB;AAuBD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,eAAe,EACvB,YAAY,CAAC,EAAE,MAAM,GACpB,eAAe,CAqBjB"}

package/dist/abort-controller.js

@@ -0,0 +1,53 @@
+/**
+ * AbortController factory with listener-limit management and
+ * memory-safe parent→child propagation via WeakRef.
+ *
+ * Inspired by Claude Code's `src/utils/abortController.ts`.
+ */
+import { setMaxListeners } from "events";
+const DEFAULT_MAX_LISTENERS = 50;
+/**
+ * Create an AbortController with raised listener limit to prevent
+ * MaxListenersExceededWarning when many consumers share one signal.
+ */
+export function createAbortController(maxListeners = DEFAULT_MAX_LISTENERS) {
+    const controller = new AbortController();
+    try {
+        setMaxListeners(maxListeners, controller.signal);
+    }
+    catch {
+        /* runtime doesn't support setMaxListeners on EventTarget */
+    }
+    return controller;
+}
+// ── WeakRef-based parent→child propagation ────────────────────────
+function propagateAbort(weakChild) {
+    const parent = this.deref();
+    weakChild.deref()?.abort(parent?.signal.reason);
+}
+function removeAbortHandler(weakHandler) {
+    const parent = this.deref();
+    const handler = weakHandler.deref();
+    if (parent && handler) {
+        parent.signal.removeEventListener("abort", handler);
+    }
+}
+/**
+ * Create a child AbortController that aborts when its parent aborts.
+ * Aborting the child does NOT affect the parent.
+ *
+ * Memory-safe: uses WeakRef so the parent doesn't retain abandoned children.
+ */
+export function createChildAbortController(parent, maxListeners) {
+    const child = createAbortController(maxListeners);
+    if (parent.signal.aborted) {
+        child.abort(parent.signal.reason);
+        return child;
+    }
+    const weakChild = new WeakRef(child);
+    const weakParent = new WeakRef(parent);
+    const handler = propagateAbort.bind(weakParent, weakChild);
+    parent.signal.addEventListener("abort", handler, { once: true });
+    child.signal.addEventListener("abort", removeAbortHandler.bind(weakParent, new WeakRef(handler)), { once: true });
+    return child;
+}

package/dist/activity-tracker.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Activity tracker for user vs CLI operation time tracking.
+ *
+ * Tracks overlapping operations with automatic deduplication.
+ * Injectable time source and callback for clean architecture.
+ *
+ * Extracted from Claude Code's ActivityManager — stripped singleton,
+ * bootstrap state, and metric counter coupling.
+ */
+export type ActivityType = "user" | "cli";
+export type ActivityRecord = {
+    type: ActivityType;
+    durationSeconds: number;
+};
+export type ActivityTrackerOptions = {
+    /** Time source (default: Date.now). */
+    getNow?: () => number;
+    /** Called when an activity period ends with its type and duration. */
+    onRecord?: (record: ActivityRecord) => void;
+    /** User inactivity timeout in ms (default: 5000). */
+    userTimeoutMs?: number;
+};
+export type ActivityStates = {
+    isUserActive: boolean;
+    isCliActive: boolean;
+    activeOperationCount: number;
+};
+export declare class ActivityTracker {
+    private activeOperations;
+    private lastUserActivityTime;
+    private lastCliRecordedTime;
+    private isCliActive;
+    private readonly getNow;
+    private readonly onRecord;
+    private readonly userTimeoutMs;
+    constructor(options?: ActivityTrackerOptions);
+    /** Record a user interaction (typing, clicking, etc.). */
+    recordUserActivity(): void;
+    /** Start tracking a CLI operation. Duplicate IDs are force-ended first. */
+    startActivity(operationId: string): void;
+    /** End tracking a CLI operation. Records CLI time when last op ends. */
+    endActivity(operationId: string): void;
+    /** Track an async operation automatically. */
+    trackOperation<T>(operationId: string, fn: () => Promise<T>): Promise<T>;
+    /** Get current activity states. */
+    getActivityStates(): ActivityStates;
+}
+//# sourceMappingURL=activity-tracker.d.ts.map

package/dist/activity-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-tracker.d.ts","sourceRoot":"","sources":["../src/activity-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,KAAK,CAAC;AAE1C,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,YAAY,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,uCAAuC;IACvC,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;IACtB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IAC5C,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;IACrB,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,qBAAa,eAAe;IAC1B,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,OAAO,CAAC,oBAAoB,CAAK;IACjC,OAAO,CAAC,mBAAmB,CAAS;IACpC,OAAO,CAAC,WAAW,CAAS;IAE5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAe;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmC;IAC5D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;gBAE3B,OAAO,CAAC,EAAE,sBAAsB;IAO5C,0DAA0D;IAC1D,kBAAkB,IAAI,IAAI;IAW1B,2EAA2E;IAC3E,aAAa,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAYxC,wEAAwE;IACxE,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAatC,8CAA8C;IACxC,cAAc,CAAC,CAAC,EACpB,WAAW,EAAE,MAAM,EACnB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC;IASb,mCAAmC;IACnC,iBAAiB,IAAI,cAAc;CAUpC"}

package/dist/activity-tracker.js

@@ -0,0 +1,80 @@
+/**
+ * Activity tracker for user vs CLI operation time tracking.
+ *
+ * Tracks overlapping operations with automatic deduplication.
+ * Injectable time source and callback for clean architecture.
+ *
+ * Extracted from Claude Code's ActivityManager — stripped singleton,
+ * bootstrap state, and metric counter coupling.
+ */
+export class ActivityTracker {
+    activeOperations = new Set();
+    lastUserActivityTime = 0;
+    lastCliRecordedTime;
+    isCliActive = false;
+    getNow;
+    onRecord;
+    userTimeoutMs;
+    constructor(options) {
+        this.getNow = options?.getNow ?? (() => Date.now());
+        this.onRecord = options?.onRecord ?? (() => { });
+        this.userTimeoutMs = options?.userTimeoutMs ?? 5000;
+        this.lastCliRecordedTime = this.getNow();
+    }
+    /** Record a user interaction (typing, clicking, etc.). */
+    recordUserActivity() {
+        if (!this.isCliActive && this.lastUserActivityTime !== 0) {
+            const now = this.getNow();
+            const elapsed = (now - this.lastUserActivityTime) / 1000;
+            if (elapsed > 0 && elapsed < this.userTimeoutMs / 1000) {
+                this.onRecord({ type: "user", durationSeconds: elapsed });
+            }
+        }
+        this.lastUserActivityTime = this.getNow();
+    }
+    /** Start tracking a CLI operation. Duplicate IDs are force-ended first. */
+    startActivity(operationId) {
+        if (this.activeOperations.has(operationId)) {
+            this.endActivity(operationId);
+        }
+        const wasEmpty = this.activeOperations.size === 0;
+        this.activeOperations.add(operationId);
+        if (wasEmpty) {
+            this.isCliActive = true;
+            this.lastCliRecordedTime = this.getNow();
+        }
+    }
+    /** End tracking a CLI operation. Records CLI time when last op ends. */
+    endActivity(operationId) {
+        this.activeOperations.delete(operationId);
+        if (this.activeOperations.size === 0) {
+            const now = this.getNow();
+            const elapsed = (now - this.lastCliRecordedTime) / 1000;
+            if (elapsed > 0) {
+                this.onRecord({ type: "cli", durationSeconds: elapsed });
+            }
+            this.lastCliRecordedTime = now;
+            this.isCliActive = false;
+        }
+    }
+    /** Track an async operation automatically. */
+    async trackOperation(operationId, fn) {
+        this.startActivity(operationId);
+        try {
+            return await fn();
+        }
+        finally {
+            this.endActivity(operationId);
+        }
+    }
+    /** Get current activity states. */
+    getActivityStates() {
+        const now = this.getNow();
+        const elapsed = (now - this.lastUserActivityTime) / 1000;
+        return {
+            isUserActive: this.lastUserActivityTime > 0 && elapsed < this.userTimeoutMs / 1000,
+            isCliActive: this.isCliActive,
+            activeOperationCount: this.activeOperations.size,
+        };
+    }
+}

package/dist/analytics.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Analytics decoupling layer — deferred sink attachment with PII safety.
+ *
+ * ZERO external dependencies — pure domain layer.
+ *
+ * Inspired by Claude Code's analytics pattern:
+ * - Events queue before any sink is attached (startup race-free)
+ * - Drain happens via queueMicrotask (non-blocking)
+ * - PII-marked fields are stripped before forwarding to sink
+ * - _resetForTesting() ensures test isolation
+ */
+/** A single analytics event. */
+export interface AnalyticsEvent {
+    /** Machine-readable event name (e.g., "tool.invoked", "search.completed"). */
+    name: string;
+    /** Event properties. Keys prefixed with `_pii:` are stripped before sink. */
+    properties: Record<string, unknown>;
+    /** ISO timestamp — defaults to now. */
+    timestamp?: string;
+}
+/** Sink port — implement this to send events to your telemetry backend. */
+export interface AnalyticsSink {
+    track(event: AnalyticsEvent): void;
+    flush?(): Promise<void>;
+}
+/**
+ * Analytics tracker with deferred sink attachment.
+ *
+ * Events are queued until a sink is attached, then drained via microtask.
+ * PII-marked properties are stripped before forwarding.
+ */
+export declare class AnalyticsTracker {
+    private sink;
+    private queue;
+    private drainScheduled;
+    /** Attach a sink and drain any queued events. */
+    attach(sink: AnalyticsSink): void;
+    /** Track an event. If no sink is attached, queues for later delivery. */
+    track(name: string, properties?: Record<string, unknown>): void;
+    /** Flush the underlying sink (if it supports flushing). */
+    flush(): Promise<void>;
+    /** Reset all state — for test isolation only. */
+    _resetForTesting(): void;
+    private forward;
+    private scheduleDrain;
+}
+/** Default global tracker instance. */
+export declare const analytics: AnalyticsTracker;
+//# sourceMappingURL=analytics.d.ts.map

package/dist/analytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytics.d.ts","sourceRoot":"","sources":["../src/analytics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,gCAAgC;AAChC,MAAM,WAAW,cAAc;IAC7B,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,uCAAuC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAC;IACnC,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAqBD;;;;;GAKG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,IAAI,CAA8B;IAC1C,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,cAAc,CAAS;IAE/B,iDAAiD;IACjD,MAAM,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI;IAKjC,yEAAyE;IACzE,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,IAAI;IAanE,2DAA2D;IACrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,iDAAiD;IACjD,gBAAgB,IAAI,IAAI;IAMxB,OAAO,CAAC,OAAO;IASf,OAAO,CAAC,aAAa;CAWtB;AAID,uCAAuC;AACvC,eAAO,MAAM,SAAS,kBAAyB,CAAC"}

package/dist/analytics.js

@@ -0,0 +1,88 @@
+/**
+ * Analytics decoupling layer — deferred sink attachment with PII safety.
+ *
+ * ZERO external dependencies — pure domain layer.
+ *
+ * Inspired by Claude Code's analytics pattern:
+ * - Events queue before any sink is attached (startup race-free)
+ * - Drain happens via queueMicrotask (non-blocking)
+ * - PII-marked fields are stripped before forwarding to sink
+ * - _resetForTesting() ensures test isolation
+ */
+// ─── PII Stripping ──────────────────────────────────────────────────
+const PII_PREFIX = "_pii:";
+/** Remove any property whose key starts with `_pii:` — returns a clean copy. */
+function stripPii(properties) {
+    const clean = {};
+    for (const [key, value] of Object.entries(properties)) {
+        if (!key.startsWith(PII_PREFIX)) {
+            clean[key] = value;
+        }
+    }
+    return clean;
+}
+// ─── Tracker ────────────────────────────────────────────────────────
+/**
+ * Analytics tracker with deferred sink attachment.
+ *
+ * Events are queued until a sink is attached, then drained via microtask.
+ * PII-marked properties are stripped before forwarding.
+ */
+export class AnalyticsTracker {
+    sink = null;
+    queue = [];
+    drainScheduled = false;
+    /** Attach a sink and drain any queued events. */
+    attach(sink) {
+        this.sink = sink;
+        this.scheduleDrain();
+    }
+    /** Track an event. If no sink is attached, queues for later delivery. */
+    track(name, properties = {}) {
+        const event = {
+            name,
+            properties,
+            timestamp: new Date().toISOString(),
+        };
+        if (this.sink) {
+            this.forward(event);
+        }
+        else {
+            this.queue.push(event);
+        }
+    }
+    /** Flush the underlying sink (if it supports flushing). */
+    async flush() {
+        await this.sink?.flush?.();
+    }
+    /** Reset all state — for test isolation only. */
+    _resetForTesting() {
+        this.sink = null;
+        this.queue = [];
+        this.drainScheduled = false;
+    }
+    forward(event) {
+        if (!this.sink)
+            return; // Guard against drain after reset
+        const clean = {
+            ...event,
+            properties: stripPii(event.properties),
+        };
+        this.sink.track(clean);
+    }
+    scheduleDrain() {
+        if (this.drainScheduled || this.queue.length === 0)
+            return;
+        this.drainScheduled = true;
+        queueMicrotask(() => {
+            this.drainScheduled = false;
+            const events = this.queue.splice(0);
+            for (const event of events) {
+                this.forward(event);
+            }
+        });
+    }
+}
+// ─── Singleton ──────────────────────────────────────────────────────
+/** Default global tracker instance. */
+export const analytics = new AnalyticsTracker();

package/dist/array.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Functional array utilities — zero dependencies.
+ *
+ * Inspired by Claude Code's `src/utils/array.ts`.
+ */
+/** Interleave a separator (computed from index) between array elements. */
+export declare function intersperse<A>(as: A[], separator: (index: number) => A): A[];
+/** Count elements matching a predicate. */
+export declare function count<T>(arr: readonly T[], pred: (x: T) => unknown): number;
+/** Deduplicate via Set, preserving insertion order. */
+export declare function uniq<T>(xs: Iterable<T>): T[];
+//# sourceMappingURL=array.d.ts.map

package/dist/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,CAAC,EAAE,CAE5E;AAED,2CAA2C;AAC3C,wBAAgB,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,MAAM,CAI3E;AAED,uDAAuD;AACvD,wBAAgB,IAAI,CAAC,CAAC,EAAE,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAE5C"}

package/dist/array.js

@@ -0,0 +1,20 @@
+/**
+ * Functional array utilities — zero dependencies.
+ *
+ * Inspired by Claude Code's `src/utils/array.ts`.
+ */
+/** Interleave a separator (computed from index) between array elements. */
+export function intersperse(as, separator) {
+    return as.flatMap((a, i) => (i ? [separator(i), a] : [a]));
+}
+/** Count elements matching a predicate. */
+export function count(arr, pred) {
+    let n = 0;
+    for (const x of arr)
+        n += +!!pred(x);
+    return n;
+}
+/** Deduplicate via Set, preserving insertion order. */
+export function uniq(xs) {
+    return [...new Set(xs)];
+}

package/dist/async-context.d.ts

@@ -0,0 +1,20 @@
+/**
+ * AsyncLocalStorage-based CWD override for concurrent async contexts.
+ *
+ * Enables multiple agents to each see their own working directory
+ * without affecting each other or the global process.cwd().
+ *
+ * Inspired by Claude Code's `src/utils/cwd.ts`.
+ */
+/**
+ * Run a function with an overridden working directory for the current
+ * async context. All calls to `getContextCwd()` within `fn` (and its
+ * async descendants) will return `cwd`.
+ */
+export declare function runWithCwdOverride<T>(cwd: string, fn: () => T): T;
+/**
+ * Get the current working directory, respecting any active override.
+ * Falls back to `process.cwd()` when no override is set.
+ */
+export declare function getContextCwd(): string;
+//# sourceMappingURL=async-context.d.ts.map

package/dist/async-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-context.d.ts","sourceRoot":"","sources":["../src/async-context.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAEjE;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC"}

package/dist/async-context.js

@@ -0,0 +1,25 @@
+/**
+ * AsyncLocalStorage-based CWD override for concurrent async contexts.
+ *
+ * Enables multiple agents to each see their own working directory
+ * without affecting each other or the global process.cwd().
+ *
+ * Inspired by Claude Code's `src/utils/cwd.ts`.
+ */
+import { AsyncLocalStorage } from "async_hooks";
+const cwdOverrideStorage = new AsyncLocalStorage();
+/**
+ * Run a function with an overridden working directory for the current
+ * async context. All calls to `getContextCwd()` within `fn` (and its
+ * async descendants) will return `cwd`.
+ */
+export function runWithCwdOverride(cwd, fn) {
+    return cwdOverrideStorage.run(cwd, fn);
+}
+/**
+ * Get the current working directory, respecting any active override.
+ * Falls back to `process.cwd()` when no override is set.
+ */
+export function getContextCwd() {
+    return cwdOverrideStorage.getStore() ?? process.cwd();
+}

package/dist/binary-check.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Session-cached binary existence probe.
+ *
+ * Checks whether a command is installed via the platform's `which` / `where`.
+ * Results are cached for the process lifetime.
+ *
+ * Inspired by Claude Code's `src/utils/binaryCheck.ts`.
+ */
+/**
+ * Check if a binary/command is installed and available on the system.
+ * Results are cached for the process lifetime.
+ */
+export declare function isBinaryInstalled(command: string): Promise<boolean>;
+/** Clear the binary check cache (useful for testing). */
+export declare function clearBinaryCache(): void;
+//# sourceMappingURL=binary-check.d.ts.map

package/dist/binary-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-check.d.ts","sourceRoot":"","sources":["../src/binary-check.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAoBH;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUzE;AAED,yDAAyD;AACzD,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}

package/dist/binary-check.js

@@ -0,0 +1,43 @@
+/**
+ * Session-cached binary existence probe.
+ *
+ * Checks whether a command is installed via the platform's `which` / `where`.
+ * Results are cached for the process lifetime.
+ *
+ * Inspired by Claude Code's `src/utils/binaryCheck.ts`.
+ */
+import { execFile } from "child_process";
+const binaryCache = new Map();
+/** Resolve a command to its path, or null if not found. */
+function which(command) {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    return new Promise((resolve) => {
+        execFile(cmd, [command], (err, stdout) => {
+            if (err) {
+                resolve(null);
+            }
+            else {
+                resolve(stdout.trim() || null);
+            }
+        });
+    });
+}
+/**
+ * Check if a binary/command is installed and available on the system.
+ * Results are cached for the process lifetime.
+ */
+export async function isBinaryInstalled(command) {
+    if (!command || !command.trim())
+        return false;
+    const trimmed = command.trim();
+    const cached = binaryCache.get(trimmed);
+    if (cached !== undefined)
+        return cached;
+    const exists = (await which(trimmed)) !== null;
+    binaryCache.set(trimmed, exists);
+    return exists;
+}
+/** Clear the binary check cache (useful for testing). */
+export function clearBinaryCache() {
+    binaryCache.clear();
+}

package/dist/buffered-writer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Batched I/O writer with backpressure — zero external dependencies.
+ *
+ * Batches writes by count, byte size, or time interval. Overflow batches
+ * are deferred via `setImmediate` to keep the current tick fast.
+ *
+ * Inspired by Claude Code's `src/utils/bufferedWriter.ts`.
+ */
+export type BufferedWriter = {
+    /** Append content to the buffer. May trigger an async flush on overflow. */
+    write: (content: string) => void;
+    /** Flush all buffered content immediately. */
+    flush: () => void;
+    /** Flush and stop the periodic timer. */
+    dispose: () => void;
+};
+export type BufferedWriterOptions = {
+    /** The function that actually writes a batch of content. */
+    writeFn: (batch: string[]) => void;
+    /** Flush interval in ms. Default: 1000. */
+    flushIntervalMs?: number;
+    /** Max items before overflow flush. Default: 100. */
+    maxBufferSize?: number;
+    /** Max total bytes before overflow flush. Default: Infinity. */
+    maxBufferBytes?: number;
+    /** Bypass buffering entirely — write immediately. Default: false. */
+    immediateMode?: boolean;
+};
+export declare function createBufferedWriter(opts: BufferedWriterOptions): BufferedWriter;
+//# sourceMappingURL=buffered-writer.d.ts.map

package/dist/buffered-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffered-writer.d.ts","sourceRoot":"","sources":["../src/buffered-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,MAAM,MAAM,cAAc,GAAG;IAC3B,4EAA4E;IAC5E,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,8CAA8C;IAC9C,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,yCAAyC;IACzC,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,4DAA4D;IAC5D,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;IACnC,2CAA2C;IAC3C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,qDAAqD;IACrD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gEAAgE;IAChE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AASF,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,qBAAqB,GAC1B,cAAc,CAsFhB"}

package/dist/buffered-writer.js

@@ -0,0 +1,87 @@
+/**
+ * Batched I/O writer with backpressure — zero external dependencies.
+ *
+ * Batches writes by count, byte size, or time interval. Overflow batches
+ * are deferred via `setImmediate` to keep the current tick fast.
+ *
+ * Inspired by Claude Code's `src/utils/bufferedWriter.ts`.
+ */
+// ─── Factory ────────────────────────────────────────────────────────
+const scheduleImmediate = typeof globalThis.setImmediate === "function"
+    ? globalThis.setImmediate
+    : (fn) => setTimeout(fn, 0);
+export function createBufferedWriter(opts) {
+    const { writeFn, flushIntervalMs = 1000, maxBufferSize = 100, maxBufferBytes = Infinity, immediateMode = false, } = opts;
+    let buffer = [];
+    let bufferBytes = 0;
+    let flushTimer = null;
+    let pendingOverflow = null;
+    function drainOverflow() {
+        if (pendingOverflow) {
+            const batch = pendingOverflow;
+            pendingOverflow = null;
+            writeFn(batch);
+        }
+    }
+    function flushBuffer() {
+        if (buffer.length === 0)
+            return;
+        const batch = buffer;
+        buffer = [];
+        bufferBytes = 0;
+        writeFn(batch);
+    }
+    function scheduleFlush() {
+        if (flushTimer !== null)
+            return;
+        flushTimer = setTimeout(() => {
+            flushTimer = null;
+            flushBuffer();
+        }, flushIntervalMs);
+        if (typeof flushTimer === "object" && "unref" in flushTimer) {
+            flushTimer.unref();
+        }
+    }
+    return {
+        write(content) {
+            if (immediateMode) {
+                writeFn([content]);
+                return;
+            }
+            buffer.push(content);
+            bufferBytes += content.length;
+            if (buffer.length >= maxBufferSize || bufferBytes >= maxBufferBytes) {
+                // Overflow: detach buffer and defer the write
+                const batch = buffer;
+                buffer = [];
+                bufferBytes = 0;
+                if (pendingOverflow) {
+                    pendingOverflow.push(...batch);
+                }
+                else {
+                    pendingOverflow = batch;
+                    scheduleImmediate(drainOverflow);
+                }
+            }
+            else {
+                scheduleFlush();
+            }
+        },
+        flush() {
+            drainOverflow();
+            flushBuffer();
+            if (flushTimer !== null) {
+                clearTimeout(flushTimer);
+                flushTimer = null;
+            }
+        },
+        dispose() {
+            drainOverflow();
+            flushBuffer();
+            if (flushTimer !== null) {
+                clearTimeout(flushTimer);
+                flushTimer = null;
+            }
+        },
+    };
+}

package/dist/circular-buffer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Fixed-size circular buffer — zero external dependencies.
+ *
+ * O(1) add, automatic eviction of oldest entries when capacity is exceeded.
+ * Useful for metrics windows, log tailing, and recent-activity buffers.
+ *
+ * Inspired by Claude Code's `src/utils/CircularBuffer.ts`.
+ */
+export declare class CircularBuffer<T> {
+    private readonly capacity;
+    private buffer;
+    private head;
+    private _size;
+    constructor(capacity: number);
+    /** Add an item, evicting the oldest if at capacity. */
+    add(item: T): void;
+    /** Add multiple items. */
+    addAll(items: T[]): void;
+    /** Get the most recent `count` items in insertion order (oldest first). */
+    getRecent(count?: number): T[];
+    /** Get all items in insertion order (oldest first). */
+    toArray(): T[];
+    /** Remove all items. */
+    clear(): void;
+    /** Current number of items (0 to capacity). */
+    get length(): number;
+}
+//# sourceMappingURL=circular-buffer.d.ts.map

package/dist/circular-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circular-buffer.d.ts","sourceRoot":"","sources":["../src/circular-buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,qBAAa,cAAc,CAAC,CAAC;IAKf,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJrC,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,KAAK,CAAK;gBAEW,QAAQ,EAAE,MAAM;IAO7C,uDAAuD;IACvD,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;IAQlB,0BAA0B;IAC1B,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI;IAMxB,2EAA2E;IAC3E,SAAS,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE;IAa9B,uDAAuD;IACvD,OAAO,IAAI,CAAC,EAAE;IAId,wBAAwB;IACxB,KAAK,IAAI,IAAI;IAKb,+CAA+C;IAC/C,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF"}