@buihongduc132/pi-acp-agents 0.3.1 → 0.4.0

package/index.ts

@@ -3,13 +3,14 @@ import { join } from "node:path";
 import { randomBytes } from "node:crypto";
 import type { AgentToolResult, ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { Type } from "typebox";
-import { type AcpWidgetState, createAcpWidget } from "./src/acp-widget.js";
+import { type AcpWidgetState, type AcpWidgetDag, createAcpWidget, dagIndexEntryToWidgetDag } from "./src/acp-widget.js";
 import { createAdapter } from "./src/adapter-factory.js";
 import { loadConfig } from "./src/config/config.js";
-import type { AcpArchivedSessionMetadata, AcpConfig, AcpPromptResult, AcpSessionHandle, AcpWorkerStatus } from "./src/config/types.js";
+import type { AcpArchivedSessionMetadata, AcpConfig, AcpPromptResult, AcpSessionHandle, AcpWorkerStatus, DagIndexEntry } from "./src/config/types.js";
 import { AgentCoordinator } from "./src/coordination/coordinator.js";
 import { WorkerDispatcher, type WorkerDispatcherDeps } from "./src/coordination/worker-dispatcher.js";
 import { AcpCircuitBreaker } from "./src/core/circuit-breaker.js";
+import { AsyncExecutor } from "./src/core/async-executor.js";
 import { HealthMonitor } from "./src/core/health-monitor.js";
 import { getSessionAutoCloseReason } from "./src/core/session-lifecycle.js";
 import { SessionManager } from "./src/core/session-manager.js";
@@ -22,7 +23,12 @@ import { AcpTaskStore, type AcpTaskStatus } from "./src/management/task-store.js
 import { WorkerStore } from "./src/management/worker-store.js";
 import { SessionArchiveStore } from "./src/management/session-archive-store.js";
 import { SessionNameStore } from "./src/management/session-name-store.js";
+import { SessionStoreFactory } from "./src/management/session-store-factory.js";
 import { ensureRuntimeDir } from "./src/management/runtime-paths.js";
+import { DagStore } from "./src/dag/dag-store.js";
+import { DagValidator } from "./src/dag/dag-validator.js";
+import { DagExecutor, type DagCancelSummary } from "./src/dag/dag-executor.js";
+import { TemplateResolver } from "./src/dag/template-resolver.js";
 import { loadSettings, isToolEnabled, type AcpToolSettings } from "./src/settings/config.js";
 import { configureToolSettings } from "./src/settings/configure-tui.js";
 
@@ -81,13 +87,33 @@ export default function (pi: ExtensionAPI) {
   const logger = createFileLogger(logsDir);
   const runtimePaths = ensureRuntimeDir(config.runtimeDir);
   const eventLog = new AcpEventLog(runtimePaths.rootDir);
-  const taskStore = new AcpTaskStore(runtimePaths.rootDir);
-  const workerStore = new WorkerStore(runtimePaths.rootDir);
-  const mailboxManager = new MailboxManager(runtimePaths.rootDir);
-  const governanceStore = new GovernanceStore(runtimePaths.rootDir);
-  const sessionArchiveStore = new SessionArchiveStore(runtimePaths.rootDir);
   const sessionNameStore = new SessionNameStore(runtimePaths.rootDir);
-  governanceStore.setModelPolicy(config.modelPolicy ?? {});
+
+  // Session-scoped stores — lazily created per host session ID
+  const storeFactory = new SessionStoreFactory(runtimePaths.rootDir);
+  let hostSessionId: string | undefined;
+
+  // Capture host session ID on session start (fires before any tool call)
+  pi.on("session_start", (_event, ctx) => {
+    hostSessionId = ctx.sessionManager.getSessionId();
+    // Apply governance policy to the session-scoped governance store
+    storeFactory.get(hostSessionId).governanceStore.setModelPolicy(config.modelPolicy ?? {});
+  });
+
+  /** Get session-scoped stores for the current host session. */
+  function getStores() {
+    const sid = hostSessionId ?? process.env.PI_SESSION_ID ?? "default";
+    return storeFactory.get(sid);
+  }
+
+  /** Convenience accessors for closures that need stores without ctx. */
+  const taskStore = () => getStores().taskStore;
+  const workerStore = () => getStores().workerStore;
+  const mailboxManager = () => getStores().mailboxManager;
+  const governanceStore = () => getStores().governanceStore;
+
+  // SessionArchiveStore is GLOBAL (catalogs all sessions) — not session-scoped
+  const sessionArchiveStore = new SessionArchiveStore(runtimePaths.rootDir);
 
   const cb = new AcpCircuitBreaker(
     config.circuitBreakerMaxFailures ?? 3,
@@ -95,6 +121,66 @@ export default function (pi: ExtensionAPI) {
     config.stallTimeoutMs ?? 300_000,
   );
 
+  // DAG orchestration — file-backed store, validator, template resolver, and
+  // wave-based executor. Wired with existing infrastructure singletons below.
+  // The coordinator and async executor are created lazily per tool call where
+  // they already exist; the DagExecutor consults the coordinator on each step
+  // dispatch, so a placeholder is passed and the real coordinator is supplied
+  // at execute time inside acp_dag_submit.
+  //
+  // Task 3.3: `dagStore` is deliberately declared here (same closure scope as
+  // `workerStore` above and the `getWidgetState()` builder below) so it is
+  // directly reachable from getWidgetState() when it maps `dagStore.listAll()`
+  // into AcpWidgetState.dags. No hoisting is required — the instance lives at
+  // the extension-factory scope for the lifetime of the extension, matching
+  // the pattern already used by `workerStore`.
+  const dagStore = new DagStore({
+    dagDir: runtimePaths.dagDir,
+    dagIndexFile: runtimePaths.dagIndexFile,
+  });
+  const dagValidator = new DagValidator();
+  const dagTemplateResolver = new TemplateResolver({
+    truncateChars: config.dagOutputTruncateChars ?? 8000,
+  });
+
+  // ── Resume-on-startup hook (task 7.3, specs/dag-resume "Resume from last
+  // checkpoint after pi restart") ──
+  // On extension load, discover DAGs persisted in `running` state and resume
+  // each from its last checkpoint. The resume pass is fire-and-forget: the
+  // coordinator/executor construction and resumeAll() run inside an async
+  // IIFE so a failure (e.g. unreadable runtime dir) is caught and logged
+  // rather than thrown into the synchronous extension load path.
+  (async () => {
+    try {
+      const resumeCoordinator = new AgentCoordinator(config, process.cwd(), {
+        isHealthyFn: (name) => cb.isHealthy(name),
+        recordSuccessFn: (name) => cb.recordSuccess(name),
+        recordFailureFn: (name) => cb.recordFailure(name),
+      });
+      const resumeAsyncExecutor = new AsyncExecutor(resumeCoordinator, runtimePaths.rootDir);
+      const resumeExecutor = new DagExecutor({
+        store: dagStore,
+        resolver: dagTemplateResolver,
+        coordinator: resumeCoordinator,
+        asyncExecutor: resumeAsyncExecutor,
+        circuitBreaker: cb,
+        logger,
+        eventLog,
+      });
+      // Mark stale DAGs before resuming — a DAG with no step transitions
+      // for longer than dagStaleTimeoutMs is transitioned to `stale` and
+      // excluded from resume (specs/dag-stale-detection).
+      const staleTimeoutMs = config.dagStaleTimeoutMs ?? 3_600_000;
+      resumeExecutor.markStale(staleTimeoutMs);
+
+      await resumeExecutor.resumeAll();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error("DAG resume-on-startup failed", { error: message });
+      eventLog.append("dag_resume_failed", { error: message });
+    }
+  })();
+
   function archiveSession(handle: AcpSessionHandle): AcpArchivedSessionMetadata {
     return sessionArchiveStore.upsert(handle);
   }
@@ -185,7 +271,7 @@ export default function (pi: ExtensionAPI) {
   const heartbeatDeps = {
     resolveWorkerName: (sid: string) => workerSessionMap.get(sid),
     touch: (name: string, deltas?: { tokenDelta?: number; toolCallDelta?: number }) =>
-      workerStore.touch(name, deltas),
+      workerStore().touch(name, deltas),
     logParseError: (entry: { workerName: string; sessionId: string; error: string }) =>
       eventLog.append("heartbeat_parse_error", entry),
   };
@@ -253,12 +339,12 @@ export default function (pi: ExtensionAPI) {
 
   if (workerAutoClaim) {
     const dispatchDeps: WorkerDispatcherDeps = {
-      workerStore: workerStore as unknown as WorkerDispatcherDeps["workerStore"],
-      taskStore: taskStore as unknown as WorkerDispatcherDeps["taskStore"],
+      get workerStore() { return workerStore() as unknown as WorkerDispatcherDeps["workerStore"]; },
+      get taskStore() { return taskStore() as unknown as WorkerDispatcherDeps["taskStore"]; },
       eventLog,
       busySessions,
       getSessionIdForWorker: (workerName: string) => {
-        const worker = workerStore.get(workerName);
+        const worker = workerStore().get(workerName);
         if (!worker) return undefined;
         // Find sessionId from the workerSessionMap by reversing the lookup
         for (const [sid, name] of workerSessionMap.entries()) {
@@ -309,7 +395,7 @@ export default function (pi: ExtensionAPI) {
     configuredAliases: config.agent_aliases ? Object.keys(config.agent_aliases) : [],
     defaultAgent: config.defaultAgent,
     activity: { ...widgetActivity },
-    workers: workerStore.list().map((w) => {
+    workers: workerStore().list().map((w) => {
       const now = Date.now();
       const ageSec = Math.floor((now - new Date(w.lastActivityAt).getTime()) / 1000);
       const derived = deriveWorkerStatus(w);
@@ -324,6 +410,16 @@ export default function (pi: ExtensionAPI) {
         currentTaskId: w.currentTaskId,
       };
     }),
+    // Task 3.2 / 3.4: populate `dags` from DagStore.listAll() — filter out
+    // `pending`, sort by `updatedAt` desc, cap at 5 entries. Field-name
+    // remapping DagIndexEntry → AcpWidgetDag is centralized and documented in
+    // `dagIndexEntryToWidgetDag()` (see src/acp-widget.ts).
+    dags: dagStore
+      .listAll()
+      .filter((e) => e.status !== "pending")
+      .sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : a.updatedAt > b.updatedAt ? -1 : 0))
+      .slice(0, 5)
+      .map((e) => dagIndexEntryToWidgetDag(e)),
   });
 
   const widgetFactory = createAcpWidget({ getState: getWidgetState });
@@ -710,7 +806,7 @@ ${pr.text}`;
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       config = loadConfig();
-      governanceStore.setModelPolicy(config.modelPolicy ?? {});
+      governanceStore().setModelPolicy(config.modelPolicy ?? {});
       if (params.session_id || params.session_name) {
         let target;
         try {
@@ -844,7 +940,7 @@ ${pr.text}`;
       // Bulk operation
       if (params.task_id === "*") {
         const filter = params.filter ?? "";
-        const updated = taskStore.updateWhere(filter, (t: any) => {
+        const updated = taskStore().updateWhere(filter, (t: any) => {
           if (params.status) t.status = params.status;
           if (params.assignee !== undefined) t.assignee = params.assignee || null;
           if (params.result) t.result = params.result;
@@ -854,7 +950,7 @@ ${pr.text}`;
       }
 
       // Single task
-      const updated = taskStore.update(params.task_id, (t: any) => {
+      const updated = taskStore().update(params.task_id, (t: any) => {
         if (params.status) t.status = params.status;
         if (params.assignee !== undefined) t.assignee = params.assignee || null;
         if (params.result) t.result = params.result;
@@ -892,7 +988,7 @@ ${pr.text}`;
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       if (params.action === "send") {
         const kind: "dm" | "steer" | "broadcast" = params.to === "*" ? "broadcast" : ((params.kind as "dm" | "steer" | "broadcast" | undefined) ?? "dm");
-        const result = mailboxManager.send({
+        const result = mailboxManager().send({
           from: params.from ?? "user",
           to: params.to ?? "",
           message: params.message ?? "",
@@ -903,11 +999,11 @@ ${pr.text}`;
 
       if (params.action === "list") {
         if (params.recipient) {
-          const messages = mailboxManager.listFor(params.recipient);
+          const messages = mailboxManager().listFor(params.recipient);
           return { content: [textContent(`${messages.length} messages for ${params.recipient}.`)], details: { messages } };
         }
         // List all
-        const messages = mailboxManager.listAll?.() ?? [];
+        const messages = mailboxManager().listAll?.() ?? [];
         return { content: [textContent(`${messages.length} total messages.`)], details: { messages } };
       }
 
@@ -931,7 +1027,7 @@ ${pr.text}`;
       deps: Type.Optional(Type.Array(Type.String(), { description: "Task IDs this task depends on" })),
     }),
     async execute(_toolCallId, params) {
-      const task = taskStore.create({ subject: params.subject, description: params.description, assignee: params.assignee, deps: params.deps });
+      const task = taskStore().create({ subject: params.subject, description: params.description, assignee: params.assignee, deps: params.deps });
       eventLog.append("task_create", { taskId: task.id, assignee: task.assignee });
       return { content: [textContent(formatJson(task))], details: task };
     },
@@ -1143,7 +1239,7 @@ ${pr.text}`;
       }
 
       // Check for duplicate name
-      const existing = workerStore.get(name);
+      const existing = workerStore().get(name);
       if (existing) {
         return {
           content: [textContent(`Worker '${name}' already exists`)],
@@ -1166,7 +1262,7 @@ ${pr.text}`;
           if (params.thinking) await adapter.setMode(params.thinking);
           const handle = makeSessionHandle(sessionId, agentName, effectiveCwd, adapter);
           // Register in WorkerStore
-          const worker = workerStore.register({ name, sessionId, agentName });
+          const worker = workerStore().register({ name, sessionId, agentName });
           // Register session → worker mapping for heartbeat consumer
           workerSessionMap.set(sessionId, name);
           // Store adapter for dispatcher access
@@ -1222,7 +1318,7 @@ ${pr.text}`;
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       // Fetch all workers, then filter by derived status if requested
-      const allWorkers = workerStore.list();
+      const allWorkers = workerStore().list();
       const rawFilter = params.filter as string | undefined;
       const workers = rawFilter
         ? allWorkers.filter((w) => {
@@ -1294,7 +1390,7 @@ ${pr.text}`;
       const message = requireString(params.message, "message");
 
       // 4.5: Return error if worker not found
-      const worker = workerStore.get(name);
+      const worker = workerStore().get(name);
       if (!worker) {
         return { content: [textContent(`Worker '${name}' not found`)], details: { error: "worker_not_found", name } };
       }
@@ -1309,7 +1405,7 @@ ${pr.text}`;
         try {
           await adapter.cancel();
           // Cancel succeeded — queue steer for next prompt after worker returns to idle
-          workerStore.updateMetadata(name, { pendingSteer: message });
+          workerStore().updateMetadata(name, { pendingSteer: message });
           eventLog.append("worker_steer_interrupt", { name, sessionId, message });
           refreshWidget(ctx);
           return {
@@ -1318,7 +1414,7 @@ ${pr.text}`;
           };
         } catch (err) {
           // Interrupt failed — queue as next-prompt-prefix with warning
-          workerStore.updateMetadata(name, { pendingSteer: message });
+          workerStore().updateMetadata(name, { pendingSteer: message });
           eventLog.append("worker_steer_queued", { name, sessionId, message, reason: "interrupt_failed" });
           refreshWidget(ctx);
           return {
@@ -1329,7 +1425,7 @@ ${pr.text}`;
       }
 
       // Idle or no adapter — queue as next-prompt-prefix (4.4)
-      workerStore.updateMetadata(name, { pendingSteer: message });
+      workerStore().updateMetadata(name, { pendingSteer: message });
       eventLog.append("worker_steer_queued", { name, sessionId, message, reason: isBusy ? "no_adapter" : "idle" });
       refreshWidget(ctx);
       return { content: [textContent(`Steer message queued for worker '${name}': ${message}`)], details: { name, message, queued: true } };
@@ -1353,9 +1449,9 @@ ${pr.text}`;
       // Determine which workers to shut down
       let targets: string[];
       if (params.all) {
-        targets = workerStore.list().filter((w) => w.status !== "offline").map((w) => w.name);
+        targets = workerStore().list().filter((w) => w.status !== "offline").map((w) => w.name);
       } else if (params.name) {
-        const worker = workerStore.get(params.name);
+        const worker = workerStore().get(params.name);
         if (!worker) {
           return { content: [textContent(`Worker '${params.name}' not found`)], details: { error: "worker_not_found" } };
         }
@@ -1367,7 +1463,7 @@ ${pr.text}`;
       const results: Array<{ name: string; ok: boolean; error?: string }> = [];
 
       for (const name of targets) {
-        const worker = workerStore.get(name);
+        const worker = workerStore().get(name);
         if (!worker) continue;
 
         try {
@@ -1376,11 +1472,11 @@ ${pr.text}`;
             const startTime = Date.now();
             while (worker.currentTaskId && (Date.now() - startTime) < shutdownTimeoutMs) {
               await new Promise((r) => setTimeout(r, 500));
-              const fresh = workerStore.get(name);
+              const fresh = workerStore().get(name);
               if (fresh && !fresh.currentTaskId) break;
             }
             // Check if still busy after timeout
-            const afterWait = workerStore.get(name);
+            const afterWait = workerStore().get(name);
             if (afterWait?.currentTaskId) {
               results.push({ name, ok: false, error: `Shutdown timed out; worker '${name}' still busy. Use acp_worker_kill to force.` });
               continue;
@@ -1398,7 +1494,7 @@ ${pr.text}`;
           busySessions.delete(sessionId);
 
           // Mark worker offline
-          workerStore.updateStatus(name, "offline");
+          workerStore().updateStatus(name, "offline");
 
           // 6.2: Emit worker_shutdown event
           eventLog.append("worker_shutdown", { name, sessionId });
@@ -1430,7 +1526,7 @@ ${pr.text}`;
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const name = requireString(params.name, "name");
-      const worker = workerStore.get(name);
+      const worker = workerStore().get(name);
       if (!worker) {
         return { content: [textContent(`Worker '${name}' not found`)], details: { error: "worker_not_found" } };
       }
@@ -1448,13 +1544,13 @@ ${pr.text}`;
       // Unassign active tasks (set to pending)
       if (worker.currentTaskId) {
         try {
-          taskStore.update(worker.currentTaskId, (t) => { t.status = "pending"; });
+          taskStore().update(worker.currentTaskId, (t) => { t.status = "pending"; });
         } catch { /* ignore */ }
-        workerStore.unassignTask(name);
+        workerStore().unassignTask(name);
       }
 
       // Mark worker offline
-      workerStore.updateStatus(name, "offline");
+      workerStore().updateStatus(name, "offline");
 
       // 6.2: Emit worker_shutdown event
       eventLog.append("worker_shutdown", { name, sessionId, forced: true });
@@ -1473,7 +1569,7 @@ ${pr.text}`;
     promptSnippet: "acp_worker_prune — prune stale workers",
     parameters: Type.Object({}),
     async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-      const workers = workerStore.list();
+      const workers = workerStore().list();
       const pruned: string[] = [];
 
       for (const w of workers) {
@@ -1483,12 +1579,12 @@ ${pr.text}`;
           // Unassign active tasks
           if (w.currentTaskId) {
             try {
-              taskStore.update(w.currentTaskId, (t) => { t.status = "pending"; });
+              taskStore().update(w.currentTaskId, (t) => { t.status = "pending"; });
             } catch { /* ignore */ }
-            workerStore.unassignTask(w.name);
+            workerStore().unassignTask(w.name);
           }
           // Mark offline
-          workerStore.updateStatus(w.name, "offline");
+          workerStore().updateStatus(w.name, "offline");
           pruned.push(w.name);
         }
       }
@@ -1501,6 +1597,178 @@ ${pr.text}`;
     },
   });
 
+  // ── DAG tools ────────────────────────────────────────────────────────
+
+  if (isToolEnabled(toolSettings, "acp_dag_submit")) pi.registerTool({
+    name: "acp_dag_submit",
+    label: "ACP DAG Submit",
+    description: "Submit a complete DAG (directed acyclic graph) of ACP agent tasks in a single call. Validates statically (cycles, dangling refs, duplicate IDs, agent availability, reserved IDs), creates the DAG, starts wave-based background execution, and returns the dagId immediately.",
+    promptSnippet: "acp_dag_submit — submit a DAG of ACP agent tasks and start background execution",
+    parameters: Type.Object({
+      tasks: Type.Array(Type.Object({
+        id: Type.String({ description: "Unique step identifier" }),
+        agent: Type.String({ description: "Agent name (must exist in agent_servers config)" }),
+        prompt: Type.String({ description: "Prompt text. May contain {<step-id>.output}, {<step-id>.status}, {dag.args.<key>} template variables." }),
+        dependsOn: Type.Optional(Type.Array(Type.String(), { description: "Step IDs this step depends on (default: [])" })),
+        gate: Type.Optional(Type.Union([Type.Literal("needs"), Type.Literal("after")], { description: "Gate type for ALL dependencies. needs = success-gate (default), after = completion-gate" })),
+      }), { description: "DAG task definitions" }),
+      args: Type.Optional(Type.Record(Type.String(), Type.String(), { description: "Workflow-level arguments for {dag.args.*} template variables" })),
+      options: Type.Optional(Type.Object({
+        failFast: Type.Optional(Type.Boolean({ description: "On failure, skip transitive dependents. Default: true" })),
+        maxRetries: Type.Optional(Type.Number({ description: "Retry attempts per step on failure. Default: 0" })),
+      })),
+      cwd: Type.Optional(Type.String({ description: "Working directory for all DAG steps" })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const tasks = params.tasks;
+      if (!Array.isArray(tasks) || tasks.length === 0) {
+        return { content: [textContent("acp_dag_submit requires a non-empty \"tasks\" array.")], details: { error: "no tasks" } };
+      }
+
+      // 1. Static validation against the configured agent set.
+      const agentNames = new Set(Object.keys(config.agent_servers));
+      const validation = dagValidator.validate(tasks, agentNames);
+      if (!validation.valid) {
+        const message = `DAG validation failed: ${validation.errors.join("; ")}`;
+        eventLog.append("dag_submit_rejected", { errors: validation.errors });
+        return { content: [textContent(message)], details: { error: "validation_failed", violations: validation.errors } };
+      }
+
+      // 2. Create the DAG record via the file-backed store.
+      const record = dagStore.create({
+        tasks,
+        args: params.args,
+        options: params.options ?? {},
+      });
+
+      // 3. Build a per-call coordinator + executor with the current cwd and
+      //    circuit breaker, then kick off execution in the background
+      //    (fire-and-forget). The dagId is returned immediately.
+      const coordinator = new AgentCoordinator(config, params.cwd ?? ctx.cwd, {
+        isHealthyFn: (name) => cb.isHealthy(name),
+        recordSuccessFn: (name) => cb.recordSuccess(name),
+        recordFailureFn: (name) => cb.recordFailure(name),
+      });
+      // Existing AsyncExecutor singleton wired into the DagExecutor (task
+      // 7.1). The wave loop is driven directly by the executor (design.md
+      // D2 / task 5.3), but the AsyncExecutor is retained on the instance
+      // for integration with the rest of the background-dispatch infra.
+      const asyncExecutor = new AsyncExecutor(coordinator, runtimePaths.rootDir);
+      const dagExecutor = new DagExecutor({
+        store: dagStore,
+        resolver: dagTemplateResolver,
+        coordinator,
+        asyncExecutor,
+        circuitBreaker: cb,
+        logger,
+        eventLog,
+      });
+
+      // Fire-and-forget: errors are captured per step into the DAG state file.
+      dagExecutor.execute(record.dagId).catch((err) => {
+        logger.error(`acp_dag_submit background execution failed for dagId=${record.dagId}`, { error: err instanceof Error ? err.message : String(err) });
+        eventLog.append("dag_execute_failed", { dagId: record.dagId, error: err instanceof Error ? err.message : String(err) });
+      });
+
+      eventLog.append("dag_submitted", { dagId: record.dagId, stepCount: tasks.length });
+      return {
+        content: [textContent(`Submitted DAG "${record.dagId}" with ${tasks.length} step(s). Execution started in the background.`)],
+        details: { dagId: record.dagId, stepCount: tasks.length },
+      };
+    },
+  });
+
+  if (isToolEnabled(toolSettings, "acp_dag_status")) pi.registerTool({
+    name: "acp_dag_status",
+    label: "ACP DAG Status",
+    description: "Query the execution state of a DAG. With a dagId, returns the full DAG state (status, all steps with their statuses, outputs, errors, dependencies, wave progress). Without a dagId, lists all DAGs with summary status.",
+    promptSnippet: "acp_dag_status — get full DAG state or list all DAGs",
+    parameters: Type.Object({
+      dagId: Type.Optional(Type.String({ description: "DAG ID to inspect. Omit to list all DAGs." })),
+    }),
+    async execute(_toolCallId, params): Promise<AgentToolResult<{ dagId?: string; status?: string; currentWave?: number; totalWaves?: number; dags?: DagIndexEntry[]; count?: number; error?: string }>> {
+      const dagId = params.dagId?.trim();
+
+      // Listing mode: no dagId provided → return all DAGs from the index.
+      if (!dagId) {
+        const dags = dagStore.listAll();
+        return {
+          content: [textContent(formatJson({ dags }))],
+          details: { dags, count: dags.length },
+        };
+      }
+
+      // Detail mode: dagId provided → return the full DAG record.
+      const record = dagStore.get(dagId);
+      if (!record) {
+        return {
+          content: [textContent(`DAG "${dagId}" not found`)],
+          details: { error: "not_found", dagId },
+        };
+      }
+
+      return {
+        content: [textContent(formatJson(record))],
+        details: { dagId, status: record.status, currentWave: record.currentWave, totalWaves: record.totalWaves },
+      };
+    },
+  });
+
+  if (isToolEnabled(toolSettings, "acp_dag_cancel")) pi.registerTool({
+    name: "acp_dag_cancel",
+    label: "ACP DAG Cancel",
+    description: "Cancel a running DAG. Aborts in-flight agent sessions, marks all pending/running steps as cancelled, transitions the DAG to cancelled, and returns a summary of the cancellation.",
+    promptSnippet: "acp_dag_cancel — cancel a running DAG and return a cancellation summary",
+    parameters: Type.Object({
+      dagId: Type.String({ description: "DAG ID to cancel" }),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx): Promise<AgentToolResult<{ dagId: string; completed?: number; aborted?: number; cancelled?: number; error?: string }>> {
+      const dagId = (params.dagId ?? "").toString().trim();
+      if (!dagId) {
+        return {
+          content: [textContent("acp_dag_cancel requires a non-empty \"dagId\".")],
+          details: { dagId, error: "no_dagId" },
+        };
+      }
+
+      // Build a per-call coordinator + executor (same wiring as
+      // acp_dag_submit). DagExecutor.cancel() reads the persisted step states
+      // from the DagStore to tally the summary and abort in-flight sessions.
+      const coordinator = new AgentCoordinator(config, ctx.cwd, {
+        isHealthyFn: (name) => cb.isHealthy(name),
+        recordSuccessFn: (name) => cb.recordSuccess(name),
+        recordFailureFn: (name) => cb.recordFailure(name),
+      });
+      const asyncExecutor = new AsyncExecutor(coordinator, runtimePaths.rootDir);
+      const dagExecutor = new DagExecutor({
+        store: dagStore,
+        resolver: dagTemplateResolver,
+        coordinator,
+        asyncExecutor,
+        circuitBreaker: cb,
+        logger,
+        eventLog,
+      });
+
+      try {
+        const summary: DagCancelSummary = await dagExecutor.cancel(dagId);
+        eventLog.append("dag_cancelled", { dagId, ...summary });
+        return {
+          content: [textContent(formatJson({ dagId, ...summary }))],
+          details: { dagId, ...summary },
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger.error(`acp_dag_cancel failed for dagId=${dagId}`, { error: message });
+        eventLog.append("dag_cancel_failed", { dagId, error: message });
+        return {
+          content: [textContent(message)],
+          details: { dagId, error: "cancel_failed" },
+        };
+      }
+    },
+  });
+
   pi.registerCommand("acp-doctor", {
     description: "Compatibility alias for /acp runtime doctor",
     async handler(_args, ctx) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buihongduc132/pi-acp-agents",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Pi extension: ACP agent client — spawn and control ACP-compatible agents (Gemini CLI, etc.) from within pi",
   "keywords": [
     "pi-package",