pi-subagents 0.81.0 → 0.82.1

package/bundle/{chunk-V3BIUPLU.js → chunk-IVAE5Z6Q.js}

@@ -10,10 +10,10 @@ import {
   setInlineWorkflowCoverage,
   setMainThinkingLevelSource,
   widgetRenderKey
-} from "./chunk-2ZSNH26H.js";
+} from "./chunk-4Y2ROR7L.js";
 import {
   package_default
-} from "./chunk-2XYWN7QJ.js";
+} from "./chunk-UTT254JE.js";
 import {
   EXTERNAL_JOB_BRIDGE_REQUEST_DIR,
   REVIVAL_ORIGIN_FILE,
@@ -36,25 +36,32 @@ import {
   formatControlNoticeMessage,
   getInspectorPlugins,
   hasLiveSubagentWork,
+  hasWorkflowResumeRefusal,
   listRetainedChildren,
   listScheduledRunSummaries,
   markSeenWithTtl,
   normalizePublicSubagentExecution,
   parseSubagentNotifyContent,
+  prepareWorkflowResume,
   preservedAgentFrontmatterFields,
   readWorkflowReceipt,
+  recordWorkflowResumeRefusal,
+  refusalSentence,
   registerHerdrStatusBridge,
   registerInspectorEventListener,
   registerMainWatchdog,
   registerPiWebSessionLiveness,
   registerSubagentNotify,
+  releaseWorkflowResumeClaim,
   resolveSubagentResultStatus,
-  restoreForegroundRunHistory,
+  resumedRunStarted,
   runtimeReplacedAbortReason,
   sameProviderDiagnostics,
   serviceExternalJobBridgeRequests,
-  snapshotProviderDiagnostics
-} from "./chunk-26C3WLYQ.js";
+  snapshotProviderDiagnostics,
+  workflowResumeClaimState,
+  workflowResumeRefusal
+} from "./chunk-ZIV4J4HG.js";
 import {
   CONTACT_SUPERVISOR_TOOL_NAME,
   NATIVE_SUPERVISOR_TOOL_NAME,
@@ -78,16 +85,18 @@ import {
   registerPinnedTool,
   registerWaitTool,
   resolveCurrentSessionId,
+  resolvePiSessionId,
   resolveWaitToolConfig,
   setDeclarationPinning,
   topLevelSupervisorTool
-} from "./chunk-BPS2AGBZ.js";
+} from "./chunk-VSUSLDNW.js";
 import {
-  currentCompletionOwnerId,
   deliverAsyncRunStop,
+  ownerConfirmedDead,
   readSessionMessagesTail,
-  resolveSubagentRunId
-} from "./chunk-KSWQVGDW.js";
+  resolveSubagentRunId,
+  restoreForegroundRunHistory
+} from "./chunk-FXUXCX2K.js";
 import {
   ASYNC_STATUS_SNAPSHOT_KIND,
   ASYNC_STATUS_SNAPSHOT_VERSION,
@@ -109,7 +118,7 @@ import {
   resolveAsyncStatusChild,
   stopStoppableAsyncStatusChildren,
   withCachedUiContext
-} from "./chunk-NNLASTQE.js";
+} from "./chunk-6XJB7PIX.js";
 import "./chunk-NF7IEKBH.js";
 import {
   disabledFeatureUseError,
@@ -120,15 +129,21 @@ import {
   resolveDisabledFeatureSurface,
   resolveMaxActiveAsyncRunsPerSession,
   resolveScheduledStoreRoot
-} from "./chunk-WSBNENFS.js";
+} from "./chunk-UCPP4GNU.js";
 import {
   ACTIVE_RUN_INDEX_DIR,
   MissionNotFoundError,
+  OWNING_SESSION_COMPLETION_OWNER,
+  WORKFLOW_STOP_CAUSE_OWNER_EXITED,
   acknowledgeMissionObserverSnapshot,
+  checkRecordedPidLiveness,
   cleanupResultIndexes,
+  currentCompletionOwnerId,
   encodeIndexSegment,
   findNestedRouteForRootId,
   hasLiveNestedDescendants,
+  isRecordedPid,
+  isReusableWorkflowStopCause,
   listMissions,
   missionObserverIndexPath,
   missionObserverResultCandidateFiles,
@@ -141,6 +156,7 @@ import {
   readMission,
   readMissionBinding,
   readProcessTerminal,
+  readRecentTerminalRunIndex,
   readResultPayload,
   reconcileAsyncRun,
   reconcileNestedAsyncDescendants,
@@ -162,28 +178,28 @@ import {
   withWorkflowChildRunModel,
   writeAsyncResultFile,
   writeResultIndexForData
-} from "./chunk-VJHOELQP.js";
-import "./chunk-BJN5LUQY.js";
+} from "./chunk-46XKCPJR.js";
+import "./chunk-OYF6AFDY.js";
 import {
   shouldUseNativeFsWatch
 } from "./chunk-NIXWDZZV.js";
 import {
   validateIntercomBridgeConfig
-} from "./chunk-ZP3HODFH.js";
+} from "./chunk-XSWOTIA3.js";
 import "./chunk-7F6RKT6W.js";
-import "./chunk-G5DKFLLI.js";
+import "./chunk-4SDU2BZX.js";
 import "./chunk-CTPAE36Y.js";
 import {
   listHerdrProjectPaneRoots,
   restoreHerdrProjectPaneSnapshots
-} from "./chunk-V2JWDB5U.js";
+} from "./chunk-52UBALJL.js";
 import "./chunk-7J4ZXMY7.js";
 import {
   cleanupAllArtifactDirs,
   cleanupOldArtifacts,
   getArtifactPaths,
   getArtifactsDir
-} from "./chunk-3DC5KBVP.js";
+} from "./chunk-5TYMSZX3.js";
 import {
   listBackgroundWorkProviders
 } from "./chunk-N2BN7BF5.js";
@@ -191,12 +207,12 @@ import "./chunk-YYREO77V.js";
 import "./chunk-UKG4V45O.js";
 import {
   registerRuntimeAgentEventListener
-} from "./chunk-LSRUTHT7.js";
+} from "./chunk-43SCHIMD.js";
 import {
   clearRuntimeAgentsForPi,
   listRuntimeAgentConfigs,
   mergeRuntimeAgents
-} from "./chunk-3IF2PGW7.js";
+} from "./chunk-YKEWIB4M.js";
 import {
   DEFAULT_FILE_SYSTEM_RETRY_DELAYS_MS,
   EXTRA_AGENT_DIRS_ENV,
@@ -236,7 +252,7 @@ import {
   waitForFileSystemRetry,
   withSettingsFileLease,
   writeAtomicJson
-} from "./chunk-ZBC44JJ3.js";
+} from "./chunk-CIZQXJ5Q.js";
 import {
   DEFAULT_ARTIFACT_CONFIG,
   DIRS,
@@ -282,7 +298,7 @@ import {
 import { randomUUID as randomUUID3 } from "node:crypto";
 import * as fs16 from "node:fs";
 import * as os3 from "node:os";
-import * as path15 from "node:path";
+import * as path16 from "node:path";
 import { Box as Box2, Container as Container3, Spacer as Spacer3, Text as Text2 } from "@earendil-works/pi-tui";
 
 // src/agents/global-npm-root.ts
@@ -884,7 +900,7 @@ function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
         job.sessionFile = status.sessionFile ?? job.sessionFile;
         if (isTerminalJobStatus(job.status)) {
           let publication = terminalPublications.get(job.asyncId);
-          if (!publication && status.mode !== "workflow" && status.processTerminal?.state === "pending" && status.runId === job.asyncId && status.sessionId === state.currentSessionId && status.completionOwnerId && status.completionOwnerId === state.completionOwnerId) {
+          if (!publication && status.mode !== "workflow" && status.processTerminal?.state === "pending" && status.runId === job.asyncId && status.completionOwnerId && (status.sessionId === state.currentSessionId && status.completionOwnerId === state.completionOwnerId || typeof status.sessionId === "string" && options.deliveryOwnerId?.(status.sessionId, status.completionOwnerId, status.completionOwnerProcess, status.parentWorkflowRunId) === OWNING_SESSION_COMPLETION_OWNER)) {
             publication = { instanceId: status.processTerminal.runnerProcessInstanceId, pending: true };
             terminalPublications.set(job.asyncId, publication);
           }
@@ -1160,13 +1176,13 @@ function createAsyncJobTracker(pi, state, asyncDirRoot, options = {}) {
       rerenderWidget(ctx, []);
     }
   };
-  const restoreActiveJobs = (ctx) => {
+  const restoreActiveJobs = (ctx, observeStatus) => {
     if (ctx?.hasUI) state.lastUiContext = ctx;
     state.statusProjectionSessionId = null;
     if (!state.currentSessionId) return;
     let runs;
     try {
-      runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: state.currentSessionId, resultsDir, kill: options.kill, now: options.now });
+      runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: state.currentSessionId, resultsDir, kill: options.kill, now: options.now, adoptCompletionOwnerId: state.completionOwnerId }, observeStatus);
     } catch (error) {
       console.error(`Failed to restore active async jobs from '${asyncDirRoot}':`, error);
       return;
@@ -1975,22 +1991,27 @@ var HEALTHY_SCAN_INTERVAL_MS = 6e4;
 var RETRY_DELAY_MS = 100;
 var CLEANUP_LEASE_WAIT_MS = 0;
 var SLOW_RESULT_SCAN_MS = 500;
-function jsonStringProperty(raw, property) {
-  const matches = raw.matchAll(new RegExp(`"${property}"\\s*:\\s*("(?:\\\\.|[^"\\\\])*")`, "g"));
+function jsonPropertyValue(raw, property, valuePattern) {
   let encoded;
-  for (const match of matches) encoded = match[1];
+  for (const match of raw.matchAll(new RegExp(`"${property}"\\s*:\\s*(${valuePattern})`, "g"))) encoded = match[1];
   if (!encoded) return void 0;
   try {
-    const value = JSON.parse(encoded);
-    return typeof value === "string" && value ? value : void 0;
+    return JSON.parse(encoded);
   } catch {
     return void 0;
   }
 }
+function jsonStringProperty(raw, property) {
+  const value = jsonPropertyValue(raw, property, `"(?:\\\\.|[^"\\\\])*"`);
+  return typeof value === "string" && value ? value : void 0;
+}
 function resultFileIdentity(raw, file) {
   return {
     sessionId: jsonStringProperty(raw, "sessionId"),
     completionOwnerId: jsonStringProperty(raw, "completionOwnerId"),
+    // Recorded as a flat object, so a brace-free match is the whole value.
+    completionOwnerProcess: jsonPropertyValue(raw, "completionOwnerProcess", `\\{[^{}]*\\}`),
+    parentWorkflowRunId: jsonStringProperty(raw, "parentWorkflowRunId"),
     runId: file.replace(/\.json$/i, "")
   };
 }
@@ -2047,12 +2068,14 @@ function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps = {})
   const handling = /* @__PURE__ */ new Set();
   let deliveringPending = 0;
   const identityCache = /* @__PURE__ */ new Map();
+  const reportedMissionSyncFailures = /* @__PURE__ */ new Map();
   let deliveryActive = true;
   let deliveryEpoch = 0;
   let resultScanTimer = null;
   let activeSessionId = null;
   const ownsResult = deps.ownership?.owns ?? ((sessionId, completionOwnerId) => sessionId === state.currentSessionId && typeof completionOwnerId === "string" && completionOwnerId === state.completionOwnerId);
   const claimedSessionIds = () => deps.ownership?.claimedSessionIds() ?? [];
+  const deliveryOwnerId = deps.ownership?.deliveryOwnerId ?? ((_sessionId, completionOwnerId) => completionOwnerId);
   const ownsCompletion = (sessionId, completionOwnerId, epoch) => {
     if (!deliveryActive || epoch !== deliveryEpoch) return false;
     if (!activeSessionId && state.currentSessionId) activeSessionId = state.currentSessionId;
@@ -2136,7 +2159,7 @@ function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps = {})
     if (!inspected) return false;
     const { identity } = inspected;
     if (!identity.sessionId) return true;
-    if (ownsResult(identity.sessionId, identity.completionOwnerId)) return true;
+    if (ownsResult(identity.sessionId, deliveryOwnerId(identity.sessionId, identity.completionOwnerId, identity.completionOwnerProcess, identity.parentWorkflowRunId))) return true;
     if (identity.runId && fsApi.existsSync(missionObserverIndexPath(resultsDir, identity.runId))) return true;
     if (identity.runId && (observed ?? observedRunIds()).has(identity.runId)) return true;
     return Boolean(deps.observeCompletion && !deps.observedCompletionRunIds);
@@ -2201,7 +2224,7 @@ function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps = {})
       let data = parseResult(raw);
       if (typeof data.sessionId !== "string" || !data.sessionId) return;
       const sessionId = data.sessionId;
-      const completionOwnerId = data.completionOwnerId;
+      const completionOwnerId = deliveryOwnerId(sessionId, data.completionOwnerId, data.completionOwnerProcess, data.parentWorkflowRunId);
       const runId = typeof data.runId === "string" && data.runId ? data.runId : typeof data.id === "string" && data.id ? data.id : file.replace(/\.json$/i, "");
       const toolCallId = typeof data.toolCallId === "string" ? data.toolCallId : void 0;
       let read = { runId, sessionId, toolCallId, snapshot: raw, ...publicAtRead !== void 0 && publicAtRead !== raw ? { stalePublic: publicAtRead } : {} };
@@ -2219,9 +2242,14 @@ function createResultWatcher(pi, state, resultsDir, completionTtlMs, deps = {})
       let observerSucceeded = true;
       try {
         syncMissionFromAsyncCompletion({ ...data, runId });
+        reportedMissionSyncFailures.delete(file);
       } catch (error) {
         observerSucceeded = false;
-        console.error(`Mission completion sync failed for '${resultPath}':`, error);
+        const message2 = error instanceof Error ? error.message : String(error);
+        if (reportedMissionSyncFailures.get(file) !== message2) {
+          reportedMissionSyncFailures.set(file, message2);
+          console.error(`Mission completion sync failed for '${resultPath}':`, error);
+        }
       }
       try {
         deps.observeCompletion?.({ ...data, runId });
@@ -2348,6 +2376,7 @@ ${baseOutput}` : ""}` : output;
         ...data,
         id: data.id ?? runId,
         runId,
+        completionOwnerId,
         triggerTurn,
         intercomDelivered,
         ...nestedChildren?.length ? { nestedChildren } : {},
@@ -2622,14 +2651,24 @@ ${baseOutput}` : ""}` : output;
 }
 
 // src/runs/background/result-delivery-ownership.ts
+var deadCompletionOwnerIds = /* @__PURE__ */ new Set();
 function createResultDeliveryOwnership(state) {
   const currentOwner = () => typeof state.completionOwnerId === "string" && state.completionOwnerId ? state.completionOwnerId : void 0;
   return {
     owns(sessionId, completionOwnerId) {
       const owner = currentOwner();
-      if (!owner || completionOwnerId !== owner) return false;
+      if (!owner || completionOwnerId !== owner && completionOwnerId !== OWNING_SESSION_COMPLETION_OWNER) return false;
       return ownsRun(state.currentSessionId, sessionId);
     },
+    deliveryOwnerId(sessionId, completionOwnerId, ownerProcess, parentWorkflowRunId) {
+      const owner = currentOwner();
+      if (!owner || typeof completionOwnerId !== "string" || completionOwnerId === owner || completionOwnerId === OWNING_SESSION_COMPLETION_OWNER || parentWorkflowRunId || !ownsRun(state.currentSessionId, sessionId)) return completionOwnerId;
+      if (!deadCompletionOwnerIds.has(completionOwnerId)) {
+        if (!isRecordedPid(ownerProcess) || checkRecordedPidLiveness(ownerProcess) !== "dead") return completionOwnerId;
+        deadCompletionOwnerIds.add(completionOwnerId);
+      }
+      return OWNING_SESSION_COMPLETION_OWNER;
+    },
     claimedSessionIds() {
       if (!currentOwner() || !state.currentSessionId) return [];
       return inheritedSessionIds(state.currentSessionId);
@@ -5141,7 +5180,7 @@ function registerSlashCommands(pi, state, options = {}) {
     }
     fleetOpen = true;
     try {
-      const { openSubagentFleet } = await import("./chunk-563BHAZ5.js");
+      const { openSubagentFleet } = await import("./chunk-G4GZD3OJ.js");
       await openSubagentFleet(ctx, state, { asyncDirRoot: DIRS.async, inspectorPlugins: () => getInspectorPlugins(pi), resultsDir: DIRS.results, fleetKeybindings: options.fleetKeybindings });
     } finally {
       fleetOpen = false;
@@ -6773,6 +6812,7 @@ var MESSAGE_VIEWS = /* @__PURE__ */ new Map([
   ["subagent-wait-subscription", readsContent("result", (message2) => waitSubscriptionHeadline(message2.details))],
   ["subagent-incremental-child-notify", readsContent("result", workflowChildHeadline)],
   ["subagent-workflow-result-write-failed", readsContent("result", () => ["workflow result ", { status: "save failed" }])],
+  ["subagent-auto-resume", readsContent("result", () => ["workflow auto-resume ", { status: "failed" }])],
   [SUBAGENT_CONTROL_MESSAGE_TYPE, readsContent("attention", (message2) => controlNoticeHeadline(message2.details))],
   [SUBAGENT_STEERING_MESSAGE_TYPE, readsContent("attention", (message2) => steeringNoticeHeadline(message2.details))],
   [SUBAGENT_WATCHDOG_WARNING_TYPE, (message2) => watchdogWarningView(message2.details, contentText(message2.content))],
@@ -8039,9 +8079,79 @@ function buildSubagentToolDescription(config = {}, options) {
   return fullDescription(on);
 }
 
+// src/workflows/workflow-auto-resume.ts
+import * as path13 from "node:path";
+var WORKFLOW_AUTO_RESUME_MESSAGE_TYPE = "subagent-auto-resume";
+var AUTO_RESUME_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var AUTO_RESUME_SCAN_LIMIT = 50;
+function interruptedAt(status) {
+  return status.workflow?.stopCause === WORKFLOW_STOP_CAUSE_OWNER_EXITED ? status.workflow.ownerExitedAt : status.endedAt;
+}
+var registryKey = /* @__PURE__ */ Symbol.for("pi-subagents.workflow-auto-resume.v1");
+var registryGlobal = globalThis;
+var pendingAutoResumes = registryGlobal[registryKey] ?? (registryGlobal[registryKey] = /* @__PURE__ */ new Set());
+function cancelPendingWorkflowAutoResumes(match) {
+  for (const entry of pendingAutoResumes) {
+    if (entry.state !== "pending" || !match(entry)) continue;
+    entry.state = "cancelled";
+    try {
+      releaseWorkflowResumeClaim(entry.prepared.sourceAsyncDir, entry.prepared.newRunId);
+    } catch (error) {
+      console.error(`Failed to give back the auto-resume claim of workflow ${entry.prepared.sourceRunId}:`, error);
+    }
+  }
+}
+function finishWorkflowAutoResume(entry) {
+  if (entry.state !== "cancelled") pendingAutoResumes.delete(entry);
+}
+function planWorkflowAutoResumes(input) {
+  const { asyncDirRoot, currentSessionId, now } = input;
+  cancelPendingWorkflowAutoResumes((entry) => entry.sessionId === currentSessionId);
+  const reusableRunIds = /* @__PURE__ */ new Map();
+  for (const entry of pendingAutoResumes) {
+    if (entry.sessionId !== currentSessionId || entry.state !== "cancelled") continue;
+    reusableRunIds.set(entry.prepared.sourceRunId, entry.prepared.newRunId);
+    pendingAutoResumes.delete(entry);
+  }
+  let runIds;
+  try {
+    runIds = readRecentTerminalRunIndex(asyncDirRoot, { sessionId: currentSessionId, limit: AUTO_RESUME_SCAN_LIMIT, endedAfter: now - AUTO_RESUME_MAX_AGE_MS });
+  } catch (error) {
+    console.error("Failed to read interrupted workflows for auto-resume:", error);
+    return [];
+  }
+  const planned = [];
+  for (const runId of runIds) {
+    const asyncDir = path13.join(asyncDirRoot, runId);
+    try {
+      const status = readStatus(asyncDir);
+      if (!status || status.mode !== "workflow" || status.parentWorkflowRunId !== void 0 || status.sessionId !== currentSessionId) continue;
+      if (!isReusableWorkflowStopCause(status.workflow?.stopCause)) continue;
+      const at = interruptedAt(status);
+      if (at === void 0 || now - at > AUTO_RESUME_MAX_AGE_MS) continue;
+      if (workflowResumeClaimState(asyncDir).kind !== "none" || hasWorkflowResumeRefusal(asyncDir)) continue;
+      const preparation = prepareWorkflowResume({ asyncDirRoot, sourceRunId: runId, trigger: "auto", now, currentSessionId, newRunId: reusableRunIds.get(runId) });
+      if (preparation.ok) {
+        const entry = { sessionId: currentSessionId, owner: input.owner, prepared: preparation.prepared, state: "pending" };
+        pendingAutoResumes.add(entry);
+        planned.push(entry);
+        continue;
+      }
+      if (preparation.code === "claim-busy" || preparation.code === "claim-resumed") continue;
+      recordWorkflowResumeRefusal(asyncDir, { reason: preparation.reason, byHand: preparation.byHand }, now);
+    } catch (error) {
+      console.error(`Failed to prepare auto-resume of workflow ${runId}:`, error);
+    }
+  }
+  return planned;
+}
+function autoResumeFailureText(sourceRunId, refusal) {
+  return `Workflow ${sourceRunId} was not auto-resumed: ${refusalSentence(refusal.reason, refusal.byHand)}`;
+}
+
 // src/missions/goal-driver.ts
 import * as fs14 from "node:fs";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 var TERMINAL_MISSION_STATUSES2 = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set(["queued", "running", "active"]);
 var MAX_ACTION_LENGTH = 180;
@@ -8056,7 +8166,7 @@ function tokenUsage(value) {
 }
 function readLinkedRun(run) {
   if (!run.asyncDir) return run;
-  const statusPath = path13.join(run.asyncDir, "status.json");
+  const statusPath = path14.join(run.asyncDir, "status.json");
   if (!fs14.existsSync(statusPath)) return run;
   let parsed;
   try {
@@ -8182,14 +8292,57 @@ function collectGoalContinuationNotices(input) {
   return notices;
 }
 
+// src/runs/background/interrupted-elsewhere.ts
+var INTERRUPTED_ELSEWHERE_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+function interruptedElsewhereLine(reopenId, count) {
+  const command = `\`pi --session ${reopenId}\``;
+  return count === 1 ? `1 subagent run was interrupted in another session. Reopen it to resume it: ${command}` : `${count} subagent runs were interrupted in another session. Reopen it to resume them: ${command}`;
+}
+function createInterruptedElsewhereCollector(input) {
+  const ownSessions = ownerSessionIds(input.currentSessionId);
+  const candidates = /* @__PURE__ */ new Map();
+  const recent = (at) => typeof at === "number" && input.now - at <= INTERRUPTED_ELSEWHERE_MAX_AGE_MS;
+  const add = (sessionId, runId, ownerDead) => {
+    if (ownSessions.has(sessionId)) return;
+    const runs = candidates.get(sessionId) ?? /* @__PURE__ */ new Map();
+    if (!runs.has(runId)) runs.set(runId, ownerDead);
+    candidates.set(sessionId, runs);
+  };
+  return {
+    observeStatus(observed) {
+      const status = observed;
+      if (!status || typeof status.sessionId !== "string" || typeof status.runId !== "string" || status.state !== "running" && status.state !== "queued") return;
+      if (status.parentWorkflowRunId !== void 0 || status.cwd !== input.cwd || !recent(status.lastUpdate ?? status.startedAt)) return;
+      const { pid, pidNamespaceScope, bootId } = status;
+      if (typeof pid !== "number") return;
+      add(status.sessionId, status.runId, () => checkRecordedPidLiveness({ pid, pidNamespaceScope, bootId }) === "dead");
+    },
+    observeForegroundRun(run) {
+      if (!run.sessionId || run.parentWorkflowRunId !== void 0 || run.cwd !== input.cwd || !recent(run.updatedAt)) return;
+      add(run.sessionId, run.runId, () => ownerConfirmedDead(run));
+    },
+    lines() {
+      const lines = [];
+      for (const [sessionId, runs] of candidates) {
+        const reopenId = resolvePiSessionId(sessionId);
+        if (!reopenId) continue;
+        let interrupted = 0;
+        for (const ownerDead of runs.values()) if (ownerDead()) interrupted += 1;
+        if (interrupted > 0) lines.push(interruptedElsewhereLine(reopenId, interrupted));
+      }
+      return lines;
+    }
+  };
+}
+
 // src/extension/upgrade-notice.ts
 import * as fs15 from "node:fs";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var versionNumber = (version) => typeof version === "string" && /^\d+\.\d+\.\d+$/.test(version) ? version.split(".").reduce((total, part) => total * 1e6 + Number(part), 0) : void 0;
-async function showUpgradeNotice(ctx, stateDir = path14.join(getAgentDir(), "pi-subagents"), changelogPath = fileURLToPath2(new URL("../../CHANGELOG.md", new URL("../src/extension/upgrade-notice.js", import.meta.url).href)), version = package_default.version) {
+async function showUpgradeNotice(ctx, stateDir = path15.join(getAgentDir(), "pi-subagents"), changelogPath = fileURLToPath2(new URL("../../CHANGELOG.md", new URL("../src/extension/upgrade-notice.js", import.meta.url).href)), version = package_default.version) {
   if (!ctx.hasUI) return;
-  const statePath = path14.join(stateDir, "last-seen-version.json");
+  const statePath = path15.join(stateDir, "last-seen-version.json");
   const lastSeen = await fs15.promises.readFile(statePath, "utf-8").then((raw) => JSON.parse(raw).version).catch(() => void 0);
   const previous = versionNumber(lastSeen);
   const current = versionNumber(version);
@@ -8251,14 +8404,14 @@ function formatWorkflowPreflightCall(input) {
 }
 function getSubagentSessionRoot(parentSessionFile) {
   if (parentSessionFile) {
-    const baseName = path15.basename(parentSessionFile, ".jsonl");
-    const sessionsDir = path15.dirname(parentSessionFile);
-    return path15.join(sessionsDir, baseName);
+    const baseName = path16.basename(parentSessionFile, ".jsonl");
+    const sessionsDir = path16.dirname(parentSessionFile);
+    return path16.join(sessionsDir, baseName);
   }
-  return fs16.mkdtempSync(path15.join(os3.tmpdir(), "pi-subagent-session-"));
+  return fs16.mkdtempSync(path16.join(os3.tmpdir(), "pi-subagent-session-"));
 }
 function expandTilde(p) {
-  return p.startsWith("~/") ? path15.join(os3.homedir(), p.slice(2)) : p;
+  return p.startsWith("~/") ? path16.join(os3.homedir(), p.slice(2)) : p;
 }
 function isSlashResultRunning(result) {
   return result.details?.progress?.some((entry) => entry.status === "running") || result.details?.results.some((entry) => entry.progress?.status === "running") || false;
@@ -8414,7 +8567,7 @@ function registerSubagentExtension(pi) {
     const ctx = withLastUiContext((current) => current);
     if (!ctx) return;
     try {
-      const { openSubagentFleet } = await import("./chunk-563BHAZ5.js");
+      const { openSubagentFleet } = await import("./chunk-G4GZD3OJ.js");
       await openSubagentFleet(ctx, state, { initialKey: itemKey, asyncDirRoot: DIRS.async, resultsDir: DIRS.results, fleetKeybindings: config.fleetKeybindings, inspectorPlugins: () => getInspectorPlugins(pi) });
     } catch (error) {
       if (isStaleExtensionContextError(error)) {
@@ -8521,6 +8674,7 @@ function registerSubagentExtension(pi) {
       refreshResultDelivery();
     },
     onJobCleanup: (asyncId) => deliveredRunIds.delete(asyncId),
+    deliveryOwnerId: resultDeliveryOwnership.deliveryOwnerId,
     supervisorRequestState: supervisorChannel.getSupervisorRequestState,
     onJobsChanged: programStatus.sync
   });
@@ -8609,7 +8763,7 @@ function registerSubagentExtension(pi) {
   let executor;
   let executorPromise;
   let executorModulePromise;
-  const loadExecutorModule = () => executorModulePromise ??= import("./chunk-XMFLCKMQ.js");
+  const loadExecutorModule = () => executorModulePromise ??= import("./chunk-QE4AGIMG.js");
   const getExecutor = () => {
     executorPromise ??= loadExecutorModule().then(({ createSubagentExecutor }) => {
       executor = createSubagentExecutor(executorDeps);
@@ -8623,7 +8777,7 @@ function registerSubagentExtension(pi) {
     modulePreloadTimer = setTimeout(() => {
       loadExecutorModule().catch(() => {
       });
-      if (fleetViewEnabled) import("./chunk-563BHAZ5.js").catch(() => {
+      if (fleetViewEnabled) import("./chunk-G4GZD3OJ.js").catch(() => {
       });
     }, MODULE_PRELOAD_DELAY_MS);
     modulePreloadTimer.unref?.();
@@ -8675,6 +8829,43 @@ ${close}` }]
     await waitForAdvertisement();
     return (await getExecutor()).executePublic(id, params, signal, onUpdate, ctx);
   };
+  const autoResumeOwner = {};
+  const postAutoResumeFailure = (sourceRunId, refusal) => {
+    pi.sendMessage({ customType: WORKFLOW_AUTO_RESUME_MESSAGE_TYPE, content: autoResumeFailureText(sourceRunId, refusal), display: true }, { triggerTurn: false });
+  };
+  const launchWorkflowAutoResume = async (entry, ctx) => {
+    const { prepared } = entry;
+    try {
+      await new Promise((resolve6) => setImmediate(resolve6));
+      await waitForAdvertisement();
+      const executor2 = await getExecutor();
+      if (entry.state !== "pending") return;
+      entry.state = "started";
+      const outcome = await executor2.executeWorkflowResume(randomUUID3(), prepared, new AbortController().signal, ctx);
+      if (outcome.launched && runtimeCleaned) state.workflowControllers?.get(prepared.newRunId)?.abort(runtimeReplacedAbortReason());
+      if (outcome.launched || runtimeCleaned) return;
+      try {
+        postAutoResumeFailure(prepared.sourceRunId, outcome.refusal);
+      } catch (error) {
+        console.error(`Failed to post the auto-resume failure of workflow ${prepared.sourceRunId}:`, error);
+      }
+    } catch (error) {
+      if (entry.state === "cancelled") return;
+      const message2 = error instanceof Error ? error.message : String(error);
+      console.error(`Failed to auto-resume workflow ${prepared.sourceRunId}:`, error);
+      try {
+        if (resumedRunStarted(prepared.sourceAsyncDir, prepared.newRunId)) return;
+        releaseWorkflowResumeClaim(prepared.sourceAsyncDir, prepared.newRunId);
+        const refusal = workflowResumeRefusal("launch-failed", `launch failed: ${message2}`, prepared.sourceRunId);
+        recordWorkflowResumeRefusal(prepared.sourceAsyncDir, { reason: refusal.reason, byHand: refusal.byHand, newRunId: prepared.newRunId });
+        postAutoResumeFailure(prepared.sourceRunId, refusal);
+      } catch (cleanupError) {
+        console.error(`Failed to give back the auto-resume claim of workflow ${prepared.sourceRunId}:`, cleanupError);
+      }
+    } finally {
+      finishWorkflowAutoResume(entry);
+    }
+  };
   const executeSubagentCollapsed = (id, params, signal, onUpdate, ctx) => {
     if (ctx.hasUI) ctx.ui.setToolsExpanded(false);
     return executeSubagentReady(id, params, signal, onUpdate, ctx);
@@ -8898,9 +9089,9 @@ ${close}` }]
     owedResultRunIds.clear();
     deliveredRunIds.clear();
     state.parentSessionFile = ctx.sessionManager.getSessionFile();
-    state.trustedSessionFileRoot = state.parentSessionFile ? path15.join(getAgentDir(), "sessions") : void 0;
+    state.trustedSessionFileRoot = state.parentSessionFile ? path16.join(getAgentDir(), "sessions") : void 0;
     state.trustedSessionRoots = [.../* @__PURE__ */ new Set([
-      ...config.defaultSessionDir ? [path15.resolve(expandTilde(config.defaultSessionDir))] : [],
+      ...config.defaultSessionDir ? [path16.resolve(expandTilde(config.defaultSessionDir))] : [],
       ...state.parentSessionFile ? [getSubagentSessionRoot(state.parentSessionFile)] : []
     ])];
     state.subagentSpawns = {
@@ -8910,7 +9101,7 @@ ${close}` }]
       granted: 0,
       grantHistory: []
     };
-    const projectPaneOwnerRoot = path15.resolve(ctx.cwd);
+    const projectPaneOwnerRoot = path16.resolve(ctx.cwd);
     restoreHerdrProjectPaneSnapshots(state, [.../* @__PURE__ */ new Set([...state.herdrProjectPanes?.keys() ?? [], ...listHerdrProjectPaneRoots(projectPaneOwnerRoot), projectPaneOwnerRoot])]);
     if (!process.env[SUBAGENT_CHILD_ENV]) {
       delete process.env[SUBAGENT_PARENT_SESSION_ENV];
@@ -8931,12 +9122,24 @@ ${close}` }]
     resetJobs(ctx);
     logSlowPhase("reset-jobs", phaseStartedAt);
     phaseStartedAt = Date.now();
-    restoreForegroundRunHistory(state, { resultsDir: DIRS.results });
+    const interruptedElsewhere = ctx.hasUI ? createInterruptedElsewhereCollector({ currentSessionId: state.currentSessionId, cwd: ctx.cwd, now: Date.now() }) : void 0;
+    restoreForegroundRunHistory(state, { resultsDir: DIRS.results, observeForeign: interruptedElsewhere?.observeForegroundRun });
     logSlowPhase("foreground-history", phaseStartedAt);
     phaseStartedAt = Date.now();
-    restoreActiveJobs(ctx);
+    restoreActiveJobs(ctx, interruptedElsewhere?.observeStatus);
     logSlowPhase("active-job-restore", phaseStartedAt);
     phaseStartedAt = Date.now();
+    if (interruptedElsewhere) for (const line of interruptedElsewhere.lines()) ctx.ui.notify(line, "info");
+    logSlowPhase("cross-session-notice", phaseStartedAt);
+    phaseStartedAt = Date.now();
+    cancelPendingWorkflowAutoResumes((entry) => entry.owner === autoResumeOwner);
+    if (recovering && ctx.hasUI && config.autoResume !== false) {
+      for (const entry of planWorkflowAutoResumes({ asyncDirRoot: DIRS.async, currentSessionId: state.currentSessionId, now: Date.now(), owner: autoResumeOwner })) {
+        void launchWorkflowAutoResume(entry, ctx);
+      }
+    }
+    logSlowPhase("workflow-auto-resume", phaseStartedAt);
+    phaseStartedAt = Date.now();
     scheduledRunManager.bindSession(ctx);
     logSlowPhase("scheduled-runs", phaseStartedAt);
     phaseStartedAt = Date.now();
@@ -8960,6 +9163,7 @@ ${close}` }]
     cleanup(shutdownReason) {
       if (runtimeCleaned) return;
       runtimeCleaned = true;
+      cancelPendingWorkflowAutoResumes((entry) => entry.owner === autoResumeOwner);
       programStatus.dispose(shutdownReason);
       releaseHostSessionLiveness();
       releaseHostSessionLiveness = () => {