@selesai/code 0.13.10 → 0.13.11

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.11] - 2026-09-02
+
+### Added
+- **RPC rev-4 `get_skills` command.** New RPC command returning the resolved skill catalog (one entry per discovered skill with its effective enablement) plus the raw merged `global + project` `settings.skills` patterns, so hosts can mirror the TUI `/skills` toggle surface without reimplementing `isEnabledByOverrides` semantics. Exposed on the typed client as `RpcClient.getSkills()`.
+- **RPC `working` loader parity.** `ctx.ui.setWorkingMessage()`, `setWorkingVisible()`, and `setWorkingIndicator()` now emit a fire-and-forget `extension_ui_request {method: "working"}` (message/visible/frames/intervalMs patch fields) instead of no-oping in RPC mode, so the host can render the streaming loader row.
+- **Herdr agent-state extension.** New bundled extension that reports session/lifecycle state (`working`/`blocked`/`idle`) plus session references to the Herdr pane over `HERDR_SOCKET_PATH`. Instance state lives inside the factory so successor sessions after `/new`, fork, resume, or reload keep reporting; only the monotonic `reportSeq` stays module-level to satisfy Herdr's per-source sequence guard.
+
+### Fixed
+- **handoff-new no longer fails session creation.** The `setup` callback read the session name from the (already replaced) extension ctx, throwing the stale-ctx error and aborting `newSession` with "Failed to create session". The name is now captured before `newSession()` and passed into `setup` as a plain value; the session name still carries over as before.
+
 ## [0.13.10] - 2026-09-02
 
 ### Added

package/dist/extensions/handoff-new.ts

@@ -108,12 +108,15 @@ async function handoffNew(args: string, ctx: ExtensionCommandContext) {
 		return;
 	}
 
+	// Read the name before newSession: the original ctx is invalidated once
+	// the session is replaced, so it cannot be read inside setup().
+	const sessionName = ctx.sessionManager.getSessionName();
+
 	const newSessionResult = await ctx.newSession({
 		parentSession: currentSessionFile,
 		// Carry the current session's name over to the new session as the starting point.
 		setup: (replacementManager) => {
-			const name = ctx.sessionManager.getSessionName();
-			if (name) replacementManager.appendSessionInfo(name);
+			if (sessionName) replacementManager.appendSessionInfo(sessionName);
 		},
 		withSession: async (replacementCtx) => {
 			await replacementCtx.sendUserMessage(result);

package/dist/extensions/herdr-agent-state.ts

@@ -0,0 +1,310 @@
+// adapted from herdr's pi integration (herdr/src/integration/assets/pi/herdr-agent-state.ts)
+// reports lifecycle state for selesai instead of pi: agent=selesai, source=herdr:selesai
+// HERDR_INTEGRATION_ID=selesai
+// HERDR_INTEGRATION_VERSION=2
+// @ts-nocheck
+//
+// Instance state lives inside the factory, not at module scope. Selesai caches
+// the extension module per cwd and re-invokes the factory for every session, so
+// a module-scoped `released`/`queuedState`/`sendInFlight` from a previous
+// session (handoff-new, auto-handoff, /new, resume, fork, reload) would make
+// every successor instance silently drop its state reports and leave the pane
+// stuck on the last reported state. Only the monotonic reportSeq stays
+// module-level: Herdr guards pane.report_agent per source by seq and drops
+// lower-seq reports, so the successor must never restart the counter below the
+// previous instance's high-water mark.
+
+import net from "node:net";
+
+const HERDR_ENV = process.env.HERDR_ENV;
+const socketPath = process.env.HERDR_SOCKET_PATH;
+const socketEndpoint =
+  process.platform === "win32" && socketPath ? `\\\\.\\pipe\\${socketPath}` : socketPath;
+const paneId = process.env.HERDR_PANE_ID;
+const source = "herdr:selesai";
+
+function enabled() {
+  return HERDR_ENV === "1" && !!socketPath && !!paneId;
+}
+
+function sendRequestAttempt(request: unknown, timeoutMs: number): Promise<boolean> {
+  if (!enabled()) {
+    return Promise.resolve(true);
+  }
+
+  return new Promise((resolve) => {
+    let done = false;
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    const finish = (delivered: boolean) => {
+      if (done) return;
+      done = true;
+      if (timeout) {
+        clearTimeout(timeout);
+      }
+      socket.destroy();
+      resolve(delivered);
+    };
+
+    const socket = net.createConnection(socketEndpoint!);
+    socket.on("error", () => finish(false));
+    socket.on("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+    socket.on("data", () => finish(true));
+    socket.on("end", () => finish(false));
+    timeout = setTimeout(() => finish(false), timeoutMs);
+    timeout.unref?.();
+  });
+}
+
+async function sendRequest(request: unknown): Promise<void> {
+  if (await sendRequestAttempt(request, 500)) {
+    return;
+  }
+  await sendRequestAttempt(request, 1500);
+}
+
+type AgentState = "working" | "blocked" | "idle";
+
+type QueuedState = {
+  state: AgentState;
+  message?: string;
+  seq: number;
+};
+
+// Monotonic across all extension instances in this process. A per-session
+// restart below the previous instance's high-water mark would be dropped by
+// Herdr's per-source seq guard.
+let reportSeq = Date.now() * 1000;
+
+function nextReportSeq(): number {
+  reportSeq = Math.max(reportSeq + 1, Date.now() * 1000);
+  return reportSeq;
+}
+
+export default function (pi) {
+  if (!enabled()) {
+    return;
+  }
+
+  let currentAgentSessionId: string | undefined;
+  let currentAgentSessionPath: string | undefined;
+  let sendInFlight = false;
+  let queuedState: QueuedState | undefined;
+  let activeDrain: Promise<void> = Promise.resolve();
+  let released = false;
+  let agentActive = false;
+  let blockedCount = 0;
+  let blockedMessage: string | undefined;
+  let lastState: AgentState | undefined;
+  let lastMessage: string | undefined;
+  let rootSession = false;
+
+  function updateSessionRef(ctx: any): void {
+    try {
+      const file = ctx?.sessionManager?.getSessionFile?.();
+      currentAgentSessionPath =
+        typeof file === "string" && file.startsWith("/") ? file : undefined;
+    } catch {
+      currentAgentSessionPath = undefined;
+    }
+
+    try {
+      const id = ctx?.sessionManager?.getSessionId?.();
+      currentAgentSessionId = typeof id === "string" && id.length > 0 ? id : undefined;
+    } catch {
+      currentAgentSessionId = undefined;
+    }
+  }
+
+  function withSessionRef(params: Record<string, unknown>): Record<string, unknown> {
+    if (currentAgentSessionPath) {
+      return { ...params, agent_session_path: currentAgentSessionPath };
+    }
+    if (currentAgentSessionId) {
+      return { ...params, agent_session_id: currentAgentSessionId };
+    }
+    return params;
+  }
+
+  function currentSessionRef(): Record<string, unknown> | undefined {
+    if (currentAgentSessionPath) {
+      return { agent_session_path: currentAgentSessionPath };
+    }
+    if (currentAgentSessionId) {
+      return { agent_session_id: currentAgentSessionId };
+    }
+    return undefined;
+  }
+
+  function reportSession(sessionStartSource?: string): Promise<void> {
+    const sessionRef = currentSessionRef();
+    if (!sessionRef) {
+      return Promise.resolve();
+    }
+
+    return sendRequest({
+      id: `${source}:session:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+      method: "pane.report_agent_session",
+      params: {
+        pane_id: paneId,
+        source,
+        agent: "selesai",
+        seq: nextReportSeq(),
+        session_start_source: sessionStartSource,
+        ...sessionRef,
+      },
+    });
+  }
+
+  function sendState(state: AgentState, message?: string, seq = nextReportSeq()): Promise<void> {
+    return sendRequest({
+      id: `${source}:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+      method: "pane.report_agent",
+      params: withSessionRef({
+        pane_id: paneId,
+        source,
+        agent: "selesai",
+        state,
+        message,
+        seq,
+      }),
+    });
+  }
+
+  function queueState(state: AgentState, message?: string): void {
+    if (released) {
+      // The pane was released on quit; a late report would reclaim it and
+      // leave Herdr showing an agent that already exited.
+      return;
+    }
+    queuedState = { state, message, seq: nextReportSeq() };
+    if (!sendInFlight) {
+      activeDrain = drainStateQueue();
+    }
+  }
+
+  async function drainStateQueue(): Promise<void> {
+    if (sendInFlight) {
+      return;
+    }
+
+    sendInFlight = true;
+    try {
+      while (queuedState) {
+        const next = queuedState;
+        queuedState = undefined;
+        await sendState(next.state, next.message, next.seq);
+      }
+    } finally {
+      sendInFlight = false;
+      if (queuedState) {
+        activeDrain = drainStateQueue();
+      }
+    }
+  }
+
+  async function releaseAgent(): Promise<void> {
+    // Stop new reports, drop anything still queued, and wait for the in-flight
+    // send to finish so the release is the last write on the wire; a report
+    // landing after the release would reclaim the pane.
+    released = true;
+    queuedState = undefined;
+    await activeDrain.catch(() => undefined);
+    return sendRequest({
+      id: `${source}:release:${Date.now()}:${Math.random().toString(36).slice(2)}`,
+      method: "pane.release_agent",
+      params: {
+        pane_id: paneId,
+        source,
+        agent: "selesai",
+        seq: nextReportSeq(),
+      },
+    });
+  }
+
+  function desiredState() {
+    if (blockedCount > 0) {
+      return { state: "blocked" as const, message: blockedMessage };
+    }
+    if (agentActive) {
+      return { state: "working" as const, message: undefined };
+    }
+    return { state: "idle" as const, message: undefined };
+  }
+
+  function publishState(force = false) {
+    const next = desiredState();
+    if (!force && next.state === lastState && next.message === lastMessage) {
+      return;
+    }
+    lastState = next.state;
+    lastMessage = next.message;
+    queueState(next.state, next.message);
+  }
+
+  pi.events.on("herdr:blocked", (data) => {
+    if (!rootSession) {
+      return;
+    }
+    if (!data?.active) {
+      blockedCount = Math.max(0, blockedCount - 1);
+      if (blockedCount === 0) {
+        blockedMessage = undefined;
+      }
+      publishState();
+      return;
+    }
+
+    blockedCount += 1;
+    blockedMessage = data.label;
+    publishState();
+  });
+
+  pi.on("session_start", async (event, ctx) => {
+    // TUI only: RPC/JSON/print modes are headless (no PTY herdr can display),
+    // and RPC still reports hasUI=true, so mode is the reliable gate.
+    if (ctx?.mode !== "tui") {
+      return;
+    }
+    rootSession = true;
+    updateSessionRef(ctx);
+    await reportSession(event?.reason);
+    // A reload can replace this extension mid-run without emitting another agent_start.
+    agentActive = ctx?.isIdle?.() === false;
+    publishState(true);
+  });
+
+  pi.on("agent_start", (_event, ctx) => {
+    if (!rootSession) {
+      return;
+    }
+    updateSessionRef(ctx);
+    void reportSession();
+    agentActive = true;
+    publishState();
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    if (!rootSession || ctx?.isIdle?.() !== true) {
+      return;
+    }
+
+    agentActive = false;
+    publishState();
+  });
+
+  pi.on("session_shutdown", async (event) => {
+    if (!rootSession) {
+      return;
+    }
+    if (event?.reason !== "quit") {
+      // new/resume/fork/reload: a successor instance in this same pane
+      // re-reports immediately. Releasing here races that report, and a
+      // release landing after the successor's report clears the pane.
+      // Silence this instance so no stale queued report lands around it.
+      released = true;
+      queuedState = undefined;
+      return;
+    }
+    await releaseAgent();
+  });
+}

package/dist/extensions/package.json

@@ -15,6 +15,7 @@
 			"./question",
 			"./grep-app",
 			"./handoff-new.ts",
+			"./herdr-agent-state.ts",
 			"./inline-skills.ts",
 			"./rtk.ts",
 			"./tokenin-onboarding.ts",

package/dist/modes/rpc/rpc-client.d.ts

@@ -12,7 +12,7 @@ import type { BashResult } from "../../core/bash-executor.ts";
 import type { CompactionResult } from "../../core/compaction/index.ts";
 import type { SessionEntry, SessionTreeNode } from "../../core/session-manager.ts";
 import type { ChangelogEntry } from "../../utils/changelog.ts";
-import type { RpcSessionInfo, RpcSessionState, RpcSlashCommand } from "./rpc-types.ts";
+import type { RpcSessionInfo, RpcSessionState, RpcSkillInfo, RpcSlashCommand } from "./rpc-types.ts";
 export interface RpcClientOptions {
     /** Path to the CLI entry point (default: searches for dist/cli.js) */
     cliPath?: string;
@@ -286,6 +286,14 @@ export declare class RpcClient {
      * Get available commands (extension commands, prompt templates, builtins).
      */
     getCommands(): Promise<RpcSlashCommand[]>;
+    /**
+     * Get the resolved skill catalog (per-skill enabled state) plus the raw
+     * global+project merged settings.skills patterns for round-trip toggling.
+     */
+    getSkills(): Promise<{
+        skills: RpcSkillInfo[];
+        patterns: string[];
+    }>;
     /**
      * Get settings for a scope ("global" | "project" | "effective", default "effective").
      */

package/dist/modes/rpc/rpc-client.js

@@ -411,6 +411,14 @@ export class RpcClient {
         const response = await this.send({ type: "get_commands" });
         return this.getData(response).commands;
     }
+    /**
+     * Get the resolved skill catalog (per-skill enabled state) plus the raw
+     * global+project merged settings.skills patterns for round-trip toggling.
+     */
+    async getSkills() {
+        const response = await this.send({ type: "get_skills" });
+        return this.getData(response);
+    }
     // =========================================================================
     // Settings
     // =========================================================================

package/dist/modes/rpc/rpc-mode.js

@@ -12,9 +12,9 @@
  */
 import * as crypto from "node:crypto";
 import { spawnSync } from "node:child_process";
-import { chmodSync, copyFileSync, existsSync, unlinkSync } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, readFileSync, unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { basename, dirname, join, relative } from "node:path";
 import { generateHandoff } from "../../core/handoff.js";
 import { buildGitCommandPrompt } from "../../core/git-command.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
@@ -27,7 +27,8 @@ import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
 import { createSyntheticSourceInfo } from "../../core/source-info.js";
 import { killTrackedDetachedChildren } from "../../utils/shell.js";
 import { getChangelogPath, parseChangelog } from "../../utils/changelog.js";
-import { VERSION, getAgentDir, getBundledDefaultsDir, getShareViewerUrl } from "../../config.js";
+import { parseFrontmatter } from "../../utils/frontmatter.js";
+import { VERSION, CONFIG_DIR_NAME, getAgentDir, getBundledDefaultsDir, getShareViewerUrl } from "../../config.js";
 import { openBrowser } from "../../utils/open-browser.js";
 import { theme } from "../interactive/theme/theme.js";
 import { getAvailableThemesWithPaths, setRegisteredThemes } from "../interactive/theme/theme.js";
@@ -164,14 +165,34 @@ export async function runRpcMode(runtimeHost) {
                 statusText: text,
             });
         },
-        setWorkingMessage(_message) {
-            // Working message not supported in RPC mode - requires TUI loader access
+        setWorkingMessage(message) {
+            // Fire and forget - host renders the working loader row
+            output({
+                type: "extension_ui_request",
+                id: crypto.randomUUID(),
+                method: "working",
+                ...(message !== undefined ? { message } : {}),
+            });
         },
-        setWorkingVisible(_visible) {
-            // Working visibility not supported in RPC mode - requires TUI loader access
+        setWorkingVisible(visible) {
+            // Fire and forget - host shows/hides the working loader row
+            output({
+                type: "extension_ui_request",
+                id: crypto.randomUUID(),
+                method: "working",
+                visible,
+            });
         },
-        setWorkingIndicator(_options) {
-            // Working indicator customization not supported in RPC mode - requires TUI loader access
+        setWorkingIndicator(options) {
+            // Fire and forget - host customizes the working indicator. Custom frames only
+            // affect the normal streaming loader; compaction/retry keep built-in styling.
+            output({
+                type: "extension_ui_request",
+                id: crypto.randomUUID(),
+                method: "working",
+                ...(options?.frames !== undefined ? { frames: options.frames } : {}),
+                ...(options?.intervalMs !== undefined ? { intervalMs: options.intervalMs } : {}),
+            });
         },
         setHiddenThinkingLabel(_label) {
             // Hidden thinking label not supported in RPC mode - requires TUI message rendering access
@@ -880,6 +901,57 @@ export async function runRpcMode(runtimeHost) {
                 return success(id, "get_commands", { commands });
             }
             // =================================================================
+            // Skills (resolved catalog + raw toggle patterns)
+            // =================================================================
+            case "get_skills": {
+                const resolvedSkills = session.resourceLoader.getResolvedSkills();
+                const agentDir = getAgentDir();
+                const cwd = session.sessionManager.getCwd();
+                const skills = [];
+                // Mirror the TUI skill-toggle resolution (buildSkillToggleItems):
+                // name/pattern from the SKILL.md parent dir, scope from resource metadata,
+                // enabled per isEnabledByOverrides via the resource loader.
+                for (const resource of resolvedSkills) {
+                    const pathStr = resource.path;
+                    const isSkillFile = basename(pathStr) === "SKILL.md";
+                    const name = isSkillFile ? basename(dirname(pathStr)) : basename(pathStr);
+                    const scope = resource.metadata.scope === "project" ? "project" : "user";
+                    const baseDir = resource.metadata.baseDir ??
+                        (scope === "project" ? join(cwd, CONFIG_DIR_NAME) : agentDir);
+                    const pattern = relative(baseDir, pathStr) || name;
+                    let frontmatterName;
+                    let description;
+                    try {
+                        const raw = readFileSync(pathStr, "utf-8");
+                        const { frontmatter } = parseFrontmatter(raw);
+                        if (typeof frontmatter.name === "string" && frontmatter.name.trim()) {
+                            frontmatterName = frontmatter.name.trim();
+                        }
+                        if (typeof frontmatter.description === "string" && frontmatter.description.trim()) {
+                            description = frontmatter.description.trim();
+                        }
+                    }
+                    catch {
+                        // Unreadable skill file: keep path-derived name, no description.
+                    }
+                    skills.push({
+                        name: frontmatterName ?? name,
+                        description,
+                        scope: scope === "project" ? "project" : "global",
+                        pattern,
+                        enabled: resource.enabled,
+                    });
+                }
+                skills.sort((a, b) => a.name.localeCompare(b.name));
+                // Raw global+project merged settings.skills patterns so the caller can
+                // round-trip the exact write shape via set_settings + reload.
+                const patterns = [
+                    ...(session.settingsManager.getGlobalSettings().skills ?? []),
+                    ...(session.settingsManager.getProjectSettings().skills ?? []),
+                ];
+                return success(id, "get_skills", { skills, patterns });
+            }
+            // =================================================================
             // Settings
             // =================================================================
             case "get_settings": {

package/dist/modes/rpc/rpc-types.d.ts

@@ -257,6 +257,9 @@ export type RpcCommand = {
 } | {
     id?: string;
     type: "get_commands";
+} | {
+    id?: string;
+    type: "get_skills";
 };
 /** A command available for invocation via prompt */
 export interface RpcSlashCommand {
@@ -271,6 +274,19 @@ export interface RpcSlashCommand {
     /** True for interactive-TUI-only builtins that cannot be invoked via prompt */
     interactiveOnly?: boolean;
 }
+/** A resolved skill in the get_skills catalog (mirrors the TUI skill-toggle resolution). */
+export interface RpcSkillInfo {
+    /** Skill name (frontmatter name, falling back to the SKILL.md parent directory name). */
+    name: string;
+    /** Skill description from frontmatter. */
+    description?: string;
+    /** "global" for user-level skills, "project" for project-level skills. */
+    scope: "global" | "project";
+    /** Toggle pattern relative to the skill base dir (same shape the TUI writes to settings.skills). */
+    pattern: string;
+    /** Resolved enabled state per isEnabledByOverrides semantics. */
+    enabled: boolean;
+}
 /** Session listing entry (SessionInfo with transcript text stripped). */
 export interface RpcSessionInfo {
     path: string;
@@ -555,6 +571,15 @@ export type RpcResponse = {
     data: {
         commands: RpcSlashCommand[];
     };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_skills";
+    success: true;
+    data: {
+        skills: RpcSkillInfo[];
+        patterns: string[];
+    };
 } | {
     id?: string;
     type: "response";
@@ -843,6 +868,18 @@ export type RpcExtensionUIRequest = {
     id: string;
     method: "set_editor_text";
     text: string;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "working";
+    /** Working/loading message shown during streaming. Omit to restore the default. */
+    message?: string;
+    /** Show or hide the built-in working loader row during streaming. */
+    visible?: boolean;
+    /** Custom animation frames for the normal streaming loader. Empty array hides the indicator; omit to restore the default spinner. */
+    frames?: string[];
+    /** Frame interval in milliseconds for animated indicators. */
+    intervalMs?: number;
 };
 /** Response to an extension UI request */
 export type RpcExtensionUIResponse = {

package/docs/rpc.md

@@ -897,6 +897,38 @@ Each command has:
 
 **Note**: Built-in TUI commands (`/settings`, `/hotkeys`, etc.) are included with `source: "builtin"` and `interactiveOnly: true`. They are display-only: they are handled only in interactive mode and would not execute if sent via `prompt`.
 
+#### get_skills
+
+Get the resolved skill catalog (one entry per discovered skill with its effective enablement) plus the raw `settings.skills` patterns for round-trip toggling. Enables the extension to mirror the TUI `/skills` toggle surface without reimplementing `isEnabledByOverrides` semantics.
+
+```json
+{"type": "get_skills"}
+```
+
+Response:
+```json
+{
+  "type": "response",
+  "command": "get_skills",
+  "success": true,
+  "data": {
+    "skills": [
+      {"name": "fix-tests", "description": "Fix failing tests", "scope": "global", "pattern": "fix-tests", "enabled": true}
+    ],
+    "patterns": ["+fix-tests", "-legacy-skill"]
+  }
+}
+```
+
+Each skill entry has:
+- `name`: Skill name (frontmatter `name`, falling back to the SKILL.md parent directory name)
+- `description`: Frontmatter description (optional)
+- `scope`: `"global"` (user-level) or `"project"` (project-level)
+- `pattern`: Path relative to the skill base dir — the same pattern the TUI writes as `+pattern`/`-pattern` into `settings.skills`
+- `enabled`: Resolved enablement per `isEnabledByOverrides` semantics (package-manager.ts)
+
+`patterns` is the raw merged `global + project` `settings.skills` array. To toggle a skill, write `set_settings {scope, values:{skills:[...]}}` with `+pattern`/`-pattern` entries applied, then send `reload` (the TUI reloads after every toggle).
+
 ## Events
 
 Events are streamed to stdout as JSON lines during agent operation. Events do not generally include an `id` field; `bash_execution_update` includes the `id` of its originating `bash` command when one was provided.
@@ -1179,13 +1211,13 @@ Extensions can request user interaction via `ctx.ui.select()`, `ctx.ui.confirm()
 There are two categories of extension UI methods:
 
 - **Dialog methods** (`select`, `multiselect`, `confirm`, `input`, `editor`): emit an `extension_ui_request` on stdout and block until the client sends back an `extension_ui_response` on stdin with the matching `id`.
-- **Fire-and-forget methods** (`notify`, `setStatus`, `setWidget`, `setTitle`, `set_editor_text`): emit an `extension_ui_request` on stdout but do not expect a response. The client can display the information or ignore it.
+- **Fire-and-forget methods** (`notify`, `setStatus`, `setWidget`, `setTitle`, `set_editor_text`, `working`): emit an `extension_ui_request` on stdout but do not expect a response. The client can display the information or ignore it.
 
 If a dialog method includes a `timeout` field, the agent-side will auto-resolve with a default value when the timeout expires. The client does not need to track timeouts.
 
 Some `ExtensionUIContext` methods are not supported or degraded in RPC mode because they require direct TUI access:
 - `custom()` returns `undefined`
-- `setWorkingMessage()`, `setWorkingIndicator()`, `setFooter()`, `setHeader()`, `setEditorComponent()`, `setToolsExpanded()` are no-ops
+- `setWorkingMessage()`, `setWorkingVisible()`, `setWorkingIndicator()` emit a `working` extension_ui_request (see below); `setFooter()`, `setHeader()`, `setEditorComponent()`, `setToolsExpanded()` are no-ops
 - `getEditorText()` returns `""`
 - `getToolsExpanded()` returns `false`
 - `pasteToEditor()` delegates to `setEditorText()` (no paste/collapse handling)
@@ -1357,6 +1389,28 @@ Set the text in the input editor. Fire-and-forget.
 }
 ```
 
+#### working
+
+Control the streaming "working" loader row. Fire-and-forget; the host renders the loader. This mirrors the TUI's `setWorkingMessage()` / `setWorkingVisible()` / `setWorkingIndicator()` extension methods.
+
+```json
+{
+  "type": "extension_ui_request",
+  "id": "uuid-10",
+  "method": "working",
+  "message": "Analyzing repository...",
+  "visible": true,
+  "frames": ["⠋", "⠙", "⠹"],
+  "intervalMs": 80
+}
+```
+
+Fields (all optional, applied as a patch):
+- `message`: phase text shown next to the loader. Omit to keep (or restore to default).
+- `visible`: show/hide the loader row.
+- `frames`: custom animation frames for the normal streaming loader. An empty array hides the indicator; omitting restores the default spinner. Compaction/retry loaders keep their built-in styling.
+- `intervalMs`: frame interval in milliseconds for animated indicators.
+
 ### Extension UI Responses (stdin)
 
 Responses are sent for dialog methods only (`select`, `multiselect`, `confirm`, `input`, `editor`). The `id` must match the request.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selesai/code",
-  "version": "0.13.10",
+  "version": "0.13.11",
   "description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
   "type": "module",
   "repository": {