@heyhuynhgiabuu/pi-task 0.1.5 → 0.2.0

package/dist/subagent/tmux.js

@@ -1,56 +1,48 @@
-/**
- * Tmux helpers for subagent panes (shared by task extension).
- */
 import { execFileSync } from "node:child_process";
 import { buildTmuxSplitWindowArgs, chooseTmuxSplitDirection } from "../helpers.js";
 export function tmuxCmd(args) {
     return execFileSync("tmux", args, {
         encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
+        stdio: ["ignore", "pipe", "pipe"],
     }).trim();
 }
-export function hasTmux() {
+function tmuxCmdQuiet(args) {
     try {
-        execFileSync("tmux", ["-V"], { stdio: "pipe" });
-        return true;
+        return tmuxCmd(args);
     }
     catch {
-        return false;
+        return "";
     }
 }
-export function paneExists(paneId) {
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export function hasTmux() {
     try {
-        const out = tmuxCmd(["list-panes", "-a", "-F", "#{pane_id}"]);
-        return out.split("\n").includes(paneId);
+        execFileSync("tmux", ["-V"], { stdio: "ignore" });
+        if (!process.env.TMUX)
+            return false;
+        tmuxCmd(["display-message", "-p", "#{pane_id}"]);
+        return true;
     }
     catch {
         return false;
     }
 }
 export function getCurrentPaneId() {
-    try {
-        return tmuxCmd(["display-message", "-p", "#{pane_id}"]);
-    }
-    catch {
-        return null;
-    }
+    return tmuxCmdQuiet(["display-message", "-p", "#{pane_id}"]) || null;
 }
 export function getCurrentPaneSize(targetPane) {
-    try {
-        const args = ["display-message", "-p", "#{pane_width} #{pane_height}"];
-        if (targetPane)
-            args.splice(1, 0, "-t", targetPane);
-        const raw = tmuxCmd(args);
-        const [widthRaw, heightRaw] = raw.trim().split(/\s+/, 2);
-        const width = Number(widthRaw);
-        const height = Number(heightRaw);
-        if (!Number.isFinite(width) || !Number.isFinite(height))
-            return null;
-        return { width, height };
-    }
-    catch {
+    const args = ["display-message", "-p", "#{pane_width} #{pane_height}"];
+    if (targetPane)
+        args.splice(1, 0, "-t", targetPane);
+    const raw = tmuxCmdQuiet(args);
+    const [widthRaw, heightRaw] = raw.trim().split(/\s+/, 2);
+    const width = Number(widthRaw);
+    const height = Number(heightRaw);
+    if (!Number.isFinite(width) || !Number.isFinite(height))
         return null;
-    }
+    return { width, height };
 }
 export function splitWindowPane(cwd, command) {
     const originalPane = getCurrentPaneId();
@@ -59,21 +51,49 @@ export function splitWindowPane(cwd, command) {
     const paneId = tmuxCmd(buildTmuxSplitWindowArgs(cwd, command, direction, originalPane));
     return { paneId, originalPane };
 }
+export function setPaneRemainOnExit(paneId, enabled) {
+    tmuxCmdQuiet([
+        "set-option",
+        "-p",
+        "-t",
+        paneId,
+        "remain-on-exit",
+        enabled ? "on" : "off",
+    ]);
+}
+export function setPaneSelfDestruct(paneId, enabled, delaySeconds = 1) {
+    const hook = enabled
+        ? `run-shell 'sleep ${Math.max(0, delaySeconds)}; tmux kill-pane -t ${paneId} 2>/dev/null || true'`
+        : "";
+    tmuxCmdQuiet(["set-hook", "-p", "-t", paneId, "pane-died", hook]);
+}
+export function paneExists(paneId) {
+    return tmuxCmdQuiet(["display-message", "-p", "-t", paneId, "#{pane_id}"]) === paneId;
+}
+export function paneDead(paneId) {
+    const value = tmuxCmdQuiet(["display-message", "-p", "-t", paneId, "#{pane_dead}"]);
+    return value === "1" || value === "";
+}
+export function capturePaneTail(paneId, lines = 80) {
+    return tmuxCmdQuiet([
+        "capture-pane",
+        "-p",
+        "-t",
+        paneId,
+        "-S",
+        `-${Math.max(1, lines)}`,
+    ]);
+}
 export function killAgentPane(paneId, originalPane) {
-    try {
-        tmuxCmd(["kill-pane", "-t", paneId]);
-    }
-    catch {
-        /* already dead */
-    }
     if (originalPane) {
         try {
             tmuxCmd(["select-pane", "-t", originalPane]);
         }
         catch {
-            /* ignore */
+            // Original pane may have been closed; still try to kill the agent pane.
         }
     }
+    tmuxCmdQuiet(["kill-pane", "-t", paneId]);
 }
 /** Inject text into a running subagent pane (steer / follow-up). */
 export function tmuxSteerPane(paneId, message) {
@@ -86,12 +106,55 @@ export function tmuxSteerPane(paneId, message) {
         tmuxCmd(["paste-buffer", "-b", bufferName, "-t", paneId]);
     }
     finally {
-        try {
-            tmuxCmd(["delete-buffer", "-b", bufferName]);
-        }
-        catch {
-            /* ignore */
-        }
+        tmuxCmdQuiet(["delete-buffer", "-b", bufferName]);
     }
     tmuxCmd(["send-keys", "-t", paneId, "Enter"]);
 }
+function sessionWatcherScript(sessionFilePath) {
+    const quotedPath = shellQuote(sessionFilePath);
+    // Watch a *specific* file so stale sibling files can't trigger premature /exit.
+    return `(
+  if [ -s ${quotedPath} ]; then
+    last_size=$(wc -c < ${quotedPath} 2>/dev/null || echo 0)
+  else
+    last_size=-1
+  fi
+  stable=0
+  deadline=$(( $(date +%s) + 86400 ))
+  while [ "$(date +%s)" -lt "$deadline" ]; do
+    if [ -s ${quotedPath} ]; then
+      size=$(wc -c < ${quotedPath} 2>/dev/null || echo 0)
+      if [ "$size" = "$last_size" ]; then
+        stable=$((stable + 1))
+      else
+        stable=0
+        last_size=$size
+      fi
+      if [ "$stable" -ge 3 ]; then
+        tmux send-keys -t "$TMUX_PANE" /exit Enter 2>/dev/null || true
+        sleep 0.2
+        tmux send-keys -t "$TMUX_PANE" 'exit 0' Enter 2>/dev/null || true
+        sleep 2
+        tmux kill-pane -t "$TMUX_PANE" 2>/dev/null || true
+        exit 0
+      fi
+    fi
+    sleep 0.5
+  done
+) & watcher_pid=$!`;
+}
+export function wrapWithPaneExitWatcher(sessionFilePath, command) {
+    const script = `tmux set-option -p -t "$TMUX_PANE" remain-on-exit on 2>/dev/null || true
+${sessionWatcherScript(sessionFilePath)}
+${command}
+exit_code=$?
+kill "$watcher_pid" 2>/dev/null || true
+wait "$watcher_pid" 2>/dev/null || true
+if [ "$exit_code" -eq 0 ]; then
+  tmux set-hook -p -t "$TMUX_PANE" pane-died '' 2>/dev/null || true
+  tmux set-option -p -t "$TMUX_PANE" remain-on-exit off 2>/dev/null || true
+  tmux kill-pane -t "$TMUX_PANE" 2>/dev/null || true
+fi
+exit "$exit_code"`;
+    return `sh -c ${shellQuote(script)}`;
+}

package/dist/subagent/waitCompletion.d.ts

@@ -2,16 +2,16 @@ export type TaskCompletionStatus = "running" | "completed" | "failed" | "cancell
 export interface TaskCompletionSnapshot {
     status: TaskCompletionStatus;
     content: string;
-    source?: "result-file" | "session-jsonl" | "pane" | "timeout" | "signal";
+    source?: "session-jsonl" | "pane" | "timeout" | "signal";
 }
-export interface TaskCompletionOptions {
-    resultPath: string;
+export interface WaitForTaskCompletionOptions {
     sessionDir: string;
     sessionName: string;
     paneId?: string;
     signal?: AbortSignal;
     timeoutMs?: number;
     pollMs?: number;
+    sinceMs?: number;
 }
-export declare function checkTaskCompletion(options: TaskCompletionOptions): Promise<TaskCompletionSnapshot>;
-export declare function waitForTaskCompletion(options: TaskCompletionOptions): Promise<TaskCompletionSnapshot>;
+export declare function checkTaskCompletion(options: Omit<WaitForTaskCompletionOptions, "signal" | "timeoutMs" | "pollMs">): Promise<TaskCompletionSnapshot>;
+export declare function waitForTaskCompletion(options: WaitForTaskCompletionOptions): Promise<TaskCompletionSnapshot>;

package/dist/subagent/waitCompletion.js

@@ -1,49 +1,42 @@
-import { readFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { getLastAssistantTextFromSessionDir } from "../session-text.js";
+import { getLastAssistantTextFromSessionDir, hasAgentFinished, } from "../session-text.js";
 import { paneExists } from "./tmux.js";
-async function readResultFile(resultPath) {
-    if (!existsSync(resultPath))
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * v0.1.6: The subagent's final assistant message from the auto-saved
+ * persistent JSONL session IS the result. No RESULT.md, no agent instructions
+ * to write a file. Completion is gated by the assistant's terminal
+ * `stopReason` (not `toolUse`, not streaming text).
+ */
+function readSessionText(sessionDir, sessionName, sinceMs) {
+    if (!hasAgentFinished(sessionDir, sessionName, sinceMs))
         return null;
-    const text = (await readFile(resultPath, "utf-8")).trim();
-    return text.length > 0 ? text : null;
-}
-function readSessionText(sessionDir, sessionName) {
-    const sessionPath = join(sessionDir, "sessions", sessionName);
-    const text = getLastAssistantTextFromSessionDir(sessionPath).trim();
+    const text = getLastAssistantTextFromSessionDir(sessionDir, sessionName, sinceMs).trim();
     return text.length > 0 ? text : null;
 }
 export async function checkTaskCompletion(options) {
-    const result = await readResultFile(options.resultPath);
-    if (result) {
-        return { status: "completed", content: result, source: "result-file" };
+    // If the pane has exited, give pi a brief moment to flush JSONL.
+    if (options.paneId && !paneExists(options.paneId)) {
+        await sleep(500);
     }
+    // Session JSONL is the single authoritative completion source.
+    const sessionResult = readSessionText(options.sessionDir, options.sessionName, options.sinceMs);
+    if (sessionResult) {
+        return { status: "completed", content: sessionResult, source: "session-jsonl" };
+    }
+    // No terminal assistant message yet. If the pane is alive, keep waiting.
     if (options.paneId && paneExists(options.paneId)) {
         return { status: "running", content: "", source: "pane" };
     }
-    const sessionText = readSessionText(options.sessionDir, options.sessionName);
-    if (sessionText) {
-        return {
-            status: "completed",
-            content: sessionText,
-            source: "session-jsonl",
-        };
-    }
-    if (options.paneId) {
-        return {
-            status: "failed",
-            content: "Task pane exited before producing a result or assistant response.",
-            source: "pane",
-        };
-    }
-    return { status: "running", content: "", source: "pane" };
+    return {
+        status: "failed",
+        content: "Subagent pane exited without producing a result.",
+    };
 }
 export async function waitForTaskCompletion(options) {
+    const started = Date.now();
     const timeoutMs = options.timeoutMs ?? 30 * 60 * 1000;
     const pollMs = options.pollMs ?? 1000;
-    const deadline = Date.now() + timeoutMs;
-    while (true) {
+    while (Date.now() - started < timeoutMs) {
         if (options.signal?.aborted) {
             return {
                 status: "cancelled",
@@ -54,13 +47,11 @@ export async function waitForTaskCompletion(options) {
         const snapshot = await checkTaskCompletion(options);
         if (snapshot.status !== "running")
             return snapshot;
-        if (Date.now() >= deadline) {
-            return {
-                status: "timeout",
-                content: `Task timed out after ${Math.round(timeoutMs / 1000)}s without producing a result.`,
-                source: "timeout",
-            };
-        }
-        await new Promise((resolve) => setTimeout(resolve, pollMs));
+        await sleep(pollMs);
     }
+    return {
+        status: "timeout",
+        content: `Task timed out after ${Math.round(timeoutMs / 1000)}s without producing a result.`,
+        source: "timeout",
+    };
 }

package/dist/task-widget.d.ts

@@ -0,0 +1,21 @@
+import type { ToolCallRecord } from "./helpers.js";
+export interface WidgetTask {
+    agentType: string;
+    description?: string;
+    startedAt: number;
+    toolUses: number;
+    recentCalls?: ToolCallRecord[];
+}
+export interface ThemeLike {
+    fg(color: string, text: string): string;
+}
+export declare const TASK_WIDGET_RENDER_MS = 80;
+export declare function renderTaskWidget(params: {
+    foregroundTasks: Iterable<[string, WidgetTask]>;
+    backgroundTasks: Iterable<[string, WidgetTask]>;
+    foregroundCount: number;
+    backgroundCount: number;
+    width: number;
+    theme?: ThemeLike | null;
+    now?: number;
+}): string[];

package/dist/task-widget.js

@@ -0,0 +1,122 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { formatMs } from "./helpers.js";
+export const TASK_WIDGET_RENDER_MS = 80;
+const SPINNER_FRAMES = [
+    "\u280B",
+    "\u2819",
+    "\u2838",
+    "\u2834",
+    "\u2826",
+    "\u2827",
+    "\u2807",
+    "\u280F",
+];
+const MAX_TOOL_LINES = 12;
+const MAX_BACKGROUND_LINES = 8;
+const MAX_WIDTH = 120;
+const TREE_MIDDLE = "\u251C\u2500"; // ├─
+const TREE_LAST = "\u2514\u2500"; // └─
+function color(theme, token, text) {
+    return theme?.fg ? theme.fg(token, text) : text;
+}
+function toolStatusMark(theme, status, spinner) {
+    switch (status) {
+        case "done":
+            return color(theme, "success", "\u2713");
+        case "error":
+            return color(theme, "error", "\u2717");
+        case "in_progress":
+        default:
+            return color(theme, "accent", spinner);
+    }
+}
+function formatToolCount(count) {
+    return `${count} ${count === 1 ? "tool" : "tools"}`;
+}
+function formatLatestTool(task, spinner, theme) {
+    const latest = task.recentCalls?.at(-1);
+    if (!latest) {
+        return `${toolStatusMark(theme, "in_progress", spinner)} ${color(theme, "dim", "waiting")}`;
+    }
+    const detail = latest.detail ? ` ${latest.detail}` : "";
+    return (`${toolStatusMark(theme, latest.status, spinner)} ` +
+        color(theme, "text", latest.name) +
+        color(theme, "dim", detail));
+}
+function renderForegroundTask(task, now, maxWidth, spinner, theme) {
+    const agentName = task.agentType.charAt(0).toUpperCase() + task.agentType.slice(1);
+    const elapsed = formatMs(now - task.startedAt);
+    const description = task.description ? ` — ${task.description}` : "";
+    const lines = [];
+    const header = color(theme, "accent", spinner) +
+        " " +
+        color(theme, "toolTitle", agentName) +
+        color(theme, "dim", description) +
+        color(theme, "dim", "  \u2022 ") +
+        color(theme, "warning", elapsed) +
+        (task.toolUses > 0
+            ? color(theme, "dim", " \u2022 ") +
+                color(theme, "success", formatToolCount(task.toolUses))
+            : "");
+    lines.push(truncateToWidth(header, maxWidth));
+    const recent = task.recentCalls ?? [];
+    const slice = recent.slice(-MAX_TOOL_LINES);
+    slice.forEach((tc, idx) => {
+        const connector = idx === slice.length - 1 ? TREE_LAST : TREE_MIDDLE;
+        const detail = tc.detail ? `  ${tc.detail}` : "";
+        const line = "  " +
+            color(theme, "dim", connector) +
+            " " +
+            toolStatusMark(theme, tc.status, spinner) +
+            " " +
+            color(theme, "text", tc.name) +
+            color(theme, "dim", detail);
+        lines.push(truncateToWidth(line, maxWidth));
+    });
+    return lines;
+}
+function renderBackgroundLine(id, task, now, maxWidth, spinner, theme) {
+    const elapsed = formatMs(now - task.startedAt);
+    const latest = formatLatestTool(task, spinner, theme);
+    const line = color(theme, "dim", "- ") +
+        color(theme, "toolTitle", task.agentType) +
+        color(theme, "dim", " \u00b7 ") +
+        color(theme, "accent", id) +
+        color(theme, "dim", " \u00b7 ") +
+        color(theme, "warning", elapsed) +
+        color(theme, "dim", " \u00b7 ") +
+        color(theme, "success", formatToolCount(task.toolUses)) +
+        color(theme, "dim", " \u00b7 ") +
+        latest;
+    return truncateToWidth(line, maxWidth);
+}
+export function renderTaskWidget(params) {
+    const { foregroundTasks, backgroundTasks, foregroundCount, backgroundCount, width, theme, } = params;
+    if (foregroundCount === 0 && backgroundCount === 0)
+        return [];
+    const now = params.now ?? Date.now();
+    const maxWidth = Math.min(width, MAX_WIDTH);
+    const tick = Math.floor(now / TASK_WIDGET_RENDER_MS);
+    const spinner = SPINNER_FRAMES[tick % SPINNER_FRAMES.length];
+    const lines = [];
+    for (const [, task] of foregroundTasks) {
+        lines.push(...renderForegroundTask(task, now, maxWidth, spinner, theme));
+        lines.push("");
+    }
+    const renderedBackground = [];
+    for (const entry of backgroundTasks) {
+        if (renderedBackground.length >= MAX_BACKGROUND_LINES)
+            break;
+        renderedBackground.push(entry);
+    }
+    for (const [id, task] of renderedBackground) {
+        lines.push(renderBackgroundLine(id, task, now, maxWidth, spinner, theme));
+    }
+    const hidden = backgroundCount - renderedBackground.length;
+    if (hidden > 0) {
+        lines.push(truncateToWidth(color(theme, "dim", `+ ${hidden} more background tasks`), maxWidth));
+    }
+    // Keep a little breathing room above the editor.
+    lines.push("");
+    return lines;
+}

package/dist/tool/index.d.ts

@@ -0,0 +1,5 @@
+export { renderCall } from "./renderCall.js";
+export { renderResult } from "./renderResult.js";
+export { createTaskCompleteRenderer } from "./taskComplete.js";
+export { buildTaskPrompt } from "./prompt.js";
+export { taskParametersSchema } from "./schema.js";

package/dist/tool/index.js

@@ -0,0 +1,5 @@
+export { renderCall } from "./renderCall.js";
+export { renderResult } from "./renderResult.js";
+export { createTaskCompleteRenderer } from "./taskComplete.js";
+export { buildTaskPrompt } from "./prompt.js";
+export { taskParametersSchema } from "./schema.js";

package/dist/tool/prompt.d.ts

@@ -0,0 +1,8 @@
+export interface BuildTaskPromptOptions {
+    description: string;
+    agentName: string;
+    agentSource: string;
+    prompt: string;
+    cwd: string;
+}
+export declare function buildTaskPrompt(options: BuildTaskPromptOptions): string;

package/dist/tool/prompt.js

@@ -0,0 +1,17 @@
+import { TASK_PROMPT_INSTRUCTIONS } from "../helpers.js";
+export function buildTaskPrompt(options) {
+    return [
+        `# Task: ${options.description}`,
+        "",
+        "## Agent",
+        `${options.agentName} (${options.agentSource})`,
+        "",
+        "## Instructions",
+        options.prompt,
+        "",
+        "## Working Directory",
+        options.cwd,
+        "",
+        TASK_PROMPT_INSTRUCTIONS,
+    ].join("\n");
+}

package/dist/tool/renderCall.d.ts

@@ -0,0 +1,3 @@
+import { Text } from "@earendil-works/pi-tui";
+/** Render the task tool call line while the subagent is running. */
+export declare function renderCall(args: unknown, theme: any): Text;

package/dist/tool/renderCall.js

@@ -0,0 +1,12 @@
+import { Text } from "@earendil-works/pi-tui";
+/** Render the task tool call line while the subagent is running. */
+export function renderCall(args, theme) {
+    const params = args;
+    const agentName = params.agent_type || "...";
+    const desc = params.description || "";
+    let text = theme.fg("toolTitle", "");
+    text += theme.fg("accent", agentName);
+    if (desc)
+        text += theme.fg("dim", ` - ${desc}`);
+    return new Text(text, 0, 0);
+}

package/dist/tool/renderResult.d.ts

@@ -0,0 +1,8 @@
+import { Container } from "@earendil-works/pi-tui";
+/**
+ * Custom renderResult for the task tool.
+ * Supports collapsed/expanded views with Ctrl+O (app.tools.expand).
+ */
+export declare function renderResult(result: any, options: {
+    expanded?: boolean;
+}, theme: any): Container;

package/dist/tool/renderResult.js

@@ -0,0 +1,51 @@
+import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { keyHint, keyText, rawKeyHint } from "@earendil-works/pi-coding-agent";
+import { formatMs } from "../helpers.js";
+/**
+ * Custom renderResult for the task tool.
+ * Supports collapsed/expanded views with Ctrl+O (app.tools.expand).
+ */
+export function renderResult(result, options, theme) {
+    const details = (result.details ?? {});
+    const stats = [];
+    if (typeof details.tool_uses === "number" && details.tool_uses > 0) {
+        stats.push(theme.fg("muted", `${details.tool_uses} toolcall${details.tool_uses === 1 ? "" : "s"}`));
+    }
+    if (typeof details.duration_ms === "number" && details.duration_ms > 0) {
+        stats.push(theme.fg("muted", formatMs(details.duration_ms)));
+    }
+    const firstContent = result.content?.[0];
+    const fullText = firstContent && "text" in firstContent
+        ? (firstContent.text ?? "").trim()
+        : "";
+    const preview = fullText.slice(0, 120);
+    const expandHint = expandCollapseHint("to expand");
+    const collapseHint = expandCollapseHint("to collapse");
+    const container = new Container();
+    if (stats.length) {
+        container.addChild(new Text(stats.join(theme.fg("dim", " • ")), 0, 0));
+    }
+    if (options.expanded) {
+        if (fullText) {
+            for (const line of fullText.split("\n")) {
+                container.addChild(new Text(truncateToWidth(line, 200), 0, 0));
+            }
+        }
+        container.addChild(new Text(theme.fg("dim", `  (${collapseHint})`), 0, 0));
+    }
+    else {
+        if (preview) {
+            container.addChild(new Text(theme.fg("dim", `  ⎿  ${preview}`) +
+                (fullText.length > 120 ? theme.fg("dim", "…") : ""), 0, 0));
+        }
+        if (fullText.length > 120) {
+            container.addChild(new Text(theme.fg("dim", `  (${expandHint})`), 0, 0));
+        }
+    }
+    return container;
+}
+function expandCollapseHint(action) {
+    return keyText("app.tools.expand").trim()
+        ? keyHint("app.tools.expand", action)
+        : rawKeyHint("Ctrl+O", action);
+}

package/dist/tool/schema.d.ts

@@ -0,0 +1,8 @@
+export declare function taskParametersSchema(): import("@sinclair/typebox").TObject<{
+    agent_type: import("@sinclair/typebox").TString;
+    prompt: import("@sinclair/typebox").TString;
+    description: import("@sinclair/typebox").TString;
+    task_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    conversation_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    background: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;

package/dist/tool/schema.js

@@ -0,0 +1,24 @@
+import { Type } from "@sinclair/typebox";
+export function taskParametersSchema() {
+    return Type.Object({
+        agent_type: Type.String({
+            description: "The type of specialist agent to use for this task",
+        }),
+        prompt: Type.String({
+            description: "The complete task for the agent to perform. Be detailed and self-contained.",
+        }),
+        description: Type.String({
+            description: "A short (3-5 word) summary of the task",
+        }),
+        task_id: Type.Optional(Type.String({
+            description: "Resume an existing background task by id instead of starting a new task.",
+        })),
+        conversation_id: Type.Optional(Type.String({
+            description: "Durable specialist conversation id. Reuses .pi/artifacts/task-<id>/sessions when called again.",
+        })),
+        background: Type.Optional(Type.Boolean({
+            description: "Run in background (async). You will be notified when it completes. DO NOT sleep, poll, ask the task for status, or duplicate its work while it runs in background.",
+            default: true,
+        })),
+    });
+}

package/dist/tool/taskComplete.d.ts

@@ -0,0 +1,8 @@
+import { Text } from "@earendil-works/pi-tui";
+/**
+ * Renderer for background task completion notifications.
+ * Supports collapsed/expanded views with Ctrl+O.
+ */
+export declare function createTaskCompleteRenderer(): (message: any, { expanded }: {
+    expanded?: boolean;
+}, theme: any) => Text | undefined;