oira666_pi-subagent 0.2.11 → 0.2.13

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,8 +364,6 @@ 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 = 50;
@@ -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];
@@ -662,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();
@@ -947,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.11",
+  "version": "0.2.13",
   "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,40 @@ 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);
+}
+
+function resultHasStarted(result: SingleResult | undefined): boolean {
+  if (!result) return false;
+  return result.messages.length > 0 || result.completedTurns > 0 || result.liveLog.length > 0 || Object.keys(result.toolCalls).length > 0;
+}
+
+function sessionDirExists(dir: string | undefined): boolean {
+  if (!dir) return false;
+  try {
+    return fs.existsSync(dir) && fs.statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
 export function processJsonLine(line: string, result: SingleResult): boolean {
   if (!line.trim()) return false;
 
@@ -307,6 +340,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 +362,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 +550,31 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     };
   }
 
+  let shouldContinueSession = resumeSession;
+  if (resumeSession && sessionDir && !sessionDirExists(sessionDir)) {
+    if (resultHasStarted(initialResult)) {
+      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,
+      };
+    }
+    shouldContinueSession = false;
+  }
+
   const result: SingleResult = {
     agent: agentName,
     agentSource: agent.source,
@@ -561,7 +621,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
       promptTmpPath,
       task,
       sessionDir,
-      resumeSession,
+      shouldContinueSession,
       fallbackModel,
     );
     let wasAborted = false;
@@ -743,7 +803,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.";
@@ -841,7 +901,6 @@ export async function executeParallelSubprocess(
     completedTurns: 0,
     turnInProgress: false,
     liveLog: [],
-    sessionDir: getSessionDir?.(index, t),
   }));
 
   const emitProgress = () => {
@@ -876,7 +935,12 @@ export async function executeParallelSubprocess(
         emitProgress();
         return previousResult;
       }
-      const sessionDir = previousResult?.sessionDir ?? getSessionDir?.(index, t);
+      const savedSessionDir = previousResult?.sessionDir;
+      const savedSessionDirExists = sessionDirExists(savedSessionDir);
+      const shouldResumeThisSession = resumeExistingSessions && (!previousResult || !savedSessionDir || savedSessionDirExists);
+      const sessionDir = shouldResumeThisSession && savedSessionDirExists
+        ? savedSessionDir
+        : getSessionDir?.(index, t);
       const result = await runAgentSubprocess({
         cwd: defaultCwd,
         agents,
@@ -890,7 +954,7 @@ export async function executeParallelSubprocess(
         signal,
         sessionDir,
         sessionRoot,
-        resumeSession: resumeExistingSessions && !!sessionDir,
+        resumeSession: shouldResumeThisSession && !!sessionDir,
         initialResult: previousResult,
         fallbackModel,
         onUpdate: (partial) => {

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;