@nexrall/code-core 1.4.66 → 1.4.68

package/dist/agent/loop.d.ts

@@ -1,487 +1,19 @@
-import type { Message, ToolResult, AgentLoopOptions, EnvContext } from '../types';
+import type { Message, ToolResult, AgentLoopOptions } from '../types';
 import { type BackgroundAgentHub } from './backgroundAgents';
-import { streamChat } from '../api/client';
-import { type AgentType, type AgentMemoryScope } from './agentTypes';
+import { type AgentType } from './agentTypes';
 import { bashNeedsRepoLock } from '../permissions/bashClassify';
 export { bashNeedsRepoLock };
-/** Backoff for the Nth (0-based) empty-turn retry. Pure, so the schedule is testable. */
-export declare function emptyTurnBackoffMs(attempt: number): number;
-/**
- * Should an empty assistant turn be retried automatically, rather than surfaced?
- *
- * Split out as a pure function because the two "empty" causes look IDENTICAL at the
- * call site (both are `content.length === 0`) and telling them apart is the entire
- * point — the previous bug in this area was treating a deterministic truncation as a
- * transient hiccup and advising a retry that reproduced it verbatim.
- *
- *   • `max_tokens` → the model burned its whole output budget on reasoning and was CUT
- *     OFF. Retrying re-runs the same prompt with the same budget and the same reasoning
- *     behaviour, so it fails the same way while billing again. Never retried; the user
- *     is told to lower effort or split the task (stopReasonNotice 'output-limit').
- *   • anything else → a genuinely transient empty turn. Retried, up to the limit.
- *
- * The attempt cap matters as much as the classification: a model that has decided to
- * return nothing (e.g. a prompt it refuses to continue) would otherwise loop forever
- * on a paid endpoint. After the cap we fall back to the old visible notice.
- */
-export declare function shouldRetryEmptyTurn(stopReason: string | null | undefined, attemptsSoFar: number): boolean;
-/** Empty-turn retry limits, exposed for tests. */
-export declare const _emptyTurnRetry: {
-    EMPTY_TURN_RETRY_LIMIT: number;
-    EMPTY_TURN_RETRY_BASE_MS: number;
-};
-/**
- * Fingerprint one round's tool failures, for the repeated-failure runaway guard.
- *
- * Exported (with the limits) purely as a test seam: the guard's whole value is in the
- * edge cases — that a DIFFERENT error each round must NOT trip it, that call order
- * within a round is irrelevant, that a long error body doesn't make every occurrence
- * look unique — and none of that is reachable without driving a live model loop.
- *
- * Sorted so parallel tool calls completing in a different order still compare equal;
- * truncated because errors often embed a varying path or timestamp late in the string.
- */
-export declare function errorRoundSignature(errored: Array<{
-    name: string;
-    error: string;
-}>): string;
-/** Runaway-guard limits, exposed for tests. */
-export declare const _stallLimits: {
-    STALL_LIMIT: number;
-    REPEAT_STALL_LIMIT: number;
-};
-/**
- * The single tool granted by a `memory:` frontmatter scope.
- *
- * Named distinctly from `memory_write` on purpose: they write to DIFFERENT stores, and
- * a model that saw one name for both would reasonably assume its notes were visible to
- * the main agent. They are not.
- */
-export declare const AGENT_MEMORY_TOOL = "agent_memory_write";
-/**
- * Schema advertised to the model, only for a sub-agent with a declared memory scope.
- *
- * The description does the load-bearing work of keeping the two stores apart in the
- * model's head: it must not believe these notes reach the user or the main agent.
- */
-export declare const AGENT_MEMORY_TOOL_SCHEMA: {
-    readonly name: "agent_memory_write";
-    readonly description: string;
-    readonly input_schema: {
-        readonly type: "object";
-        readonly properties: {
-            readonly content: {
-                readonly type: "string";
-                readonly description: "The single fact to remember, 1-2 sentences.";
-            };
-        };
-        readonly required: readonly ["content"];
-    };
-};
-/** Identifies whose notes an agent_memory_write call may touch. */
-export interface AgentMemoryBinding {
-    agentName: string;
-    scope: AgentMemoryScope;
-}
-/**
- * Execute an `agent_memory_write` call.
- *
- * Pure-ish and exported so the refusal paths are testable without spawning a real
- * sub-agent: the binding is data, so "no binding" and "unsafe agent name" can both be
- * exercised directly.
- */
-export declare function executeAgentMemoryWrite(input: Record<string, unknown>, binding: AgentMemoryBinding | undefined, workDir?: string): Promise<ToolResult>;
-/**
- * Why an agent run stopped.
- *
- * `'clean'` and `'aborted'` are the two silent-by-design outcomes: the model gave a
- * final answer, or the user pressed Ctrl+C and already knows why it stopped.
- * EVERYTHING else owes the user an explanation, which is what stopReasonNotice covers.
- */
-export type StopReason = 'clean' | 'aborted' | 'reported-elsewhere' | 'empty-response' | 'output-limit' | 'no-balance' | 'no-team-budget' | 'team-unavailable' | 'stalled' | 'stalled-repeat' | 'budget' | 'unknown';
-/**
- * The message shown when a run ends for any reason other than a clean finish.
- *
- * Pure and exported so every branch is testable: reaching some of these for real needs
- * an empty wallet, a dead upstream, or hundreds of iterations. Returns null only for
- * the two outcomes that are deliberately silent.
- *
- * `'unknown'` deliberately produces a message rather than nothing. If a future `break`
- * forgets to set a reason, the symptom should be a visible "ended unexpectedly" line —
- * annoying and reportable — not the silent stop that made this refactor necessary.
- */
-export declare function stopReasonNotice(reason: StopReason, ctx?: {
-    budget?: number;
-    repeatError?: string | null;
-}): string | null;
-export declare function resolveMaxIterations(optionValue: number | undefined, settingsRaw: Record<string, unknown>): number;
-/**
- * Every path a tool call will touch, so all of them can be locked.
- *
- * `move_file`/`copy_file` carry `source` + `destination`, the rest carry `path`. Both
- * `dest` and `destination` are accepted because the schema has used both spellings and
- * silently missing the key would mean silently losing the lock — a failure that shows
- * up as corrupted content rather than an error.
- *
- * Exported for tests: getting this wrong is invisible until two writes race.
- */
-export declare function lockPathsFor(name: string, input: Record<string, unknown>, workDir?: string): string[];
-/**
- * Resolve the fan-out limit: env → settings.json → default.
- *
- * Was env-ONLY, the same gap as the sub-task timeout: a project on a small machine that
- * wanted 2, or a big one that wanted 6, had to set a shell variable, and nobody reading
- * settings.json could see what the limit even was. Capped at HARD_MAX_CONCURRENT_SUBTASKS
- * (32 — above Claude Code's default 20, so a user who wants that width can have it)
- * because this bounds real shared resources (CPU, the API rate limit, file handles) and a
- * typo like 400 should degrade to "a lot" rather than fork-bomb the machine.
- */
-export declare function resolveMaxConcurrentSubtasks(settingsRaw?: Record<string, unknown>): number;
-/** Resolve the session-total sub-agent ceiling: env → settings.json → default. */
-export declare function resolveMaxSubagentsPerSession(settingsRaw?: Record<string, unknown>): number;
-/**
- * Minimal concurrency gate. Hand-rolled rather than pulling in `p-limit` because
- * the CLI ships as a single esbuild bundle with no node_modules, and this is a
- * dozen lines.
- */
-export declare function createLimiter(max: number): <T>(fn: () => Promise<T>) => Promise<T>;
-/** Test-only: forget the memoised limiter so a new limit can take effect. */
-export declare function _resetSubTaskLimiter(): void;
-/**
- * Start a fresh sub-agent budget. Call when a NEW conversation begins.
- *
- * Exported for clients that reuse one process across conversations (the VS Code extension
- * host). A client that never calls it gets process-lifetime semantics, which is correct
- * for a one-shot CLI invocation.
- */
-export declare function resetSessionSubAgentBudget(sessionKey?: string): void;
-/** Test-only: observe the session counter without exporting the mutable binding. */
-export declare function _sessionSubAgentCount(sessionKey?: string): number;
-/**
- * Deepest nesting level allowed to spawn: env → settings.json → default 3.
- *
- * Was a hard-coded 1, i.e. "sub-agents are leaves". That was the right default while the
- * three capability decisions disagreed with each other (see canSpawnSubAgents), but it is
- * no longer where the ecosystem is: Claude Code lifted the no-nesting rule and, after a
- * brief period with it disabled entirely, settled on a configurable default of 3.
- *
- * 3, not 5, deliberately. Depth is a budget you SPEND, not headroom you fill: every level
- * is a context window that receives only a dispatch prompt on the way down and returns
- * only a summary on the way up, so the deeper frames pay full freight to carry less
- * information. 3 covers orchestrator → worker → helper, which is where the observed value
- * is; beyond that latency and token cost tend to exceed the benefit.
- *
- * Depth 1 remains available (`maxSubagentDepth: 1`) for anyone who wants leaves-only.
- */
-export declare function resolveMaxSubagentDepth(settingsRaw?: Record<string, unknown>): number;
-/**
- * The ONE explanation for "this run may not spawn a sub-agent", shared by every place
- * that can refuse it, so the same impossibility never gets two different stories.
- *
- * Parameterised on the REASON because the reasons are no longer interchangeable. It used
- * to be a flat constant reading "Sub-agents cannot spawn further sub-agents — this is a
- * structural limit"; with nesting configurable that sentence is now false for most runs,
- * and telling a depth-1 agent its limit is structural when the user could raise it by one
- * line of settings is the same class of misdirection as the "needs a different agent" text
- * this replaced. A refusal has to be accurate about whether it can be lifted, or the model
- * either gives up when it shouldn't or hunts for an escape that doesn't exist.
- */
-export declare function noSpawnReason(kind: 'depth' | 'denied', limit?: number): string;
-/**
- * Whether a run at `depth` may spawn sub-agents.
- *
- * The single source of truth for THREE things that must agree: the `<available_subagents>`
- * catalogue in the system prompt, whether the backend is asked to send the `task` tool
- * schema at all, and which prompt block teaches delegation. They used to be decided
- * independently, and the result was a sub-agent that got the tool plus instructions to use
- * it but no catalogue — then a permission-gate refusal telling it not to ask for approval.
- *
- * `depth < limit` because the children this run would create land at `depth + 1`; the
- * guard inside runSubTask mirrors it as `depth >= limit`.
- *
- * `limit` is injected rather than read from module state so this stays pure and testable.
- * Callers pass the resolved per-workspace value; it defaults to the built-in for the
- * handful of call sites that have no settings in hand.
- */
-/**
- * A child sub-agent's effective tool allowlist: its own, narrowed by its parent's.
- *
- * Exported and pure because it is a SECURITY boundary and was previously verified only by
- * grepping the source for the intersection expression — which matched happily while the
- * code threw a TypeError on one of its own four cases. A boundary needs behavioural tests.
- *
- * `null` means "no allowlist" (unrestricted), and it is returned only when BOTH sides say
- * so. The four cases:
- *   own + parent → intersection (a child can narrow, never widen)
- *   own only     → own (the main agent, which has no allowlist, spawning a specialist)
- *   parent only  → a COPY of parent (an unnamed/general-purpose child inherits the
- *                  restriction instead of resetting to full access — this is the
- *                  escalation path, since `general-purpose` declares no tools at all)
- *   neither      → null
- *
- * The parent-only case must COPY: the caller adds AGENT_MEMORY_TOOL to the returned set,
- * which would otherwise mutate the parent's live allowlist.
- */
-export declare function intersectAllowlists(own: Set<string> | null, parent: Set<string> | undefined): Set<string> | null;
-export declare function canSpawnSubAgents(depth: number, allowedTools?: Set<string>, limit?: number): boolean;
-/**
- * How long a sub-agent may make NO progress before it is stopped.
- *
- * Precedence matches every other tunable in this file
- * (env → settings.json → default) — it used to be env-ONLY, which meant a project that
- * legitimately needed longer sub-tasks had no way to say so in the file where every
- * other such preference lives, and the limit was invisible to anyone reading settings.
- *
- * Exported for tests: the behaviour that matters (a long-but-productive sub-agent is
- * NOT killed) takes minutes of wall clock to exercise through the real loop.
- */
-export declare function resolveSubtaskTimeoutMs(settingsRaw: Record<string, unknown>): number;
-/**
- * Thrown by a sub-agent's permission gate when the AGENT DEFINITION forbids a
- * tool — as opposed to the user declining it.
- *
- * The distinction matters to the model, which is why this is an exception rather
- * than a `false`: both used to collapse into "Permission denied by user", so an
- * agent blocked by its own allowlist (very often a mistyped tool name) was told
- * the human had refused. The rational response to that is to ask again, which
- * can never succeed. Carrying a reason lets the tool_result say what is actually
- * true and what to do instead.
- */
-export declare class ToolNotAllowedError extends Error {
-    constructor(message: string);
-}
-/**
- * Reduce a sub-agent's message history to the text its parent should receive.
- *
- * Pure + exported so the salvage rules can be tested without running a real
- * sub-agent (which needs a live model stream and, for the timeout path, ten
- * minutes of wall clock).
- *
- * `preferLast` — the normal completion path — returns the final assistant
- * message, which is the sub-agent's actual answer.
- *
- * `preferLast: false` is the SALVAGE path, used when the sub-agent was cut off.
- * A stopped sub-agent usually has no closing summary at all (it was killed
- * mid-tool-round), so the last assistant message is frequently empty or a
- * fragment. Concatenating what it did produce is far more useful to the parent
- * model than nothing: it can build on the work instead of redoing it.
- */
-export declare function extractSubTaskText(messages: Message[], preferLast?: boolean): string;
-/** Apply the parent-context cap to a sub-task's text, keeping head + tail. */
-export declare function capSubTaskText(text: string, max?: number): string;
-/**
- * Summarise what a cut-short sub-agent actually accomplished, so the parent model
- * can continue from it rather than starting over.
- *
- * This is the whole point of the salvage path. Previously a timed-out sub-agent
- * returned ONLY an error string: ten minutes of work, dozens of tool calls and
- * any files it wrote were invisible to the parent, which typically responded by
- * re-running the same work from scratch — while the tokens for the discarded run
- * had already been billed in full.
- */
-export declare function summariseSubTaskProgress(messages: Message[]): string;
-/**
- * The last N tool results from a transcript, newest last, each truncated.
- *
- * Pure + exported so the salvage rules are testable without a real sub-agent.
- *
- * Truncation keeps the HEAD of each result: tool output is overwhelmingly
- * front-loaded (a file starts with its imports, a failing command starts with its
- * error), and a head slice is the half that identifies what was found.
- */
-export declare function lastToolResults(messages: Message[], count: number, maxChars: number): string;
-/**
- * Context window (tokens) for a model alias or real model id.
- *
- * Checks the LIVE catalogue (GET /api/code/models, modelCatalogue.ts) first —
- * populated once per process by whichever client fetched it (CLI at session
- * start, VS Code via _postModelCatalogue, desktop via its main-process
- * fetch) — falling back to this hard-coded table when no live data exists yet
- * (offline, older backend, or the catalogue simply hasn't been fetched by
- * this call site). This is what lets a model added to the backend registry
- * (services/providers/modelRegistry.js) get the CORRECT context window here
- * even before this table is updated by hand for a new nexrall-code release —
- * exactly the class of bug GPT-5.6's 922K-vs-1.05M mismatch was (see
- * modelRegistry.js's own comment on that row).
- *
- * The static-table fallback is deliberately the SMALLEST window in the table
- * rather than the largest. An unknown model is most likely a newly added one
- * this client build predates, and guessing high is the failure that cannot be
- * recovered from: the turn hits a provider 400 with no chance to compact.
- * Guessing low only costs an earlier, lossy compaction — annoying, not broken.
- */
-export declare function contextWindowFor(model?: string): number;
-/** Token counts at which auto-prune and auto-compact (summarise) fire for a model window. */
-export declare function compactionLimits(contextWindow: number, settingsRaw?: Record<string, unknown>): {
-    prune: number;
-    compact: number;
-};
-/** Auto-prune / auto-compact thresholds as fractions of the context window — for UI display (e.g. `/context`). */
-export declare function compactionThresholds(contextWindow?: number, settingsRaw?: Record<string, unknown>): {
-    prune: number;
-    compact: number;
-};
-export declare function pruneReclaimFloor(lastCallEndedAt: number | undefined, now?: number): number;
-/** Approximate serialised request-body size (bytes) for the messages array. */
-export declare function estimateBodyBytes(messages: Message[]): number;
-/** Tools that mutate the filesystem — used by the verification nudge (GAP D). */
-export declare const WRITE_TOOL_NAMES: Set<string>;
-/**
- * May an agent restricted to `testFilesOnly` perform this tool call?
- *
- * A tool allowlist is all-or-nothing per tool: granting `edit_file` grants it for
- * every path in the repo. A user-defined test-writer agent needs write access to produce
- * tests, but must NOT be able to "fix" production source so a failing test goes
- * green — the single most common way a test-writing agent destroys the signal it
- * was asked to create. Its prompt says so; this makes it a refusal rather than a
- * request.
- *
- * Pure + exported so the rules are testable directly, without running a real
- * sub-agent.
- *
- * KNOWN LIMIT, stated rather than hidden: this gates the file TOOLS, not `bash`.
- * A determined model could still write source via `bash: echo ... > src/x.ts`.
- * Closing that means parsing shell redirection, which is not reliably doable — so
- * this is a strong guardrail against the realistic failure mode, not a sandbox.
- * Real isolation is the sandbox config (tools/sandbox.ts), a separate mechanism.
- */
-export declare function allowsTestOnlyWrite(tool: string, input: Record<string, unknown> | undefined): boolean;
-/** Heuristic: does a bash command look like it's running tests/build/lint/typecheck? (GAP D) */
-export declare const VERIFY_CMD_RE: RegExp;
-/**
- * Find the latest index ≤ maxIdx where history can be cut safely.
- *
- * A safe cut point is a **turn boundary**: an assistant message (which always
- * begins a fresh turn after a user message). Cutting there guarantees that
- * `messages[cut..]` starts with an assistant whose `tool_use` blocks are all
- * answered by `tool_result`s that remain in the kept slice — so we never orphan
- * a tool_result (which the API rejects). We deliberately allow cutting across
- * tool_result-bearing user messages: the OLD implementation only cut at a
- * *non*-tool_result user message, which never exists inside a single long
- * agentic run (every user turn is a tool_result), so compaction was a no-op
- * exactly when a long task needs it most.
- */
-export declare function findSafeCutIndex(messages: Message[], maxIdx: number): number;
-/**
- * Render messages to a plain-text transcript for the summariser (tool noise
- * truncated per-block AND the whole transcript hard-capped). When the transcript
- * would exceed MAX_TRANSCRIPT_CHARS we keep the HEAD (original task + early
- * decisions) and the TAIL (most-recent, highest-signal context) and drop the
- * middle — a middle-out elision that preserves both "what we set out to do" and
- * "where we are now", which is what the continuation summary needs most.
- */
-/**
- * Appends the backend-announced runtime-context block to the user message it was
- * attached to. No-op if that message is not a user turn or already ends with the
- * identical block. Exported for tests.
- */
-export declare function persistRuntimeContext(messages: Message[], idx: number, text: string): boolean;
-export declare function transcriptOf(messages: Message[]): string;
-export interface ProgressLedger {
-    filesTouched: Map<string, {
-        tool: string;
-        edits: number;
-    }>;
-    /**
-     * DISTINCT paths ever touched, including any since evicted from `filesTouched`.
-     *
-     * The Map is bounded (see ledgerRecord), so `filesTouched.size` is a window, not a
-     * total. The preamble states "FILES CHANGED THIS SESSION (N)" as a fact the model
-     * reasons about, so N must not silently shrink when eviction kicks in on a very long
-     * run — that would tell the model less work happened than actually did.
-     */
-    filesTouchedTotal: number;
-    verifications: Array<{
-        cmd: string;
-        ok: boolean;
-        epoch: number;
-    }>;
-    /** Test-integrity findings (reward-hacking signals) that must survive compaction. */
-    testIntegrity: Array<{
-        path: string;
-        reason: string;
-    }>;
-    /**
-     * TOTAL test-integrity findings ever recorded, including ones since trimmed.
-     *
-     * `testIntegrity` is a bounded window (older entries are spliced off once it grows
-     * past 2×LEDGER_MAX_NOTES), so its `.length` STOPS being a running total after the
-     * first trim. The one-shot nudge compares "how many findings exist" against "how
-     * many I've already surfaced", and comparing against a window that shrinks meant the
-     * count could never move ahead again — silently disabling the reward-hacking warning
-     * for the remainder of a long session, i.e. exactly when it matters most.
-     *
-     * This counter only ever increases, so it is a safe basis for that comparison.
-     */
-    testIntegrityTotal: number;
-    /**
-     * Monotonic mutation epoch: incremented on every successful source write. Two
-     * verification runs sharing an epoch had NO edit between them, so a PASS↔FAIL
-     * flip across that boundary proves the test is flaky (see detectFlaky).
-     */
-    epoch: number;
-}
-export declare function createLedger(): ProgressLedger;
-/** Record one tool call's effect on the ledger (deterministic, no model call). */
-export declare function ledgerRecord(ledger: ProgressLedger, toolName: string, input: Record<string, unknown> | undefined, ok: boolean, output?: string, exitCode?: number): void;
-/** Render the ledger as a compact, verbatim block for the compaction preamble. */
-export declare function ledgerSummary(ledger: ProgressLedger): string;
-/**
- * Lossy-but-structure-preserving prune: shrink OLD, large tool_result blocks in
- * place, keeping the last PRUNE_KEEP_RECENT messages untouched. This is tried
- * BEFORE summarisation because it:
- *   • keeps every turn and every tool_use/tool_result pair (API stays valid),
- *   • never makes an extra model call (summarisation does — cost + latency),
- *   • degrades gracefully on repeat (summarise-of-summarise loses the most on
- *     long runs; pruning just trims already-consumed output further).
- *
- * IMPORTANT: pruned state is encoded in the content string (PRUNE_MARKER_TAIL
- * suffix), NOT as an extra property on the block — a stray field on a content
- * block is rejected by the Anthropic API as an unknown key (400). This keeps the
- * serialised body schema-clean while remaining idempotent across repeat calls.
- *
- * Returns the number of bytes reclaimed (0 if nothing was prunable).
- *
- * `minReclaimBytes` (default 0): if the TOTAL prunable amount is below this, the
- * function makes NO changes and returns 0. This is a cache-safety gate — pruning
- * even one old block changes the request prefix and invalidates the message-level
- * prompt cache, so a tiny prune would bust the cache (re-write at 1.25×) for
- * almost no size win. Measuring first, then applying only if worthwhile, keeps
- * the "don't bust cache for a trivial gain" contract truly atomic (the old code
- * mutated first and let the caller decide, which had already invalidated the
- * cache by the time the caller declined).
- */
-export declare function pruneOldToolResults(messages: Message[], minReclaimBytes?: number): number;
-/**
- * Summarises the WHOLE conversation by appending the instruction to its final user
- * message and sending it with the conversation's own request options — Claude Code's
- * approach. The prefix is byte-identical to the previous request, so the history is a
- * cache READ (0.10×) instead of a fresh uncached transcript of up to 600K chars.
- * Returns '' when it cannot be used (last turn is not the user's) or yields no text.
- */
-export type CachedSummarizer = (instruction: string) => Promise<string>;
-export declare function makeCachedSummarizer(messages: Message[], requestOptions: () => Parameters<typeof streamChat>[1], abortSignal?: {
-    aborted: boolean;
-}): CachedSummarizer;
-/** Rough token estimate for a resumed transcript — no API round-trip needed. */
-export declare function estimateTokensRough(messages: Message[]): number;
-/**
- * Proactively compact `messages` in place if resuming this session would blow
- * past the auto-compact threshold on the very first turn. Returns true if any
- * compaction happened (so the caller can surface a one-line notice to the
- * user). Safe to call on any message array, including empty/small ones (no-op).
- *
- * `model` picks the right context window (mirrors runAgentLoop's own lookup);
- * `onNotice` is optional — pass it to show the same "auto-compacted" message
- * the in-loop path shows, so the behaviour is visually consistent.
- */
-export declare function compactMessagesForResume(messages: Message[], opts: {
-    model?: string;
-    workDir: string;
-    clientType?: string;
-    env?: EnvContext;
-    onNotice?: (text: string) => void;
-}): Promise<boolean>;
+export { loadHooks, parsePromptHookReply, classifyStopFailure, runLifecycleHooks, runPermissionRequestHooks, fireNotificationHooks, fireManualPostCompactHook, fireManualPreCompactHook, fireObserverHook, drainHookDeliveries, takeHookWakes, hasPendingHookWake, formatHookDeliveries, setHookWakeListener, setHookStatusListener, setHookMcpCaller, resetHookOnceState, setHookEventListener, hasHookEventListener, runElicitationHooks, runElicitationResultHooks, } from './hooks';
+export type { HookDef, HookEntry, HooksConfig, ObserverEvent, HookDelivery, HookMcpCaller, HookLifecycleEvent, ElicitationAnswer, ElicitationAction } from './hooks';
+export { contextWindowFor, compactionLimits, compactionThresholds, pruneReclaimFloor, estimateBodyBytes, WRITE_TOOL_NAMES, allowsTestOnlyWrite, VERIFY_CMD_RE, findSafeCutIndex, persistRuntimeContext, transcriptOf, createLedger, ledgerRecord, ledgerSummary, pruneOldToolResults, makeCachedSummarizer, estimateTokensRough, compactMessagesForResume, } from './compaction';
+export type { ProgressLedger, CachedSummarizer } from './compaction';
+export { emptyTurnBackoffMs, shouldRetryEmptyTurn, _emptyTurnRetry, errorRoundSignature, _stallLimits, AGENT_MEMORY_TOOL, AGENT_MEMORY_TOOL_SCHEMA, executeAgentMemoryWrite, stopReasonNotice, resolveMaxIterations } from './iterationPolicy';
+export type { AgentMemoryBinding, StopReason } from './iterationPolicy';
+export { lockPathsFor } from './fileLocks';
+export { resolveMaxConcurrentSubtasks, resolveMaxSubagentsPerSession, createLimiter, _resetSubTaskLimiter, resetSessionSubAgentBudget, _sessionSubAgentCount } from './subAgentBudget';
+export { resolveMaxSubagentDepth, noSpawnReason, intersectAllowlists, canSpawnSubAgents, resolveSubtaskTimeoutMs, ToolNotAllowedError, extractSubTaskText, capSubTaskText, summariseSubTaskProgress, lastToolResults } from './subTaskSupport';
+import { type ForkContext } from './subTask';
+export type { ForkContext };
 /**
  * Dispatch one `task` (sub-agent) call — the exact same path the `task` tool's
  * `runAgentLoop` switch-case uses (session-budget claim, per-depth concurrency
@@ -497,17 +29,33 @@ export declare function compactMessagesForResume(messages: Message[], opts: {
  * own about where agent definitions come from.
  */
 export declare function dispatchSubAgent(input: Record<string, unknown>, options: AgentLoopOptions, agentTypes: AgentType[]): Promise<ToolResult>;
-/**
- * `task` with run_in_background — start the sub-agent detached and return at once.
- *
- * The child runs with its OWN abort signal (the user's Stop on the main turn does not
- * kill it; the hub's stop() does), renders nothing into the chat (its tool calls are
- * only counted for the "N agents" badge), and cannot prompt the user: a call that the
- * project's rules or the session mode do not already allow is refused with an
- * explanation, which the child then reports (Claude Code auto-denies the same way).
- * Its final report reaches the main agent as a <task-notification>.
- */
 export declare function dispatchBackgroundSubAgent(input: Record<string, unknown>, options: AgentLoopOptions, agentTypes: AgentType[], hub: BackgroundAgentHub): ToolResult;
+/**
+ * `/subtask` — fork the CURRENT conversation into a background agent.
+ *
+ * The difference from `dispatchBackgroundSubAgent` above is the starting history: that one
+ * hands the child a self-contained prompt (fresh context, described work, `task` tool
+ * semantics), whereas this one COPIES the caller's transcript in and appends the user's
+ * instruction to it. A user who has spent a conversation narrowing down a problem should not
+ * have to write a brief that re-states it — and a child that re-reads everything to catch up
+ * pays for the same context twice.
+ *
+ * Returns as soon as the child is started (the child runs detached, exactly like a
+ * background `task`): the caller gets the id and the description to show, and the report
+ * arrives later through the hub's notifications. Never `ToolResult`: nothing here is a tool
+ * result for a model to read, so the wording lives with whoever renders it.
+ *
+ * Permission policy is the shared background policy — the child cannot ask the user
+ * anything, because the user is not watching it.
+ */
+export declare function dispatchForkedSubAgent(conversation: Message[], prompt: string, options: AgentLoopOptions, agentTypes: AgentType[], hub: BackgroundAgentHub): {
+    id: string;
+    description: string;
+    agentType: string;
+    messages: number;
+} | {
+    error: string;
+};
 export declare function runAgentLoop(initialMessages: Message[], options: AgentLoopOptions): Promise<Message[]>;
 /**
  * Cut a history back to the last point the API will accept as a resumable

package/dist/agent/loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAKP,UAAU,EACV,gBAAgB,EAChB,UAAU,EAEX,MAAM,UAAU,CAAC;AAIlB,OAAO,EAAiC,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE5F,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAiF,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAmB,MAAM,cAAc,CAAC;AAQrK,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,CAAC;AA8P7B,yFAAyF;AACzF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACrC,aAAa,EAAE,MAAM,GACpB,OAAO,CAGT;AAED,kDAAkD;AAClD,eAAO,MAAM,eAAe;;;CAAuD,CAAC;AAEpF;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,GAC9C,MAAM,CAKR;AAED,+CAA+C;AAC/C,eAAO,MAAM,YAAY;;;CAAsC,CAAC;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,uBAAuB,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;CAgB3B,CAAC;AAEX,mEAAmE;AACnE,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,gBAAgB,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,kBAAkB,GAAG,SAAS,EACvC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,CAAC,CA8BrB;AAED;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAClB,OAAO,GACP,SAAS,GACT,oBAAoB,GACpB,gBAAgB,GAChB,cAAc,GACd,YAAY,GACZ,gBAAgB,GAChB,kBAAkB,GAClB,SAAS,GACT,gBAAgB,GAChB,QAAQ,GACR,SAAS,CAAC;AAEd;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,UAAU,EAClB,GAAG,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GACzD,MAAM,GAAG,IAAI,CAwDf;AAyBD,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,CAYR;AA2ED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,EAAE,CAQV;AAuCD;;;;;;;;;GASG;AACH,wBAAgB,4BAA4B,CAAC,WAAW,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,MAAM,CAW9F;AAoBD,kFAAkF;AAClF,wBAAgB,6BAA6B,CAAC,WAAW,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,MAAM,CAa/F;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAgBlF;AA6DD,6EAA6E;AAC7E,wBAAgB,oBAAoB,IAAI,IAAI,CAM3C;AA0BD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAGpE;AAwDD,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAEjE;AA2KD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,MAAM,CAOzF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAe9E;AAED;;;;;;;;;;;;;;;GAeG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,EACvB,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,SAAS,GAC9B,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAIpB;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAC1B,KAAK,GAAE,MAA+B,GACrC,OAAO,CAMT;AAaD;;;;;;;;;;GAUG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAOpF;AAMD;;;;;;;;;;GAUG;AACH,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAQD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,UAAU,UAAO,GAAG,MAAM,CAYjF;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,SAAc,GAAG,MAAM,CAKtE;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAgCpE;AAMD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CA6B5F;AAi4BD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAGvD;AAmDD,6FAA6F;AAC7F,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACpC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CASpC;AAED,kHAAkH;AAClH,wBAAgB,oBAAoB,CAClC,aAAa,SAAY,EACzB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACpC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAGpC;AAiBD,wBAAgB,iBAAiB,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,EAAE,GAAG,SAAa,GAAG,MAAM,CAI/F;AAyCD,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAM7D;AAsBD,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,aAA+G,CAAC;AAC7I;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,OAAO,CA8BrG;AAED,gGAAgG;AAChG,eAAO,MAAM,aAAa,QAA2J,CAAC;AAEtL;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK5E;AAUD;;;;;;;GAOG;AACH;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAO7F;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAyBxD;AAoBD,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3D;;;;;;;OAOG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAClE,qFAAqF;IACrF,aAAa,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD;;;;;;;;;;;OAWG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAgB,YAAY,IAAI,cAAc,CAE7C;AAED,kFAAkF;AAClF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,cAAc,EACtB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC1C,EAAE,EAAE,OAAO,EACX,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI,CA2EN;AAED,kFAAkF;AAClF,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,GAAG,MAAM,CAgC5D;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,eAAe,SAAI,GAAG,MAAM,CAwCpF;AAsCD;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAExE,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,OAAO,EAAE,EACnB,cAAc,EAAE,MAAM,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,EACtD,WAAW,CAAC,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GACjC,gBAAgB,CAsBlB;AA0LD,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,MAAM,CAE/D;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,EAAE;IACJ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,UAAU,CAAC;IACjB,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC,GACA,OAAO,CAAC,OAAO,CAAC,CAmFlB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,gBAAgB,EACzB,UAAU,EAAE,SAAS,EAAE,GACtB,OAAO,CAAC,UAAU,CAAC,CAyBrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,gBAAgB,EACzB,UAAU,EAAE,SAAS,EAAE,EACvB,GAAG,EAAE,kBAAkB,GACtB,UAAU,CA8DZ;AAID,wBAAsB,YAAY,CAChC,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CAozCpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAqCtE"}
+{"version":3,"file":"loop.d.ts","sourceRoot":"","sources":["../../src/agent/loop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAKP,UAAU,EACV,gBAAgB,EAGjB,MAAM,UAAU,CAAC;AAIlB,OAAO,EAAiC,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAK5F,OAAO,EAAiF,KAAK,SAAS,EAA0C,MAAM,cAAc,CAAC;AAQrK,OAAO,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAkC7B,OAAO,EACL,SAAS,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,yBAAyB,EAClG,qBAAqB,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,gBAAgB,EAG5F,mBAAmB,EAAE,aAAa,EAAE,kBAAkB,EAAE,oBAAoB,EAC5E,mBAAmB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,kBAAkB,EAEhF,oBAAoB,EAAE,oBAAoB,EAG1C,mBAAmB,EAAE,yBAAyB,GAC/C,MAAM,SAAS,CAAC;AACjB,YAAY,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAqBrK,OAAO,EACL,gBAAgB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,iBAAiB,EAC9F,gBAAgB,EAAE,mBAAmB,EAAE,aAAa,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,YAAY,EAC3G,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,mBAAmB,EACzG,wBAAwB,GACzB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAGrE,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,eAAe,EAAE,mBAAmB,EAAE,YAAY,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC/O,YAAY,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAE,4BAA4B,EAAE,6BAA6B,EAAE,aAAa,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAIvL,OAAO,EAAE,uBAAuB,EAAE,aAAa,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,cAAc,EAAE,wBAAwB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAE/O,OAAO,EAAgC,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAE3E,YAAY,EAAE,WAAW,EAAE,CAAC;AAa5B;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,gBAAgB,EACzB,UAAU,EAAE,SAAS,EAAE,GACtB,OAAO,CAAC,UAAU,CAAC,CAyBrB;AA4ED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,gBAAgB,EACzB,UAAU,EAAE,SAAS,EAAE,EACvB,GAAG,EAAE,kBAAkB,GACtB,UAAU,CAkDZ;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,OAAO,EAAE,EACvB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gBAAgB,EACzB,UAAU,EAAE,SAAS,EAAE,EACvB,GAAG,EAAE,kBAAkB,GACtB;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAwD9F;AAID,wBAAsB,YAAY,CAChC,eAAe,EAAE,OAAO,EAAE,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,OAAO,EAAE,CAAC,CA6/CpB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAqCtE"}