@astrofoundry/pi-astro 0.18.4 → 0.18.6

package/agents/arcane.md

@@ -18,6 +18,6 @@ Rules:
 - Project definitions of GitOps-managed projects (Compose files, `.env` layout, project folders) change only through `git show`, `git write`, `git commit`, `git push`, then the project's server-side sync (`arcane-cli gitops`). Never edit a managed project through `projects update` or `projects workspace`, even though the CLI allows it.
 - Operational actions (restart, logs, stats, redeploy, image pull, prune) go straight through the CLI.
 - Confirm destructive operations (`down`, `delete`, `prune`) are explicitly requested in the task before running them.
-- Updating Arcane itself ends with a hand-over: after the repository change and the file sync, stop and give the caller the host commands from the skill. Never run `system upgrade` or `projects upgrade arcane`.
+- Updating Arcane itself is a hand-over: do the repository change and the sync, then end with the exact hand-over block from the skill (numbered host steps, digests, rollback). Never run `system upgrade` or `projects upgrade arcane`.
 - Report facts from the JSON output. Sensitive fields are already removed; never guess at what was removed.
 - Delegate through `subagent` only to another specialist (`astro.identity`, `astro.network`) and only for that specialist's own area.

package/extensions/astro-footer/segments.test.ts

@@ -193,7 +193,8 @@ describe("segments", () => {
         expect(out).toContain("2.1k");
     });
 
-    it("renderExtensionStatus uses muted colour", () => {
+    it("renderExtensionStatus uses muted colour, unless the status is already styled", () => {
         expect(renderExtensionStatus(fakeTheme, "🪨 caveman:full")).toBe("<muted>🪨 caveman:full</muted>");
+        expect(renderExtensionStatus(fakeTheme, "\u001b[36m⠋ astro.arcane 0:05\u001b[0m")).toBe("\u001b[36m⠋ astro.arcane 0:05\u001b[0m");
     });
 });

package/extensions/astro-footer/segments.ts

@@ -133,6 +133,7 @@ export function renderCache(
     return `${theme.fg("muted", icons.cacheRead)}${theme.fg("text", formatTokens(cacheRead))} ${theme.fg("muted", icons.cacheWrite)}${theme.fg("text", formatTokens(cacheWrite))}`;
 }
 
+/** Statuses that already carry ANSI styling (for example a coloured spinner) render as they are. */
 export function renderExtensionStatus(theme: ThemeFn, value: string): string {
-    return theme.fg("muted", value);
+    return value.includes("\u001b[") ? value : theme.fg("muted", value);
 }

package/extensions/astro-subagents/index.ts

@@ -3,10 +3,11 @@ import * as path from "node:path";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
+import { type Static, Type } from "typebox";
 import { type AgentConfig, type AgentDirs, type AgentScope, BUNDLED_NAMESPACE, defaultDirs, discoverAgents, formatAgentList, resolveSkills } from "./agents.ts";
 import { childRemaining, currentDepth, type DispatchDefaults, finalOutput, isFailed, resultOutput, type RunResult, runAgent } from "./child.ts";
 import { renderCall, renderResult, type SubagentDetails } from "./render.ts";
+import { startTicker } from "./ticker.ts";
 
 const MAX_PARALLEL_TASKS = 8;
 const MAX_CONCURRENCY = 4;
@@ -151,6 +152,23 @@ 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 stopTicker = startTicker(ctx, label);
+                try {
+                    return await runTool(params, signal, onUpdate, ctx);
+                } finally {
+                    stopTicker();
+                }
+            },
+            renderCall: (args, theme) => renderCall(args, theme),
+            renderResult: (result, { expanded }, theme) => renderResult(result as AgentToolResult<SubagentDetails>, expanded, theme),
+        });
+    }
+
+    type ToolParams = Static<typeof Params>;
+    type ToolResult = AgentToolResult<SubagentDetails> & { isError?: boolean };
+
+    async function runTool(params: ToolParams, signal: AbortSignal | undefined, onUpdate: ((r: ToolResult) => void) | undefined, ctx: ExtensionContext): Promise<ToolResult> {
                 const scope: AgentScope = params.agentScope ?? "user";
                 const discovery = listAgents(ctx.cwd, scope);
                 const agents = discovery.agents;
@@ -227,10 +245,6 @@ export default function astroSubagents(pi: ExtensionAPI, options: GateOptions =
                     return { content: [{ type: "text", text: `Agent ${result.stopReason ?? "failed"}: ${resultOutput(result)}` }], details: details("single", [result]), isError: true };
                 }
                 return { content: [{ type: "text", text: finalOutput(result.messages) || "(no output)" }], details: details("single", [result]) };
-            },
-            renderCall: (args, theme) => renderCall(args, theme),
-            renderResult: (result, { expanded }, theme) => renderResult(result as AgentToolResult<SubagentDetails>, expanded, theme),
-        });
     }
 
     pi.registerCommand("run", {
@@ -246,16 +260,15 @@ export default function astroSubagents(pi: ExtensionAPI, options: GateOptions =
                 return;
             }
             const agents = listAgents(ctx.cwd, "user").agents;
-            ctx.ui.notify(`running ${parsed.agent}...`, "info");
-            ctx.ui.setStatus("subagent", `${parsed.agent} running`);
+            const stopTicker = startTicker(ctx, parsed.agent);
             let result: RunResult;
             try {
                 result = await runOne(ctx, agents, parsed.agent, parsed.task, undefined, undefined, undefined, undefined);
             } finally {
-                ctx.ui.setStatus("subagent", undefined);
+                stopTicker();
             }
             const status = isFailed(result) ? "failed" : "done";
-            ctx.ui.notify(`${parsed.agent} ${status}`, isFailed(result) ? "warning" : "info");
+            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 },

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

@@ -0,0 +1,40 @@
+import { describe, expect, it, vi } from "vitest";
+import { formatElapsed, startTicker, tickerText } from "./ticker.ts";
+
+describe("ticker", () => {
+    it("formats elapsed time as m:ss", () => {
+        expect(formatElapsed(0)).toBe("0:00");
+        expect(formatElapsed(59_999)).toBe("0:59");
+        expect(formatElapsed(61_000)).toBe("1:01");
+        expect(formatElapsed(3_600_000)).toBe("60:00");
+    });
+
+    it("cycles spinner frames", () => {
+        expect(tickerText("astro.arcane", 0, 1000)).toBe("⠋ astro.arcane 0:01");
+        expect(tickerText("astro.arcane", 10, 1000)).toBe("⠋ astro.arcane 0:01");
+        expect(tickerText("astro.arcane", 1, 65_000)).toBe("⠙ astro.arcane 1:05");
+    });
+
+    it("paints accent-coloured status until stopped and then clears it", () => {
+        vi.useFakeTimers();
+        const setStatus = vi.fn();
+        const fg = vi.fn((color: string, text: string) => `<${color}>${text}</${color}>`);
+        const ctx = { hasUI: true, ui: { setStatus, theme: { fg } } } as unknown as Parameters<typeof startTicker>[0];
+        let clock = 0;
+        const stop = startTicker(ctx, "astro.network", 100, () => clock);
+        expect(setStatus).toHaveBeenLastCalledWith("subagent", "<accent>⠋ astro.network 0:00</accent>");
+        clock = 1500;
+        vi.advanceTimersByTime(100);
+        expect(setStatus).toHaveBeenLastCalledWith("subagent", "<accent>⠙ astro.network 0:01</accent>");
+        stop();
+        expect(setStatus).toHaveBeenLastCalledWith("subagent", undefined);
+        vi.useRealTimers();
+    });
+
+    it("does nothing without a UI", () => {
+        const setStatus = vi.fn();
+        const stop = startTicker({ hasUI: false, ui: { setStatus } } as unknown as Parameters<typeof startTicker>[0], "x");
+        stop();
+        expect(setStatus).not.toHaveBeenCalled();
+    });
+});

package/extensions/astro-subagents/ticker.ts

@@ -0,0 +1,36 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const STATUS_KEY = "subagent";
+
+export function formatElapsed(ms: number): string {
+    const total = Math.max(0, Math.floor(ms / 1000));
+    const minutes = Math.floor(total / 60);
+    const seconds = total % 60;
+    return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+
+export function tickerText(label: string, frameIndex: number, elapsedMs: number): string {
+    return `${FRAMES[frameIndex % FRAMES.length]} ${label} ${formatElapsed(elapsedMs)}`;
+}
+
+/**
+ * Animated footer status in the accent colour while a subagent runs.
+ * Returns a stop function that clears the status. A no-op without UI.
+ */
+export function startTicker(ctx: ExtensionContext, label: string, intervalMs = 250, now: () => number = Date.now): () => void {
+    if (!ctx.hasUI) return () => {};
+    const started = now();
+    let frame = 0;
+    const paint = () => {
+        const text = tickerText(label, frame++, now() - started);
+        ctx.ui.setStatus(STATUS_KEY, ctx.ui.theme ? ctx.ui.theme.fg("accent", text) : text);
+    };
+    paint();
+    const timer = setInterval(paint, intervalMs);
+    timer.unref();
+    return () => {
+        clearInterval(timer);
+        ctx.ui.setStatus(STATUS_KEY, undefined);
+    };
+}

package/package.json

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

package/skills/arcane/SKILL.md

@@ -29,13 +29,27 @@ The full `arcane-cli` is available. The tool refuses only `config`, `auth`, `sel
 
 ## Updating Arcane itself
 
-The `arcane` project is GitOps-managed and pinned by digest (`ghcr.io/getarcaneapp/manager@sha256:...`). The documented path (Arcane installation guide, homelab self-management exception) has three steps; you do the first two and hand over the third.
-
-1. Repository: `git pull`, `git show arcane/compose.yaml`, find the new digest with `["projects", "updates"]`, `git write` the file with the new digest, `git diff`, `git commit "Update Arcane manager image"`, `git push`.
-2. Sync files: trigger the `arcane` project's GitOps sync through `["gitops", ...]` so `/opt/docker/arcane/compose.yaml` matches the repository. The manager cannot recreate itself from its own sync.
-3. Stop and report: the caller runs on VM 100, in `/opt/docker/arcane`, `docker compose pull arcane && docker compose up -d arcane`, then asks you to verify with `["version"]` and `["projects", "list"]`.
-
-Never use `["system", "upgrade"]` or `["projects", "upgrade", "arcane"]` for the manager: both bypass the pinned digest in the repository.
+The `arcane` project is GitOps-managed and pinned by digest (`ghcr.io/getarcaneapp/manager@sha256:...`). The manager cannot recreate its own container, so the update is a hand-over: you do the repository and sync work, then give the caller exact steps for VM 100 and verify afterwards. Never use `["system", "upgrade"]` or `["projects", "upgrade", "arcane"]` for the manager; both bypass the pinned digest in the repository.
+
+Procedure, in this order:
+
+1. Facts: `["version"]` (running version and digest), `["projects", "updates"]` (new digest, if any). If there is no update, report that and stop.
+2. Repository: `git pull`, `git show arcane/compose.yaml`, `git write arcane/compose.yaml <file with the new digest, nothing else changed>`, `git diff`, `git commit "Update Arcane manager to <version>"`, `git push`.
+3. Sync: `["gitops", "sync", "arcane", "--yes"]`, then `["gitops", "status", "arcane"]` until the last synced commit is yours. This updates `/opt/docker/arcane/compose.yaml` on VM 100; the container keeps running the old image.
+4. Hand over. End your answer with exactly this block, values filled in:
+
+   ```
+   Arcane manager update <old version> -> <new version>
+   Repository: commit <short hash> pushed and synced (digest <new digest, first 12 chars>).
+   Your steps on VM 100 (ssh arcane), expect ~1 minute of Arcane UI/API downtime; other containers keep running:
+     1. cd /opt/docker/arcane && docker compose pull arcane && docker compose up -d arcane
+     2. docker inspect arcane --format "{{.Config.Image}} {{.State.Status}}"   (expect the new digest, running)
+   Then ask me to verify; I will check version, projects, and GitOps status.
+   Rollback if the manager does not come back: git revert <short hash> in the repository (ask me), then on VM 100: docker compose up -d arcane with the previous digest <old digest, first 12 chars>.
+   Last Restic backup of arcane-data: nightly at 03:00; check the date before you start if the change worries you.
+   ```
+
+5. When the caller reports back: `["version"]` must show the new digest, `["projects", "list"]` must show `arcane` running, `["gitops", "status", "arcane"]` must be clean. Report the three facts.
 
 ## Output