@astrofoundry/pi-astro 0.22.2 → 0.22.4

package/extensions/astro-discord/discord.test.ts

@@ -7,6 +7,8 @@ import { chunkMessage, fenceState } from "./chunk.ts";
 import { helpText, parseCommand } from "./commands.ts";
 import { allowedSpecialists, canUse, loadConfig, loadToken, validateConfig } from "./config.ts";
 import { INTENTS, initialState, reduce } from "./gateway.ts";
+import type { RunResult } from "../astro-subagents/child.ts";
+import { failureReply } from "./index.ts";
 import { DiscordRest } from "./rest.ts";
 
 const ID = "123456789012345678";
@@ -147,6 +149,17 @@ describe("rest", () => {
     });
 });
 
+describe("failure reply", () => {
+    it("names the reason and keeps stderr as an attachment", () => {
+        const base: RunResult = { agent: "astro.dns", agentSource: "bundled", task: "t", exitCode: 1, messages: [], stderr: "", usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 } };
+        expect(failureReply({ ...base, errorMessage: "timed out after 30 min" })).toEqual({ text: "timed out after 30 min" });
+        expect(failureReply({ ...base, stderr: "noise\n" })).toEqual({ text: "the specialist process exited with code 1", attachment: "noise" });
+        expect(failureReply({ ...base, stopReason: "aborted" as RunResult["stopReason"] }).text).toBe("the run was stopped");
+        const withWords = failureReply({ ...base, messages: [{ role: "assistant", content: [{ type: "text", text: "I asked for approval." }] } as never] });
+        expect(withWords.text).toContain("Last words of the specialist:\nI asked for approval.");
+    });
+});
+
 describe("approval server", () => {
     it("creates tickets, reports decisions, expires, and rejects bad tokens", async () => {
         const tickets: Ticket[] = [];

package/extensions/astro-discord/index.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import { loadConfig as loadSpecialists } from "../specialist-gate/config.ts";
 import { APPROVAL_TOKEN_ENV, APPROVAL_URL_ENV } from "../specialist-gate/index.ts";
 import { type AgentConfig, defaultDirs, discoverAgents, resolveSkills } from "../astro-subagents/agents.ts";
-import { type DispatchDefaults, childRemaining, currentDepth, isFailed, resultOutput, runAgent } from "../astro-subagents/child.ts";
+import { AGENT_ENV, type DispatchDefaults, type RunResult, childRemaining, currentDepth, finalOutput, isFailed, runAgent } from "../astro-subagents/child.ts";
 import { ApprovalServer, type Ticket } from "./approvals.ts";
 import { chunkMessage } from "./chunk.ts";
 import { CHANNEL_RULES, helpText, parseCommand } from "./commands.ts";
@@ -13,6 +13,40 @@ import { DiscordRest, type MessageComponent } from "./rest.ts";
 const REACTION = { running: "⏳", waiting: "🔒", done: "✅", failed: "❌" } as const;
 /** Answers longer than this go as a file attachment with a short summary. */
 const ATTACHMENT_THRESHOLD = 6000;
+/** Upper bound for one specialist run started from chat; the wrappers' own timeouts are shorter. */
+const TASK_TIMEOUT_MINUTES = 30;
+
+interface ToolCallPart {
+    type?: string;
+    name?: string;
+    arguments?: unknown;
+}
+
+/** One log line per new message: tool calls with their arguments, tool results, and assistant text lengths. */
+function describeProgress(result: RunResult, seen: number): { lines: string[]; seen: number } {
+    const lines: string[] = [];
+    for (const message of result.messages.slice(seen)) {
+        if (message.role === "assistant") {
+            for (const part of message.content as ToolCallPart[]) {
+                if (part.type === "toolCall") lines.push(`tool ${part.name ?? "?"} ${JSON.stringify(part.arguments ?? {}).slice(0, 300)}`);
+                else if (part.type === "text") lines.push(`assistant text ${((part as { text?: string }).text ?? "").length} chars`);
+            }
+        } else if (message.role === "toolResult") {
+            const { toolName, isError } = message as { toolName?: string; isError?: boolean };
+            lines.push(`result ${toolName ?? "?"}${isError ? " (error)" : ""}`);
+        }
+    }
+    return { lines, seen: result.messages.length };
+}
+
+/** Reply for a failed run: the reason in one line, the specialist's last words if any, raw stderr only as an attachment. */
+export function failureReply(result: RunResult): { text: string; attachment?: string } {
+    const reason = result.errorMessage?.trim() || (result.stopReason === "aborted" ? "the run was stopped" : `the specialist process exited with code ${result.exitCode}`);
+    const lastWords = finalOutput(result.messages).trim();
+    const text = lastWords.length > 0 ? `${reason}\n\nLast words of the specialist:\n${lastWords}` : reason;
+    const stderr = result.stderr.trim();
+    return stderr.length > 0 ? { text, attachment: stderr } : { text };
+}
 
 interface IncomingMessage {
     id: string;
@@ -162,21 +196,35 @@ class Bridge {
         const { depth, remaining } = currentDepth();
         let failed = true;
         let output: string;
+        let attachment: string | undefined;
+        let seen = 0;
         try {
             const result = await runAgent({
-                agent,
+                agent: { ...agent, timeoutMinutes: agent.timeoutMinutes ?? TASK_TIMEOUT_MINUTES },
                 skills,
                 task: taskText,
                 cwd: process.cwd(),
                 depth,
                 remaining: childRemaining(remaining, agent),
                 defaults,
-                env: { [APPROVAL_URL_ENV]: this.approvals.url, [APPROVAL_TOKEN_ENV]: this.approvals.token, ASTRO_CHANNEL: "discord" },
+                // The child must not become a second Discord bridge.
+                env: { [ACTIVATION_ENV]: "0", [APPROVAL_URL_ENV]: this.approvals.url, [APPROVAL_TOKEN_ENV]: this.approvals.token, ASTRO_CHANNEL: "discord" },
                 extraSystemPrompt: CHANNEL_RULES,
+                onUpdate: (partial) => {
+                    const progress = describeProgress(partial, seen);
+                    seen = progress.seen;
+                    for (const line of progress.lines) log(`astro.${task.specialist}: ${line}`);
+                },
             });
             failed = isFailed(result);
-            output = resultOutput(result);
-            log(`astro.${task.specialist} ${failed ? "failed" : "done"} in ${Math.round((Date.now() - task.startedAt) / 1000)} s, ${result.usage.turns} turns, cost ${result.usage.cost.toFixed(4)}`);
+            if (failed) {
+                const reply = failureReply(result);
+                output = reply.text;
+                attachment = reply.attachment;
+            } else {
+                output = finalOutput(result.messages) || "(no output)";
+            }
+            log(`astro.${task.specialist} ${failed ? "failed" : "done"} in ${Math.round((Date.now() - task.startedAt) / 1000)} s, ${result.usage.turns} turns, model spend ${result.usage.cost.toFixed(4)} USD`);
         } catch (err) {
             output = err instanceof Error ? err.message : String(err);
         } finally {
@@ -184,10 +232,14 @@ class Bridge {
         }
         await this.rest.removeOwnReaction(task.channelId, task.messageId, REACTION.running).catch(() => undefined);
         await this.rest.addReaction(task.channelId, task.messageId, failed ? REACTION.failed : REACTION.done).catch(() => undefined);
-        await this.post(task, `${failed ? "❌" : "✅"} **${task.specialist}**\n${output}`);
+        await this.post(task, `${failed ? "❌" : "✅"} **${task.specialist}**\n${output}`, attachment);
     }
 
-    private async post(task: ActiveTask, text: string): Promise<void> {
+    private async post(task: ActiveTask, text: string, attachment?: string): Promise<void> {
+        if (attachment !== undefined) {
+            await this.rest.createMessage(task.channelId, { content: text.slice(0, 1900), replyTo: task.messageId, file: { name: `astro-${task.specialist}-stderr-${Date.now()}.txt`, content: attachment } });
+            return;
+        }
         if (text.length > ATTACHMENT_THRESHOLD) {
             const summary = `${text.slice(0, 1200).trim()}\n… full answer attached (${text.length} characters).`;
             await this.rest.createMessage(task.channelId, { content: summary, replyTo: task.messageId, file: { name: `astro-${task.specialist}-${Date.now()}.md`, content: text } });
@@ -252,7 +304,7 @@ class Bridge {
  * the headless LaunchAgent host sets; interactive sessions never connect.
  */
 export default function astroDiscord(pi: ExtensionAPI): void {
-    if (process.env[ACTIVATION_ENV] !== "1") return;
+    if (process.env[ACTIVATION_ENV] !== "1" || process.env[AGENT_ENV]) return;
     pi.on("session_start", async (_event, ctx: ExtensionContext) => {
         const loaded = loadConfig();
         if (!loaded.config) {

package/extensions/astro-discord/setup.ts

@@ -30,11 +30,12 @@ class MutableOutput extends Writable {
 async function main(): Promise<void> {
     const output = new MutableOutput();
     const rl = createInterface({ input: process.stdin, output, terminal: true });
+    // readline redraws the prompt line on every keystroke, so the question must be its prompt, not a bare stdout write.
     const ask = async (question: string, hidden = false): Promise<string> => {
         output.muted = false;
-        process.stdout.write(question);
+        const pending = rl.question(question);
         output.muted = hidden;
-        const answer = await rl.question("");
+        const answer = await pending;
         output.muted = false;
         if (hidden) process.stdout.write("\n");
         return answer.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrofoundry/pi-astro",
-  "version": "0.22.2",
+  "version": "0.22.4",
   "description": "Personal pi customizations (extensions, subagents, skills, prompts, themes) for the pi coding agent.",
   "keywords": [
     "pi-package"