@d3ara1n/pi-subagent 0.10.2 → 0.10.3

package/README.md

@@ -47,6 +47,12 @@ This means:
 - **Collapsed result**: `✓ explorer · Found login, registration, and token logic` + recent tool calls + usage stats
 - **Expanded result** (Ctrl+O): Full task text, all tool calls, final output as rendered Markdown, and usage details
 
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/subagent:doctor` | Diagnose pi invocation, model-role resolution, configuration, and role references |
+
 ## Dependencies
 
 - [`@d3ara1n/pi-model-roles`](../pi-model-roles) — model role resolution

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-subagent",
-  "version": "0.10.2",
+  "version": "0.10.3",
   "type": "module",
   "description": "Role-based subagent orchestration for pi — delegates tasks to specialized pi child processes with configurable model roles",
   "main": "src/index.ts",

package/src/index.ts

@@ -23,6 +23,7 @@ import {
   AsyncSemaphore,
   isProviderError,
   effectiveTimeout,
+  hasFailedSubagentResult,
 } from "./utils.ts";
 import { persistSubagentHistory } from "./history.ts";
 import { compressOutput, generateSummary } from "./output.ts";
@@ -169,6 +170,11 @@ export default function subagentExtension(pi: ExtensionAPI) {
     rebuildGuidelines(availableRoles);
   });
 
+  pi.on("tool_result", (event) => {
+    if (event.toolName !== "delegate") return;
+    if (hasFailedSubagentResult(event.details)) return { isError: true };
+  });
+
   pi.registerTool({
     name: "delegate",
     label: "Delegate to subagent",
@@ -218,16 +224,9 @@ export default function subagentExtension(pi: ExtensionAPI) {
 
       // Guard against bounded subagent nesting. A configured depth of 0 is unlimited.
       if (config.maxDepth > 0 && CURRENT_DEPTH >= config.maxDepth) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Cannot delegate: maximum nesting depth (${config.maxDepth}) reached (current depth ${CURRENT_DEPTH}). Return a result to the caller instead of delegating further.`,
-            },
-          ],
-          details: undefined as any,
-          isError: true,
-        };
+        throw new Error(
+          `Cannot delegate: maximum nesting depth (${config.maxDepth}) reached (current depth ${CURRENT_DEPTH}). Return a result to the caller instead of delegating further.`,
+        );
       }
 
       // Throttle state hoisted to the execute scope so the finally block can clear it.
@@ -285,16 +284,9 @@ export default function subagentExtension(pi: ExtensionAPI) {
       try {
         await gate.acquire(signal);
       } catch {
-        return {
-          content: [
-            { type: "text", text: `Subagent (${params.role}) was cancelled while queued.` },
-          ],
-          details: { mode: "single", results: [] },
-          isError: true,
-        };
+        throw new Error(`Subagent (${params.role}) was cancelled while queued.`);
       }
 
-      const rethrowToToolRuntime = Symbol("pi-subagent-rethrow");
       try {
         // Resolve model AFTER acquiring so the queued period stays zero-cost
         let rolesApi: ModelRolesAPI;
@@ -522,9 +514,10 @@ export default function subagentExtension(pi: ExtensionAPI) {
         if (result.exitCode !== 0 || result.errorMessage) {
           const failedText = `Subagent (${params.role}) failed: ${result.errorMessage || result.stderr || "unknown error"}\n\nPartial output:\n${result.output}`;
           emitFinal([result], failedText);
-          const err = new Error(failedText) as Error & { [rethrowToToolRuntime]?: true };
-          err[rethrowToToolRuntime] = true;
-          throw err;
+          return {
+            content: [{ type: "text", text: failedText }],
+            details: { mode: "single", results: [result] },
+          };
         }
 
         // Build concise output for the main model with usage info
@@ -544,7 +537,6 @@ export default function subagentExtension(pi: ExtensionAPI) {
           details: { mode: "single", results: [result] },
         };
       } catch (err: any) {
-        if (err?.[rethrowToToolRuntime]) throw err;
         const errorText = `Subagent (${params.role}) error: ${err.message || err}`;
         emitFinal([], errorText);
         throw new Error(errorText);

package/src/utils.test.ts

@@ -21,9 +21,50 @@ import {
   formatTokens,
   effectiveTimeout,
   elapsedSeconds,
+  hasFailedSubagentResult,
 } from "./utils.ts";
 import type { SubagentResult, SubagentRole } from "./types.ts";
 
+describe("subagent failure details", () => {
+  const baseResult = (overrides: Partial<SubagentResult> = {}): SubagentResult => ({
+    role: "worker",
+    task: "test task",
+    exitCode: 0,
+    messages: [],
+    output: "ok",
+    stderr: "",
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      cost: 0,
+      contextTokens: 0,
+      turns: 0,
+    },
+    activityLog: [],
+    ...overrides,
+  });
+
+  test("detects failed delegate results for tool_result error marking", () => {
+    assert.equal(
+      hasFailedSubagentResult({ mode: "single", results: [baseResult({ exitCode: 1 })] }),
+      true,
+    );
+    assert.equal(
+      hasFailedSubagentResult({ mode: "single", results: [baseResult({ stopReason: "timeout" })] }),
+      true,
+    );
+  });
+
+  test("does not mark successful or malformed details as failed", () => {
+    assert.equal(hasFailedSubagentResult({ mode: "single", results: [baseResult()] }), false);
+    assert.equal(hasFailedSubagentResult({ mode: "single", results: [] }), false);
+    assert.equal(hasFailedSubagentResult(undefined), false);
+    assert.equal(hasFailedSubagentResult({}), false);
+  });
+});
+
 // ── sanitizeFilename: guards the path-injection fix ──
 describe("sanitizeFilename", () => {
   test("never yields a path separator (no directory traversal)", () => {

package/src/utils.ts

@@ -4,7 +4,13 @@
  */
 
 import * as os from "node:os";
-import type { ActivityEntry, SubagentRole, SubagentResult, ToolStatus } from "./types.ts";
+import type {
+  ActivityEntry,
+  SubagentDetails,
+  SubagentRole,
+  SubagentResult,
+  ToolStatus,
+} from "./types.ts";
 
 /** Max output chars fed to the main model and the expanded TUI. Larger outputs are compressed (or truncated) to fit. */
 export const MAX_OUTPUT_CHARS = 50_000;
@@ -194,6 +200,11 @@ export function isFailedResult(r: SubagentResult): boolean {
   );
 }
 
+export function hasFailedSubagentResult(details: unknown): boolean {
+  const d = details as SubagentDetails | undefined;
+  return Array.isArray(d?.results) && d.results.some(isFailedResult);
+}
+
 /** Heuristic: does this result look like a provider-side failure worth retrying on the fallback role? */
 export function isProviderError(result: SubagentResult): boolean {
   const haystack = `${result.stderr || ""}\n${result.errorMessage || ""}`;