@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/tui/result-facts.js

@@ -0,0 +1,64 @@
+import { getSingleResultOutput } from "../shared/utils.js";
+import { workflowGraphHasStatus } from "./workflow-labels.js";
+import { hasEmptyTextOutputWithoutOutputTarget } from "./display.js";
+export function workflowFacts(d, isError) {
+    return {
+        running: !isError &&
+            (d.progress?.some((p) => p.status === "running") === true ||
+                d.results.some((r) => r.progress?.status === "running") ||
+                workflowGraphHasStatus(d, ["running"])),
+        failed: isError ||
+            workflowGraphHasStatus(d, ["failed", "timed-out"]) ||
+            d.results.some((r) => r.exitCode !== 0 && r.progress?.status !== "running"),
+        blocked: d.results.some((r) => r.acceptance?.status === "blocked" && r.exitCode === 0) ||
+            workflowGraphHasStatus(d, ["blocked"]),
+        paused: d.results.some((r) => (r.interrupted === true || r.detached === true) && r.progress?.status !== "running") || workflowGraphHasStatus(d, ["paused", "detached"]),
+    };
+}
+export function totalProgress(d) {
+    if (d.progressSummary) {
+        return d.progressSummary;
+    }
+    const progress = d.results.flatMap((r) => r.progress ?? r.progressSummary ?? []);
+    if (progress.length === 0) {
+        return;
+    }
+    return {
+        toolCount: progress.reduce((sum, p) => sum + p.toolCount, 0),
+        tokens: progress.reduce((sum, p) => sum + p.tokens, 0),
+        durationMs: d.mode === "chain"
+            ? progress.reduce((sum, p) => sum + p.durationMs, 0)
+            : Math.max(...progress.map((p) => p.durationMs)),
+    };
+}
+export function resultProgress(d, index) {
+    const r = d.results.at(index);
+    if (!r) {
+        return;
+    }
+    return (r.progress ??
+        d.progress?.find((p) => p.index === index) ??
+        d.progress?.find((p) => p.agent === r.agent && p.status === "running") ??
+        r.progressSummary);
+}
+export function expandedResultStatus(r, running, emptyWarning = false) {
+    if (running) {
+        return "running";
+    }
+    if (r.detached === true) {
+        return "detached";
+    }
+    if (r.interrupted === true) {
+        return "paused";
+    }
+    if (r.exitCode !== 0) {
+        return "failed";
+    }
+    if (r.acceptance?.status === "blocked") {
+        return "needs your action";
+    }
+    if (emptyWarning && hasEmptyTextOutputWithoutOutputTarget(r.task, getSingleResultOutput(r))) {
+        return "warning";
+    }
+    return "done";
+}

package/dist/tui/task-observation.js

@@ -0,0 +1,59 @@
+import { agentTaskLabel } from "./view-model.js";
+export function selectedChild(child, prior, updatedAt) {
+    return {
+        ...child,
+        task: prior.child.task,
+        launch: prior.child.launch,
+        result: child.result && prior.run.updatedAt === updatedAt ? prior.child.result : child.result,
+        activity: { ...prior.child.activity, ...child.activity },
+    };
+}
+export function observedTask(prior, state, updatedAt) {
+    return prior !== undefined && prior.child.state === state && prior.metadataAt === updatedAt;
+}
+export function observedLabel(child, prior, sameAttempt) {
+    if (child.identityUnavailable === true) {
+        return "Saved assignment unavailable";
+    }
+    return sameAttempt ? agentTaskLabel(child) : (prior?.label ?? agentTaskLabel(child));
+}
+export function cachedHistory(prior) {
+    if (!prior) {
+        return { history: [], historyIds: [], historyLoading: false, replied: false };
+    }
+    return {
+        history: prior.history,
+        historyIds: prior.historyIds,
+        page: prior.page,
+        historySource: prior.historySource,
+        historyLoading: prior.historyLoading,
+        finalId: prior.finalId,
+        replied: prior.replied,
+    };
+}
+export function observedConfiguration(child, prior, canonical) {
+    if (child.nativeConfiguration) {
+        return child.nativeConfiguration;
+    }
+    if (canonical && prior && child.sessionFile === prior.child.sessionFile) {
+        return prior.page?.configuration;
+    }
+    return;
+}
+export function activityUnread(child, updatedAt, visit) {
+    return (visit !== undefined &&
+        (child.activity?.lastActivityAt ?? updatedAt) > (visit.seenActivityAt ?? 0));
+}
+export function observationFlags(prior, observed, unread) {
+    return {
+        metadataAt: observed ? prior?.metadataAt : undefined,
+        unread: observed ? (prior?.unread ?? false) : unread,
+    };
+}
+export function observedQuestion(child, questions) {
+    if (child.identityUnavailable === true) {
+        return;
+    }
+    return questions.findLast((question) => question.index === child.index &&
+        ["awaiting_input", "answer_pending"].includes(question.state));
+}

package/dist/tui/task-store.js

@@ -0,0 +1,366 @@
+import { hasText, errorText } from "./text-values.js";
+import { listOwnedRunQuestions } from "../runs/shared/supervisor-questions.js";
+import { ownedRunView } from "../runs/shared/run-records.js";
+import { restoredView } from "./view-persistence.js";
+import { UNAVAILABLE_ASSIGNMENT, PENDING_MESSAGE_NOTICE, agentModel, unavailableModel, } from "./view-model.js";
+import { selectedChild, observedTask, observedLabel, cachedHistory, observedConfiguration, activityUnread, observationFlags, observedQuestion, } from "./task-observation.js";
+function identityKey(run, child, stable) {
+    let identity = child.index;
+    if (child.workflowNodeId !== undefined) {
+        identity = child.workflowNodeId;
+    }
+    else if (run.mode === "chain") {
+        identity = chainIdentity(child, stable);
+    }
+    return `${run.runId}:${identity}`;
+}
+function chainIdentity(child, stable) {
+    if (!stable) {
+        return child.sessionFile ?? child.index;
+    }
+    return hasText(child.sessionFile) && child.identityUnavailable !== true
+        ? `session:${child.sessionFile}`
+        : child.index;
+}
+function authorityUnavailable(task, reason) {
+    return {
+        ...task,
+        child: { ...task.child, state: "unknown", identityUnavailable: true },
+        question: undefined,
+        unavailable: reason,
+    };
+}
+/** Owns task-cache writes; composer and controls share visits through visit(). */
+export class AgentTaskStore {
+    currentTasks = [];
+    currentDockTasks = [];
+    get tasks() {
+        return this.currentTasks;
+    }
+    get dockTasks() {
+        return this.currentDockTasks;
+    }
+    taskKeys = new Map();
+    visits = new Map();
+    selectedKey;
+    pinned;
+    state;
+    syncDraft;
+    constructor(state, syncDraft) {
+        this.state = state;
+        this.syncDraft = syncDraft;
+    }
+    visit(key) {
+        let visit = this.visits.get(key);
+        if (!visit) {
+            visit = { draft: "", outbox: [] };
+            this.visits.set(key, visit);
+        }
+        return visit;
+    }
+    task(key) {
+        return this.tasks.find((task) => task.key === key);
+    }
+    reset() {
+        this.currentTasks = [];
+        this.currentDockTasks = [];
+        this.taskKeys.clear();
+        this.visits.clear();
+        this.selectedKey = undefined;
+        this.pinned = undefined;
+    }
+    restore(value, ownerSessionId) {
+        const saved = restoredView(value, ownerSessionId);
+        if (saved) {
+            this.visits = saved.visits;
+            this.pinned = saved.pinned;
+        }
+    }
+    dockPage(rows) {
+        this.currentDockTasks = rows.flatMap((row) => this.fromView(row));
+    }
+    retainSelected() {
+        this.currentTasks = this.currentTasks.filter((task) => task.key === this.selectedKey || task.key === this.pinned);
+    }
+    setHistoryLoading(key, loading) {
+        const task = this.currentTasks.find((candidate) => candidate.key === key);
+        if (task) {
+            task.historyLoading = loading;
+        }
+    }
+    applyHistoryPage(key, history, page, sourceSeen) {
+        const task = this.currentTasks.find((candidate) => candidate.key === key);
+        if (!task) {
+            return;
+        }
+        task.history = history.items;
+        task.historyIds = history.entryIds;
+        task.finalId = history.finalId;
+        task.page = page;
+        task.unavailable =
+            !sourceSeen &&
+                task.child.state === "live" &&
+                ["missing", "pending", "indexing", "unlinked"].includes(page.sourceState)
+                ? undefined
+                : history.unavailable;
+        this.applyTaskMetadata(task, page);
+    }
+    taskKey(run, child) {
+        const path = new Set();
+        let cursor = { run, child }, key;
+        for (;;) {
+            const cache = identityKey(cursor.run, cursor.child, false), cached = this.taskKeys.get(cache);
+            if (cached !== undefined) {
+                key = cached;
+                break;
+            }
+            if (path.has(cache)) {
+                throw new Error("Cyclic saved continuation ancestry");
+            }
+            path.add(cache);
+            const predecessor = hasText(cursor.run.predecessorRunId)
+                ? this.state.ownedRuns?.get(cursor.run.predecessorRunId)
+                : undefined;
+            if (!predecessor) {
+                key = identityKey(cursor.run, cursor.child, true);
+                break;
+            }
+            const index = cursor.run.predecessorIndex ?? 0;
+            cursor = {
+                run: predecessor,
+                child: predecessor.children.find((candidate) => candidate.index === index) ?? { index },
+            };
+        }
+        for (const cache of path) {
+            this.taskKeys.set(cache, key);
+        }
+        return key;
+    }
+    fromView(view, questions = view.questions ?? [], canonical = false) {
+        return view.children
+            .filter((child) => view.matchedChildIndexes === undefined || view.matchedChildIndexes.includes(child.index))
+            .map((child) => this.taskFromChild(view, child, questions, canonical));
+    }
+    taskFromChild(view, child, questions, canonical) {
+        const key = this.taskKey(view, child), prior = this.task(key) ?? this.dockTasks.find((task) => task.key === key), visit = this.visits.get(key);
+        const sameAttempt = prior?.run.runId === view.runId, retained = sameAttempt ? prior : undefined;
+        const selected = !canonical && this.selectedKey === key && retained !== undefined;
+        const display = selected ? selectedChild(child, retained, view.updatedAt) : child;
+        const observed = observedTask(retained, child.state, view.updatedAt);
+        return {
+            key,
+            label: observedLabel(child, prior, sameAttempt),
+            run: view,
+            child: display,
+            model: agentModel(display, observedConfiguration(child, retained, canonical)),
+            ...cachedHistory(retained),
+            ...observationFlags(retained, observed, activityUnread(child, view.updatedAt, visit)),
+            unavailable: child.missingSession === true && child.state !== "live"
+                ? "Saved conversation unavailable."
+                : view.diagnosis,
+            question: observedQuestion(child, questions),
+        };
+    }
+    unavailableTask(key, run) {
+        return {
+            key,
+            label: "Saved assignment unavailable",
+            run,
+            child: {
+                agent: "unknown",
+                index: -1,
+                state: "unknown",
+                configuration: "legacy-partial",
+                identityUnavailable: true,
+            },
+            model: unavailableModel,
+            history: [],
+            historyIds: [],
+            unavailable: UNAVAILABLE_ASSIGNMENT,
+            unread: false,
+            replied: false,
+        };
+    }
+    latestTasks(rows) {
+        const tasks = new Map();
+        for (const row of rows) {
+            for (const task of this.fromView(row)) {
+                const prior = tasks.get(task.key);
+                if (!prior || prior.run.startedAt <= task.run.startedAt) {
+                    tasks.set(task.key, task);
+                }
+            }
+        }
+        return tasks;
+    }
+    retainedTasks(rows) {
+        const tasks = this.latestTasks(rows);
+        for (const [key, visit] of this.visits) {
+            const empty = !hasText(visit.draft) && !visit.quote && visit.outbox.length === 0 && this.pinned !== key;
+            if (tasks.has(key) || empty) {
+                continue;
+            }
+            const row = rows.find((run) => run.runId === key.split(":")[0]);
+            if (row) {
+                tasks.set(key, this.unavailableTask(key, row));
+            }
+        }
+        return tasks;
+    }
+    browsePage(rows) {
+        const tasks = this.retainedTasks(rows);
+        for (const key of [this.selectedKey, this.pinned]) {
+            if (!hasText(key)) {
+                continue;
+            }
+            const retained = this.task(key);
+            if (retained && !tasks.has(key)) {
+                tasks.set(key, { ...retained });
+            }
+        }
+        this.currentTasks = [...tasks.values()];
+    }
+    historyInput(task) {
+        const visit = this.visits.get(task.key), ids = visit?.outbox.slice(0, 999).map((sent) => sent.id) ?? [];
+        if (hasText(visit?.lastSentId)) {
+            ids.push(visit.lastSentId);
+        }
+        const common = {
+            runId: task.run.runId,
+            index: task.child.index,
+            messageIds: [...new Set(ids)],
+            readThrough: visit?.readThrough,
+        };
+        if (task.child.state === "live") {
+            return common;
+        }
+        const terminal = task.child.result?.terminalEntryId;
+        return {
+            ...common,
+            leaf: task.child.result?.terminalLeafId,
+            terminalEntryId: terminal,
+            endedAt: hasText(terminal) ? undefined : task.run.updatedAt,
+        };
+    }
+    applyMetadata(key, page) {
+        for (const task of [...this.currentTasks, ...this.currentDockTasks]) {
+            if (task.key === key) {
+                this.applyTaskMetadata(task, page);
+            }
+        }
+    }
+    applyTaskMetadata(task, page) {
+        const visit = this.visits.get(task.key), delivered = new Map(page.deliveredMessages);
+        task.historySource = JSON.stringify([page.sourceId, page.generation, page.sessionId]);
+        if (page.freshness.state !== "catching-up") {
+            task.metadataAt = task.run.updatedAt;
+        }
+        task.model = agentModel(task.child, page.configuration);
+        task.unread = page.unreadAfter === true || activityUnread(task.child, 0, visit);
+        task.replied = hasText(visit?.lastSentId) && delivered.get(visit.lastSentId) === true;
+        this.applyDelivery(task.key, delivered);
+    }
+    applyDelivery(key, delivered) {
+        const visit = this.visits.get(key);
+        if (!visit) {
+            return;
+        }
+        if (hasText(visit.lastSentId) &&
+            delivered.has(visit.lastSentId) &&
+            visit.notice === PENDING_MESSAGE_NOTICE) {
+            visit.notice = undefined;
+        }
+        for (const sent of visit.outbox) {
+            if (!delivered.has(sent.id) || visit.draft !== sent.draft) {
+                continue;
+            }
+            visit.draft = "";
+            visit.quote = undefined;
+            if (this.selectedKey === key) {
+                this.syncDraft();
+            }
+        }
+        visit.outbox = visit.outbox.filter((sent) => !delivered.has(sent.id));
+    }
+    metadataUnavailable(key, reason) {
+        for (const task of [...this.currentTasks, ...this.currentDockTasks]) {
+            if (task.key === key) {
+                task.unavailable ??= reason;
+            }
+        }
+    }
+    authorityTask(key, root, ownerSessionId) {
+        let selected, rootView;
+        for (const run of this.state.ownedRuns?.values() ?? []) {
+            if (run.rootRunId !== root || run.ownerSessionId !== ownerSessionId) {
+                continue;
+            }
+            const questions = listOwnedRunQuestions(run.ownerSessionId, run.runId);
+            const view = ownedRunView(run, this.state, {
+                pendingInput: questions.some((question) => ["awaiting_input", "answer_pending"].includes(question.state)),
+                includeContinuations: false,
+                readConfiguration: false,
+            });
+            if (view.runId === key.split(":")[0]) {
+                rootView = view;
+            }
+            const candidate = this.fromView(view, questions, true).find((task) => task.key === key);
+            if (candidate && (!selected || selected.run.startedAt <= candidate.run.startedAt)) {
+                selected = candidate;
+            }
+        }
+        return { selected, rootView };
+    }
+    missingAuthority(key, current, rootView) {
+        if (current) {
+            return authorityUnavailable(current, UNAVAILABLE_ASSIGNMENT);
+        }
+        return rootView && this.visits.has(key) ? this.unavailableTask(key, rootView) : undefined;
+    }
+    replaceTask(task) {
+        const position = this.currentTasks.findIndex((candidate) => candidate.key === task.key);
+        if (position < 0) {
+            this.currentTasks.push(task);
+        }
+        else {
+            this.currentTasks[position] = task;
+        }
+        this.currentDockTasks = this.currentDockTasks.map((candidate) => candidate.key === task.key ? task : candidate);
+    }
+    releaseSelected() {
+        for (const task of [...this.currentTasks, ...this.currentDockTasks]) {
+            if (task.key === this.selectedKey) {
+                task.history = [];
+                task.historyIds = [];
+                task.page = undefined;
+                task.finalId = undefined;
+                task.historyLoading = false;
+            }
+        }
+        this.selectedKey = undefined;
+    }
+    rootForKey(key, current) {
+        return current?.run.rootRunId ?? this.state.ownedRuns?.get(key.split(":")[0] ?? "")?.rootRunId;
+    }
+    /** Browse SQLite is not authority: recheck this lineage before sending or stopping. */
+    refreshSelected(key, ownerSessionId) {
+        const current = this.task(key), root = this.rootForKey(key, current);
+        if (!hasText(root)) {
+            return;
+        }
+        this.taskKeys.clear();
+        let selected;
+        try {
+            const authority = this.authorityTask(key, root, ownerSessionId);
+            selected = authority.selected ?? this.missingAuthority(key, current, authority.rootView);
+        }
+        catch (error) {
+            if (current) {
+                selected = authorityUnavailable(current, `Run authority unavailable: ${errorText(error)}`);
+            }
+        }
+        if (selected) {
+            this.replaceTask(selected);
+        }
+    }
+}

package/dist/tui/text-values.js

@@ -0,0 +1,16 @@
+import { inspect } from "node:util";
+export function hasText(value) {
+    return typeof value === "string" && value.length > 0;
+}
+export function nonemptyText(value) {
+    return hasText(value) ? value : undefined;
+}
+export function errorText(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    return inspect(error, { depth: 2, customInspect: false });
+}

package/dist/tui/view-connections.js

@@ -0,0 +1,47 @@
+/** Bind native UI ports directly to the owners of their operations and observations. */
+export function pickerPort(store, browser, layout) {
+    return {
+        ...layout,
+        get tasks() {
+            return store.tasks;
+        },
+        get listFilter() {
+            return browser.listFilter;
+        },
+        get listPending() {
+            return browser.listPending;
+        },
+        get listPage() {
+            return browser.listPage;
+        },
+        get listError() {
+            return browser.listError;
+        },
+        get listLoading() {
+            return browser.listLoading;
+        },
+        task: store.task.bind(store),
+        pageTasks: browser.pageTasks.bind(browser),
+        retry: browser.retry.bind(browser),
+        filterTasks: browser.filterTasks.bind(browser),
+    };
+}
+export function conversationPort(store, browser, controls, ui) {
+    return {
+        ...ui,
+        get pinned() {
+            return store.pinned;
+        },
+        task: store.task.bind(store),
+        visit: store.visit.bind(store),
+        historyPage: browser.historyPage.bind(browser),
+        savedResult: browser.savedResult.bind(browser),
+        applyHistoryPage: store.applyHistoryPage.bind(store),
+        setHistoryLoading: store.setHistoryLoading.bind(store),
+        send: controls.send.bind(controls),
+        stop: controls.stop.bind(controls),
+        changes: controls.changes.bind(controls),
+        isBusy: controls.isBusy.bind(controls),
+        retry: browser.retry.bind(browser),
+    };
+}

package/dist/tui/view-model.js

@@ -0,0 +1,94 @@
+import { nonemptyText, hasText } from "./text-values.js";
+import { rawKeyHint } from "@earendil-works/pi-coding-agent";
+import { getKeybindings, truncateToWidth } from "@earendil-works/pi-tui";
+import { readableText } from "./agent-history.js";
+export const UNAVAILABLE_ASSIGNMENT = "Assignment identity unavailable. Your draft is kept; no message or Stop was sent. Inspect the run and choose a verified assignment before sending it.";
+export const PENDING_MESSAGE_NOTICE = "This message is already waiting for the child. You can keep working or write a different message.";
+export const CONTINUE_HINT = "Continue with this message (Alt+C)";
+export const CONTINUE_NOTICES = {
+    finished: "This agent has finished. Your draft is kept. Choose ",
+    blocked: "This agent needs your action; acceptance is incomplete. Your draft is kept. Choose ",
+};
+export const short = (text, width = 48) => truncateToWidth(readableText(text).replace(/\s+/g, " ").trim(), width);
+export const resultText = (result) => result.content.map((part) => (part.type === "text" ? part.text : "")).join("\n");
+export function primaryKey(action) {
+    const key = getKeybindings().getKeys(action).at(0);
+    const labels = {
+        enter: "Enter",
+        escape: "Esc",
+        up: "↑",
+        down: "↓",
+    };
+    return labels[key ?? ""] ?? readableText(rawKeyHint(key ?? "", "")).trim();
+}
+export function agentTaskLabel(child) {
+    return readableText(nonemptyText(child.label) ??
+        nonemptyText(child.task?.split("\n").find((line) => line.trim().length > 0)) ??
+        `${child.agent} · assignment unavailable`)
+        .replace(/\s+/g, " ")
+        .trim();
+}
+export function activity(task) {
+    if (task.child.identityUnavailable === true) {
+        return "assignment unavailable";
+    }
+    if (task.question) {
+        return task.question.state === "answer_pending" ? "answer saved · waiting" : "needs an answer";
+    }
+    if (task.child.state === "blocked") {
+        return "needs your action · acceptance incomplete";
+    }
+    if (task.child.state !== "live") {
+        return task.child.state === "completed" ? "done" : task.child.state;
+    }
+    return liveActivity(task.child.activity);
+}
+function liveActivity(live) {
+    if (live?.status === "pending") {
+        return "waiting to start";
+    }
+    if (hasText(live?.currentTool)) {
+        return short(`${live.currentTool} ${nonemptyText(live.currentToolArgs) ?? nonemptyText(live.currentPath) ?? ""}`, 42);
+    }
+    return hasText(live?.streamingText) ? short(live.streamingText, 42) : "working";
+}
+function taskStatus(task) {
+    if (task.child.identityUnavailable === true) {
+        return "unavailable";
+    }
+    if (task.question) {
+        return task.question.state === "answer_pending" ? "answer pending" : "needs answer";
+    }
+    if (task.child.state === "blocked") {
+        return "needs action";
+    }
+    if (task.child.state === "live") {
+        return task.child.activity?.status === "pending" ? "queued" : "working";
+    }
+    return task.child.state === "completed" ? "done" : task.child.state;
+}
+export function taskSummary(task) {
+    let badge = "";
+    if (task.unread) {
+        badge = task.replied ? " · replied" : " · new";
+    }
+    return { status: taskStatus(task), badge };
+}
+export { agentModel, unavailableModel } from "./agent-model.js";
+export function runningIndicator(theme) {
+    // Six seconds, sampled by the existing 500 ms refresh; typing cannot speed up the pulse.
+    const phase = Math.floor(Date.now() / 500) % 12;
+    const ansi = theme.getFgAnsi("success");
+    // Parse the native SGR truecolor foreground sequence for the display-only pulse.
+    // oxlint-disable-next-line no-control-regex
+    const colorPattern = /^\x1b\[38;2;(\d+);(\d+);(\d+)m$/;
+    const rgb = theme.getColorMode() === "truecolor" ? colorPattern.exec(ansi) : null;
+    if (!rgb) {
+        return theme.fg("success", phase < 6 ? theme.bold("●") : "●");
+    }
+    const brightness = 0.9 + 0.1 * Math.cos((phase * Math.PI) / 6);
+    return theme.fg("success", "●").replace(ansi, `\x1b[38;2;${rgb
+        .slice(1)
+        .map((value) => Math.round(Number(value) * brightness))
+        .join(";")}m`);
+}