oira666_pi-subagent 0.2.10 → 0.2.12

package/index.ts

@@ -20,6 +20,7 @@ import { runAgentSubprocess, executeParallelSubprocess } from "./runner.js";
 import {
   SUBAGENT_RESUME_DISABLE_ENV,
   SUBAGENT_RESUME_PROMPT_ENV,
+  branchEntries,
   buildSubagentSessionDir,
   findLatestResumableSubagentCall,
   getDefaultSubagentSessionRoot,
@@ -30,7 +31,10 @@ import {
 } from "./resume.js";
 import {
   DEFAULT_MAX_PARALLEL_TASKS,
+  RESUME_MODEL_ID,
+  RESUME_PROVIDER,
   SUBAGENT_MAX_PARALLEL_TASKS_ENV,
+  parseBoolean,
   parseNonNegativeInt,
 } from "./shared.js";
 
@@ -97,15 +101,6 @@ interface DelegationDepthConfig {
   preventCycles: boolean;
 }
 
-function parseBoolean(raw: unknown): boolean | null {
-  if (typeof raw === "boolean") return raw;
-  if (typeof raw !== "string") return null;
-  const normalized = raw.trim().toLowerCase();
-  if (["1", "true", "yes", "on"].includes(normalized)) return true;
-  if (["0", "false", "no", "off"].includes(normalized)) return false;
-  return null;
-}
-
 function parseProjectAgentConfirmationSetting(
   raw: unknown,
 ): ProjectAgentConfirmationSetting | null {
@@ -369,11 +364,9 @@ function hasCliInitialPrompt(argv: string[]): boolean {
   return false;
 }
 
-const RESUME_PROVIDER = "pi-subagent-resume";
-const RESUME_MODEL_ID = "synthetic-tool-call";
 const RESUME_STATE_KEY = "__piSubagentResumeState";
 const SUBAGENT_FALLBACK_MODEL_ENV = "PI_SUBAGENT_FALLBACK_MODEL";
-const RESUME_INTERACTIVE_DELAY_MS = 250;
+const RESUME_INTERACTIVE_DELAY_MS = 50;
 
 type SyntheticResumeState = {
   plan: ResumableSubagentCall | null;
@@ -428,15 +421,7 @@ function formatModelFlag(model: any): string | undefined {
 }
 
 function findLastNonResumeModel(ctx: any): any | undefined {
-  const entries = (() => {
-    const leafId = ctx.sessionManager?.getLeafId?.();
-    if (leafId) {
-      const branch = ctx.sessionManager?.getBranch?.(leafId);
-      if (Array.isArray(branch)) return branch;
-    }
-    const all = ctx.sessionManager?.getEntries?.();
-    return Array.isArray(all) ? all : [];
-  })();
+  const entries = branchEntries(ctx);
 
   for (let i = entries.length - 1; i >= 0; i--) {
     const entry = entries[i];
@@ -472,6 +457,7 @@ function getRestorableModel(ctx: any): any | undefined {
 export default function (pi: ExtensionAPI) {
   let resumeModelRegistry: any | undefined;
   let lastRestorableModel: any | undefined;
+  let pendingInteractiveResumePrompt: string | null = null;
 
   async function streamWithRealModelFallback(context: any, options: any, fallback: any) {
     if (!fallback) return null;
@@ -661,7 +647,27 @@ export default function (pi: ExtensionAPI) {
           `The resumed session has an unfinished subagent call (${plan.tasks.length} task${plan.tasks.length === 1 ? "" : "s"}). Resume it from saved subagent sessions?`,
         );
       }
-      if (!shouldResume) return;
+      if (!shouldResume) {
+        if (ctx.model?.provider === RESUME_PROVIDER) {
+          if (restorableModel) {
+            await pi.setModel(restorableModel);
+          } else {
+            ctx.ui.notify(
+              `Subagent resume was declined, but the current model is the synthetic resume model and no real fallback model is available. Select a real model before continuing, or set ${SUBAGENT_FALLBACK_MODEL_ENV}=provider/model.`,
+              "error",
+            );
+          }
+        }
+        return;
+      }
+
+      if (!restorableModel && ctx.model?.provider === RESUME_PROVIDER) {
+        ctx.ui.notify(
+          `Cannot resume subagents while on the synthetic resume model because no real fallback model is available. Select a real model or set ${SUBAGENT_FALLBACK_MODEL_ENV}=provider/model.`,
+          "error",
+        );
+        return;
+      }
 
       pendingResumePlan = plan;
       const resumeState = getSyntheticResumeState();
@@ -685,20 +691,12 @@ export default function (pi: ExtensionAPI) {
       if (hasCliInitialPrompt(process.argv)) {
         if (ctx.hasUI) ctx.ui.notify(`Resuming ${plan.tasks.length} subagents...`, "info");
       } else {
-        // Do not start the synthetic resume turn synchronously from
-        // session_start. In interactive mode Pi may still be rebuilding the
-        // resumed chat UI; if the tool starts before that finishes, later
-        // renderSessionContext() can clear the live pending tool component and
-        // all real-time tool updates disappear. A short macrotask delay lets
-        // the normal "Resumed session" render settle first.
-        setTimeout(() => {
-          try {
-            pi.sendUserMessage(`Resuming ${plan.tasks.length} subagents...`);
-          } catch (err) {
-            console.error("[pi-subagent] Failed to start deferred resume turn:", err);
-            void restoreModelAfterResumeFailure(ctx);
-          }
-        }, RESUME_INTERACTIVE_DELAY_MS);
+        // Do not start the synthetic resume turn from session_start. Pi renders
+        // the resumed chat only after session_start/resources_discover complete;
+        // starting now lets that render wipe out the live tool component, so no
+        // real-time updates appear. Queue it for resources_discover instead,
+        // which is the last extension hook before the initial chat render.
+        pendingInteractiveResumePrompt = `Resuming ${plan.tasks.length} subagents...`;
       }
     } catch (err) {
       console.error("[pi-subagent] Error in session_start:", err);
@@ -710,6 +708,20 @@ export default function (pi: ExtensionAPI) {
     await restoreModelAfterResumeFailure();
   });
 
+  pi.on("resources_discover", (_event, ctx) => {
+    const prompt = pendingInteractiveResumePrompt;
+    if (!prompt) return;
+    pendingInteractiveResumePrompt = null;
+    setTimeout(() => {
+      try {
+        pi.sendUserMessage(prompt);
+      } catch (err) {
+        console.error("[pi-subagent] Failed to start deferred resume turn:", err);
+        void restoreModelAfterResumeFailure(ctx);
+      }
+    }, RESUME_INTERACTIVE_DELAY_MS);
+  });
+
   // Inject available agents into the system prompt
   pi.on("before_agent_start", async (event) => {
     try {
@@ -940,12 +952,10 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
   }
 
   function getSessionDirForTask(toolCallId: string, index: number): string {
-    const root = currentSubagentSessionRoot || pathlessSubagentRootFallback();
-    return buildSubagentSessionDir(root, currentSessionId, toolCallId, index);
-  }
-
-  function pathlessSubagentRootFallback(): string {
-    return `${process.env.HOME ?? "."}/.pi/agent/sessions-subagents`;
+    if (!currentSubagentSessionRoot) {
+      throw new Error("Cannot create subagent session dir: subagent session root is not initialized.");
+    }
+    return buildSubagentSessionDir(currentSubagentSessionRoot, currentSessionId, toolCallId, index);
   }
 
   // -----------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
   "type": "module",
   "main": "index.ts",

package/render.ts

@@ -44,7 +44,7 @@ interface TreeCounts {
 
 interface PendingSubagentCall {
 	toolCallId: string;
-	tasks: Array<{ agent: string; task?: string }>;
+	tasks: Array<{ agent: string; task?: string; cwd?: string }>;
 }
 
 // ---------------------------------------------------------------------------
@@ -151,6 +151,7 @@ function extractPendingSubagentCalls(messages: SingleResult["messages"]): Pendin
 						.map((task: any) => ({
 							agent: task.agent,
 							task: typeof task.task === "string" ? task.task : undefined,
+							cwd: typeof task.cwd === "string" ? task.cwd : undefined,
 						}))
 				: [];
 			calls.push({
@@ -181,7 +182,7 @@ function buildNodesFromNestedResult(nested: NestedSubagentResult): TreeNode[] {
 }
 
 function subagentCallSignature(call: PendingSubagentCall): string {
-	return JSON.stringify(call.tasks.map((task) => ({ agent: task.agent, task: task.task ?? "" })));
+	return JSON.stringify(call.tasks.map((task) => ({ agent: task.agent, task: task.task ?? "", cwd: task.cwd ?? "" })));
 }
 
 function nestedResultIsHealthy(nested: NestedSubagentResult | undefined): boolean {

package/resume.ts

@@ -1,7 +1,6 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { parseBoolean } from "./shared.js";
 import { isResultError, isSubagentDetails, type SingleResult, type SubagentDetails } from "./types.js";
 
 export const SUBAGENT_RESUME_PROMPT_ENV = "PI_SUBAGENT_RESUME_PROMPT";
@@ -16,14 +15,7 @@ export interface ResumableSubagentCall {
   details?: SubagentDetails;
 }
 
-export function parseBooleanEnv(raw: unknown): boolean | null {
-  if (typeof raw === "boolean") return raw;
-  if (typeof raw !== "string") return null;
-  const normalized = raw.trim().toLowerCase();
-  if (["1", "true", "yes", "on"].includes(normalized)) return true;
-  if (["0", "false", "no", "off"].includes(normalized)) return false;
-  return null;
-}
+export const parseBooleanEnv = parseBoolean;
 
 export function getDefaultSubagentSessionRoot(ctx: ExtensionContext): string {
   const inheritedRoot = process.env[SUBAGENT_SESSION_ROOT_ENV];
@@ -33,7 +25,8 @@ export function getDefaultSubagentSessionRoot(ctx: ExtensionContext): string {
   if (typeof mainSessionDir === "string" && mainSessionDir.length > 0) {
     return path.join(path.dirname(mainSessionDir), "sessions-subagents");
   }
-  return path.join(os.homedir(), ".pi", "agent", "sessions-subagents");
+
+  throw new Error("Cannot determine subagent session root: sessionManager.getSessionDir() is unavailable.");
 }
 
 export function buildSubagentSessionDir(
@@ -47,11 +40,7 @@ export function buildSubagentSessionDir(
   return path.join(root, safeParent, safeTool, String(index));
 }
 
-export function ensureDir(dir: string): void {
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-}
-
-function branchEntries(ctx: ExtensionContext): SessionEntry[] {
+export function branchEntries(ctx: ExtensionContext): SessionEntry[] {
   const leafId = ctx.sessionManager.getLeafId?.();
   if (leafId) {
     const branch = ctx.sessionManager.getBranch?.(leafId);
@@ -87,9 +76,10 @@ function normalizeTasks(args: any): Array<{ agent: string; task: string; cwd?: s
   return tasks;
 }
 
-function hasUnfinishedResults(details: SubagentDetails | undefined): boolean {
+function hasUnfinishedResults(details: SubagentDetails | undefined, expectedTaskCount: number): boolean {
   if (!details) return true;
-  return details.results.some((result) => result.exitCode === -1 || isResultError(result));
+  if (details.results.length < expectedTaskCount) return true;
+  return details.results.slice(0, expectedTaskCount).some((result) => result.exitCode === -1 || isResultError(result));
 }
 
 function messageHasNonEmptyText(message: any): boolean {
@@ -155,7 +145,7 @@ export function findLatestResumableSubagentCall(ctx: ExtensionContext): Resumabl
   const candidates: Array<ResumableSubagentCall & { activityOrder: number }> = [];
   for (const [toolCallId, call] of calls) {
     const result = results.get(toolCallId);
-    const unfinished = !result || result.isError || hasUnfinishedResults(result.details);
+    const unfinished = !result || result.isError || hasUnfinishedResults(result.details, call.tasks.length);
     if (!unfinished) continue;
     candidates.push({
       previousToolCallId: toolCallId,
@@ -165,7 +155,7 @@ export function findLatestResumableSubagentCall(ctx: ExtensionContext): Resumabl
     });
   }
 
-  const latest = candidates.at(-1);
+  const latest = candidates.sort((a, b) => a.activityOrder - b.activityOrder).at(-1);
   if (!latest || !hasOnlyIgnorableTrailingEntries(entries, latest.activityOrder)) return null;
   return latest;
 }
@@ -174,7 +164,11 @@ export function sameTasks(
   a: Array<{ agent: string; task: string; cwd?: string }>,
   b: Array<{ agent: string; task: string; cwd?: string }>,
 ): boolean {
-  return JSON.stringify(a) === JSON.stringify(b);
+  if (a.length !== b.length) return false;
+  return a.every((task, index) => {
+    const other = b[index];
+    return task.agent === other.agent && task.task === other.task && (task.cwd ?? undefined) === (other.cwd ?? undefined);
+  });
 }
 
 export function isFinishedResult(result: SingleResult | undefined): boolean {

package/runner.ts

@@ -26,6 +26,8 @@ import {
   DEFAULT_MAX_PARALLEL_TASKS,
   DEFAULT_MAX_CONCURRENCY,
   PARALLEL_HEARTBEAT_MS,
+  RESUME_MODEL_ID,
+  RESUME_PROVIDER,
   SUBAGENT_MAX_PARALLEL_TASKS_ENV,
   SUBAGENT_MAX_CONCURRENCY_ENV,
   parseNonNegativeInt,
@@ -49,23 +51,20 @@ function isTerminalStopReason(reason: string | undefined): boolean {
   return reason !== undefined && TERMINAL_STOP_REASONS.has(reason);
 }
 
-function endedWithEmptySyntheticResume(messages: Message[]): boolean {
+function endedWithSyntheticResumeFailure(messages: Message[]): boolean {
   const lastAssistant = [...messages].reverse().find((message: any) => message?.role === "assistant") as any;
-  return (
-    lastAssistant?.provider === RESUME_PROVIDER &&
-    lastAssistant?.model === RESUME_MODEL_ID &&
-    lastAssistant?.stopReason === "stop" &&
-    Array.isArray(lastAssistant.content) &&
-    lastAssistant.content.length === 0
-  );
+  if (lastAssistant?.provider !== RESUME_PROVIDER || lastAssistant?.model !== RESUME_MODEL_ID) return false;
+  const content = Array.isArray(lastAssistant.content) ? lastAssistant.content : [];
+  const handedOffToRealModel = messages.some((message: any) => message?.role === "assistant" && message.provider !== RESUME_PROVIDER);
+  const hasToolCall = content.some((part: any) => part?.type === "toolCall");
+  return !handedOffToRealModel && !hasToolCall;
 }
 const SUBAGENT_DEPTH_ENV = "PI_SUBAGENT_DEPTH";
 const SUBAGENT_MAX_DEPTH_ENV = "PI_SUBAGENT_MAX_DEPTH";
 const SUBAGENT_STACK_ENV = "PI_SUBAGENT_STACK";
 const SUBAGENT_PREVENT_CYCLES_ENV = "PI_SUBAGENT_PREVENT_CYCLES";
 const SUBAGENT_FALLBACK_MODEL_ENV = "PI_SUBAGENT_FALLBACK_MODEL";
-const RESUME_PROVIDER = "pi-subagent-resume";
-const RESUME_MODEL_ID = "synthetic-tool-call";
+
 // PI_OFFLINE intentionally removed: setting it on child processes blocks all API
 // calls and renders subagents unable to do any LLM work. Children inherit the
 // parent's PI_OFFLINE value via process.env spread if needed.
@@ -292,6 +291,26 @@ function pushLiveLog(result: SingleResult, entry: LiveLogEntry): void {
   if (result.liveLog.length > MAX_LIVE_LOG_ENTRIES) result.liveLog.shift();
 }
 
+function messageDedupKey(message: Message): string {
+  const anyMessage = message as any;
+  if (typeof anyMessage.id === "string") return `id:${anyMessage.id}`;
+  return JSON.stringify({
+    role: anyMessage.role,
+    provider: anyMessage.provider,
+    model: anyMessage.model,
+    stopReason: anyMessage.stopReason,
+    toolCallId: anyMessage.toolCallId,
+    toolName: anyMessage.toolName,
+    content: anyMessage.content,
+    usage: anyMessage.usage,
+  });
+}
+
+function hasMessage(result: SingleResult, message: Message): boolean {
+  const key = messageDedupKey(message);
+  return result.messages.some((existing) => messageDedupKey(existing) === key);
+}
+
 export function processJsonLine(line: string, result: SingleResult): boolean {
   if (!line.trim()) return false;
 
@@ -307,6 +326,7 @@ export function processJsonLine(line: string, result: SingleResult): boolean {
 
   if (event.type === "message_end" && event.message) {
     const msg = event.message as Message;
+    if (hasMessage(result, msg)) return true;
     result.messages.push(msg);
 
     if (msg.role === "assistant") {
@@ -328,7 +348,8 @@ export function processJsonLine(line: string, result: SingleResult): boolean {
   }
 
   if (event.type === "tool_result_end" && event.message) {
-    result.messages.push(event.message as Message);
+    const msg = event.message as Message;
+    if (!hasMessage(result, msg)) result.messages.push(msg);
     return true;
   }
 
@@ -515,6 +536,27 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     };
   }
 
+  if (resumeSession && sessionDir && (!fs.existsSync(sessionDir) || !fs.statSync(sessionDir).isDirectory())) {
+    const errorMessage = `Cannot resume subagent session: session directory does not exist: ${sessionDir}`;
+    return {
+      agent: agentName,
+      agentSource: agent.source,
+      task,
+      exitCode: 1,
+      messages: initialResult?.messages ? [...initialResult.messages] : [],
+      stderr: errorMessage,
+      usage: initialResult?.usage ? { ...initialResult.usage } : emptyUsage(),
+      toolCalls: initialResult?.toolCalls ? { ...initialResult.toolCalls } : {},
+      model: initialResult?.model ?? agent.model,
+      stopReason: "error",
+      errorMessage,
+      completedTurns: initialResult?.completedTurns ?? 0,
+      turnInProgress: false,
+      liveLog: initialResult?.liveLog ? [...initialResult.liveLog] : [],
+      sessionDir,
+    };
+  }
+
   const result: SingleResult = {
     agent: agentName,
     agentSource: agent.source,
@@ -743,7 +785,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
       if (!result.stderr.trim()) result.stderr = "Subagent was aborted.";
     }
 
-    if (result.exitCode === 0 && endedWithEmptySyntheticResume(result.messages)) {
+    if (result.exitCode === 0 && endedWithSyntheticResumeFailure(result.messages)) {
       result.exitCode = 1;
       result.stopReason = "error";
       result.errorMessage = "Subagent resume failed before the real model continued.";

package/shared.ts

@@ -13,11 +13,22 @@ export const DEFAULT_MAX_CONCURRENCY = 8;
 export const PARALLEL_HEARTBEAT_MS = 1000;
 export const SUBAGENT_MAX_PARALLEL_TASKS_ENV = "PI_SUBAGENT_MAX_PARALLEL_TASKS";
 export const SUBAGENT_MAX_CONCURRENCY_ENV = "PI_SUBAGENT_MAX_CONCURRENCY";
+export const RESUME_PROVIDER = "pi-subagent-resume";
+export const RESUME_MODEL_ID = "synthetic-tool-call";
 
 // ---------------------------------------------------------------------------
 // Shared helpers
 // ---------------------------------------------------------------------------
 
+export function parseBoolean(raw: unknown): boolean | null {
+	if (typeof raw === "boolean") return raw;
+	if (typeof raw !== "string") return null;
+	const normalized = raw.trim().toLowerCase();
+	if (["1", "true", "yes", "on"].includes(normalized)) return true;
+	if (["0", "false", "no", "off"].includes(normalized)) return false;
+	return null;
+}
+
 /** Parse a string into a non-negative safe integer, or null on failure. */
 export function parseNonNegativeInt(raw: unknown): number | null {
 	if (typeof raw !== "string") return null;