@multiclawcli/core 0.6.3 → 0.8.0

package/dist/index.js

@@ -241,6 +241,36 @@ function isPermanent(err) {
   return err instanceof PermanentError;
 }
 
+// src/utils/toolSummary.ts
+var MAX_SUMMARY_COLUMNS = 120;
+function stringifySafe(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0 || value === null) return "";
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return String(value);
+  }
+}
+function firstLineTruncated(value) {
+  const text = stringifySafe(value);
+  const newline = text.indexOf("\n");
+  const firstLine = newline === -1 ? text : text.slice(0, newline);
+  if (firstLine.length <= MAX_SUMMARY_COLUMNS) return firstLine;
+  return `${firstLine.slice(0, MAX_SUMMARY_COLUMNS - 1)}\u2026`;
+}
+function hasToolArgs(input) {
+  if (input === void 0 || input === null) return false;
+  if (typeof input !== "object" || Array.isArray(input)) return true;
+  return Object.keys(input).length > 0;
+}
+function summarizeToolInput(input) {
+  return hasToolArgs(input) ? firstLineTruncated(input) : "";
+}
+function summarizeToolOutput(output) {
+  return firstLineTruncated(output);
+}
+
 // src/runtime/RuntimeBase.ts
 var RuntimeBase = class {
 };
@@ -305,16 +335,26 @@ var KIND_TO_TOOLS = {
   search: ["Grep", "Glob"],
   fetch: ["WebFetch"]
 };
+function matchesTool(pattern, name) {
+  if (!pattern.includes("*")) return pattern === name;
+  const source = pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*");
+  return new RegExp(`^${source}$`).test(name);
+}
 function toolPermitted(params, tools) {
-  const allowed = new Set(tools.map((tool) => tool.toLowerCase()));
+  const allowed = tools.map((tool) => tool.toLowerCase());
   const name = params.toolCall.name ?? void 0;
-  return name !== void 0 ? allowed.has(name.toLowerCase()) : (KIND_TO_TOOLS[params.toolCall.kind ?? ""] ?? []).some(
-    (tool) => allowed.has(tool.toLowerCase())
-  );
+  if (name !== void 0) {
+    const candidate = name.toLowerCase();
+    return allowed.some((pattern) => matchesTool(pattern, candidate));
+  }
+  return (KIND_TO_TOOLS[params.toolCall.kind ?? ""] ?? []).some((tool) => {
+    const candidate = tool.toLowerCase();
+    return allowed.some((pattern) => matchesTool(pattern, candidate));
+  });
 }
 function decidePermission(params, tools, sessionId) {
   if (sessionId !== void 0 && params.sessionId !== sessionId) {
-    return { response: { outcome: { outcome: "cancelled" } } };
+    return { response: { outcome: { outcome: "cancelled" } }, approved: false };
   }
   const name = params.toolCall.name ?? void 0;
   const kind = params.toolCall.kind ?? void 0;
@@ -323,9 +363,10 @@ function decidePermission(params, tools, sessionId) {
     (o) => approved ? o.kind === "allow_once" : o.kind === "reject_once"
   );
   const response = option ? { outcome: { outcome: "selected", optionId: option.optionId } } : { outcome: { outcome: "cancelled" } };
-  if (approved) return { response };
+  if (approved) return { response, approved };
   return {
     response,
+    approved,
     rejected: {
       toolCallId: params.toolCall.toolCallId,
       name,
@@ -506,6 +547,8 @@ var AcpRuntime = class extends RuntimeBase {
       let closeResolve;
       let closeReject;
       let connection;
+      const argsSurfaced = /* @__PURE__ */ new Set();
+      const toolNames = /* @__PURE__ */ new Map();
       const killTree = (signal) => {
         if (child.pid !== void 0) {
           try {
@@ -640,15 +683,23 @@ var AcpRuntime = class extends RuntimeBase {
             }
             break;
           }
-          case "tool_call":
-            emit({
-              type: "tool_call",
-              id: update.toolCallId,
-              name: update.name ?? update.title,
-              input: update.rawInput
-            });
+          case "tool_call": {
+            const name = update.name ?? update.title;
+            toolNames.set(update.toolCallId, name);
+            if (hasToolArgs(update.rawInput)) argsSurfaced.add(update.toolCallId);
+            emit({ type: "tool_call", id: update.toolCallId, name, input: update.rawInput });
             break;
-          case "tool_call_update":
+          }
+          case "tool_call_update": {
+            if (!argsSurfaced.has(update.toolCallId) && hasToolArgs(update.rawInput)) {
+              argsSurfaced.add(update.toolCallId);
+              emit({
+                type: "tool_call",
+                id: update.toolCallId,
+                name: update.name ?? toolNames.get(update.toolCallId) ?? update.title ?? "",
+                input: update.rawInput
+              });
+            }
             emit({
               type: "tool_result",
               id: update.toolCallId,
@@ -656,6 +707,7 @@ var AcpRuntime = class extends RuntimeBase {
               isError: update.status === "failed"
             });
             break;
+          }
           case "plan":
             emit({ type: "plan", entries: update.entries.map((entry3) => entry3.content) });
             break;
@@ -690,22 +742,26 @@ var AcpRuntime = class extends RuntimeBase {
         if (state !== "running" || !turn || params.sessionId !== sessionId || context.signal.aborted)
           return cancelled;
         const mode = turn.options.permissionMode ?? "auto";
-        const { response, rejected } = decidePermission(params, options.tools, sessionId);
-        if (rejected) {
-          warn("Tool permission denied by the configured tools policy.");
-          emit({
-            type: "raw",
-            vendor: "acp",
-            payload: { type: "permission_rejected", ...rejected }
-          });
-          return response;
+        const { response, approved, rejected } = decidePermission(params, options.tools, sessionId);
+        if (approved) {
+          if (mode !== "deny") return response;
+          warn("Tool permission denied by the configured approval mode.");
+          return cancelled;
         }
-        if (mode === "auto") return response;
-        if (mode !== "ask" || !turn.options.onPermission) {
+        const askable = mode === "ask" && turn.options.onPermission !== void 0;
+        if (!askable) {
+          const label = rejected?.name ?? rejected?.kind ?? rejected?.toolCallId ?? "an unnamed tool";
           warn(
-            mode === "ask" ? "Tool permission cancelled: no approval handler is available." : "Tool permission denied by the configured approval mode."
+            mode === "ask" ? `Tool permission cancelled: no approval handler is available (${label}).` : `Tool permission denied by the configured tools policy: ${label}.`
           );
-          return cancelled;
+          if (rejected) {
+            emit({
+              type: "raw",
+              vendor: "acp",
+              payload: { type: "permission_rejected", ...rejected }
+            });
+          }
+          return mode === "deny" ? cancelled : response;
         }
         const signal = AbortSignal.any([turn.decisions.signal, context.signal]);
         const offered = new Set(params.options.map((option) => option.optionId));
@@ -736,7 +792,18 @@ var AcpRuntime = class extends RuntimeBase {
             aborted
           ]);
           if (signal.aborted || active !== turn || state !== "running") return cancelled;
-          return optionId !== void 0 && offered.has(optionId) ? { outcome: { outcome: "selected", optionId } } : cancelled;
+          const chosen = params.options.find((option) => option.optionId === optionId);
+          if (optionId === void 0 || chosen === void 0 || !offered.has(optionId)) {
+            return cancelled;
+          }
+          if (chosen.kind.startsWith("reject") && rejected) {
+            emit({
+              type: "raw",
+              vendor: "acp",
+              payload: { type: "permission_rejected", ...rejected, source: "user" }
+            });
+          }
+          return { outcome: { outcome: "selected", optionId } };
         } catch {
           return cancelled;
         } finally {
@@ -1987,6 +2054,19 @@ var AgentSessionManager = class {
       }
     }
   }
+  /**
+   * Whether this manager still holds a session for `agentId`.
+   *
+   * A caller about to continue a past conversation uses this to avoid naming a
+   * session it already has open: passing the id would change the entry's
+   * fingerprint, and the manager would close a perfectly good session and
+   * `session/load` it straight back.
+   */
+  has(agentId) {
+    if (this.closed) return false;
+    const entry3 = this.entries.get(agentId);
+    return entry3 !== void 0 && !entry3.closing && entry3.session?.state !== "closed";
+  }
   /**
    * Deliver a message into every session that is running a turn right now.
    *
@@ -2366,31 +2446,6 @@ function withTimeout(factory, ms, label, signal, options) {
   });
 }
 
-// src/utils/toolSummary.ts
-var MAX_SUMMARY_COLUMNS = 120;
-function stringifySafe(value) {
-  if (typeof value === "string") return value;
-  if (value === void 0 || value === null) return "";
-  try {
-    return JSON.stringify(value) ?? "";
-  } catch {
-    return String(value);
-  }
-}
-function firstLineTruncated(value) {
-  const text = stringifySafe(value);
-  const newline = text.indexOf("\n");
-  const firstLine = newline === -1 ? text : text.slice(0, newline);
-  if (firstLine.length <= MAX_SUMMARY_COLUMNS) return firstLine;
-  return `${firstLine.slice(0, MAX_SUMMARY_COLUMNS - 1)}\u2026`;
-}
-function summarizeToolInput(input) {
-  return firstLineTruncated(input);
-}
-function summarizeToolOutput(output) {
-  return firstLineTruncated(output);
-}
-
 // src/orchestrator/AgentRunner.ts
 var AgentRunner = class {
   constructor(eventBus, contextManager, globalWorkDir, config, sessionManager) {
@@ -2451,6 +2506,16 @@ ${prompt}`;
             if (instruction) prompt += `
 
 ${instruction}`;
+            const toolRows = /* @__PURE__ */ new Set();
+            const toolNames = /* @__PURE__ */ new Map();
+            const printToolRow = (id, name, input) => {
+              if (toolRows.has(id)) return;
+              toolRows.add(id);
+              const summary = summarizeToolInput(input);
+              this.emitOutput(agent.id, `
+\u203A ${name}${summary ? ` ${summary}` : ""}
+`, "tool");
+            };
             const task = {
               agentId: agent.id,
               systemPrompt: agent.systemPrompt,
@@ -2492,17 +2557,13 @@ ${instruction}`;
                   return;
                 }
                 if (e.type === "tool_call") {
-                  const summary = summarizeToolInput(e.input);
-                  this.emitOutput(
-                    agent.id,
-                    `
-\u203A ${e.name}${summary ? ` ${summary}` : ""}
-`,
-                    "tool"
-                  );
+                  toolNames.set(e.id, e.name);
+                  if (summarizeToolInput(e.input)) printToolRow(e.id, e.name, e.input);
                   return;
                 }
                 if (e.type === "tool_result") {
+                  const name = toolNames.get(e.id);
+                  if (name !== void 0) printToolRow(e.id, name, void 0);
                   const summary = summarizeToolOutput(e.output);
                   this.emitOutput(
                     agent.id,
@@ -2687,7 +2748,7 @@ var Orchestrator = class {
     }
     if (options.signal?.aborted)
       return { name: this.config.name, totalAgents: 0, stages: [], ...this.requirementField() };
-    this.clearStaleTaskPlan();
+    this.prepareTaskPlan();
     const resolution = await this.resolveTurn(options.signal);
     if (resolution.kind === "cancelled" || options.signal?.aborted) {
       return { name: this.config.name, totalAgents: 0, stages: [], ...this.requirementField() };
@@ -2738,7 +2799,7 @@ var Orchestrator = class {
       return this.finishEmpty(startTime, void 0, false);
     }
     if (options.signal?.aborted) return this.finishCancelled(startTime);
-    this.clearStaleTaskPlan();
+    this.prepareTaskPlan();
     const resolution = await this.resolveTurn(options.signal);
     if (resolution.kind === "cancelled" || options.signal?.aborted) {
       return this.finishCancelled(startTime);
@@ -2747,6 +2808,7 @@ var Orchestrator = class {
       return this.finishWithMessage(resolution.mode, resolution.message, startTime);
     }
     const agents2 = resolution.agents;
+    if (this.config.resume) this.applyResumeTaskPlan(agents2);
     if (agents2.length === 0)
       return this.finishEmpty(
         startTime,
@@ -3045,14 +3107,20 @@ Address these findings within your assigned scope, preserve the complete task re
     }
   }
   /**
-   * Drop last run's task plan before the architect gets a chance to write one.
+   * Decide what to do with last run's task plan before this turn starts.
    *
    * The console runs every turn against the same workspace, so the plan file
    * survives between turns. If a turn's architect fails to write a new one,
    * `applyTaskPlan` would silently re-apply the previous turn's titles, scopes
    * and dependencies to a completely different requirement.
+   *
+   * A resumed turn is the exception: the plan in the workspace describes the
+   * task being continued, and it is the only record of what each resumed agent
+   * was asked to do. Deleting it would leave every retried agent with the
+   * generic "no plan was provided" fallback.
    */
-  clearStaleTaskPlan() {
+  prepareTaskPlan() {
+    if (this.config.resume) return;
     fs4.rmSync(path5.join(this.workDir, "task-plan.json"), { force: true });
   }
   /**
@@ -3065,7 +3133,7 @@ Address these findings within your assigned scope, preserve the complete task re
    */
   async resolveTurn(signal) {
     if (signal?.aborted) return { kind: "cancelled" };
-    if (this.config.resume) {
+    if (this.config.resume?.agents) {
       return {
         kind: "run",
         agents: this.selectAgents(this.config.resume.agents, "The resume list")
@@ -3105,7 +3173,7 @@ Address these findings within your assigned scope, preserve the complete task re
    * `applyTaskPlan` writes `taskTitle` / `dependsOn` / `agentScope` onto whatever
    * objects it is handed. The console reuses a single config across turns, so
    * returning the config's own objects would leak turn 1's dependency graph into
-   * turn 2 — the exact cross-turn contamination `clearStaleTaskPlan` exists to
+   * turn 2 — the exact cross-turn contamination `prepareTaskPlan` exists to
    * prevent, but for the in-memory fields rather than the file.
    */
   configuredAgents() {
@@ -3182,9 +3250,21 @@ Address these findings within your assigned scope, preserve the complete task re
   isPlanner(agent) {
     return agent.role === "planner" || agent.id === "architect";
   }
-  async applyTaskPlan(agents2, executedIds) {
+  /**
+   * Read and validate `task-plan.json`, one entry per agent id.
+   *
+   * `undefined` means "there is no usable plan" — no file, unparseable JSON, or
+   * no `tasks` array. Each of those is reported rather than treated as an empty
+   * plan: a broken plan must not be indistinguishable from a missing one.
+   *
+   * Validation stops at "is this entry well-formed and unique". Whether an id
+   * belongs to the run is the caller's question, because a normal turn and a
+   * resume answer it differently — a resume must not warn about every teammate
+   * it deliberately left out.
+   */
+  readTaskPlan() {
     const taskPlanPath = path5.join(this.workDir, "task-plan.json");
-    if (!fs4.existsSync(taskPlanPath)) return;
+    if (!fs4.existsSync(taskPlanPath)) return void 0;
     let taskPlan;
     try {
       taskPlan = JSON.parse(fs4.readFileSync(taskPlanPath, "utf-8"));
@@ -3192,14 +3272,13 @@ Address these findings within your assigned scope, preserve the complete task re
       this.warn(
         `Could not parse task-plan.json \u2014 continuing with the original agent set: ${errorMessage2(err)}`
       );
-      return;
+      return void 0;
     }
     if (typeof taskPlan !== "object" || taskPlan === null || !("tasks" in taskPlan) || !Array.isArray(taskPlan.tasks)) {
       this.warn("task-plan.json has no `tasks` array \u2014 ignoring it.");
-      return;
+      return void 0;
     }
     const taskMap = /* @__PURE__ */ new Map();
-    const selected = new Set(agents2.map((a) => a.id));
     for (const [index, entry3] of taskPlan.tasks.entries()) {
       if (typeof entry3 !== "object" || entry3 === null || Array.isArray(entry3)) {
         this.warn(`task-plan.json contains a malformed task at index ${index} \u2014 ignoring it.`);
@@ -3210,18 +3289,23 @@ Address these findings within your assigned scope, preserve the complete task re
         this.warn(`task-plan.json contains a malformed task at index ${index} \u2014 ignoring it.`);
         continue;
       }
-      if (!selected.has(task.id)) {
-        this.warn(
-          `The task plan names "${task.id}", which is not in this run \u2014 ignoring that task.`
-        );
-        continue;
-      }
       if (taskMap.has(task.id)) {
         this.warn(`The task plan contains a duplicate task for "${task.id}" \u2014 ignoring that task.`);
         continue;
       }
       taskMap.set(task.id, task);
     }
+    return taskMap;
+  }
+  async applyTaskPlan(agents2, executedIds) {
+    const taskMap = this.readTaskPlan();
+    if (!taskMap) return;
+    const selected = new Set(agents2.map((a) => a.id));
+    for (const id of taskMap.keys()) {
+      if (!selected.has(id)) {
+        this.warn(`The task plan names "${id}", which is not in this run \u2014 ignoring that task.`);
+      }
+    }
     for (const agent of agents2) {
       const task = taskMap.get(agent.id);
       if (task) {
@@ -3243,6 +3327,27 @@ Address these findings within your assigned scope, preserve the complete task re
       }
     }
   }
+  /**
+   * Hand a resumed agent the plan entry it was originally given.
+   *
+   * `dependsOn` is deliberately not applied: `selectAgents` has already pruned
+   * the stage graph for this run, and re-applying the plan's dependencies would
+   * undo that pruning — including the one that lets a single-agent retry run
+   * without the teammate it depends on.
+   */
+  applyResumeTaskPlan(agents2) {
+    const taskMap = this.readTaskPlan();
+    if (!taskMap) return;
+    for (const agent of agents2) {
+      const task = taskMap.get(agent.id);
+      if (!task) continue;
+      agent.taskTitle = task.title;
+      agent.agentScope = task.scope;
+      if (task.plan?.length) {
+        agent.agentPlan = task.plan.map((s, i) => `${i + 1}. ${s}`).join("\n");
+      }
+    }
+  }
   /**
    * The `requirement` field for a result, present only when the caller set one.
    *

package/dist/orchestrator/AgentSessionManager.d.ts

@@ -16,6 +16,15 @@ export declare class AgentSessionManager {
     private closing?;
     private closed;
     execute(runtime: AgentRuntime, task: AgentTask): Promise<AgentOutput>;
+    /**
+     * Whether this manager still holds a session for `agentId`.
+     *
+     * A caller about to continue a past conversation uses this to avoid naming a
+     * session it already has open: passing the id would change the entry's
+     * fingerprint, and the manager would close a perfectly good session and
+     * `session/load` it straight back.
+     */
+    has(agentId: string): boolean;
     /**
      * Deliver a message into every session that is running a turn right now.
      *

package/dist/orchestrator/Orchestrator.d.ts

@@ -28,14 +28,19 @@ export declare class Orchestrator {
      */
     private buildStagesOrFallback;
     /**
-     * Drop last run's task plan before the architect gets a chance to write one.
+     * Decide what to do with last run's task plan before this turn starts.
      *
      * The console runs every turn against the same workspace, so the plan file
      * survives between turns. If a turn's architect fails to write a new one,
      * `applyTaskPlan` would silently re-apply the previous turn's titles, scopes
      * and dependencies to a completely different requirement.
+     *
+     * A resumed turn is the exception: the plan in the workspace describes the
+     * task being continued, and it is the only record of what each resumed agent
+     * was asked to do. Deleting it would leave every retried agent with the
+     * generic "no plan was provided" fallback.
      */
-    private clearStaleTaskPlan;
+    private prepareTaskPlan;
     /**
      * Decide what this turn is: a pipeline, an answer, or a question.
      *
@@ -51,7 +56,7 @@ export declare class Orchestrator {
      * `applyTaskPlan` writes `taskTitle` / `dependsOn` / `agentScope` onto whatever
      * objects it is handed. The console reuses a single config across turns, so
      * returning the config's own objects would leak turn 1's dependency graph into
-     * turn 2 — the exact cross-turn contamination `clearStaleTaskPlan` exists to
+     * turn 2 — the exact cross-turn contamination `prepareTaskPlan` exists to
      * prevent, but for the in-memory fields rather than the file.
      */
     private configuredAgents;
@@ -76,7 +81,29 @@ export declare class Orchestrator {
      * before `role` existed keeps working unchanged.
      */
     private isPlanner;
+    /**
+     * Read and validate `task-plan.json`, one entry per agent id.
+     *
+     * `undefined` means "there is no usable plan" — no file, unparseable JSON, or
+     * no `tasks` array. Each of those is reported rather than treated as an empty
+     * plan: a broken plan must not be indistinguishable from a missing one.
+     *
+     * Validation stops at "is this entry well-formed and unique". Whether an id
+     * belongs to the run is the caller's question, because a normal turn and a
+     * resume answer it differently — a resume must not warn about every teammate
+     * it deliberately left out.
+     */
+    private readTaskPlan;
     private applyTaskPlan;
+    /**
+     * Hand a resumed agent the plan entry it was originally given.
+     *
+     * `dependsOn` is deliberately not applied: `selectAgents` has already pruned
+     * the stage graph for this run, and re-applying the plan's dependencies would
+     * undo that pruning — including the one that lets a single-agent retry run
+     * without the teammate it depends on.
+     */
+    private applyResumeTaskPlan;
     /**
      * The `requirement` field for a result, present only when the caller set one.
      *

package/dist/types/config.d.ts

@@ -66,17 +66,26 @@ export interface MultiClawConfig {
      */
     history?: TurnRecord[];
     /**
-     * Re-run a known set of agents instead of letting the leader route, continuing
-     * their sessions where one is known.
+     * Continue known agent sessions, and optionally re-run a fixed set of agents
+     * instead of letting the leader route.
      *
-     * Set by a resume/retry driver — the CLI's `--resume`, the console's `/retry` —
-     * which already knows which agents to redo. Like `history`, it is per-run state
-     * the caller carries: core has no session of its own, and a config that never
-     * resumes leaves it unset and behaves exactly as before.
+     * Two shapes, and the difference is who decides what runs:
+     *
+     * - `agents` set — the CLI's `--resume`, the console's `/retry`: exactly those
+     *   agents run, in that order. A `dependsOn` outside the set is pruned, which
+     *   is what lets a single-agent retry run without its absent dependency.
+     * - `agents` absent — the console continuing an earlier session: the turn
+     *   routes as usual (leader, or the whole team) and the sessions are there for
+     *   whichever agents the route happens to pick. This is what makes a new
+     *   instruction land in a conversation the agents already remember.
+     *
+     * Like `history`, it is per-run state the caller carries: core has no session
+     * of its own, and a config that never resumes leaves it unset and behaves
+     * exactly as before.
      */
     resume?: {
         /** Agent ids to run, in the order they were originally selected. */
-        agents: string[];
+        agents?: string[];
         /** agentId → session id, for agents whose session is worth continuing. */
         sessions?: Record<string, string>;
     };

package/dist/types/runtime.d.ts

@@ -28,7 +28,14 @@ export type RuntimeEvent = (RuntimeEventBase & {
     type: "message";
     role: "agent" | "thought" | "user";
     text: string;
-}) | (RuntimeEventBase & {
+})
+/**
+ * A tool call. The same `id` may arrive more than once: providers announce a
+ * call before its arguments have streamed, so the first event can carry an
+ * empty `input` and a later one the completed arguments. Consumers should key
+ * on `id` and render a row once.
+ */
+ | (RuntimeEventBase & {
     type: "tool_call";
     id: string;
     name: string;

package/dist/utils/toolSummary.d.ts

@@ -7,6 +7,15 @@
  * truncated line and are deliberately total — a summary is diagnostics and must
  * never be the reason a run fails.
  */
+/**
+ * Whether a tool call was given any arguments.
+ *
+ * "No arguments yet" reaches us as `{}` (or missing) rather than as
+ * `undefined`: ACP announces a call before its input has finished streaming.
+ * Both mean the same thing to a reader — there is nothing to show yet — so the
+ * two are collapsed here instead of at every call site.
+ */
+export declare function hasToolArgs(input: unknown): boolean;
 /** One-line summary of a tool call's input. `input` is untrusted and may be circular. */
 export declare function summarizeToolInput(input: unknown): string;
 /** One-line summary of a tool result's output, which may be a string or a value. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiclawcli/core",
-  "version": "0.6.3",
+  "version": "0.8.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",