@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/autocomplete/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/command-enchantment",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.21",
   "description": "Enhanced TUI autocomplete for /unipi:* commands — colored, sorted, and grouped by package",
   "type": "module",
   "main": "src/index.ts",

package/packages/autocomplete/src/constants.ts

@@ -19,6 +19,7 @@ export const PACKAGE_ORDER: string[] = [
   "btw",
   "mcp",
   "utility",
+  "skill-registry",
   "ask-user",
   "info",
   "web-api",
@@ -35,19 +36,18 @@ export const PACKAGE_ORDER: string[] = [
 ];
 
 // ─── Command Registry ────────────────────────────────────────────────
-/** Mapping of full command name → package name (48 verified commands) */
+/** Mapping of full command name → package name (46 verified commands) */
 export const COMMAND_REGISTRY: Record<string, string> = {
   // workflow (2 commands)
   "unipi:plan":           "workflow",
   "unipi:permission":     "workflow",
 
-  "unipi:prefix-cache":   "utility",
-
-  // long-horizon (4 commands)
+  // long-horizon (5 commands)
   "unipi:goal":           "long-horizon",
   "unipi:ralph":          "long-horizon",
   "unipi:swarm":          "long-horizon",
   "unipi:graph":          "long-horizon",
+  "unipi:regular":        "long-horizon",
 
   // memory (7 commands)
   "unipi:memory":              "memory",
@@ -58,34 +58,32 @@ export const COMMAND_REGISTRY: Record<string, string> = {
   "unipi:memory-forget":       "memory",
   "unipi:global-memory-list":  "memory",
 
-  // btw (6 commands)
+  // btw
   "unipi:btw":           "btw",
-  "unipi:btw-tangent":   "btw",
-  "unipi:btw-new":       "btw",
-  "unipi:btw-clear":     "btw",
-  "unipi:btw-inject":    "btw",
-  "unipi:btw-summarize": "btw",
+
+  // subagents
+  "unipi:subagents":     "subagents",
+  "unipi:agents":        "subagents",
 
   // mcp (5 commands)
   "unipi:mcp-status":   "mcp",
 
-  // utility (11 commands)
+  // utility
   "unipi:continue":   "utility",
-  "unipi:reload":     "utility",
-  "unipi:status":     "utility",
+  "unipi:retry":      "utility",
   "unipi:cleanup":    "utility",
-  "unipi:env":        "utility",
   "unipi:doctor":     "utility",
+  "unipi:answer":     "utility",
+
+  // skill-registry
+  "unipi:skills":     "skill-registry",
 
   // ask-user (1 command)
 
   // utility (settings hub)
   "unipi:settings":         "utility",
 
-  // subagents (3 commands)
-  "unipi:subagents-fleet":  "subagents",
-  "unipi:subagents-doctor": "subagents",
-  "unipi:subagents-guide":  "subagents",
+  // subagents (no user commands — Devin model)
 
   // background-tasks (8 commands)
   "unipi:bg":          "background-tasks",
@@ -97,14 +95,14 @@ export const COMMAND_REGISTRY: Record<string, string> = {
 
   // info (2 commands)
   "unipi:info":          "info",
+  "unipi:hint":          "info",
 
   // web-api (2 commands)
 
-  // compact (9 commands)
-  "unipi:lossless-compact": "compact",
-  "unipi:compact":         "compact",
+  // compact (6 commands)
+  "unipi:compact-vcc":      "compact",
+  "unipi:compact-by-llm":   "compact",
   "unipi:session-recall":  "compact",
-  "unipi:compact-recall":  "compact",
   "unipi:compact-stats":   "compact",
   "unipi:compact-doctor":  "compact",
   "unipi:compact-help":    "compact",
@@ -135,12 +133,12 @@ export const COMMAND_REGISTRY: Record<string, string> = {
 export const COMMAND_DESCRIPTIONS: Record<string, string> = {
   "unipi:plan":           "Plan mode — investigate read-only, then approve a plan",
   "unipi:permission":     "Permission mode — ask · auto (jev-judged) · full",
-  "unipi:prefix-cache":   "Show privacy-safe provider prefix-cache diagnostics",
 
   "unipi:goal":           "One objective until verifiably true · medium complexity · pareto cost/success",
   "unipi:ralph":          "Checklist grind over iterations · enumerable chores · low cost, solid success",
   "unipi:swarm":          "Parallel fan-out + synthesis · complex decomposable · higher cost, high coverage",
   "unipi:graph":          "Dependent multi-step work · later steps need earlier results · highest cost",
+  "unipi:regular":        "Regular mode — stop the active owner and run prompts without long-horizon routing",
 
   "unipi:memory":             "Memory palace — status, migrate, recall/write toggles",
   "unipi:memory-process":     "Analyze text and store extracted memories",
@@ -150,21 +148,20 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
   "unipi:memory-forget":      "Delete a memory by title",
   "unipi:global-memory-list": "List all memories across all projects",
 
-  "unipi:btw":           "Run a parallel side conversation",
-  "unipi:btw-tangent":   "Start a contextless BTW tangent thread",
-  "unipi:btw-new":       "Start a fresh BTW thread with session context",
-  "unipi:btw-clear":     "Dismiss and clear the BTW thread",
-  "unipi:btw-inject":    "Inject the BTW thread into the main agent",
-  "unipi:btw-summarize": "Summarize and inject the BTW thread",
+  "unipi:btw":           "Ask a side question in an inline panel (read-only)",
+
+  "unipi:subagents":     "Open the subagent panel (also ↓ from an empty input)",
+  "unipi:agents":        "Manage subagent profiles — create, edit, copy, delete custom agents",
 
   "unipi:mcp-status":   "Show MCP server status",
 
-  "unipi:continue":   "Continue the last conversation",
-  "unipi:reload":     "Reload extensions and settings",
-  "unipi:status":     "Show system status",
-  "unipi:cleanup":    "Clean up old sessions and cache",
-  "unipi:env":        "Show environment info",
-  "unipi:doctor":     "Run diagnostics",
+  "unipi:continue":   "Continue from where the agent stopped (/unipi:retry)",
+  "unipi:retry":      "Retry the last turn (alias of /unipi:continue)",
+  "unipi:cleanup":    "Remove stale UniPi temp files and leftovers (preview first)",
+  "unipi:doctor":     "Check UniPi's runtime: config, model cache, Decision Model, skills",
+  "unipi:answer":     "Answer the last reply — fixed input under the scrollable reply, per question, or web form",
+  "unipi:skills":     "Manage skills — on/off per project, listed or not, the skill vault",
+
   "unipi:kanboard":        "Kanboard — capture tasks, run them, open the board",
   "unipi:kanboard-add":    "Kanboard — capture a task into Backlog",
   "unipi:kanboard-do":     "Kanboard — let the agent work the board for a turn",
@@ -173,14 +170,14 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
   "unipi:settings": "Configure all unipi modules in one panel",
 
   "unipi:info":          "Show system information",
+  "unipi:hint":          "Browse and search Unicrab hints, or cycle/reset",
 
 
-  "unipi:lossless-compact": "Immediate zero-LLM compaction",
-  "unipi:compact":          "(DEPRECATED) Use /unipi:lossless-compact instead",
+  "unipi:compact-vcc":      "Lossless compaction now — no model call (keep:N)",
+  "unipi:compact-by-llm":   "Compact now with a model-written summary",
   "unipi:session-recall":   "Search session history, including compacted-away messages",
-  "unipi:compact-recall":   "(DEPRECATED) Use /unipi:session-recall instead",
-  "unipi:compact-stats":    "Show compaction statistics",
-  "unipi:compact-doctor":   "Diagnose compaction issues",
+  "unipi:compact-stats":    "Show this session's compaction savings",
+  "unipi:compact-doctor":   "Check compaction settings",
   "unipi:compact-help":     "Show compactor command help",
   "unipi:notify-event":     "Toggle a notify event without the TUI: <event> <on|off>",
 
@@ -195,9 +192,6 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
   "unipi:bg-tasks":    "Open the background task manager UI",
   "unipi:model":         "Pick a model or Fusion lead+sidekick pair (Devin-style picker)",
   "unipi:fusion-stats":  "Estimated Fusion savings (sidekick tokens priced at lead rates)",
-  "unipi:subagents-fleet":  "Open the subagents fleet view",
-  "unipi:subagents-doctor": "Diagnose subagents configuration",
-  "unipi:subagents-guide":  "Show the subagents usage guide",
 };
 
 // ─── Package Display Names ───────────────────────────────────────────
@@ -210,6 +204,7 @@ export const PACKAGE_LABELS: Record<string, string> = {
   btw:       "btw",
   mcp:       "mcp",
   utility:   "utility",
+  "skill-registry": "skills",
   "ask-user": "ask-user",
   info:      "info",
   "web-api": "web-api",

package/packages/autocomplete/src/sorting.ts

@@ -16,6 +16,12 @@ export interface TaggedItem {
 
 // ─── 4-tier priority ─────────────────────────────────────────────────
 
+/**
+ * UniPi commands that supersede a same-named pi built-in: typing the bare
+ * name ranks the unipi command FIRST (`/settings` → `/unipi:settings`).
+ */
+export const PREFERRED_OVER_BUILTIN = new Set(["settings"]);
+
 /**
  * Compute the match-quality tier for an autocomplete item.
  *
@@ -38,6 +44,8 @@ export function crossItemPriority(
 
   const q = query.toLowerCase();
 
+  // Tier -1: a unipi command that supersedes the same-named built-in
+  if (isUnipi && short === q && PREFERRED_OVER_BUILTIN.has(q)) return -1;
   // Tier 0: exact full-value match
   if (full === q) return 0;
   // Tier 1: unipi short-name exact match

package/packages/background-tasks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/background-tasks",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.21",
   "description": "Background tasks for UniPi — durable shell jobs and delegated background agents with a footer dock",
   "type": "module",
   "main": "src/index.ts",
@@ -10,7 +10,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-ai": "^0.87.1",
-    "@pi-unipi/core": "3.0.0-alpha.2",
+    "@pi-unipi/core": "3.0.0-alpha.21",
     "turndown": "^7.2.4"
   },
   "devDependencies": {

package/packages/background-tasks/src/config.ts

@@ -27,14 +27,6 @@ export interface BackgroundTasksConfig {
   maxFinishedTasks: number;
   /** Output cap in bytes before a task is killed+failed (default 20 MiB). */
   maxOutputBytes: number;
-  /** Delegate defaults. */
-  delegate: {
-    extensionMode: "isolated" | "ambient";
-    autoDeliver: "never" | "when_small" | "always";
-    maxTurns: number;
-    maxToolCalls: number;
-    timeoutSeconds: number;
-  };
 }
 
 export const DEFAULT_CONFIG: BackgroundTasksConfig = {
@@ -44,13 +36,6 @@ export const DEFAULT_CONFIG: BackgroundTasksConfig = {
   defaultTimeoutSeconds: 0,
   maxFinishedTasks: 30,
   maxOutputBytes: 20 * 1024 * 1024,
-  delegate: {
-    extensionMode: "isolated",
-    autoDeliver: "when_small",
-    maxTurns: 40,
-    maxToolCalls: 120,
-    timeoutSeconds: 900,
-  },
 };
 
 function getGlobalConfigPath(): string {
@@ -144,32 +129,6 @@ export function validateBackgroundTasksConfig(config: unknown): string[] {
       problems.push("maxOutputBytes must be an integer >= 1024");
     }
   }
-  if (c.delegate !== undefined) {
-    if (typeof c.delegate !== "object" || c.delegate === null) {
-      problems.push("delegate must be an object");
-    } else {
-      const d = c.delegate as Record<string, unknown>;
-      if (d.extensionMode !== undefined && d.extensionMode !== "isolated" && d.extensionMode !== "ambient") {
-        problems.push('delegate.extensionMode must be "isolated" or "ambient"');
-      }
-      if (
-        d.autoDeliver !== undefined &&
-        d.autoDeliver !== "never" &&
-        d.autoDeliver !== "when_small" &&
-        d.autoDeliver !== "always"
-      ) {
-        problems.push('delegate.autoDeliver must be "never", "when_small", or "always"');
-      }
-      for (const key of ["maxTurns", "maxToolCalls"] as const) {
-        if (d[key] !== undefined && (typeof d[key] !== "number" || !Number.isInteger(d[key]) || (d[key] as number) < 1)) {
-          problems.push(`delegate.${key} must be a positive integer`);
-        }
-      }
-      if (d.timeoutSeconds !== undefined && (typeof d.timeoutSeconds !== "number" || !Number.isFinite(d.timeoutSeconds) || (d.timeoutSeconds as number) <= 0)) {
-        problems.push("delegate.timeoutSeconds must be a positive number");
-      }
-    }
-  }
   return problems;
 }
 
@@ -203,29 +162,6 @@ registerSettings({
         { key: "maxOutputBytes", type: "number", label: "Output cap bytes", min: 1024, description: "Kill+fail a task past this output size" },
       ],
     },
-    {
-      title: "Delegate",
-      fields: [
-        {
-          key: "delegate.extensionMode",
-          type: "enum",
-          label: "Extension mode",
-          options: [
-            { value: "isolated", label: "isolated" },
-            { value: "ambient", label: "ambient (weakens isolation)" },
-          ],
-        },
-        {
-          key: "delegate.autoDeliver",
-          type: "enum",
-          label: "Auto deliver",
-          options: ["when_small", "always", "never"],
-        },
-        { key: "delegate.maxTurns", type: "number", label: "Max turns", min: 1 },
-        { key: "delegate.maxToolCalls", type: "number", label: "Max tool calls", min: 1 },
-        { key: "delegate.timeoutSeconds", type: "number", label: "Timeout s", min: 1 },
-      ],
-    },
   ],
 });
 
@@ -278,15 +214,6 @@ export function loadBackgroundTasksConfig(cwd: string): LoadedBackgroundTasksCon
       typeof merged.maxOutputBytes === "number" && Number.isInteger(merged.maxOutputBytes) && merged.maxOutputBytes >= 1024
         ? merged.maxOutputBytes
         : DEFAULT_CONFIG.maxOutputBytes,
-    delegate: {
-      ...DEFAULT_CONFIG.delegate,
-      ...merged.delegate,
-      extensionMode: merged.delegate?.extensionMode === "ambient" ? "ambient" : "isolated",
-      autoDeliver:
-        merged.delegate?.autoDeliver === "never" || merged.delegate?.autoDeliver === "always"
-          ? merged.delegate.autoDeliver
-          : "when_small",
-    },
   };
   return { config, warnings };
 }

package/packages/background-tasks/src/index.ts

@@ -10,7 +10,7 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { createSpinnerLine, setHerdrWorking } from "@pi-unipi/core";
+import { createSpinnerLine, isChildProcess, registerWaitSource, setHerdrWorking } from "@pi-unipi/core";
 import { loadBackgroundTasksConfig } from "./config.js";
 import { BackgroundTaskRegistry } from "./registry.js";
 import {
@@ -18,7 +18,6 @@ import {
   type BackgroundTaskExtensionService,
 } from "./extension-api.js";
 import { registerToolsAndCommands } from "./tools.js";
-import { registerDelegateExtension } from "./delegate-extension.js";
 import { setSharedTaskRegistry, clearSharedTaskRegistry } from "./registry-shared.js";
 import { formatDuration, taskDisplayName, type BgTask, type StartTaskOptions } from "./types.js";
 
@@ -44,6 +43,15 @@ function pendingWakeText(registry: BackgroundTaskRegistry, isIdle: () => boolean
   return `waiting on ${count}${detail} — agent resumes automatically when done`;
 }
 
+/** Arbiter wait-source reason (lead only): what a running wake-task is, or null. */
+export function pendingWakeReason(tasks: readonly { status: string; triggerOnCompletion: boolean; command?: string; name?: string; description?: string; id?: string }[]): string | null {
+  const pendingWake = tasks.filter((task) => task.status === "running" && task.triggerOnCompletion);
+  if (pendingWake.length === 0) return null;
+  const first = pendingWake[0];
+  const more = pendingWake.length > 1 ? ` +${String(pendingWake.length - 1)} more` : "";
+  return `bg: ${first === undefined ? "task" : taskDisplayName(first)}${more}`;
+}
+
 export default function backgroundTasksExtension(pi: ExtensionAPI): void {
   const { config, warnings } = loadBackgroundTasksConfig(process.cwd());
 
@@ -77,6 +85,16 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
   });
   setSharedTaskRegistry(registry);
 
+  // Turn-arbiter wait source (lead only): while a task that will wake the
+  // agent is still running, a nudge would race the wake — defer to it.
+  if (!isChildProcess()) {
+    try {
+      registerWaitSource("background-tasks", () => pendingWakeReason(registry.allTasks()));
+    } catch {
+      // Registration must never block module load.
+    }
+  }
+
   const eventService: BackgroundTaskExtensionService = installBackgroundTaskExtensionApi({
     events: pi.events,
     registry,
@@ -205,11 +223,6 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
               return result;
             },
             rerunTask: async (task) => {
-              if (task.delegate !== undefined) {
-                throw new Error(
-                  "Only shell-command tasks can be rerun from the dock; relaunch this typed workflow through its owning tool.",
-                );
-              }
               const rerunOptions: StartTaskOptions = {
                 name: taskDisplayName(task),
                 isAgent: task.isAgent,
@@ -261,15 +274,6 @@ export default function backgroundTasksExtension(pi: ExtensionAPI): void {
     clearFinishedNotices,
   });
 
-  registerDelegateExtension(pi, {
-    startDelegateTask: async (ctx, options) => {
-      currentCtx = ctx;
-      return registry.startDelegateTask(ctx, options);
-    },
-    snapshot: (task) => registry.snapshot(task),
-    resolveTask: (idOrPrefix) => registry.resolveTask(idOrPrefix),
-  });
-
   pi.on("session_start", async (_event, ctx) => {
     registry.setShuttingDown(false);
     wakeLineInstalled = false; // pi clears extension widgets on reload/new session

package/packages/background-tasks/src/registry.ts

@@ -27,7 +27,6 @@ import {
   type BgTaskSnapshot,
   type JsonObject,
   type KillKind,
-  type StartDelegateTaskOptions,
   type StartTaskOptions,
   type TaskContextUsage,
   type TaskStatus,
@@ -637,31 +636,6 @@ function noopOnChange(): void {
   return undefined;
 }
 
-/**
- * Deliver the delegate prompt bytes over stdin.
- *
- * A failure to deliver the seed is loud: the caller terminates the task rather
- * than letting a child run without the context it was supposed to receive.
- */
-function writeDelegateStdin(
-  child: BackgroundTaskChildProcess,
-  bytes: Buffer,
-  onError: (error: Error) => void,
-): void {
-  const stdin = child.stdin;
-  if (stdin === undefined || stdin === null) {
-    onError(new Error('delegate child stdin pipe is unavailable'));
-    return;
-  }
-  stdin.once('error', onError);
-  stdin.write(bytes, (error?: Error | null) => {
-    if (error !== undefined && error !== null) {
-      onError(error);
-      return;
-    }
-    stdin.end();
-  });
-}
 
 export class BackgroundTaskRegistry {
   private readonly tasks = new Map<string, BgTask>();
@@ -921,145 +895,6 @@ export class BackgroundTaskRegistry {
     }
   }
 
-  /**
-   * Start a prepared delegate child.
-   *
-   * The caller has already completed preflight, so by the time this runs the
-   * seed, budget plan, and artifact directory exist and the argv is fixed. The
-   * child is launched directly, never through a shell, and its terminal state
-   * flows through the same durable notification path as `bg_run`.
-   */
-  async startDelegateTask(
-    ctx: BackgroundTaskContext,
-    request: StartDelegateTaskOptions,
-  ): Promise<BgTask> {
-    if (this.shuttingDown)
-      throw new Error('Cannot start a delegate task while Pi is shutting down');
-
-    const launch = resolvePiLaunch({ platform: this.platform });
-    assertWindowsCommandLineWithinLimit(launch, request.argv, this.platform, 'bg-delegate');
-
-    const dir = await this.ensureRuntimeDir(ctx);
-    const id = request.facts.taskId;
-    const outputAbsPath = join(dir.abs, `${id}.output`);
-    const metadataAbsPath = join(dir.abs, `${id}.json`);
-    const outputPath = join(dir.display, `${id}.output`);
-
-    const task: BgTask = {
-      id,
-      name: normalizeTaskName(request.name) ?? 'Delegate task',
-      command: ['pi', ...request.argv].map(shellQuote).join(' '),
-      status: 'running',
-      outputPath,
-      outputAbsPath,
-      metadataAbsPath,
-      cwd: ctx.cwd,
-      startTime: this.now(),
-      exitCode: undefined,
-      pid: undefined,
-      bytesWritten: 0,
-      isAgent: true,
-      notified: false,
-      notifyOnCompletion: request.notifyOnCompletion,
-      triggerOnCompletion: request.triggerOnCompletion,
-      timeoutSeconds: request.timeoutSeconds,
-      model: request.facts.route.qualifiedId,
-      delegate: request.facts,
-      waiters: [],
-    };
-    this.tasks.set(id, task);
-
-    const stream = createWriteStream(outputAbsPath, { flags: 'a', encoding: 'utf8' });
-    task.stream = stream;
-    stream.on('error', (error) => {
-      task.error = `Output file write failed: ${error.message}`;
-    });
-
-    try {
-      const child = this.spawn(launch.executable, piLaunchArgv(launch, [...request.argv]), {
-        cwd: ctx.cwd,
-        detached: this.platform !== 'win32',
-        shell: false,
-        // The seed travels over stdin, never as a shell or positional argument,
-        // so the bytes the child reads are exactly the bytes that were persisted
-        // and hashed, with no quoting or command-line length limit in the path.
-        stdio: ['pipe', 'pipe', 'pipe'],
-        env: request.env,
-        windowsHide: true,
-      });
-      task.child = child;
-      task.pid = child.pid;
-      writeDelegateStdin(child, request.stdinBytes, (error) => {
-        this.writeNotice(task, `\n[delegate stdin write failed: ${error.message}]\n`);
-        if (task.status === 'running') {
-          task.killKind = 'user';
-          task.error = `Delegate seed could not be delivered: ${error.message}`;
-          try {
-            this.requestKill(task, 'SIGTERM');
-          } catch {
-            void this.finalizeTask(task, 'failed', null, undefined, task.error);
-          }
-        }
-      });
-
-      child.stdout?.on('data', (data) => {
-        this.appendChildOutput(task, data, 'stdout');
-      });
-      child.stderr?.on('data', (data) => {
-        this.appendChildOutput(task, data, 'stderr');
-      });
-      child.on('error', (error) => {
-        this.writeNotice(task, `\n[delegate spawn error: ${error.message}]\n`);
-        void this.finalizeTask(task, 'failed', null, undefined, error.message);
-      });
-      child.on('close', (code, signalName) => {
-        let status: TaskStatus;
-        let error: string | undefined;
-        if (task.killKind === 'user' || task.killKind === 'shutdown') {
-          status = 'killed';
-        } else if (task.killKind === 'timeout') {
-          status = 'failed';
-          error = task.error ?? `Timed out after ${String(request.timeoutSeconds ?? 0)}s`;
-        } else if ((code ?? 0) === 0) {
-          status = 'completed';
-        } else {
-          status = 'failed';
-          error = `Exited with code ${code === null ? 'null' : String(code)}${signalName ? ` (${signalName})` : ''}`;
-        }
-        void this.finalizeTask(task, status, code, signalName, error);
-      });
-
-      if (request.timeoutSeconds !== undefined) {
-        task.timeoutHandle = setTimeout(() => {
-          if (task.status !== 'running') return;
-          task.killKind = 'timeout';
-          task.error = `Timed out after ${String(request.timeoutSeconds)}s`;
-          this.writeNotice(task, `\n[delegate timeout: ${task.error}]\n`);
-          try {
-            this.requestKill(task, 'SIGTERM');
-          } catch (error) {
-            void this.finalizeTask(
-              task,
-              'failed',
-              null,
-              undefined,
-              `${task.error}; kill failed: ${error instanceof Error ? error.message : String(error)}`,
-            );
-          }
-        }, request.timeoutSeconds * 1000);
-      }
-
-      await this.writeMetadata(task);
-      this.onChange();
-      return task;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.writeNotice(task, `\n[delegate spawn exception: ${message}]\n`);
-      await this.finalizeTask(task, 'failed', null, undefined, message);
-      throw new Error(`Failed to start delegate task: ${message}`);
-    }
-  }
-
   resolveTask(idOrPrefix: string): BgTask {
     const id = idOrPrefix.trim();
     if (!id) throw new Error('Task ID is required');
@@ -1816,12 +1651,7 @@ export class BackgroundTaskRegistry {
       task.exitCode === undefined ? '' : `\n  <exit-code>${String(task.exitCode)}</exit-code>`;
     const error = task.error ? `\n  <error>${escapeXml(task.error)}</error>` : '';
     const taskName = taskDisplayName(task);
-    const guidance =
-      task.delegate === undefined
-        ? 'Terminal state and output metadata are durable. Do not call bg_status to reconfirm; use bg_logs only if output is needed.'
-        : task.status === 'completed'
-          ? `Delegate result is durably committed. Call bg_result({taskId:${JSON.stringify(task.id)}}) once to retrieve it; do not poll.`
-          : `Delegate ended ${task.status}. Inspect the preserved artifacts at ${task.delegate.artifactDir}; do not poll.`;
+    const guidance = 'Terminal state and output metadata are durable. Do not call bg_status to reconfirm; use bg_logs only if output is needed.';
     const content = [
       '<background-task-notification>',
       `  <task-id>${task.id}</task-id>`,