pi-herdr-agents 3.0.3 → 3.2.0

package/pi-extension/subagents/index.ts

@@ -1,6 +1,7 @@
 import type {
 	AgentToolResult,
 	ExtensionAPI,
+	ExtensionCommandContext,
 	ExtensionContext,
 	SessionShutdownEvent,
 } from "@earendil-works/pi-coding-agent";
@@ -19,8 +20,9 @@ import { randomUUID } from "node:crypto";
 import type { RunCancellation, Task } from "../../maestro/core/types.ts";
 import {
 	createDefaultRunSession,
-	initializeTaskModels,
+	startTaskModelInit,
 	observePiActivity,
+	type TaskModelInitOutcome,
 	type PiRunSession,
 	type PiRunSessionInfrastructure,
 	type PiRunRecord,
@@ -36,6 +38,7 @@ import {
 	type CancelReport,
 } from "../../maestro/runtime/index.ts";
 import { loadSupervisionConfig } from "../../maestro/core/config/supervision-config.ts";
+import { loadSidebarConfig } from "../../maestro/core/config/sidebar-config.ts";
 import {
 	discoverAgentCatalog as discoverCoreAgentCatalog,
 	ROLE_PACK_DISCOVERY_EVENT,
@@ -60,9 +63,17 @@ import { wrapPiModelRegistry } from "./model-registry.ts";
 import {
 	loadModelConfig,
 	MISSING_CONFIG_REVISION,
+	parseRankingBasis,
+	readModelConfigSnapshot,
 	resolveModelDefault,
 	writeTaskModelConfig,
 } from "../../maestro/core/config/model-config.ts";
+import {
+	type OfferCallback,
+	type TaskModelBrief,
+	TASK_MODEL_INIT_APPROVAL_EVENT,
+	TASK_MODEL_INIT_START_EVENT,
+} from "../../maestro/core/config/task-model-init.ts";
 import {
 	TASK_CATEGORIES,
 	TASK_CATEGORY_DESCRIPTIONS,
@@ -98,6 +109,7 @@ import { isSubagentActivityScope } from "../../maestro/core/activity.ts";
 import type { SubagentActivityState } from "../../maestro/core/types.ts";
 import {
 	isFiniteNumber,
+	isFunction,
 	isPlainObject,
 	isString,
 } from "../../maestro/core/config/type-guards.ts";
@@ -344,6 +356,47 @@ function discoverAgentDefinitions(
 	return discoverAgentCatalog(pi).agents;
 }
 
+/**
+ * Payload of TASK_MODEL_INIT_APPROVAL_EVENT. `context` is the live context of
+ * the command that started init. It passes between trusted in-process
+ * extensions and is current only while the request is emitted.
+ */
+interface TaskModelApprovalRequest {
+	apiVersion: 1;
+	brief: TaskModelBrief;
+	context: ExtensionCommandContext;
+	offer: OfferCallback;
+}
+
+function hasMethods(value: any, names: readonly string[]): boolean {
+	return value != null && names.every((name) => isFunction(value[name]));
+}
+
+/**
+ * Read a TASK_MODEL_INIT_START_EVENT v1 payload. A v1 request whose context or
+ * preferences cannot run init still gets an offer, so its emitter reports why
+ * instead of concluding that no host is loaded.
+ */
+function parseInitStartRequest(raw: any):
+	| {
+			offer: OfferCallback;
+			input?: { context: ExtensionCommandContext; preferences: string };
+	  }
+	| undefined {
+	if (raw?.apiVersion !== 1 || !isFunction(raw.offer)) return undefined;
+	const { offer, context, preferences } = raw;
+	const usable =
+		isString(preferences) &&
+		hasMethods(context, ["isIdle", "hasPendingMessages"]) &&
+		hasMethods(context.modelRegistry, ["getAvailable"]);
+	return {
+		offer: (value) => offer.call(raw, value),
+		// The members init reads were checked above; the rest is the emitting
+		// command's own live context.
+		input: usable ? { context, preferences } : undefined,
+	};
+}
+
 function missingRoleMessage(agentName: string): string {
 	return `Agent "${agentName}" was not found. pi-herdr-agents ships no roles: define it in .pi/agents or the global agents directory, install a role pack that provides it, or omit agent for a bare launch.`;
 }
@@ -521,6 +574,10 @@ const supervisionConfig = loadSupervisionConfig(
 	getSubagentsConfigDir(),
 	getSubagentsConfigExamplePath(),
 );
+const sidebarConfig = loadSidebarConfig(
+	getSubagentsConfigDir(),
+	getSubagentsConfigExamplePath(),
+);
 
 const MAX_RESULT_PRESENTATION_CHARS = 16_000;
 const MAX_SESSION_REFERENCE_CHARS = 10_000;
@@ -2395,6 +2452,7 @@ export default function subagentsExtension(
 			configExamplePath: getSubagentsConfigExamplePath(),
 			roles: [],
 			forcePolling: supervisionConfig.forcePolling,
+			sidebarMarkers: sidebarConfig.enabled,
 			infrastructure: options.infrastructure,
 			getLaunchSnapshot() {
 				const ctx = runtime.latestCtx;
@@ -2616,7 +2674,7 @@ export default function subagentsExtension(
 		pi.registerTool({
 			name: "subagents_write_task_models",
 			label: "Write task model preferences",
-			description: `Validate and atomically replace models.tasks and models.tasksMeta in the durable Pi agent config, preserving unrelated settings. Supported categories: ${TASK_CATEGORIES.join(", ")}. Partial nonempty categories are accepted; omitted categories are removed. Rejects duplicate exact refs within a category. Review the active authenticated registry and existing preferences first. Optional expectedConfigRevision makes the write conditional: it fails without replacing configuration when the config file no longer matches the revision the proposal was read from. Cooperating writes are serialized and fail on contention rather than waiting. Returns normalized saved preferences, missing categories, and the configRevision of the written file; reload required.`,
+			description: `Validate and atomically replace models.tasks and models.tasksMeta in the durable Pi agent config, preserving unrelated settings. Supported categories: ${TASK_CATEGORIES.join(", ")}. Partial nonempty categories are accepted; omitted categories are removed. Rejects duplicate exact refs within a category. Review the active authenticated registry and existing preferences first. Optional expectedConfigRevision makes the write conditional: it fails without replacing configuration when the config file no longer matches the revision the proposal was read from. Optional basis records what the ranking rests on; its kind must equal tasksMeta.method, and it is returned but not saved. Cooperating writes are serialized and fail on contention rather than waiting. Returns normalized saved preferences, missing categories, the configRevision of the written file, and any basis; reload required.`,
 			parameters: Type.Object({
 				tasks: Type.Object(
 					Object.fromEntries(
@@ -2650,6 +2708,37 @@ export default function subagentsExtension(
 						},
 					),
 				),
+				basis: Type.Optional(
+					Type.Union(
+						[
+							Type.Object(
+								{ kind: Type.Literal("registry-only") },
+								{ additionalProperties: false },
+							),
+							Type.Object(
+								{
+									kind: Type.Literal("research"),
+									sources: Type.Array(
+										Type.Object(
+											{
+												url: Type.String({ minLength: 1 }),
+												influence: Type.String({ minLength: 1 }),
+											},
+											{ additionalProperties: false },
+										),
+										{ minItems: 1 },
+									),
+									uncertainty: Type.String({ minLength: 1 }),
+								},
+								{ additionalProperties: false },
+							),
+						],
+						{
+							description:
+								'What the ranking rests on, as submitted by the proposer and not independently verified: {"kind":"registry-only"}, or {"kind":"research"} with the http(s) sources consulted in this run, how each informed the ranking, and the remaining uncertainty. kind must equal tasksMeta.method. Not saved. Omit for a legacy write.',
+						},
+					),
+				),
 			}),
 			execute: async (_id, params, _signal, _update, ctx) => {
 				const registry = wrapPiModelRegistry(ctx.modelRegistry);
@@ -2657,6 +2746,10 @@ export default function subagentsExtension(
 				const tasks = params.tasks as TaskPreferences;
 				// SAFETY: TypeBox validates the tool payload; the write seam performs stricter schema validation.
 				const tasksMeta = params.tasksMeta as TaskPreferencesMeta;
+				// Present-but-invalid values (including null) fail before anything is written.
+				const basis = Object.hasOwn(params, "basis")
+					? parseRankingBasis(params.basis, tasksMeta.method)
+					: undefined;
 				const saved = writeTaskModelConfig(
 					getSubagentsConfigPath(),
 					getSubagentsConfigExamplePath(),
@@ -2673,14 +2766,15 @@ export default function subagentsExtension(
 						? { expectedConfigRevision: params.expectedConfigRevision }
 						: {},
 				);
+				const details = basis ? { ...saved, basis } : saved;
 				return {
 					content: [
 						{
 							type: "text",
-							text: `Wrote task model preferences. Reload required.\n${JSON.stringify(saved, null, 2)}`,
+							text: `Wrote task model preferences. Reload required.\n${JSON.stringify(details, null, 2)}`,
 						},
 					],
-					details: saved,
+					details,
 				};
 			},
 		});
@@ -3327,21 +3421,73 @@ export default function subagentsExtension(
 			},
 		});
 
-	if (!process.env.PI_SUBAGENT_ID)
+	if (!process.env.PI_SUBAGENT_ID) {
+		const runTaskModelInit = (
+			ctx: ExtensionCommandContext,
+			preferences: string,
+		): TaskModelInitOutcome => {
+			if (!ctx.isIdle() || ctx.hasPendingMessages())
+				return {
+					kind: "not-started",
+					reason:
+						"a turn is in progress or messages are queued. Nothing was queued; retry when idle",
+				};
+			// Pi refuses a prompt without a model only after submission; refuse first.
+			if (!ctx.model)
+				return {
+					kind: "not-started",
+					reason:
+						"no model is selected, so Pi cannot run the init prompt. Select a model, then retry",
+				};
+			return startTaskModelInit({
+				preferences,
+				readConfig: () => readModelConfigSnapshot(getSubagentsConfigDir()),
+				projectActiveRegistry: (project) => project(ctx.modelRegistry),
+				emitApprovalRequest: (brief, offer) =>
+					pi.events.emit(
+						TASK_MODEL_INIT_APPROVAL_EVENT,
+						Object.freeze({
+							apiVersion: 1,
+							brief,
+							context: ctx,
+							offer,
+						} satisfies TaskModelApprovalRequest),
+					),
+				isToolActive: (name) => pi.getActiveTools().includes(name),
+				submit: (prompt) => pi.sendUserMessage(prompt),
+			});
+		};
 		pi.registerCommand("subagents-init", {
 			description:
 				"Draft task-category model preferences from the live registry; optional arguments set ranking preferences",
 			handler: async (args, ctx) => {
-				const registry = ctx.modelRegistry;
-				const current = loadModelConfig(getSubagentsConfigDir());
-				const prompt = initializeTaskModels({
-					projectActiveRegistry: (project) => project(registry),
-					current,
-					preferences: args,
-				});
-				pi.sendUserMessage(prompt);
+				const outcome = runTaskModelInit(ctx, args);
+				if (outcome.kind === "not-started")
+					ctx.ui.notify(
+						`Task-model init not started: ${outcome.reason}. Nothing was written.`,
+						"warning",
+					);
 			},
 		});
+		// Another extension's command may start the same init; it renders the outcome.
+		const stopInitStart = pi.events.on(TASK_MODEL_INIT_START_EVENT, (raw) => {
+			const request = parseInitStartRequest(raw);
+			if (!request) return;
+			const { input } = request;
+			request.offer({
+				owner: "pi-herdr-agents",
+				start: (): TaskModelInitOutcome =>
+					input
+						? runTaskModelInit(input.context, input.preferences)
+						: {
+								kind: "not-started",
+								reason:
+									"the start request lacks a usable command context or preferences text",
+							},
+			});
+		});
+		pi.on("session_shutdown", () => stopInitStart());
+	}
 
 	pi.registerCommand("worktree", {
 		description: parentSession

package/plugins/sidebar/README.md

@@ -0,0 +1,242 @@
+# Pi Herdr Agents Sidebar
+
+![Pi Herdr Agents: a parent Pi session delegating to parallel child agents in dedicated Herdr panes, an isolated worktree and a retained session, with a live status widget.](https://raw.githubusercontent.com/giuseppecrj/pi-herdr-agents/main/docs/assets/pi-herdr-agents-gallery.png)
+
+> **Compatibility.** The npm release `pi-herdr-agents@3.1.0` predates sidebar support. Use a local checkout that contains this plugin and the `sidebar.enabled` setting, or a later release that includes both.
+
+An optional [Herdr](https://herdr.dev) plugin for [Pi Herdr Agents](../../README.md). It keeps your main agents easy to find in Herdr's Agents view while [Pi](https://github.com/earendil-works/pi) runs delegated children.
+
+The plugin adds two actions. The extension in the main package marks each delegated child's pane, and Focus hides the marked rows.
+
+## Features
+
+- **Focus.** Hides delegated Pi children from the Agents view, except blocked children and children whose status is unknown.
+- **All.** Removes Focus if this plugin set it, then shows every agent again. If another tool replaced the view, All leaves that view in place and reports which tool owns it.
+- **Display only.** Neither action closes, moves, or signals anything. Hidden children keep running, keep their panes, and still raise notifications. `herdr agent list` still lists them.
+- **No automatic Focus.** Installing, linking, or enabling the plugin never turns Focus on. You invoke it.
+- **Opt-in markers.** The extension writes pane markers only when you set `sidebar.enabled` to `true`.
+
+## Requirements
+
+- Herdr `0.9.2-preview.2026-09-29-8e78f929d8f0`, the only build the plugin was tested on. Herdr accepts only a plain version in `min_herdr_version` and reports this preview as `0.9.2`, so the manifest declares `0.9.2`. Herdr then also accepts other 0.9.2 builds and newer ones, all untested. A build without the agent view API makes Focus and All fail with Herdr's error.
+- Linux. The extension identifies child processes through `/proc`, so it marks nothing on other systems, and the manifest declares only `linux`.
+- `node` on the `PATH` of the Herdr server. Herdr runs the actions as `node sidebar.mjs focus` and `node sidebar.mjs all`.
+- The `pi-herdr-agents` extension, installed in Pi from a revision that supports `sidebar.enabled`, with that setting turned on. Without markers, Focus hides nothing.
+
+## Install
+
+Setup has two parts. Install the Herdr plugin, then enable markers in a compatible Pi extension. The plugin alone hides nothing, and the setting alone adds no actions.
+
+### 1. Install the Herdr plugin
+
+Review the plugin source, then link its directory from your local checkout:
+
+```bash
+herdr plugin link /path/to/pi-herdr-agents/plugins/sidebar
+```
+
+Once the GitHub default branch contains `plugins/sidebar`, you can install the subdirectory instead. Herdr shows the manifest and commands for review:
+
+```bash
+herdr plugin install giuseppecrj/pi-herdr-agents/plugins/sidebar
+```
+
+For another published branch, tag, or commit, add `--ref` followed by that revision. The revision must contain the plugin directory.
+
+### 2. Turn on markers in the Pi extension
+
+The Pi extension must also contain sidebar support. If you do not already load a compatible copy, install the same local checkout in Pi:
+
+```bash
+pi install /path/to/pi-herdr-agents
+```
+
+Use `pi list` to check your existing package sources. If another copy of Pi Herdr Agents is enabled, disable that copy with `pi config` before loading the checkout. Do not load both copies. Start Pi inside Herdr.
+
+1. Open `$PI_CODING_AGENT_DIR/herdr-agents/config.json`. The default is `~/.pi/agent/herdr-agents/config.json`.
+2. If the file does not exist, copy `config.json.example` from the extension there first. The extension rejects a `config.json` without its `status` section.
+3. Merge the `sidebar` section into the file. Keep the existing `status`, `models`, and other sections. Do not replace the file.
+
+   ```json
+   {
+     "sidebar": {
+       "enabled": true
+     }
+   }
+   ```
+
+4. Run `/reload` in each parent Pi session, or start a new one.
+5. Launch new children. Children that were already running stay unmarked.
+6. Invoke Focus yourself. See [Use Focus and All](#use-focus-and-all).
+
+### Check the result
+
+After you launch a new child and run Focus, a marked child with status `idle`, `working`, or `done` disappears from the Agents view while your main session stays. Blocked children remain visible. Run All to show the hidden row again. If nothing changes, read the action log:
+
+```bash
+herdr plugin log list --plugin pi-herdr-agents.sidebar
+```
+
+## Contents
+
+- [Requirements](#requirements), [Install](#install), [Use Focus and All](#use-focus-and-all)
+- [Troubleshooting](#troubleshooting), [Safety](#safety), [Uninstall](#uninstall)
+- [Which rows Focus hides](#which-rows-focus-hides), [What a marker proves](#what-a-marker-proves), [Reusing a delegated pane](#reusing-a-delegated-pane), [Limits](#limits)
+- Main package: [Pi Herdr Agents](../../README.md) and its [sidebar markers](../../README.md#sidebar-markers) setting
+
+## Use Focus and All
+
+Run an action from the command line:
+
+```bash
+herdr plugin action invoke pi-herdr-agents.sidebar.focus
+herdr plugin action invoke pi-herdr-agents.sidebar.all
+```
+
+To bind a key, add an entry like this to your Herdr config and pick a key you do not already use:
+
+```toml
+[[keys.command]]
+key = "prefix+g"
+type = "plugin_action"
+command = "pi-herdr-agents.sidebar.focus"
+description = "hide delegated Pi children"
+```
+
+Herdr keeps one agent view for the whole server. Focus replaces the view that was active, including a view that another tool set. All sends its clear with this plugin as the source, so Herdr clears the view only if this plugin owns it. If another tool replaced Focus, All leaves that view in place and reports which tool owns it.
+
+Each action writes one message to its log. Read it with `herdr plugin log list --plugin pi-herdr-agents.sidebar`. The exit status tells you what happened:
+
+| Exit status | Meaning |
+| --- | --- |
+| `0` | Focus is on, or All found no view left. |
+| `1` | The action failed. Herdr refused the request, sent no usable reply within 3 seconds, or still reports this plugin's view after All. The action also fails when it runs outside Herdr or as another plugin. The message names the cause. |
+| `2` | The action name was not `focus` or `all`. |
+| `3` | All left another tool's view in place. |
+
+A Herdr server restart drops the view and every marker. The plugin has no startup hook, so run Focus again after a restart if you want it.
+
+## Troubleshooting
+
+- **A child you expect to be hidden is still visible.** Check that `sidebar.enabled` is `true`, that you ran `/reload` in the parent, and that the child was launched after the reload. Then run Focus again. A blocked child or a child with unknown status is always shown.
+- **A row you expect is missing.** Run All. Markers change only what the Agents view shows.
+- **Focus or All exits with status `1`.** Read the log with the command above. The message names the cause, such as a Herdr build without the agent view API.
+- **All exits with status `3`.** Another tool owns the view. All leaves it in place.
+- **A new agent in a delegated pane is hidden.** See [Reusing a delegated pane](#reusing-a-delegated-pane).
+
+## Safety
+
+- Markers are display only. They are not a security boundary.
+- The plugin sends requests to your local Herdr server. It does not close, move, or signal panes.
+- With `sidebar.enabled` on, the parent records each child's process identity and reports one pane token, `piha_delegated_v1`, through the Herdr socket. With it off, the extension writes no pane metadata. See [Safety and uninstall](../../README.md#safety-and-uninstall) in the main README.
+
+## Uninstall
+
+1. Run All, or skip this step. Herdr also drops this plugin's view when you disable, unlink, or uninstall the plugin.
+2. Remove the plugin. Use `uninstall` for a GitHub install and `unlink` for a linked directory:
+
+   ```bash
+   herdr plugin uninstall pi-herdr-agents.sidebar
+   herdr plugin unlink pi-herdr-agents.sidebar
+   ```
+
+3. Set `sidebar.enabled` to `false`, or delete the `sidebar` key, and run `/reload` in each parent session. The reload clears the markers of children that are still running and stops renewing them. A marker whose clear does not reach Herdr expires within 15 seconds.
+
+## Which rows Focus hides
+
+The extension writes the pane token `piha_delegated_v1` with the value `live`
+on a delegated child's pane. Focus hides a row only when that token is `live`
+and the agent status is `idle`, `working`, or `done`. Focus sends this
+filter, with no sort:
+
+```json
+{
+  "op": "not",
+  "filter": {
+    "op": "all",
+    "filters": [
+      { "op": "eq", "field": { "token": "piha_delegated_v1" }, "value": "live" },
+      { "op": "in", "field": "status", "values": ["idle", "working", "done"] }
+    ]
+  }
+}
+```
+
+| Agent | Marker | Focus |
+| --- | --- | --- |
+| Main session or manually started agent | none | shown |
+| `/worktree` handoff session | none | shown |
+| Delegated child: fresh, resumed, persistent, or in a managed worktree | `live` | hidden |
+| Delegated child that Herdr reports as blocked | `live` | shown |
+| Agent whose status is unknown | any | shown |
+| Pane with a missing marker or any other value | missing or other | shown |
+| Retained worktree shell after its child exits | cleared | shown |
+
+The `done` status means idle and not yet seen. It does not mean that anyone
+accepted the child's work, so Focus hides it like any idle child.
+
+## What a marker proves
+
+A `live` marker means the extension classified the pane's process as a
+delegated child within the last 15 seconds. It does not prove that the same
+process occupies the pane when Herdr draws the row.
+
+The parent Pi session writes the marker after its child records its own
+process identity and the parent verifies it. The parent renews the marker every
+4 to 5 seconds while that exact process (PID and start time) is alive. Renewal
+runs on the parent's existing supervision checks, so if those checks stall,
+the marker expires and the child reappears. The parent clears the marker when
+the child finishes, when it stops supervising the child, or when it finds that
+process gone or unverifiable. The marker belongs to the pane, not to the process.
+Renewal checks only the original process, so a different process in the same
+pane can be hidden for as long as the original process stays alive and
+supervised. See [Reusing a delegated pane](#reusing-a-delegated-pane).
+
+Each write carries a 15-second time-to-live and a sequence number that
+increases across all of a parent's writes. The 15-second guarantee counts from
+the last write Herdr accepted. It does not restart when the pane's occupant
+changes or the original process is suspended. Herdr ignores a write whose
+sequence number is not higher than the last one it applied, so a delayed
+renewal cannot undo a clear. The extension does not retry a failed write and
+stops writing after three failures in a row.
+
+Some leftover markers still occur:
+
+- If the parent process exits or crashes, its last marker stays until its
+  time-to-live ends, up to 15 seconds after the last write Herdr applied.
+- A renewal that Herdr processes late starts a new 15-second period, unless a
+  clear with a higher sequence number has already arrived.
+- A new agent started in the same pane during that window stays hidden by
+  Focus until the marker expires.
+- If the parent restarts while the same Herdr server keeps running, and the
+  system clock has moved backwards, the new parent's sequence numbers can fall
+  behind the last ones Herdr applied. Herdr then ignores its writes until the
+  clock catches up. A Herdr server restart resets the sequence state and drops
+  every marker.
+
+Run All whenever a row you expect is missing. Markers change only what the
+Agents view shows. They are not a security boundary.
+
+### Reusing a delegated pane
+
+The marker follows the pane, and the parent keeps renewing it while the
+original child process is alive and supervised. A child suspended with Ctrl-Z
+is still alive, so if you start another agent in that pane by hand, Focus can
+hide the new agent until the original child is stopped or no longer
+supervised. Run All before you reuse a delegated pane, or start the new agent
+in a fresh pane. To end renewal, stop the child with the host's normal
+controls. The last marker then lasts at most 15 seconds after the last write
+Herdr accepted. The first version of the plugin has this limitation, and no
+fix for pane reuse is planned for it.
+
+## Limits
+
+- Tested only on Linux with the Herdr build named above, one local server, and
+  one attached client. Remote machines and several attached clients are
+  untested.
+- The marker follows the pane, not the process. See
+  [Reusing a delegated pane](#reusing-a-delegated-pane).
+- Herdr allows at most 32 sequenced metadata sources per pane. The extension
+  uses the single source `pi-herdr-agents` for every marker.
+- The plugin has no popup, settings, or startup hook, and it does not hide
+  workspaces or notifications.

package/plugins/sidebar/herdr-plugin.toml

@@ -0,0 +1,21 @@
+id = "pi-herdr-agents.sidebar"
+name = "Pi Herdr Agents Sidebar"
+version = "0.1.0"
+# Tested only on 0.9.2-preview.2026-09-29-8e78f929d8f0. Herdr accepts only a
+# plain version here and reports that preview as 0.9.2, so any 0.9.2 build,
+# including a stable one, passes this check untested. See README.md.
+min_herdr_version = "0.9.2"
+description = "Hide delegated Pi children from the Agents view (Focus) or show every agent (All)"
+platforms = ["linux"]
+
+[[actions]]
+id = "focus"
+title = "Pi agents: Focus (hide delegated children)"
+contexts = ["global"]
+command = ["node", "sidebar.mjs", "focus"]
+
+[[actions]]
+id = "all"
+title = "Pi agents: All (show every agent)"
+contexts = ["global"]
+command = ["node", "sidebar.mjs", "all"]