mindweave 0.0.1 → 2.1.2

package/dist/tools/shellTools.js

@@ -0,0 +1,203 @@
+import { relativize } from "./paths.js";
+import { MAX_READ_CHARS } from "./backgroundShells.js";
+import { fail, failQuietly } from "./results.js";
+/**
+ * One read-only tool at two levels of specificity: no `id` lists, an `id` reads.
+ *
+ * These were `list_shells` and `shell_output`. Same manager, same questions ("what is
+ * running" then "what did that one say"), and reading was almost always the direct
+ * follow-up to listing — so the split cost two advertised schemas and gave the model a
+ * routing decision it did not need.
+ *
+ * `kill_shell` deliberately stays a separate tool. It is the only mutating one of the
+ * three, and the plan-mode filter runs on `tool.readOnly` while BUILDING the advertised
+ * list — before any arguments exist. Folding a kill into this tool would therefore force
+ * a choice between hiding shell inspection from Architect mode and read-only sub-agents,
+ * or offering them a way to kill processes. Neither is acceptable, so the merge stops
+ * exactly where the read/write line is.
+ */
+export const shellsTool = {
+    name: "shells",
+    readOnly: true,
+    /**
+     * Advertised only once this session has actually started a background shell.
+     *
+     * Nothing is lost by hiding it before then: with no shells there is nothing to list
+     * and nothing to read, so the tool can only be called to be told so. It is worth
+     * roughly 600 tokens of standing prompt across this tool and `kill_shell`, paid on
+     * every uncached request of every session — including the many that never background
+     * anything.
+     *
+     * The condition is `list()`, which retains FINISHED shells, and not `running()`.
+     * That is deliberate and is about the prompt cache rather than about correctness: the
+     * tool list is part of the cached prefix, so a condition that flipped off again when
+     * the last process exited would invalidate the whole prefix twice per shell instead
+     * of once per session. `list()` only ever goes from empty to non-empty, so the cost
+     * is a single rebuild the first time a shell appears. Reading a finished shell's
+     * output is a real use anyway.
+     */
+    relevantWhen: (ctx) => (ctx.backgroundShells?.list().length ?? 0) > 0,
+    // The description never mentioned polling, while the tool itself pushes a strong
+    // don't-poll nudge at runtime; the two now agree. It also never mentioned either cap,
+    // and the buffer one matters: a chatty process can roll output out of the retained
+    // log between reads, so "everything since last time" is not always literally true.
+    description: "Look at the background shells run_command has started.\n" +
+        "With no `id` it LISTS them, running and recently finished. Each line answers the " +
+        "two questions worth asking about a background process: IS IT UP, distinguishing a " +
+        "server still starting from one that has come up, and WHY DID IT STOP, " +
+        "distinguishing a crash from the user closing it themselves from you stopping it. " +
+        "Check this before restarting anything: a process the user shut down should not be " +
+        "reopened, and an exit code alone cannot tell you which case you are in.\n" +
+        "With an `id` it READS that shell's new output — only what has been printed since " +
+        "your last check, plus whether it is still running or has finished and with what " +
+        "exit code. " +
+        "You normally do NOT need to call this on a loop: whether you are told about the " +
+        "shell is set by run_command's 'notify', and when you will be told, you are told " +
+        "automatically. Use this when you want the output itself, not to find out whether " +
+        "something has happened. " +
+        `A single read returns at most ${MAX_READ_CHARS.toLocaleString("en-US")} characters and says when it ` +
+        "has dropped earlier lines to fit. Separately, a very chatty process can overflow " +
+        "the retained log, in which case the oldest output is gone for good and the status " +
+        "line says so.",
+    parameters: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            id: {
+                type: "integer",
+                description: "A background shell id to read (e.g. 1). Omit entirely to list the shells instead.",
+            },
+        },
+    },
+    async execute(args, ctx) {
+        const mgr = ctx.backgroundShells;
+        if (!mgr)
+            return { output: "No background shells are available in this context.", summary: "no background shells" };
+        // The dispatch: naming a shell reads it, otherwise list what there is.
+        if (args.id === undefined || args.id === null)
+            return listAll(ctx);
+        const id = toId(args.id);
+        if (id === null)
+            return failQuietly("`id` must be a shell number.");
+        const res = await mgr.read(id);
+        if (!res)
+            return fail(`no background shell #${id}.`);
+        const head = statusLine(res.info);
+        const body = res.chunk.trim();
+        // If it's still running, stop the model polling: the event is pushed to it, so a
+        // poll loop is pure waste and reads as spam. But the nudge has to promise the
+        // RIGHT event. A server is never told about its own stop, so telling the model it
+        // would hear "when it finishes" is a promise the tool does not keep — the same
+        // false claim that once had it announcing a report that never arrived.
+        const nudge = res.info.status !== "running"
+            ? ""
+            : res.info.notify === "on_failure"
+                ? "\n[Still starting. You'll be told automatically once it has come up, and you will NOT be " +
+                    "told when it later stops — do NOT poll again. End your turn.]"
+                : res.info.notify === "never"
+                    ? "\n[Still running. Nothing about this will be reported to you — do NOT poll again. End your turn.]"
+                    : "\n[Still running. You'll be notified automatically when it finishes — do NOT poll again. " +
+                        "End your turn and let the user know you'll report when it's done.]";
+        return {
+            output: (body ? `${head}\n${body}` : `${head}\n(no new output)`) + nudge,
+            summary: `shell #${id} (${res.info.status})`,
+        };
+    },
+};
+export const killShell = {
+    name: "kill_shell",
+    readOnly: false,
+    /** Same gate as `shells`, and for the same reason — including using `list()` rather
+     *  than `running()` so the tool list latches once per session instead of flipping
+     *  with every process that starts and stops. */
+    relevantWhen: (ctx) => (ctx.backgroundShells?.list().length ?? 0) > 0,
+    description: "Stop a running background shell by id. Kills the whole process tree, not just the " +
+        "shell, so a dev server that spawned its own children goes down with it. " +
+        "It records that YOU stopped it, which is what later lets the status be reported as " +
+        "stopped deliberately rather than guessed at as a crash. " +
+        "Stopping something already finished is not an error: you get told it was not " +
+        "running, and nothing else happens.",
+    parameters: {
+        type: "object",
+        additionalProperties: false,
+        required: ["id"],
+        properties: {
+            id: { type: "integer", description: "The background shell id to stop." },
+        },
+    },
+    async execute(args, ctx) {
+        const mgr = ctx.backgroundShells;
+        if (!mgr)
+            return fail("no background shells are available in this context.");
+        const id = toId(args.id);
+        if (id === null)
+            return failQuietly("`id` must be a shell number.");
+        const killed = mgr.kill(id);
+        return killed
+            ? { output: `Stopped background shell #${id}.`, summary: `killed shell #${id}` }
+            : { output: `Background shell #${id} wasn't running (already finished, or no such id).`, summary: `shell #${id} not running` };
+    },
+};
+/** The no-`id` half of `shells`: what is running, and why anything stopped. */
+function listAll(ctx) {
+    const mgr = ctx.backgroundShells;
+    const shells = mgr?.list() ?? [];
+    if (shells.length === 0)
+        return { output: "No background shells.", summary: "no background shells" };
+    const running = mgr.runningCount();
+    // The same anti-poll discipline the read path (by `id`) enforces, but for the list. The
+    // events worth waking for — a task finishing, a server coming up, a server failing to come
+    // up — are PUSHED automatically, so re-listing on a loop is pure waste; and a server's
+    // normal stop is never reported, so waiting for one to "finish" waits forever. Without
+    // this a model that checks "what's running" repeatedly is told neither, and loops. Only
+    // attached while something is running: a finished list is a fact to read, not a poll.
+    const nudge = running > 0
+        ? `\n[${running} still running. You are told automatically when there is something to act on — a ` +
+            "task finishing, a server coming up, or a failure to come up. A server's normal stop is NOT " +
+            'reported, so never wait for one to "finish." Do NOT list this on a loop — end your turn.]'
+        : "";
+    return {
+        output: shells.map((s) => statusLine(s, ctx)).join("\n") + nudge,
+        summary: `${running} running, ${shells.length} total`,
+    };
+}
+/**
+ * One line describing a shell, including the facts that decide whether anything needs
+ * doing about it.
+ *
+ * `stoppedBy` and `ready` are recorded precisely so the model can answer "is my app
+ * up" and "why did it stop" without guessing, so they have to be rendered here — this
+ * is the only place it can go looking. Without them every ending reads as `exited 1`,
+ * which is the same thing a crash and a user closing a window both produce.
+ */
+function statusLine(info, ctx) {
+    const where = ctx ? ` in ${relativize(ctx, info.cwd)}` : "";
+    // A rolled buffer means output is permanently gone. It was recorded and never shown,
+    // so an incomplete log looked exactly like a complete one.
+    const rolled = info.truncated ? " [earlier output dropped: this log is incomplete]" : "";
+    if (info.status === "running") {
+        const secs = Math.round((Date.now() - info.startedAt) / 1000);
+        const state = info.notify === "on_failure" ? (info.ready ? "up" : "starting") : "running";
+        return `#${info.id} ${state} (${secs}s)${where}: ${info.command}${rolled}`;
+    }
+    const verb = info.stoppedBy === "user"
+        ? "stopped by the user"
+        : info.stoppedBy === "agent"
+            ? "stopped by you"
+            : info.status === "killed"
+                ? "killed"
+                : // A signalled process reports no exit code, so reading the number gives
+                    // "exited null" — which is how a stopped app used to describe itself.
+                    info.signal
+                        ? `stopped (${info.signal})`
+                        : `exited ${info.exitCode}`;
+    // Whether it ever came up is what separates "the user closed their app" from "it
+    // never started", which the exit code alone cannot tell you.
+    const cameUp = info.notify === "on_failure" && !info.stoppedBy ? (info.ready ? ", after it had come up" : ", never came up") : "";
+    return `#${info.id} ${verb}${cameUp}${where}: ${info.command}${rolled}`;
+}
+function toId(value) {
+    const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    return Number.isInteger(n) && n >= 1 ? n : null;
+}
+//# sourceMappingURL=shellTools.js.map

package/dist/tools/shellTools.js.map

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

package/dist/tools/spanCore.js

@@ -0,0 +1,78 @@
+/**
+ * spanCore.ts — pure line-span helpers for reading/replacing a symbol's body.
+ *
+ * The two symbol tools (read_symbol, replace_symbol_body) need to turn a symbol
+ * into a range of lines and then slice or splice that range. All of that math is
+ * kept here — string/number in, string/number out, no fs, no tree-sitter — so it
+ * is unit-tested once and both tools (and the chassis's LSP `documentSymbol`
+ * reader) inherit the same, verified behavior. Deciding WHICH symbol to touch is
+ * the model's job; this module only does the mechanical slicing.
+ */
+/** Flatten a (possibly nested) documentSymbol tree to name + 1-based line range. */
+export function flattenDocSymbols(raw) {
+    const out = [];
+    const visit = (nodes) => {
+        for (const n of nodes ?? []) {
+            const r = n.range ?? n.location?.range;
+            const name = typeof n.name === "string" ? n.name : "";
+            if (name && typeof r?.start?.line === "number" && typeof r?.end?.line === "number") {
+                out.push({ name, start: r.start.line + 1, end: r.end.line + 1 });
+            }
+            if (n.children && n.children.length)
+                visit(n.children);
+        }
+    };
+    visit(raw ?? []);
+    return out;
+}
+/**
+ * Pick the span whose start line is nearest `nearLine` (used to disambiguate
+ * overloads / same-named symbols in one file). With no hint, the first span.
+ */
+export function pickNearest(spans, nearLine) {
+    if (spans.length === 0)
+        return null;
+    if (nearLine === undefined)
+        return spans[0];
+    return spans.reduce((best, s) => Math.abs(s.start - nearLine) < Math.abs(best.start - nearLine) ? s : best);
+}
+/** Split on CRLF or LF so line math is identical regardless of the file's EOL. */
+function toLines(content) {
+    return content.split(/\r?\n/);
+}
+/**
+ * The lines [start..end] (1-based, inclusive) of `content`, line-numbered like
+ * read_file. Clamped to the file's real bounds so a slightly-too-long span never
+ * throws.
+ */
+export function sliceBody(content, start, end) {
+    const lines = toLines(content);
+    const from = Math.max(1, start);
+    const to = Math.min(lines.length, end);
+    const width = String(to).length;
+    const out = [];
+    for (let i = from; i <= to; i++)
+        out.push(`${String(i).padStart(width)}\t${lines[i - 1] ?? ""}`);
+    return out.join("\n");
+}
+/** The raw text (no line numbers) of lines [start..end], for a diff or backup. */
+export function rawLines(content, start, end) {
+    const lines = toLines(content);
+    return lines.slice(Math.max(0, start - 1), Math.min(lines.length, end)).join("\n");
+}
+/**
+ * Replace lines [start..end] (1-based, inclusive) of `content` with `replacement`.
+ * Operates on LF-normalized text (the caller re-applies the file's real EOL). The
+ * range is clamped to the file's bounds so an over-long end can't drop trailing
+ * content it didn't mean to.
+ */
+export function spliceLines(content, start, end, replacement) {
+    const lines = toLines(content);
+    const repl = replacement.replace(/\r\n/g, "\n").split("\n");
+    const from = Math.max(1, start);
+    const to = Math.min(lines.length, end);
+    const before = lines.slice(0, from - 1);
+    const after = lines.slice(to);
+    return [...before, ...repl, ...after].join("\n");
+}
+//# sourceMappingURL=spanCore.js.map

package/dist/tools/spanCore.js.map

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

package/dist/tools/subagent.js

@@ -0,0 +1,224 @@
+/**
+ * subagent.ts — spawn_subagent: delegate a bounded task to a scoped child agent.
+ *
+ * The context-isolation lever, orchestrator-worker style. A wide search or a
+ * self-contained chunk of work can cost dozens of tool rounds whose intermediate
+ * output would bloat the main agent's context. spawn_subagent runs that work in a
+ * CHILD session — its own transcript, its own read ledger, its own step budget — and
+ * returns only the child's final, distilled summary. The lead agent gets the answer
+ * without the mess, and can spawn SEVERAL read-only workers in ONE message to fan out
+ * in parallel (the engine runs concurrency-safe calls together).
+ *
+ * It reuses the engine's own `respond()` loop on a forked session (via `ctx.forkChild`,
+ * injected by the engine), so a sub-agent is a full agent, not a lesser one. Recursion
+ * is capped by `subagentDepth` so a sub-agent can't spawn its own sub-agents.
+ *
+ * A child CANNOT reach the user. It has no approval channel, and nothing the user
+ * granted in person — a Sentinel allowance, a folder they let the agent write to, the
+ * plan they approved — comes with it. So under Sentinel a child's mutating tools are
+ * REFUSED rather than prompted, and it reports back instead. That is the failing
+ * direction to pick: the alternative is a question on screen from an agent the user
+ * never saw start, or worse, an action taken on a permission they gave for something
+ * else. `read_only` restricts a child to searching/reading for safe research tasks —
+ * and ONLY a read-only worker is concurrency-safe (an editing worker runs alone, in
+ * order, so parallel edits can't race). A process-wide semaphore bounds how many run
+ * at once.
+ */
+import { randomUUID } from "node:crypto";
+import { STATUS_INSTRUCTION, renderVerdict, verifySubagentReport } from "./subagentReport.js";
+import { fail, failQuietly } from "./results.js";
+const MAX_SUBAGENT_DEPTH = 1;
+/** Default step budget for a worker; the caller can scale it with `max_steps`. */
+const SUBAGENT_BUDGET = envInt("MINDWEAVE_SUBAGENT_BUDGET", 20);
+/** Ceiling on `max_steps` so one worker can't run away. */
+const MAX_SUBAGENT_STEPS = envInt("MINDWEAVE_SUBAGENT_MAX_STEPS", 60);
+/** How many workers may run concurrently, process-wide. */
+const SUBAGENT_CONCURRENCY = envInt("MINDWEAVE_SUBAGENT_CONCURRENCY", 5);
+/**
+ * A bounded gate so a wide fan-out queues instead of launching a swarm of agents at
+ * once. Hand-off release (the freed slot goes straight to the next waiter) keeps the
+ * live count at or below the limit even under interleaved arrivals.
+ */
+export class Semaphore {
+    limit;
+    active = 0;
+    waiters = [];
+    constructor(limit) {
+        this.limit = limit;
+    }
+    async run(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+    acquire() {
+        if (this.active < this.limit) {
+            this.active++;
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => this.waiters.push(resolve));
+    }
+    release() {
+        const next = this.waiters.shift();
+        if (next)
+            next(); // hand the slot over; active is unchanged, so we never exceed limit
+        else
+            this.active--;
+    }
+}
+const gate = new Semaphore(SUBAGENT_CONCURRENCY);
+export const spawnSubagent = {
+    name: "spawn_subagent",
+    /** Deferred: fan-out is a decision made at planning time rather than a step in the edit
+     *  loop, and at ~750 tokens it is the most expensive schema outside the core four. The
+     *  index line names it, so the option is visible where the choice is made. */
+    deferred: true,
+    readOnly: false,
+    // A read-only worker changes nothing and is safe to fan out in parallel; an editing
+    // worker must run alone (serial lane) so concurrent edits can't race. This is what
+    // lets the model emit several read-only spawn_subagent calls in one message and have
+    // them run concurrently.
+    isConcurrencySafe: (args) => args.read_only === true,
+    // Three limits were enforced in code and absent from the text: a child cannot spawn
+    // its own child, parallel workers are capped, and running out of steps is a clean
+    // PAUSE rather than a failure. That last one changes what the model should do about
+    // it — re-spawn with a bigger budget, not abandon the approach or retry identically.
+    // The briefing advice was also making one point three times, which dilutes it.
+    description: "Delegate a focused, self-contained subtask to a child agent with its own context, " +
+        "then get back just its result. This is how a wide search, an inventory, or a " +
+        "bounded chunk of work stays out of your context (e.g. \"find and list every call " +
+        "site of authFetch\"). The child does NOT see this conversation and cannot ask the " +
+        "user anything, so the task must stand alone: the objective, its boundaries (what " +
+        "NOT to touch), and via output_format the exact shape of the result you want. " +
+        "Set read_only:true for research and inventory that must not change files.\n" +
+        "PARALLEL: emit several read-only calls in ONE message to fan out over independent " +
+        `areas, giving each a distinct slice so they do not duplicate work. Up to ` +
+        `${SUBAGENT_CONCURRENCY} run at once; beyond that they queue, so more workers stop ` +
+        "buying speed. A non-read-only child runs alone. Sub-agents cost far more tokens " +
+        "than doing the work inline, and most editing is sequential, so delegate for " +
+        "independent READ and discovery rather than to parallelise edits.\n" +
+        `LIMITS: a child gets ${SUBAGENT_BUDGET} tool rounds by default (raise with ` +
+        "max_steps). If it runs out it PAUSES cleanly and says so, with its findings " +
+        "intact — that is not a failure, and the fix is a bigger max_steps, not the same " +
+        "call again. A child cannot spawn its own children, so plan one level of " +
+        "delegation and do the rest yourself.\n" +
+        "BRIEF IT WELL: write to the child as you would to a competent colleague who just " +
+        "walked in and cannot see any of this. Do the thinking yourself and hand over " +
+        "specifics (file paths, line numbers, exactly what to change) rather than \"based " +
+        "on your findings, fix the bug\". Terse command-style prompts produce shallow work.",
+    parameters: {
+        type: "object",
+        additionalProperties: false,
+        required: ["task"],
+        properties: {
+            task: {
+                type: "string",
+                description: "A complete, standalone objective for the child, including any context and scope boundaries it needs " +
+                    "(it cannot see your conversation).",
+            },
+            read_only: {
+                type: "boolean",
+                description: "When true, the child may only read/search — no edits or commands — AND it runs in parallel with other " +
+                    "read-only workers spawned in the same message. Default false (runs alone). Use true for research/inventory.",
+            },
+            output_format: {
+                type: "string",
+                description: "The exact shape the result should come back in (e.g. \"a bullet list of `file:line — what's there`\"). " +
+                    "Strongly recommended — it keeps the report tight and directly usable.",
+            },
+            max_steps: {
+                type: "integer",
+                minimum: 1,
+                maximum: MAX_SUBAGENT_STEPS,
+                description: `Tool-round budget for the child (default ${SUBAGENT_BUDGET}). Scale it up for deeper tasks, down for quick lookups.`,
+            },
+        },
+    },
+    async execute(args, ctx) {
+        const task = typeof args.task === "string" ? args.task.trim() : "";
+        if (!task)
+            return failQuietly("`task` is required — describe the subtask for the child agent.");
+        const depth = ctx.subagentDepth ?? 0;
+        if (depth >= MAX_SUBAGENT_DEPTH) {
+            return fail("a sub-agent cannot spawn another sub-agent — do this part of the work directly.");
+        }
+        if (!ctx.forkChild) {
+            return fail("sub-agents aren't available in this context.");
+        }
+        const outputFormat = typeof args.output_format === "string" ? args.output_format.trim() : "";
+        // The status line is asked for on EVERY child, not only formatted ones: it is the
+        // child's half of the verification contract (see subagentReport.ts), and a child
+        // with no output_format is if anything the one whose outcome is least obvious.
+        const framedTask = [
+            task,
+            outputFormat ? `Report your result in EXACTLY this format:\n${outputFormat}` : "",
+            STATUS_INSTRUCTION,
+        ]
+            .filter(Boolean)
+            .join("\n\n");
+        const budget = clampSteps(args.max_steps) ?? SUBAGENT_BUDGET;
+        const readOnly = args.read_only === true;
+        const child = ctx.forkChild(framedTask, { readOnly });
+        // Dynamic import: the static registry ← engine edge would otherwise cycle. By the
+        // time execute() runs, both modules are fully loaded, so this is safe.
+        const { respond } = await import("../dynamo/engine.js");
+        // A short id for THIS worker. Every event it emits carries it, so the UI keeps each
+        // worker's nested rail distinct even when several fan out in parallel.
+        const agentId = randomUUID().slice(0, 8);
+        const taskLabel = task.replace(/\s+/g, " ").trim().slice(0, 100);
+        ctx.emitEvent?.({ type: "subagent", phase: "start", id: agentId, task: taskLabel, readOnly });
+        let reply;
+        try {
+            // Bounded: a wide fan-out queues here rather than launching every worker at once.
+            reply = await gate.run(() => respond(child, {
+                signal: ctx.abortSignal,
+                maxSteps: budget,
+                // Surface the child's activity, not its chatter: its usage counts toward the
+                // meter, and each of its tool calls is forwarded UP tagged with this worker's
+                // id so the UI nests them in the worker's rail (its prose/reasoning stays
+                // muted — only the final distilled report crosses back, as the tool result).
+                onEvent: (e) => {
+                    if (e.type === "usage")
+                        ctx.reportUsage?.(e);
+                    else if (e.type === "tool")
+                        ctx.emitEvent?.({ ...e, agent: agentId });
+                },
+            }));
+        }
+        catch (error) {
+            ctx.emitEvent?.({ type: "subagent", phase: "end", id: agentId, summary: "failed", error: true });
+            return fail(`the sub-agent failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const steps = child.transcript.filter((e) => e.role === "assistant").length;
+        const scope = readOnly ? " · read-only" : "";
+        const stepLabel = `${steps} step${steps === 1 ? "" : "s"}${scope}`;
+        // The gate: a child's report is a claim, not a result, until the run behind it has
+        // been checked. Nothing is withheld — the parent decides whether a partial answer
+        // is still useful — but it is told what not to assume, above the report rather
+        // than after it.
+        const verdict = verifySubagentReport(reply, { steps, budget, outputFormat });
+        const flag = verdict.trustworthy ? "" : ` · ${verdict.status === "unstated" ? "unverified" : verdict.status}`;
+        ctx.emitEvent?.({ type: "subagent", phase: "end", id: agentId, summary: `${stepLabel}${flag}`, error: verdict.status === "failed" });
+        return {
+            output: renderVerdict(verdict),
+            summary: `subagent · ${stepLabel}${flag}`,
+        };
+    },
+};
+/** A clamped positive step budget from the model's `max_steps`, or undefined. */
+export function clampSteps(value) {
+    const n = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+    if (!Number.isInteger(n) || n < 1)
+        return undefined;
+    return Math.min(MAX_SUBAGENT_STEPS, n);
+}
+/** A positive integer from an env var, or `fallback`. */
+function envInt(name, fallback) {
+    const n = Number(process.env[name]);
+    return Number.isInteger(n) && n > 0 ? n : fallback;
+}
+//# sourceMappingURL=subagent.js.map

package/dist/tools/subagent.js.map

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