@heyhuynhgiabuu/pi-task 0.1.5 → 0.2.0

package/dist/conversation.js

@@ -1,19 +1,123 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-export const CONVERSATION_REGISTRY_FILE = "task-conversations.json";
-export function getArtifactsDir(piDir) {
-    return join(piDir, "artifacts");
+/**
+ * Conversational subagent helpers.
+ *
+ * Per-task data lives in `.pi/artifacts/TASKS.md` as `### <task-id>` blocks.
+ * A small `task-sessions.json` registry in the same directory maps
+ * `conversation_id` to the auto-saved session file path so the
+ * subagent can be resumed later.
+ *
+ * The subagent's session is auto-saved by pi at
+ * `~/.pi/agent/sessions/<cwd>/<session-id>.jsonl`. pi-task does not
+ * maintain its own session storage.
+ *
+ * All artifacts live flat at the top of `.pi/artifacts/`, alongside the
+ * pikit canonical files (TODO.md, PLAN.md, PROGRESS.md, DECISIONS.md).
+ * No subdirs. No per-task paths.
+ */
+export const TASKS_FILE = "TASKS.md";
+export const TASK_SESSIONS_REGISTRY_FILE = "task-sessions.json";
+export function getTasksFilePath(piDir) {
+    return join(piDir, "artifacts", TASKS_FILE);
 }
-export function getConversationRegistryPath(piDir) {
-    return join(getArtifactsDir(piDir), CONVERSATION_REGISTRY_FILE);
+export function getTaskSessionsRegistryPath(piDir) {
+    return join(piDir, "artifacts", TASK_SESSIONS_REGISTRY_FILE);
 }
-export function taskArtifactName(taskId) {
-    return taskId.startsWith("task-") ? taskId : `task-${taskId}`;
+export function readRegistry(piDir) {
+    const path = join(piDir, "task-registry.json");
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+export function writeRegistry(piDir, entries) {
+    const path = join(piDir, "task-registry.json");
+    writeFileSync(path, JSON.stringify(entries, null, 2), "utf-8");
+}
+export function readTaskSessionHistory(piDir) {
+    const path = join(piDir, "task-session-history.json");
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return [];
+    }
+}
+export function writeTaskSessionHistory(piDir, entries) {
+    const path = join(piDir, "task-session-history.json");
+    writeFileSync(path, JSON.stringify(entries, null, 2), "utf-8");
+}
+export 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);
 }
-export function taskIdFromArtifactName(artifactName) {
-    return artifactName.startsWith("task-")
-        ? artifactName.slice("task-".length)
-        : artifactName;
+export function findTaskSessionHistory(piDir, idOrSessionName) {
+    return readTaskSessionHistory(piDir).find((entry) => entry.id === idOrSessionName || entry.sessionName === idOrSessionName);
+}
+export 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,
+                                conversationId: sessionName,
+                                status: "done",
+                                background: false,
+                            };
+                        }
+                        break;
+                    }
+                }
+                catch {
+                    // Skip malformed lines.
+                }
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
 }
 export function normalizeConversationId(value) {
     if (typeof value !== "string")
@@ -26,16 +130,21 @@ export function normalizeConversationId(value) {
     }
     return conversationId;
 }
-export function readConversationRegistry(piDir) {
+export function readTaskSessionsRegistry(piDir) {
     try {
-        const parsed = JSON.parse(readFileSync(getConversationRegistryPath(piDir), "utf-8"));
+        const parsed = JSON.parse(readFileSync(getTaskSessionsRegistryPath(piDir), "utf-8"));
         if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
             return {};
         }
         const registry = {};
         for (const [key, value] of Object.entries(parsed)) {
-            if (typeof value === "string")
-                registry[key] = value;
+            if (value &&
+                typeof value === "object" &&
+                typeof value.task_id === "string" &&
+                typeof value.session_file === "string") {
+                const v = value;
+                registry[key] = { task_id: v.task_id, session_file: v.session_file };
+            }
         }
         return registry;
     }
@@ -43,81 +152,182 @@ export function readConversationRegistry(piDir) {
         return {};
     }
 }
-export function writeConversationRegistry(piDir, registry) {
-    const artifactsDir = getArtifactsDir(piDir);
-    mkdirSync(artifactsDir, { recursive: true });
-    writeFileSync(getConversationRegistryPath(piDir), `${JSON.stringify(registry, null, 2)}\n`, "utf-8");
+export function writeTaskSessionsRegistry(piDir, registry) {
+    mkdirSync(join(piDir, "artifacts"), { recursive: true });
+    writeFileSync(getTaskSessionsRegistryPath(piDir), `${JSON.stringify(registry, null, 2)}\n`, "utf-8");
 }
-export function readConversationMetadata(metadataPath) {
+/**
+ * Find a `### <task-id>` block in TASKS.md. Returns the block content
+ * (everything between the heading and the next H3 or EOF) plus the
+ * status line if present. Returns undefined if no block exists.
+ */
+export function readTaskBlock(piDir, taskId) {
+    let content;
     try {
-        const parsed = JSON.parse(readFileSync(metadataPath, "utf-8"));
-        if (!parsed.conversation_id || !parsed.task_id)
-            return undefined;
-        return parsed;
+        content = readFileSync(getTasksFilePath(piDir), "utf-8");
     }
     catch {
         return undefined;
     }
+    return parseTaskBlocks(content).get(taskId);
 }
-export function buildSessionCard(metadata) {
-    return [
-        `# ${metadata.conversation_id}`,
-        "",
-        `Agent: ${metadata.agent_type}`,
-        `Task: ${taskArtifactName(metadata.task_id)}`,
-        `Last used: ${metadata.last_used_at}`,
-        `Session dir: ${metadata.session_dir}`,
-        "",
-        "## Resume",
+export function listTaskBlocks(piDir) {
+    let content;
+    try {
+        content = readFileSync(getTasksFilePath(piDir), "utf-8");
+    }
+    catch {
+        return new Map();
+    }
+    return parseTaskBlocks(content);
+}
+function parseTaskBlocks(content) {
+    const blocks = new Map();
+    const lines = content.split("\n");
+    let currentTaskId = null;
+    let currentStatus = null;
+    let currentBody = [];
+    const flush = () => {
+        if (currentTaskId !== null) {
+            blocks.set(currentTaskId, {
+                status: currentStatus,
+                body: currentBody.join("\n"),
+            });
+        }
+        currentTaskId = null;
+        currentStatus = null;
+        currentBody = [];
+    };
+    for (const line of lines) {
+        const heading = line.match(/^###\s+(\S+)\s*$/);
+        if (heading) {
+            flush();
+            currentTaskId = heading[1];
+            continue;
+        }
+        if (currentTaskId === null)
+            continue;
+        const statusMatch = line.match(/^status:\s*(\S+)/);
+        if (statusMatch) {
+            currentStatus = statusMatch[1].toLowerCase();
+            continue;
+        }
+        currentBody.push(line);
+    }
+    flush();
+    return blocks;
+}
+/**
+ * Append or update a `### <task-id>` block in TASKS.md. If the block
+ * already exists, its body is replaced. Otherwise, the block is
+ * appended at the end of the file.
+ */
+export function writeTaskBlock(options) {
+    const path = getTasksFilePath(options.piDir);
+    let content = "";
+    try {
+        content = readFileSync(path, "utf-8");
+        if (!content.endsWith("\n"))
+            content += "\n";
+    }
+    catch {
+        content = "";
+    }
+    const heading = `### ${options.taskId}`;
+    const statusLine = `status: ${options.status} | updated: ${options.updated}`;
+    const block = `${heading}\n${statusLine}\n\n${options.body}\n`;
+    const headingRe = new RegExp(`^### ${escapeRegExp(options.taskId)}\\s*$`, "m");
+    const match = content.match(headingRe);
+    if (match && match.index !== undefined) {
+        const start = match.index;
+        const after = content.slice(start);
+        const nextHeading = after.search(/^###\s+\S+/m);
+        const end = nextHeading > 0 ? start + nextHeading : content.length;
+        content = content.slice(0, start) + block + content.slice(end);
+    }
+    else {
+        if (content.length > 0 && !content.endsWith("\n\n")) {
+            content += "\n";
+        }
+        content += block;
+    }
+    mkdirSync(join(options.piDir, "artifacts"), { recursive: true });
+    writeFileSync(path, content, "utf-8");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function parseMetadataFromBody(body) {
+    if (!body)
+        return undefined;
+    const match = body.match(/```json\n([\s\S]*?)\n```/);
+    if (!match)
+        return undefined;
+    try {
+        return JSON.parse(match[1]);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Persist a completed task: write (or update) the `### <task-id>` block
+ * in TASKS.md with metadata and result as H4 subsections. Also updates
+ * the task-sessions registry.
+ */
+export function writeConversationArtifacts(input) {
+    const now = new Date().toISOString();
+    const existing = readTaskBlock(input.piDir, input.taskId);
+    const previous = parseMetadataFromBody(existing?.body);
+    const metadata = {
+        conversation_id: input.conversationId,
+        task_id: input.taskId,
+        agent_type: input.agentType,
+        session_file: input.sessionFile,
+        created_at: previous?.created_at ?? now,
+        last_used_at: now,
+        last_prompt: input.prompt,
+    };
+    const body = [
+        "#### Metadata",
         "",
         "```json",
-        JSON.stringify({
-            agent_type: metadata.agent_type,
-            conversation_id: metadata.conversation_id,
-            prompt: "Continue from the prior specialist conversation.",
-        }, null, 2),
+        JSON.stringify(metadata, null, 2),
         "```",
         "",
-        "## Last prompt",
+        "#### Result",
         "",
-        metadata.last_prompt ?? "",
+        input.result.trim(),
         "",
     ].join("\n");
-}
-export function writeConversationArtifacts(options) {
-    const now = new Date().toISOString();
-    const metadataPath = join(options.taskDir, "metadata.json");
-    const existing = readConversationMetadata(metadataPath);
-    const metadata = {
-        conversation_id: options.conversationId,
-        task_id: options.taskId,
-        artifact: taskArtifactName(options.taskId),
-        agent_type: options.agentType,
-        session_dir: options.sessionDir,
-        session_name: options.sessionName,
-        created_at: existing?.created_at ?? now,
-        last_used_at: now,
-        last_prompt: options.prompt,
+    writeTaskBlock({
+        piDir: input.piDir,
+        taskId: input.taskId,
+        status: "done",
+        updated: now,
+        body,
+    });
+    const registry = readTaskSessionsRegistry(input.piDir);
+    registry[input.conversationId] = {
+        task_id: input.taskId,
+        session_file: input.sessionFile,
     };
-    mkdirSync(options.taskDir, { recursive: true });
-    writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, "utf-8");
-    writeFileSync(join(options.taskDir, "SESSION.md"), buildSessionCard(metadata), "utf-8");
+    writeTaskSessionsRegistry(input.piDir, registry);
     return metadata;
 }
 export function renderConversationSessions(piDir) {
-    const registry = readConversationRegistry(piDir);
-    const entries = Object.entries(registry).sort(([left], [right]) => left.localeCompare(right));
-    if (entries.length === 0) {
+    const blocks = listTaskBlocks(piDir);
+    if (blocks.size === 0) {
         return 'No durable task conversations found. Start one with task({ conversation_id: "research-ai", ... }).';
     }
+    const entries = Array.from(blocks.entries()).sort(([a], [b]) => a.localeCompare(b));
     const lines = ["Durable task conversations:"];
-    for (const [conversationId, artifactName] of entries) {
-        const taskId = taskIdFromArtifactName(artifactName);
-        const metadata = readConversationMetadata(join(getArtifactsDir(piDir), taskArtifactName(taskId), "metadata.json"));
-        const suffix = metadata
-            ? ` — ${metadata.agent_type}, last used ${metadata.last_used_at}`
-            : "";
-        lines.push(`${conversationId} -> ${taskArtifactName(taskId)}${suffix}`);
+    for (const [taskId, block] of entries) {
+        const metadata = parseMetadataFromBody(block.body);
+        const agent = metadata?.agent_type ?? "unknown";
+        const last = metadata?.last_used_at ?? "unknown";
+        const conv = metadata?.conversation_id ?? "(no conversation_id)";
+        lines.push(`${conv} -> ${taskId} — ${agent}, last used ${last}`);
     }
     return lines.join("\n");
 }

package/dist/helpers.d.ts

@@ -40,8 +40,8 @@ export interface ToolCallRecord {
     id: string;
 }
 export declare const TASK_BACKGROUND_DEFAULT = true;
-export declare const TASK_RESULT_XML_INSTRUCTIONS = "<status>success|failure|blocked|partial</status>\n<summary>One sentence: what was accomplished</summary>\n<findings>Key findings with file:line references</findings>\n<evidence>Verification evidence, commands run, output snippets</evidence>\n<confidence>high|medium|low (optional \u2014 how certain the findings are)</confidence>\n<files>Comma-separated absolute paths of files read/created (optional)</files>\n\nPrefer writing this block to RESULT.md when done. If you cannot write the file, your final assistant message MUST include the same XML block.";
-export declare const OUTPUT_FORMAT_GUIDE = "<status>success|failure|blocked|partial</status>\n<summary>One sentence: what was accomplished</summary>\n<findings>Key findings with file:line references</findings>\n<evidence>Verification evidence, commands run, output snippets</evidence>\n<confidence>high|medium|low (optional \u2014 how certain the findings are)</confidence>\n<files>Comma-separated absolute paths of files read/created (optional)</files>\n\nPrefer writing this block to RESULT.md when done. If you cannot write the file, your final assistant message MUST include the same XML block.";
+export declare const TASK_PROMPT_INSTRUCTIONS = "Your final assistant message IS the result the parent agent will read.\n\nWhen you are done, end your final assistant message with a clear, self-contained summary in plain text. Do not wrap it in XML tags. Do not write a RESULT.md file \u2014 the parent agent reads your final assistant message from the session JSONL, not from any file.";
+export declare const OUTPUT_FORMAT_GUIDE = "Your final assistant message IS the result the parent agent will read.\n\nWhen you are done, end your final assistant message with a clear, self-contained summary in plain text. Do not wrap it in XML tags. Do not write a RESULT.md file \u2014 the parent agent reads your final assistant message from the session JSONL, not from any file.";
 export declare const TASK_TOOL_DESCRIPTION = "Launch a new agent to handle complex, multistep tasks autonomously.\n\nInclude relevant context from your current work in the prompt parameter \u2014\nthis becomes the subagent's instructions. The subagent knows nothing about what you've been doing except what you put in the prompt.\n\nWhen NOT to use:\n- To read a specific file path, use Read or Grep instead\n- To search for a class definition like 'class Foo', use Grep instead\n- To search code within 2-3 files, use Read instead\n- If no available agent fits the task, use other tools directly\n\nUsage notes:\n1. Provide complete context in the prompt \u2014 the subagent starts with a fresh context\n2. Launch multiple agents concurrently when possible (use a single message with multiple tool calls)\n3. Once you delegate work, do NOT duplicate it. Continue with non-overlapping tasks, or wait for the result\n4. Background is the default. Use background:false only when you need the caller to wait inline for the tmux task result\n5. Do not trust delegated output blindly. Read changed files, review the diff, verify scope, and run the relevant checks before claiming completion\n6. Clearly tell the agent whether to write code or just research, since it doesn't know the user's intent\n7. The result returned by the agent is not visible to the user. Send a concise summary back to the user\n8. Pass task_id to resume a previous subagent session (continues with its prior context)\n\nBackground mode (background: true):\n- Launches the subagent asynchronously and returns immediately\n- You will be notified automatically when it finishes\n- DO NOT sleep, poll, ask the task for status, or duplicate its work while it runs in background\n- Avoid working with the same files or topics the background task is using\n- Work on non-overlapping tasks, or briefly tell the user what you launched and end your response";
 /** @deprecated Import from ./agent-tools.js */
 export { ALL_TOOL_NAMES, BUILTIN_TOOL_NAMES } from "./agent-tools.js";
@@ -72,12 +72,12 @@ export declare function formatAgentList(agents: AgentConfig[]): string;
  * Build pi CLI arguments for spawning or resuming a sub-agent session.
  *
  * - Fresh spawn: omit `resume` or pass falsy — `--session` is not included.
- * - Resume: pass `resume=true` — `--session <name>` is included so pi
- *   continues the existing session file in --session-dir.
- */
-export declare function buildPiArgs(agent: AgentConfig, sessionName: string, sessionDir: string, promptContent: string, resume?: boolean, parentToolNames?: string[]): string[];
+     * - Resume: pass `resume=true` and optionally `resumeSessionRef` —
+     *   `--session <ref>` is included so pi continues an existing session.
+     */
+export declare function buildPiArgs(agent: AgentConfig, sessionName: string, sessionDir: string, promptContent: string, resume?: boolean, parentToolNames?: string[], resumeSessionRef?: string): string[];
 /** Count tool uses and turns from pi JSONL session files. */
-export declare function countToolUses(sessionDir: string): {
+export declare function countToolUses(sessionDir: string, sessionName?: string): {
     toolUses: number;
     turns: number;
 };
@@ -94,7 +94,7 @@ export declare function summarizeArgs(toolName: string, args: unknown): string;
  * Returns total counts plus the last `limit` records in chronological order.
  * Safe against malformed lines and missing fields.
  */
-export declare function readRecentToolCalls(sessionDir: string, limit?: number): {
+export declare function readRecentToolCalls(sessionDir: string, limit?: number, sessionName?: string): {
     toolUses: number;
     turns: number;
     recent: ToolCallRecord[];

package/dist/helpers.js

@@ -32,15 +32,10 @@ export function parseMarkdownFrontmatter(content) {
 }
 // ─── Constants ───────────────────────────────────────────────────────────────
 export const TASK_BACKGROUND_DEFAULT = true;
-export const TASK_RESULT_XML_INSTRUCTIONS = `<status>success|failure|blocked|partial</status>
-<summary>One sentence: what was accomplished</summary>
-<findings>Key findings with file:line references</findings>
-<evidence>Verification evidence, commands run, output snippets</evidence>
-<confidence>high|medium|low (optional — how certain the findings are)</confidence>
-<files>Comma-separated absolute paths of files read/created (optional)</files>
+export const TASK_PROMPT_INSTRUCTIONS = `Your final assistant message IS the result the parent agent will read.
 
-Prefer writing this block to RESULT.md when done. If you cannot write the file, your final assistant message MUST include the same XML block.`;
-export const OUTPUT_FORMAT_GUIDE = TASK_RESULT_XML_INSTRUCTIONS;
+When you are done, end your final assistant message with a clear, self-contained summary in plain text. Do not wrap it in XML tags. Do not write a RESULT.md file — the parent agent reads your final assistant message from the session JSONL, not from any file.`;
+export const OUTPUT_FORMAT_GUIDE = TASK_PROMPT_INSTRUCTIONS;
 export const TASK_TOOL_DESCRIPTION = `Launch a new agent to handle complex, multistep tasks autonomously.
 
 Include relevant context from your current work in the prompt parameter —
@@ -89,7 +84,7 @@ export function parseResultXml(raw) {
         !extractTag(raw, EVIDENCE_RE)) {
         return {
             status: "unknown",
-            summary: raw.slice(0, 500),
+            summary: raw.trim(),
             findings: "",
             evidence: "",
             confidence: "",
@@ -256,22 +251,42 @@ export function formatAgentList(agents) {
  * Build pi CLI arguments for spawning or resuming a sub-agent session.
  *
  * - Fresh spawn: omit `resume` or pass falsy — `--session` is not included.
- * - Resume: pass `resume=true` — `--session <name>` is included so pi
- *   continues the existing session file in --session-dir.
- */
-export function buildPiArgs(agent, sessionName, sessionDir, promptContent, resume, parentToolNames) {
+     * - Resume: pass `resume=true` and optionally `resumeSessionRef` —
+     *   `--session <ref>` is included so pi continues an existing session.
+     */
+export function buildPiArgs(agent, sessionName, sessionDir, promptContent, resume, parentToolNames, resumeSessionRef) {
     return buildPiArgv({
         agent,
         sessionName,
         sessionDir,
         promptContent,
         resume,
+        resumeSessionRef,
         parentToolNames,
     });
 }
 // ─── JSONL Session Helpers ───────────────────────────────────────────────────
+function matchesJsonlSessionName(content, sessionName) {
+    if (!sessionName)
+        return true;
+    for (const rawLine of content.split("\n")) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            if (entry.type === "session_info") {
+                return (entry.name ?? entry.session_info?.name) === sessionName;
+            }
+        }
+        catch {
+            // Skip malformed lines
+        }
+    }
+    return false;
+}
 /** Count tool uses and turns from pi JSONL session files. */
-export function countToolUses(sessionDir) {
+export function countToolUses(sessionDir, sessionName) {
     let toolUses = 0;
     let turns = 0;
     try {
@@ -280,6 +295,8 @@ export function countToolUses(sessionDir) {
         const files = readdirSync(sessionDir).filter((f) => f.endsWith(".jsonl"));
         for (const file of files) {
             const content = readFileSync(join(sessionDir, file), "utf-8");
+            if (!matchesJsonlSessionName(content, sessionName))
+                continue;
             for (const rawLine of content.split("\n")) {
                 const line = rawLine.trim();
                 if (!line)
@@ -368,7 +385,7 @@ export function summarizeArgs(toolName, args) {
  * Returns total counts plus the last `limit` records in chronological order.
  * Safe against malformed lines and missing fields.
  */
-export function readRecentToolCalls(sessionDir, limit = 12) {
+export function readRecentToolCalls(sessionDir, limit = 12, sessionName) {
     let toolUses = 0;
     let turns = 0;
     const calls = [];
@@ -379,6 +396,8 @@ export function readRecentToolCalls(sessionDir, limit = 12) {
         const files = readdirSync(sessionDir).filter((f) => f.endsWith(".jsonl"));
         for (const file of files) {
             const content = readFileSync(join(sessionDir, file), "utf-8");
+            if (!matchesJsonlSessionName(content, sessionName))
+                continue;
             for (const rawLine of content.split("\n")) {
                 const line = rawLine.trim();
                 if (!line)

package/dist/index.d.ts

@@ -1,35 +1,18 @@
 /**
  * Task Tool — Delegate complex work to specialist agents.
  *
- * Spawns pi CLI in a tmux split pane (so you can watch it live) and
- * detects completion via RESULT.md polling. On completion, tool call
- * count and duration are reported as a notification.
+ * Spawns pi CLI in a tmux split pane (foreground) or background.
+ * Completion is detected from the subagent's final assistant message
+ * in the persistent session JSONL (stopReason gating). The final message
+ * is the authoritative result; no RESULT.md is used.
  *
  * Three agent sources:
  *   - .pi/agents/*.md        project-local agents
  *   - ~/.pi/agent/agents/*.md user-global agents (fallback)
  *
  * P0: Persistent task registry (appendEntry + JSON), --session resume,
- *     sendMessage completion notification.
- * P1: Foreground mode (background:false, inline subprocess), pane death
- *     detection, 30-minute timeout.
+ *     sendMessage completion notification, Ctrl+O expand/collapse.
+ * P1: Foreground mode (background:false), pane death detection, timeout.
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-export /** Details attached to tool result for rendering. */ interface TaskDetails {
-    task_id: string;
-    agent_type: string;
-    description: string;
-    conversation_id?: string;
-    phase: "done" | "timeout" | "aborted" | "failed";
-    status?: string;
-    summary?: string;
-    findings?: string;
-    evidence?: string;
-    confidence?: string;
-    duration_ms?: number;
-    turn_count?: number;
-    tool_uses?: number;
-    background?: boolean;
-    tmux_session?: string;
-}
 export default function (pi: ExtensionAPI): void;