llm-cli-gateway 1.13.2 → 1.15.0

package/dist/async-job-manager.d.ts

@@ -16,6 +16,13 @@ export interface AsyncJobFlightRecorderEntry {
     sessionId?: string;
     stablePrefixHash?: string;
     stablePrefixTokens?: number;
+    /**
+     * Slice κ: count of caller-supplied prompt-parts content blocks the
+     * gateway emitted with explicit Anthropic `cache_control` markers
+     * (ttl='1h'). Only set for Claude requests that opt into κ; left
+     * undefined elsewhere so legacy rows stay NULL.
+     */
+    cacheControlBlocks?: number;
 }
 /**
  * Slice 1.5 usage-extraction callback. Closures MUST be constructed from
@@ -66,6 +73,13 @@ export interface StartJobOptions {
      * therefore do NOT collide on dedup.
      */
     env?: Record<string, string>;
+    /**
+     * Slice κ: optional UTF-8 payload to pipe into the child's stdin.
+     * Participates in the dedup key — two requests with identical argv
+     * but different stdin do NOT collide. When set, stdio[0] is "pipe";
+     * when unset, stdio[0] stays "ignore" (regression-protected).
+     */
+    stdin?: string;
     /**
      * Optional hook fired exactly once when the job reaches a terminal state.
      * Used by callers that own per-request resources (outputSchema temp files,
@@ -168,7 +182,7 @@ export declare class AsyncJobManager {
      * Existing callers keep working unchanged; forceRefresh is exposed as a trailing
      * optional param for the dedup-aware path.
      */
-    startJob(cli: LlmCli, args: string[], correlationId: string, cwd?: string, idleTimeoutMs?: number, outputFormat?: string, forceRefresh?: boolean, env?: Record<string, string>, onComplete?: () => void, flightRecorderEntry?: AsyncJobFlightRecorderEntry, extractUsage?: AsyncJobUsageExtractor, writeFlightStart?: boolean): AsyncJobSnapshot;
+    startJob(cli: LlmCli, args: string[], correlationId: string, cwd?: string, idleTimeoutMs?: number, outputFormat?: string, forceRefresh?: boolean, env?: Record<string, string>, onComplete?: () => void, flightRecorderEntry?: AsyncJobFlightRecorderEntry, extractUsage?: AsyncJobUsageExtractor, writeFlightStart?: boolean, stdin?: string): AsyncJobSnapshot;
     /**
      * Start a job, with optional dedup against recent identical requests.
      * Returns `{ snapshot, deduped }` so callers can log/report the short-circuit.

package/dist/async-job-manager.js

@@ -207,8 +207,22 @@ export class AsyncJobManager {
      * (sorted keys → JSON-stringified). This prevents two Mistral requests with the
      * same argv but different `VIBE_ACTIVE_MODEL` from deduping onto each other.
      */
-    buildRequestKey(cli, args, env) {
-        return computeRequestKey(cli, args, canonicaliseEnvForKey(env));
+    buildRequestKey(cli, args, env, stdin, cwd) {
+        // Slice κ: stdin participates in the dedup key. Two Claude requests
+        // with identical argv but different cache_control content blocks
+        // would otherwise collide on dedup and the second caller would get
+        // the wrong response. The legacy "no stdin" code path passes
+        // stdin=undefined, which serialises to the same empty marker the
+        // previous version emitted — non-κ dedup is unchanged.
+        // Slice λ: cwd participates similarly. Two requests with identical
+        // argv but different worktrees would otherwise collide on dedup and
+        // the second caller would receive a response executed in the wrong
+        // worktree. cwd=undefined preserves the pre-λ key shape — non-λ
+        // dedup is unchanged.
+        const extraEnv = canonicaliseEnvForKey(env);
+        const withStdin = stdin === undefined ? extraEnv : `${extraEnv}|stdin:${stdin}`;
+        const extra = cwd === undefined ? withStdin : `${withStdin}|cwd:${cwd}`;
+        return computeRequestKey(cli, args, extra);
     }
     fireOnComplete(job) {
         if (job.onCompleteFired)
@@ -417,13 +431,14 @@ export class AsyncJobManager {
      * Existing callers keep working unchanged; forceRefresh is exposed as a trailing
      * optional param for the dedup-aware path.
      */
-    startJob(cli, args, correlationId, cwd, idleTimeoutMs, outputFormat, forceRefresh, env, onComplete, flightRecorderEntry, extractUsage, writeFlightStart) {
+    startJob(cli, args, correlationId, cwd, idleTimeoutMs, outputFormat, forceRefresh, env, onComplete, flightRecorderEntry, extractUsage, writeFlightStart, stdin) {
         return this.startJobWithDedup(cli, args, correlationId, {
             cwd,
             idleTimeoutMs,
             outputFormat,
             forceRefresh,
             env,
+            stdin,
             onComplete,
             flightRecorderEntry,
             extractUsage,
@@ -439,8 +454,8 @@ export class AsyncJobManager {
      * is returned without spawning a new process. forceRefresh skips dedup entirely.
      */
     startJobWithDedup(cli, args, correlationId, opts = {}) {
-        const { cwd, idleTimeoutMs, outputFormat, forceRefresh, env: extraEnv, onComplete, flightRecorderEntry, extractUsage, writeFlightStart, } = opts;
-        const requestKey = this.buildRequestKey(cli, args, extraEnv);
+        const { cwd, idleTimeoutMs, outputFormat, forceRefresh, env: extraEnv, stdin, onComplete, flightRecorderEntry, extractUsage, writeFlightStart, } = opts;
+        const requestKey = this.buildRequestKey(cli, args, extraEnv, stdin, cwd);
         if (!forceRefresh && this.store) {
             try {
                 const existing = this.store.findByRequestKey(requestKey);
@@ -489,9 +504,18 @@ export class AsyncJobManager {
         const baseEnv = envWithExtendedPath(process.env, getExtendedPath());
         const child = spawnCliProcess(command, args, {
             cwd,
-            stdio: ["ignore", "pipe", "pipe"],
+            stdio: stdin === undefined ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
             env: { ...baseEnv, ...(extraEnv ?? {}) },
         });
+        if (stdin !== undefined && child.stdin) {
+            try {
+                child.stdin.write(stdin);
+            }
+            catch (err) {
+                this.logger.error(`Job ${id} failed to write stdin payload`, err);
+            }
+            child.stdin.end();
+        }
         // Single cleanup flag to prevent double-unregister
         let groupCleaned = false;
         const cleanupGroup = () => {
@@ -560,6 +584,7 @@ export class AsyncJobManager {
                     asyncJobId: id,
                     stablePrefixHash: flightRecorderEntry.stablePrefixHash,
                     stablePrefixTokens: flightRecorderEntry.stablePrefixTokens,
+                    cacheControlBlocks: flightRecorderEntry.cacheControlBlocks,
                 });
             }
             catch (err) {

package/dist/cache-stats.d.ts

@@ -76,6 +76,32 @@ export interface GlobalCacheStats {
         estimatedSavingsUsd: number;
     }>;
     estimatedSavingsUsd: number;
+    /**
+     * Rec #3 (slice κ): derived metrics that distinguish gateway-driven
+     * κ-explicit `cache_control` breakpoints from Claude Code's
+     * own baseline cache reads.
+     *
+     * - explicitCacheControlRows: rows where the gateway emitted at
+     *   least one `cache_control` marker (`cache_control_blocks > 0`).
+     * - explicitCacheControlHits: those rows whose `cache_read_tokens
+     *   > 0` — closest signal we have to "the caller's marked block
+     *   actually hit Anthropic's cache" (still includes Claude Code's
+     *   baseline cache reads on top, which is unavoidable without
+     *   per-block token accounting from Anthropic).
+     * - explicitCacheControlHitRate: ratio explicit hits / explicit rows.
+     * - stablePrefixReuseCount: distinct `stable_prefix_hash` values
+     *   that appear in >1 row in-window (i.e. real reuse opportunities).
+     * - avgCacheCreationAfterFirstCall: averaged across stable-prefix
+     *   reuse groups, the cache_creation_tokens on rows AFTER the
+     *   first-by-datetime in each group. Drops sharply when caller
+     *   blocks are reused; stays high when Claude Code's session-wrap
+     *   floor dominates.
+     */
+    explicitCacheControlRows: number;
+    explicitCacheControlHits: number;
+    explicitCacheControlHitRate: number;
+    stablePrefixReuseCount: number;
+    avgCacheCreationAfterFirstCall: number | null;
 }
 export declare function computeSessionCacheStats(db: FlightRecorderQuery, sessionId: string): SessionCacheStats;
 export interface TtlPolicy {

package/dist/cache-stats.js

@@ -159,14 +159,16 @@ export function computeGlobalCacheStats(db, opts = {}) {
               COALESCE(cache_read_tokens, 0) AS cache_read_tokens,
               COALESCE(cache_creation_tokens, 0) AS cache_creation_tokens,
               stable_prefix_hash,
-              datetime_utc
+              datetime_utc,
+              cache_control_blocks
        FROM requests
        WHERE datetime_utc >= ?`
         : `SELECT cli, model,
               COALESCE(cache_read_tokens, 0) AS cache_read_tokens,
               COALESCE(cache_creation_tokens, 0) AS cache_creation_tokens,
               stable_prefix_hash,
-              datetime_utc
+              datetime_utc,
+              cache_control_blocks
        FROM requests`;
     const rows = sinceIso ? db.queryRequests(sql, sinceIso) : db.queryRequests(sql);
     const perCliMap = new Map();
@@ -175,6 +177,17 @@ export function computeGlobalCacheStats(db, opts = {}) {
     let totalRead = 0;
     let totalCreation = 0;
     let totalSavings = 0;
+    // Rec #3: κ-explicit metrics. A row is "κ-explicit" iff it has
+    // `cache_control_blocks > 0` — i.e. the gateway emitted at least one
+    // caller-supplied `cache_control` marker. Rows with NULL or 0 are
+    // either pre-v4 or non-κ Claude / non-Claude requests.
+    let explicitRows = 0;
+    let explicitHits = 0;
+    // Per-prefix reuse tracking: collect cache_creation_tokens for every
+    // row keyed by stable_prefix_hash, ordered ascending by datetime_utc.
+    // For each group with >1 row, drop the first (the cache-write call)
+    // and average the rest (the cache-read calls).
+    const perPrefix = new Map();
     for (const row of rows) {
         totalRequests += 1;
         const reads = safeNum(row.cache_read_tokens);
@@ -183,6 +196,17 @@ export function computeGlobalCacheStats(db, opts = {}) {
         totalCreation += creation;
         if (reads > 0)
             totalHits += 1;
+        const ccBlocks = safeNum(row.cache_control_blocks);
+        if (ccBlocks > 0) {
+            explicitRows += 1;
+            if (reads > 0)
+                explicitHits += 1;
+        }
+        if (row.stable_prefix_hash) {
+            const arr = perPrefix.get(row.stable_prefix_hash) ?? [];
+            arr.push({ datetime_utc: row.datetime_utc, cache_creation_tokens: creation });
+            perPrefix.set(row.stable_prefix_hash, arr);
+        }
         if (!isCacheStatsCli(row.cli))
             continue;
         const cli = row.cli;
@@ -203,6 +227,20 @@ export function computeGlobalCacheStats(db, opts = {}) {
         agg.estimatedSavingsUsd += savings;
         perCliMap.set(cli, agg);
     }
+    let stablePrefixReuseCount = 0;
+    let creationAfterFirstSum = 0;
+    let creationAfterFirstCount = 0;
+    for (const arr of perPrefix.values()) {
+        if (arr.length <= 1)
+            continue;
+        stablePrefixReuseCount += 1;
+        arr.sort((a, b) => a.datetime_utc < b.datetime_utc ? -1 : a.datetime_utc > b.datetime_utc ? 1 : 0);
+        for (let i = 1; i < arr.length; i++) {
+            creationAfterFirstSum += arr[i].cache_creation_tokens;
+            creationAfterFirstCount += 1;
+        }
+    }
+    const avgCacheCreationAfterFirstCall = creationAfterFirstCount > 0 ? creationAfterFirstSum / creationAfterFirstCount : null;
     const perCli = Array.from(perCliMap.entries()).map(([cli, agg]) => ({
         cli,
         requestCount: agg.requestCount,
@@ -221,5 +259,10 @@ export function computeGlobalCacheStats(db, opts = {}) {
         totalCacheCreationTokens: totalCreation,
         perCli,
         estimatedSavingsUsd: totalSavings,
+        explicitCacheControlRows: explicitRows,
+        explicitCacheControlHits: explicitHits,
+        explicitCacheControlHitRate: explicitRows > 0 ? explicitHits / explicitRows : 0,
+        stablePrefixReuseCount,
+        avgCacheCreationAfterFirstCall,
     };
 }

package/dist/executor.d.ts

@@ -7,6 +7,14 @@ export interface ExecuteOptions {
     logger?: Logger;
     /** Extra environment variables to inject; merged after PATH. */
     env?: NodeJS.ProcessEnv;
+    /**
+     * Slice κ: optional UTF-8 payload to write to the child's stdin
+     * immediately after spawn. When provided, stdio for stdin switches
+     * from "ignore" to "pipe" so the CLI can read the payload (used by
+     * `claude --input-format stream-json`). Undefined preserves the
+     * legacy stdio:["ignore","pipe","pipe"] shape.
+     */
+    stdin?: string;
 }
 export interface ExecuteResult {
     stdout: string;

package/dist/executor.js

@@ -296,16 +296,21 @@ export function spawnCliProcess(command, args, options) {
     return proc;
 }
 export async function executeCli(command, args, options = {}) {
-    const { timeout, idleTimeout, cwd, env: extraEnv } = options;
+    const { timeout, idleTimeout, cwd, env: extraEnv, stdin } = options;
     const extendedPath = getExtendedPath();
     const baseEnv = envWithExtendedPath(process.env, extendedPath);
     const circuitBreaker = getCircuitBreaker(command);
     const runOnce = () => new Promise((resolve, reject) => {
+        const stdio = stdin === undefined ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"];
         const proc = spawnCliProcess(command, args, {
             cwd,
-            stdio: ["ignore", "pipe", "pipe"],
+            stdio,
             env: { ...baseEnv, ...(extraEnv ?? {}) },
         });
+        if (stdin !== undefined && proc.stdin) {
+            proc.stdin.write(stdin);
+            proc.stdin.end();
+        }
         let stdout = "";
         let stderr = "";
         let timedOut = false;

package/dist/flight-recorder.d.ts

@@ -8,6 +8,13 @@ export interface FlightLogStart {
     asyncJobId?: string;
     stablePrefixHash?: string;
     stablePrefixTokens?: number;
+    /**
+     * Slice κ: number of caller-supplied prompt-parts content blocks
+     * that the gateway emitted with an explicit `cache_control`
+     * breakpoint on this request. `null` (default) for non-κ requests,
+     * including pre-κ rows after a v4 migration of a legacy DB.
+     */
+    cacheControlBlocks?: number;
 }
 export interface FlightLogResult {
     response: string;

package/dist/flight-recorder.js

@@ -55,6 +55,20 @@ function ensureStablePrefixColumns(db) {
     }
     db.exec("CREATE INDEX IF NOT EXISTS idx_requests_stable_hash ON requests(stable_prefix_hash)");
 }
+/**
+ * Idempotent v4 migration (slice κ): add `cache_control_blocks` column
+ * to the `requests` table. Counts the caller-supplied content blocks
+ * the gateway emitted with an explicit Anthropic `cache_control`
+ * marker. Pre-κ rows keep NULL; only κ-opt-in callers ever set the
+ * column to a non-NULL integer.
+ */
+function ensureCacheControlBlocksColumn(db) {
+    const rows = db.prepare("PRAGMA table_info(requests)").all?.() ?? [];
+    const names = new Set(rows.map((row) => (row && typeof row.name === "string" ? row.name : "")));
+    if (!names.has("cache_control_blocks")) {
+        db.exec("ALTER TABLE requests ADD COLUMN cache_control_blocks INTEGER");
+    }
+}
 export function resolveFlightRecorderDbPath() {
     const configured = process.env.LLM_GATEWAY_LOGS_DB;
     if (configured !== undefined) {
@@ -176,6 +190,14 @@ export class FlightRecorder {
         this.db
             .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(3, ?)")
             .run(new Date().toISOString());
+        // Migration v4: cache_control_blocks (slice κ). Pre-κ rows keep NULL;
+        // only κ-opt-in writes populate this. Aggregates in cache-stats /
+        // MCP resources can use this to separate explicit κ hits from
+        // implicit prefix-cache hits.
+        ensureCacheControlBlocksColumn(this.db);
+        this.db
+            .prepare("INSERT OR IGNORE INTO _migrations(version, applied_at) VALUES(4, ?)")
+            .run(new Date().toISOString());
         if (process.platform !== "win32") {
             try {
                 chmodSync(dbPath, 0o600);
@@ -186,9 +208,11 @@ export class FlightRecorder {
         }
         const insertRequest = this.db.prepare(`
       INSERT INTO requests (id, cli, model, prompt, system, session_id, datetime_utc,
-                            stable_prefix_hash, stable_prefix_tokens)
+                            stable_prefix_hash, stable_prefix_tokens,
+                            cache_control_blocks)
       VALUES (@id, @cli, @model, @prompt, @system, @session_id, @datetime_utc,
-              @stable_prefix_hash, @stable_prefix_tokens)
+              @stable_prefix_hash, @stable_prefix_tokens,
+              @cache_control_blocks)
     `);
         const insertMetadata = this.db.prepare(`
       INSERT INTO gateway_metadata (request_id, async_job_id, status)
@@ -205,6 +229,7 @@ export class FlightRecorder {
                 datetime_utc: new Date().toISOString(),
                 stable_prefix_hash: entry.stablePrefixHash ?? null,
                 stable_prefix_tokens: entry.stablePrefixTokens ?? null,
+                cache_control_blocks: entry.cacheControlBlocks ?? null,
             });
             insertMetadata.run({
                 request_id: entry.correlationId,

package/dist/index.d.ts

@@ -67,6 +67,36 @@ type GatewayLogger = typeof logger;
  */
 export declare const MAX_TURNS_SCHEMA: z.ZodNumber;
 export declare const MAX_PRICE_SCHEMA: z.ZodNumber;
+/**
+ * Slice λ: shared worktree directive for all 10 `*_request` / `*_request_async`
+ * tools. `true` creates a fresh worktree under `<repoRoot>/.worktrees/<uuid>`
+ * branched from HEAD. `{ name?, ref? }` lets the caller supply a sanitized
+ * name and/or git ref (default ref: HEAD).
+ *
+ * Lifecycle is gateway-owned: the gateway pre-creates the worktree via
+ * `git worktree add`, then spawns the child CLI with `cwd: <worktree-path>`.
+ * No `-w` / `--worktree` flag is ever emitted to the underlying CLI. When
+ * the request carries a sessionId and the session already has a worktree,
+ * that worktree is reused. On session_delete or TTL eviction the gateway
+ * runs `git worktree remove --force`.
+ *
+ * Tool response: when a worktree was used, the successful response stdout
+ * is prefixed with `[gateway] worktree=<absolute-path>\n` so callers can
+ * parse/use the path without a schema change (slice λ §1.d).
+ *
+ * NOTE: callers should `.gitignore` the `.worktrees/` directory in their
+ * repo (the gateway does NOT auto-gitignore — see slice λ spec Q4).
+ */
+export declare const WORKTREE_SCHEMA: z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    name?: string | undefined;
+    ref?: string | undefined;
+}, {
+    name?: string | undefined;
+    ref?: string | undefined;
+}>]>;
 export declare const SESSION_PROVIDER_VALUES: readonly ["claude", "codex", "gemini", "grok", "mistral"];
 export declare const SESSION_PROVIDER_ENUM: z.ZodEnum<["claude", "codex", "gemini", "grok", "mistral"]>;
 export type SessionProvider = (typeof SESSION_PROVIDER_VALUES)[number];
@@ -82,7 +112,7 @@ export interface GatewayServerDeps {
     persistence?: PersistenceConfig;
     cacheAwareness?: CacheAwarenessConfig;
 }
-interface GatewayServerRuntime {
+export interface GatewayServerRuntime {
     sessionManager: ISessionManager;
     resourceProvider: ResourceProvider;
     db: DatabaseConnection | null;
@@ -94,6 +124,60 @@ interface GatewayServerRuntime {
     persistence: PersistenceConfig;
     cacheAwareness: CacheAwarenessConfig;
 }
+export declare function resolveGatewayServerRuntime(deps?: GatewayServerDeps, options?: {
+    isolateState?: boolean;
+}): GatewayServerRuntime;
+/**
+ * Slice λ: shape returned by `resolveWorktreeForRequest`. `cwd` is what
+ * the spawn helpers (`executeCli`, `startJobWithDedup`) consume;
+ * `worktreePath` is what the tool handler embeds in the response prefix
+ * so callers can discover the path.
+ */
+export interface ResolvedWorktree {
+    cwd?: string;
+    worktreePath?: string;
+}
+/**
+ * Slice λ: resolve a request's worktree directive into a spawn cwd.
+ *
+ * - `worktreeOpt` is the Zod-validated input value (boolean |
+ *   `{ name?, ref? }` | undefined).
+ * - When the request has a session AND the session already has a
+ *   `metadata.worktreePath`, that path is reused (resume semantics).
+ *   The reused path is returned without touching git; if the directory
+ *   was externally removed between requests, the next CLI invocation
+ *   will surface the error naturally.
+ * - When no reusable worktree exists, `createWorktree` runs; on success
+ *   the new path is written to `session.metadata` (only when a session
+ *   exists — request-scoped worktrees do NOT persist).
+ * - Returns `{}` when `worktreeOpt` is undefined/false (preserves
+ *   pre-λ behaviour at non-worktree call sites).
+ * - Errors propagate as `WorktreeError`/`Error`; the caller wraps them
+ *   in a `createErrorResponse` envelope. Do NOT swallow.
+ *
+ * Spec: docs/plans/slice-lambda.spec.md §"Implementation surface to
+ * verify" §5.
+ */
+export declare function resolveWorktreeForRequest(worktreeOpt: boolean | {
+    name?: string;
+    ref?: string;
+} | undefined, sessionId: string | undefined, runtime: GatewayServerRuntime): Promise<ResolvedWorktree>;
+/**
+ * Slice λ §1.d: response-envelope shape decision for `worktreePath`.
+ *
+ * We surface the worktree path inline as a stdout prefix
+ * (`[gateway] worktree=<absolute-path>\n`) rather than as a
+ * structuredContent field or JSON wrapper. Rationale:
+ *   - zero schema change across all 10 tools and their downstream parsers
+ *   - matches how other slice features (session warnings, cache_state
+ *     aggregates) surface side-channel metadata today
+ *   - callers that want the path can split on the first newline; callers
+ *     that don't care see a single ignorable header line
+ *
+ * Use `formatWorktreePrefix(resolution.worktreePath)` once per tool, at
+ * the moment a successful response is constructed.
+ */
+export declare function formatWorktreePrefix(worktreePath?: string): string;
 export declare function extractUsageAndCost(cli: "claude" | "codex" | "gemini" | "grok" | "mistral", output: string, outputFormat?: string, 
 /**
  * Optional context for off-stdout telemetry sources. Today only Mistral
@@ -129,6 +213,27 @@ interface CliRequestPrep {
     stablePrefixHash: string | null;
     /** Heuristic token count (bytes/4) of the same stable prefix. */
     stablePrefixTokens: number | null;
+    /**
+     * Slice κ (Claude only): JSON stream-json payload to feed on stdin
+     * when the gateway emits `-p --input-format stream-json`. Undefined
+     * when the caller did not opt into Anthropic `cache_control`
+     * breakpoints. Non-κ providers always leave this undefined.
+     */
+    stdinPayload?: string;
+    /**
+     * Slice κ (Claude only): number of caller-supplied content blocks
+     * that carry an explicit `cache_control` marker. Threaded into the
+     * flight recorder so `cache_state` aggregates can distinguish
+     * κ-explicit breakpoints from implicit prefix-cache hits.
+     */
+    cacheControlBlocks?: number;
+    /**
+     * Rec #4: structured warnings produced during prep (e.g. cacheable
+     * stable prefix without cacheControl). Handlers merge these with any
+     * other warnings (cache_ttl_expiring_soon, etc.) before returning to
+     * the caller.
+     */
+    warnings?: WarningEntry[];
 }
 export declare function prepareClaudeRequest(params: {
     prompt?: string;
@@ -360,6 +465,11 @@ export interface GeminiRequestParams {
     attachments?: string[];
     /** Phase 4 slice γ: emit `--skip-trust` for fresh-workspace headless runs. */
     skipTrust?: boolean;
+    /** Slice λ: run this request inside a gateway-owned git worktree. */
+    worktree?: boolean | {
+        name?: string;
+        ref?: string;
+    };
 }
 export interface HandlerDeps {
     sessionManager: ISessionManager;
@@ -412,6 +522,11 @@ export interface GrokRequestParams {
     allow?: string[];
     /** Phase 4 slice θ: Grok `--deny <RULE>` (repeatable; one entry per --deny instance). */
     deny?: string[];
+    /** Slice λ: run this request inside a gateway-owned git worktree. */
+    worktree?: boolean | {
+        name?: string;
+        ref?: string;
+    };
 }
 export declare function handleGrokRequest(deps: HandlerDeps, params: GrokRequestParams): Promise<ExtendedToolResponse>;
 export declare function handleGrokRequestAsync(deps: AsyncHandlerDeps, params: Omit<GrokRequestParams, "optimizeResponse">): Promise<ExtendedToolResponse>;
@@ -446,6 +561,11 @@ export interface MistralRequestParams {
     workingDir?: string;
     /** Phase 4 slice ζ: Vibe `--add-dir <DIR>` repeatable add-dir parity. */
     addDir?: string[];
+    /** Slice λ: run this request inside a gateway-owned git worktree. */
+    worktree?: boolean | {
+        name?: string;
+        ref?: string;
+    };
 }
 export declare function handleMistralRequest(deps: HandlerDeps, params: MistralRequestParams): Promise<ExtendedToolResponse>;
 export declare function handleMistralRequestAsync(deps: AsyncHandlerDeps, params: Omit<MistralRequestParams, "optimizeResponse">): Promise<ExtendedToolResponse>;
@@ -480,6 +600,11 @@ export declare function handleCodexRequestAsync(deps: AsyncHandlerDeps, params:
     ignoreRules?: boolean;
     workingDir?: string;
     addDir?: string[];
+    /** Slice λ: run this request inside a gateway-owned git worktree. */
+    worktree?: boolean | {
+        name?: string;
+        ref?: string;
+    };
 }): Promise<ExtendedToolResponse>;
 export declare function createGatewayServer(deps?: GatewayServerDeps): McpServer;
 export {};