@spencerboucher/switchyard 0.4.0 → 0.6.0

package/README.md

@@ -13,7 +13,7 @@ flowchart TB
   subgraph clients["Clients: windows onto the same work"]
     phone["Phone<br/>(installable web app)"]
     browser["Desktop browser"]
-    term["Terminal client and CLI"]
+    term["Pi terminal and CLI"]
   end
 
   coord["<b>Coordinator</b><br/>tasks, schedules, notifications,<br/>sign-in, sync<br/><i>never runs code</i>"]
@@ -37,7 +37,7 @@ There are three kinds of parts:
 
 - **The coordinator** is the one always-on service. It keeps tasks, schedules, notifications, devices and the shared view of every session, and it decides what runs where. It never runs an agent and never holds your provider credentials, so it can live anywhere: a container, a small server, or your laptop.
 - **Hosts** are your machines. A host agent runs Pi as your OS user, with your repositories, worktrees, Pi packages and model logins, and connects *outbound* to the coordinator. A host needs no open ports, and a laptop can come and go: its sessions keep running while the coordinator is down, and the events catch up when it returns.
-- **Clients** are views. The web app works on desktop and as an installed app on a phone; the terminal client and the scriptable CLI work over the same API. Any client can watch, answer and steer a session; none of them owns it.
+- **Clients** are views. The web app works on desktop and as an installed app on a phone; in a terminal you get Pi's own TUI for any session (`switchyard tui`, or a whole herdr session mirroring Switchyard), and the scriptable CLI works over the same API. Any client can watch, answer and steer a session; none of them owns it.
 
 For a single machine, `switchyard up` runs the coordinator and a host in one process. For more, run the coordinator as a server and enroll each machine as a host. The protocol is the same either way.
 
@@ -76,7 +76,7 @@ sequenceDiagram
 
 | Area | What you get |
 |---|---|
-| **Sessions** | Persistent Pi conversations on any host; the same live session in every client; steer or queue follow-ups; take over and return to automation; resume after crashes with the same conversation (never a silent new one); import existing Pi sessions |
+| **Sessions** | Persistent Pi conversations on any host; the same live session in every client; steer or queue follow-ups; take over and return to automation; resume after crashes with the same conversation (never a silent new one); import existing Pi sessions; switch model and effort, see context use and compact, a slash-command picker |
 | **Workspaces** | A git worktree per task or session inside the repository, discovery of worktrees you made yourself, setup commands, removal that refuses to lose uncommitted or unmerged work, and project folders per host whose repositories are added automatically |
 | **Tasks and board** | Backlog, Ready, In progress, Review, Done; dependencies with cycle detection; priorities; per-project concurrency limits; a Now view explaining why queued work waits |
 | **Review** | Changed files and diffs on desktop and phone, line comments sent as one follow-up, request changes, accept |
@@ -100,6 +100,8 @@ sequenceDiagram
 | **Device** | A signed-in client: a browser, an installed web app or a terminal |
 | **Adapter** | Code that renders a specific Pi plugin's questions and state as structured UI |
 
+A seeded **Vanilla** profile runs stock Pi (no extensions, skills or prompt templates).
+
 ## Quick start
 
 **Try it on one machine** (Node 24 or newer, git, and Pi 1.4 or 1.5 on your PATH):
@@ -116,7 +118,7 @@ switchyard up
 ```sh
 docker run -d --name switchyard -p 127.0.0.1:7400:7400 -v switchyard-data:/data \
   -e SWITCHYARD_PUBLIC_URL=https://switchyard.example.com \
-  ghcr.io/justmytwospence/switchyard:0.4.0
+  ghcr.io/justmytwospence/switchyard:0.6.0
 docker exec switchyard switchyard init    # prints a single-use sign-in link for your first device
 ```
 
@@ -154,7 +156,8 @@ Switchyard is young and moving quickly. It is tested against Pi `>=1.4.0 <1.6.0`
 |---|---|
 | [Deployment](docs/deployment.md) | Single machine, server, reverse proxies, VPNs, hosts, environment reference, privilege model |
 | [Sign-in and devices](docs/auth.md) | The owner model, pairing, passkeys, single sign-on, host enrollment, revocation |
-| [CLI and terminal client](docs/cli.md) | Every `switchyard` command, credentials, terminal key bindings |
+| [CLI](docs/cli.md) | Every `switchyard` command and credentials |
+| [Terminal sessions](docs/terminal-sessions.md) | Pi's own TUI for every session, from any terminal, and the herdr integration |
 | [Operations](docs/operations.md) | Backup, restore, migrations, retention, logs, health, diagnostics |
 | [Adapters](docs/adapters.md) | Rendering a Pi plugin's UI in every client; shipping an adapter with your Pi package |
 | [Architecture](docs/architecture.md) | Components, data ownership, the host and client protocols, packages |

package/dist/bridge/pi-model.js

@@ -0,0 +1,44 @@
+/**
+ * Model and thinking-level helpers shared by the Switchyard Pi extensions and `ManagedSession`.
+ * Imports nothing, so it can be loaded by Pi next to the extensions.
+ */
+/** Pi 1.4's thinking levels (pi-ai EXTENDED_THINKING_LEVELS), in order. */
+export const PI_THINKING_LEVELS = [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+/** Pi 1.4 `getSupportedThinkingLevels` (pi-ai dist/models.js:693); passes through an already-mapped `thinkingLevels`. */
+export function supportedThinkingLevels(model) {
+    const known = PI_THINKING_LEVELS;
+    if (Array.isArray(model?.thinkingLevels)) {
+        return model.thinkingLevels.filter((l) => typeof l === "string" && known.includes(l));
+    }
+    if (!model?.reasoning)
+        return ["off"];
+    return PI_THINKING_LEVELS.filter((level) => {
+        const mapped = model.thinkingLevelMap?.[level];
+        if (mapped === null)
+            return false;
+        if (level === "xhigh" || level === "max")
+            return mapped !== undefined;
+        return true;
+    });
+}
+export function modelInfo(model) {
+    if (!model || typeof model.provider !== "string" || typeof model.id !== "string")
+        return null;
+    return {
+        provider: model.provider,
+        id: model.id,
+        name: typeof model.name === "string" && model.name ? model.name : null,
+        contextWindow: typeof model.contextWindow === "number" ? model.contextWindow : null,
+        reasoning: model.reasoning === true,
+        thinkingLevels: supportedThinkingLevels(model),
+    };
+}
+//# sourceMappingURL=pi-model.js.map

package/dist/bridge/switchyard-bridge.js

@@ -8,6 +8,7 @@
  * never throws: any socket error disables forwarding for the rest of the process.
  */
 import { createConnection } from "node:net";
+import { modelInfo } from "./pi-model.js";
 export default function switchyardBridge(pi) {
     const socketPath = process.env.SWITCHYARD_BRIDGE_SOCKET;
     if (!socketPath)
@@ -46,8 +47,9 @@ export default function switchyardBridge(pi) {
             return null;
         }
     };
-    const send = (s, msg) => {
+    const send = (s, msg, extra = {}) => {
         const full = {
+            ...extra,
             type: msg.type,
             ...(msg.kind !== undefined ? { kind: msg.kind } : {}),
             title: msg.title ?? null,
@@ -77,15 +79,35 @@ export default function switchyardBridge(pi) {
             disabled = true;
         }
     };
+    const sendModelState = (ctx) => {
+        try {
+            const s = ensureSocket();
+            if (!s)
+                return;
+            send(s, { type: "model_state" }, {
+                model: modelInfo(ctx?.model),
+                thinkingLevel: ctx?.thinkingLevel ?? null,
+                scoped: (ctx?.scopedModels ?? [])
+                    .map((s) => s?.model?.provider && s?.model?.id ? `${s.model.provider}/${s.model.id}` : null)
+                    .filter(Boolean),
+            });
+        }
+        catch {
+            disabled = true;
+        }
+    };
     try {
-        pi.on("session_start", () => {
+        pi.on("session_start", (_event, ctx) => {
             try {
                 ensureSocket();
             }
             catch {
                 disabled = true;
             }
+            sendModelState(ctx);
         });
+        pi.on("model_select", (_event, ctx) => sendModelState(ctx));
+        pi.on("thinking_level_select", (_event, ctx) => sendModelState(ctx));
         pi.on("ui_prompt_start", forward);
         pi.on("ui_prompt_end", forward);
         pi.on("session_shutdown", () => {