instar 0.28.113 → 0.28.115

package/dist/providers/adapters/anthropic-interactive-pool/canary/emptyPromptSignature.js

@@ -0,0 +1,128 @@
+// safe-git-allow: test-helper-cleanup — resetSignatureForTests() removes a single signature file owned by the canary; migration to SafeFsExecutor tracked separately.
+/**
+ * Empty-prompt detector signature store with optional disk persistence.
+ *
+ * The completion-detector in promptRunner.ts reads from here to decide
+ * what to look for in the bottom of the pane buffer when checking
+ * whether Claude Code is at a ready prompt. The default pattern matches
+ * Claude Code's current `❯` glyph; the canary (see {@link emptyPromptCanary})
+ * can re-derive the pattern at startup if the upstream UI evolves and
+ * persist the new signature so future processes inherit it.
+ *
+ * Per Rule 3 of the path constraints (see specs/provider-portability/
+ * 05-state-detection-robustness.md): deterministic state-detection code
+ * against an evolving upstream must self-heal rather than silently fail,
+ * and a self-healed signature should survive process restart so the
+ * recovery cost is paid once, not every boot.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+/** Default signature — matches Claude Code as of 2026-05-15. */
+const DEFAULT_PATTERN = /^❯\s*$/;
+const DEFAULT_PROMPT_LINE_PATTERN = /^❯(\s|$)/;
+const DEFAULT_SIGNATURE = {
+    emptyPromptPattern: DEFAULT_PATTERN,
+    anyPromptLinePattern: DEFAULT_PROMPT_LINE_PATTERN,
+    source: 'default',
+    derivedAt: new Date(0).toISOString(),
+};
+let current = { ...DEFAULT_SIGNATURE };
+let persistedLoadAttempted = false;
+/**
+ * Resolve the path where this process should persist the signature.
+ *
+ * Order of precedence:
+ *   1. `INSTAR_PROVIDER_STATE_DIR` env var (used in tests to redirect
+ *      the persistence location off the real user home).
+ *   2. `~/.instar/providers/anthropic-interactive-pool/`.
+ */
+function signaturePath() {
+    const overrideDir = process.env['INSTAR_PROVIDER_STATE_DIR'];
+    const base = overrideDir
+        ? path.join(overrideDir, 'anthropic-interactive-pool')
+        : path.join(os.homedir(), '.instar', 'providers', 'anthropic-interactive-pool');
+    return path.join(base, 'empty-prompt-signature.json');
+}
+/**
+ * Attempt to load a persisted signature from disk. Idempotent; only
+ * runs the disk read once per process unless `force` is true. Silently
+ * falls back to the default on any error (file absent, parse failure,
+ * regex compile failure, schema mismatch) — persistence is an
+ * optimization, not a correctness path; the canary still runs at
+ * startup and will overwrite anything stale.
+ */
+export function loadPersistedSignature(force = false) {
+    if (persistedLoadAttempted && !force)
+        return current;
+    persistedLoadAttempted = true;
+    try {
+        const raw = fs.readFileSync(signaturePath(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed?.schemaVersion !== 1)
+            return current;
+        const sig = {
+            emptyPromptPattern: new RegExp(parsed.emptyPromptPattern),
+            anyPromptLinePattern: new RegExp(parsed.anyPromptLinePattern),
+            source: parsed.source,
+            derivedAt: parsed.derivedAt,
+        };
+        current = sig;
+    }
+    catch {
+        // No persisted file (or unreadable / unparseable / regex compile
+        // failure) — keep the default. The canary will produce one if
+        // it ends up needing to.
+    }
+    return current;
+}
+/** Read the currently-active signature. The completion detector calls this. */
+export function getSignature() {
+    if (!persistedLoadAttempted)
+        loadPersistedSignature();
+    return current;
+}
+/**
+ * Replace the active signature. Called by the canary when it derives a
+ * new pattern from a known input/output pair. Writes the new signature
+ * to disk best-effort so future processes inherit it; disk failure is
+ * non-fatal (the in-process store still has the new signature, and the
+ * canary re-runs at next startup).
+ */
+export function setSignature(sig) {
+    current = { ...sig, derivedAt: new Date().toISOString() };
+    persistedLoadAttempted = true;
+    try {
+        const filePath = signaturePath();
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        const onDisk = {
+            emptyPromptPattern: current.emptyPromptPattern.source,
+            anyPromptLinePattern: current.anyPromptLinePattern.source,
+            source: current.source,
+            derivedAt: current.derivedAt,
+            schemaVersion: 1,
+        };
+        fs.writeFileSync(filePath, JSON.stringify(onDisk, null, 2), 'utf-8');
+    }
+    catch {
+        // Persistence is best-effort. Failure here doesn't invalidate the
+        // in-process store — the canary already validated the signature
+        // against a real upstream response.
+    }
+}
+/**
+ * Test helper — reset to default AND remove any persisted file in the
+ * current state directory. Tests that exercise persistence should set
+ * `INSTAR_PROVIDER_STATE_DIR` to a tmpdir before invoking.
+ */
+export function resetSignatureForTests() {
+    current = { ...DEFAULT_SIGNATURE };
+    persistedLoadAttempted = false;
+    try {
+        fs.rmSync(signaturePath(), { force: true });
+    }
+    catch {
+        // ignore
+    }
+}
+//# sourceMappingURL=emptyPromptSignature.js.map

package/dist/providers/adapters/anthropic-interactive-pool/canary/emptyPromptSignature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emptyPromptSignature.js","sourceRoot":"","sources":["../../../../../src/providers/adapters/anthropic-interactive-pool/canary/emptyPromptSignature.ts"],"names":[],"mappings":"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"}

package/dist/providers/adapters/anthropic-interactive-pool/canary/poolDecayCanary.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pool decay handler canary.
+ *
+ * Per Rule 3.2 of the path constraints: every state-detection / failure-
+ * handling code path against an evolving system must have a canary that
+ * verifies the handler still works correctly. This canary covers the
+ * replacement-spawn retry path in `pool.ts` (Bug B fix): when a session
+ * retirement triggers a replacement spawn and the spawn fails, the pool
+ * should emit `pool:degraded`, schedule retries with exponential backoff,
+ * and emit `pool:healed` or `pool:degraded_persistent` based on outcome.
+ *
+ * RULE 3.1 RATIONALE
+ *   Criticality: high (silent decay → unbounded allocate timeouts)
+ *   Frequency:   event-driven; canary runs weekly to verify the mechanism still functions
+ *   Stability:   very stable (JS-level errors, not upstream-UI)
+ *   Fallback:    routing policy can route to anthropic-headless when pool is degraded
+ *   Verdict:     deterministic + light canary (weekly cadence)
+ *
+ * Drift risk is low (we control the JS code that defines the contract),
+ * but the canary serves a different purpose here: it verifies the
+ * handler's wiring stays intact through refactors. If a future change
+ * accidentally swallows spawn errors again, this canary fails loudly.
+ *
+ * Cadence: weekly per spec. Doesn't run at every startup; runs at
+ * startup-of-the-week or first startup after the canary's persisted
+ * last-run timestamp has aged out.
+ */
+import { type InteractivePoolConfig } from '../config.js';
+export interface PoolDecayCanaryResult {
+    status: 'pass' | 'fail';
+    message: string;
+    details: {
+        spawnFailureFired: boolean;
+        degradedEventFired: boolean;
+        degradedAttemptValue?: number;
+        retryScheduled: boolean;
+    };
+}
+/**
+ * Run the pool decay canary. Constructs a throwaway pool with a
+ * known-bad claudePath so the spawn deterministically fails, then
+ * observes the emitted events to verify the retry mechanism wired
+ * up correctly.
+ *
+ * The canary does NOT use the live pool — it spawns its own
+ * controlled-failure pool, observes the failure handling, and tears
+ * the test pool down. The live pool is unaffected.
+ */
+export declare function runPoolDecayCanary(config?: Partial<InteractivePoolConfig>): Promise<PoolDecayCanaryResult>;
+//# sourceMappingURL=poolDecayCanary.d.ts.map

package/dist/providers/adapters/anthropic-interactive-pool/canary/poolDecayCanary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poolDecayCanary.d.ts","sourceRoot":"","sources":["../../../../../src/providers/adapters/anthropic-interactive-pool/canary/poolDecayCanary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,EAAiB,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAEzE,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE;QACP,iBAAiB,EAAE,OAAO,CAAC;QAC3B,kBAAkB,EAAE,OAAO,CAAC;QAC5B,oBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,cAAc,EAAE,OAAO,CAAC;KACzB,CAAC;CACH;AAED;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GACtC,OAAO,CAAC,qBAAqB,CAAC,CAqGhC"}

package/dist/providers/adapters/anthropic-interactive-pool/canary/poolDecayCanary.js

@@ -0,0 +1,128 @@
+/**
+ * Pool decay handler canary.
+ *
+ * Per Rule 3.2 of the path constraints: every state-detection / failure-
+ * handling code path against an evolving system must have a canary that
+ * verifies the handler still works correctly. This canary covers the
+ * replacement-spawn retry path in `pool.ts` (Bug B fix): when a session
+ * retirement triggers a replacement spawn and the spawn fails, the pool
+ * should emit `pool:degraded`, schedule retries with exponential backoff,
+ * and emit `pool:healed` or `pool:degraded_persistent` based on outcome.
+ *
+ * RULE 3.1 RATIONALE
+ *   Criticality: high (silent decay → unbounded allocate timeouts)
+ *   Frequency:   event-driven; canary runs weekly to verify the mechanism still functions
+ *   Stability:   very stable (JS-level errors, not upstream-UI)
+ *   Fallback:    routing policy can route to anthropic-headless when pool is degraded
+ *   Verdict:     deterministic + light canary (weekly cadence)
+ *
+ * Drift risk is low (we control the JS code that defines the contract),
+ * but the canary serves a different purpose here: it verifies the
+ * handler's wiring stays intact through refactors. If a future change
+ * accidentally swallows spawn errors again, this canary fails loudly.
+ *
+ * Cadence: weekly per spec. Doesn't run at every startup; runs at
+ * startup-of-the-week or first startup after the canary's persisted
+ * last-run timestamp has aged out.
+ */
+import { InteractivePool } from '../pool.js';
+import { configFromEnv } from '../config.js';
+/**
+ * Run the pool decay canary. Constructs a throwaway pool with a
+ * known-bad claudePath so the spawn deterministically fails, then
+ * observes the emitted events to verify the retry mechanism wired
+ * up correctly.
+ *
+ * The canary does NOT use the live pool — it spawns its own
+ * controlled-failure pool, observes the failure handling, and tears
+ * the test pool down. The live pool is unaffected.
+ */
+export async function runPoolDecayCanary(config) {
+    // Use a bad tmuxPath rather than a bad claudePath. A bad claudePath
+    // wouldn't trip execFileSync (tmux still runs; claude would die inside
+    // the tmux session and waitForReady would only error out after 30s).
+    // A bad tmuxPath makes execFileSync throw synchronously, so the catch
+    // in spawnOne fires immediately and replaceRetired's .catch sees the
+    // error fast — the canary observes the contract without paying the
+    // 30s wait. The wiring being exercised (replaceRetired → spawnOne →
+    // catch → emit degraded → scheduleRetryReplacement) is identical
+    // regardless of which path caused the failure.
+    const testConfig = {
+        ...configFromEnv(),
+        ...config,
+        tmuxPath: '/this/path/does/not/exist/tmux',
+        poolSize: 1,
+        canaryIntervalMs: 0,
+        allocateTimeoutMs: 1_000,
+    };
+    let degradedFired = false;
+    let degradedAttempt;
+    let retryTimerScheduled = false;
+    const pool = new InteractivePool(testConfig);
+    pool.on('pool:degraded', (e) => {
+        degradedFired = true;
+        degradedAttempt = e.attempt;
+    });
+    // Trigger the retire-and-replace path on a fake session that the
+    // pool thinks it owns. The replacement spawn will fail
+    // deterministically (bad claudePath), which should fire the
+    // degraded event and schedule a retry timer.
+    const fakeSession = {
+        id: 'canary-fake',
+        tmuxName: 'canary-fake-tmux',
+        state: 'busy',
+        messageCount: 0,
+        spawnedAt: Date.now(),
+        lastUsedAt: Date.now(),
+    };
+    pool.sessions.set(fakeSession.id, fakeSession);
+    try {
+        await pool.retire(fakeSession);
+    }
+    catch {
+        // retire itself shouldn't throw — but the replacement spawn happens
+        // async via .catch in replaceRetired, so we observe via events.
+    }
+    // Give the synchronous portion of replaceRetired time to fire.
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    // Check that a retry timer was scheduled.
+    retryTimerScheduled =
+        pool.pendingRetryTimers.size > 0;
+    await pool.shutdown();
+    if (!degradedFired) {
+        return {
+            status: 'fail',
+            message: 'pool decay canary: replacement spawn failure did not emit pool:degraded — '
+                + 'the silent-decay regression is back',
+            details: {
+                spawnFailureFired: true,
+                degradedEventFired: false,
+                retryScheduled: retryTimerScheduled,
+            },
+        };
+    }
+    if (!retryTimerScheduled) {
+        return {
+            status: 'fail',
+            message: 'pool decay canary: pool:degraded fired but no retry was scheduled — '
+                + 'the retry-with-backoff path is broken',
+            details: {
+                spawnFailureFired: true,
+                degradedEventFired: true,
+                degradedAttemptValue: degradedAttempt,
+                retryScheduled: false,
+            },
+        };
+    }
+    return {
+        status: 'pass',
+        message: 'pool decay canary: degraded event fired and retry was scheduled',
+        details: {
+            spawnFailureFired: true,
+            degradedEventFired: true,
+            degradedAttemptValue: degradedAttempt,
+            retryScheduled: true,
+        },
+    };
+}
+//# sourceMappingURL=poolDecayCanary.js.map

package/dist/providers/adapters/anthropic-interactive-pool/canary/poolDecayCanary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poolDecayCanary.js","sourceRoot":"","sources":["../../../../../src/providers/adapters/anthropic-interactive-pool/canary/poolDecayCanary.ts"],"names":[],"mappings":"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"}

package/dist/providers/adapters/anthropic-interactive-pool/capabilities.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Capability declaration for the anthropic-interactive-pool adapter.
+ *
+ * Declares ONLY the capabilities the pool actually implements — no
+ * stub-only entries. The previous version claimed the full universal
+ * capability surface even for primitives that were wired to throwing
+ * stubs; the Phase 3c parity harness now catches that as a "declared
+ * but mixed real/stub" lie and fails the suite. The honest fix is to
+ * stop claiming what we don't implement, which is what this file does.
+ *
+ * Primary role: warm REPL pool driven by prompt injection. Owns
+ * WarmSessionInbox and a pool-routed OneShotCompletion. Owns the
+ * session-control primitives the pool needs to manage its REPLs
+ * (HardKill / Interrupt / InputInjection / etc.). Owns
+ * LiveOutputStream / ProcessLifecycle / SessionId for pool-session
+ * observability.
+ *
+ * Anything NOT in this list — long-running autonomous sessions
+ * (AgenticSessionHeadless), capability-layer primitives, asymmetric
+ * observability that reads provider state files (ConversationLogReader,
+ * HookEventReceiver, UsageMeterProvider, etc.), integration primitives
+ * — routes to anthropic-headless via the registry. The pool adapter
+ * does not claim them, so it isn't a candidate.
+ */
+export declare const anthropicInteractivePoolCapabilities: import("../../capabilities.js").CapabilitySet;
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/providers/adapters/anthropic-interactive-pool/capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../../../src/providers/adapters/anthropic-interactive-pool/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,eAAO,MAAM,oCAAoC,+CAoB/C,CAAC"}

package/dist/providers/adapters/anthropic-interactive-pool/capabilities.js

@@ -0,0 +1,45 @@
+/**
+ * Capability declaration for the anthropic-interactive-pool adapter.
+ *
+ * Declares ONLY the capabilities the pool actually implements — no
+ * stub-only entries. The previous version claimed the full universal
+ * capability surface even for primitives that were wired to throwing
+ * stubs; the Phase 3c parity harness now catches that as a "declared
+ * but mixed real/stub" lie and fails the suite. The honest fix is to
+ * stop claiming what we don't implement, which is what this file does.
+ *
+ * Primary role: warm REPL pool driven by prompt injection. Owns
+ * WarmSessionInbox and a pool-routed OneShotCompletion. Owns the
+ * session-control primitives the pool needs to manage its REPLs
+ * (HardKill / Interrupt / InputInjection / etc.). Owns
+ * LiveOutputStream / ProcessLifecycle / SessionId for pool-session
+ * observability.
+ *
+ * Anything NOT in this list — long-running autonomous sessions
+ * (AgenticSessionHeadless), capability-layer primitives, asymmetric
+ * observability that reads provider state files (ConversationLogReader,
+ * HookEventReceiver, UsageMeterProvider, etc.), integration primitives
+ * — routes to anthropic-headless via the registry. The pool adapter
+ * does not claim them, so it isn't a candidate.
+ */
+import { CapabilityFlag, capabilitySet } from '../../capabilities.js';
+export const anthropicInteractivePoolCapabilities = capabilitySet([
+    // ── TRANSPORT (real only) ────────────────────────────────────────────
+    CapabilityFlag.OneShotCompletion, // real — via pool
+    CapabilityFlag.WarmSessionInbox, // PRIMARY — the pool's main contract
+    // ── OBSERVABILITY (only pool-session-state primitives) ───────────────
+    CapabilityFlag.LiveOutputStream,
+    CapabilityFlag.SessionId,
+    CapabilityFlag.ProcessLifecycle,
+    // ── CONTROL (session-management primitives needed by the pool) ───────
+    CapabilityFlag.InputInjection,
+    CapabilityFlag.HardKill,
+    CapabilityFlag.Interrupt,
+    CapabilityFlag.StopGateInterceptor,
+    CapabilityFlag.TimeoutBound,
+    CapabilityFlag.IdleBound,
+    CapabilityFlag.AuthCredentialInjection,
+    CapabilityFlag.ContextScopeControl,
+    CapabilityFlag.CompactionLifecycle,
+]);
+//# sourceMappingURL=capabilities.js.map

package/dist/providers/adapters/anthropic-interactive-pool/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../../../src/providers/adapters/anthropic-interactive-pool/capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAEtE,MAAM,CAAC,MAAM,oCAAoC,GAAG,aAAa,CAAC;IAChE,wEAAwE;IACxE,cAAc,CAAC,iBAAiB,EAAc,kBAAkB;IAChE,cAAc,CAAC,gBAAgB,EAAe,qCAAqC;IAEnF,wEAAwE;IACxE,cAAc,CAAC,gBAAgB;IAC/B,cAAc,CAAC,SAAS;IACxB,cAAc,CAAC,gBAAgB;IAE/B,wEAAwE;IACxE,cAAc,CAAC,cAAc;IAC7B,cAAc,CAAC,QAAQ;IACvB,cAAc,CAAC,SAAS;IACxB,cAAc,CAAC,mBAAmB;IAClC,cAAc,CAAC,YAAY;IAC3B,cAAc,CAAC,SAAS;IACxB,cAAc,CAAC,uBAAuB;IACtC,cAAc,CAAC,mBAAmB;IAClC,cAAc,CAAC,mBAAmB;CACnC,CAAC,CAAC"}

package/dist/providers/adapters/anthropic-interactive-pool/config.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Configuration shape for the anthropic-interactive-pool adapter.
+ */
+import type { CanaryLlmFallback } from './canary/emptyPromptCanary.js';
+export interface InteractivePoolConfig {
+    /** Absolute path to the `claude` CLI binary. */
+    claudePath: string;
+    /** Absolute path to the `tmux` binary. */
+    tmuxPath: string;
+    /** Pool size (number of warm REPL sessions kept available). */
+    poolSize: number;
+    /** Auto-retire a session after this many messages (defends context window). */
+    maxMessagesPerSession: number;
+    /** Auto-retire a session after this many minutes idle. */
+    maxIdleMinutes: number;
+    /** Max wait time when allocating from an empty pool (ms). */
+    allocateTimeoutMs: number;
+    /** Optional Anthropic credential — OAuth subscription token preferred. */
+    credential?: string;
+    /** Optional API base URL override. */
+    apiBaseUrl?: string;
+    /** Working directory for the REPL sessions. */
+    workingDirectory?: string;
+    /**
+     * Idle markers used to detect prompt completion. Inherited from the
+     * feasibility prototype.
+     */
+    idleMarkers: ReadonlyArray<string>;
+    /** Seconds of buffer stability before declaring a response complete. */
+    stabilitySeconds: number;
+    /** Per-prompt max wait in seconds before giving up. */
+    maxPromptWaitSeconds: number;
+    /** Tmux pane width (columns) — wider gives more usable output. */
+    paneWidth: number;
+    /** Tmux pane height (rows). */
+    paneHeight: number;
+    /**
+     * Interval in milliseconds between scheduled empty-prompt canary
+     * checks. Default 1 hour. Setting to 0 disables the scheduled
+     * recurrence (canary still runs at startup). The recurring canary
+     * picks a ready pool session, allocates it, runs a known round-trip,
+     * and self-heals or surfaces failure per Rule 3 of the path
+     * constraints.
+     */
+    canaryIntervalMs: number;
+    /**
+     * Optional LLM fallback for the empty-prompt canary. When deterministic
+     * re-derivation fails (structure shifted enough that the canary can't
+     * extract a new signature), the canary calls this function with the
+     * captured pane to ask a small model whether Claude Code is idle.
+     * Wire via `buildCanaryLlmFallback(intelligence)` from this adapter's
+     * index. Omitting it leaves the canary deterministic-only.
+     */
+    llmFallback?: CanaryLlmFallback;
+}
+export declare function configFromEnv(env?: NodeJS.ProcessEnv): InteractivePoolConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/providers/adapters/anthropic-interactive-pool/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/providers/adapters/anthropic-interactive-pool/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAEvE,MAAM,WAAW,qBAAqB;IACpC,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,QAAQ,EAAE,MAAM,CAAC;IACjB,+EAA+E;IAC/E,qBAAqB,EAAE,MAAM,CAAC;IAC9B,0DAA0D;IAC1D,cAAc,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,iBAAiB,EAAE,MAAM,CAAC;IAC1B,0EAA0E;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sCAAsC;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,WAAW,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACnC,wEAAwE;IACxE,gBAAgB,EAAE,MAAM,CAAC;IACzB,uDAAuD;IACvD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;;;OAOG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;CACjC;AAED,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,qBAAqB,CAiBzF"}

package/dist/providers/adapters/anthropic-interactive-pool/config.js

@@ -0,0 +1,22 @@
+/**
+ * Configuration shape for the anthropic-interactive-pool adapter.
+ */
+export function configFromEnv(env = process.env) {
+    return {
+        claudePath: env['CLAUDE_PATH'] || '/opt/homebrew/bin/claude',
+        tmuxPath: env['TMUX_PATH'] || '/opt/homebrew/bin/tmux',
+        poolSize: parseInt(env['INTERACTIVE_POOL_SIZE'] || '2', 10),
+        maxMessagesPerSession: parseInt(env['INTERACTIVE_POOL_MAX_MESSAGES'] || '50', 10),
+        maxIdleMinutes: parseInt(env['INTERACTIVE_POOL_MAX_IDLE_MINUTES'] || '30', 10),
+        allocateTimeoutMs: 60_000,
+        credential: env['CLAUDE_CODE_OAUTH_TOKEN'] || env['ANTHROPIC_API_KEY'],
+        apiBaseUrl: env['ANTHROPIC_BASE_URL'],
+        idleMarkers: ['? for shortcuts', 'bypass permissions on', 'shift+tab to cycle'],
+        stabilitySeconds: 4,
+        maxPromptWaitSeconds: 120,
+        paneWidth: 200,
+        paneHeight: 50,
+        canaryIntervalMs: parseInt(env['INTERACTIVE_POOL_CANARY_INTERVAL_MS'] || '3600000', 10),
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/providers/adapters/anthropic-interactive-pool/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../../src/providers/adapters/anthropic-interactive-pool/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAwDH,MAAM,UAAU,aAAa,CAAC,MAAyB,OAAO,CAAC,GAAG;IAChE,OAAO;QACL,UAAU,EAAE,GAAG,CAAC,aAAa,CAAC,IAAI,0BAA0B;QAC5D,QAAQ,EAAE,GAAG,CAAC,WAAW,CAAC,IAAI,wBAAwB;QACtD,QAAQ,EAAE,QAAQ,CAAC,GAAG,CAAC,uBAAuB,CAAC,IAAI,GAAG,EAAE,EAAE,CAAC;QAC3D,qBAAqB,EAAE,QAAQ,CAAC,GAAG,CAAC,+BAA+B,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;QACjF,cAAc,EAAE,QAAQ,CAAC,GAAG,CAAC,mCAAmC,CAAC,IAAI,IAAI,EAAE,EAAE,CAAC;QAC9E,iBAAiB,EAAE,MAAM;QACzB,UAAU,EAAE,GAAG,CAAC,yBAAyB,CAAC,IAAI,GAAG,CAAC,mBAAmB,CAAC;QACtE,UAAU,EAAE,GAAG,CAAC,oBAAoB,CAAC;QACrC,WAAW,EAAE,CAAC,iBAAiB,EAAE,uBAAuB,EAAE,oBAAoB,CAAC;QAC/E,gBAAgB,EAAE,CAAC;QACnB,oBAAoB,EAAE,GAAG;QACzB,SAAS,EAAE,GAAG;QACd,UAAU,EAAE,EAAE;QACd,gBAAgB,EAAE,QAAQ,CAAC,GAAG,CAAC,qCAAqC,CAAC,IAAI,SAAS,EAAE,EAAE,CAAC;KACxF,CAAC;AACJ,CAAC"}

package/dist/providers/adapters/anthropic-interactive-pool/control/authCredentialInjection.d.ts

@@ -0,0 +1,7 @@
+/**
+ * AuthCredentialInjection: same validation rules as 3a — interactive pool
+ * requires OAuth subscription token for subscription billing.
+ */
+import type { AuthCredentialInjection } from '../../../primitives/control/authCredentialInjection.js';
+export declare function createAuthCredentialInjection(): AuthCredentialInjection;
+//# sourceMappingURL=authCredentialInjection.d.ts.map

package/dist/providers/adapters/anthropic-interactive-pool/control/authCredentialInjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authCredentialInjection.d.ts","sourceRoot":"","sources":["../../../../../src/providers/adapters/anthropic-interactive-pool/control/authCredentialInjection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,uBAAuB,EAGxB,MAAM,wDAAwD,CAAC;AAkChE,wBAAgB,6BAA6B,IAAI,uBAAuB,CAEvE"}

package/dist/providers/adapters/anthropic-interactive-pool/control/authCredentialInjection.js

@@ -0,0 +1,39 @@
+/**
+ * AuthCredentialInjection: same validation rules as 3a — interactive pool
+ * requires OAuth subscription token for subscription billing.
+ */
+import { CapabilityFlag } from '../../../capabilities.js';
+import { AuthError } from '../../../errors.js';
+import { ANTHROPIC_INTERACTIVE_POOL_ID } from '../errors.js';
+class InteractivePoolAuthCredentialInjection {
+    capability = CapabilityFlag.AuthCredentialInjection;
+    buildSpec(credential) {
+        return { __brand: 'AuthCredentialSpec', credential };
+    }
+    validate(credential) {
+        if (credential.kind === 'none')
+            return 'interactive-pool requires credentials';
+        if (credential.kind === 'bearer')
+            return 'interactive-pool does not accept bearer tokens';
+        if (credential.kind === 'api-key') {
+            // API key works but doesn't draw from subscription — warn but allow
+            return null;
+        }
+        if (credential.kind === 'oauth-subscription' && !credential.token.startsWith('sk-ant-oat')) {
+            return 'OAuth subscription token must start with "sk-ant-oat"';
+        }
+        return null;
+    }
+    async probe(credential) {
+        const v = this.validate(credential);
+        if (v)
+            throw new AuthError(v, ANTHROPIC_INTERACTIVE_POOL_ID);
+        // Probing for interactive-pool would require spawning a pool session.
+        // Defer to validate() result and validate the credential lazily on
+        // first pool spawn.
+    }
+}
+export function createAuthCredentialInjection() {
+    return new InteractivePoolAuthCredentialInjection();
+}
+//# sourceMappingURL=authCredentialInjection.js.map

package/dist/providers/adapters/anthropic-interactive-pool/control/authCredentialInjection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"authCredentialInjection.js","sourceRoot":"","sources":["../../../../../src/providers/adapters/anthropic-interactive-pool/control/authCredentialInjection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,6BAA6B,EAAE,MAAM,cAAc,CAAC;AAE7D,MAAM,sCAAsC;IACjC,UAAU,GAAG,cAAc,CAAC,uBAAuB,CAAC;IAE7D,SAAS,CAAC,UAA8B;QACtC,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAwB,CAAC;IAC7E,CAAC;IAED,QAAQ,CAAC,UAA8B;QACrC,IAAI,UAAU,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,uCAAuC,CAAC;QAC/E,IAAI,UAAU,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,gDAAgD,CAAC;QAC1F,IAAI,UAAU,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAClC,oEAAoE;YACpE,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,UAAU,CAAC,IAAI,KAAK,oBAAoB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;YAC3F,OAAO,uDAAuD,CAAC;QACjE,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,UAA8B;QACxC,MAAM,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QACpC,IAAI,CAAC;YAAE,MAAM,IAAI,SAAS,CAAC,CAAC,EAAE,6BAA6B,CAAC,CAAC;QAC7D,sEAAsE;QACtE,mEAAmE;QACnE,oBAAoB;IACtB,CAAC;CACF;AAED,MAAM,UAAU,6BAA6B;IAC3C,OAAO,IAAI,sCAAsC,EAAE,CAAC;AACtD,CAAC"}

package/dist/providers/adapters/anthropic-interactive-pool/control/compactionLifecycle.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CompactionLifecycle: especially relevant for interactive pool because
+ * sessions hit context limits and need retirement. Polls the same marker
+ * file as 3a; additionally exposes pool-side retirement signals.
+ *
+ * Phase 3b: same polling approach as 3a. The pool's own retire-on-message-
+ * threshold logic complements this primitive (avoids most compactions by
+ * proactively retiring before they happen).
+ */
+import type { CompactionLifecycle } from '../../../primitives/control/compactionLifecycle.js';
+export declare function createCompactionLifecycle(): CompactionLifecycle;
+//# sourceMappingURL=compactionLifecycle.d.ts.map

package/dist/providers/adapters/anthropic-interactive-pool/control/compactionLifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compactionLifecycle.d.ts","sourceRoot":"","sources":["../../../../../src/providers/adapters/anthropic-interactive-pool/control/compactionLifecycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EACV,mBAAmB,EAGpB,MAAM,oDAAoD,CAAC;AAwF5D,wBAAgB,yBAAyB,IAAI,mBAAmB,CAE/D"}