@bubblebrain-ai/bubble 0.0.58 → 0.0.60

package/dist/skills/format.js

@@ -1,47 +1,68 @@
-const MAX_SKILL_DESC_CHARS = 200;
-const SKILLS_BUDGET_CHARS = 6000;
+/** Default size of the always-present skill catalog (the listed lines, not the header). */
+export const SKILL_CATALOG_CHARS = 12_000;
+/** Each description is cut to this length; it only has to tell the model when to load. */
+export const SKILL_CATALOG_DESC_CHARS = 120;
+export const SKILL_CATALOG_HEADING = "## Skills";
+/** First line under the heading; together they mark the catalog unambiguously. */
+export const SKILL_CATALOG_INTRO = "Skills are task-specific instructions loaded on demand. When a task matches a skill below, call `skill` with its exact name before starting, then follow it. Load only what clearly applies.";
 const SOURCE_PRIORITY = {
     project: 0,
     configured: 1,
     user: 2,
 };
-export function formatSkillsPrompt(skills) {
-    if (skills.length === 0)
-        return "";
+/**
+ * The always-present skill catalog: name and a one-line description per skill,
+ * so the model knows what exists and loads a body with `skill` only when it
+ * applies. Ordering is deterministic (source, then name) so the system prompt
+ * stays byte-identical, and cacheable, while the skill set is unchanged.
+ */
+export function buildSkillCatalog(skills, options = {}) {
+    const budgetChars = Math.max(0, Math.floor(options.budgetChars ?? SKILL_CATALOG_CHARS));
+    const empty = { text: "", listed: 0, unlisted: skills.length, chars: 0, budgetChars };
+    if (skills.length === 0 || budgetChars === 0)
+        return empty;
     const sorted = [...skills].sort((a, b) => {
         const ap = SOURCE_PRIORITY[a.source ?? "user"] ?? 3;
         const bp = SOURCE_PRIORITY[b.source ?? "user"] ?? 3;
         if (ap !== bp)
             return ap - bp;
-        return a.name.localeCompare(b.name);
+        // Code-point order, not locale collation: the prompt must be byte-identical across runtimes.
+        return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
     });
-    const header = [
-        "Skills provide specialized instructions and workflows for specific tasks.",
-        "Use the skill system when a task clearly matches a skill description.",
-        "Available skills:",
-    ];
     const lines = [];
     let used = 0;
-    let dropped = 0;
     for (const skill of sorted) {
         const line = formatSkillLine(skill);
-        if (used + line.length + 1 > SKILLS_BUDGET_CHARS) {
-            dropped = sorted.length - lines.length;
+        if (used + line.length + 1 > budgetChars)
             break;
-        }
         lines.push(line);
         used += line.length + 1;
     }
-    if (dropped > 0) {
-        lines.push(`- ... and ${dropped} more skills (use /skills to list all)`);
+    if (lines.length === 0)
+        return empty;
+    const unlisted = sorted.length - lines.length;
+    if (unlisted > 0) {
+        lines.push(options.searchable
+            ? `- … and ${unlisted} more skills not listed here; use skill_search to find them.`
+            : `- … and ${unlisted} more skills not listed here.`);
     }
-    return [...header, ...lines].join("\n");
+    const text = [
+        SKILL_CATALOG_HEADING,
+        SKILL_CATALOG_INTRO,
+        ...lines,
+    ].join("\n");
+    return { text, listed: sorted.length - unlisted, unlisted, chars: used, budgetChars };
+}
+/** The catalog section text (see buildSkillCatalog). */
+export function formatSkillsPrompt(skills, options = {}) {
+    return buildSkillCatalog(skills, options).text;
 }
 function formatSkillLine(skill) {
-    const tagSuffix = skill.tags && skill.tags.length > 0 ? ` [tags: ${skill.tags.join(", ")}]` : "";
-    const rawDesc = skill.description ?? "";
-    const desc = rawDesc.length > MAX_SKILL_DESC_CHARS
-        ? rawDesc.slice(0, MAX_SKILL_DESC_CHARS - 1) + "…"
-        : rawDesc;
-    return `- ${skill.name}: ${desc}${tagSuffix}`;
+    const raw = (skill.description ?? "").replace(/\s+/g, " ").trim();
+    // Cut by code points so an emoji is never split into a lone surrogate, which some APIs reject.
+    const points = Array.from(raw);
+    const desc = points.length > SKILL_CATALOG_DESC_CHARS
+        ? points.slice(0, SKILL_CATALOG_DESC_CHARS - 1).join("").trimEnd() + "…"
+        : raw;
+    return desc ? `- ${skill.name}: ${desc}` : `- ${skill.name}`;
 }

package/dist/slash-commands/commands.d.ts

@@ -1,4 +1,7 @@
+import type { SlashCommand } from "./types.js";
 import type { UnifiedCommand } from "./unified.js";
+/** Rebuild the system prompt from the agent's live options (model, tools, memory, Skills catalog). */
+export declare function syncSystemPrompt(ctx: Pick<Parameters<SlashCommand["handler"]>[1], "agent" | "cwd">, model: string): void;
 /**
  * Public export — built-in commands tagged with `source: "builtin"` so the
  * registry and TUI can group them uniformly alongside MCP-derived commands.

package/dist/slash-commands/commands.js

@@ -3,6 +3,7 @@ import { formatContextUsage } from "../context/usage.js";
 import { formatDiagnostics } from "../lsp/index.js";
 import { normalizeNameForMCP } from "../mcp/name.js";
 import { parseRule } from "../permissions/rule.js";
+import { describeRepoCapabilities } from "../permissions/trust.js";
 import { encodeModel, decodeModel, displayModel, BUILTIN_PROVIDERS, isUserVisibleProvider } from "../provider-registry.js";
 import { getAvailableThinkingLevels, getDefaultThinkingLevel, normalizeThinkingLevel } from "../provider-transform.js";
 import { SessionManager } from "../session.js";
@@ -181,16 +182,18 @@ function persistSelectedModel(model, ctx) {
         ctx.sessionManager.appendMarker("model_switch", model);
     }
 }
-function syncSystemPrompt(ctx, model) {
+/** Rebuild the system prompt from the agent's live options (model, tools, memory, Skills catalog). */
+export function syncSystemPrompt(ctx, model) {
     const { providerId } = decodeModel(model);
     const toolPromptOptions = typeof ctx.agent.getSystemPromptToolOptions === "function"
         ? ctx.agent.getSystemPromptToolOptions()
         : {};
     ctx.agent.setSystemPrompt(buildSystemPrompt({
         agentName: "Bubble",
-        configuredProvider: providerId,
-        configuredModel: displayModel(model),
-        configuredModelId: model,
+        // Same placeholders as startup when no model is configured yet.
+        configuredProvider: providerId || "none",
+        configuredModel: model ? displayModel(model) : "none",
+        configuredModelId: model || "none",
         thinkingLevel: ctx.agent.thinking,
         workingDir: ctx.cwd,
         ...toolPromptOptions,
@@ -697,7 +700,9 @@ const builtinSlashCommandEntries = [
         name: "login",
         description: "Login to OpenAI OAuth or Grok Subscription. Usage: /login [openai|grok]",
         async handler(args, ctx) {
-            const providerId = args?.trim() || "openai";
+            // No default provider: a bare command must ask which account, never
+            // silently act on OpenAI now that more than one OAuth provider exists.
+            const providerId = args?.trim();
             if (!providerId) {
                 ctx.openPicker("login");
                 return;
@@ -825,7 +830,9 @@ const builtinSlashCommandEntries = [
         name: "logout",
         description: "Remove local login credentials. Usage: /logout [openai|grok]",
         async handler(args, ctx) {
-            const providerId = args?.trim() || "openai";
+            // No default provider: a bare command must ask which account, never
+            // silently act on OpenAI now that more than one OAuth provider exists.
+            const providerId = args?.trim();
             if (!providerId) {
                 ctx.openPicker("logout");
                 return;
@@ -833,10 +840,13 @@ const builtinSlashCommandEntries = [
             if (isGrokSubscriptionProviderId(providerId)) {
                 return logoutGrokSubscription(ctx);
             }
-            if (!ctx.registry.getAuthStorage().has(providerId)) {
+            // Alias-aware: `openai` may be backed by the legacy `openai-codex` key.
+            const loginKeys = ctx.registry.getOAuthLoginKeys(providerId);
+            if (loginKeys.length === 0) {
                 return `No OAuth credentials found for ${providerId}.`;
             }
-            ctx.registry.getAuthStorage().remove(providerId);
+            for (const key of loginKeys)
+                ctx.registry.getAuthStorage().remove(key);
             const fallback = ctx.registry.getDefault();
             if (fallback?.apiKey) {
                 const fallbackModel = ctx.registry.getDefaultModel(fallback.id);
@@ -878,7 +888,7 @@ const builtinSlashCommandEntries = [
     },
     {
         name: "permissions",
-        description: "Inspect or edit allow/deny rules. Subcommands: add <scope> <list> <rule>, remove <scope> <list> <rule>, clear (session allowlist), reload.",
+        description: "Inspect or edit allow/deny rules. Subcommands: add <scope> <list> <rule>, remove <scope> <list> <rule>, clear (session approvals), reload.",
         async handler(args, ctx) {
             const tokens = args.trim().split(/\s+/).filter(Boolean);
             const sub = tokens[0] ?? "";
@@ -892,7 +902,7 @@ const builtinSlashCommandEntries = [
                 if (size === 0)
                     return "Bash allowlist is already empty.";
                 ctx.bashAllowlist.clear();
-                return `Cleared ${size} bash prefix${size === 1 ? "" : "es"} from the session allowlist.`;
+                return `Cleared ${size} session-approved bash command${size === 1 ? "" : "s"}.`;
             }
             if (sub === "reload") {
                 if (!ctx.settingsManager)
@@ -920,6 +930,11 @@ const builtinSlashCommandEntries = [
                     for (const r of merged.ruleSet.allow)
                         lines.push(`  ${r.source}`);
                 }
+                const untrusted = merged.untrusted;
+                if (untrusted.allow.length + untrusted.mcpServers.length + untrusted.lspServers.length > 0) {
+                    lines.push("", "This folder is not trusted, so these stay off (Bubble asks at startup):");
+                    lines.push(...describeRepoCapabilities(untrusted).map((line) => `  ${line}`));
+                }
                 lines.push("", `Deny rules (${merged.ruleSet.deny.length}):`);
                 if (merged.ruleSet.deny.length === 0) {
                     lines.push("  (none)");
@@ -939,13 +954,13 @@ const builtinSlashCommandEntries = [
                 const entries = ctx.bashAllowlist.list();
                 if (lines.length > 0)
                     lines.push("");
-                lines.push(`Session bash allowlist (${entries.length}):`);
+                lines.push(`Session-approved bash commands (${entries.length}):`);
                 if (entries.length === 0) {
-                    lines.push('  (none) — approving "Yes, and don\'t ask again for <prefix>" adds entries here');
+                    lines.push('  (none) — "don\'t ask again for this exact command this session" adds entries here');
                 }
                 else {
-                    for (const prefix of entries)
-                        lines.push(`  ${prefix}`);
+                    for (const command of entries)
+                        lines.push(`  ${command}`);
                 }
             }
             if (lines.length === 0) {

package/dist/system-prompt.d.ts

@@ -26,8 +26,10 @@ export interface SystemPromptOptions {
     mode?: PermissionMode;
     /** Current date override */
     currentDate?: string;
-    /** Prompt-visible skills */
+    /** Prompt-visible skills, listed as the Skills catalog when `skill` is a tool */
     skills?: SkillSummary[];
+    /** Catalog budget in characters; 0 turns the catalog off */
+    skillCatalogChars?: number;
     /** Prompt-visible memory guidance and summaries */
     memoryPrompt?: string;
     /** Durable child-agent profile prompt used for subagents. */

package/dist/tasks/manager.d.ts

@@ -20,6 +20,12 @@
  * process, so the event loop keeps owning it (design §2.2a). Reaping is
  * three-layered (design §2.2b): graceful shutdownTasks() with escalation, a
  * SIGKILL-only path for signal handlers, and a process.once("exit") backstop.
+ *
+ * Finalization waits for stdio to drain: Node may emit "exit" before the last
+ * pipe chunks are delivered, so a record is settled on "close" — with a short
+ * grace timer from "exit" as the fallback, because a detached grandchild that
+ * inherited the pipes (`some-server &`) can keep "close" from ever firing.
+ * Same pattern as POST_EXIT_STDIO_GRACE_MS in src/tools/bash.ts.
  */
 import { type ChildProcess } from "node:child_process";
 export type ManagedServerPurpose = "preview" | "verification";
@@ -99,6 +105,7 @@ export declare class ProcessManager {
     adoptTask(input: AdoptBackgroundTaskInput): BackgroundTaskInfo;
     private reserveTaskSlot;
     private registerTaskChild;
+    private finalizeExitedTask;
     private finalizeTask;
     getTask(id: string): BackgroundTaskInfo | undefined;
     listTasks(ownerSessionId?: string): BackgroundTaskInfo[];

package/dist/tasks/manager.js

@@ -20,6 +20,12 @@
  * process, so the event loop keeps owning it (design §2.2a). Reaping is
  * three-layered (design §2.2b): graceful shutdownTasks() with escalation, a
  * SIGKILL-only path for signal handlers, and a process.once("exit") backstop.
+ *
+ * Finalization waits for stdio to drain: Node may emit "exit" before the last
+ * pipe chunks are delivered, so a record is settled on "close" — with a short
+ * grace timer from "exit" as the fallback, because a detached grandchild that
+ * inherited the pipes (`some-server &`) can keep "close" from ever firing.
+ * Same pattern as POST_EXIT_STDIO_GRACE_MS in src/tools/bash.ts.
  */
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
@@ -28,6 +34,7 @@ import { platform } from "node:os";
 import { appendTailCapped, killProcessTree, stripAnsi, tail } from "./process-utils.js";
 const MAX_LOG_BYTES = 96 * 1024;
 const STOP_FORCE_AFTER_MS = 1000;
+const POST_EXIT_STDIO_GRACE_MS = 150;
 const MAX_RUNNING_TASKS_PER_SESSION = 8;
 const MAX_FINISHED_TASKS = 20;
 function countLineBreaks(value) {
@@ -143,14 +150,18 @@ export class ProcessManager {
             append(Buffer.from(`\n[task failed to start: ${error.message}]\n`));
             this.finalizeTask(record, "failed", null);
         });
-        child.once("exit", (code) => {
-            if (record.status === "running") {
-                this.finalizeTask(record, code === 0 ? "completed" : "failed", code);
-            }
+        record.settled = onChildSettled(child, {
+            onExit: (code) => {
+                record.exited = { code };
+            },
+            onSettled: (code) => this.finalizeExitedTask(record, code),
         });
         this.bumpTaskState(record);
         return this.publicTask(record);
     }
+    finalizeExitedTask(record, code) {
+        this.finalizeTask(record, code === 0 ? "completed" : "failed", code);
+    }
     finalizeTask(record, status, exitCode) {
         if (record.status !== "running")
             return;
@@ -242,13 +253,20 @@ export class ProcessManager {
         if (record.status !== "running")
             return this.publicTask(record);
         const pid = record.child?.pid ?? record.pid;
-        // Mark first so the exit listener does not double-finalize as failed.
-        this.finalizeTask(record, "killed", null);
+        // Mark first so the exit listener does not double-finalize as failed. A
+        // task that already exited on its own keeps its real outcome instead, and
+        // is left to the close/grace path: finish listeners snapshot the output
+        // tail, so they must not fire before the pending pipe data is appended.
+        if (!record.exited)
+            this.finalizeTask(record, "killed", null);
         if (pid) {
+            // Also reaps pipe-holding grandchildren, which lets "close" fire promptly.
             killProcessTree(pid, "SIGTERM");
             const forceTimer = setTimeout(() => killProcessTree(pid, "SIGKILL"), STOP_FORCE_AFTER_MS);
             forceTimer.unref?.();
         }
+        if (record.exited)
+            await record.settled;
         return this.publicTask(record);
     }
     /** Graceful reaping for shutdownRuntime (design §2.2b layer 1). */
@@ -266,7 +284,12 @@ export class ProcessManager {
             const pid = task.child?.pid ?? task.pid;
             if (pid)
                 killProcessTree(pid, "SIGKILL");
-            if (task.status === "running")
+            if (task.status !== "running")
+                continue;
+            // Exited on its own inside the drain window: bounded wait for its output.
+            if (task.exited)
+                await task.settled;
+            else
                 this.finalizeTask(task, "killed", null);
         }
     }
@@ -318,7 +341,7 @@ export class ProcessManager {
         return [...this.registry.values()].filter((record) => record.kind === "task");
     }
     publicTask(record) {
-        const { child: _child, output: _output, outputLineBreaks: _outputLineBreaks, outputHasData: _outputHasData, outputEndsWithNewline: _outputEndsWithNewline, ...info } = record;
+        const { child: _child, exited: _exited, settled: _settled, output: _output, outputLineBreaks: _outputLineBreaks, outputHasData: _outputHasData, outputEndsWithNewline: _outputEndsWithNewline, ...info } = record;
         return { ...info };
     }
     // -- servers (moved verbatim from server-manager.ts, kind-filtered) --------
@@ -379,18 +402,31 @@ export class ProcessManager {
             record.status = "failed";
             appendServerLog(record, `\n[server failed: ${error.message}]\n`);
         });
-        child.once("exit", (code) => {
-            record.exitCode = code;
-            if (record.status !== "stopped") {
-                record.status = code === 0 ? "exited" : "failed";
-            }
-            record.child = undefined;
+        // Settle after stdio drains so a fast crash surfaces its logs in the
+        // "did not become ready" error instead of racing the status flip.
+        record.settled = onChildSettled(child, {
+            unrefTimer: true,
+            onExit: (code) => {
+                record.exited = { code };
+            },
+            onSettled: (code) => {
+                record.exitCode = code;
+                if (record.status !== "stopped") {
+                    record.status = code === 0 ? "exited" : "failed";
+                }
+                record.child = undefined;
+            },
         });
         const timeoutSec = input.timeoutSec ?? 30;
         const ready = readinessUrl
             ? await waitForReadiness(record, readinessUrl, timeoutSec)
             : await waitForProcessToStayAlive(record, Math.min(timeoutSec, 2));
-        if (!ready) {
+        // `exited` is checked on its own: the status flip lags "exit" by the drain
+        // window, so a server dying right at the deadline still reads as active.
+        if (!ready || record.exited) {
+            // Bounded: lets the crash output land before it is quoted below.
+            if (record.exited)
+                await record.settled;
             const logs = record.logs.trim();
             await this.stopManagedServer(id);
             throw new Error(`Server ${id} did not become ready within ${timeoutSec}s.${logs ? `\n\nLogs:\n${tail(logs, 4000)}` : ""}`);
@@ -479,6 +515,46 @@ process.once("exit", () => {
 // ---------------------------------------------------------------------------
 // Server internals (moved verbatim)
 // ---------------------------------------------------------------------------
+/**
+ * Calls `onSettled` exactly once, after the child has exited AND its stdio has
+ * drained ("close"), or POST_EXIT_STDIO_GRACE_MS after "exit" when something
+ * else still holds the pipes open. `onExit` fires synchronously at "exit".
+ * The returned promise resolves right after `onSettled` has run.
+ */
+function onChildSettled(child, handlers) {
+    let settled = false;
+    let resolveSettled;
+    const done = new Promise((resolve) => {
+        resolveSettled = resolve;
+    });
+    let graceTimer;
+    const settle = (code) => {
+        if (settled)
+            return;
+        settled = true;
+        if (graceTimer)
+            clearTimeout(graceTimer);
+        try {
+            handlers.onSettled(code);
+        }
+        finally {
+            resolveSettled();
+        }
+    };
+    child.once("exit", (code) => {
+        handlers.onExit?.(code);
+        if (settled)
+            return;
+        // Timers run before the poll phase: if the loop stalled past the grace
+        // period, output already sitting in the pipe has not been read yet. Yield
+        // through one poll phase (setImmediate) so it is appended before settling.
+        graceTimer = setTimeout(() => setImmediate(() => settle(code)), POST_EXIT_STDIO_GRACE_MS);
+        if (handlers.unrefTimer)
+            graceTimer.unref?.();
+    });
+    child.once("close", (code) => settle(code));
+    return done;
+}
 function publicServerInfo(server) {
     return {
         id: server.id,
@@ -506,7 +582,7 @@ function unrefStream(stream) {
 async function waitForReadiness(server, url, timeoutSec) {
     const deadline = Date.now() + timeoutSec * 1000;
     while (Date.now() < deadline) {
-        if (!isActiveStatus(server.status))
+        if (!isServerAlive(server))
             return false;
         if (await canFetch(url))
             return true;
@@ -517,11 +593,11 @@ async function waitForReadiness(server, url, timeoutSec) {
 async function waitForProcessToStayAlive(server, timeoutSec) {
     const deadline = Date.now() + timeoutSec * 1000;
     while (Date.now() < deadline) {
-        if (!isActiveStatus(server.status))
+        if (!isServerAlive(server))
             return false;
         await new Promise((resolve) => setTimeout(resolve, 100));
     }
-    return isActiveStatus(server.status);
+    return isServerAlive(server);
 }
 async function canFetch(url) {
     const controller = new AbortController();
@@ -537,6 +613,9 @@ async function canFetch(url) {
         clearTimeout(timeout);
     }
 }
+function isServerAlive(server) {
+    return !server.exited && isActiveStatus(server.status);
+}
 function isActiveStatus(status) {
     return status === "starting" || status === "ready" || status === "running";
 }

package/dist/tools/agent-lifecycle.js

@@ -6,6 +6,7 @@ import { THINKING_LEVELS } from "../types.js";
 import { buildWorkflowResultBlock, workflowMemberWarning } from "../agent/workflow/control.js";
 import { precompileWorkflowScript } from "../agent/workflow/runtime.js";
 import { formatSubagentRoute } from "../agent/subagent-route-format.js";
+import { SUBAGENT_WAIT_GUIDANCE } from "../agent/subagent-wait-guidance.js";
 /**
  * Session-scoped trust decisions for project profiles, keyed by file path +
  * content hash so an edited file re-prompts (design §10.2). Shared across the
@@ -121,6 +122,7 @@ export function createSpawnAgentTool(options = {}, sharedTrust) {
         parameters: {
             type: "object",
             properties: {
+                description: { type: "string", description: "Short task title for the activity card (under 60 characters). Put the full instructions in message." },
                 agent_type: { type: "string", description: "Subagent profile or role name. Defaults to default. Built-in types include default, explorer, and worker; see the tool description for custom profiles." },
                 agent: { type: "string", description: "Alias for agent_type." },
                 category: { type: "string", description: "Optional semantic category for model/thinking routing, such as quick, deep, explore, review, frontend, or writing." },
@@ -196,7 +198,7 @@ export function createWaitAgentTool() {
         effect: "read",
         description: [
             "Wait for one or more spawned subagents to reach a final status and return snapshots.",
-            "If the wait times out while children are still queued or running, call wait_agent again with a longer timeout instead of redoing the same delegated work locally.",
+            ...SUBAGENT_WAIT_GUIDANCE,
         ].join(" "),
         parameters: {
             type: "object",
@@ -204,10 +206,10 @@ export function createWaitAgentTool() {
                 agent_id: { type: "string", description: "A single agent id to wait for." },
                 agent_ids: {
                     type: "array",
-                    description: "Agent ids to wait for. If omitted, waits for any active subagent.",
+                    description: "Agent ids to wait for; returns when any target finishes. Prefer explicit IDs for remaining work. If omitted, considers all non-closed subagents, including already-finished ones.",
                     items: { type: "string" },
                 },
-                timeout_ms: { type: "number", description: "Maximum wait time in milliseconds. Defaults to 30000." },
+                timeout_ms: { type: "number", description: "Maximum wait time in milliseconds, not a mandatory delay; returns early when a target finishes. Choose according to your next decision. Defaults to 30000." },
             },
             additionalProperties: false,
         },
@@ -249,7 +251,7 @@ export function createSendInputTool() {
         name: "send_input",
         readOnly: true,
         effect: "read",
-        description: "Send a follow-up message to an existing subagent thread. If it is still running, pass interrupt:true to cancel and redirect it. Restarting a finished child goes through the scheduler like any spawn.",
+        description: "Send a follow-up message to an existing subagent thread. While running or queued, text input is queued and applied at the next safe boundary without interruption. Use interrupt:true only to cancel and redirect it. Restarting a finished child goes through the scheduler like any spawn.",
         parameters: {
             type: "object",
             properties: {
@@ -277,7 +279,7 @@ export function createSendInputTool() {
                     abortSignal: ctx.abortSignal,
                 });
                 return formatLifecycleResult("send_input", [snapshot], [
-                    `Sent input to ${snapshot.nickname} (${snapshot.agentName})`,
+                    `${snapshot.pendingInputCount ? "Queued input for" : "Sent input to"} ${snapshot.nickname} (${snapshot.agentName})`,
                     `agent_id: ${snapshot.agentId}`,
                     `status: ${snapshot.status}`,
                     ...(snapshot.status === "queued" ? [queuedStatusLine(snapshot)] : []),
@@ -562,7 +564,7 @@ function spawnNextSteps(snapshot) {
         ];
     }
     return [
-        `next: call wait_agent for ${snapshot.agentId} before reporting this subagent's current status or final result`,
+        `next: continue useful non-overlapping work; call wait_agent for ${snapshot.agentId} when its result is needed for your next step or final synthesis`,
     ];
 }
 function queuedStatusLine(snapshot) {
@@ -581,7 +583,7 @@ function waitTimeoutGuidance(snapshots) {
     if (running.length > 0) {
         lines.push(`${running.length} child${running.length === 1 ? " is" : "ren are"} still running.`);
     }
-    lines.push("Call wait_agent again with a longer timeout instead of duplicating the same work locally.");
+    lines.push("Reassess whether a child's result blocks your next meaningful step: continue useful independent work if available, otherwise call wait_agent again with a suitable timeout. Do not duplicate the delegated work.");
     return lines;
 }
 function formatLifecycleResult(toolName, snapshots, header) {
@@ -717,6 +719,8 @@ function snapshotToMetadata(snapshot) {
         error: snapshot.error,
         createdAt: snapshot.createdAt,
         updatedAt: snapshot.updatedAt,
+        pendingInputCount: snapshot.pendingInputCount,
+        inputDelivery: snapshot.inputDelivery,
     };
 }
 function unsupportedProfile(profile) {

package/dist/tools/child-tools.d.ts

@@ -33,7 +33,7 @@ export declare class WorktreeApprovalController implements ApprovalController {
  * exposes a cloneForChild hook (the standard `read`, which carries a
  * FileStateTracker) is rebuilt as a fresh per-child instance, so concurrent
  * members of a fan-out never share mutable tool state. Stateless tools
- * (glob/grep, web/memory/skill) and custom/mock tools without the hook are
+ * (ls/grep, web/memory/skill) and custom/mock tools without the hook are
  * passed through unchanged. Write children get full isolation via
  * createWorktreeChildTools instead.
  */

package/dist/tools/child-tools.js

@@ -11,7 +11,7 @@
 import { isAbsolute, resolve, sep } from "node:path";
 import { createBashTool } from "./bash.js";
 import { createEditTool } from "./edit.js";
-import { createGlobTool } from "./glob.js";
+import { createLsTool } from "./ls.js";
 import { createGrepTool } from "./grep.js";
 import { createReadTool } from "./read.js";
 import { createWriteTool } from "./write.js";
@@ -86,7 +86,7 @@ export class WorktreeApprovalController {
         return { decision: "ask" };
     }
 }
-const WORKTREE_TOOL_NAMES = new Set(["read", "glob", "grep", "edit", "write", "bash"]);
+const WORKTREE_TOOL_NAMES = new Set(["read", "ls", "grep", "edit", "write", "bash"]);
 /**
  * Builds the write child's toolset bound to its worktree: fresh instances
  * with their own FileStateTracker and the worktree approval policy. A
@@ -97,7 +97,7 @@ const WORKTREE_TOOL_NAMES = new Set(["read", "glob", "grep", "edit", "write", "b
  * exposes a cloneForChild hook (the standard `read`, which carries a
  * FileStateTracker) is rebuilt as a fresh per-child instance, so concurrent
  * members of a fan-out never share mutable tool state. Stateless tools
- * (glob/grep, web/memory/skill) and custom/mock tools without the hook are
+ * (ls/grep, web/memory/skill) and custom/mock tools without the hook are
  * passed through unchanged. Write children get full isolation via
  * createWorktreeChildTools instead.
  */
@@ -109,7 +109,7 @@ export function createWorktreeChildTools(worktreeCwd, include) {
     const fileState = new FileStateTracker(worktreeCwd);
     const tools = [
         createReadTool(worktreeCwd, approval, undefined, fileState),
-        createGlobTool(worktreeCwd),
+        createLsTool(worktreeCwd),
         createGrepTool(worktreeCwd),
         createEditTool(worktreeCwd, approval, undefined, fileState),
         createWriteTool(worktreeCwd, {}, approval, undefined, fileState),

package/dist/tools/edit-apply.d.ts

@@ -2,13 +2,11 @@ export interface EditOperation {
     oldText: string;
     newText: string;
 }
-export type EditMatchMode = "exact" | "trimmed" | "unescaped" | "normalized-line" | "smart-line" | "markdown-table" | "single-line-whitespace";
 export interface EditApplyOptions {
     path?: string;
 }
 export interface EditMatchInfo {
     editIndex: number;
-    mode: EditMatchMode;
     start: number;
     end: number;
 }
@@ -25,4 +23,3 @@ export declare class EditApplyError extends Error {
     constructor(message: string, status?: "no_match" | "blocked");
 }
 export declare function applyEditsToContent(rawContent: string, edits: EditOperation[], options?: EditApplyOptions): AppliedEditResult;
-export declare function formatEditMatchNotes(matches: EditMatchInfo[]): string;