@multiclawcli/core 0.7.0 → 0.8.0

package/dist/index.js

@@ -2054,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.
    *
@@ -2735,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() };
@@ -2786,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);
@@ -2795,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,
@@ -3093,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 });
   }
   /**
@@ -3113,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")
@@ -3153,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() {
@@ -3230,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"));
@@ -3240,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.`);
@@ -3258,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) {
@@ -3291,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/package.json

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