@esso0428/pi-subagents 0.17.5 → 0.17.7

package/dist/agent-manager.d.ts

@@ -1,43 +1,81 @@
 /**
  * agent-manager.ts — Tracks agents, background execution, resume support.
  *
- * Background agents are subject to a configurable concurrency limit (default: 4).
- * Excess agents are queued and auto-started as running agents complete.
- * Foreground agents bypass the queue (they block the parent anyway).
+ * There are two independent concurrency pools, never one:
+ *
+ * - Background (`maxConcurrent`, default 10) bounds detached agents.
+ * - Foreground (`maxConcurrentForeground`, default 0 = unlimited) bounds
+ *   agents a caller is blocking on inline — `spawnAndWait`.
+ *
+ * Independent by design: a foreground agent blocks the parent anyway, so
+ * charging it to the background pool would let a saturated pool starve the main
+ * session of work it could have done itself. Excess agents in either pool are
+ * queued and auto-started as slots free up. Nested children take no slot in
+ * either — see `occupiesPoolSlot` / `occupiesForegroundSlot`.
  */
 import type { Model } from "@earendil-works/pi-ai";
 import type { AgentSession, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { type ToolActivity } from "./agent-runner.js";
-import type { AgentInvocation, AgentRecord, IsolationMode, SubagentType, ThinkingLevel } from "./types.js";
+import type { AgentInvocation, AgentRecord, AgentTombstone, IsolationMode, MentionResolution, SubagentType, ThinkingLevel } from "./types.js";
+import { type LifetimeUsage } from "./usage.js";
+import type { CompiledSchema } from "./workflow/json-schema.js";
 export type OnAgentComplete = (record: AgentRecord) => void;
 export type OnAgentStart = (record: AgentRecord) => void;
 export type OnAgentCompact = (record: AgentRecord, info: CompactionInfo) => void;
+/**
+ * Fired once per assistant `message_end`, for EVERY agent this manager owns —
+ * top-level and nested alike, spawns and resumes. The one place where each
+ * message is seen exactly once: `AgentRecord.lifetimeUsage` is deliberately
+ * double-booked into ancestors (see `nested-tools.ts`) so a hidden child's spend
+ * shows up on the record a human can see, which makes those records useless as
+ * a basis for anything that must not count a message twice — parent-session
+ * accounting above all.
+ */
+export type OnAgentUsage = (record: AgentRecord, usage: LifetimeUsage) => void;
 export type CompactionInfo = {
     reason: "manual" | "threshold" | "overflow";
     tokensBefore: number;
 };
-type RestorableAgentStatus = "completed" | "steered" | "stopped" | "aborted" | "error";
-/** Validate one persisted terminal record without constructing runtime handles. */
-export declare function isRestorableAgentRecord(value: unknown): value is {
-    id: string;
-    type: string;
-    description: string;
-    status: RestorableAgentStatus;
-    startedAt: number;
-    completedAt: number;
-    result?: string;
-    error?: string;
-    toolUses?: number;
-    lifetimeUsage?: {
-        input: number;
-        output: number;
-        cacheWrite: number;
-    };
-    transcriptPath?: string;
-    invocation?: AgentInvocation;
-};
+/**
+ * Whether a record is one of the session's own agents, rather than something
+ * another agent or a workflow owns.
+ *
+ * The single definition behind every user-facing surface — the fleet list, the
+ * widget, the `/agents` menus, `@handle` resolution, and the completion events
+ * and session entries. An owned child reports through its owner, so surfacing
+ * it separately would double-count the same work in the places a person reads.
+ */
+export declare function isTopLevelAgent(record: Pick<AgentRecord, "parentAgentId" | "workflowId">): boolean;
 interface SpawnOptions {
     description: string;
+    /**
+     * Optional memorable name for this instance, becoming a second handle
+     * (`@auth-audit`) alongside the type-derived one. Slugged, not validated —
+     * anything unusable degrades via `handleBase` rather than failing the spawn.
+     */
+    name?: string;
+    /**
+     * Reopen this pi session file instead of starting a fresh conversation, so a
+     * mention of an evicted agent continues where it left off. The agent's
+     * definition is still resolved from its type, so the continuation runs under
+     * the type's CURRENT config.
+     */
+    resumeSessionFile?: string;
+    /**
+     * Take an evicted agent's names back verbatim instead of allocating fresh
+     * ones, so a resumed conversation keeps the handle the user just typed —
+     * `handleBase(type)` cannot reproduce a numbered `explore-2`. Safe without an
+     * `assignHandle` pass because tombstoned names are excluded from allocation
+     * (`takenHandles`), so nothing live can be holding them.
+     *
+     * Internal capability, like `resumeSessionFile`: a forged handle would
+     * duplicate a live agent's name and make `resolveMention` ambiguous, so
+     * `spawnTopLevel` strips it from anything a caller sends.
+     */
+    reclaim?: {
+        handle: string;
+        alias?: string;
+    };
     model?: Model<any>;
     maxTurns?: number;
     isolated?: boolean;
@@ -45,11 +83,38 @@ interface SpawnOptions {
     thinkingLevel?: ThinkingLevel;
     isBackground?: boolean;
     /**
-     * Skip the maxConcurrent queue check for this spawn — start immediately even
-     * if the configured concurrency limit would otherwise queue it. Used by the
-     * scheduler so a fired job can't be deferred past its trigger window.
+     * Skip whichever pool's queue check applies to this spawn — start immediately
+     * even if the configured concurrency limit would otherwise queue it. The slot
+     * is still COUNTED once the run starts, so a bypassing spawn transiently
+     * exceeds the limit rather than being invisible to it.
+     *
+     * Used by the scheduler, so a fired job can't be deferred past its trigger
+     * window, and by the `/agents` agent-file generator, which has no way to
+     * cancel a wait (see its call site).
      */
     bypassQueue?: boolean;
+    /**
+     * A caller is awaiting this record inline (`spawnAndWait`) — what
+     * `maxConcurrentForeground` bounds. Set only by `spawnAndWait`; stripped from
+     * caller-supplied options by `spawnTopLevel`, since a forged `blocking` would
+     * defer a detached start behind a queue its caller cannot see or release.
+     */
+    blocking?: boolean;
+    /**
+     * The workflow run this child belongs to, when a workflow spawned it.
+     *
+     * Ownership, not decoration. A workflow's children are the workflow's — they
+     * report through its card, its notification and its dialog, so they are
+     * filtered out of every top-level surface exactly as nested children are, and
+     * they take no `maxConcurrent` slot: the run has its own concurrency cap, and
+     * counting them twice would let one workflow starve the whole session.
+     */
+    workflowId?: string;
+    /**
+     * Make the child report through a `StructuredOutput` tool built from this
+     * compiled schema. Set only by the workflow host, for `agent({ schema })`.
+     */
+    structuredOutput?: CompiledSchema;
     /** Isolation mode — "worktree" creates a temp git worktree for the agent. */
     isolation?: IsolationMode;
     /**
@@ -61,10 +126,44 @@ interface SpawnOptions {
      * branch lands in that repo.
      */
     cwd?: string;
+    /**
+     * Last chance to look at an isolated agent's worktree, awaited immediately
+     * before it is committed to a branch and removed.
+     *
+     * Exists because that removal happens inside the settle path, before
+     * `spawnAndWait` resolves: by the time a caller has the finished record, the
+     * directory the child actually wrote in is gone. Anything that must inspect
+     * or verify that tree — a workflow `gate` is the motivating case — has to run
+     * here or it silently inspects the main tree instead.
+     *
+     * Fires only on the normal settle path, and only when a worktree was created.
+     * Not on the error path and not on the stop-during-copy guard: those are
+     * already failing, and delaying cleanup there would leak a copy for no gain.
+     * A rejection is swallowed — the hook can never keep the worktree alive.
+     */
+    onBeforeWorktreeCleanup?: (worktreePath: string) => Promise<void>;
     /** Resolved invocation snapshot captured for UI display. */
     invocation?: AgentInvocation;
+    /** Whether the optional `.output` transcript is enabled for this run. */
+    outputTranscript?: boolean;
     /** Parent abort signal — when aborted, the subagent is also stopped. */
     signal?: AbortSignal;
+    /**
+     * Called synchronously once the record is in the map and its promise is set,
+     * before `onSessionCreated` fires — where callers attach the output file.
+     *
+     * Carried on the options rather than parked on the manager for the duration
+     * of a spawn: with a foreground queue, `startAgent` can run at drain time,
+     * long after any such field would have been restored, and the callback would
+     * silently never fire (or fire into an unrelated caller's closure).
+     */
+    onSpawned?: (id: string) => void;
+    /**
+     * Called synchronously when the spawn is queued instead of started, with how
+     * many entries in its own pool are ahead of it. The foreground UI uses it to
+     * say so while it waits; nothing else needs it.
+     */
+    onQueued?: (id: string, ahead: number) => void;
     /** Called on tool start/end with activity info (for streaming progress to UI). */
     onToolActivity?: (activity: ToolActivity) => void;
     /** Called on streaming text deltas from the assistant response. */
@@ -81,8 +180,45 @@ interface SpawnOptions {
     }) => void;
     /** Called when the session successfully compacts. */
     onCompaction?: (info: CompactionInfo) => void;
-    /** Called synchronously after the record exists, before it is queued or started. */
-    onSpawned?: (id: string) => void;
+    /** Nesting depth: top-level subagent = 1. */
+    depth?: number;
+    /** Parent agent ID for ownership-scoped nested controls. */
+    parentAgentId?: string;
+    /** Effective inherited nesting cap for this branch. */
+    maxSubagentDepth?: number;
+    /** Config-discovery root inherited by nested launches when it differs from the working directory. */
+    configCwd?: string;
+    /** Root session id, inherited by nested launches so transcripts stay grouped. */
+    rootSessionId?: string;
+}
+interface ResumeOptions {
+    /**
+     * Run the resumed turn detached in the background: return immediately with
+     * the record still "running" (or "queued" at the concurrency limit) and
+     * notify on completion via onComplete, exactly like a background spawn.
+     * Default (false/undefined) runs the resume inline and returns the settled
+     * record — the historical behavior.
+     */
+    isBackground?: boolean;
+    /** Called on tool start/end with activity info (for streaming progress to UI). */
+    onToolActivity?: (activity: ToolActivity) => void;
+    /** Called once per assistant message_end with that message's usage delta. */
+    onAssistantUsage?: (usage: {
+        input: number;
+        output: number;
+        cacheWrite: number;
+    }) => void;
+    /** Called when the session successfully compacts. */
+    onCompaction?: (info: CompactionInfo) => void;
+    /**
+     * Background resume only: called synchronously when the run actually starts —
+     * immediately, or later from drainQueue. Callers wire per-run side effects
+     * (output-file streaming) here rather than at the call site, so a resume that
+     * is stopped while still queued never leaves a subscription behind: `abort()`
+     * drops a queued record without reaching `settle()`, which is what would have
+     * torn that subscription down.
+     */
+    onStarted?: () => void;
 }
 export declare class AgentManager {
     private agents;
@@ -90,55 +226,195 @@ export declare class AgentManager {
     private onComplete?;
     private onStart?;
     private onCompact?;
+    private onUsage?;
     private maxConcurrent;
+    private maxConcurrentForeground;
     /** Base repos worktrees were created from — so dispose() can prune them all,
      *  not just the parent repo (caller-supplied cwd can target other repos). */
     private worktreeRepos;
     /** Project cwd for each record's durable checkpoint. */
     private recoveryCwds;
-    /** Queue of background agents waiting to start. */
+    /**
+     * Startup phases, keyed by agent id. `spawn()` still returns synchronously,
+     * but an agent using worktree isolation is not running yet when it does —
+     * copying the repo is an awaited git call. This is what `awaitStartup` hands
+     * callers that must fail their tool call on a startup failure, and what
+     * `waitForAll` waits on while a record is "running" with no `promise` yet.
+     * Entries are dropped once the run is underway, and kept (rejected) after a
+     * startup failure so a late `awaitStartup` still sees it.
+     */
+    private startups;
+    /**
+     * Evicted agents that can still be reached by name, keyed by handle. Outlives
+     * the 10-minute record cleanup — that timer exists to bound memory, not to
+     * expire a conversation the user might still want — and is cleared alongside
+     * completed records on session start/switch.
+     */
+    private tombstones;
+    /**
+     * Agents waiting to start, tagged with the pool they wait on. One queue for
+     * both pools: `drainQueue` picks the earliest entry whose own pool has room,
+     * so neither can head-of-line-block the other, and every removal path
+     * (`abort`, `abortAll`, `dispose`) stays a single filter.
+     *
+     * `release` wakes a caller blocked in `spawnAndWait`, and is fired once the
+     * entry's `start` has SETTLED rather than at drain time: startup is async
+     * now, so releasing earlier would wake the caller before `record.promise`
+     * exists and it would read a still-starting agent as one that never ran.
+     * Removing an entry from this array MUST release it — a queued record has no
+     * promise to await, and pi has no tool-execution timeout to bail the caller
+     * out.
+     */
     private queue;
     /** Number of currently running background agents. */
     private runningBackground;
-    /** Prevent late promise settlement from decrementing a replacement run. */
-    private runningBackgroundIds;
-    constructor(onComplete?: OnAgentComplete, maxConcurrent?: number, onStart?: OnAgentStart, onCompact?: OnAgentCompact);
+    /** Number of currently running foreground (blocking) agents. */
+    private runningForeground;
+    constructor(onComplete?: OnAgentComplete, maxConcurrent?: number, onStart?: OnAgentStart, onCompact?: OnAgentCompact, onUsage?: OnAgentUsage);
     /** Update the max concurrent background agents limit. */
     setMaxConcurrent(n: number): void;
     getMaxConcurrent(): number;
-    private finishBackground;
+    /** Update the max concurrent foreground (blocking) agents limit. 0 = unlimited. */
+    setMaxConcurrentForeground(n: number): void;
+    getMaxConcurrentForeground(): number;
+    /**
+     * Which pool a spawn is charged to, or undefined for one that is charged to
+     * neither (nested children, detached non-background spawns).
+     *
+     * Nothing here queues when the limit is unset — `poolHasRoom` reports an
+     * unlimited pool as always having room, so that alone is what keeps the
+     * default path identical. The `> 0` guard is belt and braces on top: it also
+     * keeps the counter from churning and the settle path from calling a drain
+     * that would find nothing to do. Both are unobservable, which is why no test
+     * pins them; the observable half — that the default start stays synchronous —
+     * is pinned in `test/foreground-concurrency.test.ts`.
+     */
+    private poolFor;
+    private poolHasRoom;
+    /**
+     * Spawn an agent and return its ID immediately (for background use).
+     * If the concurrency limit is reached, the agent is queued.
+     *
+     * The id comes back synchronously, but with `isolation: "worktree"` the agent
+     * is not running yet when it does — the repo copy is an awaited git call.
+     * Callers that must fail a tool call on a startup failure await
+     * `awaitStartup(id)`; everyone else sees it on the record (status "error").
+     */
+    spawn(pi: ExtensionAPI, ctx: ExtensionContext, type: SubagentType, prompt: string, options: SpawnOptions): string;
+    /**
+     * Attach the project-local transcript once for a newly-created record.
+     * Repeated calls are harmless: deterministic paths and an existing file keep
+     * the initial user entry intact, which is important for resume and retries.
+     */
+    private attachDurableTranscript;
     private checkpointStatus;
     private makeCheckpoint;
     private checkpoint;
-    private flushOutput;
-    /** Set the durable transcript locator and checkpoint the current state. */
-    setTranscript(id: string, historyFile: string, transcriptPath: string, cwd?: string): void;
-    /** Checkpoint one record explicitly (used after transcript setup). */
+    /** Checkpoint a record after external transcript wiring. */
     checkpointRecord(id: string): void;
+    /** Register durable transcript metadata for compatibility with callers that
+     * attach a pre-existing history (for example a restored session). */
+    setTranscript(id: string, historyFile: string, transcriptPath: string, cwd?: string): void;
+    /** Restore active checkpoints as stopped partial history after a restart. */
+    restoreRecovered(cwd: string): void;
     /**
-     * Reload durable records from this project's checkpoint directory. A
-     * running/queued checkpoint means the process was killed before it could
-     * write its stopped state; treat it as stopped and retain its transcript.
-     * SIGKILL cannot run a final flush/checkpoint, so this active snapshot is
-     * necessarily the last recoverable state.
+     * Restore terminal records from durable history without creating sessions.
+     * Invalid and live records are ignored so recovery cannot replace active work.
      */
-    restoreRecovered(cwd: string): void;
+    restoreCompleted(records: readonly Partial<AgentRecord>[]): void;
     /**
-     * Spawn an agent and return its ID immediately (for background use).
-     * If the concurrency limit is reached, the agent is queued.
+     * Wire a parent abort signal for a record that is about to be QUEUED.
+     * `startAgent` does this for running agents, and a queued record never gets
+     * there, so without this Esc could not release a queue position.
+     *
+     * Returns false when the signal is ALREADY aborted, in which case the record
+     * is stopped here and must not be enqueued: `addEventListener` never fires on
+     * an aborted signal, so a `spawnAndWait` on it would wait forever — pi has no
+     * tool-execution timeout to bail it out.
+     *
+     * The listener is left in place when the agent starts. `startAgent` adds its
+     * own, so both fire on a later abort, but `abort()` on an already-stopped
+     * record is a no-op — so detaching would only be tidiness, and tidiness the
+     * `abortAll`/`dispose` paths could not offer anyway.
      */
-    spawn(pi: ExtensionAPI, ctx: ExtensionContext, type: SubagentType, prompt: string, options: SpawnOptions): string;
+    private armQueuedAbort;
+    /**
+     * Kick off an agent's startup and register it under `startups`. The returned
+     * promise never rejects — the failure is delivered through `awaitStartup`,
+     * and to the record.
+     *
+     * @param queuedPool - The pool this start was QUEUED on, or undefined for an
+     *   immediate start. A queue drain can be minutes after `spawn()` returned,
+     *   and nobody is awaiting `awaitStartup` by then, so a failure has to live
+     *   on the record as status "error" — what drainQueue did when the throw was
+     *   still synchronous. An immediate start instead drops the record, exactly
+     *   as the throw out of `spawn()` did: no orphan in `listAgents()`, and the
+     *   handle goes back.
+     */
+    private launch;
+    /**
+     * Resolves once the agent is actually running, and rejects with the startup
+     * failure (strict worktree isolation) that `spawn()` used to throw before the
+     * repo copy became async. Resolves immediately for an agent that is already
+     * running, still queued, or unknown — so callers can await it unconditionally.
+     *
+     * Call it in the same tick as the `spawn()` it belongs to: a failed startup
+     * takes its record (and this entry) with it, exactly as the throw did.
+     */
+    awaitStartup(id: string): Promise<void>;
     /** Actually start an agent (called immediately or from queue drain). */
     private startAgent;
-    /** Start queued agents up to the concurrency limit. */
+    /**
+     * The shared tail of both settle paths: release whatever pool slot the run
+     * held, notify, and let the queue drain into the freed slot.
+     *
+     * The decrement lives HERE and nowhere else. `abort()` on a running record
+     * only fires its controller and leaves the run to settle normally, so
+     * decrementing there too would double-free — permanently lifting the limit.
+     *
+     * Foreground agents fire `onComplete` for lifecycle symmetry, with
+     * `resultConsumed` set so the callback skips notifications the inline result
+     * already delivered.
+     *
+     * @param guardCallback swallow a throwing `onComplete` (the success path does;
+     *   the error path historically did not, and keeps not doing so).
+     * @param pool the pool this run was CHARGED TO at start time — passed in, not
+     *   recomputed, so a mid-run change to `maxConcurrentForeground` can't make
+     *   the release disagree with the acquire.
+     */
+    private settleRun;
+    private flushOutput;
+    /**
+     * Stop the nested children a settled parent owns. Nested records are hidden
+     * from the UI and only their owner can consume them, so a child outliving its
+     * parent would burn tokens unseen with no way to reach it. Grandchildren are
+     * covered transitively — each abort lands in that child's own settle path.
+     */
+    private abortOwnedChildren;
+    /**
+     * Start queued agents up to each pool's concurrency limit.
+     *
+     * `findIndex` on the entry's OWN pool rather than `shift`: with one queue
+     * serving two independent limits, a saturated foreground pool at the head
+     * would otherwise stall every background agent behind it. Taking the earliest
+     * eligible entry keeps FIFO within each pool, which is what callers see.
+     */
     private drainQueue;
+    /**
+     * Remove queued entries and wake anyone blocked on them. The single point
+     * that enforces "leaving the queue releases the waiter" — a missed release is
+     * an unbounded hang, not a failed call.
+     */
+    private dequeue;
     /**
      * Spawn an agent and wait for completion (foreground use).
-     * Foreground agents bypass the concurrency queue.
+     * Charged to the foreground pool (`maxConcurrentForeground`), which is
+     * unlimited by default; never to the background one.
      * Returns { id, record } so callers can access the agent ID.
      *
-     * @param onSpawned - Called synchronously after spawn(), before onSessionCreated fires.
-     *   Use this to set record.outputFile so streamToOutputFile can pick it up.
+     * @param onSpawned - Called synchronously once the run is kicked off, before
+     *   onSessionCreated fires. Use this to set record.outputFile so
+     *   streamToOutputFile can pick it up.
      */
     spawnAndWait(pi: ExtensionAPI, ctx: ExtensionContext, type: SubagentType, prompt: string, options: Omit<SpawnOptions, "isBackground">, onSpawned?: (id: string) => void): Promise<{
         id: string;
@@ -147,7 +423,15 @@ export declare class AgentManager {
     /**
      * Resume an existing agent session with a new prompt.
      */
-    resume(id: string, prompt: string, signal?: AbortSignal): Promise<AgentRecord | undefined>;
+    resume(id: string, prompt: string, signal?: AbortSignal, options?: ResumeOptions): Promise<AgentRecord | undefined>;
+    /**
+     * Start a background resume run: detached, settling and notifying like
+     * startAgent's background path. Invoked immediately, or from drainQueue when
+     * a concurrency slot frees. The session already exists (resume reuses it), so
+     * there is no onSessionCreated to hang per-run wiring off — callers use
+     * `options.onStarted`, which fires on both the immediate and the drained path.
+     */
+    private startResume;
     /**
      * Send a steering message to an agent from the UI (mirrors the steer_subagent
      * tool). A live session delivers it now — it interrupts the agent after its
@@ -158,13 +442,38 @@ export declare class AgentManager {
      */
     steer(id: string, message: string): boolean;
     getRecord(id: string): AgentRecord | undefined;
+    /** Handles already in use, so a fresh spawn can pick an unclaimed one. */
+    private takenHandles;
+    /**
+     * Resolve an `@name` from the prompt. Matches a top-level agent's handle
+     * case-insensitively, preferring one that can still be steered and otherwise
+     * the most recently started (which is the one a resume should continue), then
+     * falls back to an exact agent id so `@<agentId>` works too.
+     */
+    resolveMention(name: string): MentionResolution | undefined;
+    /**
+     * Forget an evicted agent, by handle. For the case where its session file has
+     * gone: the entry can then only ever fail, while still holding the name
+     * against the type that would otherwise start a fresh agent under it.
+     *
+     * A *successful* resume does not drop its tombstone — the live record it
+     * creates already wins in `resolveMention`, and overwrites the entry in place
+     * when it is itself evicted.
+     */
+    dropTombstone(handle: string): void;
+    /** Evicted agents whose conversation can still be reopened, newest first. */
+    listTombstones(): AgentTombstone[];
     listAgents(): AgentRecord[];
-    /** Restore terminal records persisted by a parent branch without runtime handles. */
-    restoreCompleted(records: readonly unknown[]): void;
-    private createRestoredRecord;
     abort(id: string): boolean;
     /** Dispose a record's session and remove it from the map. */
     private removeRecord;
+    /**
+     * Preserve enough of a departing record for `@handle` to reopen its
+     * conversation later. Nothing to keep unless it has both a handle to be
+     * addressed by and a session file to reopen — an in-memory session leaves no
+     * transcript, so the mention would have nothing to continue from.
+     */
+    private tombstone;
     private cleanup;
     /**
      * Remove all completed/stopped/errored records immediately.
@@ -179,7 +488,12 @@ export declare class AgentManager {
     abortAll(): number;
     /** Wait for all running and queued agents to complete (including queued ones). */
     waitForAll(): Promise<void>;
-    dispose(): void;
+    /**
+     * @param pi - Needed to run `git worktree prune`, which is async now and so
+     *   cannot be reached through a stored spawn argument at shutdown. Omitting
+     *   it (tests, teardown of a manager that never spawned) skips the prune.
+     */
+    dispose(pi?: ExtensionAPI): Promise<void>;
 }
 export {};
 //# sourceMappingURL=agent-manager.d.ts.map

package/dist/agent-manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-manager.d.ts","sourceRoot":"","sources":["../src/agent-manager.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"agent-manager.d.ts","sourceRoot":"","sources":["../src/agent-manager.ts"],"names":[],"mappings":"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"}