@bermudi/pi-delegate 0.1.13 → 0.1.15

package/session-quarantine.ts

@@ -0,0 +1,266 @@
+import { existsSync } from "node:fs";
+import type { ResolvedTask } from "./types.ts";
+import { canonicalPath } from "./trusted-paths.ts";
+import { resolveCwd } from "./utils.ts";
+
+/**
+ * Internal, non-serialized hand-off for a runner that returned before its
+ * AgentSession was proven quiescent. Symbol properties survive object spreads
+ * inside delegate, but JSON/tool-result serialization ignores them.
+ */
+const SESSION_QUARANTINE = Symbol("delegate.sessionQuarantine");
+
+export interface SessionQuarantine {
+  /** Resolves only after background termination and quiescence checks confirm
+   * that the abandoned AgentSession can no longer mutate its workspace. */
+  safe: Promise<void>;
+}
+
+export type WithSessionQuarantine = {
+  [SESSION_QUARANTINE]?: SessionQuarantine;
+};
+
+interface QuarantineReservation {
+  task: ResolvedTask;
+  quarantine: SessionQuarantine;
+  /** Physical transcript identity used to acquire the abandoned session.
+   * This is passed through from acquisition and must never be re-resolved at
+   * publication time: a symlink may have changed while the task was running. */
+  resumeFromIdentity?: string;
+}
+
+/** Identity snapshot supplied while a resume transcript lock is held. */
+export interface LockedResumeTranscript {
+  /** Stable absolute spelling used even when the transcript does not exist. */
+  lexicalPath: string;
+  /** Physical target captured once for this acquisition. */
+  canonicalPath?: string;
+  /** The captured physical target still existed after this call acquired all
+   * applicable lexical/physical locks. */
+  exists: boolean;
+}
+
+/** Process-local admission reservations for abandoned tasks. A reservation is
+ * removed only when its safety proof fulfills; rejection is not evidence that
+ * the session stopped mutating. */
+const quarantineReservations = new Map<symbol, QuarantineReservation>();
+
+/** Per-transcript locks close the validation-to-dispatch race for resume-only
+ * tasks (which have no sessionId and therefore do not use the pool lock). */
+const resumeFromLocks = new Map<string, Promise<void>>();
+
+/** Resolve an existing resume transcript to its current physical identity.
+ * Admission-time callers use this as a best-effort early rejection only; the
+ * lifecycle lock captures and carries the authoritative acquisition identity. */
+export function canonicalResumeFromIdentity(
+  resumeFrom: string | undefined,
+): string | undefined {
+  return resumeFrom ? canonicalPath(resolveCwd(resumeFrom)) : undefined;
+}
+
+function logObserverFailure(description: string, error: unknown): void {
+  try {
+    console.error(`[delegate] ${description}`, error);
+  } catch {
+    // A cleanup observer must never turn a handled background failure into an
+    // unhandled rejection, even when a test or host replaces console.error.
+  }
+}
+
+/** Observe a safety proof without creating a dangling rejecting promise.
+ * Callback failures are surfaced and swallowed because cleanup must not become
+ * a process-level unhandled rejection. */
+export function observeQuarantineSafety(
+  quarantine: SessionQuarantine,
+  description: string,
+  onSafe: () => void | Promise<void>,
+  onFailure?: (error: unknown) => void | Promise<void>,
+): void {
+  const invoke = async (
+    callback: (() => void | Promise<void>) | undefined,
+  ): Promise<void> => {
+    if (!callback) return;
+    try {
+      await callback();
+    } catch (error) {
+      logObserverFailure(`${description} callback failed`, error);
+    }
+  };
+
+  // Both branches fulfill. The final catch is defensive against an unusual
+  // Promise implementation or callback plumbing regression.
+  void quarantine.safe
+    .then(
+      () => invoke(onSafe),
+      (error) =>
+        invoke(
+          onFailure
+            ? () => onFailure(error)
+            : () =>
+                logObserverFailure(`${description} safety proof failed`, error),
+        ),
+    )
+    .catch((error) =>
+      logObserverFailure(`${description} observer failed`, error),
+    );
+}
+
+/** Reserve the task's shared-write capability and logical session identities
+ * until safe. `resumeFromIdentity` must be the exact canonical path passed to
+ * acquisition; publication deliberately performs no mutable-path lookup. */
+export function reserveSessionQuarantine(
+  task: ResolvedTask,
+  quarantine: SessionQuarantine,
+  resumeFromIdentity: string | undefined,
+): void {
+  const key = Symbol("quarantined-task");
+  quarantineReservations.set(key, {
+    task,
+    quarantine,
+    resumeFromIdentity,
+  });
+  observeQuarantineSafety(
+    quarantine,
+    "quarantine admission reservation release",
+    () => {
+      quarantineReservations.delete(key);
+    },
+    // Fail closed: a rejected proof retains the reservation indefinitely.
+    () => {},
+  );
+}
+
+/** Snapshot abandoned tasks that admission must treat as still active. */
+export function quarantinedTasks(): ResolvedTask[] {
+  return [...quarantineReservations.values()].map(({ task }) => task);
+}
+
+export function isSessionIdQuarantined(sessionId: string): boolean {
+  for (const { task } of quarantineReservations.values()) {
+    if (task.sessionId === sessionId) return true;
+  }
+  return false;
+}
+
+export function isResumeFromIdentityQuarantined(identity: string): boolean {
+  for (const reservation of quarantineReservations.values()) {
+    if (reservation.resumeFromIdentity === identity) return true;
+  }
+  return false;
+}
+
+export function isResumeFromQuarantined(resumeFrom: string): boolean {
+  const identity = canonicalResumeFromIdentity(resumeFrom);
+  return identity ? isResumeFromIdentityQuarantined(identity) : false;
+}
+
+async function withResumeLockKeys<T>(
+  identities: string[],
+  fn: () => Promise<T>,
+): Promise<T> {
+  const keys = [...new Set(identities)].sort();
+  const previous = keys
+    .map((identity) => resumeFromLocks.get(identity))
+    .filter((pending): pending is Promise<void> => pending !== undefined);
+  let release!: () => void;
+  const current = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  // Publish every claim before waiting. A later caller sharing any lexical or
+  // physical identity therefore queues behind this owner rather than racing a
+  // different key in the set.
+  for (const identity of keys) resumeFromLocks.set(identity, current);
+  try {
+    await Promise.all(previous);
+    return await fn();
+  } finally {
+    release();
+    for (const identity of keys) {
+      if (resumeFromLocks.get(identity) === current) {
+        resumeFromLocks.delete(identity);
+      }
+    }
+  }
+}
+
+/** Serialize transcript acquisition without trusting a mutable path twice.
+ *
+ * Every call claims its stable absolute lexical spelling, so missing and
+ * unresolvable paths never fail open. Existing targets additionally claim the
+ * pre-wait canonical snapshot, which serializes symlink aliases and pins a
+ * queued call to the target it named when it entered. If a formerly missing
+ * path becomes resolvable while waiting, its new physical key is claimed
+ * before the callback runs. Existence is then checked under all applicable
+ * locks and the same canonical path is passed through to acquisition. */
+export async function withResumeTranscriptLock<T>(
+  resumeFrom: string | undefined,
+  fn: (transcript: LockedResumeTranscript | undefined) => Promise<T>,
+): Promise<T> {
+  if (!resumeFrom) return fn(undefined);
+
+  const lexicalPath = resolveCwd(resumeFrom);
+  const preWaitCanonicalPath = canonicalPath(lexicalPath);
+  const initialKeys = preWaitCanonicalPath
+    ? [lexicalPath, preWaitCanonicalPath]
+    : [lexicalPath];
+
+  return withResumeLockKeys(initialKeys, async () => {
+    // Preserve an existing target captured before waiting. Only retry
+    // canonicalization when there was no target to capture at call entry.
+    const canonicalPathOnce =
+      preWaitCanonicalPath ?? canonicalPath(lexicalPath);
+    const invoke = async (): Promise<T> =>
+      fn({
+        lexicalPath,
+        canonicalPath: canonicalPathOnce,
+        exists:
+          canonicalPathOnce !== undefined && existsSync(canonicalPathOnce),
+      });
+
+    // A missing/broken symlink can become a physical alias while queued. Claim
+    // that identity before validation/acquisition so it cannot race an owner
+    // that entered through the physical path or another alias.
+    if (canonicalPathOnce && !initialKeys.includes(canonicalPathOnce)) {
+      return withResumeLockKeys([canonicalPathOnce], invoke);
+    }
+    return invoke();
+  });
+}
+
+/** @internal Test-only reset. Existing safety observers are token-scoped, so a
+ * late fulfillment cannot delete a reservation created after the reset. */
+export function _resetQuarantineRegistryForTesting(): void {
+  quarantineReservations.clear();
+  resumeFromLocks.clear();
+}
+
+export function markSessionQuarantined<T extends object>(
+  value: T,
+  quarantine: SessionQuarantine,
+): T & WithSessionQuarantine {
+  Object.defineProperty(value, SESSION_QUARANTINE, {
+    value: quarantine,
+    enumerable: true,
+    configurable: false,
+    writable: false,
+  });
+  return value as T & WithSessionQuarantine;
+}
+
+export function sessionQuarantineOf(
+  value: object | undefined,
+): SessionQuarantine | undefined {
+  return value
+    ? (value as WithSessionQuarantine)[SESSION_QUARANTINE]
+    : undefined;
+}
+
+/** Preserve quarantine across explicit result projections that do not use an
+ * object spread. */
+export function propagateSessionQuarantine<T extends object>(
+  source: object,
+  target: T,
+): T {
+  const quarantine = sessionQuarantineOf(source);
+  return quarantine ? markSessionQuarantined(target, quarantine) : target;
+}

package/spill.ts

@@ -4,6 +4,34 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { getOutputSpillTail, getOutputSpillThreshold } from "./config.ts";
 
+const SPILL_PREFIX = "delegate-output-";
+const RANDOM_SUFFIX_BYTES = 16;
+const CREATE_ATTEMPTS = 5;
+
+type SpillFileOperations = {
+  open: (filePath: string, flags: string, mode: number) => number;
+  write: (fd: number, output: string) => void;
+  close: (fd: number) => void;
+  remove: (filePath: string) => void;
+};
+
+const defaultSpillFileOperations: SpillFileOperations = {
+  open: (filePath, flags, mode) => fs.openSync(filePath, flags, mode),
+  write: (fd, output) => fs.writeFileSync(fd, output),
+  close: (fd) => fs.closeSync(fd),
+  remove: (filePath) => fs.rmSync(filePath, { force: true }),
+};
+let spillFileOperations = defaultSpillFileOperations;
+
+/** @internal Test-only I/O seam for deterministic write/cleanup failures. */
+export function _setSpillFileOperationsForTesting(
+  overrides: Partial<SpillFileOperations> | undefined,
+): void {
+  spillFileOperations = overrides
+    ? { ...defaultSpillFileOperations, ...overrides }
+    : defaultSpillFileOperations;
+}
+
 // ── Spill: keep subagent final-output bloat out of the LLM context ───────
 //
 // Two audiences share one source of truth (`result.output`):
@@ -13,8 +41,10 @@ import { getOutputSpillTail, getOutputSpillThreshold } from "./config.ts";
 //
 // The spill is a greppable plain-text `.md` projection of the *final output*
 // only. The full transcript already lives in the session `.jsonl`; this does
-// not duplicate it. Design: lossless always — if the spill write fails, we
-// degrade to today's behavior (full output in context) rather than hard-truncate.
+// not duplicate it. Delegate never deletes spills because their pointers can
+// persist in transcripts; lifecycle is left to the OS temp policy. Design:
+// lossless always — if the spill write fails, we degrade to today's behavior
+// (full output in context) rather than hard-truncate.
 
 /** Decision over an output string: spill or not, and what stays in-context. */
 export interface SpillDecision {
@@ -50,33 +80,68 @@ export function decideSpill(
   return { spill: true, inContext: tailOf(output, opts.tailChars), fullChars };
 }
 
+function errorCode(error: unknown): unknown {
+  return typeof error === "object" && error !== null && "code" in error
+    ? (error as { code?: unknown }).code
+    : undefined;
+}
+
 /**
  * Write the full output to a temp `.md` file and return its path, or `null`
  * on failure. Never throws — callers rely on the lossless-degrade guarantee.
  *
- * Path shape: `os.tmpdir()/delegate-output-<sanitized-label>-<6hex>.md`,
- * mode 0o600. The label is sanitized (subagent precedent) so agent names
- * can't escape the filename. `suffix` (and `dir`) are injectable so tests get
- * deterministic, collision-free names and can point at an unwritable dir to
- * exercise the failure path without mocking.
+ * Files are mode 0o600 and opened with `wx`: even an improbable collision can
+ * never overwrite another spill. Production names use 128 bits of randomness
+ * and retry collisions. `suffix` and `dir` remain injectable for focused I/O
+ * tests; a supplied suffix is attempted exactly once.
  */
 export function spillToTempFile(
   output: string,
   label: string,
-  suffix: string = randomBytes(3).toString("hex"),
+  suffix?: string,
   dir: string = os.tmpdir(),
 ): string | null {
-  const safeLabel = label.replace(/[^\w.-]+/g, "_");
-  const filePath = path.join(dir, `delegate-output-${safeLabel}-${suffix}.md`);
-  try {
-    fs.writeFileSync(filePath, output, { mode: 0o600 });
-    return filePath;
-  } catch (e) {
-    console.warn(
-      `[delegate] spill write failed (${filePath}): ${e instanceof Error ? e.message : String(e)}`,
-    );
-    return null;
+  const safeLabel = label.replace(/[^\w.-]+/g, "_").slice(0, 64) || "agent";
+  const attempts = suffix === undefined ? CREATE_ATTEMPTS : 1;
+  let lastPath = path.join(dir, `${SPILL_PREFIX}${safeLabel}-unknown.md`);
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    let fd: number | undefined;
+    try {
+      const candidate =
+        suffix ?? randomBytes(RANDOM_SUFFIX_BYTES).toString("hex");
+      lastPath = path.join(dir, `${SPILL_PREFIX}${safeLabel}-${candidate}.md`);
+      fd = spillFileOperations.open(lastPath, "wx", 0o600);
+      spillFileOperations.write(fd, output);
+      spillFileOperations.close(fd);
+      return lastPath;
+    } catch (error) {
+      lastError = error;
+      if (fd !== undefined) {
+        try {
+          spillFileOperations.close(fd);
+        } catch {
+          // Continue to remove the incomplete file below.
+        }
+        try {
+          spillFileOperations.remove(lastPath);
+        } catch (cleanupError) {
+          console.warn(
+            `[delegate] spill partial-file cleanup failed (${lastPath}): ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`,
+          );
+        }
+      }
+      const code = errorCode(error);
+      if (suffix === undefined && code === "EEXIST") continue;
+      break;
+    }
   }
+
+  console.warn(
+    `[delegate] spill write failed (${lastPath}): ${lastError instanceof Error ? lastError.message : String(lastError)}`,
+  );
+  return null;
 }
 
 /**
@@ -119,17 +184,23 @@ export function renderOutputForLLM(
  * The output is a moving target mid-flight (a done task's full spill lands at
  * ticket completion via `formatCompletedTask`); writing a file per poll would
  * churn paths and confuse the LLM. So the poll stays bounded with a tail and
- * a note pointing to the eventual spill. Under the tail budget → unchanged.
+ * accurately says whether completion will spill or include the full output.
+ * Under the tail budget → unchanged.
  */
 export function renderOutputForPoll(
   output: string,
-  opts?: { tailChars?: number },
+  opts?: { tailChars?: number; thresholdChars?: number },
 ): string {
   if (!output || !output.trim() || output === "(no output)") return output;
   const tailChars = opts?.tailChars ?? getOutputSpillTail();
   if (output.length <= tailChars) return output;
+  const thresholdChars = opts?.thresholdChars ?? getOutputSpillThreshold();
   const tail = tailOf(output, tailChars);
-  return `…${tail}\n[truncated — full output is spilled to a file when the ticket completes]`;
+  const completionNote =
+    output.length > thresholdChars
+      ? "full output will spill to a file if possible when the ticket completes, with full in-result inclusion as the fallback"
+      : "full output will be included when the ticket completes";
+  return `…${tail}\n[truncated in this poll — ${completionNote}]`;
 }
 
 /** Assemble the tail + pointer block emitted on a successful spill. */
@@ -138,7 +209,7 @@ function spillPointer(
   filePath: string,
   fullChars: number,
 ): string {
-  return `…${tail}\n\n[full output (${humanSize(fullChars)}) spilled to ${filePath} —\n \`read\`/\`grep\` it if completeness matters here; above is the tail]`;
+  return `…${tail}\n\n[full output (${humanSize(fullChars)}) spilled to ${filePath} —\n retention follows OS temp policy; \`read\`/\`grep\` it if completeness matters here; above is the tail]`;
 }
 
 /**

package/task-resolution.ts

@@ -13,7 +13,12 @@ import {
 } from "./tools.ts";
 import { configFor } from "./pool.ts";
 import { isSessionBusy } from "./tickets.ts";
+import {
+  isResumeFromQuarantined,
+  isSessionIdQuarantined,
+} from "./session-quarantine.ts";
 import { BUILTIN_AGENT_CONFIGS, buildSubagentSystemPrompt } from "./agents.ts";
+import { formatResumeTag } from "./format.ts";
 import { buildParentTranscript } from "./parent-context.ts";
 import { findAvailableAlternative, resolveModelRequest } from "./model.ts";
 import {
@@ -25,10 +30,6 @@ import {
 } from "./config.ts";
 import type { DelegateConfig } from "./config.ts";
 import { resolveCwd } from "./utils.ts";
-import {
-  loadDelegateSettings,
-  warnLegacyDelegateSettingsMoved,
-} from "./settings.ts";
 import type {
   AgentConfig,
   DelegateToolCtx,
@@ -171,6 +172,32 @@ export function validateTasks(
     );
   }
 
+  // An abandoned session is detached from the pool, but reusing its caller key
+  // before background safety confirmation would create a second live owner for
+  // the same logical session in both sync and async dispatches.
+  const quarantinedSessions = sessionIds.filter(isSessionIdQuarantined);
+  if (quarantinedSessions.length) {
+    return noticeResult(
+      `SessionId(s) quarantined after abandonment: ${quarantinedSessions.join(", ")}. Wait for background safety confirmation before reusing each sessionId.`,
+      tasks,
+      parentModelId,
+    );
+  }
+
+  const quarantinedResumes = tasks
+    .map((task) => task.resumeFrom)
+    .filter(
+      (resumeFrom): resumeFrom is string =>
+        resumeFrom !== undefined && isResumeFromQuarantined(resumeFrom),
+    );
+  if (quarantinedResumes.length) {
+    return noticeResult(
+      `resumeFrom transcript(s) quarantined after abandonment: ${[...new Set(quarantinedResumes)].join(", ")}. Wait for background safety confirmation before resuming each transcript.`,
+      tasks,
+      parentModelId,
+    );
+  }
+
   // Disallow sessionIds already claimed by a running async ticket.
   const busyConflicts: string[] = [];
   for (const sid of sessionIds) {
@@ -238,9 +265,7 @@ export function resolveTasks(
     ctx.getSystemPrompt?.(),
   );
 
-  // Modern overrides come from delegate.json. A one-release bridge below also
-  // reads legacy settings.json model/thinking values; modern values win
-  // field-by-field and legacy tools are never honored.
+  // Agent overrides come exclusively from the user-scoped delegate.json.
   const agentOverrides = getAgentOverrides(dispatchConfig);
   const overridesByParentModel = getAgentOverridesByParentModel(dispatchConfig);
 
@@ -252,13 +277,6 @@ export function resolveTasks(
     const isBuiltinAgent = agent?.builtin === true;
     const cwd = resolveCwd(t.cwd ?? ctx.cwd, ctx.cwd);
 
-    // A task can resolve to a different cwd than the parent; legacy
-    // `delegate` blocks in those project settings must be surfaced too.
-    warnLegacyDelegateSettingsMoved(cwd, (message) =>
-      ctx.ui?.notify(message, "warning"),
-    );
-    const legacySettings = loadDelegateSettings(cwd);
-
     // delegate.json agent overrides for this agent. `default` bypasses them
     // entirely (it mirrors the live parent by contract).
     const parentModelKey = ctx.model
@@ -275,20 +293,6 @@ export function resolveTasks(
       t.agent && !isDefaultAgent
         ? getOwnMapValue(agentOverrides, t.agent)
         : undefined;
-    const legacyParentModelOverride =
-      t.agent && !isDefaultAgent && parentModelKey
-        ? getOwnMapValue(
-            getOwnMapValue(
-              legacySettings?.agentOverridesByParentModel,
-              parentModelKey,
-            ),
-            t.agent,
-          )
-        : undefined;
-    const legacyAgentOverride =
-      t.agent && !isDefaultAgent
-        ? getOwnMapValue(legacySettings?.agentOverrides, t.agent)
-        : undefined;
 
     // Build system prompt. Explicit task prompts and named agent prompts
     // win; ad-hoc subagents inherit the parent's base prompt when Pi exposes
@@ -426,11 +430,10 @@ export function resolveTasks(
 
     if (t.sessionAction !== "close" && t.sessionAction !== "list") {
       const agentType = t.agent ?? "inline";
-      // The built-in `default` profile bypasses delegate/settings model
-      // overrides for backwards compatibility. The other built-ins accept
-      // task and settings.json model overrides, but deliberately ignore the
-      // legacy delegate.json agent model map so they inherit the parent unless
-      // an explicit modern override wins.
+      // The built-in `default` profile bypasses delegate.json model overrides.
+      // The other built-ins accept task and modern agent overrides, but
+      // deliberately ignore the legacy delegate.json agent model map so they
+      // inherit the parent unless an explicit modern override wins.
       // Overridden built-ins can still provide an explicit `model` in their
       // Markdown frontmatter – when `explicitModel` is set, honor it instead
       // of silently ignoring it (which would contradict the Markdown contract).
@@ -440,16 +443,10 @@ export function resolveTasks(
           ? (t.model ??
             parentModelOverride?.model ??
             agentOverride?.model ??
-            legacyParentModelOverride?.model ??
-            legacyAgentOverride?.model ??
             (agent?.explicitModel ? agent.model : undefined))
           : resolveModelSpec({
               taskModel:
-                t.model ??
-                parentModelOverride?.model ??
-                agentOverride?.model ??
-                legacyParentModelOverride?.model ??
-                legacyAgentOverride?.model,
+                t.model ?? parentModelOverride?.model ?? agentOverride?.model,
               agentType,
               frontmatterModel: agent?.model,
               config: dispatchConfig,
@@ -477,7 +474,16 @@ export function resolveTasks(
         } else if (isDefaultAgent) {
           requestedModel = ctx.model;
         }
-        model = pooledConfig.model;
+        const frozenModel = pooledConfig.model;
+        // configFor() returns a defensive clone. Recover the registry's
+        // canonical instance for downstream identity compatibility while the
+        // pool keeps validating against its immutable value snapshot.
+        model =
+          ctx.model?.provider === frozenModel.provider &&
+          ctx.model.id === frozenModel.id
+            ? ctx.model
+            : (ctx.modelRegistry.find(frozenModel.provider, frozenModel.id) ??
+              frozenModel);
       } else {
         const resolvedRequest = modelSpec
           ? resolveModelRequest(modelSpec, ctx.modelRegistry, ctx.model)
@@ -488,7 +494,7 @@ export function resolveTasks(
         modelSuffix = resolvedRequest?.strippedSuffix;
 
         // The selected model spec is explicit regardless of whether it came
-        // from the task, settings, or named-agent frontmatter. If it cannot
+        // from the task, delegate config, or named-agent frontmatter. If it cannot
         // resolve, fail loudly instead of silently falling back to the parent.
         const explicitRequest = modelSpec;
         if (explicitRequest && !resolvedModel) {
@@ -524,8 +530,6 @@ export function resolveTasks(
           ? (t.thinking ??
             parentModelOverride?.thinking ??
             agentOverride?.thinking ??
-            legacyParentModelOverride?.thinking ??
-            legacyAgentOverride?.thinking ??
             (agent?.explicitThinking ? agent.thinking : undefined) ??
             modelSuffix ??
             parentDefaults.thinking ??
@@ -534,8 +538,6 @@ export function resolveTasks(
           : (t.thinking ??
             parentModelOverride?.thinking ??
             agentOverride?.thinking ??
-            legacyParentModelOverride?.thinking ??
-            legacyAgentOverride?.thinking ??
             (agent?.explicitThinking ? agent.thinking : undefined) ??
             (isPoolHit ? pooledConfig?.thinking : undefined) ??
             modelSuffix ??
@@ -544,8 +546,6 @@ export function resolveTasks(
         : (t.thinking ??
           parentModelOverride?.thinking ??
           agentOverride?.thinking ??
-          legacyParentModelOverride?.thinking ??
-          legacyAgentOverride?.thinking ??
           agent?.thinking ??
           (isPoolHit ? pooledConfig?.thinking : undefined) ??
           modelSuffix ??
@@ -592,6 +592,14 @@ export function resolveTasks(
       requestedSystemPrompt = systemPrompt;
     }
 
+    // Freeze the display tag from the caller's path *before* lifecycle
+    // canonicalizes `resumeFrom` for locking/acquisition. A symlink whose
+    // basename differs from its target would otherwise make the settled row's
+    // `resumedFrom` disagree with the live progress row and `agentName`,
+    // defeating `resumeMarker`'s no-duplication rule.
+    const resumeFromDisplay = t.resumeFrom
+      ? formatResumeTag(t.resumeFrom)
+      : undefined;
     return {
       ...t,
       id: t.id,
@@ -605,8 +613,13 @@ export function resolveTasks(
       // display code treats "" and absent alike (`t.prompt || …`).
       prompt: prompt ?? "",
       // Keep the built-in selector visible in progress/results. Omitted-agent
-      // inline tasks retain the established `ad-hoc` label and config namespace.
-      agentName: agent?.name ?? "ad-hoc",
+      // inline tasks retain the established `ad-hoc` label and config namespace
+      // — except resumes: a continued transcript is not a fresh ad-hoc spawn,
+      // so it carries the resumed-transcript identity instead.
+      agentName:
+        agent?.name ??
+        (resumeFromDisplay ? `resume:${resumeFromDisplay}` : "ad-hoc"),
+      resumeFromDisplay,
       warnings,
       reuseIntent: {
         model: requestedModel,

package/telemetry.ts

@@ -695,7 +695,7 @@ export interface TaskSpanInput {
 
 function outcomeFromResult(result: TaskResult): string {
   if (result.error) {
-    return result.error === "Aborted" ? "cancelled" : "failed";
+    return result.failureKind === "cancelled" ? "cancelled" : "failed";
   }
   return "success";
 }