@heyhuynhgiabuu/pi-task 0.1.4 → 0.1.6

package/dist/index.js

@@ -14,24 +14,26 @@
  * P1: Foreground mode (background:false, inline subprocess), pane death
  *     detection, 30-minute timeout.
  */
-import { mkdir, writeFile } from "node:fs/promises";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Type } from "@sinclair/typebox";
 import { Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { buildAgentToolSelection } from "./agent-tools.js";
+import { normalizeConversationId, parseMetadataFromBody, readTaskBlock, readTaskSessionsRegistry, renderConversationSessions, writeConversationArtifacts, writeTaskSessionsRegistry, } from "./conversation.js";
 import { TASK_BACKGROUND_DEFAULT, TASK_RESULT_XML_INSTRUCTIONS, TASK_TOOL_DESCRIPTION, buildTmuxSplitWindowArgs, chooseTmuxSplitDirection, formatBackgroundReceipt, buildPiArgs, parseResultXml, formatMs, shellQuote, discoverAgents, formatAgentList, countToolUses, readRecentToolCalls, } from "./helpers.js";
 import { runSdkSubagent } from "./subagent/runSdk.js";
 import { checkTaskCompletion, waitForTaskCompletion as waitForSessionTaskCompletion, } from "./subagent/waitCompletion.js";
-import { buildAgentToolSelection } from "./agent-tools.js";
+import { renderTaskWidget, TASK_WIDGET_RENDER_MS, } from "./task-widget.js";
 // ─── Constants ───────────────────────────────────────────────────────────────
 const BUNDLED_AGENT_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "agents");
 const BACKGROUND_CHECK_MS = 10_000; // poll every 10 sec
 const COUNT_POLL_MS = 3_000; // update toolcall counts every 3 sec
 const TASK_TIMEOUT_MS = 30 * 60 * 1_000; // 30 minutes
-// ─── Registry helpers (durable JSON) ─────────────────────────────────────────
+// Conversation helpers live in ./conversation.js.
 function readRegistry(piDir) {
     const path = join(piDir, "task-registry.json");
     try {
@@ -45,6 +47,87 @@ function writeRegistry(piDir, entries) {
     const path = join(piDir, "task-registry.json");
     writeFileSync(path, JSON.stringify(entries, null, 2), "utf-8");
 }
+function readTaskSessionHistory(piDir) {
+    const path = join(piDir, "task-session-history.json");
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+function writeTaskSessionHistory(piDir, entries) {
+    const path = join(piDir, "task-session-history.json");
+    writeFileSync(path, JSON.stringify(entries, null, 2), "utf-8");
+}
+function upsertTaskSessionHistory(piDir, entry) {
+    const entries = readTaskSessionHistory(piDir);
+    const index = entries.findIndex((existing) => existing.id === entry.id);
+    if (index >= 0) {
+        entries[index] = { ...entries[index], ...entry };
+    }
+    else {
+        entries.push(entry);
+    }
+    writeTaskSessionHistory(piDir, entries);
+}
+function findTaskSessionHistory(piDir, idOrSessionName) {
+    return readTaskSessionHistory(piDir).find((entry) => entry.id === idOrSessionName || entry.sessionName === idOrSessionName);
+}
+function findJsonlSessionByName(piDir, sessionName, agentType) {
+    const artifactsDir = join(piDir, "artifacts");
+    const sessionDir = join(artifactsDir, "sessions");
+    try {
+        if (!existsSync(sessionDir))
+            return undefined;
+        const files = readdirSync(sessionDir)
+            .filter((file) => file.endsWith(".jsonl"))
+            .sort()
+            .reverse();
+        for (const file of files) {
+            const content = readFileSync(join(sessionDir, file), "utf-8");
+            let startedAt = Date.now();
+            for (const rawLine of content.split("\n")) {
+                const line = rawLine.trim();
+                if (!line)
+                    continue;
+                try {
+                    const entry = JSON.parse(line);
+                    if (entry.type === "session" && entry.timestamp) {
+                        const parsed = Date.parse(entry.timestamp);
+                        if (Number.isFinite(parsed))
+                            startedAt = parsed;
+                    }
+                    if (entry.type === "session_info") {
+                        const name = entry.name ?? entry.session_info?.name;
+                        if (name === sessionName) {
+                            return {
+                                id: sessionName,
+                                agentType,
+                                description: `Resumed session ${sessionName}`,
+                                sessionName,
+                                sessionRef: join(sessionDir, file),
+                                startedAt,
+                                piDir,
+                                dir: artifactsDir,
+                                status: "done",
+                                background: false,
+                            };
+                        }
+                        break;
+                    }
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
 // ─── Tmux Helpers ────────────────────────────────────────────────────────────
 function tmuxCmd(args) {
     return execFileSync("tmux", args, {
@@ -128,6 +211,22 @@ function completeTask(pi, id, task, content, phase, piDir) {
     killAgentPane(task.paneId, task.originalPane);
     const parsed = parseResultXml(content);
     const durationMs = Date.now() - task.startedAt;
+    const completedSessionRef = findJsonlSessionByName(piDir, task.sessionName, task.agentType)?.sessionRef;
+    upsertTaskSessionHistory(piDir, {
+        id,
+        agentType: task.agentType,
+        description: task.description,
+        sessionName: task.sessionName,
+        startedAt: task.startedAt,
+        paneId: task.paneId,
+        piDir,
+        dir: task.dir,
+        conversationId: task.conversationId,
+        sessionRef: completedSessionRef,
+        status: phase,
+        completedAt: Date.now(),
+        background: true,
+    });
     // Send completion notification
     pi.sendMessage({
         customType: "task-complete",
@@ -190,6 +289,7 @@ export default function (pi) {
             startedAt: entry.startedAt,
             toolUses: 0,
             turns: 0,
+            conversationId: entry.conversationId,
             recentCalls: [],
         };
         backgroundTasks.set(entry.id, bgtask);
@@ -212,62 +312,27 @@ export default function (pi) {
         ]) {
             const sessionDir = join(task.dir, "sessions");
             // Single walk: counts + recent tool-call history with status
-            const { toolUses, turns, recent } = readRecentToolCalls(sessionDir, 12);
+            const { toolUses, turns, recent } = readRecentToolCalls(sessionDir, 12, task.sessionName);
             task.toolUses = toolUses;
             task.turns = turns;
             task.recentCalls = recent;
         }
     }, COUNT_POLL_MS);
-    /**
-     * Render a streaming view of one active subagent. Layout per task:
-     *
-     *   ⠋ Scout — SDK docs  • 1m 0s  11 toolcalls       (themed: accent + dim)
-     *     ├─ ✓ websearch  Model Context Protocol 2026    (green/success)
-     *     ├─ ✓ codesearch MCP reference server typescript
-     *     ├─ ✗ bash  curl -sL "https://api.github.com..."  (red/error)
-     *     └─ ⠹ read  /Users/.../scout.md                 (yellow/warning, animates)
-     *
-     * The header caret and in-progress tool marks share the same spinner
-     * frame set (rotates every WIDGET_RENDER_MS based on wall-clock time,
-     * so the animation cadence is stable regardless of TUI render rate).
-     */
     // Theme reference is captured at setWidget time so renderWidget can use it.
-    // We don't import the Theme type because it's not exported; structural typing
-    // via `any` here is safe — the c() helper only calls `theme(color, text)`.
     let widgetTheme = null;
-    // 8-frame Braille spinner. 80ms cadence = 12.5 FPS, which is the human
-    // perception threshold for "smooth motion" (below ~10 FPS the brain
-    // sees discrete steps; above ~12 FPS it reads as continuous rotation).
-    // Full rotation: 8 × 80ms = 640ms. Used for both per-tool in-progress
-    // marks AND the header caret (the "agent is active" indicator).
-    const WIDGET_SPINNER_FRAMES = [
-        "\u280B",
-        "\u2819",
-        "\u2838",
-        "\u2834",
-        "\u2826",
-        "\u2827",
-        "\u2807",
-        "\u280F",
-    ];
-    const WIDGET_CARET_FRAMES = WIDGET_SPINNER_FRAMES;
-    const WIDGET_RENDER_MS = 80;
-    const WIDGET_MAX_TOOL_LINES = 12;
-    const WIDGET_MAX_WIDTH = 120;
-    const TREE_MIDDLE = "\u251C\u2500"; // ├─
-    const TREE_LAST = "\u2514\u2500"; // └─
-    function c(color, text) {
-        // widgetTheme is a Theme object with a .fg(color, text) method,
-        // not a callable. Calling it as a function throws "widgetTheme is not
-        // a function" which the outer try/catch in renderWidget swallows.
-        return widgetTheme ? widgetTheme.fg(color, text) : text;
-    }
     function renderWidget(width) {
         // Defensive: never let a render exception kill the TUI. If anything
         // throws (theme lookup miss, malformed session JSONL, etc.), fall
         // back to a minimal single-line summary so the TUI stays alive.
         try {
-            return renderWidgetInner(width);
+            return renderTaskWidget({
+                foregroundTasks: foregroundTasks.entries(),
+                backgroundTasks: backgroundTasks.entries(),
+                foregroundCount: foregroundTasks.size,
+                backgroundCount: backgroundTasks.size,
+                width,
+                theme: widgetTheme,
+            });
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -279,7 +344,7 @@ export default function (pi) {
                 return [];
             const [, task] = active[0];
             return [
-                truncateToWidth(`${task.agentType}  \u2022 ${formatMs(Date.now() - task.startedAt)}  (render error: ${msg})`, Math.min(width, WIDGET_MAX_WIDTH)),
+                truncateToWidth(`${task.agentType}  \u2022 ${formatMs(Date.now() - task.startedAt)}  (render error: ${msg})`, Math.min(width, 120)),
             ];
         }
     }
@@ -289,7 +354,7 @@ export default function (pi) {
         widgetCtx = targetCtx;
         targetCtx.ui.setWidget("task", (tui, theme) => {
             widgetTheme = theme ?? null;
-            widgetTimer = setInterval(() => tui.requestRender(), WIDGET_RENDER_MS);
+            widgetTimer = setInterval(() => tui.requestRender(), TASK_WIDGET_RENDER_MS);
             // Don't keep the process alive just for the widget refresh.
             widgetTimer.unref?.();
             return {
@@ -311,62 +376,6 @@ export default function (pi) {
             widgetCtx = null;
         }
     }
-    function renderWidgetInner(width) {
-        const active = [
-            ...Array.from(foregroundTasks.entries()),
-            ...Array.from(backgroundTasks.entries()),
-        ];
-        if (active.length === 0)
-            return [];
-        const now = Date.now();
-        const maxWidth = Math.min(width, WIDGET_MAX_WIDTH);
-        const tick = Math.floor(now / WIDGET_RENDER_MS);
-        const spinner = WIDGET_SPINNER_FRAMES[tick % WIDGET_SPINNER_FRAMES.length];
-        const caret = WIDGET_CARET_FRAMES[tick % WIDGET_CARET_FRAMES.length];
-        const lines = [];
-        for (const [, task] of active) {
-            const agentName = task.agentType.charAt(0).toUpperCase() + task.agentType.slice(1);
-            const elapsed = formatMs(now - task.startedAt);
-            const total = task.toolUses > 0 ? `  ${task.turns || task.toolUses} toolcalls` : "";
-            const description = task.description ? ` — ${task.description}` : "";
-            // Header: ▼ <Agent> — <description>  • 1m 0s  11 toolcalls
-            const header = c("accent", caret) +
-                " " +
-                c("toolTitle", agentName) +
-                c("dim", `${description}  \u2022 ${elapsed}${total}`);
-            lines.push(truncateToWidth(header, maxWidth));
-            const recent = task.recentCalls ?? [];
-            if (recent.length > 0) {
-                const slice = recent.slice(-WIDGET_MAX_TOOL_LINES);
-                slice.forEach((tc, idx) => {
-                    const isLast = idx === slice.length - 1;
-                    const connector = isLast ? TREE_LAST : TREE_MIDDLE;
-                    const isInProgress = tc.status === "in_progress";
-                    const markChar = isInProgress
-                        ? spinner
-                        : tc.status === "error"
-                            ? "\u2717"
-                            : "\u2713";
-                    const markColor = isInProgress
-                        ? "warning"
-                        : tc.status === "error"
-                            ? "error"
-                            : "success";
-                    const detailStr = tc.detail ? `  ${tc.detail}` : "";
-                    const line = "  " +
-                        c("dim", connector) +
-                        " " +
-                        c(markColor, markChar) +
-                        " " +
-                        c("text", tc.name) +
-                        c("dim", detailStr);
-                    lines.push(truncateToWidth(line, maxWidth));
-                });
-            }
-            lines.push("");
-        }
-        return lines;
-    }
     // ── Polling loop (background task completion, pane death, timeout) ──────
     const checkInterval = setInterval(async () => {
         if (backgroundTasks.size === 0) {
@@ -379,24 +388,27 @@ export default function (pi) {
             const task = backgroundTasks.get(id);
             if (!task)
                 continue;
-            backgroundTasks.delete(id); // Remove atomically
             // ── Check timeout ────────────────────────────────────────────
             if (now - task.startedAt > TASK_TIMEOUT_MS) {
                 killAgentPane(task.paneId, task.originalPane);
+                backgroundTasks.delete(id);
+                clearTaskWidgetIfIdle();
                 completeTask(pi, id, task, "Task timed out after 30 minutes", "timeout", piDir);
                 continue;
             }
             const snapshot = await checkTaskCompletion({
                 resultPath: join(task.dir, "RESULT.md"),
-                sessionDir: task.dir,
+                sessionDir: join(task.dir, "sessions"),
                 sessionName: task.sessionName,
                 paneId: task.paneId,
+                sinceMs: task.startedAt,
             });
             if (snapshot.status === "running") {
-                backgroundTasks.set(id, task);
                 continue;
             }
             const phase = snapshot.status === "completed" ? "done" : "failed";
+            backgroundTasks.delete(id);
+            clearTaskWidgetIfIdle();
             completeTask(pi, id, task, snapshot.content, phase, piDir);
         }
     }, BACKGROUND_CHECK_MS);
@@ -422,34 +434,36 @@ export default function (pi) {
         const confidence = d.confidence || "";
         const durationMs = d.duration_ms || 0;
         const toolUses = d.tool_uses || 0;
-        const turns = d.turn_count || 0;
-        let line = theme.fg("accent", agentType);
+        let line = " " + theme.fg("accent", agentType);
         if (desc)
             line += theme.fg("dim", ` - ${desc}`);
-        const useStr = toolUses > 0 ? `${turns || toolUses} toolcalls` : "";
+        const useStr = toolUses > 0 ? `${toolUses} toolcalls` : "";
         const durStr = durationMs >= 1000 ? formatMs(durationMs) : "";
         const statsParts = [useStr, durStr].filter(Boolean);
-        if (statsParts.length) {
-            line += "\n" + theme.fg("dim", statsParts.join(" • "));
-        }
+        const statsText = statsParts.join(" • ");
         const confStr = confidence ? confidence.toUpperCase() : "";
-        if (confStr && (statsParts.length || expanded)) {
-            const confColor = confidence === "high"
-                ? "success"
-                : confidence === "low"
-                    ? "error"
-                    : "accent";
-            line += "\n" + theme.fg(confColor, `[${confStr}]`);
+        const confColor = confidence === "high"
+            ? "success"
+            : confidence === "low"
+                ? "error"
+                : "accent";
+        if (statsText || confStr) {
+            line += "\n ";
+            if (confStr)
+                line += theme.fg(confColor, `[${confStr}]`);
+            if (statsText)
+                line += (confStr ? " " : "") + theme.fg("dim", statsText);
         }
         if (expanded) {
             if (summary)
-                line += "\n" + theme.fg("muted", summary);
+                line += "\n " + theme.fg("muted", summary);
             if (findings)
-                line += "\n" + theme.fg("dim", findings);
+                line += "\n " + theme.fg("dim", findings);
         }
         if (!line.trim())
             return undefined;
-        return new Text(line, 0, 0);
+        const subtleBg = (text) => `\x1b[48;2;30;28;44m${text}\x1b[0m`;
+        return new Text(line, 0, 1, subtleBg);
     });
     // ── Tool Registration ──────────────────────────────────────────────────
     pi.registerTool({
@@ -478,7 +492,10 @@ export default function (pi) {
                 description: "A short (3-5 word) summary of the task",
             }),
             task_id: Type.Optional(Type.String({
-                description: "Resume a previous task by ID (continues the same subagent session with its prior context instead of creating a fresh one)",
+                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.",
@@ -508,22 +525,139 @@ export default function (pi) {
                     isError: true,
                 };
             }
-            // ── Resolve task identity: new or resume ───────────────────────────
+            // ── Resolve task identity: new, task resume, or conversation resume ──
+            const conversationId = normalizeConversationId(params.conversation_id);
+            const taskSessionsRegistry = conversationId
+                ? readTaskSessionsRegistry(piDir)
+                : {};
+            const registeredTaskId = conversationId
+                ? taskSessionsRegistry[conversationId]?.task_id
+                : undefined;
+            if (params.task_id &&
+                registeredTaskId &&
+                params.task_id !== registeredTaskId) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `conversation_id "${conversationId}" maps to ${registeredTaskId}, not ${params.task_id}. Omit task_id or use the mapped task id.`,
+                        },
+                    ],
+                    details: {
+                        phase: "failed",
+                        error: "conversation_id/task_id mismatch",
+                    },
+                    isError: true,
+                };
+            }
             let id;
             let sessionName;
-            let artifactDir;
             let resultPath;
             let resume = false;
-            if (params.task_id) {
-                // Look up the task in the persistent registry
+            let resumeSessionRef;
+            const artifactsDir = join(piDir, "artifacts");
+            if (registeredTaskId) {
+                id = registeredTaskId;
+                sessionName = conversationId ?? `task-${id}`;
+                resultPath = join(artifactsDir, `RESULT-${id}.md`);
+                if (!existsSync(resultPath)) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `conversation_id "${conversationId}" has no prior result file at ${resultPath}. Cannot resume.`,
+                            },
+                        ],
+                        details: {
+                            phase: "failed",
+                            error: "Conversation result missing",
+                            conversation_id: conversationId,
+                        },
+                        isError: true,
+                    };
+                }
+                const block = readTaskBlock(piDir, id);
+                const previousMetadata = parseMetadataFromBody(block?.body);
+                const metadataAgent = previousMetadata?.agent_type;
+                if (metadataAgent && metadataAgent !== agent.name) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `conversation_id "${conversationId}" belongs to agent "${metadataAgent}", not "${agent.name}". Use the original agent_type or start a different conversation_id.`,
+                            },
+                        ],
+                        details: {
+                            phase: "failed",
+                            error: "conversation_id agent_type mismatch",
+                            conversation_id: conversationId,
+                        },
+                        isError: true,
+                    };
+                }
+                resume = true;
+                const entry = readRegistry(piDir).find((candidate) => candidate.id === id);
+                if (params.background !== false &&
+                    entry?.paneId &&
+                    paneExists(entry.paneId)) {
+                    const bgtask = {
+                        dir: artifactsDir,
+                        agentType: entry.agentType,
+                        sessionName,
+                        paneId: entry.paneId,
+                        originalPane: null,
+                        description: params.description || entry.description,
+                        startedAt: entry.startedAt,
+                        toolUses: 0,
+                        turns: 0,
+                        conversationId,
+                        recentCalls: [],
+                    };
+                    backgroundTasks.set(id, bgtask);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Resumed conversation "${conversationId}" via ${sessionName}. The subagent is running in background and will notify on completion.`,
+                            },
+                        ],
+                        details: {
+                            task_id: id,
+                            agent_type: agent.name,
+                            description: params.description,
+                            conversation_id: conversationId,
+                            tmux_session: sessionName,
+                            background: true,
+                        },
+                    };
+                }
+            }
+            else if (params.task_id) {
+                // Look up active tasks first, then durable completed-session history.
                 const entries = readRegistry(piDir);
-                const entry = entries.find((e) => e.id === params.task_id);
+                let entry = entries.find((e) => e.id === params.task_id || e.sessionName === params.task_id) ??
+                    findTaskSessionHistory(piDir, params.task_id) ??
+                    findJsonlSessionByName(piDir, params.task_id, agent.name);
+                // Older history entries were written before we stored the
+                // actual JSONL path needed by `pi --session`. Repair them by
+                // resolving the display session name to a session file.
+                if (entry && !entry.sessionRef) {
+                    const discovered = findJsonlSessionByName(piDir, entry.sessionName, entry.agentType);
+                    if (discovered?.sessionRef) {
+                        entry = { ...entry, sessionRef: discovered.sessionRef };
+                        upsertTaskSessionHistory(piDir, {
+                            ...entry,
+                            status: "done",
+                            background: false,
+                        });
+                    }
+                }
                 if (!entry) {
                     return {
                         content: [
                             {
                                 type: "text",
-                                text: `Unknown task_id: "${params.task_id}". No task with that ID found in the registry.`,
+                                text: `Unknown task_id: "${params.task_id}". No active or completed task session with that ID/session name was found.`,
                             },
                         ],
                         details: {
@@ -548,26 +682,28 @@ export default function (pi) {
                         isError: true,
                     };
                 }
-                // Resume: reuse existing artifact dir and session name
+                // Resume: reuse the existing session name; runtime files are
+                // flat in artifactsDir, no per-task subdir.
                 id = entry.id;
                 sessionName = entry.sessionName;
-                artifactDir = entry.dir;
-                resultPath = join(artifactDir, "RESULT.md");
+                resultPath = join(artifactsDir, `RESULT-${id}.md`);
                 resume = true;
+                resumeSessionRef = entry.sessionRef;
                 // If background and pane still alive, reattach to tracker
                 if (params.background !== false &&
                     entry.paneId &&
                     paneExists(entry.paneId)) {
                     const bgtask = {
-                        dir: artifactDir,
-                        agentType: agent.name,
+                        dir: artifactsDir,
+                        agentType: entry.agentType,
                         sessionName,
                         paneId: entry.paneId,
                         originalPane: null,
-                        description: params.description || entry.agentType,
+                        description: params.description || entry.description,
                         startedAt: entry.startedAt,
                         toolUses: 0,
                         turns: 0,
+                        conversationId: entry.conversationId,
                         recentCalls: [],
                     };
                     backgroundTasks.set(id, bgtask);
@@ -580,27 +716,65 @@ export default function (pi) {
                         ],
                         details: {
                             task_id: id,
-                            agent_type: agent.name,
-                            description: params.description,
+                            agent_type: entry.agentType,
+                            description: params.description || entry.description,
+                            conversation_id: entry.conversationId ?? conversationId,
                             tmux_session: sessionName,
                             background: true,
                         },
                     };
                 }
+                if (!resumeSessionRef) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Task "${params.task_id}" was found, but its session JSONL file could not be resolved. Cannot resume without a --session file path.`,
+                            },
+                        ],
+                        details: {
+                            phase: "failed",
+                            error: "Task session file missing",
+                        },
+                        isError: true,
+                    };
+                }
             }
             else {
                 id = `${Date.now().toString(36)}-${randomUUID().slice(0, 4)}`;
-                sessionName = `task-${id}`;
-                artifactDir = join(piDir, "artifacts", sessionName);
-                await mkdir(artifactDir, { recursive: true });
-                resultPath = join(artifactDir, "RESULT.md");
+                sessionName = conversationId ?? `task-${id}`;
+                resultPath = join(artifactsDir, `RESULT-${id}.md`);
+            }
+            if (conversationId && !hasTmux()) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Durable conversations require the tmux/CLI backend so Pi can save and reopen the subagent session. Install/start tmux or omit conversation_id for a one-shot SDK task.",
+                        },
+                    ],
+                    details: {
+                        phase: "failed",
+                        error: "tmux required for durable conversation",
+                        conversation_id: conversationId,
+                    },
+                    isError: true,
+                };
+            }
+            if (conversationId) {
+                await mkdir(artifactsDir, { recursive: true });
+                const taskSessionsRegistry = readTaskSessionsRegistry(piDir);
+                taskSessionsRegistry[conversationId] = {
+                    task_id: id,
+                    session_file: `${artifactsDir}/${id}`,
+                };
+                writeTaskSessionsRegistry(piDir, taskSessionsRegistry);
             }
             const descText = params.description || "";
             const isBackground = params.background ?? TASK_BACKGROUND_DEFAULT;
             // default true
-            // ── Write durable task context ──────────────────────────────────────
-            const contextPath = join(artifactDir, "CONTEXT.md");
-            const contextContent = [
+            // ── Build the prompt (instructions are inlined; no CONTEXT.md file) ─
+            const promptContent = [
                 `# Task: ${descText}`,
                 "",
                 `## Agent`,
@@ -613,26 +787,18 @@ export default function (pi) {
                 ctx.cwd,
                 "",
                 `## Output`,
-                `Write your result to ${resultPath}`,
+                "Your final assistant message is the result. End with a clear summary of what you did and any findings. No file write is required.",
                 "",
-                "Use this format:",
+                "Use this format for the summary:",
                 "",
                 "```",
                 TASK_RESULT_XML_INSTRUCTIONS,
                 "```",
             ].join("\n");
-            await writeFile(contextPath, contextContent, "utf-8");
-            const promptContent = [
-                `Read ${contextPath} for your task.`,
-                `Write your findings/output to ${resultPath}`,
-                "",
-                "Format:",
-                TASK_RESULT_XML_INSTRUCTIONS,
-            ].join("\n");
-            const sessionDir = join(artifactDir, "sessions");
+            const sessionDir = join(artifactsDir, "sessions");
             await mkdir(sessionDir, { recursive: true });
             // ─── Build and run the sub-agent pi process ──────────────────────────
-            const piArgs = buildPiArgs(agent, sessionName, sessionDir, promptContent, resume, parentToolNames);
+            const piArgs = buildPiArgs(agent, sessionName, sessionDir, promptContent, resume, parentToolNames, resumeSessionRef);
             const envPrefix = `PI_TASK_TOOL_DISABLED=1`;
             const toolSelection = buildAgentToolSelection({
                 tools: agent.tools,
@@ -653,7 +819,7 @@ export default function (pi) {
             const foregroundTask = isBackground
                 ? undefined
                 : {
-                    dir: artifactDir,
+                    dir: artifactsDir,
                     agentType: agent.name,
                     sessionName,
                     originalPane: null,
@@ -661,6 +827,7 @@ export default function (pi) {
                     startedAt: Date.now(),
                     toolUses: 0,
                     turns: 0,
+                    conversationId,
                     recentCalls: [],
                 };
             if (foregroundTask) {
@@ -671,7 +838,7 @@ export default function (pi) {
             if (!hasTmux()) {
                 if (isBackground) {
                     const bgtask = {
-                        dir: artifactDir,
+                        dir: artifactsDir,
                         agentType: agent.name,
                         sessionName,
                         originalPane: null,
@@ -679,6 +846,7 @@ export default function (pi) {
                         startedAt: Date.now(),
                         toolUses: 0,
                         turns: 0,
+                        conversationId,
                         recentCalls: [],
                     };
                     backgroundTasks.set(id, bgtask);
@@ -689,17 +857,22 @@ export default function (pi) {
                         sessionName,
                         startedAt: bgtask.startedAt,
                         piDir,
-                        dir: artifactDir,
+                        dir: artifactsDir,
+                        conversationId,
                     };
                     const entries = readRegistry(piDir);
                     entries.push(entry);
                     writeRegistry(piDir, entries);
+                    upsertTaskSessionHistory(piDir, {
+                        ...entry,
+                        status: "running",
+                        background: true,
+                    });
                     pi.appendEntry("task-registry", entry);
                     ensureTaskWidget(ctx);
                     void runSdkFallback()
                         .then(async ({ output }) => {
                         const finalOutput = output || "SDK subagent completed without assistant text.";
-                        await writeFile(resultPath, finalOutput, "utf-8");
                         backgroundTasks.delete(id);
                         clearTaskWidgetIfIdle();
                         completeTask(pi, id, bgtask, finalOutput, "done", piDir);
@@ -722,13 +895,24 @@ export default function (pi) {
                             background: true,
                             backend: "sdk",
                             result_path: resultPath,
+                            conversation_id: conversationId,
                         },
                     };
                 }
                 try {
                     const { output, sessionPath } = await runSdkFallback();
                     const finalOutput = output || "SDK subagent completed without assistant text.";
-                    await writeFile(resultPath, finalOutput, "utf-8");
+                    if (conversationId) {
+                        writeConversationArtifacts({
+                            piDir,
+                            taskId: id,
+                            conversationId,
+                            agentType: agent.name,
+                            sessionFile: sessionPath ?? "unknown",
+                            prompt: params.prompt,
+                            result: finalOutput,
+                        });
+                    }
                     return {
                         content: [{ type: "text", text: finalOutput }],
                         details: {
@@ -736,6 +920,7 @@ export default function (pi) {
                             backend: "sdk",
                             session_path: sessionPath,
                             result_path: resultPath,
+                            conversation_id: conversationId,
                         },
                     };
                 }
@@ -786,14 +971,29 @@ export default function (pi) {
             }
             // ── FOREGROUND MODE: block until result, return directly ────────────
             if (!isBackground) {
-                const startedAt = Date.now();
+                const startedAt = foregroundTask?.startedAt ?? Date.now();
+                upsertTaskSessionHistory(piDir, {
+                    id,
+                    agentType: agent.name,
+                    description: descText,
+                    sessionName,
+                    startedAt,
+                    paneId,
+                    piDir,
+                    dir: artifactsDir,
+                    conversationId,
+                    status: "running",
+                    background: false,
+                });
                 const completion = await waitForSessionTaskCompletion({
                     resultPath,
                     sessionDir,
                     sessionName,
                     paneId,
                     signal,
-                    timeoutMs: 30 * 60 * 1000,
+                    timeoutMs: TASK_TIMEOUT_MS,
+                    pollMs: 1000,
+                    sinceMs: startedAt,
                 });
                 const content = completion.content;
                 const phase = completion.status === "completed"
@@ -801,19 +1001,46 @@ export default function (pi) {
                     : completion.status === "cancelled"
                         ? "cancelled"
                         : "failed";
+                const completedSessionRef = findJsonlSessionByName(piDir, sessionName, agent.name)?.sessionRef;
+                upsertTaskSessionHistory(piDir, {
+                    id,
+                    agentType: agent.name,
+                    description: descText,
+                    sessionName,
+                    startedAt,
+                    paneId,
+                    piDir,
+                    dir: artifactsDir,
+                    conversationId,
+                    sessionRef: completedSessionRef,
+                    status: phase,
+                    completedAt: Date.now(),
+                    background: false,
+                });
                 killAgentPane(paneId, originalPane);
                 foregroundTasks.delete(id);
                 clearTaskWidgetIfIdle();
+                if (conversationId) {
+                    writeConversationArtifacts({
+                        piDir,
+                        taskId: id,
+                        conversationId,
+                        agentType: agent.name,
+                        sessionFile: `${sessionDir}/${sessionName}`,
+                        prompt: params.prompt,
+                        result: content,
+                    });
+                }
                 const parsed = parseResultXml(content);
                 const durationMs = Date.now() - startedAt;
-                const { toolUses, turns } = countToolUses(sessionDir);
+                const { toolUses, turns } = countToolUses(sessionDir, sessionName);
                 return {
                     content: [
                         {
                             type: "text",
                             text: [
                                 `${parsed.status || "done"}: ${parsed.summary || content.slice(0, 300)}`,
-                                toolUses > 0 ? `\n${turns || toolUses} toolcalls` : "",
+                                toolUses > 0 ? `\n${toolUses} toolcalls` : "",
                                 durationMs >= 1000 ? `\n${formatMs(durationMs)}` : "",
                             ]
                                 .filter(Boolean)
@@ -834,12 +1061,13 @@ export default function (pi) {
                         tool_uses: toolUses,
                         turn_count: turns,
                         background: false,
+                        conversation_id: conversationId,
                     },
                 };
             }
             // ── BACKGROUND MODE (default): add to tracker, return immediately ─────
             const bgtask = {
-                dir: artifactDir,
+                dir: artifactsDir,
                 agentType: agent.name,
                 sessionName,
                 paneId,
@@ -848,6 +1076,7 @@ export default function (pi) {
                 startedAt: Date.now(),
                 toolUses: 0,
                 turns: 0,
+                conversationId,
                 recentCalls: [],
             };
             backgroundTasks.set(id, bgtask);
@@ -857,15 +1086,21 @@ export default function (pi) {
                 agentType: agent.name,
                 description: descText,
                 sessionName,
-                startedAt: Date.now(),
+                startedAt: bgtask.startedAt,
                 paneId,
                 piDir,
-                dir: artifactDir,
+                dir: artifactsDir,
+                conversationId,
             };
             // Write to JSON registry for on-load restore
             const entries = readRegistry(piDir);
             entries.push(entry);
             writeRegistry(piDir, entries);
+            upsertTaskSessionHistory(piDir, {
+                ...entry,
+                status: "running",
+                background: true,
+            });
             // Also persist to session store via appendEntry (audit trail)
             pi.appendEntry("task-registry", entry);
             // ── Abort signal handling ──────────────────────────────────────────
@@ -896,7 +1131,7 @@ export default function (pi) {
                             taskId: id,
                             agentType: agent.name,
                             tmuxSession: sessionName,
-                            artifactDir,
+                            artifactDir: artifactsDir,
                         }),
                     },
                 ],
@@ -923,7 +1158,17 @@ export default function (pi) {
             if (!d)
                 return new Text("", 0, 0);
             if (d.background) {
-                return new Text("", 0, 0);
+                const toolUses = d.tool_uses || 0;
+                const durationMs = d.duration_ms || 0;
+                const confidence = d.confidence || "";
+                const useStr = toolUses > 0 ? `${toolUses} toolcalls` : "";
+                const durStr = durationMs >= 1000 ? formatMs(durationMs) : "";
+                const statsParts = [useStr, durStr].filter(Boolean);
+                const statsText = statsParts.join(" \u2022 ");
+                const confStr = confidence ? `[${confidence.toUpperCase()}]` : "";
+                const statsLine = [confStr, statsText].filter(Boolean).join(" ");
+                const subtleBg = (text) => `\x1b[48;2;30;28;44m${text}\x1b[0m`;
+                return new Text(statsLine ? " " + theme.fg("dim", statsLine.trim()) : "", 0, 0, subtleBg);
             }
             if (d.phase === "timeout" ||
                 d.phase === "aborted" ||
@@ -938,8 +1183,7 @@ export default function (pi) {
                 d.status === "failed";
             const durationMs = d.duration_ms || 0;
             const toolUses = d.tool_uses || 0;
-            const turns = d.turn_count || 0;
-            const useStr = toolUses > 0 ? `${turns || toolUses} toolcalls` : "";
+            const useStr = toolUses > 0 ? `${toolUses} toolcalls` : "";
             const durStr = durationMs >= 1000 ? formatMs(durationMs) : "";
             const statsParts = [useStr, durStr].filter(Boolean);
             const statsStr = statsParts.length
@@ -974,4 +1218,12 @@ export default function (pi) {
             return new Text(line, 0, 0);
         },
     });
+    pi.registerCommand("task-sessions", {
+        description: "List durable pi-task conversations",
+        handler: async (_args, ctx) => {
+            const cwd = ctx.sessionManager?.getCwd?.() ?? process.cwd();
+            const { piDir } = discoverAgents(cwd);
+            ctx.ui.notify(renderConversationSessions(piDir), "info");
+        },
+    });
 }