pi-orchestrator-config 4.3.11 → 4.3.13

package/extensions/orchestrator/async-agents.ts

@@ -13,8 +13,7 @@ import { fileURLToPath } from "node:url";
 const require = createRequire(import.meta.url);
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import type { AgentConfig } from "./agents.js";
-import { discoverAgents } from "./agents.js";
+import type { AgentConfig, AgentDiscoveryResult } from "./agents.js";
 import { resolveAgentModelProvider } from "./resolve-agent-model.js";
 import { getPiInvocation, getProjectTmpDir, parseProcStartTime, djb2Hash } from "./utils.js";
 import { addReviewerPending, recordReviewerResult, countFindings, readReviewState, markTestsPassed, markTestsFailed } from "./pi-config-review-state.js";
@@ -22,14 +21,17 @@ import {
   getMainBranch,
 } from "./git-helpers.js";
 import { waitForResultFiles } from "./async-wait.js";
-import { openAsyncStatusOverlay } from "./async-status-ui.js";
+import { formatAsyncResultOutput, reviewerOutputArchivePath } from "./async-result-format.js";
+import { cleanupReviewerOutputArchives } from "./reviewer-output-archive.js";
 const log = createLogger("async_agents");
 
 export { autoCompleteTask, autoMarkInProgress } from "./task-lifecycle.js";
 import { autoCompleteTask, autoMarkInProgress } from "./task-lifecycle.js";
+import { openAsyncStatusOverlay } from "./async-status-ui.js";
 import { setSlot } from "./status-bar.js";
 import { getSetting } from "./project-settings.js";
 import { substituteSettingsPlaceholders } from "./rule-placeholders.js";
+import { isLiveExtensionCtx } from "../shared/live-ctx.js";
 
 const SETTINGS_KEYS: Record<string, unknown> = JSON.parse(
   fs.readFileSync(
@@ -117,6 +119,10 @@ export function formatDuration(ms: number): string {
 export function registerAsyncAgents(
   pi: ExtensionAPI,
   terminalNotify: (title: string, body: string) => void,
+  runtime: {
+    spawnProcess?: typeof spawn;
+    discoverAgents?: (cwd: string, scope: "both") => Pick<AgentDiscoveryResult, "agents">;
+  } = {},
 ): {
   spawnAsyncAgent: (agentName: string, task: string, cwd: string, agents: AgentConfig[], options?: { fireAndForget?: boolean; name?: string; parentModelId?: string; parentProvider?: string; groupId?: string; taskId?: string; onComplete?: () => void; persistSession?: boolean; explicit?: { model?: string; provider?: string } }) => { id: string; error?: string; model?: string };
   killAsyncAgent: (target: string) => { killed: string[]; errors: string[] };
@@ -125,6 +131,28 @@ export function registerAsyncAgents(
   let PROJECT_TMP_DIR = path.join(process.cwd(), ".pi", "tmp"); // Computed only; created on session_start
   let ASYNC_RESULTS_DIR = ""; // Set on session_start to project-scoped dir
 
+  function resultOutputPath(job: Pick<AsyncJob, "agent" | "id" | "workerDir">): string {
+    const workerOutputPath = path.join(job.workerDir, "output.log");
+    const outputPath = job.agent.startsWith("code-reviewer-")
+      ? reviewerOutputArchivePath(PROJECT_TMP_DIR, job.id)
+      : workerOutputPath;
+    log.debug("async_result_output_path", { agent: job.agent, archived: outputPath !== workerOutputPath });
+    return outputPath;
+  }
+
+  function preserveReviewerOutput(job: Pick<AsyncJob, "agent" | "id">, output: string): void {
+    if (!job.agent.startsWith("code-reviewer-")) return;
+    const outputPath = reviewerOutputArchivePath(PROJECT_TMP_DIR, job.id);
+    try {
+      fs.mkdirSync(path.dirname(outputPath), { recursive: true, mode: 0o700 });
+      fs.writeFileSync(outputPath, output, { mode: 0o600 });
+      fs.chmodSync(outputPath, 0o600);
+      cleanupReviewerOutputArchives(path.dirname(outputPath));
+      log.info("preserved_reviewer_output", { agent: job.agent, bytes: Buffer.byteLength(output, "utf8") });
+    } catch (e: any) {
+      log.error(`preserve reviewer output failed for ${job.id}: ${e?.message}`);
+    }
+  }
 
   const asyncState: AsyncState = {
     jobs: new Map(),
@@ -148,10 +176,20 @@ export function registerAsyncAgents(
   }
 
   let lastWidgetKey = "";
+  function getLiveAsyncCtx(): any | null {
+    const ctx = asyncState.lastCtx;
+    if (!isLiveExtensionCtx(ctx)) {
+      log.debug("async_context_stale", { hadContext: ctx !== null });
+      asyncState.lastCtx = null;
+      return null;
+    }
+    return ctx;
+  }
+
   function updateAsyncWidget() {
-    if (!asyncState.lastCtx?.hasUI) return;
     try {
-      const ctx = asyncState.lastCtx;
+      const ctx = getLiveAsyncCtx();
+      if (!ctx?.hasUI) return;
       const running = Array.from(asyncState.jobs.values()).filter(j => j.status === "running" || j.status === "queued");
       const names = running.map(j => j.name || j.agent).join(", ");
       const widgetKey = `${running.length}:${names}`;
@@ -181,10 +219,15 @@ export function registerAsyncAgents(
   function ensureAsyncPoller() {
     if (asyncState.poller) return;
     asyncState.poller = setInterval(() => {
+      const liveCtx = getLiveAsyncCtx();
+      if (!liveCtx) {
+        // ctx is stale (session ended) — stop polling
+        if (asyncState.poller) { clearInterval(asyncState.poller); asyncState.poller = null; }
+        return;
+      }
       try {
-        if (!asyncState.lastCtx?.hasUI) return;
+        if (!liveCtx.hasUI) return;
       } catch {
-        // ctx is stale (session ended) — stop polling
         if (asyncState.poller) { clearInterval(asyncState.poller); asyncState.poller = null; }
         return;
       }
@@ -375,7 +418,7 @@ export function registerAsyncAgents(
               deliverGroupResults(groupJobs);
             }
           // Delivery: retry for non-grouped jobs (zombie-ingest path may skip delivery)
-          } else if (asyncState.lastCtx && !job.fireAndForget) {
+          } else if (getLiveAsyncCtx() && !job.fireAndForget) {
             const displayName = job.name || job.agent;
             const resultStatus = job.status === "complete" ? "✅ completed" : "❌ failed";
             const duration = job.durationMs || (job.updatedAt ? job.updatedAt - job.startedAt : 0);
@@ -392,9 +435,14 @@ export function registerAsyncAgents(
                 log.error(`reconcile: auto-complete failed for task #${safeTaskId}: ${e?.message}`);
               }
             }
-            // Enforce same output-length budget as processResultFile
-            const maxOutput = 3000 - autoCompleteError.length;
-            const output = (job.output || "").slice(0, Math.max(maxOutput, 500));
+            // Enforce same output-length budget as processResultFile.
+            const maxOutput = Math.max(3000 - autoCompleteError.length, 500);
+            const output = formatAsyncResultOutput(
+              job.agent,
+              job.output || "",
+              resultOutputPath(job),
+              maxOutput,
+            );
             // Emit lifecycle events
             if (job.status === "complete") {
               pi.events.emit("subagents:completed", { id: job.id, result: job.output || "" });
@@ -406,7 +454,7 @@ export function registerAsyncAgents(
               job.delivered = true;
               log.debug(`reconcile: skipping already-delivered result for ${job.id}`);
             } else {
-              log.debug("reconcile_deliver", job.id, "hasCtx", !!asyncState.lastCtx);
+              log.debug("reconcile_deliver", job.id, "hasCtx", true);
               try {
                 pi.sendMessage({
                   customType: "async-agent-result",
@@ -463,8 +511,6 @@ export function registerAsyncAgents(
     if (gid && groupDeliveryInProgress.has(gid)) return;
     if (gid) groupDeliveryInProgress.add(gid);
     try {
-    if (!asyncState.lastCtx) return;
-
     // Ingest any unprocessed result files — zombie/kill paths may trigger delivery
     // before processResultFile() has read all group members' outputs.
     // Wait up to 2s total (not per-job) for all missing result files.
@@ -481,6 +527,7 @@ export function registerAsyncAgents(
       try {
         const data = JSON.parse(fs.readFileSync(rp, "utf-8"));
         j.output = data.output;
+        preserveReviewerOutput(j, typeof data.output === "string" ? data.output : JSON.stringify(data.output ?? ""));
         j.exitCode = data.exitCode;
         j.durationMs = data.durationMs;
         if (data.success !== undefined) j.status = data.success ? "complete" : "failed";
@@ -549,7 +596,11 @@ export function registerAsyncAgents(
       if (j.fireAndForget) { j.delivered = true; continue; }
       const resultStatus = j.status === "complete" ? "✅ completed" : "❌ failed";
       const displayName = j.name || j.agent;
-      const output = (j.output || "").slice(0, 3000);
+      const output = formatAsyncResultOutput(
+        j.agent,
+        j.output || "",
+        resultOutputPath(j),
+      );
       let autoCompleteError = "";
       // Auto-complete linked task directly in the store file (no AI involvement)
       if (j.taskId && j.taskId !== "-1" && j.status === "complete" && j.cwd) {
@@ -567,6 +618,12 @@ export function registerAsyncAgents(
     }
 
     if (sections.length > 0) {
+      // A group may have waited for result files while its session was replaced.
+      // Keep persisted/in-memory results for reconciliation rather than sending into it.
+      if (!getLiveAsyncCtx()) {
+        log.debug("deliver_group_results_deferred", { groupId: groupJobs[0]?.groupId, jobs: groupJobs.length, deliverableJobs: deliverableJobs.length, status: groupJobs[0]?.status });
+        return;
+      }
       try {
         pi.sendMessage({
           customType: "async-agent-result",
@@ -613,7 +670,7 @@ export function registerAsyncAgents(
     try {
       const data = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
       const job = asyncState.jobs.get(data.id);
-      log.debug(`processResultFile: ${path.basename(resultPath)} job=${!!job} delivered=${job?.delivered} hasCtx=${!!asyncState.lastCtx} fireAndForget=${job?.fireAndForget} groupId=${job?.groupId}`);
+      log.debug(`processResultFile: ${path.basename(resultPath)} job=${!!job} delivered=${job?.delivered} hasCtx=${!!getLiveAsyncCtx()} fireAndForget=${job?.fireAndForget} groupId=${job?.groupId}`);
       if (!job) {
         // Orphan result file — job not in current session. Clean up to prevent re-delivery on reload.
         try { fs.unlinkSync(resultPath); } catch (e: any) { log.debug(`orphan cleanup failed: ${resultPath}: ${e?.message}`); }
@@ -639,6 +696,7 @@ export function registerAsyncAgents(
       job.exitCode = data.exitCode;
       job.durationMs = data.durationMs;
       job.updatedAt = Date.now();
+      preserveReviewerOutput(job, typeof data.output === "string" ? data.output : JSON.stringify(data.output ?? ""));
 
       // Notify terminal per-agent (lightweight, non-conversational)
       const displayName = job.name || data.agent;
@@ -657,11 +715,11 @@ export function registerAsyncAgents(
         // Use model context window from the agent's effective model.
         // If agent uses a custom model, we pass its context window via the config.
         // Fall back to orchestrator's model context window.
-        const contextWindow = data.contextWindow || asyncState.lastCtx?.model?.contextWindow || 0;
+        const contextWindow = data.contextWindow || getLiveAsyncCtx()?.model?.contextWindow || 0;
         if (data.lastUsage?.totalTokens && data.lastUsage.totalTokens > 0 && contextWindow > 0) {
           const pct = (data.lastUsage.totalTokens / contextWindow) * 100;
           if (pct > 80) {
-            const sessId = `async-${job.agent}-${djb2Hash(job.agent + ':' + (jobCwd(job)) + ':' + (asyncState.lastCtx?.sessionManager?.getSessionId?.() || '')).toString(36)}`;
+            const sessId = `async-${job.agent}-${djb2Hash(job.agent + ':' + (jobCwd(job)) + ':' + (getLiveAsyncCtx()?.sessionManager?.getSessionId?.() || '')).toString(36)}`;
             try {
               // Find and delete the session file to force fresh on next cycle
               const sessDir = path.join(os.homedir(), '.pi', 'agent', 'sessions');
@@ -703,7 +761,11 @@ export function registerAsyncAgents(
       try {
         const statusPath = path.join(job.workerDir, "status.json");
         const existing = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
-        existing.output = (data.output || "").slice(0, 3000);
+        existing.output = formatAsyncResultOutput(
+          job.agent,
+          data.output || "",
+          resultOutputPath(job),
+        );
         existing.state = job.status;
         existing.exitCode = job.exitCode;
         existing.durationMs = job.durationMs;
@@ -735,7 +797,7 @@ export function registerAsyncAgents(
 
       // Non-grouped job: deliver immediately (existing behavior)
       let sendSucceeded = false;
-      if (asyncState.lastCtx && !job.fireAndForget) {
+      if (getLiveAsyncCtx() && !job.fireAndForget) {
         const resultStatus = data.success ? "✅ completed" : "❌ failed";
         let autoCompleteError = "";
         // Auto-complete linked task directly in the store file (no AI involvement)
@@ -748,8 +810,13 @@ export function registerAsyncAgents(
             log.error(`auto-complete failed for task #${job.taskId}: ${e?.message}`);
           }
         }
-        const maxOutput = 3000 - autoCompleteError.length;
-        const output = (data.output || "").slice(0, Math.max(maxOutput, 500));
+        const maxOutput = Math.max(3000 - autoCompleteError.length, 500);
+        const output = formatAsyncResultOutput(
+          job.agent,
+          data.output || "",
+          resultOutputPath(job),
+          maxOutput,
+        );
         const pContent = `## Async Agent Result: ${displayName} ${resultStatus}\n\nTask: ${data.task}\nDuration: ${formatDuration(data.durationMs)}\n\n${output}${autoCompleteError}`;
         if (wasAlreadyDelivered(job.id)) {
           // Already delivered in previous lifecycle — skip send AND onComplete
@@ -806,16 +873,17 @@ export function registerAsyncAgents(
     watchedDir = ASYNC_RESULTS_DIR;
     try {
       fs.mkdirSync(ASYNC_RESULTS_DIR, { recursive: true, mode: 0o700 });
-      asyncState.watcher = fs.watch(ASYNC_RESULTS_DIR, (ev, file) => {
+      const resultsDir = ASYNC_RESULTS_DIR;
+      asyncState.watcher = fs.watch(resultsDir, (ev, file) => {
         if (ev !== "rename" || !file) return;
         const fileName = file.toString();
         log.debug("watcher_event", ev, fileName);
         if (!fileName.endsWith(".json")) return;
-        const resultPath = path.join(ASYNC_RESULTS_DIR, fileName);
+        const resultPath = path.join(resultsDir, fileName);
         setTimeout(() => processResultFile(resultPath), 100);
       });
       if (asyncState.watcher.unref) asyncState.watcher.unref();
-    } catch (e: any) { console.debug("[async-agents] watcher setup failed:", e?.message || e); }
+    } catch (e: any) { log.error(`watcher setup failed: ${e?.message || e}`); }
   }
 
   function spawnAsyncAgent(
@@ -844,7 +912,7 @@ export function registerAsyncAgents(
       } catch { /* retry */ }
     }
     if (!parentStartTime) {
-      console.debug("[async-agents] WARNING: could not read /proc/self/stat starttime after 3 attempts");
+      log.warn("async-spawn: could not read /proc/self/stat starttime after 3 attempts");
     }
     const { model: effectiveModel, provider: effectiveProvider } = resolveAgentModelProvider(agentName, agent, options?.parentModelId, options?.parentProvider, cwd, options?.explicit);
     fs.writeFileSync(path.join(workerDir, "session.json"), JSON.stringify({
@@ -854,8 +922,8 @@ export function registerAsyncAgents(
       parentStartTime,
       taskId: options?.taskId || null,
       cwd,
-      projectCwd: asyncState.lastCtx?.sessionManager?.getCwd?.() || null,
-      sessionId: asyncState.lastCtx?.sessionManager?.getSessionId?.() || null,
+      projectCwd: getLiveAsyncCtx()?.sessionManager?.getCwd?.() || null,
+      sessionId: getLiveAsyncCtx()?.sessionManager?.getSessionId?.() || null,
     }), { mode: 0o600 });
 
     // Track reviewer spawn BEFORE building args — addReviewerPending sets status to
@@ -877,7 +945,7 @@ export function registerAsyncAgents(
     // Deterministic session ID for provider cache affinity + optional session reuse.
     // When persistSession is true, omits --no-session so the session persists to disk.
     // Same agent + cwd gets the same session ID across calls.
-    const parentSessionId = asyncState.lastCtx?.sessionManager?.getSessionId?.() || '';
+    const parentSessionId = getLiveAsyncCtx()?.sessionManager?.getSessionId?.() || '';
     const sessionIdSource = persistSession
       ? agentName + ':' + cwd + ':' + parentSessionId
       : agentName + ':' + task.slice(0, 100);
@@ -910,8 +978,11 @@ export function registerAsyncAgents(
       task,
       cwd,
       model: effectiveModel,
-      contextWindow: asyncState.lastCtx?.model?.contextWindow || 0,
+      contextWindow: getLiveAsyncCtx()?.model?.contextWindow || 0,
       resultPath,
+      reviewerOutputPath: agentName.startsWith("code-reviewer-")
+        ? reviewerOutputArchivePath(PROJECT_TMP_DIR, id)
+        : undefined,
       workerDir,
       sessionId: `${process.pid}:${process.cwd()}`,
       piCommand: inv.command,
@@ -982,7 +1053,7 @@ export function registerAsyncAgents(
 
     // Fail fast with a self-explanatory error instead of spawning a child that
     // cannot load TypeScript (bare node dies on ".js"→".ts" specifiers).
-    if (!jitiCliPath) {
+    if (!jitiCliPath && !runtime.spawnProcess) {
       log.error(`async-spawn: ${id} — no jiti-cli.mjs found. Probes:\n  ${(jitiProbes.slice(-14)).join("\n  ")}`);
       // Clean up the artifacts we already created — nothing will consume them.
       try { fs.rmSync(configPath, { force: true }); } catch {}
@@ -1045,8 +1116,8 @@ export function registerAsyncAgents(
       groupId: options?.groupId,
       taskId: options?.taskId,
       cwd,
-      projectCwd: asyncState.lastCtx?.sessionManager?.getCwd?.(),
-      sessionId: asyncState.lastCtx?.sessionManager?.getSessionId?.(),
+      projectCwd: getLiveAsyncCtx()?.sessionManager?.getCwd?.(),
+      sessionId: getLiveAsyncCtx()?.sessionManager?.getSessionId?.(),
       model: effectiveModel,
     };
     asyncState.jobs.set(id, job);
@@ -1056,7 +1127,7 @@ export function registerAsyncAgents(
     stderrLog.on("error", () => {}); // never let a log write failure crash the session
     log.debug(`async-spawn: ${job.id} stderr → ${stderrLogPath}`);
 
-    const proc = spawn(process.execPath, spawnArgs, {
+    const proc = (runtime.spawnProcess ?? spawn)(process.execPath, spawnArgs, {
       cwd,
       stdio: ["ignore", "ignore", "pipe"],
       windowsHide: true,
@@ -1136,7 +1207,7 @@ export function registerAsyncAgents(
 
     // Auto-mark linked task as in_progress AFTER successful spawn
     if (options?.taskId && options.taskId !== "-1") {
-      autoMarkInProgress(options.taskId, asyncState.lastCtx?.sessionManager?.getCwd?.() || cwd, asyncState.lastCtx?.sessionManager?.getSessionId?.() || undefined)
+      autoMarkInProgress(options.taskId, getLiveAsyncCtx()?.sessionManager?.getCwd?.() || cwd, getLiveAsyncCtx()?.sessionManager?.getSessionId?.() || undefined)
         .catch(() => {});  // best-effort, don't block spawn
     }
 
@@ -1145,6 +1216,10 @@ export function registerAsyncAgents(
 
   // Start result watcher on session start
   pi.on("session_start", (_event, ctx) => {
+    if (!isLiveExtensionCtx(ctx)) {
+      log.warn("session_start received a stale ctx; preserving async results for a live session");
+      return;
+    }
     asyncState.lastCtx = ctx;
     deliveredResultIds.clear();
 
@@ -1153,6 +1228,8 @@ export function registerAsyncAgents(
     // Export as env var so prompts/CLI commands can reference it
     process.env.PROJECT_TMP_DIR = PROJECT_TMP_DIR;
 
+    cleanupReviewerOutputArchives(path.join(PROJECT_TMP_DIR, "reviewer-results"));
+
     // Scan worker directories for jobs with delivered=true in status.json
     // This is more reliable than content hashing — uses job IDs directly
     try {
@@ -1205,7 +1282,7 @@ export function registerAsyncAgents(
           try { fs.rmSync(jobDir, { recursive: true, force: true }); } catch {}
         } catch {} // skip unreadable dirs
       }
-    } catch (e: any) { console.debug("[async-agents] zombie cleanup failed:", e?.message?.slice(0, 100)); }
+    } catch (e: any) { log.error(`zombie cleanup failed: ${e?.message?.slice(0, 100)}`); }
 
     // Clean up stale result directories from dead sessions
     try {
@@ -1296,13 +1373,13 @@ export function registerAsyncAgents(
           log.info(`restored job: ${id} state=${job.status}`);
         }
       }
-    } catch (e: any) { console.debug("[async-agents] job restore failed:", e?.message || e); }
+    } catch (e: any) { log.error(`job restore failed: ${e?.message || e}`); }
 
     // Start poller if we have jobs or unprocessed result files
     let hasResultFiles = false;
     try {
       hasResultFiles = fs.existsSync(ASYNC_RESULTS_DIR) && fs.readdirSync(ASYNC_RESULTS_DIR).some(f => f.endsWith(".json"));
-    } catch (e: any) { console.debug("[async-agents] result files check failed:", e?.message || e); }
+    } catch (e: any) { log.error(`result files check failed: ${e?.message || e}`); }
     if (asyncState.jobs.size > 0 || hasResultFiles) {
       ensureAsyncPoller();
     }
@@ -1314,6 +1391,7 @@ export function registerAsyncAgents(
   // Clean up on shutdown
   pi.on("session_shutdown", () => {
     log.info(`shutdown: jobs=${asyncState.jobs.size}`);
+    asyncState.lastCtx = null;
     if (asyncState.poller) { clearInterval(asyncState.poller); asyncState.poller = null; }
     if (asyncState.watcher) { asyncState.watcher.close(); asyncState.watcher = null; }
   });
@@ -1321,6 +1399,7 @@ export function registerAsyncAgents(
   // /async-status — fullscreen overlay list → live output detail
   async function handleAsyncStatus(ctx: any): Promise<void> {
     if (!ctx.hasUI) return;
+    log.debug("opening_async_status_overlay", { jobs: asyncState.jobs.size });
     await openAsyncStatusOverlay(ctx, {
       listJobs: () => Array.from(asyncState.jobs.values()),
       killJob: (id) => {
@@ -1408,12 +1487,16 @@ export function registerAsyncAgents(
         if (pending.length === 0) {
           deliverGroupResults(groupJobs);
         }
-      } else if (asyncState.lastCtx && !job.fireAndForget) {
+      } else if (getLiveAsyncCtx() && !job.fireAndForget) {
         // Non-grouped killed job — deliver immediately so AI knows it was killed
         const displayName = job.name || job.agent;
         const duration = job.durationMs || (Date.now() - job.startedAt);
         const rawOutput = typeof job.output === "string" ? job.output : "Killed by user";
-        const output = rawOutput.slice(0, 3000);
+        const output = formatAsyncResultOutput(
+          job.agent,
+          rawOutput,
+          resultOutputPath(job),
+        );
         const killContent = `## Async Agent Result: ${displayName} ❌ failed\n\nTask: ${job.task}\nDuration: ${formatDuration(duration)}\n\n${output}`;
         if (wasAlreadyDelivered(job.id)) {
           job.delivered = true;
@@ -1524,13 +1607,15 @@ export function registerAsyncAgents(
 
   // Spawn — create an async agent from pitasks' TaskExecute
   handleRpc<{ requestId: string; type: string; prompt: string; options?: any }>(
-    "subagents:rpc:spawn", ({ type, prompt, options }) => {
-      const ctx = asyncState.lastCtx;
+    "subagents:rpc:spawn", async ({ type, prompt, options }) => {
+      const ctx = getLiveAsyncCtx();
       if (!ctx) throw new Error("No active session");
       if (!type || typeof type !== "string") throw new Error("Missing or invalid 'type' parameter");
       if (!prompt || typeof prompt !== "string") throw new Error("Missing or invalid 'prompt' parameter");
 
       const cwd = options?.cwd || ctx.cwd;
+      log.debug("rpc_spawn_requested", { type, customCwd: Boolean(options?.cwd) });
+      const discoverAgents = runtime.discoverAgents ?? (await import("./agents.js")).discoverAgents;
       const discovery = discoverAgents(cwd, "both");
       const agents = discovery.agents;
 

package/extensions/orchestrator/async-result-format.ts

@@ -0,0 +1,58 @@
+/** Format async-agent output for bounded delivery and status persistence. */
+
+import { createHash } from "node:crypto";
+import * as path from "node:path";
+import { createLogger } from "../shared/logger.js";
+
+const log = createLogger("async_agents");
+const MAX_OUTPUT_CHARS = 3000;
+
+/** Return the completed-result archive path, outside cleanup-prone worker directories. */
+export function reviewerOutputArchivePath(projectTmpDir: string, jobId: string): string {
+  const archiveDir = path.resolve(projectTmpDir, "reviewer-results");
+  const filename = `${createHash("sha256").update(jobId).digest("hex")}.json`;
+  const archivePath = path.resolve(archiveDir, filename);
+  if (path.dirname(archivePath) !== archiveDir) {
+    throw new Error("Reviewer archive destination escapes its archive root");
+  }
+  log.debug("reviewer_output_archive_path", { jobId, archivePath });
+  return archivePath;
+}
+
+/**
+ * Preserve valid reviewer JSON unless it exceeds the delivery budget.
+ * Oversized reviewer output is available only in its worker output.log.
+ */
+export function formatAsyncResultOutput(
+  agent: string,
+  output: string,
+  outputPath: string,
+  maxChars = MAX_OUTPUT_CHARS,
+): string {
+  log.debug("format_async_result_output", { agent, outputChars: output.length, maxChars });
+  if (agent.startsWith("code-reviewer-") && output.length > maxChars) {
+    try {
+      const parsed = JSON.parse(output);
+      if (parsed && typeof parsed === "object" && Array.isArray(parsed.findings)) {
+        const metadata = {
+          truncated: true,
+          format: "json",
+          outputBytes: Buffer.byteLength(output, "utf8"),
+          outputPath,
+        };
+        const serialized = JSON.stringify(metadata);
+        if (serialized.length <= maxChars) return serialized;
+        log.warn("reviewer_metadata_path_exceeds_budget", { agent, maxChars });
+        return JSON.stringify({
+          truncated: true,
+          format: "json",
+          outputBytes: metadata.outputBytes,
+          outputPathOmitted: true,
+        });
+      }
+    } catch {
+      // Invalid reviewer output retains ordinary bounded-text behavior.
+    }
+  }
+  return output.slice(0, maxChars);
+}

package/extensions/orchestrator/async-runner.ts

@@ -9,6 +9,10 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { createRequire } from "node:module";
 import { getSetting } from "./project-settings.js";
+import { createLogger } from "../shared/logger.js";
+import { archiveReviewerOutput } from "./reviewer-output-archive.js";
+
+const log = createLogger("async_agents");
 
 interface RunConfig {
   id: string;
@@ -20,6 +24,7 @@ interface RunConfig {
   tools?: string[];
   systemPrompt?: string;
   resultPath: string;
+  reviewerOutputPath?: string;
   workerDir: string;
   sessionId?: string;
   piCommand: string;
@@ -72,7 +77,7 @@ async function run(config: RunConfig): Promise<void> {
   writeJson(statusPath, status);
   let lastUsage: any = null;
 
-  const outputStream = fs.createWriteStream(outputPath, { flags: "w" });
+  const outputStream = fs.createWriteStream(outputPath, { flags: "w", mode: 0o600 });
 
   // Connect to pidash server to stream events
   const pidashPort = getSetting(config.cwd, "pidash_port");
@@ -157,7 +162,7 @@ async function run(config: RunConfig): Promise<void> {
           if (pidashWs?.readyState === 1) {
             pidashWs.send(JSON.stringify({ type: "async_event", id: config.id, event: ev }));
           }
-        } catch (e: any) { console.debug("[async-runner] event processing failed:", e?.message || e); }
+        } catch (e: any) { log.warn(`event processing skipped: ${e?.message || e}`); }
       }
 
       // Update status periodically (every ~10 lines)
@@ -193,7 +198,7 @@ async function run(config: RunConfig): Promise<void> {
           if (p.type === "text") finalOutput = p.text;
         }
       }
-    } catch (e: any) { console.debug("[async-runner] final line parse failed:", e?.message || e); }
+    } catch (e: any) { log.error(`final line parse failed: ${e?.message || e}`); }
   }
 
   // Write final status
@@ -283,7 +288,18 @@ async function run(config: RunConfig): Promise<void> {
   }
 
   // End the output stream after all retries are done
-  outputStream.end();
+  await new Promise<void>((resolve, reject) => {
+    outputStream.once("error", reject);
+    outputStream.end(resolve);
+  });
+  if (config.reviewerOutputPath && config.agent.startsWith("code-reviewer-")) {
+    try {
+      archiveReviewerOutput(outputPath, config.reviewerOutputPath);
+      log.info("archived_reviewer_output", { agent: config.agent, outputPath: config.reviewerOutputPath });
+    } catch (err) {
+      log.error("archive_reviewer_output_failed", err);
+    }
+  }
 
   // Write result for the watcher to pick up
   writeJson(config.resultPath, {

package/extensions/orchestrator/cron-status-format.ts

@@ -3,10 +3,10 @@
  */
 
 export interface CronStatusTaskView {
-  /** Unique overlay row id (e.g. "1" or "cron-123-abc.json:1"). */
+  /** Unique scope-qualified overlay row id (e.g. "session:<uuid>"). */
   id: string;
-  /** Numeric cron task id within its session file. */
-  taskId: number;
+  /** Stable UUID within its session or project scope. */
+  taskId: string | number;
   description: string;
   task: string;
   intervalMs?: number;
@@ -15,7 +15,7 @@ export interface CronStatusTaskView {
   createdAt: number;
   lastRun?: number;
   nextRun?: number;
-  /** Shown in list-all rows (e.g. "this session", "PID 42"). */
+  /** Optional scope and leader-state label shown in overlay rows. */
   sessionLabel?: string;
   isLocal?: boolean;
   cronFile?: string;
@@ -91,7 +91,7 @@ export function formatNextRunLabel(
 /** Map a CronTask-like object into an overlay row view. */
 export function toCronStatusTaskView(
   task: {
-    id: number;
+    id: string | number;
     description: string;
     task: string;
     intervalMs?: number;
@@ -110,7 +110,7 @@ export function toCronStatusTaskView(
 ): CronStatusTaskView {
   return {
     id: opts.overlayId,
-    taskId: task.id,
+    taskId: opts.overlayId,
     description: task.description,
     task: task.task,
     intervalMs: task.intervalMs,

package/extensions/orchestrator/cron-status-ui.ts

@@ -1,5 +1,5 @@
 /**
- * /cron list + list-all fullscreen overlay — list dashboard → task detail.
+ * /cron list fullscreen overlay for session and project tasks — list dashboard → task detail.
  */
 
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
@@ -25,7 +25,7 @@ export {
 
 export interface CronStatusUiDeps {
   listTasks: () => CronStatusTaskView[];
-  /** Remove by overlay row id. Return true if removed. */
+  /** Remove by scope-qualified task id. Return true if removed. */
   removeTask: (id: string) => boolean;
   title?: string;
   emptyMessage?: string;
@@ -33,7 +33,7 @@ export interface CronStatusUiDeps {
 }
 
 /**
- * Open fullscreen cron list. Loops list → detail until user closes list.
+ * Open fullscreen cron list for the selected scope. Loops list → detail until closed.
  */
 export async function openCronStatusOverlay(
   ctx: ExtensionCommandContext,