oira666_pi-subagent 0.2.16 → 0.2.18

package/index.ts

@@ -457,6 +457,7 @@ function getRestorableModel(ctx: any): any | undefined {
 export default function (pi: ExtensionAPI) {
   let resumeModelRegistry: any | undefined;
   let lastRestorableModel: any | undefined;
+  let latestSessionCtx: any | undefined;
   let pendingInteractiveResumePrompt: string | null = null;
 
   async function streamWithRealModelFallback(context: any, options: any, fallback: any) {
@@ -474,6 +475,20 @@ export default function (pi: ExtensionAPI) {
     });
   }
 
+  async function restoreVisibleModelForResume(): Promise<any | undefined> {
+    const restore = modelToRestoreAfterResume ?? lastRestorableModel;
+    if (!restore) return undefined;
+    lastRestorableModel = restore;
+    if (latestSessionCtx?.model?.provider === RESUME_PROVIDER) {
+      try {
+        await pi.setModel(restore);
+      } catch (err) {
+        console.error("[pi-subagent] Failed to restore real model during resume:", err);
+      }
+    }
+    return restore;
+  }
+
   pi.registerFlag("subagent-max-depth", {
     description: "Maximum allowed subagent delegation depth (default: 3).",
     type: "string",
@@ -491,7 +506,12 @@ export default function (pi: ExtensionAPI) {
     streamSimple: async (model, context, options) => {
       const stream = createAssistantMessageEventStream();
       const state = getSyntheticResumeState();
-      const plan = state.plan;
+      const discoveredPlan = state.plan ?? pendingResumePlan ?? (latestSessionCtx ? findLatestResumableSubagentCall(latestSessionCtx) : null);
+      if (discoveredPlan && !state.plan) {
+        state.plan = discoveredPlan;
+        pendingResumePlan = discoveredPlan;
+      }
+      const plan = discoveredPlan;
       const phase = state.phase;
       const triggerMatches =
         state.trigger === "nextRequest" ||
@@ -524,12 +544,14 @@ export default function (pi: ExtensionAPI) {
         return stream;
       }
 
-      if (phase === "final" && modelToRestoreAfterResume) {
-        const delegated = await streamWithRealModelFallback(context, options, modelToRestoreAfterResume);
+      if (phase === "final") {
+        const restore = await restoreVisibleModelForResume();
+        const delegated = await streamWithRealModelFallback(context, options, restore);
         if (delegated) return delegated;
       }
 
-      const fallback = await streamWithRealModelFallback(context, options, lastRestorableModel);
+      const restore = await restoreVisibleModelForResume();
+      const fallback = await streamWithRealModelFallback(context, options, restore ?? lastRestorableModel);
       if (fallback) return fallback;
 
       if (!(plan && phase === "tool")) {
@@ -603,6 +625,7 @@ export default function (pi: ExtensionAPI) {
 
   // Auto-discover agents on session start
   pi.on("session_start", async (event, ctx) => {
+    latestSessionCtx = ctx;
     try {
       // Always repair sessions left on the synthetic resume model, even in
       // nested subagents that can no longer delegate. Those leaf processes
@@ -917,7 +940,11 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
               resumePlan?.details?.results[0],
               getSessionDirForTask(resumePlan?.previousToolCallId ?? toolCallId, 0),
               !!resumePlan,
-              formatModelFlag(modelToRestoreAfterResume),
+              // Prefer the pre-resume model (during resume) or the current
+              // active model (normal runs). This prevents children from
+              // defaulting to whatever settings.json says at spawn time, which
+              // can change while the parent session is long-running.
+              formatModelFlag(modelToRestoreAfterResume ?? lastRestorableModel),
             );
           }
 
@@ -931,7 +958,7 @@ This guard prevents self-recursion and cyclic handoffs (for example A -> B -> A)
             resumePlan?.details?.results,
             (index) => getSessionDirForTask(resumePlan?.previousToolCallId ?? toolCallId, index),
             !!resumePlan,
-            formatModelFlag(modelToRestoreAfterResume),
+            formatModelFlag(modelToRestoreAfterResume ?? lastRestorableModel),
           );
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);

package/package.json

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

package/resume.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import { parseBoolean } from "./shared.js";
+import { parseBoolean, RESUME_PROVIDER } from "./shared.js";
 import { isResultError, isSubagentDetails, type SingleResult, type SubagentDetails } from "./types.js";
 
 export const SUBAGENT_RESUME_PROMPT_ENV = "PI_SUBAGENT_RESUME_PROMPT";
@@ -82,11 +82,17 @@ function hasUnfinishedResults(details: SubagentDetails | undefined, expectedTask
   return details.results.slice(0, expectedTaskCount).some((result) => result.exitCode === -1 || isResultError(result));
 }
 
-function messageHasNonEmptyText(message: any): boolean {
+function getMessageText(message: any): string {
   const content = message?.content;
-  if (typeof content === "string") return content.trim().length > 0;
-  if (!Array.isArray(content)) return false;
-  return content.some((part) => part?.type === "text" && typeof part.text === "string" && part.text.trim().length > 0);
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((part) => (part?.type === "text" && typeof part.text === "string" ? part.text : ""))
+    .join("");
+}
+
+function messageHasNonEmptyText(message: any): boolean {
+  return getMessageText(message).trim().length > 0;
 }
 
 function messageHasToolCall(message: any): boolean {
@@ -114,9 +120,55 @@ function isIgnorableTrailingAbortMessage(entry: any): boolean {
   return false;
 }
 
+function isResumePromptEntry(entry: any): boolean {
+  if (entry?.type !== "message") return false;
+  const message = entry.message;
+  if (message?.role !== "user") return false;
+  return /^Resuming \d+ subagents\.\.\.$/.test(getMessageText(message).trim());
+}
+
+function isSyntheticResumeModelChange(entry: any): boolean {
+  return entry?.type === "model_change" && entry.provider === RESUME_PROVIDER;
+}
+
+function isFailedResumeAttemptTail(entries: SessionEntry[], start: number): boolean {
+  if (start >= entries.length) return true;
+
+  let sawSyntheticModel = false;
+  let sawResumePrompt = false;
+  let sawFailure = false;
+
+  for (let i = start; i < entries.length; i++) {
+    const entry: any = entries[i];
+
+    if (isSyntheticResumeModelChange(entry)) {
+      sawSyntheticModel = true;
+      continue;
+    }
+
+    if (entry?.type === "thinking_level_change") continue;
+
+    if (isResumePromptEntry(entry)) {
+      if (!sawSyntheticModel) return false;
+      sawResumePrompt = true;
+      continue;
+    }
+
+    if (isIgnorableTrailingAbortMessage(entry)) {
+      if (entry?.type === "message" && sawResumePrompt) sawFailure = true;
+      continue;
+    }
+
+    return false;
+  }
+
+  return sawSyntheticModel && sawResumePrompt && sawFailure;
+}
+
 function hasOnlyIgnorableTrailingEntries(entries: SessionEntry[], activityOrder: number): boolean {
-  for (let i = activityOrder + 1; i < entries.length; i++) {
-    if (!isIgnorableTrailingAbortMessage(entries[i])) return false;
+  const start = activityOrder + 1;
+  for (let i = start; i < entries.length; i++) {
+    if (!isIgnorableTrailingAbortMessage(entries[i])) return isFailedResumeAttemptTail(entries, start);
   }
   return true;
 }

package/runner.ts

@@ -38,6 +38,8 @@ const SIGKILL_TIMEOUT_MS = 5000;
 const HANG_GUARD_DELAY_MS = 5000;
 const DEFAULT_STARTUP_TIMEOUT_MS = 120_000; // only for startup (before first assistant turn)
 const SUBAGENT_STARTUP_TIMEOUT_ENV = "PI_SUBAGENT_STARTUP_TIMEOUT";
+const SUBAGENT_PI_COMMAND_ENV = "PI_SUBAGENT_PI_COMMAND";
+const SUBAGENT_PI_ARGS_PREFIX_ENV = "PI_SUBAGENT_PI_ARGS_PREFIX";
 
 /**
  * Stop reasons that indicate the agent has truly finished its work.
@@ -110,6 +112,53 @@ function getCurrentPiCliScript(): string | null {
   return script;
 }
 
+function findPiCliScriptOnPath(): string | null {
+  const pathEnv = process.env.PATH ?? "";
+  for (const dir of pathEnv.split(path.delimiter)) {
+    if (!dir) continue;
+    for (const shimName of process.platform === "win32" ? ["pi.cmd", "pi"] : ["pi"]) {
+      const shimPath = path.join(dir, shimName);
+      if (!fs.existsSync(shimPath)) continue;
+      let text = "";
+      try {
+        text = fs.readFileSync(shimPath, "utf8");
+      } catch {
+        continue;
+      }
+      const match = text.match(/node_modules[\\/]([^\s"']*pi-coding-agent)[\\/]dist[\\/]cli\.js/);
+      if (!match) continue;
+      const cliPath = path.join(dir, "node_modules", match[1], "dist", "cli.js");
+      if (fs.existsSync(cliPath)) return cliPath;
+    }
+  }
+  return null;
+}
+
+function getPiSpawnCommand(override?: { command: string; argsPrefix?: string[] }): { command: string; argsPrefix: string[] } {
+  if (override?.command) return { command: override.command, argsPrefix: override.argsPrefix ?? [] };
+
+  const overrideCommand = process.env[SUBAGENT_PI_COMMAND_ENV];
+  if (overrideCommand) {
+    let argsPrefix: string[] = [];
+    const rawPrefix = process.env[SUBAGENT_PI_ARGS_PREFIX_ENV];
+    if (rawPrefix) {
+      try {
+        const parsed = JSON.parse(rawPrefix);
+        if (Array.isArray(parsed) && parsed.every((value) => typeof value === "string")) {
+          argsPrefix = parsed;
+        }
+      } catch {
+        // Ignore invalid test/debug override and run the command without a prefix.
+      }
+    }
+    return { command: overrideCommand, argsPrefix };
+  }
+
+  const cliScript = getCurrentPiCliScript() ?? findPiCliScriptOnPath();
+  if (cliScript) return { command: process.execPath, argsPrefix: [cliScript] };
+  return { command: "pi", argsPrefix: [] };
+}
+
 function resolveExtensionArg(value: string): string {
   if (!value) return value;
   if (value.startsWith("npm:") || value.startsWith("git:")) return value;
@@ -498,6 +547,10 @@ export interface RunAgentOptions {
   initialResult?: SingleResult;
   /** Fallback model to use when the agent config does not pin one. */
   fallbackModel?: string;
+  /** Test/debug override for the spawned pi executable. */
+  piCommandOverride?: { command: string; argsPrefix?: string[] };
+  /** Test/debug override for startup timeout. */
+  startupTimeoutMsOverride?: number;
 }
 
 /**
@@ -524,6 +577,8 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     resumeSession = false,
     initialResult,
     fallbackModel,
+    piCommandOverride,
+    startupTimeoutMsOverride,
   } = opts;
 
   const agent = agents.find((a) => a.name === agentName);
@@ -606,9 +661,9 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
       // but shell:true splits arguments on whitespace — breaking task strings.
       // Fix: reuse the running node binary + the pi CLI script path directly,
       // so the child is spawned without a shell and args are passed safely.
-      const currentPiCli = getCurrentPiCliScript();
-      const spawnCmd = currentPiCli ? process.execPath : "pi";
-      const spawnArgs = currentPiCli ? [currentPiCli, ...piArgs] : piArgs;
+      const piSpawn = getPiSpawnCommand(piCommandOverride);
+      const spawnCmd = piSpawn.command;
+      const spawnArgs = [...piSpawn.argsPrefix, ...piArgs];
       const proc = spawn(spawnCmd, spawnArgs, {
         cwd: taskCwd ?? cwd,
         shell: false,
@@ -636,6 +691,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
       // disabled — from that point, tool calls can run for as long as they
       // need, and only the terminal-stopReason hang guard applies.
       const startupTimeoutMs = (() => {
+        if (startupTimeoutMsOverride !== undefined) return startupTimeoutMsOverride;
         const raw = process.env[SUBAGENT_STARTUP_TIMEOUT_ENV];
         if (raw === undefined) return DEFAULT_STARTUP_TIMEOUT_MS;
         const parsed = parseNonNegativeInt(raw);