@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/dist/tui/result-facts.js

@@ -1,64 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,366 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,47 +0,0 @@
-/** 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

@@ -1,94 +0,0 @@
-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`);
-}