@multiclawcli/core 0.8.2 → 0.9.0

package/dist/index.js

@@ -2721,6 +2721,8 @@ var Orchestrator = class {
   constructor(config, sessions) {
     this.config = config;
     this.eventBus = new EventBus();
+    /** Which configured checkpoints have already been triggered this run. */
+    this.checkpointTriggered = /* @__PURE__ */ new Set();
     this.workDir = path5.resolve(config.workDir);
     fs4.mkdirSync(this.workDir, { recursive: true });
     this.contextManager = new ContextManager(config.context);
@@ -2896,7 +2898,31 @@ var Orchestrator = class {
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
         payload: { stageIndex: i }
       });
-      if (!allSuccess && !this.config.continueOnError) {
+      if (this.config.checkpoints?.length && this.config.onCheckpoint) {
+        for (let cpIdx = 0; cpIdx < this.config.checkpoints.length; cpIdx++) {
+          if (this.checkpointTriggered.has(cpIdx)) continue;
+          const cp = this.config.checkpoints[cpIdx];
+          if (cp.afterAgents.every((id) => executedIds.has(id))) {
+            this.checkpointTriggered.add(cpIdx);
+            const response = await this.handleCheckpoint(cp, results, options.signal);
+            if (response.action === "cancel") {
+              cancelled = true;
+              allSuccess = false;
+              break;
+            }
+            if (response.action === "modify") {
+              const current = this.contextManager.get("requirement") ?? "";
+              this.contextManager.set(
+                "requirement",
+                `${current}
+
+[Checkpoint feedback] ${response.instruction}`
+              );
+            }
+          }
+        }
+      }
+      if (cancelled || !allSuccess && !this.config.continueOnError) {
         for (const remainingStage of stages.slice(i + 1)) {
           for (const agent of remainingStage) {
             this.eventBus.emit({
@@ -3075,6 +3101,19 @@ Address these findings within your assigned scope, preserve the complete task re
       acceptance.status = "failed";
     }
   }
+  async handleCheckpoint(policy, results, signal) {
+    if (signal?.aborted) return { action: "cancel" };
+    const completedAgents = policy.afterAgents.map((id) => {
+      const r = results.find((res) => res.agentId === id && res.status === "success");
+      if (!r) return void 0;
+      return { id: r.agentId, name: r.agentName, output: r.output };
+    }).filter((a) => a !== void 0);
+    const info = {
+      label: policy.label || "review checkpoint",
+      completedAgents
+    };
+    return this.config.onCheckpoint(info, signal ?? new AbortController().signal);
+  }
   stageInfos(stages) {
     const getModel = (agent) => resolveModel(agent, this.config);
     return stages.map((stage, i) => ({

package/dist/orchestrator/Orchestrator.d.ts

@@ -7,6 +7,8 @@ export declare class Orchestrator {
     private contextManager;
     private runner;
     private workDir;
+    /** Which configured checkpoints have already been triggered this run. */
+    private checkpointTriggered;
     constructor(config: MultiClawConfig, sessions?: AgentSessionManager);
     preview(options?: {
         signal?: AbortSignal;
@@ -16,6 +18,7 @@ export declare class Orchestrator {
     }): Promise<OrchestratorResult>;
     private reviewPolicyError;
     private reviewDelivery;
+    private handleCheckpoint;
     private stageInfos;
     /**
      * Order the agents into stages, degrading to declaration order if the graph is

package/dist/types/config.d.ts

@@ -38,6 +38,36 @@ export interface ReviewPolicy {
     /** Maximum repair passes (0–5); defaults to 1. Review runs once more after each pass. */
     maxRepairRounds?: number;
 }
+/**
+ * A checkpoint pauses the pipeline after specific agents complete, giving the
+ * user a chance to review their output before downstream agents run.
+ */
+export interface CheckpointPolicy {
+    /** Agent IDs that must all complete before this checkpoint triggers. */
+    afterAgents: string[];
+    /** Label shown to the user in the checkpoint prompt. */
+    label?: string;
+}
+/** What the orchestrator presents when a checkpoint is reached. */
+export interface CheckpointInfo {
+    label: string;
+    completedAgents: Array<{
+        id: string;
+        name: string;
+        output?: string;
+    }>;
+}
+/** How the user responds to a checkpoint. */
+export type CheckpointResponse = {
+    action: "continue";
+} | {
+    action: "modify";
+    instruction: string;
+} | {
+    action: "cancel";
+};
+/** Caller-owned checkpoint handler; headless callers continue automatically. */
+export type CheckpointHandler = (checkpoint: CheckpointInfo, signal: AbortSignal) => Promise<CheckpointResponse>;
 export interface ReviewVerdict {
     verdict: "approved" | "changes_required";
     summary: string;
@@ -95,6 +125,10 @@ export interface MultiClawConfig {
     useLeader?: boolean;
     /** Opt-in delivery gate. Execution success alone does not satisfy this policy. */
     review?: ReviewPolicy;
+    /** Pause points after specific agents complete, for human review before continuation. */
+    checkpoints?: CheckpointPolicy[];
+    /** Caller-owned checkpoint handler; absent checkpoints proceed automatically. */
+    onCheckpoint?: CheckpointHandler;
     /** Caller-owned live approvals. Ask mode without a handler fails closed. */
     permissions?: {
         mode: "auto" | "ask" | "deny";

package/package.json

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