@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/dist/slash/slash-live-state.js

@@ -1,4 +1,5 @@
-import { SLASH_RESULT_TYPE } from "../shared/types.js";
+import { isRecord, isUnknownArray } from "../shared/unknown.js";
+import { SLASH_RESULT_TYPE, } from "../shared/types.js";
 const liveSnapshots = new Map();
 const finalSnapshots = new Map();
 let versionCounter = 1;
@@ -40,10 +41,12 @@ function createPlaceholderResult(agent, task, status, index = 0) {
 function buildParallelInitialResult(params) {
     const tasks = params.tasks ?? [];
     return {
-        content: [{ type: "text", text: tasks.map((task) => `${task.agent}: ${task.task}`).join("\n\n") }],
+        content: [
+            { type: "text", text: tasks.map((task) => `${task.agent}: ${task.task}`).join("\n\n") },
+        ],
         details: {
             mode: "parallel",
-            ...(params.context ? { context: params.context } : {}),
+            ...(params.context !== undefined ? { context: params.context } : {}),
             results: tasks.map((task, index) => createPlaceholderResult(task.agent, task.task, "running", index)),
             progress: tasks.map((task, index) => ({
                 index,
@@ -59,42 +62,44 @@ function buildParallelInitialResult(params) {
         },
     };
 }
-function isParallelChainStep(step) {
-    return "parallel" in step && Array.isArray(step.parallel);
+function chainTasks(step) {
+    if ("agent" in step) {
+        return [step];
+    }
+    return "expand" in step ? [step.parallel] : step.parallel;
 }
 function chainStepLabel(step) {
-    if (isParallelChainStep(step)) {
-        return `[${step.parallel.map((entry) => entry.agent).join("+")}]`;
-    }
-    return step.agent;
+    const label = chainTasks(step)
+        .map((task) => task.agent)
+        .join("+");
+    return "parallel" in step ? `[${label}]` : label;
 }
 function flattenChainResults(chain, fallbackTask) {
     const results = [];
     let flatIndex = 0;
     for (const step of chain) {
-        if (isParallelChainStep(step)) {
-            for (const task of step.parallel) {
-                results.push(createPlaceholderResult(task.agent, task.task ?? fallbackTask ?? "", results.length === 0 ? "running" : "pending", flatIndex));
-                flatIndex++;
-            }
-            continue;
+        for (const task of chainTasks(step)) {
+            results.push(createPlaceholderResult(task.agent, task.task ?? fallbackTask ?? "", results.length === 0 ? "running" : "pending", flatIndex));
+            flatIndex++;
         }
-        results.push(createPlaceholderResult(step.agent, step.task ?? fallbackTask ?? "", results.length === 0 ? "running" : "pending", flatIndex));
-        flatIndex++;
     }
     return results;
 }
 function buildChainInitialResult(params) {
-    const chain = (params.chain ?? []);
+    const chain = params.chain ?? [];
     const results = flattenChainResults(chain, params.task);
     return {
-        content: [{
+        content: [
+            {
                 type: "text",
-                text: results.map((result, index) => `Step ${index + 1}: ${result.agent}\n${result.task}`).join("\n\n"),
-            }],
+                text: results
+                    .map((result, index) => `Step ${index + 1}: ${result.agent}\n${result.task}`)
+                    .join("\n\n"),
+            },
+        ],
         details: {
             mode: "chain",
-            ...(params.context ? { context: params.context } : {}),
+            ...(params.context !== undefined ? { context: params.context } : {}),
             results,
             progress: results.map((result, index) => ({
                 index,
@@ -120,9 +125,10 @@ function buildSingleInitialResult(params) {
         content: [{ type: "text", text: task }],
         details: {
             mode: "single",
-            ...(params.context ? { context: params.context } : {}),
+            ...(params.context !== undefined ? { context: params.context } : {}),
             results: [createPlaceholderResult(agent, task, "running")],
-            progress: [{
+            progress: [
+                {
                     index: 0,
                     agent,
                     status: "running",
@@ -132,41 +138,49 @@ function buildSingleInitialResult(params) {
                     toolCount: 0,
                     tokens: 0,
                     durationMs: 0,
-                }],
+                },
+            ],
         },
     };
 }
 export function buildSlashInitialResult(requestId, params) {
-    const result = (params.tasks?.length ?? 0) > 0
-        ? buildParallelInitialResult(params)
-        : (params.chain?.length ?? 0) > 0
-            ? buildChainInitialResult(params)
-            : buildSingleInitialResult(params);
+    let result;
+    if ((params.tasks?.length ?? 0) > 0) {
+        result = buildParallelInitialResult(params);
+    }
+    else if ((params.chain?.length ?? 0) > 0) {
+        result = buildChainInitialResult(params);
+    }
+    else {
+        result = buildSingleInitialResult(params);
+    }
     liveSnapshots.set(requestId, { result, version: nextVersion() });
     finalSnapshots.delete(requestId);
     return { requestId, result };
 }
 function cloneResultsWithProgress(results, progress) {
     return results.map((result, index) => {
-        const nextProgress = progress?.find((entry) => entry.index === index)
-            ?? progress?.[index]
-            ?? result.progress;
-        return nextProgress ? { ...result, progress: nextProgress } : result;
+        const nextProgress = progress?.find((entry) => entry.index === index) ?? progress?.[index] ?? result.progress;
+        return nextProgress ? Object.assign({}, result, { progress: nextProgress }) : result;
     });
 }
 export function applySlashUpdate(requestId, update) {
     const snapshot = liveSnapshots.get(requestId);
-    if (!snapshot)
+    if (!snapshot) {
         return;
+    }
     const progress = update.progress;
-    if (!progress || !snapshot.result.details)
+    if (!progress) {
         return;
+    }
     const currentStepIndex = progress.findIndex((entry) => entry.status === "running");
     const nextDetails = {
         ...snapshot.result.details,
         progress,
         results: cloneResultsWithProgress(snapshot.result.details.results, progress),
-        ...(snapshot.result.details.mode === "chain" && currentStepIndex >= 0 ? { currentStepIndex } : {}),
+        ...(snapshot.result.details.mode === "chain" && currentStepIndex >= 0
+            ? { currentStepIndex }
+            : {}),
     };
     liveSnapshots.set(requestId, {
         result: {
@@ -201,7 +215,7 @@ export function failSlashResult(requestId, params, message) {
         details: {
             ...initial.details,
             results: failedResults,
-            progress: failedResults.map((entry) => entry.progress).filter(Boolean),
+            progress: failedResults.flatMap((entry) => (entry.progress ? [entry.progress] : [])),
         },
     };
     const snapshot = { result, version: nextVersion() };
@@ -210,33 +224,40 @@ export function failSlashResult(requestId, params, message) {
     return { requestId, result };
 }
 function isSlashMessageDetails(value) {
-    if (!value || typeof value !== "object")
+    if (!isRecord(value)) {
         return false;
+    }
     const v = value;
-    if (typeof v.requestId !== "string" || !v.requestId)
+    if (typeof v.requestId !== "string" || v.requestId.length === 0) {
         return false;
-    if (!v.result || !Array.isArray(v.result.content))
+    }
+    if (!isRecord(v.result) || !isUnknownArray(v.result.content)) {
         return false;
-    return !!v.result.details && Array.isArray(v.result.details.results);
+    }
+    return isRecord(v.result.details) && isUnknownArray(v.result.details.results);
 }
 export function resolveSlashMessageDetails(value) {
     return isSlashMessageDetails(value) ? value : undefined;
 }
 export function getSlashRenderableSnapshot(details) {
-    return finalSnapshots.get(details.requestId)
-        ?? liveSnapshots.get(details.requestId)
-        ?? { result: details.result, version: 0 };
+    return (finalSnapshots.get(details.requestId) ??
+        liveSnapshots.get(details.requestId) ?? { result: details.result, version: 0 });
 }
 export function restoreSlashFinalSnapshots(entries) {
     liveSnapshots.clear();
     finalSnapshots.clear();
     for (const entry of entries) {
+        if (!isRecord(entry)) {
+            continue;
+        }
         const e = entry;
-        if (e?.type !== "custom_message" || e.customType !== SLASH_RESULT_TYPE)
+        if (e.type !== "custom_message" || e.customType !== SLASH_RESULT_TYPE) {
             continue;
+        }
         const details = resolveSlashMessageDetails(e.details);
-        if (!details)
+        if (!details) {
             continue;
+        }
         finalSnapshots.set(details.requestId, { result: details.result, version: nextVersion() });
     }
 }

package/dist/tui/action-hints.js

@@ -1,5 +1,5 @@
 import { rawKeyHint } from "@earendil-works/pi-coding-agent";
-import { MouseRegion, Text, stripTerminalSequences, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { MouseRegion, Text, stripTerminalSequences, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
 /** Native custom messages expose global expansion, but need their own per-message click state. */
 export function withMouseExpansion(renderer) {
     const states = new WeakMap();
@@ -12,34 +12,61 @@ export function withMouseExpansion(renderer) {
         const expansion = state;
         const draw = () => renderer(message, { ...options, expanded: expansion.expanded }, theme);
         let content = draw();
-        if (!content)
+        if (!content) {
             return;
+        }
         return new MouseRegion({ render: (width) => content?.render(width) ?? [], invalidate: () => content?.invalidate() }, (event) => {
-            if (event.type !== "click" || event.button !== "left")
+            if (event.type !== "click" || event.button !== "left") {
                 return;
+            }
             expansion.expanded = !expansion.expanded;
             content = draw();
             return { handled: true };
         });
     };
 }
-/** Declare action spans while building text; native Text owns wrapping and clipping. */
-export function actionHints(parts, style = (text) => text, ellipsis) {
+function actionSource(parts) {
     let text = "", source = "";
     const ranges = [];
     for (const part of parts) {
-        const displayed = typeof part === "string" ? part : part.text.replace(/\balt\+/gi, (key) => stripTerminalSequences(rawKeyHint(key, "")).trim());
+        const displayed = typeof part === "string"
+            ? part
+            : part.text.replace(/\balt\+/gi, (key) => stripTerminalSequences(rawKeyHint(key, "")).trim());
         const plain = stripTerminalSequences(displayed).replace(/\t/g, "   ");
-        if (typeof part !== "string")
+        if (typeof part !== "string") {
             ranges.push({ start: source.length, length: plain.length, run: part.run });
+        }
         text += displayed;
         source += plain;
     }
-    text = style(text);
-    const content = new Text("", 0, 0);
+    return { text, source, ranges };
+}
+function lineHits(shown, from, ranges, row) {
+    const hits = [];
+    const to = from + shown.length;
+    for (const range of ranges) {
+        const start = Math.max(from, range.start), end = Math.min(to, range.start + range.length);
+        if (start < end) {
+            hits.push({
+                row,
+                start: visibleWidth(shown.slice(0, start - from)),
+                end: visibleWidth(shown.slice(0, end - from)),
+                run: range.run,
+            });
+        }
+    }
+    return hits;
+}
+/** Declare action spans while building text; native Text owns wrapping and clipping. */
+export function actionHints(parts, style = (text) => text, ellipsis) {
+    const { text: raw, source, ranges } = actionSource(parts);
+    const text = style(raw), content = new Text("", 0, 0);
     let hits = [];
     return new MouseRegion({
-        invalidate() { content.invalidate(); hits = []; },
+        invalidate() {
+            content.invalidate();
+            hits = [];
+        },
         render(width) {
             const clipped = ellipsis !== undefined && visibleWidth(text) > width;
             content.setText(ellipsis === undefined ? text : truncateToWidth(text, width, ellipsis));
@@ -48,28 +75,29 @@ export function actionHints(parts, style = (text) => text, ellipsis) {
             let offset = 0;
             for (const [row, line] of lines.entries()) {
                 const visible = stripTerminalSequences(line).trimEnd();
-                const shown = clipped ? visible.slice(0, Math.max(0, visible.length - ellipsis.length)) : visible;
+                const shown = clipped
+                    ? visible.slice(0, Math.max(0, visible.length - ellipsis.length))
+                    : visible;
                 const from = source.indexOf(shown, offset);
-                if (!shown || from < 0)
+                if (shown.length === 0 || from < 0) {
                     continue;
-                const to = from + shown.length;
-                for (const range of ranges) {
-                    const start = Math.max(from, range.start), end = Math.min(to, range.start + range.length);
-                    if (start < end)
-                        hits.push({ row, start: visibleWidth(shown.slice(0, start - from)), end: visibleWidth(shown.slice(0, end - from)), run: range.run });
                 }
-                offset = to;
+                hits.push(...lineHits(shown, from, ranges, row));
+                offset = from + shown.length;
             }
             return lines;
         },
     }, (event) => {
-        if (event.button !== "left" || (event.type !== "press" && event.type !== "click"))
+        if (event.button !== "left" || (event.type !== "press" && event.type !== "click")) {
             return;
-        const hit = hits.find((hit) => hit.row === event.y && event.x >= hit.start && event.x < hit.end);
-        if (!hit)
+        }
+        const hit = hits.find((candidate) => candidate.row === event.y && event.x >= candidate.start && event.x < candidate.end);
+        if (!hit) {
             return;
-        if (event.type === "click")
+        }
+        if (event.type === "click") {
             hit.run();
+        }
         return { handled: true };
     });
 }

package/dist/tui/activity-lines.js

@@ -0,0 +1,32 @@
+import { formatDuration, shortenPath } from "../shared/formatters.js";
+import { hasText, nonemptyText } from "./text-values.js";
+function toolActivity(input, now) {
+    if (!hasText(input.currentTool)) {
+        return;
+    }
+    if (input.currentToolStartedAt === undefined || now === undefined) {
+        return input.currentTool;
+    }
+    return `${input.currentTool} ${formatDuration(Math.max(0, now - input.currentToolStartedAt))}`;
+}
+/** Activity facts are shared by job, step and nested rows; each caller owns status/outcome policy. */
+export function activityFacts(input, now, counts = true) {
+    const facts = [], tool = toolActivity(input, now);
+    if (tool !== undefined) {
+        facts.push(tool);
+    }
+    if (hasText(input.currentPath)) {
+        facts.push(shortenPath(input.currentPath));
+    }
+    if (counts && input.turnCount !== undefined) {
+        facts.push(`${input.turnCount} turns`);
+    }
+    if (counts && input.toolCount !== undefined) {
+        facts.push(`${input.toolCount} tools`);
+    }
+    return facts;
+}
+export function joinActivity(facts, activity, fallback = "") {
+    const prefix = hasText(activity) ? [activity] : [];
+    return nonemptyText([...prefix, ...facts].join(" · ")) ?? fallback;
+}

package/dist/tui/agent-browser.js

@@ -0,0 +1,290 @@
+import { runHistoryIndex } from "../runs/shared/history-index.js";
+import { indexedHistory, readableText } from "./agent-history.js";
+import { hasText, errorText } from "./text-values.js";
+function boundary(input) {
+    return {
+        runId: input.runId,
+        index: input.index,
+        terminalEntryId: input.terminalEntryId,
+        endedAt: input.endedAt,
+    };
+}
+async function readMarker(index, input) {
+    if (!hasText(input.readThrough) || input.readThrough.startsWith("result:")) {
+        return;
+    }
+    return index.entry({
+        ...boundary(input),
+        entryId: input.readThrough.replace(/:(?:\d+|error)$/, ""),
+    });
+}
+async function anchorPaging(index, input, anchor, marker) {
+    if (anchor === null) {
+        return { after: 0 };
+    }
+    if (!hasText(anchor) || anchor.startsWith("result:")) {
+        return;
+    }
+    const entry = anchor === input.readThrough
+        ? marker
+        : await index.entry({ ...boundary(input), entryId: anchor.replace(/:(?:\d+|error)$/, "") });
+    return entry ? { after: Math.max(0, entry.sequence - 1) } : undefined;
+}
+async function selectedHistory(index, input, paging, anchor) {
+    const marker = await readMarker(index, input), selectedPaging = (await anchorPaging(index, input, anchor, marker)) ?? paging;
+    const result = await indexedHistory(index, { ...input, limit: 100, ...selectedPaging });
+    const latestPage = selectedPaging.after !== undefined
+        ? !result.page.hasMore
+        : selectedPaging.before === undefined && selectedPaging.cursor === undefined;
+    const unreadStart = input.readThrough === null || input.readThrough === undefined ? -1 : undefined;
+    return { ...result, latestPage, readThroughSequence: marker?.sequence ?? unreadStart };
+}
+function sameHistoryBoundary(a, b) {
+    return (a.runId === b.runId &&
+        a.index === b.index &&
+        a.leaf === b.leaf &&
+        a.terminalEntryId === b.terminalEntryId &&
+        a.endedAt === b.endedAt);
+}
+/** Browse requests own paging, subscriptions and stale-observation guards, never execution authority. */
+export class AgentBrowser {
+    refreshPromise;
+    indexUnsubscribe;
+    listRequest = 0;
+    appliedListRequest = -1;
+    filter = "";
+    offset = 0;
+    listPage;
+    listLoading = false;
+    listError;
+    state;
+    store;
+    session;
+    notify;
+    constructor(state, store, session, notify) {
+        this.state = state;
+        this.store = store;
+        this.session = session;
+        this.notify = notify;
+    }
+    get listFilter() {
+        return this.filter;
+    }
+    get listPending() {
+        return !this.listPage || this.appliedListRequest !== this.listRequest;
+    }
+    active(snapshot) {
+        return this.session.live(snapshot.generation) && snapshot.request === this.listRequest;
+    }
+    wake() {
+        this.refresh().catch((error) => {
+            if (this.session.live()) {
+                this.listError = errorText(error);
+                this.notify();
+            }
+        });
+    }
+    refresh(browse = false) {
+        if (!this.session.live()) {
+            return Promise.resolve();
+        }
+        if (!browse && (this.state.ownedRuns?.size ?? 0) === 0 && !this.state.historyIndex) {
+            return Promise.resolve();
+        }
+        if (this.refreshPromise) {
+            return this.refreshPromise;
+        }
+        const snapshot = {
+            generation: this.session.generation,
+            request: this.listRequest,
+            offset: this.offset,
+            text: this.filter,
+        };
+        this.listLoading = this.listPending;
+        this.refreshPromise = this.refreshPage(snapshot);
+        return this.refreshPromise;
+    }
+    async refreshPage(snapshot) {
+        try {
+            const index = await runHistoryIndex(this.state);
+            if (!this.session.live(snapshot.generation)) {
+                return;
+            }
+            this.indexUnsubscribe ??= index.onChanged(() => this.wake());
+            const page = await index.listRuns({
+                offset: snapshot.offset,
+                limit: 50,
+                text: hasText(snapshot.text) ? snapshot.text : undefined,
+                sort: "attention",
+                latestTasksOnly: true,
+            });
+            const dock = hasText(snapshot.text) || snapshot.offset !== 0
+                ? await index.listRuns({ limit: 50, sort: "attention", latestTasksOnly: true })
+                : page;
+            if (!this.active(snapshot)) {
+                return;
+            }
+            this.applyLists(page, dock, snapshot);
+            await this.observeMetadata(index, snapshot);
+        }
+        catch (error) {
+            if (this.active(snapshot)) {
+                this.listError = `Agents history unavailable: ${errorText(error)}. Retry (F5).`;
+            }
+        }
+        finally {
+            this.finishRefresh(snapshot);
+        }
+    }
+    applyLists(page, dock, snapshot) {
+        this.listPage = page;
+        this.appliedListRequest = snapshot.request;
+        this.listError = undefined;
+        this.store.browsePage(page.rows);
+        this.store.dockPage(dock.rows);
+    }
+    shouldObserve(task) {
+        const visit = this.store.visits.get(task.key);
+        if (!visit || task.child.identityUnavailable === true) {
+            return false;
+        }
+        const idle = task.child.state !== "live" &&
+            !task.question &&
+            task.key !== this.store.selectedKey &&
+            task.key !== this.store.pinned;
+        return !idle || visit.outbox.length > 0 || task.metadataAt !== task.run.updatedAt;
+    }
+    async observeMetadata(index, snapshot) {
+        const markers = new Map([...this.store.tasks, ...this.store.dockTasks].map((task) => [task.key, task]));
+        for (const task of markers.values()) {
+            if (!this.shouldObserve(task)) {
+                continue;
+            }
+            // Each observation applies before the next bounded query; owner/read markers may change at its await.
+            // oxlint-disable-next-line no-await-in-loop
+            await this.observeTask(index, task, snapshot);
+            if (!this.active(snapshot)) {
+                return;
+            }
+        }
+    }
+    async observeTask(index, task, snapshot) {
+        try {
+            const page = await index.historyPage({ ...this.store.historyInput(task), limit: 1 });
+            if (!this.active(snapshot)) {
+                return;
+            }
+            this.store.applyMetadata(task.key, page);
+        }
+        catch (error) {
+            if (this.active(snapshot)) {
+                this.store.metadataUnavailable(task.key, `Conversation metadata unavailable: ${errorText(error)}`);
+            }
+        }
+    }
+    finishRefresh(snapshot) {
+        if (!this.session.live(snapshot.generation)) {
+            return;
+        }
+        this.listLoading = false;
+        this.refreshPromise = undefined;
+        this.notify();
+        if (snapshot.request !== this.listRequest) {
+            this.wake();
+        }
+    }
+    filterTasks(text) {
+        if (text === this.filter) {
+            return;
+        }
+        this.filter = text.slice(0, 256);
+        this.offset = 0;
+        this.listRequest++;
+        this.store.retainSelected();
+        this.wake();
+    }
+    pageTasks(direction) {
+        const next = direction === "later" ? this.listPage?.nextOffset : Math.max(0, this.offset - 50);
+        if (next === undefined || next === this.offset) {
+            return;
+        }
+        this.offset = next;
+        this.listRequest++;
+        this.wake();
+    }
+    async retry(key) {
+        const generation = this.session.generation;
+        try {
+            const index = await runHistoryIndex(this.state, true);
+            await index.refresh(hasText(key) ? this.store.task(key)?.run.runId : undefined);
+        }
+        catch (error) {
+            if (this.session.live(generation)) {
+                this.listError = `History refresh unavailable: ${errorText(error)}`;
+            }
+        }
+        if (this.session.live(generation)) {
+            await this.refresh();
+        }
+    }
+    async historyPage(key, paging = {}, anchor) {
+        const task = this.store.task(key), generation = this.session.generation;
+        if (!task || !this.session.live() || task.child.identityUnavailable === true) {
+            return;
+        }
+        const published = task.page, source = task.historySource;
+        const sessionFile = task.child.sessionFile, childState = task.child.state;
+        const input = this.store.historyInput(task), index = await runHistoryIndex(this.state);
+        const isCurrent = () => {
+            const current = this.store.task(key);
+            if (!this.session.live(generation) ||
+                this.state.historyIndex !== index ||
+                index.failure ||
+                !current ||
+                current.child.identityUnavailable === true ||
+                current.page !== published ||
+                current.historySource !== source ||
+                current.child.sessionFile !== sessionFile ||
+                current.child.state !== childState) {
+                return false;
+            }
+            return sameHistoryBoundary(this.store.historyInput(current), input);
+        };
+        const result = await selectedHistory(index, input, paging, anchor);
+        if (!this.session.live(generation) || this.store.task(key)?.run.runId !== task.run.runId) {
+            return;
+        }
+        return { ...result, isCurrent };
+    }
+    async savedResult(key, id) {
+        const task = this.store.task(key), generation = this.session.generation;
+        if (!task || !this.session.live()) {
+            throw new Error("The owning session is no longer available.");
+        }
+        const index = await runHistoryIndex(this.state), result = await index.result({ runId: task.run.runId, index: task.child.index });
+        if (!this.session.live(generation) || this.store.task(key)?.run.runId !== task.run.runId) {
+            throw new Error("The selected attempt changed; choose the report again.");
+        }
+        if (!result) {
+            throw new Error("The selected saved report is unavailable.");
+        }
+        return {
+            id,
+            kind: "assistant",
+            title: "Saved result",
+            text: readableText(result.text),
+            timestamp: result.timestamp,
+        };
+    }
+    dispose() {
+        this.indexUnsubscribe?.();
+        this.indexUnsubscribe = undefined;
+        this.refreshPromise = undefined;
+        this.listRequest++;
+        this.listPage = undefined;
+        this.listError = undefined;
+        this.listLoading = false;
+        this.offset = 0;
+        this.filter = "";
+    }
+}