pi-orchestrator-config 4.2.0 → 4.3.2

package/extensions/orchestrator/async-agents.ts

@@ -2,11 +2,13 @@
  * Async agent infrastructure — background agent spawning, polling, result watching.
  */
 
+import { createLogger } from "../shared/logger.js";
 import { execFileSync, execSync, spawn, spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
 
 const require = createRequire(import.meta.url);
 
@@ -16,18 +18,31 @@ import { discoverAgents } 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";
-import { getMainBranch } from "./git-helpers.js";
+import {
+  getMainBranch,
+} from "./git-helpers.js";
 import { waitForResultFiles } from "./async-wait.js";
 import { openAsyncStatusOverlay } from "./async-status-ui.js";
+const log = createLogger("async_agents");
+
 export { autoCompleteTask, autoMarkInProgress } from "./task-lifecycle.js";
 import { autoCompleteTask, autoMarkInProgress } from "./task-lifecycle.js";
 import { setSlot } from "./status-bar.js";
+import { getSetting } from "./project-settings.js";
+import { substituteSettingsPlaceholders } from "./rule-placeholders.js";
+
+const SETTINGS_KEYS: Record<string, unknown> = JSON.parse(
+  fs.readFileSync(
+    path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "settings-keys.json"),
+    "utf-8",
+  ),
+);
 
 // ── Constants ────────────────────────────────────────────────────────────
 
 
 
-const ASYNC_POLL_INTERVAL_MS = 3000;
+// Resolved per-call from settings
 
 // ── Interfaces ───────────────────────────────────────────────────────────
 
@@ -44,6 +59,7 @@ export interface AsyncJob {
   exitCode?: number | null;
   durationMs?: number;
   delivered?: boolean;
+  sideEffectsApplied?: boolean;
   fireAndForget?: boolean;
   onComplete?: () => void;
   groupId?: string;
@@ -52,6 +68,7 @@ export interface AsyncJob {
   projectCwd?: string;
   sessionId?: string;
   model?: string;
+  restoredPid?: number;
 }
 
 /** Get the effective working directory for a job. */
@@ -101,20 +118,13 @@ export function registerAsyncAgents(
   pi: ExtensionAPI,
   terminalNotify: (title: string, body: string) => void,
 ): {
-  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 }) => { id: string; error?: string; model?: string };
+  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[] };
   getAsyncJobs: () => Array<{ id: string; agent: string; name?: string; task: string; status: string; startedAt: number }>;
 } {
   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
 
-  const ASYNC_DEBUG = !!process.env.PI_ASYNC_DEBUG;
-  const EARLY_LOG_PATH = ASYNC_DEBUG ? path.join(PROJECT_TMP_DIR, `early-debug-${process.pid}.log`) : "";
-  let DEBUG_LOG_PATH = EARLY_LOG_PATH; // Starts with early log, moved to project dir on session_start
-  function asyncLog(msg: string) {
-    if (!ASYNC_DEBUG || !DEBUG_LOG_PATH) return;
-    try { fs.appendFileSync(DEBUG_LOG_PATH, `${new Date().toISOString()} ${msg}\n`); } catch {}
-  }
 
   const asyncState: AsyncState = {
     jobs: new Map(),
@@ -123,6 +133,20 @@ export function registerAsyncAgents(
     lastCtx: null,
   };
 
+  // Track job IDs that have already been delivered in this session (including previous lifecycles).
+  // Populated from status.json delivered flags on session_start to prevent re-delivery after reload.
+  const deliveredResultIds = new Set<string>();
+
+  /** Check if a job result was already delivered in a previous session lifecycle. */
+  function wasAlreadyDelivered(jobId: string): boolean {
+    return deliveredResultIds.has(jobId);
+  }
+
+  /** Record a job result as delivered so it won't be re-sent after reload. */
+  function recordDelivered(jobId: string): void {
+    deliveredResultIds.add(jobId);
+  }
+
   let lastWidgetKey = "";
   function updateAsyncWidget() {
     if (!asyncState.lastCtx?.hasUI) return;
@@ -172,15 +196,88 @@ export function registerAsyncAgents(
       for (const job of asyncState.jobs.values()) {
         if (job.status === "complete" || job.status === "failed") continue;
         const status = readAsyncStatus(job.workerDir);
-        if (status) {
+        log.debug("poller_check", job.id, "workerDir exists", fs.existsSync(job.workerDir), "pid", status?.pid);
+        if (!status) {
+          // No status file — process never started or died before writing status.
+          // Check if workerDir still exists; if not, the job is definitely dead.
+          if (!fs.existsSync(job.workerDir)) {
+            // Worker dir missing (e.g. cleaned across a reload). Do NOT declare
+            // death if the worker process is still alive — trust the live PID.
+            const restoredPid = job.restoredPid;
+            const stillAlive = restoredPid
+              ? (() => { try { process.kill(restoredPid, 0); return true; } catch { return false; } })()
+              : false;
+            if (stillAlive) {
+              const elapsed = Date.now() - job.startedAt;
+              if (elapsed <= getSetting(jobCwd(job), "async_phantom_timeout_ms")) {
+                log.debug(`restored job dir missing but pid ${restoredPid} alive — waiting`, job.id);
+                continue;
+              }
+              // else fall through to failure below (grace window exceeded)
+            }
+            job.status = "failed";
+            job.output = "Agent process died without writing status";
+            job.durationMs = Date.now() - job.startedAt;
+            job.updatedAt = Date.now();
+            job.sideEffectsApplied = true;
+            log.debug(`phantom: ${job.id} — no status file, worker dir missing`);
+            if (job.agent.startsWith("code-reviewer-")) {
+              try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch {}
+            }
+            if (job.groupId) {
+              const groupJobs = Array.from(asyncState.jobs.values()).filter(j => j.groupId === job.groupId);
+              const pending = groupJobs.filter(j => j.status !== "complete" && j.status !== "failed");
+              if (pending.length === 0) deliverGroupResults(groupJobs);
+            }
+          } else {
+            // Worker dir exists but no status file — check timeout
+            const elapsed = Date.now() - job.startedAt;
+            if (elapsed > getSetting(jobCwd(job), "async_phantom_timeout_ms")) {
+              job.status = "failed";
+              job.output = `Agent process timed out — no status file after ${Math.round(elapsed / 1000)}s`;
+              job.durationMs = elapsed;
+              job.updatedAt = Date.now();
+              job.sideEffectsApplied = true;
+              log.debug(`phantom-timeout: ${job.id} — no status file after ${Math.round(elapsed / 1000)}s`);
+              if (job.agent.startsWith("code-reviewer-")) {
+                try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch {}
+              }
+              if (job.groupId) {
+                const groupJobs = Array.from(asyncState.jobs.values()).filter(j => j.groupId === job.groupId);
+                const pending = groupJobs.filter(j => j.status !== "complete" && j.status !== "failed");
+                if (pending.length === 0) deliverGroupResults(groupJobs);
+              }
+              updateAsyncWidget();
+            }
+          }
+          continue;
+        }
+        {
           job.status = status.state;
           job.updatedAt = status.lastUpdate ?? Date.now();
           if (status.exitCode !== undefined) job.exitCode = status.exitCode;
 
           // Check if process is actually alive — clean up zombies
-          if (job.status === "running" && status.pid) {
+          if (job.status === "running" && !status.pid) {
+            // Status file exists but no PID — process died before recording PID
+            job.status = "failed";
+            job.output = "Agent process died before recording PID";
+            job.durationMs = Date.now() - job.startedAt;
+            job.updatedAt = Date.now();
+            job.sideEffectsApplied = true;
+            log.debug(`phantom: ${job.id} — status file exists but no PID`);
+            if (job.agent.startsWith("code-reviewer-")) {
+              try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch {}
+            }
+            if (job.groupId) {
+              const groupJobs = Array.from(asyncState.jobs.values()).filter(j => j.groupId === job.groupId);
+              const pending = groupJobs.filter(j => j.status !== "complete" && j.status !== "failed");
+              if (pending.length === 0) deliverGroupResults(groupJobs);
+            }
+          } else if (job.status === "running" && status.pid) {
             try { process.kill(status.pid, 0); } catch {
               // Process exited — check if it wrote a result file first
+              log.debug("poller_zombie", job.id, "pid", status.pid, "checking result file");
               const resultFilePath = path.join(ASYNC_RESULTS_DIR, `${job.id}.json`);
               if (fs.existsSync(resultFilePath)) {
                 // Result file exists — ingest it so output/durationMs are populated
@@ -191,29 +288,40 @@ export function registerAsyncAgents(
                   job.exitCode = data.exitCode;
                   job.durationMs = data.durationMs;
                   job.updatedAt = Date.now();
+                  log.debug("poller_zombie_ingest", job.id, "status", job.status, "output_len", job.output?.length);
+                  let zombieSideEffectsOk = true;
                   if (job.agent.startsWith("code-reviewer-")) {
                     const findings = countFindings(typeof data.output === "string" ? data.output : "");
-                    try { recordReviewerResult(jobCwd(job), job.agent, findings < 0 ? 1 : findings); } catch {}
+                    try { recordReviewerResult(jobCwd(job), job.agent, findings < 0 ? 1 : findings); } catch (e: any) { zombieSideEffectsOk = false; log.error(`recordReviewerResult failed for ${job.agent}: ${e?.message}`); }
                   }
+                  if (job.agent === "test-automator" || job.agent === "test-runner") {
+                    try { job.status === "complete" ? markTestsPassed(jobCwd(job)) : markTestsFailed(jobCwd(job)); } catch (e: any) { zombieSideEffectsOk = false; log.error(`markTests failed for ${job.agent}: ${e?.message}`); }
+                  }
+                  if (zombieSideEffectsOk) job.sideEffectsApplied = true;
                   try { fs.unlinkSync(resultFilePath); } catch {}
                 } catch {
                   job.status = "failed";
                   job.output = "Process exited before result could be read";
                   job.durationMs = Date.now() - job.startedAt;
                   job.updatedAt = Date.now();
+                  let catchSideEffectsOk = true;
                   if (job.agent.startsWith("code-reviewer-")) {
-                    try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch {}
+                    try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch (e: any) { catchSideEffectsOk = false; log.error(`recordReviewerResult failed for ${job.agent}: ${e?.message}`); }
                   }
+                  if (catchSideEffectsOk) job.sideEffectsApplied = true;
                 }
               } else {
                 job.status = "failed";
                 job.output = "Process exited without producing results";
                 job.durationMs = Date.now() - job.startedAt;
                 job.updatedAt = Date.now();
+                log.debug("poller_zombie_no_result", job.id, "agent", job.agent, "pid", status?.pid, "elapsed_ms", Date.now() - job.startedAt);
                 // Record killed reviewer as having 0 findings — prevents permanent commit block
+                let noFileSideEffectsOk = true;
                 if (job.agent.startsWith("code-reviewer-")) {
-                  try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch { /* best-effort */ }
+                  try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch (e: any) { noFileSideEffectsOk = false; log.error(`recordReviewerResult failed for ${job.agent}: ${e?.message}`); }
                 }
+                if (noFileSideEffectsOk) job.sideEffectsApplied = true;
               }
               // Check if this completes a group — deliver remaining siblings' results
               if (job.groupId) {
@@ -224,26 +332,126 @@ export function registerAsyncAgents(
             }
           }
         }
+
       }
 
       // Fallback: check for result files the watcher may have missed
-      try {
-        const files = fs.readdirSync(ASYNC_RESULTS_DIR).filter(f => f.endsWith(".json"));
-        for (const file of files) {
-          processResultFile(path.join(ASYNC_RESULTS_DIR, file));
+      if (fs.existsSync(ASYNC_RESULTS_DIR)) {
+        try {
+          const files = fs.readdirSync(ASYNC_RESULTS_DIR).filter(f => f.endsWith(".json"));
+          for (const file of files) {
+            try {
+              processResultFile(path.join(ASYNC_RESULTS_DIR, file));
+            } catch (e: any) { log.error(`processResultFile error for ${file}: ${e?.message}`); }
+          }
+        } catch (e: any) {
+          // ENOENT = directory removed between existsSync and readdirSync — expected race
+          if ((e as NodeJS.ErrnoException).code !== "ENOENT") {
+            log.error(`result file scan error: ${e?.message}`);
+          }
         }
-      } catch (e: any) { console.debug("[async-agents] result file scan failed:", e?.message || e); }
+      }
 
-      // Remove completed/failed jobs older than 30s (skip undelivered group members)
+      // Reconciliation pass — retry side-effects + delivery for done-but-undelivered jobs
+      for (const [id, job] of asyncState.jobs.entries()) {
+        if ((job.status === "complete" || job.status === "failed") && !job.delivered) {
+          // Side-effects: ensure they fired (only mark applied when ALL succeed)
+          if (!job.sideEffectsApplied) {
+            let sideEffectsOk = true;
+            if (job.agent.startsWith("code-reviewer-")) {
+              const findings = countFindings(typeof job.output === "string" ? job.output : "");
+              try { recordReviewerResult(jobCwd(job), job.agent, findings < 0 ? 1 : findings); } catch (e: any) { sideEffectsOk = false; log.error(`reconcile: recordReviewerResult failed for ${job.agent}: ${e?.message}`); }
+            }
+            if (job.agent === "test-automator" || job.agent === "test-runner") {
+              try { job.status === "complete" ? markTestsPassed(jobCwd(job)) : markTestsFailed(jobCwd(job)); } catch (e: any) { sideEffectsOk = false; log.error(`reconcile: markTests failed for ${job.agent}: ${e?.message}`); }
+            }
+            if (sideEffectsOk) job.sideEffectsApplied = true;
+          }
+          // Delivery: retry for groups where all members are done
+          if (job.groupId) {
+            const groupJobs = Array.from(asyncState.jobs.values()).filter(j => j.groupId === job.groupId);
+            const pending = groupJobs.filter(j => j.status !== "complete" && j.status !== "failed");
+            if (pending.length === 0) {
+              deliverGroupResults(groupJobs);
+            }
+          // Delivery: retry for non-grouped jobs (zombie-ingest path may skip delivery)
+          } else if (asyncState.lastCtx && !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);
+            // Auto-complete linked task (with logging, matching processResultFile behavior)
+            let autoCompleteError = "";
+            if (job.taskId && job.taskId !== "-1" && job.status === "complete" && job.cwd) {
+              try {
+                autoCompleteTask(job.taskId, job.projectCwd || job.cwd, job.sessionId)
+                  .then((completed) => log.info(`reconcile: auto-completed task #${job.taskId}: ${completed}`))
+                  .catch((e: any) => log.error(`reconcile: auto-complete failed for task #${job.taskId}: ${e?.message}`));
+              } catch (e: any) {
+                const safeTaskId = /^-?\d+$/.test(job.taskId!) ? job.taskId : "(invalid)";
+                autoCompleteError = `\n\n⚠️ Failed to auto-complete task #${safeTaskId}: ${e?.message}. Run TaskUpdate(taskId="${safeTaskId}", status="completed") manually.`;
+                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));
+            // Emit lifecycle events
+            if (job.status === "complete") {
+              pi.events.emit("subagents:completed", { id: job.id, result: job.output || "" });
+            } else {
+              pi.events.emit("subagents:failed", { id: job.id, error: job.output || "Agent failed", result: job.output || "", status: "failed" });
+            }
+            const msgContent = `## Async Agent Result: ${displayName} ${resultStatus}\n\nTask: ${job.task}\nDuration: ${formatDuration(duration)}\n\n${output}${autoCompleteError}`;
+            if (wasAlreadyDelivered(job.id)) {
+              job.delivered = true;
+              log.debug(`reconcile: skipping already-delivered result for ${job.id}`);
+            } else {
+              log.debug("reconcile_deliver", job.id, "hasCtx", !!asyncState.lastCtx);
+              try {
+                pi.sendMessage({
+                  customType: "async-agent-result",
+                  content: msgContent,
+                  display: true,
+                }, { triggerTurn: true, deliverAs: "followUp" });
+                if (job.onComplete) {
+                  try { job.onComplete(); } catch (e: any) { log.error(`onComplete callback failed for ${job.id}: ${e?.message}`); }
+                }
+                job.delivered = true;
+                recordDelivered(job.id);
+                log.debug("reconcile_deliver_ok", job.id);
+              } catch (e: any) {
+                log.error(`reconcile: sendMessage failed for ${job.id}: ${e?.message}`);
+                // delivered stays false — will retry on next poll
+              }
+            }
+            // Persist delivered state so restore skips this job
+            if (job.delivered) {
+              try {
+                const sp = path.join(job.workerDir, "status.json");
+                const ex = fs.existsSync(sp) ? JSON.parse(fs.readFileSync(sp, "utf-8")) : {};
+                ex.delivered = true;
+                fs.writeFileSync(sp, JSON.stringify(ex), { mode: 0o600 });
+              } catch {}
+            }
+          } else if (job.fireAndForget) {
+            if (job.onComplete) {
+              try { job.onComplete(); } catch (e: any) { log.error(`onComplete callback failed for ${job.id}: ${e?.message}`); }
+            }
+            job.delivered = true;
+          }
+        }
+      }
+
+      // Remove completed/failed jobs older than 30s — require delivered before cleanup
       for (const [id, job] of asyncState.jobs.entries()) {
         if ((job.status === "complete" || job.status === "failed")
             && Date.now() - job.updatedAt > 30000
-            && (job.delivered || !job.groupId)) {
+            && job.delivered) {
           asyncState.jobs.delete(id);
         }
       }
       updateAsyncWidget();
-    }, ASYNC_POLL_INTERVAL_MS);
+    }, getSetting(process.cwd(), "async_poll_interval_ms"));
     if (asyncState.poller.unref) asyncState.poller.unref();
   }
 
@@ -260,7 +468,6 @@ export function registerAsyncAgents(
     // 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.
-    const lateIngestedIds = new Set<string>();
     // Wait for non-failed, non-fireAndForget jobs that haven't been ingested yet
     const waitJobs = groupJobs.filter(j => j.output === undefined && !j.fireAndForget && j.status !== "failed");
     if (waitJobs.length > 0) {
@@ -277,40 +484,57 @@ export function registerAsyncAgents(
         j.exitCode = data.exitCode;
         j.durationMs = data.durationMs;
         if (data.success !== undefined) j.status = data.success ? "complete" : "failed";
-        lateIngestedIds.add(j.id);
-        asyncLog(`deliverGroupResults: late-ingested result for ${j.id}`);
-      } catch (e: any) { asyncLog(`deliverGroupResults: late-ingest failed for ${j.id}: ${e?.message}`); }
+        log.debug(`deliverGroupResults: late-ingested result for ${j.id}`);
+      } catch (e: any) { log.error(`deliverGroupResults: late-ingest failed for ${j.id}: ${e?.message}`); }
     }
 
-    // Track reviewer completions for late-ingested code-reviewer jobs only
-    // (jobs already processed by processResultFile were tracked there)
+    // Track reviewer completions for ALL code-reviewer jobs in the group.
+    // processResultFile may have already called recordReviewerResult for some,
+    // but recordReviewerResult is idempotent (skips if reviewer already reported).
     for (const j of groupJobs) {
-      if (!j.agent.startsWith("code-reviewer-") || !lateIngestedIds.has(j.id)) continue;
+      if (!j.agent.startsWith("code-reviewer-")) continue;
       try {
         const output = typeof j.output === "string" ? j.output : "";
         const findings = countFindings(output);
         // -1 means invalid JSON output — treat conservatively as having findings
         recordReviewerResult(jobCwd(j), j.agent, findings < 0 ? 1 : findings);
-      } catch { /* best-effort */ }
+      } catch (e: any) { j.sideEffectsApplied = false; log.error(`recordReviewerResult failed for ${j.agent}: ${e?.message}`); continue; }
+    }
+
+    // Track test agent completions for grouped test-automator/test-runner
+    for (const j of groupJobs) {
+      if (j.agent !== "test-automator" && j.agent !== "test-runner") continue;
+      try {
+        if (j.status === "complete") {
+          markTestsPassed(jobCwd(j));
+        } else if (j.status === "failed") {
+          markTestsFailed(jobCwd(j));
+        }
+      } catch (e: any) { j.sideEffectsApplied = false; log.error(`markTests failed for ${j.agent}: ${e?.message}`); continue; }
+    }
+
+    // Mark side-effects applied per-job (only if not already marked false by a failed side-effect above)
+    for (const j of groupJobs) {
+      if (j.sideEffectsApplied !== false) j.sideEffectsApplied = true;
     }
 
     // Skip delivery if ALL jobs in group are fire-and-forget
     if (groupJobs.every(j => j.fireAndForget)) {
       for (const j of groupJobs) {
         if (j.onComplete) {
-          try { j.onComplete(); } catch (e: any) { asyncLog(`onComplete callback failed for ${j.id}: ${e?.message}`); }
+          try { j.onComplete(); } catch (e: any) { log.error(`onComplete callback failed for ${j.id}: ${e?.message}`); }
         }
         j.delivered = true;
       }
       // Clean up result files for fire-and-forget groups
       for (const j of groupJobs) {
         const rp = path.join(ASYNC_RESULTS_DIR, `${j.id}.json`);
-        try { fs.unlinkSync(rp); } catch (e: any) { asyncLog(`unlink failed ${rp}: ${e?.message}`); }
+        try { fs.unlinkSync(rp); } catch (e: any) { log.debug(`unlink failed ${rp}: ${e?.message}`); }
       }
       return;
     }
 
-    // Emit lifecycle events for pi-tasks RPC bridge (one per job)
+    // Emit lifecycle events for pitasks RPC bridge (one per job)
     for (const j of groupJobs) {
       if (j.status === "complete") {
         pi.events.emit("subagents:completed", { id: j.id, result: j.output || "" });
@@ -320,6 +544,7 @@ export function registerAsyncAgents(
     }
 
     const sections: string[] = [];
+    const deliverableJobs: AsyncJob[] = [];
     for (const j of groupJobs) {
       if (j.fireAndForget) { j.delivered = true; continue; }
       const resultStatus = j.status === "complete" ? "✅ completed" : "❌ failed";
@@ -330,29 +555,50 @@ export function registerAsyncAgents(
       if (j.taskId && j.taskId !== "-1" && j.status === "complete" && j.cwd) {
         try {
           const completed = await autoCompleteTask(j.taskId, j.projectCwd || j.cwd, j.sessionId);
-          asyncLog(`auto-completed task #${j.taskId}: ${completed}`);
+          log.info(`auto-completed task #${j.taskId}: ${completed}`);
         } catch (e: any) {
           autoCompleteError = `\n\n⚠️ Failed to auto-complete task #${j.taskId}: ${e?.message}. Run TaskUpdate(taskId="${j.taskId}", status="completed") manually.`;
-          asyncLog(`auto-complete failed for task #${j.taskId}: ${e?.message}`);
+          log.error(`auto-complete failed for task #${j.taskId}: ${e?.message}`);
         }
       }
       const duration = j.durationMs || (j.updatedAt ? j.updatedAt - j.startedAt : 0);
       sections.push(`## Async Agent Result: ${displayName} ${resultStatus}\n\nTask: ${j.task}\nDuration: ${formatDuration(duration)}\n\n${output}${autoCompleteError}`);
-      j.delivered = true;
+      deliverableJobs.push(j);
     }
 
     if (sections.length > 0) {
-      pi.sendMessage({
-        customType: "async-agent-result",
-        content: sections.join("\n\n---\n\n"),
-        display: true,
-      }, { triggerTurn: true, deliverAs: "followUp" });
+      try {
+        pi.sendMessage({
+          customType: "async-agent-result",
+          content: sections.join("\n\n---\n\n"),
+          display: true,
+        }, { triggerTurn: true, deliverAs: "followUp" });
+        // Only mark delivered AFTER sendMessage succeeds
+        for (const j of deliverableJobs) {
+          j.delivered = true;
+          // Persist delivered state so restore skips this job
+          try {
+            const sp = path.join(j.workerDir, "status.json");
+            const ex = fs.existsSync(sp) ? JSON.parse(fs.readFileSync(sp, "utf-8")) : {};
+            ex.delivered = true;
+            fs.writeFileSync(sp, JSON.stringify(ex), { mode: 0o600 });
+          } catch {}
+        }
+      } catch (e: any) {
+        log.error(`deliverGroupResults: sendMessage failed: ${e?.message}`);
+        // delivered stays false — reconciliation will retry on next poll
+      }
+    } else {
+      // No sections to deliver (all fire-and-forget) — already marked above
     }
 
-    // Clean up result files for group members now that delivery succeeded
+    // Clean up any remaining result files (most already deleted by processResultFile)
     for (const j of groupJobs) {
       const rp = path.join(ASYNC_RESULTS_DIR, `${j.id}.json`);
-      try { fs.unlinkSync(rp); } catch (e: any) { asyncLog(`unlink failed ${rp}: ${e?.message}`); }
+      try { fs.unlinkSync(rp); } catch (e: any) {
+        // ENOENT = already deleted by processResultFile — expected
+        if ((e as NodeJS.ErrnoException).code !== "ENOENT") log.debug(`unlink failed ${rp}: ${e?.message}`);
+      }
     }
     } finally {
       if (gid) groupDeliveryInProgress.delete(gid);
@@ -360,14 +606,32 @@ export function registerAsyncAgents(
   }
 
   async function processResultFile(resultPath: string) {
+    if (!fs.existsSync(resultPath)) {
+      log.debug(`processResultFile: file already deleted: ${path.basename(resultPath)}`);
+      return;
+    }
     try {
       const data = JSON.parse(fs.readFileSync(resultPath, "utf-8"));
       const job = asyncState.jobs.get(data.id);
-      asyncLog(`processResultFile: ${path.basename(resultPath)} job=${!!job} delivered=${job?.delivered} hasCtx=${!!asyncState.lastCtx} fireAndForget=${job?.fireAndForget} groupId=${job?.groupId}`);
-      if (!job) return;
-      if (job.delivered) return; // Already delivered to user
-      // Skip if already ingested (grouped jobs stay on disk until group delivers)
-      if (job.output !== undefined) return;
+      log.debug(`processResultFile: ${path.basename(resultPath)} job=${!!job} delivered=${job?.delivered} hasCtx=${!!asyncState.lastCtx} 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}`); }
+        return;
+      }
+      if (job.delivered) {
+        // Already delivered — clean up stale file
+        log.debug("processResultFile_skip_delivered", job.id);
+        try { fs.unlinkSync(resultPath); } catch (e: any) { log.debug(`stale cleanup failed: ${resultPath}: ${e?.message}`); }
+        return;
+      }
+      // Skip if already ingested — delete file to prevent re-scan every 3s
+      if (job.output !== undefined) {
+        try { fs.unlinkSync(resultPath); } catch (e: any) {
+          if ((e as NodeJS.ErrnoException).code !== "ENOENT") log.debug(`re-ingest unlink failed ${resultPath}: ${e?.message}`);
+        }
+        return;
+      }
 
       // Update job state immediately (before group check)
       job.status = data.success ? "complete" : "failed";
@@ -381,13 +645,14 @@ export function registerAsyncAgents(
       terminalNotify("pi", `Async agent ${displayName} ${data.success ? "completed" : "failed"} (${formatDuration(data.durationMs)})`);
 
       // Track reviewer completion for review loop enforcement
+      let processResultSideEffectsOk = true;
       if (job.agent.startsWith("code-reviewer-")) {
         try {
           const output = typeof data.output === "string" ? data.output : JSON.stringify(data.output ?? "");
           const findings = countFindings(output);
           // -1 means invalid JSON output — treat conservatively as having findings
           recordReviewerResult(jobCwd(job), job.agent, findings < 0 ? 1 : findings);
-        } catch { /* best-effort */ }
+        } catch (e: any) { processResultSideEffectsOk = false; log.error(`recordReviewerResult failed for ${job.agent}: ${e?.message}`); }
         // Clear reviewer session if context usage > 80% to prevent overflow on next cycle
         // Use model context window from the agent's effective model.
         // If agent uses a custom model, we pass its context window via the config.
@@ -406,7 +671,7 @@ export function registerAsyncAgents(
               for (const f of files) {
                 if (f.includes(sessId)) {
                   fs.unlinkSync(path.join(sessPath, f));
-                  asyncLog(`Cleared session for ${job.agent} (context ${Math.round(pct)}%)`);
+                  log.info(`Cleared session for ${job.agent} (context ${Math.round(pct)}%)`);
                   break;
                 }
               }
@@ -423,19 +688,33 @@ export function registerAsyncAgents(
           } else {
             markTestsFailed(jobCwd(job));
           }
-        } catch (e: any) { console.debug(`[async-agents] markTests(Passed|Failed) failed for ${job.agent}: ${e?.message}`); }
+        } catch (e: any) { processResultSideEffectsOk = false; log.error(`markTests(Passed|Failed) failed for ${job.agent}: ${e?.message}`); }
       }
 
-      // Clean up result file — for grouped jobs, defer to deliverGroupResults
-      if (!job.groupId) {
-        try { fs.unlinkSync(resultPath); } catch (e: any) { asyncLog(`unlink failed ${resultPath}: ${e?.message}`); }
-      }
+      if (processResultSideEffectsOk) job.sideEffectsApplied = true;
+
+      // Always delete result file after ingestion — data is in memory (job.output).
+      // Reconciliation uses in-memory data, not the file. Leaving files on disk
+      // causes the poller's readdirSync to re-ingest them every 3s.
+      try { fs.unlinkSync(resultPath); } catch (e: any) { log.debug(`unlink failed ${resultPath}: ${e?.message}`); }
+
+      // Persist output summary to status.json so session restore can recover it
+      // (result file is now deleted, but output must survive restart)
+      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.state = job.status;
+        existing.exitCode = job.exitCode;
+        existing.durationMs = job.durationMs;
+        fs.writeFileSync(statusPath, JSON.stringify(existing), { mode: 0o600 });
+      } catch (e: any) { log.error(`status.json output persist failed for ${job.id}: ${e?.message}`); }
 
       // Group-aware delivery: hold results until ALL jobs in the group are done
       if (job.groupId) {
         const groupJobs = Array.from(asyncState.jobs.values()).filter(j => j.groupId === job.groupId);
         const pending = groupJobs.filter(j => j.status !== "complete" && j.status !== "failed");
-        asyncLog(`group ${job.groupId}: ${groupJobs.length} total, ${pending.length} pending`);
+        log.info(`group ${job.groupId}: ${groupJobs.length} total, ${pending.length} pending`);
         if (pending.length > 0) {
           // Not all group members done yet — hold delivery
           updateAsyncWidget();
@@ -447,7 +726,7 @@ export function registerAsyncAgents(
         return;
       }
 
-      // Emit lifecycle events for pi-tasks RPC bridge
+      // Emit lifecycle events for pitasks RPC bridge
       if (data.success) {
         pi.events.emit("subagents:completed", { id: job.id, result: data.output || "" });
       } else {
@@ -455,6 +734,7 @@ export function registerAsyncAgents(
       }
 
       // Non-grouped job: deliver immediately (existing behavior)
+      let sendSucceeded = false;
       if (asyncState.lastCtx && !job.fireAndForget) {
         const resultStatus = data.success ? "✅ completed" : "❌ failed";
         let autoCompleteError = "";
@@ -462,30 +742,59 @@ export function registerAsyncAgents(
         if (job.taskId && job.taskId !== "-1" && data.success && job.cwd) {
           try {
             const completed = await autoCompleteTask(job.taskId, job.projectCwd || job.cwd, job.sessionId);
-            asyncLog(`auto-completed task #${job.taskId}: ${completed}`);
+            log.info(`auto-completed task #${job.taskId}: ${completed}`);
           } catch (e: any) {
             autoCompleteError = `\n\n⚠️ Failed to auto-complete task #${job.taskId}: ${e?.message}. Run TaskUpdate(taskId="${job.taskId}", status="completed") manually.`;
-            asyncLog(`auto-complete failed for task #${job.taskId}: ${e?.message}`);
+            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));
-        pi.sendMessage({
-          customType: "async-agent-result",
-          content: `## Async Agent Result: ${displayName} ${resultStatus}\n\nTask: ${data.task}\nDuration: ${formatDuration(data.durationMs)}\n\n${output}${autoCompleteError}`,
-          display: true,
-        }, { triggerTurn: true, deliverAs: "followUp" });
+        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
+          job.delivered = true;
+          log.debug(`processResultFile: skipping already-delivered result for ${job.id}`);
+          updateAsyncWidget();
+          return;
+        } else {
+          try {
+            pi.sendMessage({
+              customType: "async-agent-result",
+              content: pContent,
+              display: true,
+            }, { triggerTurn: true, deliverAs: "followUp" });
+            sendSucceeded = true;
+            recordDelivered(job.id);
+          } catch (e: any) {
+            log.error(`processResultFile: sendMessage failed for ${job.id}: ${e?.message}`);
+            // sendSucceeded stays false — delivered won't be set, reconciliation retries
+          }
+        }
+      } else if (job.fireAndForget) {
+        sendSucceeded = true; // fire-and-forget doesn't need sendMessage
       }
 
       // Invoke onComplete callback if registered (e.g., dreaming → rebuildAndOrganize)
       if (job.onComplete) {
-        try { job.onComplete(); } catch (e: any) { asyncLog(`onComplete callback failed for ${job.id}: ${e?.message}`); }
+        try { job.onComplete(); } catch (e: any) { log.error(`onComplete callback failed for ${job.id}: ${e?.message}`); }
+      }
+      if (sendSucceeded) {
+        job.delivered = true;
+        // Persist delivered state so restore skips this job
+        if (job.delivered) {
+          try {
+            const sp = path.join(job.workerDir, "status.json");
+            const ex = fs.existsSync(sp) ? JSON.parse(fs.readFileSync(sp, "utf-8")) : {};
+            ex.delivered = true;
+            fs.writeFileSync(sp, JSON.stringify(ex), { mode: 0o600 });
+          } catch {}
+        }
       }
-      job.delivered = true;
       // Result file already deleted above (non-grouped path)
       updateAsyncWidget();
     } catch (e: any) {
-      asyncLog(`processResultFile ERROR: ${e.message}`);
+      log.error(`processResultFile ERROR: ${e.message}`);
     }
   }
 
@@ -500,6 +809,7 @@ export function registerAsyncAgents(
       asyncState.watcher = fs.watch(ASYNC_RESULTS_DIR, (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);
         setTimeout(() => processResultFile(resultPath), 100);
@@ -513,7 +823,7 @@ export function registerAsyncAgents(
     task: string,
     cwd: string,
     agents: AgentConfig[],
-    options?: { fireAndForget?: boolean; name?: string; parentModelId?: string; parentProvider?: string; groupId?: string; taskId?: string; onComplete?: () => void; persistSession?: boolean },
+    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 } {
     const agent = agents.find(a => a.name === agentName);
     if (!agent) return { id: "", error: `Unknown agent: "${agentName}"` };
@@ -536,6 +846,7 @@ export function registerAsyncAgents(
     if (!parentStartTime) {
       console.debug("[async-agents] WARNING: 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({
       resultsDir: ASYNC_RESULTS_DIR,
       fireAndForget: options?.fireAndForget || false,
@@ -572,14 +883,18 @@ export function registerAsyncAgents(
       : agentName + ':' + task.slice(0, 100);
     const deterministicSessionId = `async-${agentName}-${djb2Hash(sessionIdSource).toString(36)}`;
     piArgs.push("--session-id", deterministicSessionId);
-    const { model: effectiveModel, provider: effectiveProvider } = resolveAgentModelProvider(agentName, agent, options?.parentModelId, options?.parentProvider, cwd);
     if (effectiveModel) piArgs.push("--model", effectiveModel);
     if (effectiveProvider) piArgs.push("--provider", effectiveProvider);
     if (agent.tools?.length) piArgs.push("--tools", agent.tools.join(","));
 
     if (agent.systemPrompt?.trim()) {
       const promptPath = path.join(workerDir, "system-prompt.md");
-      fs.writeFileSync(promptPath, agent.systemPrompt, { mode: 0o600 });
+      const resolvedPrompt = substituteSettingsPlaceholders(
+        agent.systemPrompt,
+        (key) => getSetting(cwd, key as any),
+        Object.keys(SETTINGS_KEYS),
+      );
+      fs.writeFileSync(promptPath, resolvedPrompt, { mode: 0o600 });
       piArgs.push("--append-system-prompt", promptPath);
     }
 
@@ -614,7 +929,7 @@ export function registerAsyncAgents(
       const candidate = path.join(piPkgDir, "node_modules/jiti/lib/jiti-cli.mjs");
       if (fs.existsSync(candidate)) jitiCliPath = candidate;
     } catch (e: any) {
-      asyncLog(`jiti strategy 1 (require.resolve) failed: ${e?.message || e}`);
+      log.debug(`jiti strategy 1 (require.resolve) failed: ${e?.message || e}`);
     }
     // Strategy 2: resolve from the pi binary (works for global npm installs)
     if (!jitiCliPath) {
@@ -628,7 +943,7 @@ export function registerAsyncAgents(
           if (fs.existsSync(candidate)) jitiCliPath = candidate;
         }
       } catch (e: any) {
-        asyncLog(`jiti strategy 2 (process.argv) failed: ${e?.message || e}`);
+        log.debug(`jiti strategy 2 (process.argv) failed: ${e?.message || e}`);
       }
     }
 
@@ -641,6 +956,9 @@ export function registerAsyncAgents(
       ...process.env,
       PI_SUBAGENT_CHILD: "1",
       PI_AGENT_NAME: agentName,
+      PI_PRIMARY_MODEL: process.env.PI_PRIMARY_MODEL || process.env.PI_MODEL || "",
+      __PI_CONFIG_SESSION_ID: (globalThis as any).__piConfigSessionId || "",
+      __PI_PARENT_SESSION_ID: (globalThis as any).__piConfigSessionId || "",
     };
     if (agentName.startsWith("code-reviewer-") || agentName === "test-automator" || agentName === "test-runner") {
       try {
@@ -664,14 +982,8 @@ export function registerAsyncAgents(
       }
     }
 
-    const proc = spawn(process.execPath, spawnArgs, {
-      cwd,
-      stdio: "ignore",
-      windowsHide: true,
-      env: spawnEnv,
-    });
-
-    // Track the job
+    // Register job BEFORE spawn — child can finish and write result file before
+    // jobs.set runs; watcher/poller would then treat it as orphan and delete it.
     const job: AsyncJob = {
       id,
       agent: agentName,
@@ -692,6 +1004,57 @@ export function registerAsyncAgents(
     };
     asyncState.jobs.set(id, job);
 
+    const proc = spawn(process.execPath, spawnArgs, {
+      cwd,
+      stdio: "ignore",
+      windowsHide: true,
+      env: spawnEnv,
+    });
+
+    proc.once("error", (err) => {
+      log.info(`spawn-error: ${job.id} — ${err.message}`);
+      if (job.status === "complete" || job.status === "failed") return;
+      job.status = "failed";
+      job.output = `Spawn error: ${err.message}`;
+      job.durationMs = Date.now() - job.startedAt;
+      job.updatedAt = Date.now();
+      job.sideEffectsApplied = true;
+      if (job.agent.startsWith("code-reviewer-")) {
+        try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch {}
+      }
+      if (job.groupId) {
+        const groupJobs = Array.from(asyncState.jobs.values()).filter(j => j.groupId === job.groupId);
+        const pending = groupJobs.filter(j => j.status !== "complete" && j.status !== "failed");
+        if (pending.length === 0) deliverGroupResults(groupJobs);
+      }
+      updateAsyncWidget();
+    });
+
+    proc.once("exit", (code, signal) => {
+      if (job.status === "complete" || job.status === "failed") return;
+      if (code !== 0) {
+        // Give 2s for result file to be written by async-runner
+        setTimeout(() => {
+          if (job.status === "complete" || job.status === "failed") return;
+          log.info(`spawn-exit: ${job.id} — code=${code} signal=${signal}`);
+          job.status = "failed";
+          job.output = `Process exited with code ${code} signal ${signal}`;
+          job.durationMs = Date.now() - job.startedAt;
+          job.updatedAt = Date.now();
+          job.sideEffectsApplied = true;
+          if (job.agent.startsWith("code-reviewer-")) {
+            try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch {}
+          }
+          if (job.groupId) {
+            const groupJobs = Array.from(asyncState.jobs.values()).filter(j => j.groupId === job.groupId);
+            const pending = groupJobs.filter(j => j.status !== "complete" && j.status !== "failed");
+            if (pending.length === 0) deliverGroupResults(groupJobs);
+          }
+          updateAsyncWidget();
+        }, 2000).unref();
+      }
+    });
+
     // addReviewerPending already called above (before piArgs construction)
 
     updateAsyncWidget();
@@ -710,23 +1073,35 @@ export function registerAsyncAgents(
   // Start result watcher on session start
   pi.on("session_start", (_event, ctx) => {
     asyncState.lastCtx = ctx;
+    deliveredResultIds.clear();
 
     // Set project-scoped dir first (getProjectTmpDir creates it if missing)
     PROJECT_TMP_DIR = getProjectTmpDir(ctx.cwd);
     // Export as env var so prompts/CLI commands can reference it
     process.env.PROJECT_TMP_DIR = PROJECT_TMP_DIR;
 
+    // Scan worker directories for jobs with delivered=true in status.json
+    // This is more reliable than content hashing — uses job IDs directly
+    try {
+      for (const entry of fs.readdirSync(PROJECT_TMP_DIR)) {
+        const jobDir = path.join(PROJECT_TMP_DIR, entry);
+        try {
+          if (!fs.statSync(jobDir).isDirectory()) continue;
+          const statusPath = path.join(jobDir, "status.json");
+          if (!fs.existsSync(statusPath)) continue;
+          const status = JSON.parse(fs.readFileSync(statusPath, "utf-8"));
+          if (status.delivered && status.runId) {
+            deliveredResultIds.add(status.runId);
+          }
+        } catch {}
+      }
+      if (deliveredResultIds.size > 0) {
+        log.info(`session_start: found ${deliveredResultIds.size} previously delivered job IDs`);
+      }
+    } catch (e: any) { log.error(`delivered job scan failed: ${e?.message}`); }
+
     // Set results dir — PID-scoped under project dir
     ASYNC_RESULTS_DIR = path.join(PROJECT_TMP_DIR, sessionResultsDirName());
-    const projectLogPath = path.join(PROJECT_TMP_DIR, "debug.log");
-    // Move early startup logs to project dir
-    if (EARLY_LOG_PATH && fs.existsSync(EARLY_LOG_PATH)) {
-      try {
-        fs.appendFileSync(projectLogPath, fs.readFileSync(EARLY_LOG_PATH, "utf-8"));
-        fs.unlinkSync(EARLY_LOG_PATH);
-      } catch {}
-    }
-    DEBUG_LOG_PATH = projectLogPath;
 
     // Zombie cleanup: scan project dir for dead agents
     try {
@@ -759,7 +1134,39 @@ export function registerAsyncAgents(
       }
     } catch (e: any) { console.debug("[async-agents] zombie cleanup failed:", e?.message?.slice(0, 100)); }
 
-    asyncLog(`session_start: resultsDir=${path.basename(ASYNC_RESULTS_DIR)}`);
+    // Clean up stale result directories from dead sessions
+    try {
+      for (const entry of fs.readdirSync(PROJECT_TMP_DIR)) {
+        if (!entry.startsWith("async-results-pid-")) continue;
+        const resultDir = path.join(PROJECT_TMP_DIR, entry);
+        if (resultDir === ASYNC_RESULTS_DIR) continue; // skip our own
+        try {
+          if (!fs.statSync(resultDir).isDirectory()) continue;
+          // Extract PID and starttime from directory name
+          // Format: async-results-pid-{pid}-{starttime} (current) or async-results-pid-{pid} (legacy)
+          const match = entry.match(/^async-results-pid-(\d+)(?:-(\d+))?$/);
+          if (!match) continue;
+          const dirPid = parseInt(match[1], 10);
+          const dirStartTime = match[2]; // undefined for legacy PID-only format
+          let parentAlive = false;
+          try {
+            const stat = fs.readFileSync(`/proc/${dirPid}/stat`, "utf-8");
+            const currentStartTime = parseProcStartTime(stat);
+            if (currentStartTime) {
+              // With starttime: must match exactly. Without: PID alive = keep (conservative)
+              parentAlive = dirStartTime ? currentStartTime === dirStartTime : true;
+            }
+          } catch {} // /proc not found = dead
+          if (!parentAlive) {
+            // Parent dead — clean up entire result directory
+            try { fs.rmSync(resultDir, { recursive: true, force: true }); } catch {}
+            log.info(`cleaned stale result dir: ${entry}`);
+          }
+        } catch {} // skip unreadable dirs
+      }
+    } catch (e: any) { log.error(`stale result dir cleanup failed: ${e?.message?.slice(0, 100)}`); }
+
+    log.info(`session_start: resultsDir=${path.basename(ASYNC_RESULTS_DIR)}`);
 
     // Restore jobs from status files in PROJECT_TMP_DIR that belong to this session
     try {
@@ -780,8 +1187,17 @@ export function registerAsyncAgents(
         if (!id || asyncState.jobs.has(id)) continue;
         const isAlive = status.pid ? (() => { try { process.kill(status.pid, 0); return true; } catch { return false; } })() : false;
         const isComplete = status.state === "complete" || status.state === "failed";
-        // Always restore — poller's zombie check will mark dead ones as failed
-        if (isAlive || isComplete || status.state === "running") {
+        // Skip completed/failed jobs — they were already delivered. Clean up worker dir.
+        if (isComplete) {
+          try { fs.rmSync(jobDir, { recursive: true, force: true }); } catch {}
+          log.debug(`cleaned completed worker dir on restore: ${entry} (state=${status.state})`);
+          continue;
+        }
+        // Only restore running/queued jobs with alive processes
+        log.debug("restore_check", id, "isAlive", isAlive, "state", status.state);
+        if (isAlive || status.state === "running") {
+          // No result file = already processed and delivered — mark as delivered
+          const hasResultFile = fs.existsSync(path.join(ASYNC_RESULTS_DIR, `${id}.json`));
           const job: AsyncJob = {
             id,
             agent: status.agent || "unknown",
@@ -792,15 +1208,19 @@ export function registerAsyncAgents(
             updatedAt: status.lastUpdate || Date.now(),
             exitCode: status.exitCode,
             durationMs: status.endedAt ? status.endedAt - status.startedAt : undefined,
+            output: status.output || undefined,
+            delivered: isComplete,
+            sideEffectsApplied: isComplete,
             fireAndForget: marker.fireAndForget || false,
             taskId: marker.taskId || undefined,
             cwd: marker.cwd || undefined,
             projectCwd: marker.projectCwd || undefined,
             sessionId: marker.sessionId || undefined,
             model: status.model || marker.model || undefined,
+            restoredPid: typeof status.pid === "number" ? status.pid : undefined,
           };
           asyncState.jobs.set(id, job);
-          asyncLog(`restored job: ${id} state=${job.status}`);
+          log.info(`restored job: ${id} state=${job.status}`);
         }
       }
     } catch (e: any) { console.debug("[async-agents] job restore failed:", e?.message || e); }
@@ -820,7 +1240,7 @@ export function registerAsyncAgents(
 
   // Clean up on shutdown
   pi.on("session_shutdown", () => {
-    asyncLog(`shutdown: jobs=${asyncState.jobs.size}`);
+    log.info(`shutdown: jobs=${asyncState.jobs.size}`);
     if (asyncState.poller) { clearInterval(asyncState.poller); asyncState.poller = null; }
     if (asyncState.watcher) { asyncState.watcher.close(); asyncState.watcher = null; }
   });
@@ -889,10 +1309,25 @@ export function registerAsyncAgents(
       killed.push(label);
       job.status = "failed";
       job.updatedAt = Date.now();
+      job.durationMs = Date.now() - job.startedAt;
+      // Persist killed state to disk — prevents stale re-delivery on reload
+      try {
+        const statusPath = path.join(job.workerDir, "status.json");
+        const existing = fs.existsSync(statusPath) ? JSON.parse(fs.readFileSync(statusPath, "utf-8")) : {};
+        existing.state = "failed";
+        existing.exitCode = -9;
+        existing.endedAt = Date.now();
+        existing.output = "Killed by user";
+        fs.writeFileSync(statusPath, JSON.stringify(existing), { mode: 0o600 });
+      } catch (e: any) { log.error(`kill: status.json update failed for ${job.id}: ${e?.message}`); }
+      // Delete result file if it exists — prevent re-ingestion on reload
+      try { fs.unlinkSync(path.join(ASYNC_RESULTS_DIR, `${job.id}.json`)); } catch {}
       // Record killed reviewer as having 0 findings — prevents permanent commit block
+      let killSideEffectsOk = true;
       if (job.agent.startsWith("code-reviewer-")) {
-        try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch { /* best-effort */ }
+        try { recordReviewerResult(jobCwd(job), job.agent, 0); } catch (e: any) { killSideEffectsOk = false; log.error(`recordReviewerResult failed for ${job.agent}: ${e?.message}`); }
       }
+      if (killSideEffectsOk) job.sideEffectsApplied = true;
       // Check if this completes a group — deliver remaining siblings' results
       if (job.groupId) {
         const groupJobs = Array.from(asyncState.jobs.values()).filter(j => j.groupId === job.groupId);
@@ -900,9 +1335,35 @@ export function registerAsyncAgents(
         if (pending.length === 0) {
           deliverGroupResults(groupJobs);
         }
+      } else if (asyncState.lastCtx && !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 killContent = `## Async Agent Result: ${displayName} ❌ failed\n\nTask: ${job.task}\nDuration: ${formatDuration(duration)}\n\n${output}`;
+        if (wasAlreadyDelivered(job.id)) {
+          job.delivered = true;
+          log.debug(`kill: skipping already-delivered result for ${job.id}`);
+        } else {
+          try {
+            pi.sendMessage({
+              customType: "async-agent-result",
+              content: killContent,
+              display: true,
+            }, { triggerTurn: true, deliverAs: "followUp" });
+            job.delivered = true;
+            recordDelivered(job.id);
+          } catch (e: any) {
+            log.error(`kill delivery failed for ${job.id}: ${e?.message}`);
+            // delivered stays false — reconciliation will retry
+          }
+        }
+      } else if (job.fireAndForget) {
+        job.delivered = true;
       }
-      // Delay cleanup — skip auto-delete for undelivered group members (let reaper handle them)
-      if (!job.groupId || job.delivered) {
+      // Delay cleanup — only for delivered jobs
+      if (job.delivered) {
         setTimeout(() => { asyncState.jobs.delete(job.id); updateAsyncWidget(); }, 5000);
       }
     }
@@ -958,7 +1419,7 @@ export function registerAsyncAgents(
   });
 
   // ── pi-subagents RPC compatibility bridge ──────────────────────────────
-  // Implements the subagents:rpc:* protocol so pi-tasks' TaskExecute
+  // Implements the subagents:rpc:* protocol so pitasks' TaskExecute
   // can spawn our agents. Protocol version 2 matches @tintinweb/pi-subagents.
 
   const RPC_PROTOCOL_VERSION = 2;
@@ -988,7 +1449,7 @@ export function registerAsyncAgents(
     return { version: RPC_PROTOCOL_VERSION };
   });
 
-  // Spawn — create an async agent from pi-tasks' TaskExecute
+  // 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;
@@ -1007,7 +1468,7 @@ export function registerAsyncAgents(
 
       const result = spawnAsyncAgent(agentName, prompt, cwd, agents, {
         name: options?.description || agentName,
-        taskId: "-1",  // pi-tasks manages its own task linkage via agentTaskMap
+        taskId: "-1",  // pitasks manages its own task linkage via agentTaskMap
         fireAndForget: false,
       });
 
@@ -1024,7 +1485,7 @@ export function registerAsyncAgents(
     },
   );
 
-  // Emit subagents:ready so pi-tasks can discover us
+  // Emit subagents:ready so pitasks can discover us
   pi.on("session_start", () => {
     pi.events.emit("subagents:ready", {});
   });