@heyhuynhgiabuu/pi-task 0.1.4 → 0.1.6

package/dist/session-text.d.ts

@@ -2,6 +2,6 @@
  * Read assistant text from pi JSONL session directories (task / harness).
  */
 /**
- * Last non-empty assistant message across all .jsonl files in sessionDir.
+ * Last non-empty assistant message from matching .jsonl files in sessionDir.
  */
-export declare function getLastAssistantTextFromSessionDir(sessionDir: string): string;
+export declare function getLastAssistantTextFromSessionDir(sessionDir: string, sessionName?: string, sinceMs?: number): string;

package/dist/session-text.js

@@ -14,10 +14,29 @@ function extractText(content) {
         .join("\n")
         .trim();
 }
+function matchesSessionName(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 JSONL rows */
+        }
+    }
+    return false;
+}
 /**
- * Last non-empty assistant message across all .jsonl files in sessionDir.
+ * Last non-empty assistant message from matching .jsonl files in sessionDir.
  */
-export function getLastAssistantTextFromSessionDir(sessionDir) {
+export function getLastAssistantTextFromSessionDir(sessionDir, sessionName, sinceMs) {
     if (!existsSync(sessionDir))
         return "";
     const files = readdirSync(sessionDir)
@@ -26,6 +45,8 @@ export function getLastAssistantTextFromSessionDir(sessionDir) {
     let last = "";
     for (const file of files) {
         const content = readFileSync(join(sessionDir, file), "utf-8");
+        if (!matchesSessionName(content, sessionName))
+            continue;
         for (const rawLine of content.split("\n")) {
             const line = rawLine.trim();
             if (!line)
@@ -34,6 +55,11 @@ export function getLastAssistantTextFromSessionDir(sessionDir) {
                 const entry = JSON.parse(line);
                 if (entry.type !== "message")
                     continue;
+                if (sinceMs !== undefined && entry.timestamp) {
+                    const timestampMs = Date.parse(entry.timestamp);
+                    if (Number.isFinite(timestampMs) && timestampMs < sinceMs)
+                        continue;
+                }
                 const msg = entry.message;
                 if (!msg || msg.role !== "assistant")
                     continue;

package/dist/subagent/buildArgv.d.ts

@@ -8,6 +8,7 @@ export interface BuildPiArgvOptions {
     sessionDir: string;
     promptContent: string;
     resume?: boolean;
+    resumeSessionRef?: string;
     parentToolNames?: string[];
 }
 export declare function buildPiArgv(opts: BuildPiArgvOptions): string[];

package/dist/subagent/buildArgv.js

@@ -18,7 +18,7 @@ export function buildPiArgv(opts) {
     args.push("--name", sessionName);
     args.push("--session-dir", sessionDir);
     if (resume)
-        args.push("--session", sessionName);
+        args.push("--session", opts.resumeSessionRef ?? sessionName);
     args.push("--append-system-prompt", agent.body);
     args.push(promptContent);
     return args;

package/dist/subagent/waitCompletion.d.ts

@@ -12,6 +12,7 @@ export interface TaskCompletionOptions {
     signal?: AbortSignal;
     timeoutMs?: number;
     pollMs?: number;
+    sinceMs?: number;
 }
 export declare function checkTaskCompletion(options: TaskCompletionOptions): Promise<TaskCompletionSnapshot>;
 export declare function waitForTaskCompletion(options: TaskCompletionOptions): Promise<TaskCompletionSnapshot>;

package/dist/subagent/waitCompletion.js

@@ -1,42 +1,49 @@
 import { readFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
-import { join } from "node:path";
 import { getLastAssistantTextFromSessionDir } 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;
 }
-function readSessionText(sessionDir, sessionName) {
-    const sessionPath = join(sessionDir, "sessions", sessionName);
-    const text = getLastAssistantTextFromSessionDir(sessionPath).trim();
+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.
+    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 (options.paneId && !paneExists(options.paneId)) {
+        await sleep(500);
+    }
     const result = await readResultFile(options.resultPath);
     if (result) {
         return { status: "completed", content: result, source: "result-file" };
     }
-    if (options.paneId && paneExists(options.paneId)) {
-        return { status: "running", content: "", source: "pane" };
-    }
-    const sessionText = readSessionText(options.sessionDir, options.sessionName);
-    if (sessionText) {
-        return {
-            status: "completed",
-            content: sessionText,
-            source: "session-jsonl",
-        };
+    // 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).
+    const sessionResult = readSessionText(options.sessionDir, options.sessionName, options.sinceMs);
+    if (sessionResult) {
+        return { status: "completed", content: sessionResult, source: "session-jsonl" };
     }
-    if (options.paneId) {
-        return {
-            status: "failed",
-            content: "Task pane exited before producing a result or assistant response.",
-            source: "pane",
-        };
+    // 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." };
     }
+    // Pane still exists and no session text yet — keep polling.
     return { status: "running", content: "", source: "pane" };
 }
 export async function waitForTaskCompletion(options) {

package/dist/task-widget.d.ts

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

package/dist/task-widget.js

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

package/package.json

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