@heyhuynhgiabuu/pi-task 0.1.6 → 0.2.0

package/dist/lifecycle/completion.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { BackgroundTask } from "../types.js";
+export declare function completeTask(pi: ExtensionAPI, id: string, task: BackgroundTask, content: string, phase: "done" | "timeout" | "failed", piDir: string): void;

package/dist/lifecycle/completion.js

@@ -0,0 +1,50 @@
+import { findJsonlSessionByName, readRegistry, upsertTaskSessionHistory, writeRegistry } from "../conversation.js";
+import { parseResultXml } from "../helpers.js";
+import { killAgentPane } from "../subagent/tmux.js";
+export function completeTask(pi, id, task, content, phase, piDir) {
+    // Kill the tmux pane if still alive.
+    if (task.paneId)
+        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,
+    });
+    pi.sendMessage({
+        customType: "task-complete",
+        content: `Background task ${id} (${task.agentType}) ${phase}.\n\nResult:\n${content}`,
+        display: true,
+        details: {
+            task_id: id,
+            agent_type: task.agentType,
+            description: task.description,
+            phase,
+            status: phase,
+            result: content,
+            summary: parsed.summary,
+            findings: parsed.findings,
+            confidence: parsed.confidence,
+            duration_ms: durationMs,
+            tool_uses: task.toolUses,
+            turn_count: task.turns,
+        },
+    }, {
+        triggerTurn: true,
+        deliverAs: "followUp",
+    });
+    const entries = readRegistry(piDir).filter((entry) => entry.id !== id);
+    writeRegistry(piDir, entries);
+}

package/dist/lifecycle/index.d.ts

@@ -0,0 +1,5 @@
+export { completeTask } from "./completion.js";
+export { startBackgroundPolling } from "./polling.js";
+export { restoreActiveBackgroundTasks } from "./restore.js";
+export { startToolStatsPolling } from "./toolStats.js";
+export { createTaskWidgetController } from "./widget.js";

package/dist/lifecycle/index.js

@@ -0,0 +1,5 @@
+export { completeTask } from "./completion.js";
+export { startBackgroundPolling } from "./polling.js";
+export { restoreActiveBackgroundTasks } from "./restore.js";
+export { startToolStatsPolling } from "./toolStats.js";
+export { createTaskWidgetController } from "./widget.js";

package/dist/lifecycle/polling.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Background polling logic for task completion.
+ * This module encapsulates the interval-based checking of background tasks.
+ */
+export interface PollingDeps {
+    backgroundTasks: Map<string, any>;
+    checkTaskCompletion: (opts: any) => Promise<any>;
+    killAgentPane: (paneId: string | undefined, originalPane: string | null) => void;
+    clearTaskWidgetIfIdle: () => void;
+    completeTask: (pi: any, id: string, task: any, content: string, phase: "done" | "timeout" | "failed", piDir: string) => void;
+    TASK_TIMEOUT_MS: number;
+    MAX_POLL_ERRORS: number;
+    piDir: string;
+    pi: any;
+}
+export declare function startBackgroundPolling(deps: PollingDeps, intervalMs: number): NodeJS.Timeout;

package/dist/lifecycle/polling.js

@@ -0,0 +1,61 @@
+import { join } from "node:path";
+let checkInFlight = false;
+export function startBackgroundPolling(deps, intervalMs) {
+    const { backgroundTasks, checkTaskCompletion, killAgentPane, clearTaskWidgetIfIdle, completeTask, TASK_TIMEOUT_MS, MAX_POLL_ERRORS, piDir, pi, } = deps;
+    return setInterval(async () => {
+        if (checkInFlight)
+            return;
+        if (backgroundTasks.size === 0) {
+            clearTaskWidgetIfIdle();
+            return;
+        }
+        checkInFlight = true;
+        try {
+            const now = Date.now();
+            const ids = Array.from(backgroundTasks.keys());
+            for (const id of ids) {
+                const task = backgroundTasks.get(id);
+                if (!task)
+                    continue;
+                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;
+                }
+                let snapshot;
+                try {
+                    snapshot = await checkTaskCompletion({
+                        sessionDir: join(task.dir, "sessions", id),
+                        sessionName: task.sessionName,
+                        paneId: task.paneId,
+                        sinceMs: task.startedAt,
+                    });
+                }
+                catch (err) {
+                    task.pollErrors = (task.pollErrors ?? 0) + 1;
+                    if (task.pollErrors >= MAX_POLL_ERRORS) {
+                        killAgentPane(task.paneId, task.originalPane);
+                        backgroundTasks.delete(id);
+                        clearTaskWidgetIfIdle();
+                        const message = err instanceof Error ? err.message : String(err);
+                        completeTask(pi, id, task, `Task ${id} polling failed ${task.pollErrors}x; last error: ${message}`, "failed", piDir);
+                    }
+                    continue;
+                }
+                task.pollErrors = 0;
+                if (snapshot.status === "running") {
+                    continue;
+                }
+                const phase = snapshot.status === "completed" ? "done" : "failed";
+                backgroundTasks.delete(id);
+                clearTaskWidgetIfIdle();
+                completeTask(pi, id, task, snapshot.content, phase, piDir);
+            }
+        }
+        finally {
+            checkInFlight = false;
+        }
+    }, intervalMs);
+}

package/dist/lifecycle/restore.d.ts

@@ -0,0 +1,2 @@
+import type { BackgroundTask } from "../types.js";
+export declare function restoreActiveBackgroundTasks(piDir: string, backgroundTasks: Map<string, BackgroundTask>): void;

package/dist/lifecycle/restore.js

@@ -0,0 +1,34 @@
+import { existsSync } from "node:fs";
+import { readRegistry, writeRegistry } from "../conversation.js";
+import { paneExists } from "../subagent/tmux.js";
+export function restoreActiveBackgroundTasks(piDir, backgroundTasks) {
+    const registry = readRegistry(piDir);
+    const staleIds = [];
+    for (const entry of registry) {
+        if (!existsSync(entry.dir)) {
+            staleIds.push(entry.id);
+            continue;
+        }
+        const paneAlive = entry.paneId ? paneExists(entry.paneId) : false;
+        if (!paneAlive) {
+            staleIds.push(entry.id);
+            continue;
+        }
+        backgroundTasks.set(entry.id, {
+            dir: entry.dir,
+            agentType: entry.agentType,
+            sessionName: entry.sessionName,
+            paneId: entry.paneId,
+            originalPane: null,
+            description: entry.description,
+            startedAt: entry.startedAt,
+            toolUses: 0,
+            turns: 0,
+            conversationId: entry.conversationId,
+            recentCalls: [],
+        });
+    }
+    if (staleIds.length) {
+        writeRegistry(piDir, registry.filter((entry) => !staleIds.includes(entry.id)));
+    }
+}

package/dist/lifecycle/toolStats.d.ts

@@ -0,0 +1,2 @@
+import type { BackgroundTask } from "../types.js";
+export declare function startToolStatsPolling(foregroundTasks: Map<string, BackgroundTask>, backgroundTasks: Map<string, BackgroundTask>, intervalMs: number): NodeJS.Timeout;

package/dist/lifecycle/toolStats.js

@@ -0,0 +1,17 @@
+import { join } from "node:path";
+import { readRecentToolCalls } from "../helpers.js";
+export function startToolStatsPolling(foregroundTasks, backgroundTasks, intervalMs) {
+    return setInterval(() => {
+        const trackedTasks = [
+            ...foregroundTasks.entries(),
+            ...backgroundTasks.entries(),
+        ];
+        for (const [id, task] of trackedTasks) {
+            const sessionDir = join(task.dir, "sessions", id);
+            const { toolUses, turns, recent } = readRecentToolCalls(sessionDir, 12, task.sessionName);
+            task.toolUses = toolUses;
+            task.turns = turns;
+            task.recentCalls = recent;
+        }
+    }, intervalMs);
+}

package/dist/lifecycle/widget.d.ts

@@ -0,0 +1,8 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { BackgroundTask } from "../types.js";
+export interface TaskWidgetController {
+    ensureTaskWidget(targetCtx: ExtensionContext): void;
+    clearTaskWidgetIfIdle(): void;
+    dispose(): void;
+}
+export declare function createTaskWidgetController(foregroundTasks: Map<string, BackgroundTask>, backgroundTasks: Map<string, BackgroundTask>): TaskWidgetController;

package/dist/lifecycle/widget.js

@@ -0,0 +1,75 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { formatMs } from "../helpers.js";
+import { TASK_WIDGET_RENDER_MS, renderTaskWidget, } from "../task-widget.js";
+export function createTaskWidgetController(foregroundTasks, backgroundTasks) {
+    let widgetCtx = null;
+    let widgetTimer = null;
+    let widgetTheme = null;
+    function stopWidget() {
+        if (widgetTimer) {
+            clearInterval(widgetTimer);
+            widgetTimer = null;
+        }
+    }
+    function renderWidget(width) {
+        try {
+            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);
+            const active = [
+                ...Array.from(foregroundTasks.entries()),
+                ...Array.from(backgroundTasks.entries()),
+            ];
+            if (active.length === 0)
+                return [];
+            const [, task] = active[0];
+            return [
+                truncateToWidth(`${task.agentType}  • ${formatMs(Date.now() - task.startedAt)}  (render error: ${msg})`, Math.min(width, 120)),
+            ];
+        }
+    }
+    function ensureTaskWidget(targetCtx) {
+        if (widgetCtx || targetCtx.mode !== "tui")
+            return;
+        widgetCtx = targetCtx;
+        targetCtx.ui.setWidget("task", (tui, theme) => {
+            widgetTheme = theme ?? null;
+            widgetTimer = setInterval(() => tui.requestRender(), TASK_WIDGET_RENDER_MS);
+            widgetTimer.unref?.();
+            return {
+                render: (width) => renderWidget(width),
+                invalidate: () => { },
+                dispose: () => {
+                    widgetTheme = null;
+                    stopWidget();
+                },
+            };
+        });
+    }
+    function clearTaskWidgetIfIdle() {
+        if (foregroundTasks.size > 0 || backgroundTasks.size > 0)
+            return;
+        if (widgetCtx) {
+            widgetCtx.ui.setWidget("task", undefined);
+            widgetCtx = null;
+        }
+        stopWidget();
+    }
+    function dispose() {
+        if (widgetCtx) {
+            widgetCtx.ui.setWidget("task", undefined);
+            widgetCtx = null;
+        }
+        widgetTheme = null;
+        stopWidget();
+    }
+    return { ensureTaskWidget, clearTaskWidgetIfIdle, dispose };
+}

package/dist/session-text.d.ts

@@ -1,6 +1,15 @@
 /**
  * Read assistant text from pi JSONL session directories (task / harness).
  */
+/**
+ * Whether the subagent has finished producing responses.
+ *
+ * The reliable completion signal is the last assistant message's stopReason.
+ * - "toolUse": the agent called tools and should continue, so it is not done.
+ * - "stop" / "endTurn" / "length" / "error" / "aborted": terminal.
+ * - no assistant messages or no stopReason yet: not done.
+ */
+export declare function hasAgentFinished(sessionDir: string, sessionName?: string, sinceMs?: number): boolean;
 /**
  * Last non-empty assistant message from matching .jsonl files in sessionDir.
  */

package/dist/session-text.js

@@ -33,6 +33,56 @@ function matchesSessionName(content, sessionName) {
     }
     return false;
 }
+/**
+ * Whether the subagent has finished producing responses.
+ *
+ * The reliable completion signal is the last assistant message's stopReason.
+ * - "toolUse": the agent called tools and should continue, so it is not done.
+ * - "stop" / "endTurn" / "length" / "error" / "aborted": terminal.
+ * - no assistant messages or no stopReason yet: not done.
+ */
+export function hasAgentFinished(sessionDir, sessionName, sinceMs) {
+    if (!existsSync(sessionDir))
+        return false;
+    const files = readdirSync(sessionDir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .sort();
+    let lastStopReason;
+    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)
+                continue;
+            try {
+                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;
+                if (typeof msg.stopReason === "string") {
+                    lastStopReason = msg.stopReason;
+                }
+            }
+            catch {
+                /* skip malformed JSONL rows */
+            }
+        }
+    }
+    if (!lastStopReason)
+        return false;
+    if (lastStopReason === "toolUse")
+        return false;
+    return ["stop", "endTurn", "length", "error", "aborted"].includes(lastStopReason);
+}
 /**
  * Last non-empty assistant message from matching .jsonl files in sessionDir.
  */

package/dist/subagent/runSdk.js

@@ -1,42 +1,66 @@
-function resolveModel(ctx, requested) {
+async function resolveModel(ctx, requested) {
     const registry = ctx.modelRegistry;
-    const available = registry?.getAll?.() ?? registry?.getAvailable?.() ?? [];
     if (requested) {
         const [provider, ...rest] = requested.split("/");
         const modelId = rest.join("/");
-        const byProvider = available.find((model) => {
-            return model?.provider?.id === provider && model?.id === modelId;
-        });
-        if (byProvider)
-            return byProvider;
-        const byId = available.find((model) => model?.id === requested || model?.name === requested);
+        const exact = modelId
+            ? registry?.find?.(provider, modelId)
+            : registry?.find?.(requested);
+        if (exact)
+            return exact;
+    }
+    const all = registry?.getAll?.() ?? [];
+    const available = all.length > 0 ? all : ((await registry?.getAvailable?.()) ?? []);
+    if (requested) {
+        const byId = available.find((model) => model?.id === requested ||
+            `${model?.provider?.id ?? model?.provider}/${model?.id}` === requested ||
+            model?.name === requested);
         if (byId)
             return byId;
     }
     return available[0];
 }
 export async function runSdkSubagent(options) {
-    const model = resolveModel(options.ctx, options.model ?? options.agent.model);
+    const model = await resolveModel(options.ctx, options.model ?? options.agent.model);
     if (!model) {
         throw new Error("No model available for SDK subagent execution");
     }
-    const { createAgentSession, DefaultResourceLoader } = await import("@earendil-works/pi-coding-agent");
-    const resourceLoader = new DefaultResourceLoader({
-        cwd: options.cwd,
-        systemPromptOverride: options.systemPrompt,
-    });
-    const { session } = await createAgentSession({
-        cwd: options.cwd,
-        model,
-        thinkingLevel: options.thinkingLevel,
-        tools: options.tools,
-        excludeTools: options.excludeTools,
-        resourceLoader,
-    });
-    await session.prompt(options.prompt);
-    const sessionPath = session.sessionFile;
-    const output = getLastAssistantText(session.messages);
-    return { output: output.trim(), sessionPath };
+    const { createAgentSession, DefaultResourceLoader, getAgentDir } = await import("@earendil-works/pi-coding-agent");
+    const previousDisabled = process.env.PI_TASK_TOOL_DISABLED;
+    process.env.PI_TASK_TOOL_DISABLED = "1";
+    let session;
+    try {
+        const agentDir = getAgentDir();
+        const resourceLoader = new DefaultResourceLoader({
+            cwd: options.cwd,
+            agentDir,
+            systemPromptOverride: () => options.systemPrompt,
+            noExtensions: true,
+        });
+        await resourceLoader.reload();
+        ({ session } = await createAgentSession({
+            cwd: options.cwd,
+            agentDir,
+            model,
+            thinkingLevel: options.thinkingLevel,
+            tools: options.tools,
+            excludeTools: options.excludeTools,
+            resourceLoader,
+        }));
+        await session.prompt(options.prompt);
+        const sessionPath = session.sessionFile;
+        const output = getLastAssistantText(session.messages);
+        return { output: output.trim(), sessionPath };
+    }
+    finally {
+        session?.dispose?.();
+        if (previousDisabled === undefined) {
+            delete process.env.PI_TASK_TOOL_DISABLED;
+        }
+        else {
+            process.env.PI_TASK_TOOL_DISABLED = previousDisabled;
+        }
+    }
 }
 function getLastAssistantText(messages) {
     for (let index = messages.length - 1; index >= 0; index -= 1) {

package/dist/subagent/tmux.d.ts

@@ -1,18 +1,21 @@
-/**
- * Tmux helpers for subagent panes (shared by task extension).
- */
+export type TmuxSplitResult = {
+    paneId: string;
+    originalPane: string | null;
+};
 export declare function tmuxCmd(args: string[]): string;
 export declare function hasTmux(): boolean;
-export declare function paneExists(paneId: string): boolean;
 export declare function getCurrentPaneId(): string | null;
 export declare function getCurrentPaneSize(targetPane?: string | null): {
     width: number;
     height: number;
 } | null;
-export declare function splitWindowPane(cwd: string, command: string): {
-    paneId: string;
-    originalPane: string | null;
-};
-export declare function killAgentPane(paneId: string, originalPane: string | null): void;
+export declare function splitWindowPane(cwd: string, command: string): TmuxSplitResult;
+export declare function setPaneRemainOnExit(paneId: string, enabled: boolean): void;
+export declare function setPaneSelfDestruct(paneId: string, enabled: boolean, delaySeconds?: number): void;
+export declare function paneExists(paneId: string): boolean;
+export declare function paneDead(paneId: string): boolean;
+export declare function capturePaneTail(paneId: string, lines?: number): string;
+export declare function killAgentPane(paneId: string, originalPane?: string | null): void;
 /** Inject text into a running subagent pane (steer / follow-up). */
 export declare function tmuxSteerPane(paneId: string, message: string): void;
+export declare function wrapWithPaneExitWatcher(sessionFilePath: string, command: string): string;