@astrofoundry/pi-astro 0.23.0 → 0.23.2

package/extensions/astro-discord/commands.ts

@@ -48,12 +48,15 @@ export const CHANNEL_RULES = `## Channel rules
 
 This task arrived from a Discord channel and your answer is posted there. Answer in plain text under 1500 characters when possible, facts first, no headings. When the task is ambiguous (which guest, which record, which host), do not act: ask one precise question and stop. Risky calls may wait for an operator's approval; if the tool reports a denial or a missing answer, report it and stop.`;
 
-export function helpText(allowed: readonly string[], present: readonly string[], isOwner: boolean, trigger: Trigger): string {
+export function helpText(allowed: readonly string[], present: readonly string[], isOwner: boolean, trigger: Trigger, canConfig: boolean): string {
     if (allowed.length === 0) return present.length === 0 ? "No specialist is present in this channel." : "You may not use the specialists present in this channel.";
     const how = present.length === 1 ? `Every message${trigger === "mention" ? " that addresses me" : ""} here goes to \`${present[0]}\`.` : `Send \`<specialist> <task>\`${trigger === "mention" ? " after mentioning me" : ""}. Specialists you may use here:`;
     const lines = [how];
     if (present.length > 1) lines.push(...allowed.map((name) => `• \`${name}\``));
-    lines.push("Reactions: ⏳ running, 🔒 waiting for an owner's approval, ✅ done, ❌ failed. `status` lists running tasks.");
+    lines.push("Reactions: ⏳ running, 🔒 waiting for an owner's approval, ✅ done, ❌ failed.");
+    const commands = ["`help` this message", "`status` running tasks"];
+    if (canConfig) commands.push("`config show`", "`config channel <#channel> <always|mention> <*|name,name>`", "`config access <specialist> add|remove <@user>`");
+    lines.push(`Commands: ${commands.join(", ")}.`);
     if (isOwner) lines.push("Owners approve risky calls with the buttons the bot posts and may use every specialist.");
     return lines.join("\n");
 }

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

@@ -118,10 +118,12 @@ describe("commands", () => {
     });
 
     it("writes help and prefix texts", () => {
-        expect(helpText([], [], false, "always")).toMatch(/No specialist/);
-        expect(helpText([], ["dns"], false, "always")).toMatch(/may not/);
-        expect(helpText(["arcane"], ["arcane"], false, "mention")).toMatch(/addresses me here goes to `arcane`/);
-        expect(helpText(["dns"], ["dns", "edge"], true, "always")).toMatch(/`dns`/);
+        expect(helpText([], [], false, "always", false)).toMatch(/No specialist/);
+        expect(helpText([], ["dns"], false, "always", false)).toMatch(/may not/);
+        expect(helpText(["arcane"], ["arcane"], false, "mention", false)).toMatch(/addresses me here goes to `arcane`/);
+        expect(helpText(["dns"], ["dns", "edge"], true, "always", false)).toMatch(/`dns`/);
+        expect(helpText(["dns"], ["dns"], true, "always", false)).not.toMatch(/config show/);
+        expect(helpText(["dns"], ["dns"], true, "always", true)).toMatch(/`config show`/);
         expect(needsPrefixText(["dns", "edge"])).toMatch(/`dns`, `edge`/);
     });
 });

package/extensions/astro-discord/index.ts

@@ -205,7 +205,7 @@ class Bridge {
         }
         if (allowed.length === 0) return;
         if (command.kind === "help") {
-            await this.rest.createMessage(message.channel_id, { content: helpText(allowed, present, owner, channel.settings.trigger), replyTo: message.id });
+            await this.rest.createMessage(message.channel_id, { content: helpText(allowed, present, owner, channel.settings.trigger, owner && channel.id === this.config.adminChannelId), replyTo: message.id });
             return;
         }
         if (command.kind === "status") {
@@ -230,6 +230,14 @@ class Bridge {
         task.startedAt = Date.now();
         this.active.set(task.specialist, task);
         await this.rest.addReaction(task.channelId, task.messageId, REACTION.running);
+        const placeholder = await this.rest
+            .createMessage(task.channelId, { content: `${REACTION.running} **${task.specialist}** is working on your task, please wait…`, replyTo: task.messageId })
+            .then((m) => m.id)
+            .catch(() => undefined);
+        // Discord clears the typing indicator after about ten seconds; refresh it while the task runs.
+        await this.rest.triggerTyping(task.channelId).catch(() => undefined);
+        const typing = setInterval(() => void this.rest.triggerTyping(task.channelId).catch(() => undefined), 8000);
+        typing.unref();
         log(`run astro.${task.specialist} for ${task.userId}: ${taskText.slice(0, 200)}`);
         const dirs = defaultDirs();
         const { skills, missing } = resolveSkills(agent.skills, dirs);
@@ -273,26 +281,30 @@ class Bridge {
         } catch (err) {
             output = err instanceof Error ? err.message : String(err);
         } finally {
+            clearInterval(typing);
             this.active.delete(task.specialist);
         }
         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}`, attachment);
+        await this.deliver(task, placeholder, `${failed ? "❌" : "✅"} **${task.specialist}**\n${output}`, attachment);
     }
 
-    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 } });
+    /** Turns the "working" placeholder into the answer: edit it in place when it fits, otherwise replace it with chunks or an attachment. */
+    private async deliver(task: ActiveTask, placeholder: string | undefined, text: string, attachment?: string): Promise<void> {
+        const oversized = attachment !== undefined || text.length > ATTACHMENT_THRESHOLD;
+        if (oversized) {
+            if (placeholder) await this.rest.deleteMessage(task.channelId, placeholder).catch(() => undefined);
+            const file = attachment !== undefined ? { name: `astro-${task.specialist}-stderr-${Date.now()}.txt`, content: attachment } : { name: `astro-${task.specialist}-${Date.now()}.md`, content: text };
+            const content = attachment !== undefined ? text.slice(0, 1900) : `${text.slice(0, 1200).trim()}\n… full answer attached (${text.length} characters).`;
+            await this.rest.createMessage(task.channelId, { content, replyTo: task.messageId, file });
             return;
         }
         const chunks = chunkMessage(text);
-        for (let i = 0; i < chunks.length; i++) {
-            await this.rest.createMessage(task.channelId, { content: chunks[i], replyTo: i === 0 ? task.messageId : undefined });
+        if (chunks.length === 0) chunks.push(text);
+        if (placeholder) await this.rest.editMessage(task.channelId, placeholder, chunks[0]).catch(() => undefined);
+        else await this.rest.createMessage(task.channelId, { content: chunks[0], replyTo: task.messageId });
+        for (let i = 1; i < chunks.length; i++) {
+            await this.rest.createMessage(task.channelId, { content: chunks[i] });
         }
     }
 

package/extensions/astro-discord/rest.ts

@@ -72,6 +72,15 @@ export class DiscordRest {
         await this.call("PATCH", `/channels/${channelId}/messages/${messageId}`, JSON.stringify({ content, components, allowed_mentions: { parse: [] } }), "application/json");
     }
 
+    /** Shows the "Cortex is typing…" indicator for about ten seconds. */
+    async triggerTyping(channelId: string): Promise<void> {
+        await this.call("POST", `/channels/${channelId}/typing`);
+    }
+
+    async deleteMessage(channelId: string, messageId: string): Promise<void> {
+        await this.call("DELETE", `/channels/${channelId}/messages/${messageId}`);
+    }
+
     async addReaction(channelId: string, messageId: string, emoji: string): Promise<void> {
         await this.call("PUT", `/channels/${channelId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}/@me`);
     }

package/extensions/astro-subagents/index.test.ts

@@ -70,6 +70,16 @@ describe("astro-subagents extension", () => {
         expect(notify).toHaveBeenCalledWith(expect.stringContaining("depth limit"), "warning");
     });
 
+    it("posts the /run result without a model turn and names the model in the footer", async () => {
+        const pi = makePi();
+        astroSubagents(pi as unknown as Parameters<typeof astroSubagents>[0], { dirs, env: {} });
+        const setStatus = vi.fn();
+        const ctx = { ui: { notify: vi.fn(), setStatus }, hasUI: true, cwd: root, model: { provider: "openai-codex", id: "gpt-6-astra" } };
+        await pi.commands.get("run")?.handler("astro.nobody -- x", ctx);
+        expect(setStatus).toHaveBeenCalledWith("subagent", expect.stringContaining("astro.nobody on openai-codex/gpt-6-astra"));
+        expect(pi.sendMessage).toHaveBeenCalledWith(expect.objectContaining({ customType: "astro-subagents", content: expect.stringContaining("Unknown agent") }), { triggerTurn: false });
+    });
+
     it("removes legacy loader copies on session start", async () => {
         writeFileSync(join(dirs.userAgents, "astro.arcane.md"), "old copy");
         writeFileSync(join(dirs.userAgents, "mine.md"), "---\nname: mine\ndescription: keep\n---\n");

package/extensions/astro-subagents/index.ts

@@ -139,6 +139,12 @@ export default function astroSubagents(pi: ExtensionAPI, options: GateOptions =
         });
     }
 
+    /** Footer label: the agent and the model it will run on. */
+    function runLabel(ctx: ExtensionContext, agents: AgentConfig[], agentName: string): string {
+        const model = agents.find((a) => a.name === agentName)?.model ?? (ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined);
+        return model ? `${agentName} on ${model}` : agentName;
+    }
+
     if (canDelegate) {
         const initial = listAgents(process.cwd(), "user");
         pi.registerTool({
@@ -152,7 +158,13 @@ export default function astroSubagents(pi: ExtensionAPI, options: GateOptions =
             ],
             parameters: Params,
             async execute(_id, params, signal, onUpdate, ctx) {
-                const label = params.chain?.length ? `chain of ${params.chain.length}` : params.tasks?.length ? `${params.tasks.length} agents` : (params.agent ?? "subagent");
+                const label = params.chain?.length
+                    ? `chain of ${params.chain.length}`
+                    : params.tasks?.length
+                      ? `${params.tasks.length} agents`
+                      : params.agent
+                        ? runLabel(ctx, listAgents(ctx.cwd, params.agentScope ?? "user").agents, params.agent)
+                        : "subagent";
                 const stopTicker = startTicker(ctx, label);
                 try {
                     return await runTool(params, signal, onUpdate, ctx);
@@ -260,7 +272,7 @@ export default function astroSubagents(pi: ExtensionAPI, options: GateOptions =
                 return;
             }
             const agents = listAgents(ctx.cwd, "user").agents;
-            const stopTicker = startTicker(ctx, parsed.agent);
+            const stopTicker = startTicker(ctx, runLabel(ctx, agents, parsed.agent));
             let result: RunResult;
             try {
                 result = await runOne(ctx, agents, parsed.agent, parsed.task, undefined, undefined, undefined, undefined);
@@ -269,10 +281,8 @@ export default function astroSubagents(pi: ExtensionAPI, options: GateOptions =
             }
             const status = isFailed(result) ? "failed" : "done";
             if (isFailed(result)) ctx.ui.notify(`${parsed.agent} failed`, "warning");
-            pi.sendMessage(
-                { customType: "astro-subagents", content: `Result from /run ${parsed.agent} (${status}). Task: ${parsed.task}\n\n${resultOutput(result)}`, display: true },
-                { deliverAs: "followUp", triggerTurn: true },
-            );
+            // No turn: the result joins the context for the next prompt without the parent model restating it.
+            pi.sendMessage({ customType: "astro-subagents", content: `Result from /run ${parsed.agent} (${status}). Task: ${parsed.task}\n\n${resultOutput(result)}`, display: true }, { triggerTurn: false });
         },
     });
 

package/package.json

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

package/specialists/README.md

@@ -105,7 +105,7 @@ Check: `sudo -n -u specialist -H /usr/local/bin/specialist-cli arcane --caller t
 
 The `astro-discord` extension gives Discord users access to the specialists from a channel. It runs in a headless Pi host on Cortex (LaunchAgent `com.astrofoundry.astro-discord`, user `cortex`), never in interactive sessions.
 
-- Channels are configured one by one (`channels.<id>`): `trigger` is `always` (every message that names a specialist counts) or `mention` (only messages that start with `@Cortex` or reply to the bot); `specialists` is `*` or a list. A channel with one specialist needs no prefix: every message there is a task for it. In a channel with several, `dns list the zones` names the specialist; an addressed message without a name gets a reply asking for one. Threads inherit their parent channel's entry; unlisted channels are ignored. Reactions on your message: ⏳ running, 🔒 waiting for an owner's approval, ✅ done, ❌ failed. `help` shows what you may use in that channel; `status` lists running tasks. Long answers arrive as a `.md` attachment.
+- Channels are configured one by one (`channels.<id>`): `trigger` is `always` (every message that names a specialist counts) or `mention` (only messages that start with `@Cortex` or reply to the bot); `specialists` is `*` or a list. A channel with one specialist needs no prefix: every message there is a task for it. In a channel with several, `dns list the zones` names the specialist; an addressed message without a name gets a reply asking for one. Threads inherit their parent channel's entry; unlisted channels are ignored. The bot replies at once with "<specialist> is working on your task" and shows the typing indicator until the answer replaces that reply. Reactions on your message: ⏳ running, 🔒 waiting for an owner's approval, ✅ done, ❌ failed. `help` shows the specialists you may use in that channel and the commands (`status` lists running tasks; owners in the admin channel also see the `config` commands). Long answers arrive as a `.md` attachment.
 - Access: `owners` may use every specialist and decide approvals; `access.<specialist>` lists extra users for that specialist; everyone else gets no reply. Owners change the configuration from the admin channel (`adminChannelId`) without a shell: `config show`, `config channel <#channel> <always|mention> <*|dns,edge>`, `config channel <#channel> remove`, `config access <specialist> add|remove <@user>`; the bot writes `~/.config/astro-discord/config.json` on Cortex, which is also editable by hand and re-read on every message. Deny the bot's role View Channel on channels it must never read; that is the boundary the map cannot provide.
 - Approvals: a risky call (anything with `--confirm`, plus writes such as record or zone deletes, Zitadel changes, Pomerium deploys, Arcane redeploys, service restarts) pauses the specialist and posts Approve/Deny buttons; only owners' clicks count; no decision within `approvalTimeoutMinutes` denies it. The specialist then reports the denial. Ambiguous tasks get a question back instead of an action.
 - Setup, as `cortex`: `d=$(mktemp -d) && cp ~/.pi/agent/npm/node_modules/@astrofoundry/pi-astro/extensions/astro-discord/*.ts "$d" && node --disable-warning=ExperimentalWarning "$d/setup.ts"` (Node does not strip types inside `node_modules`, so the files are copied first) prompts for the bot token and the ids, checks each against Discord, and writes `~/.config/astro-discord/{token,config.json,run.sh}` and the LaunchAgent; it prints the `launchctl bootstrap` line. After a pi-astro update restart the bridge with `launchctl kickstart -k gui/$(id -u)/com.astrofoundry.astro-discord`. Log: `~/Library/Logs/astro-discord.log`.

package/specialists/lib/pinned.ts

@@ -25,7 +25,8 @@ export function pinnedRequest(url: URL, options: PinnedOptions): Promise<PinnedR
     return new Promise((resolve, reject) => {
         const req = httpsRequest(
             url,
-            { method: options.method, rejectUnauthorized: false, headers: options.headers, timeout: options.timeoutMs },
+            // agent:false forces a new connection per call: a pooled TLS socket returns an empty peer certificate on reuse, which would fail the pin.
+            { method: options.method, rejectUnauthorized: false, headers: options.headers, timeout: options.timeoutMs, agent: false },
             (res) => {
                 const socket = res.socket as { getPeerCertificate?: () => { fingerprint256?: string } };
                 const fingerprint = socket.getPeerCertificate?.().fingerprint256 ?? "";