@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/dist/tui/agent-controls.js

@@ -0,0 +1,289 @@
+import { randomUUID } from "node:crypto";
+import { resolveSubagentIntercomTarget } from "../intercom/intercom-bridge.js";
+import { sendLiveSubagentMessage } from "../intercom/live-intercom.js";
+import { questionProcessAlive } from "../runs/shared/supervisor-questions.js";
+import { readableText } from "./agent-history.js";
+import { short, resultText, UNAVAILABLE_ASSIGNMENT, PENDING_MESSAGE_NOTICE, } from "./view-model.js";
+import { hasText, errorText } from "./text-values.js";
+const DIRECTION_MESSAGE = "subagent-human-direction";
+function trackedDiff(diff, code) {
+    if (code !== 0) {
+        return;
+    }
+    return hasText(diff) ? diff : "No tracked changes.";
+}
+function savedSessionUnavailable(task) {
+    return task.child.missingSession === true || !hasText(task.child.sessionFile);
+}
+function missingProfile(task, explicit) {
+    return explicit && task.child.state !== "live" && !task.child.launch;
+}
+function inactiveGate(task, explicit) {
+    const liveQuestion = task.question !== undefined && questionProcessAlive(task.question);
+    const inactive = task.child.state !== "live";
+    if (inactive && !liveQuestion && !explicit) {
+        return {
+            kind: "notice",
+            notice: { continue: task.child.state === "blocked" ? "blocked" : "finished" },
+        };
+    }
+    if (!liveQuestion && inactive && savedSessionUnavailable(task)) {
+        return {
+            kind: "notice",
+            notice: "The saved conversation is unavailable. No agent was started; your draft is kept.",
+        };
+    }
+    if (missingProfile(task, explicit)) {
+        return {
+            kind: "notice",
+            notice: `This older run has no saved profile. Inspect it, then use agent_runs continue with agent: ${JSON.stringify(task.child.agent)} to explicitly choose the current profile. Your draft is kept.`,
+        };
+    }
+    return { kind: "send" };
+}
+function duplicateMessage(visit, text) {
+    return visit.outbox.some((sent) => sent.status !== "unconfirmed" &&
+        sent.text === text &&
+        JSON.stringify(sent.quote) === JSON.stringify(visit.quote));
+}
+function sendGate(task, visit, text, explicit) {
+    if (task.child.identityUnavailable === true) {
+        return { kind: "notice", notice: UNAVAILABLE_ASSIGNMENT };
+    }
+    if (task.child.activity?.status === "pending") {
+        return { kind: "ignore" };
+    }
+    const gate = inactiveGate(task, explicit);
+    if (gate.kind !== "send") {
+        return gate;
+    }
+    return !explicit && duplicateMessage(visit, text)
+        ? { kind: "notice", notice: PENDING_MESSAGE_NOTICE }
+        : { kind: "send" };
+}
+function stoppable(task) {
+    return (task !== undefined &&
+        task.child.identityUnavailable !== true &&
+        (task.child.state === "live" || task.question !== undefined) &&
+        task.child.activity?.status !== "pending");
+}
+/** Authoritative control, delivery receipts and busy locks are separate from browse-only history. */
+export class AgentControls {
+    busy = new Set();
+    pi;
+    store;
+    session;
+    effects;
+    constructor(pi, store, session, effects) {
+        this.pi = pi;
+        this.store = store;
+        this.session = session;
+        this.effects = effects;
+    }
+    isBusy(key) {
+        return this.busy.has(key);
+    }
+    ready(key) {
+        return this.session.live() && !this.busy.has(key);
+    }
+    breadcrumb(task, text, quote) {
+        const label = short(task.label, 42);
+        this.pi.sendMessage({
+            customType: DIRECTION_MESSAGE,
+            display: true,
+            content: `For context only: the user sent this directly to ${label} (run ${task.run.runId}, child ${task.child.index}). No relay or approval is needed.\n\n${text}${quote ? `\n\nRegarding ${quote.title}:\n${quote.text}` : ""}`,
+            details: { label, text, quote, runId: task.run.runId, index: task.child.index },
+        }, { triggerTurn: false });
+    }
+    acceptSend(key, task, text, explicit) {
+        const gate = sendGate(task, this.store.visit(key), text, explicit);
+        if (gate.kind === "notice") {
+            this.store.visit(key).notice = gate.notice;
+            this.effects.changed();
+        }
+        return gate.kind === "send";
+    }
+    async send(key, text, continueExplicitly = false) {
+        if (!hasText(text.trim()) || !this.ready(key)) {
+            return;
+        }
+        this.effects.refreshSelected(key);
+        const task = this.store.task(key), visit = this.store.visit(key), generation = this.session.generation;
+        if (!task) {
+            return;
+        }
+        if (!this.acceptSend(key, task, text, continueExplicitly)) {
+            return;
+        }
+        const draft = { draft: visit.draft, quote: visit.quote, text };
+        this.busy.add(key);
+        visit.notice = undefined;
+        this.effects.changed();
+        try {
+            if (task.question || task.child.state !== "live") {
+                await this.answerOrContinue(key, task, draft);
+            }
+            else {
+                await this.deliver(key, task, draft);
+            }
+        }
+        catch (error) {
+            if (this.session.live(generation)) {
+                visit.notice = `Message not confirmed; draft kept. ${errorText(error)}`;
+            }
+        }
+        finally {
+            this.finishControl(key, generation, true);
+        }
+    }
+    async answerOrContinue(key, task, draft) {
+        const generation = this.session.generation, question = task.question, visit = this.store.visit(key);
+        const message = `${draft.text}${draft.quote ? `\n\nRegarding ${draft.quote.title}:\n${draft.quote.text}` : ""}`;
+        const result = await this.effects.execute({
+            action: question ? "answer" : "resume",
+            id: task.run.runId,
+            index: task.child.index,
+            ...(question ? { questionId: question.questionId } : {}),
+            message,
+            messageOrigin: "human",
+        }, this.session.context());
+        if (!this.session.live(generation)) {
+            return;
+        }
+        visit.notice = this.answerNotice(result, question !== undefined);
+        if (result.isError === true) {
+            return;
+        }
+        if (visit.draft === draft.draft) {
+            visit.draft = "";
+            visit.quote = undefined;
+        }
+        visit.outbox = visit.outbox.filter((sent) => sent.draft !== draft.draft);
+        this.breadcrumb(task, draft.text, draft.quote);
+    }
+    answerNotice(result, question) {
+        if (result.isError === true) {
+            return resultText(result);
+        }
+        return question
+            ? "Answer saved; waiting for the child. This is not proof it has acted."
+            : "Continuation started on the saved conversation.";
+    }
+    async deliver(key, task, draft) {
+        const generation = this.session.generation, visit = this.store.visit(key);
+        const sent = {
+            id: randomUUID(),
+            runId: task.run.runId,
+            index: task.child.index,
+            text: draft.text,
+            draft: draft.draft,
+            quote: draft.quote,
+            at: Date.now(),
+            status: "sending",
+        };
+        visit.outbox.push(sent);
+        visit.lastSentId = sent.id;
+        this.effects.save();
+        const receipt = await sendLiveSubagentMessage(this.pi.events, {
+            to: resolveSubagentIntercomTarget(task.run.runId, task.child.agent, task.child.index),
+            message: draft.text,
+            delivery: "steer",
+            timeoutMs: 15_000,
+            signal: this.session.signal,
+            extra: {
+                messageId: sent.id,
+                human: {
+                    ownerSessionId: this.session.context().sessionManager.getSessionId(),
+                    runId: task.run.runId,
+                    index: task.child.index,
+                },
+                ...(draft.quote
+                    ? {
+                        attachments: [
+                            { type: "context", name: draft.quote.title, content: draft.quote.text },
+                        ],
+                    }
+                    : {}),
+            },
+        });
+        if (!this.session.live(generation)) {
+            return;
+        }
+        const accepted = receipt.accepted === true || receipt.delivered;
+        sent.status = accepted ? "waiting" : "unconfirmed";
+        sent.reason = receipt.reason;
+        if (accepted) {
+            this.breadcrumb(task, draft.text, draft.quote);
+        }
+        else {
+            visit.notice = `Delivery unconfirmed. Your draft is kept. ${receipt.reason ?? "Check the conversation before retrying."}`;
+        }
+    }
+    finishControl(key, generation, sending) {
+        if (!this.session.live(generation)) {
+            return;
+        }
+        this.busy.delete(key);
+        this.effects.refreshSelected(key);
+        if (sending) {
+            this.effects.syncDraft();
+            this.effects.save();
+        }
+        else {
+            this.effects.changed();
+        }
+    }
+    async stop(key) {
+        if (!this.ready(key)) {
+            return;
+        }
+        this.effects.refreshSelected(key);
+        const task = this.store.task(key);
+        if (!stoppable(task)) {
+            return;
+        }
+        const generation = this.session.generation;
+        this.busy.add(key);
+        try {
+            const result = await this.effects.execute({ action: "interrupt", id: task.run.runId, index: task.child.index }, this.session.context());
+            if (this.session.live(generation)) {
+                this.store.visit(key).notice =
+                    result.isError === true
+                        ? resultText(result)
+                        : "Stop requested for this child only. Independent siblings continue; dependent workflow steps may not run.";
+            }
+        }
+        catch (error) {
+            if (this.session.live(generation)) {
+                this.store.visit(key).notice = `Stop not confirmed: ${errorText(error)}`;
+            }
+        }
+        finally {
+            this.finishControl(key, generation, false);
+        }
+    }
+    async changes(key) {
+        const task = this.store.task(key), generation = this.session.generation;
+        if (!task || !this.session.live()) {
+            return;
+        }
+        const cwd = task.child.launch?.cwd ?? task.run.cwd;
+        const result = await this.pi.exec("git", ["--no-pager", "diff", "--no-ext-diff", "--no-textconv", "HEAD", "--"], { cwd, timeout: 10_000, signal: this.session.signal });
+        if (!this.session.live(generation)) {
+            return;
+        }
+        const diff = readableText(result.stdout);
+        return {
+            id: "working-tree-changes",
+            kind: "change",
+            title: `Working tree changes · ${cwd}`,
+            timestamp: Date.now(),
+            text: "This is the working tree, not a claim that this child made every change. Untracked files are not included; inspect write/tool results for their full content.",
+            diff: trackedDiff(diff, result.code),
+            details: result.code === 0 ? undefined : readableText(result.stderr),
+        };
+    }
+    dispose() {
+        this.busy.clear();
+    }
+}