@heyhuynhgiabuu/pi-task 0.1.6 → 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,10 +2,9 @@ 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;
@@ -14,5 +13,5 @@ export interface TaskCompletionOptions {
     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,56 +1,42 @@
-import { readFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import { getLastAssistantTextFromSessionDir } from "../session-text.js";
+import { getLastAssistantTextFromSessionDir, hasAgentFinished, } from "../session-text.js";
 import { paneExists } from "./tmux.js";
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-async function readResultFile(resultPath) {
-    if (!existsSync(resultPath))
-        return null;
-    const text = (await readFile(resultPath, "utf-8")).trim();
-    return text.length > 0 ? text : null;
-}
+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) {
-    // Session files are written by pi directly into `sessionDir`
-    // (flat). Filter by session_info.name so a new task never
-    // completes from an older task's JSONL.
+    if (!hasAgentFinished(sessionDir, sessionName, sinceMs))
+        return null;
     const text = getLastAssistantTextFromSessionDir(sessionDir, sessionName, sinceMs).trim();
     return text.length > 0 ? text : null;
 }
 export async function checkTaskCompletion(options) {
-    // When the pane has exited, give pi a brief moment to flush the
-    // session file. Without this, the read can catch a partial
-    // file (e.g. the last `agent_end` / `message_end` events not
-    // yet written) and report "failed" even though the subagent
-    // completed successfully.
+    // If the pane has exited, give pi a brief moment to flush JSONL.
     if (options.paneId && !paneExists(options.paneId)) {
         await sleep(500);
     }
-    const result = await readResultFile(options.resultPath);
-    if (result) {
-        return { status: "completed", content: result, source: "result-file" };
-    }
-    // Check session text FIRST. If the subagent's session file has
-    // its final assistant message, the subagent is done — kill the
-    // pane and return, regardless of whether the pane shell is
-    // still open (e.g. remain-on-exit on, or the command exited but
-    // tmux kept the shell alive).
+    // 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 session text yet. If the pane is gone and we never got
-    // session text, the subagent failed.
-    if (options.paneId && !paneExists(options.paneId)) {
-        return { status: "failed", content: "Subagent pane exited without producing a result." };
+    // No terminal assistant message yet. If the pane is alive, keep waiting.
+    if (options.paneId && paneExists(options.paneId)) {
+        return { status: "running", content: "", source: "pane" };
     }
-    // Pane still exists and no session text yet — keep polling.
-    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",
@@ -61,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/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;

package/dist/tool/taskComplete.js

@@ -0,0 +1,65 @@
+import { Text } from "@earendil-works/pi-tui";
+import { keyHint, keyText, rawKeyHint } from "@earendil-works/pi-coding-agent";
+/**
+ * Renderer for background task completion notifications.
+ * Supports collapsed/expanded views with Ctrl+O.
+ */
+export function createTaskCompleteRenderer() {
+    return (message, { expanded }, theme) => {
+        const d = message.details;
+        if (!d)
+            return undefined;
+        const agentType = d.agent_type || "";
+        const desc = d.description || "";
+        const result = (d.result || "").trim();
+        const durationMs = d.duration_ms || 0;
+        const toolUses = d.tool_uses || 0;
+        let line = " " + theme.fg("accent", agentType);
+        if (desc)
+            line += theme.fg("dim", ` - ${desc}`);
+        const useStr = toolUses > 0 ? `${toolUses} toolcalls` : "";
+        const durStr = durationMs >= 1000 ? formatMs(durationMs) : "";
+        const statsParts = [useStr, durStr].filter(Boolean);
+        const statsText = statsParts.join(" • ");
+        if (statsText) {
+            line += "\n " + theme.fg("dim", statsText);
+        }
+        const expandHint = expandCollapseHint("to expand");
+        const collapseHint = expandCollapseHint("to collapse");
+        if (expanded) {
+            if (result)
+                line += "\n " + theme.fg("muted", result);
+            line += "\n " + theme.fg("dim", `  (${collapseHint})`);
+        }
+        else {
+            const preview = result.slice(0, 120);
+            if (preview) {
+                line +=
+                    "\n " +
+                        theme.fg("dim", `  ⎿  ${preview}`) +
+                        (result.length > 120 ? theme.fg("dim", "…") : "");
+            }
+            if (result.length > 120) {
+                line += "\n " + theme.fg("dim", `  (${expandHint})`);
+            }
+        }
+        if (!line.trim())
+            return undefined;
+        const subtleBg = (text) => `\x1b[48;2;30;28;44m${text}\x1b[0m`;
+        return new Text(line, 0, 1, subtleBg);
+    };
+}
+function expandCollapseHint(action) {
+    return keyText("app.tools.expand").trim()
+        ? keyHint("app.tools.expand", action)
+        : rawKeyHint("Ctrl+O", action);
+}
+function formatMs(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    if (minutes > 0) {
+        return `${minutes}m ${seconds}s`;
+    }
+    return `${seconds}s`;
+}

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+import type { ToolCallRecord } from "./helpers.js";
+export interface BackgroundTask {
+    dir: string;
+    agentType: string;
+    sessionName: string;
+    paneId?: string;
+    originalPane: string | null;
+    description: string;
+    startedAt: number;
+    toolUses: number;
+    turns: number;
+    conversationId?: string;
+    /** Most recent tool calls (capped), updated every COUNT_POLL_MS. */
+    recentCalls: ToolCallRecord[];
+    /** Consecutive completion-poll failures; reset to 0 on a successful poll. */
+    pollErrors?: number;
+}
+/** Serializable subset for active task registry persistence. */
+export interface RegistryEntry {
+    id: string;
+    agentType: string;
+    description: string;
+    sessionName: string;
+    startedAt: number;
+    paneId?: string;
+    piDir: string;
+    dir: string;
+    conversationId?: string;
+    sessionRef?: string;
+}
+/** Durable task→session mapping used for resume after task completion. */
+export interface TaskSessionHistoryEntry extends RegistryEntry {
+    status: "running" | "done" | "cancelled" | "aborted" | "failed" | "timeout";
+    completedAt?: number;
+    background: boolean;
+}
+/** Details attached to tool result for rendering. */
+export 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;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heyhuynhgiabuu/pi-task",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "Delegating task/subagent extension for Pi: foreground/background subagents, widgets, tmux observability, SDK fallback.",
   "type": "module",
   "main": "./dist/index.js",