pi-squire 0.7.0 → 0.8.1

package/CHANGELOG.md

@@ -6,6 +6,34 @@ follows [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.8.1] - 2026-10-20
+
+### Fixed
+
+- A 429 whose text says the endpoint is unavailable, such as OpenCode Go's
+  `429: Endpoint is unavailable`, no longer marks the provider as
+  usage-limited. It is an outage, not a used-up quota, so `/delegate` keeps
+  launching on the provider instead of refusing it for five minutes or more.
+  Pi has already retried the request by then. A running delegate that hits
+  it moves to its next fallback model and carries on, as it does on a usage
+  limit.
+
+## [0.8.0] - 2026-10-20
+
+### Added
+
+- A delegate's footer shows that it is a delegate and whether auto-exit is
+  on: `👦 delegate · auto-exit on`, or
+  `👦 delegate · auto-exit off`. It follows the
+  setting as typing turns it off and `/auto-exit` turns it back on.
+
+### Changed
+
+- The parent's footer reads `👨 N delegates running` instead of
+  `⇄ N running`. Each side picks its icon at random per session: 👨 or 👩
+  for the parent, 👦 or 👧 for a delegate. The footer tests in
+  `test/delegate.test.ts` change to match.
+
 ## [0.7.0] - 2026-10-19
 
 ### Added
@@ -257,7 +285,9 @@ author's dotfiles; the changes below are against that copy.
 
 - The published file list includes `child.ts`, which `index.ts` imports.
 
-[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.7.0...HEAD
+[Unreleased]: https://github.com/gvanderclay/pi-squire/compare/v0.8.1...HEAD
+[0.8.1]: https://github.com/gvanderclay/pi-squire/compare/v0.8.0...v0.8.1
+[0.8.0]: https://github.com/gvanderclay/pi-squire/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/gvanderclay/pi-squire/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/gvanderclay/pi-squire/compare/v0.5.1...v0.6.0
 [0.5.1]: https://github.com/gvanderclay/pi-squire/compare/v0.5.0...v0.5.1

package/README.md

@@ -393,6 +393,10 @@ The parent resolves each delegation's auto-exit from the call
   notice: typed or RPC input, or a run the user stopped (Esc).
 - `/auto-exit` inside the delegate turns it on again for the next normal
   completion, whatever the launch said.
+- The footer shows that this is a delegate and whether auto-exit is on:
+  `👦 delegate · auto-exit on`, or
+  `👦 delegate · auto-exit off`, with 👦 or 👧
+  picked at random per session.
 
 There is no `subagent_done` tool: auto-exit off only means the window stays.
 
@@ -439,8 +443,9 @@ Delegate session: <session file or id>
   current tool calls, before the next model call. A follow-up would wait
   until the parent had answered, by which time it had often read the
   envelope itself, and the late result cost a second, redundant turn.
-- The footer counts the running delegations (`⇄ N running`), clears one entry
-  per result or close and hides itself at zero.
+- The footer counts the running delegations (`👨 N delegates running`, with 👨 or 👩
+  picked at random per session), clears one entry per result or close and
+  hides itself at zero.
 - Each result and each close is recorded in the parent session, and the
   records are rebuilt synchronously at session start. A resume still
   recognises replies, including one that arrived while the parent was

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-squire",
-	"version": "0.7.0",
+	"version": "0.8.1",
 	"description": "Starts a delegate Pi session in a background tmux window, sends it the task over message:*, and shows the parent its result",
 	"keywords": [
 		"pi-package",

package/src/child.ts

@@ -21,6 +21,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import { activeMark, classify, type Response, recordLimit } from "./limits.ts";
+import { STATUS_KEY } from "./results.ts";
 
 /** The launch variable that carries the parent's resolved setting. */
 export const AUTO_EXIT_ENV = "PI_DELEGATE_AUTO_EXIT";
@@ -83,39 +84,68 @@ function registerTakeover(pi: ExtensionAPI, parent: string): void {
 }
 
 /**
- * A usage limit moves the run to the next fallback that is usable and not
- * marked, and continues it in this session; each fallback is tried once.
- * Returns the setter for the model whose usage limit ended the last run.
+ * A usage limit or an unavailable endpoint moves the run to the next fallback
+ * that is usable and not marked, and continues it in this session; each
+ * fallback is tried once. Returns the setter for what ended the last run, as
+ * `<provider/model> <what happened>`.
  */
-function registerFallback(pi: ExtensionAPI): (model: string | undefined) => void {
+function registerFallback(pi: ExtensionAPI): (failure: string | undefined) => void {
 	/** The models still to move to on a usage limit, in order. */
 	const fallback = (process.env[FALLBACK_ENV] ?? "").split(",").filter((model) => model.includes("/"));
-	let limited: string | undefined;
+	let failure: string | undefined;
 	pi.on("agent_before_settle", async (_event, ctx) => {
-		const from = limited;
-		limited = undefined;
+		const from = failure;
+		failure = undefined;
 		const next = from === undefined ? undefined : await switchModel(pi, ctx, fallback);
 		if (next === undefined) return;
-		const content = `[delegate] ${from} hit a usage limit, so this session switched to ${next}. Carry on with the task from where it stopped.`;
+		const content = `[delegate] ${from}, so this session switched to ${next}. Carry on with the task from where it stopped.`;
 		return { continue: true, entries: [{ type: "custom_message", customType: "delegate", content, display: true }] };
 	});
-	return (model) => {
-		limited = model;
+	return (value) => {
+		failure = value;
 	};
 }
 
+/** Why a failed run should move to a fallback, as `<provider/model> <what happened>`; undefined when it should not. */
+function fallbackReason(last: Message | undefined): string | undefined {
+	const error = last?.errorMessage;
+	if (typeof error !== "string") return undefined;
+	const model = `${String(last?.provider)}/${String(last?.model)}`;
+	if (classify(error) !== undefined) return `${model} hit a usage limit`;
+	// Pi has already retried an unavailable endpoint; it marks nothing, but this run moves on.
+	if (/unavailable/i.test(error)) return `${model} was unavailable (${error})`;
+	return undefined;
+}
+
+/** This delegate's footer icon, picked once per load. */
+const ICON = Math.random() < 0.5 ? "👦" : "👧";
+
+function showStatus(ctx: ExtensionContext, armed: boolean): void {
+	const { theme } = ctx.ui;
+	ctx.ui.setStatus(
+		STATUS_KEY,
+		armed
+			? `${ICON} delegate · auto-exit ${theme.fg("success", "on")}`
+			: `${ICON} delegate · auto-exit ${theme.fg("dim", "off")}`,
+	);
+}
+
 export function registerChild(pi: ExtensionAPI, parent: string): void {
 	registerTakeover(pi, parent);
-	const setLimited = registerFallback(pi);
+	const setFailure = registerFallback(pi);
 
 	let armed = process.env[AUTO_EXIT_ENV] === "1";
 	/** Whether the run that just ended finished without the user stopping it. */
 	let completed = false;
 
+	// Reload and session replacement clear extension statuses, then start again.
+	pi.on("session_start", async (_event, ctx) => showStatus(ctx, armed));
+
 	function disarm(ctx: ExtensionContext): void {
 		if (!armed) return;
 		armed = false;
 		ctx.ui.notify(OFF_NOTICE, "info");
+		showStatus(ctx, armed);
 	}
 
 	// Typed text and RPC input are the user's; a prompt an extension sends is not.
@@ -144,11 +174,7 @@ export function registerChild(pi: ExtensionAPI, parent: string): void {
 		const stopped = last?.stopReason === "aborted" || ctx.signal?.aborted === true;
 		if (stopped) disarm(ctx);
 		if (!stopped && last?.stopReason === "error") recordUsageLimit(last, ctx, response);
-		setLimited(
-			!stopped && typeof last?.errorMessage === "string" && classify(last.errorMessage) !== undefined
-				? `${String(last.provider)}/${String(last.model)}`
-				: undefined,
-		);
+		setFailure(stopped ? undefined : fallbackReason(last));
 		// A failure ends the work like a completion: the parent gets the error, the session file stays.
 		completed = !stopped;
 	});
@@ -166,6 +192,7 @@ export function registerChild(pi: ExtensionAPI, parent: string): void {
 		handler: async (_args, ctx) => {
 			armed = true;
 			ctx.ui.notify(ON_NOTICE, "info");
+			showStatus(ctx, armed);
 		},
 	});
 }

package/src/limits.ts

@@ -145,10 +145,12 @@ export function headerReset(response: Response | undefined, now = Date.now()): n
 
 /**
  * Whether an error message (Pi's `<status>: <body>`) is a usage limit, and
- * the reset time the text states, if any. Overloaded and 5xx errors never are.
+ * the reset time the text states, if any. Overloaded, unavailable and 5xx
+ * errors never are: OpenCode Go sends "429: Endpoint is unavailable" for an
+ * outage, with quota left.
  */
 export function classify(message: string, now = Date.now()): { resetAt?: number } | undefined {
-	if (/overloaded/i.test(message) || /^\s*5\d\d\b/.test(message)) return undefined;
+	if (/overloaded|unavailable/i.test(message) || /^\s*5\d\d\b/.test(message)) return undefined;
 	if (!LIMIT_PATTERN.test(message) && !/^\s*429\b/.test(message)) return undefined;
 	const resetAt = statedReset(message, now);
 	return resetAt !== undefined && resetAt > now ? { resetAt } : {};

package/src/results.ts

@@ -237,6 +237,7 @@ export function createResults(pi: ExtensionAPI): Results {
 	let ctx: ExtensionContext | undefined;
 	/** Whether the footer currently shows the entry, so a clear is sent only when needed. */
 	let footerShown = false;
+	const icon = Math.random() < 0.5 ? "👨" : "👩";
 
 	/** A delegation still going: no result and no recorded close. */
 	const running = (): Recorded[] =>
@@ -251,7 +252,7 @@ export function createResults(pi: ExtensionAPI): Results {
 		const visible = count > 0;
 		if (!visible && !footerShown) return;
 		footerShown = visible;
-		ctx.ui.setStatus(STATUS_KEY, visible ? `⇄ ${count} running` : undefined);
+		ctx.ui.setStatus(STATUS_KEY, visible ? `${icon} ${count} delegate${count === 1 ? "" : "s"} running` : undefined);
 	}
 
 	/** Rebuild the records from the session's entries, so a resume still recognises replies. */