pi-subagents 0.81.0 → 0.82.0

package/bundle/{chunk-BPS2AGBZ.js → chunk-W2SZ22EM.js}

@@ -11,7 +11,7 @@ import {
   projectTimeoutRecovery,
   readAsyncRecoveryDescriptor,
   utf8Tail
-} from "./chunk-NNLASTQE.js";
+} from "./chunk-VH5OAWVG.js";
 import {
   MAX_ARGS_BYTES,
   MAX_ARGS_DEPTH,
@@ -24,13 +24,13 @@ import {
   resultFilePath,
   resultPayloadMatchesSessionRun,
   resultPayloadPathForSessionRun
-} from "./chunk-VJHOELQP.js";
+} from "./chunk-NRQ75MGH.js";
 import {
   shouldUseNativeFsWatch
 } from "./chunk-NIXWDZZV.js";
 import {
   PROJECT_SUBAGENTS_RELATIVE_DIR
-} from "./chunk-3DC5KBVP.js";
+} from "./chunk-5TYMSZX3.js";
 import {
   listBackgroundWorkWakeChannels,
   snapshotBackgroundWork
@@ -55,7 +55,7 @@ import {
   withSettingsFileLease,
   writeAtomicJson,
   writePrivateAtomicJson
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   ASYNC_DIR,
   DIRS,
@@ -213,6 +213,7 @@ async function waitForReply(channelDir, requestId, initialDeadline, signal) {
     if (fs.existsSync(file)) {
       const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
       if (parsed.type === "subagent.supervisor.reply" && parsed.requestId === requestId && typeof parsed.message === "string") {
+        if (typeof parsed.error === "string") throw new Error(parsed.error);
         return parsed;
       }
     }
@@ -748,6 +749,24 @@ function createNativeSupervisorChannel(pi, state, deps = {}) {
         cleanupRequestLifecycle(request, lifecycle);
         continue;
       }
+      if (request.expectsReply && runState(request).blockingWorkflowChildren?.has(request.runId)) {
+        try {
+          writePrivateAtomicJson(replyPath(channelDir, request.id), {
+            type: "subagent.supervisor.reply",
+            requestId: request.id,
+            createdAt: now,
+            message: "",
+            error: "Supervisor unavailable: the parent is blocked in an async:false workflow and cannot answer this request. Report the blocker and any partial results, then stop. Relaunch the workflow with async:true to allow supervisor replies."
+          });
+        } catch (error) {
+          console.error(`Failed to report unreachable supervisor request ${request.id}; will retry:`, error);
+          continue;
+        }
+        seenFiles.add(file);
+        observeRequestLifecycle(request, "resolved");
+        cleanupRequestLifecycle(request, "resolved");
+        continue;
+      }
       seenFiles.add(file);
       if (!request.expectsReply) {
         removeRequestFile(request.requestFile);
@@ -1037,14 +1056,34 @@ function createNativeSupervisorChannel(pi, state, deps = {}) {
 }
 
 // src/shared/session-identity.ts
+import * as fs2 from "node:fs";
 function resolveCurrentSessionId(sessionManager) {
   const sessionId = sessionManager.getSessionFile() ?? sessionManager.getSessionId();
   if (!sessionId) throw new Error("Current session identity is unavailable.");
   return sessionId;
 }
+function resolvePiSessionId(sessionFile) {
+  if (!sessionFile) return void 0;
+  try {
+    const fd = fs2.openSync(sessionFile, "r");
+    try {
+      const buffer = Buffer.alloc(16 * 1024);
+      const bytes = fs2.readSync(fd, buffer, 0, buffer.length, 0);
+      const line = buffer.toString("utf-8", 0, bytes).split("\n", 1)[0];
+      if (!line) return void 0;
+      const header = JSON.parse(line);
+      if (header.type === "session" && typeof header.id === "string" && /^[A-Za-z0-9-]{8,}$/.test(header.id)) return header.id;
+      return void 0;
+    } finally {
+      fs2.closeSync(fd);
+    }
+  } catch {
+    return void 0;
+  }
+}
 
 // src/watchdog/settings.ts
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 import * as path2 from "node:path";
 var DEFAULT_WATCHDOG_CONFIG = {
   enabled: false,
@@ -1294,10 +1333,10 @@ function parseSettingsObject(settings, meta) {
   return parseWatchdogPatch(subagents.watchdog, "subagents.watchdog", meta);
 }
 function readSettingsFileStrict(filePath) {
-  if (!fs2.existsSync(filePath)) return {};
+  if (!fs3.existsSync(filePath)) return {};
   let raw;
   try {
-    raw = fs2.readFileSync(filePath, "utf-8");
+    raw = fs3.readFileSync(filePath, "utf-8");
   } catch (error) {
     const message2 = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to read settings file '${filePath}': ${message2}`, { cause: error });
@@ -1316,7 +1355,7 @@ function readSettingsFileStrict(filePath) {
 }
 function isDirectory(dir) {
   try {
-    return fs2.statSync(dir).isDirectory();
+    return fs3.statSync(dir).isDirectory();
   } catch {
     return false;
   }
@@ -1383,8 +1422,8 @@ function targetSettingsObject(watchdog, target, meta) {
   return ensureObjectField(overrides, target.agent.trim(), `subagents.watchdog.children.overrides.${target.agent.trim()}`, meta);
 }
 function writeSettingsFile(settingsPath, settings) {
-  fs2.mkdirSync(path2.dirname(settingsPath), { recursive: true });
-  fs2.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs3.mkdirSync(path2.dirname(settingsPath), { recursive: true });
+  fs3.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `, "utf-8");
   return settingsPath;
 }
@@ -1423,7 +1462,7 @@ function resolveWatchdogConfig(cwd2, options = {}) {
   ];
   for (const source of sourceSpecs) {
     if (!source.path) continue;
-    sources.push({ scope: source.scope, path: source.path, exists: fs2.existsSync(source.path) });
+    sources.push({ scope: source.scope, path: source.path, exists: fs3.existsSync(source.path) });
     try {
       patch = deepMerge(patch, parseSourceFile(source.path, source.scope));
     } catch (error) {
@@ -1747,7 +1786,7 @@ var SubagentParamProperties = {
     description: "true: run the one ```js workflow block written in this same reply (false invalid). String with '/': script file read from request cwd. Other string: named workflow resource. Raw scripts (true or path) have no runs.host."
   })),
   args: Type2.Optional(Type2.Unsafe({ type: "object", maxProperties: MAX_ARGS_FIELDS, additionalProperties: true, description: `Plain-JSON args for workflow; ${MAX_ARGS_FIELDS} fields/object, ${MAX_ARGS_ITEMS} items/array, depth ${MAX_ARGS_DEPTH}, ${MAX_ARGS_BYTES / 1024} KiB total; raw-script args are exposed deeply frozen and persisted, so do not include secrets.` })),
-  reuseFrom: Type2.Optional(Type2.String({ minLength: 1, description: "Exact id of a workflow run stopped by a session handoff or reload; this async workflow reuses its finished children and re-attaches to its running ones." })),
+  reuseFrom: Type2.Optional(Type2.String({ minLength: 1, description: "Exact id of a workflow run ended by a reload, handoff or Pi exit; this async workflow reuses its finished children and re-attaches to its running ones." })),
   globalConcurrencyLimit: Type2.Optional(Type2.Integer({ minimum: 1 })),
   maxSubagentSpawnsPerRun: Type2.Optional(Type2.Integer({ minimum: 1 })),
   preflight: Type2.Optional(WorkflowPreflightOverride),
@@ -1769,7 +1808,7 @@ var SubagentParamProperties = {
   usageBudget: Type2.Optional(UsageBudgetOverride),
   agentScope: Type2.Optional(Type2.String({ description: "user/project/both (default); project wins collisions." })),
   cwd: Type2.Optional(Type2.String({ description: "Execution/project-pane directory." })),
-  machine: Type2.Optional(Type2.String({ minLength: 1, maxLength: 128, description: "Herdr saved machine id or label; runs an external CLI agent there. cwd then means the directory on that machine." })),
+  machine: Type2.Optional(Type2.String({ minLength: 1, maxLength: 128, description: 'Herdr saved machine id or label (runs an external CLI agent), a Rex host named in settings (runs a Pi child), or "local" (a Pi child in a Rex pane here). On another machine, cwd is a directory there.' })),
   artifacts: Type2.Optional(Type2.Boolean({ description: "Debug artifacts; default true." })),
   includeProgress: Type2.Optional(Type2.Boolean({ description: "Full result progress; default false." })),
   share: Type2.Optional(Type2.Boolean({ description: "Upload session to GitHub Gist; default false." })),
@@ -1851,7 +1890,7 @@ var SubagentWaitParamsSchema = Type2.Object({
   nonBlocking: Type2.Optional(Type2.Boolean({ description: "Subscribe to id's wake and return immediately; requires id, not with all." })),
   all: Type2.Optional(Type2.Boolean({ description: "Wait for all work active at call time." })),
   timeoutMs: Type2.Optional(Type2.Integer({ minimum: 1, description: "Max wait; default waitTool.defaultTimeoutMs, then 30 min." })),
-  stopOnAttention: Type2.Optional(Type2.Boolean({ description: "false: keep waiting through idle or long-thinking attention." }))
+  stopOnAttention: Type2.Optional(Type2.Boolean({ description: "false: keep waiting through all attention except supervisor requests." }))
 });
 var SubagentWaitParams = keepTopLevelParameterDescriptions(SubagentWaitParamsSchema);
 
@@ -1896,14 +1935,14 @@ function resolveWaitToolConfig(config, env = process.env) {
 }
 
 // src/runs/background/subagent-wait.ts
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import * as path4 from "node:path";
 
 // src/runs/background/wait-completions.ts
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 
 // src/runs/background/completion-replay.ts
-import * as fs3 from "node:fs";
+import * as fs4 from "node:fs";
 import * as path3 from "node:path";
 var REPLAY_VERSION = 1;
 var ARCHIVE_VERSION = 1;
@@ -1928,7 +1967,7 @@ function existingFile(value) {
   const filePath = nonEmptyString(value);
   if (!filePath) return void 0;
   try {
-    return fs3.statSync(filePath).isFile() ? filePath : void 0;
+    return fs4.statSync(filePath).isFile() ? filePath : void 0;
   } catch {
     return void 0;
   }
@@ -2013,7 +2052,7 @@ function runIdFromReplayFile(file) {
 }
 function removeBestEffort(filePath) {
   try {
-    fs3.rmSync(filePath, { force: true });
+    fs4.rmSync(filePath, { force: true });
   } catch {
   }
 }
@@ -2056,7 +2095,7 @@ function readCompletionReplay(resultsDir, runId, options = {}) {
   const replayPath = completionReplayPath(resultsDir, runId);
   let parsed;
   try {
-    parsed = parseReplay(JSON.parse(fs3.readFileSync(replayPath, "utf-8")));
+    parsed = parseReplay(JSON.parse(fs4.readFileSync(replayPath, "utf-8")));
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw error;
@@ -2078,7 +2117,7 @@ function readCompletionReplay(resultsDir, runId, options = {}) {
 }
 function readCompletionArchive(archivePath) {
   try {
-    const archive = parseArchive(JSON.parse(fs3.readFileSync(archivePath, "utf-8")));
+    const archive = parseArchive(JSON.parse(fs4.readFileSync(archivePath, "utf-8")));
     if (!archive) throw new Error("Completion archive is malformed.");
     return archive;
   } catch (error) {
@@ -2096,20 +2135,20 @@ function cleanupCompletionReplayIfDue(resultsDir, now, maxAgeMs, intervalMs = CL
 function cleanupCompletionReplay(resultsDir, now, maxAgeMs) {
   const replayDir = path3.join(resultsDir, REPLAY_DIR_NAME);
   try {
-    for (const file of fs3.readdirSync(replayDir)) {
+    for (const file of fs4.readdirSync(replayDir)) {
       const runId = runIdFromReplayFile(file);
       if (!runId) continue;
       const filePath = path3.join(replayDir, file);
       try {
-        const record = parseReplay(JSON.parse(fs3.readFileSync(filePath, "utf-8")));
+        const record = parseReplay(JSON.parse(fs4.readFileSync(filePath, "utf-8")));
         const safeRecord = record ? validateReplayRecord(resultsDir, runId, record) : void 0;
         if (record && !safeRecord) {
-          fs3.rmSync(filePath, { force: true });
+          fs4.rmSync(filePath, { force: true });
         } else if (safeRecord && safeRecord.expiresAt <= now) {
-          fs3.rmSync(filePath, { force: true });
-          fs3.rmSync(safeRecord.archivePath, { force: true });
-        } else if (!record && now - fs3.statSync(filePath).mtimeMs > maxAgeMs) {
-          fs3.rmSync(filePath, { force: true });
+          fs4.rmSync(filePath, { force: true });
+          fs4.rmSync(safeRecord.archivePath, { force: true });
+        } else if (!record && now - fs4.statSync(filePath).mtimeMs > maxAgeMs) {
+          fs4.rmSync(filePath, { force: true });
         }
       } catch {
       }
@@ -2118,10 +2157,10 @@ function cleanupCompletionReplay(resultsDir, now, maxAgeMs) {
   }
   const archiveDir = path3.join(resultsDir, ARCHIVE_DIR_NAME);
   try {
-    for (const file of fs3.readdirSync(archiveDir)) {
+    for (const file of fs4.readdirSync(archiveDir)) {
       const filePath = path3.join(archiveDir, file);
       try {
-        if (now - fs3.statSync(filePath).mtimeMs > maxAgeMs) fs3.rmSync(filePath, { force: true });
+        if (now - fs4.statSync(filePath).mtimeMs > maxAgeMs) fs4.rmSync(filePath, { force: true });
       } catch {
       }
     }
@@ -2173,7 +2212,7 @@ function waitResultPayloadCandidate(resultsDir, run) {
 }
 function readWaitResultPayload(candidatePath, run) {
   if (!run.sessionId) return void 0;
-  const payload = JSON.parse(fs4.readFileSync(candidatePath, "utf-8"));
+  const payload = JSON.parse(fs5.readFileSync(candidatePath, "utf-8"));
   if (!resultPayloadMatchesSessionRun(payload, run.sessionId, run.id)) return void 0;
   return payload;
 }
@@ -2333,7 +2372,7 @@ function collectWaitCompletions(terminal, state, resultsDir, onReference) {
 }
 
 // src/runs/background/resume-guidance.ts
-import * as fs5 from "node:fs";
+import * as fs6 from "node:fs";
 var INTERCOM_DETACH_ERROR = "detached for intercom coordination";
 function isIntercomDetached(run) {
   return run.steps.some((step) => step.execution?.status === "detached" || errorWithoutReplyText(step.error)?.toLowerCase().includes(INTERCOM_DETACH_ERROR) === true) || errorWithoutReplyText(run.error)?.toLowerCase().includes(INTERCOM_DETACH_ERROR) === true;
@@ -2345,7 +2384,7 @@ function formatIntercomDetachGuidance(run) {
 function formatAsyncReviveCommand(run) {
   const step = run.steps.find((candidate) => candidate.status === "failed");
   const sessionFile = step?.sessionFile ?? (run.steps.length === 1 ? run.sessionFile : void 0);
-  if (!step || !sessionFile || !fs5.existsSync(sessionFile)) return void 0;
+  if (!step || !sessionFile || !fs6.existsSync(sessionFile)) return void 0;
   try {
     const descriptor = readAsyncRecoveryDescriptor(run.asyncDir);
     if (!descriptor || descriptor.sourceRunId !== run.id || descriptor.agent !== step.agent) return void 0;
@@ -2670,13 +2709,13 @@ function readTranscriptActivity(transcriptPath) {
   if (!transcriptPath) return void 0;
   let fd;
   try {
-    const stat = fs6.statSync(transcriptPath);
+    const stat = fs7.statSync(transcriptPath);
     if (!stat.isFile() || stat.size <= 0) return void 0;
     const start = Math.max(0, stat.size - TRANSCRIPT_TAIL_BYTES);
     const length = stat.size - start;
     const buffer = Buffer.allocUnsafe(length);
-    fd = fs6.openSync(transcriptPath, "r");
-    const bytesRead = fs6.readSync(fd, buffer, 0, length, start);
+    fd = fs7.openSync(transcriptPath, "r");
+    const bytesRead = fs7.readSync(fd, buffer, 0, length, start);
     let lines = buffer.subarray(0, bytesRead).toString("utf-8").split(/\r?\n/);
     if (start > 0) lines = lines.slice(1);
     let currentTool;
@@ -2721,7 +2760,7 @@ function readTranscriptActivity(transcriptPath) {
   } finally {
     if (fd !== void 0) {
       try {
-        fs6.closeSync(fd);
+        fs7.closeSync(fd);
       } catch {
       }
     }
@@ -2974,7 +3013,8 @@ ${references2.join("\n")}` : ""}`,
   }
   const relevantAttention = attention.filter((run) => initialAsyncIds.has(run.id));
   const supervisorAttentionHint = relevantAttention.some(hasSupervisorTool) ? ' Reply to any pending supervisor request. If subagent_supervisor({ action: "pending" }) is empty, check intercom({ action: "pending" }) because an external intercom tool may own the request.' : "";
-  const attentionNote = relevantAttention.length > 0 ? ` ${relevantAttention.length} run(s) need attention: ${relevantAttention.map((run) => run.id).join(", ")} \u2014${supervisorAttentionHint} inspect with subagent({ action: "status" }) then steer a top-level live async child, resume a paused/completed/failed child, or interrupt explicitly.` : "";
+  const keepWaitingHint = stopOnAttention && supervisorAttentionHint === "" && (waitForAll || finishedAsyncCount + providerFinishedCount === 0) ? " These runs are still running and none is waiting on a supervisor reply. To keep waiting through this kind of attention, call bg_wait again with stopOnAttention: false; supervisor requests still end that wait." : "";
+  const attentionNote = relevantAttention.length > 0 ? ` ${relevantAttention.length} run(s) need attention: ${relevantAttention.map((run) => run.id).join(", ")} \u2014${supervisorAttentionHint} inspect with subagent({ action: "status" }) then steer a top-level live async child, resume a paused/completed/failed child, or interrupt explicitly.${keepWaitingHint}` : "";
   const stillRunning = active.filter((run) => initialAsyncIds.has(run.id)).length + providerActive.filter((item) => initialProviderIds.has(backgroundWorkIdentity(item))).length;
   const elapsed = formatDuration(now() - startedAt);
   const outcome = terminalSummary ? ` Outcome: ${terminalSummary}.` : "";
@@ -3368,7 +3408,7 @@ import { createHash as createHash3 } from "node:crypto";
 // src/watchdog/change-signature.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { createHash } from "node:crypto";
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as os from "node:os";
 import * as path6 from "node:path";
 var IGNORED_CHANGE_PREFIXES = [`${PROJECT_SUBAGENTS_RELATIVE_DIR}/`, "tmp/", "node_modules/"];
@@ -3399,7 +3439,7 @@ function git(cwd2, args2) {
 function comparablePath(value) {
   let resolved = path6.resolve(value);
   try {
-    resolved = fs7.realpathSync.native(resolved);
+    resolved = fs8.realpathSync.native(resolved);
   } catch {
   }
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
@@ -3431,7 +3471,7 @@ function useHashEntryBudget(budget) {
   return true;
 }
 function hashFile(filePath) {
-  return createHash("sha256").update(fs7.readFileSync(filePath)).digest("hex");
+  return createHash("sha256").update(fs8.readFileSync(filePath)).digest("hex");
 }
 function largeFileHash(stat) {
   return "large:" + stat.size + ":" + Math.floor(stat.mtimeMs);
@@ -3471,17 +3511,17 @@ function hashPath(root, relPath, budget) {
   const fullPath = path6.join(root, normalized);
   let stat;
   try {
-    stat = fs7.lstatSync(fullPath);
+    stat = fs8.lstatSync(fullPath);
   } catch (error) {
     if (error.code === "ENOENT") return { path: normalized, state: "deleted" };
     throw error;
   }
   if (stat.isSymbolicLink()) {
-    return { path: normalized, state: "symlink", target: fs7.readlinkSync(fullPath) };
+    return { path: normalized, state: "symlink", target: fs8.readlinkSync(fullPath) };
   }
   if (stat.isDirectory()) {
-    if (fs7.existsSync(path6.join(fullPath, ".git"))) return gitWorktreeEntry(normalized, fullPath);
-    const entries = fs7.readdirSync(fullPath).map((entry) => normalizeRelPath(path6.posix.join(normalized, entry))).filter((entry) => !ignoredRelPath(entry)).sort();
+    if (fs8.existsSync(path6.join(fullPath, ".git"))) return gitWorktreeEntry(normalized, fullPath);
+    const entries = fs8.readdirSync(fullPath).map((entry) => normalizeRelPath(path6.posix.join(normalized, entry))).filter((entry) => !ignoredRelPath(entry)).sort();
     const remainingEntries = Math.max(0, budget.maxEntries - budget.entries);
     const selectedEntries = entries.slice(0, remainingEntries);
     const childEntries = selectedEntries.map((entry) => hashPath(root, entry, budget));
@@ -3659,7 +3699,7 @@ var WatchdogEmissionGuard = class {
 // src/watchdog/lsp-diagnostics.ts
 import { spawn } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import * as fs8 from "node:fs";
+import * as fs9 from "node:fs";
 import * as path7 from "node:path";
 import { pathToFileURL } from "node:url";
 var TS_JS_EXTENSIONS = /* @__PURE__ */ new Map([
@@ -3698,10 +3738,10 @@ function severityFromLsp(value) {
 }
 function pathExecutable(filePath) {
   try {
-    const stat = fs8.statSync(filePath);
+    const stat = fs9.statSync(filePath);
     if (!stat.isFile()) return false;
     if (process.platform === "win32") return true;
-    fs8.accessSync(filePath, fs8.constants.X_OK);
+    fs9.accessSync(filePath, fs9.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -3738,7 +3778,7 @@ function collectTargetFiles(root, changedPaths, maxFiles) {
     }
     let stat;
     try {
-      stat = fs8.statSync(absPath);
+      stat = fs9.statSync(absPath);
     } catch (error) {
       if (error.code === "ENOENT") {
         skippedPaths.push(relPath);
@@ -4032,7 +4072,7 @@ async function collectWithTypeScriptLanguageServer(input) {
     await client.request("initialize", initializeParams(input.root), remaining(), input.signal);
     client.notify("initialized", {});
     for (const target of input.targets) {
-      const text = fs8.readFileSync(target.absPath, "utf-8");
+      const text = fs9.readFileSync(target.absPath, "utf-8");
       client.notify("textDocument/didOpen", {
         textDocument: { uri: target.uri, languageId: target.languageId, version: 1, text }
       });
@@ -5069,12 +5109,12 @@ import { createReadOnlyTools, convertToLlm } from "@earendil-works/pi-coding-age
 import { Type as Type4 } from "typebox";
 
 // src/watchdog/guidance.ts
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as path8 from "node:path";
 var WATCHDOG_GUIDANCE_MAX_CHARS = 8e3;
 function readOptional(filePath) {
   try {
-    return fs9.readFileSync(filePath, "utf-8").trim();
+    return fs10.readFileSync(filePath, "utf-8").trim();
   } catch {
     return "";
   }
@@ -5381,6 +5421,7 @@ export {
   registerNativeSupervisorClient,
   createNativeSupervisorChannel,
   resolveCurrentSessionId,
+  resolvePiSessionId,
   WATCHDOG_DIFF_TOOL_NAME,
   captureWatchdogDiffBaseline,
   startWatchdogDiffBaselineCapture,