@selesai/code 0.13.10 → 0.13.12

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to `@selesai/code` will be documented in this file.
 
+## [0.13.12] - 2026-09-03
+
+### Added
+- **Auto-continue after output token limit.** When the model stops because it reached the maximum output token limit (`stopReason: "length"`) mid-response, the agent now queues a follow-up "continue from where you left off" message and re-prompts automatically instead of stopping with the "response may be incomplete" error. Truncated tool calls were already re-issued by the agent loop; this covers truncated text. The continuation is capped at 3 consecutive length stops (the counter resets on any normal stop) so a model that keeps hitting the cap doesn't loop forever, and context-pressure length stops still trigger compaction first.
+
+## [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/core/agent-session-length-continuation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/agent-session-length-continuation.test.js

@@ -0,0 +1,107 @@
+import { describe, expect, it, vi } from "vitest";
+import { AgentSession } from "./agent-session.js";
+import { SettingsManager } from "./settings-manager.js";
+function createMockSession() {
+    const settings = SettingsManager.inMemory({});
+    const extensionRunner = {
+        getCommand: vi.fn(),
+        createCommandContext: vi.fn(),
+        emitError: vi.fn(),
+        emit: vi.fn(),
+        emitMessageEnd: vi.fn(),
+        hasHandlers: vi.fn(() => false),
+    };
+    const resourceLoader = {
+        getExtensions: () => ({ extensions: [], errors: [], runtime: { flagValues: new Map(), pendingProviderRegistrations: [], pendingNativeProviderRegistrations: [], assertActive: () => { } } }),
+        getSkills: () => ({ skills: [], diagnostics: [] }),
+        getPrompts: () => ({ prompts: [], diagnostics: [] }),
+        getThemes: () => ({ themes: [], diagnostics: [] }),
+        getAgents: () => ({ agents: [], diagnostics: [] }),
+        getAgentsFiles: () => ({ agentsFiles: [] }),
+        getSystemPrompt: () => undefined,
+        getAppendSystemPrompt: () => [],
+        getExtensionDiagnostics: () => [],
+        extendResources: () => { },
+        reload: vi.fn(),
+    };
+    const modelRegistry = {
+        registerProvider: vi.fn(),
+        unregisterProvider: vi.fn(),
+        getProvider: vi.fn(),
+        getProviders: vi.fn(() => []),
+        getModels: vi.fn(() => []),
+    };
+    const followUp = vi.fn();
+    const hasQueuedMessages = vi.fn(() => false);
+    const agent = {
+        state: { messages: [], tools: [] },
+        subscribe: vi.fn(() => () => { }),
+        followUp,
+        hasQueuedMessages,
+    };
+    const session = new AgentSession({
+        agent: agent,
+        sessionManager: { getBranch: () => [], appendMessage: vi.fn() },
+        settingsManager: settings,
+        cwd: "/tmp",
+        resourceLoader: resourceLoader,
+        modelRuntime: modelRegistry,
+    });
+    session._extensionRunner = extensionRunner;
+    return { session, followUp, hasQueuedMessages };
+}
+function lengthStopMessage(text) {
+    return {
+        role: "assistant",
+        content: [{ type: "text", text }],
+        stopReason: "length",
+        timestamp: Date.now(),
+        usage: { input: 100, output: 500, cacheRead: 0, cacheWrite: 0, totalTokens: 600, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+    };
+}
+describe("AgentSession length-stop continuation", () => {
+    it("queues a follow-up continuation and returns true for a truncated text response", async () => {
+        const { session, followUp } = createMockSession();
+        session._lastAssistantMessage = lengthStopMessage("partial response...");
+        const result = await session._handlePostAgentRun();
+        expect(result).toBe(true);
+        expect(followUp).toHaveBeenCalledTimes(1);
+        const queued = followUp.mock.calls[0][0];
+        expect(queued.role).toBe("user");
+        expect(queued.content[0].text).toContain("Continue from where you left off");
+    });
+    it("does not continue when the truncated message contains tool calls", async () => {
+        const { session, followUp } = createMockSession();
+        session._lastAssistantMessage = {
+            role: "assistant",
+            content: [{ type: "toolCall", id: "tc_1", name: "bash", arguments: "{}" }],
+            stopReason: "length",
+            timestamp: Date.now(),
+        };
+        const result = await session._handlePostAgentRun();
+        expect(result).toBe(false);
+        expect(followUp).not.toHaveBeenCalled();
+    });
+    it("stops after MAX_LENGTH_CONTINUATIONS consecutive length stops", async () => {
+        const { session, followUp } = createMockSession();
+        session._lengthContinuations = 3;
+        session._lastAssistantMessage = lengthStopMessage("still truncated...");
+        const result = await session._handlePostAgentRun();
+        expect(result).toBe(false);
+        expect(followUp).not.toHaveBeenCalled();
+    });
+    it("resets the continuation counter on a non-length assistant stop", async () => {
+        const { session } = createMockSession();
+        session._lengthContinuations = 2;
+        await session._handleAgentEvent({
+            type: "message_end",
+            message: {
+                role: "assistant",
+                content: [{ type: "text", text: "done" }],
+                stopReason: "stop",
+                timestamp: Date.now(),
+            },
+        });
+        expect(session._lengthContinuations).toBe(0);
+    });
+});

package/dist/core/agent-session.d.ts

@@ -232,6 +232,7 @@ export declare class AgentSession {
     private _branchSummaryAbortController;
     private _retryAbortController;
     private _retryAttempt;
+    private _lengthContinuations;
     private readonly _bashAbortControllers;
     private _pendingBashMessages;
     private _extensionRunner;

package/dist/core/agent-session.js

@@ -82,6 +82,10 @@ function estimateMessagesTokens(messages) {
 // ============================================================================
 // Constants
 // ============================================================================
+/** Max consecutive auto-continuations after a length stop (output token limit). */
+const MAX_LENGTH_CONTINUATIONS = 3;
+/** Follow-up message queued when the model hits the output token limit. */
+const LENGTH_CONTINUATION_MESSAGE = "Your previous response was cut off because it reached the maximum output token limit. Continue from where you left off. Do not repeat content you already produced.";
 // ============================================================================
 // AgentSession Class
 // ============================================================================
@@ -113,6 +117,8 @@ export class AgentSession {
     // Retry state
     _retryAbortController = undefined;
     _retryAttempt = 0;
+    // Length-stop continuation state (consecutive output-token-limit continuations)
+    _lengthContinuations = 0;
     // Bash execution state
     _bashAbortControllers = new Set();
     _pendingBashMessages = [];
@@ -441,6 +447,11 @@ export class AgentSession {
                 if (assistantMsg.stopReason !== "error") {
                     this._overflowRecoveryAttempted = false;
                 }
+                // Reset the length-continuation counter on any non-length stop so the
+                // cap only bounds consecutive output-token-limit continuations.
+                if (assistantMsg.stopReason !== "length") {
+                    this._lengthContinuations = 0;
+                }
                 // Reset retry counter immediately on successful assistant response
                 // This prevents accumulation across multiple LLM calls within a turn
                 if (assistantMsg.stopReason !== "error" && this._retryAttempt > 0) {
@@ -863,6 +874,18 @@ export class AgentSession {
         if (await this._checkCompaction(msg)) {
             return true;
         }
+        // A length stop means the model hit the output token limit mid-response.
+        // The agent loop already re-prompts when truncated tool calls are present;
+        // here the loop stopped on truncated text, so queue a follow-up to continue.
+        // Compaction runs first: a length stop caused by context pressure (input
+        // filling the window) should compact instead of blindly continuing.
+        if (msg.stopReason === "length" &&
+            !msg.content.some((c) => c.type === "toolCall") &&
+            this._lengthContinuations < MAX_LENGTH_CONTINUATIONS) {
+            this._lengthContinuations++;
+            await this._queueFollowUp(LENGTH_CONTINUATION_MESSAGE);
+            return true;
+        }
         // The agent loop drains both queues before emitting agent_end. Any messages
         // here were queued by agent_end extension handlers and need a continuation.
         return this.agent.hasQueuedMessages();

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/extensions/pi-hermes-memory/src/index.ts

@@ -24,7 +24,7 @@
 
 import * as path from "node:path";
 import * as fs from "node:fs";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { MemoryStore } from "./store/memory-store.js";
 import { SkillStore } from "./store/skill-store.js";
 import { DatabaseManager } from "./store/db.js";
@@ -106,6 +106,10 @@ export default function (pi: ExtensionAPI) {
 
   const shouldMigrateExtensionRoot = !configuredMemoryDir || pointsToLegacyMemoryDir;
   let persistenceInitialized = false;
+  // Captured at session_start: the extension factory runs with no session, but
+  // the auto-consolidator needs model access to use the fast in-process direct
+  // transport instead of always spawning a slow `pi -p` subprocess agent.
+  let sessionModelCtx: Pick<ExtensionContext, "model" | "modelRegistry"> | null = null;
 
   const store = new MemoryStore({ ...config, memoryDir: globalDir });
   // Factory may run with no session (Pi public contract). Do not snapshot
@@ -182,6 +186,7 @@ export default function (pi: ExtensionAPI) {
 
   // ── 1. Load memory from disk on session start ──
   pi.on("session_start", async (_event, ctx) => {
+    sessionModelCtx = { model: ctx.model, modelRegistry: ctx.modelRegistry };
     if (!persistenceInitialized) {
       try {
         await measureLifecycle("session-start.persistence-sync", async () => {
@@ -286,6 +291,7 @@ export default function (pi: ExtensionAPI) {
       config.consolidationTimeoutMs,
       toolTarget,
       config,
+      sessionModelCtx,
     );
     if (result.deferred) {
       console.info(`⏳ Auto-consolidation for '${toolTarget}' deferred: ${result.error ?? "another session holds the consolidation lock"}`);

package/dist/extensions/pi-web-agent/src/backends/config.ts

@@ -17,7 +17,7 @@ export type FirecrawlOptions = {
 };
 
 export type SearchBackendConfig = {
-  provider: 'duckduckgo' | 'searxng' | 'brave' | 'youcom' | 'exa' | 'tavily';
+  provider: 'duckduckgo' | 'searxng' | 'brave' | 'youcom' | 'exa' | 'tavily' | 'tokenin';
   baseUrl?: string;
   fallback?: 'duckduckgo';
   options?: SearxngOptions;
@@ -54,7 +54,7 @@ export type BackendConfigFile = {
 };
 
 export const DEFAULT_BACKEND_CONFIG: BackendConfig = {
-  search: { provider: 'duckduckgo' },
+  search: { provider: 'tokenin', fallback: 'duckduckgo' },
   fetch: { provider: 'http' },
   headless: { provider: 'local-browser' }
 };
@@ -86,7 +86,7 @@ function extractFirecrawlOptions(value: unknown): FirecrawlOptions | undefined {
   return Object.keys(options).length > 0 ? options : undefined;
 }
 
-const PROVIDER_NAMES: SearchProviderName[] = ['duckduckgo', 'searxng', 'brave', 'youcom', 'exa', 'tavily'];
+const PROVIDER_NAMES: SearchProviderName[] = ['duckduckgo', 'searxng', 'brave', 'youcom', 'exa', 'tavily', 'tokenin'];
 
 export function usableSearchProviders(
   search: SearchBackendConfig,
@@ -99,6 +99,7 @@ export function usableSearchProviders(
   if (env.YDC_API_KEY?.trim()) usable.push('youcom');
   if (env.EXA_API_KEY?.trim()) usable.push('exa');
   if (env.TAVILY_API_KEY?.trim()) usable.push('tavily');
+  if (hasActiveTokenInAccount()) usable.push('tokenin');
   return usable;
 }
 
@@ -129,7 +130,8 @@ export function extractBackendConfigOverride(
     backends?.search?.provider === 'brave' ||
     backends?.search?.provider === 'youcom' ||
     backends?.search?.provider === 'exa' ||
-    backends?.search?.provider === 'tavily'
+    backends?.search?.provider === 'tavily' ||
+    backends?.search?.provider === 'tokenin'
   ) {
     override.search = { provider: backends.search.provider };
     if (backends.search.provider === 'searxng' && typeof backends.search.baseUrl === 'string') {
@@ -186,8 +188,8 @@ export function validateBackendConfig(config: BackendConfig): string[] {
     issues.push('fetch provider firecrawl requires backends.fetch.baseUrl');
   }
 
-  if (config.search.fallback === 'duckduckgo' && config.search.provider !== 'searxng' && config.search.provider !== 'brave' && config.search.provider !== 'youcom' && config.search.provider !== 'exa' && config.search.provider !== 'tavily') {
-    issues.push('search fallback duckduckgo is only supported when search provider is searxng, brave, youcom, exa, or tavily');
+  if (config.search.fallback === 'duckduckgo' && config.search.provider !== 'searxng' && config.search.provider !== 'brave' && config.search.provider !== 'youcom' && config.search.provider !== 'exa' && config.search.provider !== 'tavily' && config.search.provider !== 'tokenin') {
+    issues.push('search fallback duckduckgo is only supported when search provider is searxng, brave, youcom, exa, tavily, or tokenin');
   }
 
   if (config.fetch.fallback === 'http' && config.fetch.provider !== 'firecrawl') {

package/dist/extensions/pi-web-agent/src/backends/factory.ts

@@ -3,6 +3,7 @@ import { createBraveSearchTool } from '../search/brave.js';
 import { createYouComSearchTool } from '../search/youcom.js';
 import { createExaSearchTool } from '../search/exa.js';
 import { createTavilySearchTool } from '../search/tavily.js';
+import { createTokenInSearchTool } from '../search/tokenin.js';
 import { createSearxngSearchTool } from '../search/searxng.js';
 import { createFanoutSearch } from '../search/fanout.js';
 import { buildFetchPresentation } from '../presentation/fetch-presentation.js';
@@ -31,6 +32,7 @@ export type BackendFactoryDeps = {
   createYouComSearch?: typeof createYouComSearchTool;
   createExaSearch?: typeof createExaSearchTool;
   createTavilySearch?: typeof createTavilySearchTool;
+  createTokenInSearch?: typeof createTokenInSearchTool;
   createHttpFetch?: typeof createWebFetchTool;
   createFirecrawlFetch?: typeof createFirecrawlFetcher;
   createHeadlessFetch?: typeof createWebFetchHeadlessTool;
@@ -71,7 +73,7 @@ function invalidFirecrawlFetch() {
 function withSearchFallback(
   primary: BackendSet['search'],
   fallback: BackendSet['search'],
-  fallbackFrom: 'searxng' | 'brave' | 'youcom' | 'exa' | 'tavily' | 'duckduckgo'
+  fallbackFrom: 'searxng' | 'brave' | 'youcom' | 'exa' | 'tavily' | 'tokenin' | 'duckduckgo'
 ): BackendSet['search'] {
   return async (input) => {
     const first = await primary(input);
@@ -124,6 +126,7 @@ export function createBackendSet(
   const createYouComSearch = deps.createYouComSearch ?? createYouComSearchTool;
   const createExaSearch = deps.createExaSearch ?? createExaSearchTool;
   const createTavilySearch = deps.createTavilySearch ?? createTavilySearchTool;
+  const createTokenInSearch = deps.createTokenInSearch ?? createTokenInSearchTool;
   const createHttpFetch = deps.createHttpFetch ?? createWebFetchTool;
   const createFirecrawlFetch = deps.createFirecrawlFetch ?? createFirecrawlFetcher;
   const createHeadlessFetch = deps.createHeadlessFetch ?? createWebFetchHeadlessTool;
@@ -142,6 +145,8 @@ export function createBackendSet(
         return createExaSearch({ apiKey: process.env.EXA_API_KEY });
       case 'tavily':
         return createTavilySearch({ apiKey: process.env.TAVILY_API_KEY });
+      case 'tokenin':
+        return createTokenInSearch();
       case 'duckduckgo':
       default:
         return createDuckDuckGoSearch();
@@ -160,7 +165,9 @@ export function createBackendSet(
           ? createExaSearch({ apiKey: process.env.EXA_API_KEY })
           : config.search.provider === 'tavily'
             ? createTavilySearch({ apiKey: process.env.TAVILY_API_KEY })
-            : createDuckDuckGoSearch();
+            : config.search.provider === 'tokenin'
+              ? createTokenInSearch()
+              : createDuckDuckGoSearch();
 
   if (config.search.provider === 'searxng' && config.search.fallback === 'duckduckgo') {
     search = withSearchFallback(search, createDuckDuckGoSearch(), 'searxng');
@@ -182,6 +189,10 @@ export function createBackendSet(
     search = withSearchFallback(search, createDuckDuckGoSearch(), 'tavily');
   }
 
+  if (config.search.provider === 'tokenin' && config.search.fallback === 'duckduckgo') {
+    search = withSearchFallback(search, createDuckDuckGoSearch(), 'tokenin');
+  }
+
   const fanoutConfig = config.search.fanout;
   if (fanoutConfig && fanoutConfig.mode !== 'off') {
     const baseNames =

package/dist/extensions/pi-web-agent/src/backends/settings-reader.ts

@@ -4,7 +4,28 @@
 // minimal settings.json read. Ceiling: if selesai moves web search config elsewhere, this
 // helper needs updating; upgrade path = upstream pi-web-agent adopting a settings hook.
 import { existsSync, readFileSync } from 'node:fs';
-import { getSettingsPath } from '@selesai/code';
+import { join } from 'node:path';
+import { getAgentDir, getSettingsPath } from '@selesai/code';
+
+/**
+ * True when tokenin-auth.json (written by the tokenin-onboarding extension)
+ * has an active account. Used to decide whether the tokenin search provider is
+ * usable. Never throws.
+ */
+export function hasActiveTokenInAccount(authPath: string = join(getAgentDir(), 'tokenin-auth.json')): boolean {
+	try {
+		if (!existsSync(authPath)) return false;
+		const parsed = JSON.parse(readFileSync(authPath, 'utf-8')) as unknown;
+		if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false;
+		const auth = parsed as { accounts?: unknown; activeId?: unknown };
+		if (!Array.isArray(auth.accounts) || typeof auth.activeId !== 'string') return false;
+		return auth.accounts.some(
+			(a) => a && typeof a === 'object' && !Array.isArray(a) && (a as { id?: unknown }).id === auth.activeId
+		);
+	} catch {
+		return false;
+	}
+}
 
 /**
  * Read the Brave API key from selesai settings.json (webAgent.braveApiKey).

package/dist/extensions/pi-web-agent/src/commands/web-agent-config.ts

@@ -278,7 +278,7 @@ function buildBackendSettingsItems(
       id: 'backend:search:provider',
       label: 'Search backend',
       currentValue: backends.search.provider,
-      values: ['duckduckgo', 'searxng', 'brave', 'youcom', 'exa', 'tavily']
+      values: ['duckduckgo', 'searxng', 'brave', 'youcom', 'exa', 'tavily', 'tokenin']
     },
     {
       id: 'backend:search:baseUrl',
@@ -289,8 +289,8 @@ function buildBackendSettingsItems(
     {
       id: 'backend:search:fallback',
       label: 'Search fallback',
-      currentValue: backends.search.provider === 'searxng' || backends.search.provider === 'brave' || backends.search.provider === 'youcom' || backends.search.provider === 'exa' || backends.search.provider === 'tavily' ? backends.search.fallback ?? 'off' : 'off',
-      values: backends.search.provider === 'searxng' || backends.search.provider === 'brave' || backends.search.provider === 'youcom' || backends.search.provider === 'exa' || backends.search.provider === 'tavily' ? ['off', 'duckduckgo'] : ['off']
+      currentValue: backends.search.provider === 'searxng' || backends.search.provider === 'brave' || backends.search.provider === 'youcom' || backends.search.provider === 'exa' || backends.search.provider === 'tavily' || backends.search.provider === 'tokenin' ? backends.search.fallback ?? 'off' : 'off',
+      values: backends.search.provider === 'searxng' || backends.search.provider === 'brave' || backends.search.provider === 'youcom' || backends.search.provider === 'exa' || backends.search.provider === 'tavily' || backends.search.provider === 'tokenin' ? ['off', 'duckduckgo'] : ['off']
     },
     {
       id: 'backend:search:fanout:mode',
@@ -488,7 +488,7 @@ export function applySettingsValue(
     currentDraft.tools = nextTools;
   }
 
-  if (id === 'backend:search:provider' && (newValue === 'duckduckgo' || newValue === 'searxng' || newValue === 'brave' || newValue === 'youcom' || newValue === 'exa' || newValue === 'tavily')) {
+  if (id === 'backend:search:provider' && (newValue === 'duckduckgo' || newValue === 'searxng' || newValue === 'brave' || newValue === 'youcom' || newValue === 'exa' || newValue === 'tavily' || newValue === 'tokenin')) {
     currentBackends.search.provider = newValue;
     if (newValue !== 'searxng') {
       delete currentBackends.search.baseUrl;
@@ -500,7 +500,7 @@ export function applySettingsValue(
   }
 
   if (id === 'backend:search:fallback') {
-    if (newValue === 'duckduckgo' && (currentBackends.search.provider === 'searxng' || currentBackends.search.provider === 'brave' || currentBackends.search.provider === 'youcom' || currentBackends.search.provider === 'exa' || currentBackends.search.provider === 'tavily')) {
+    if (newValue === 'duckduckgo' && (currentBackends.search.provider === 'searxng' || currentBackends.search.provider === 'brave' || currentBackends.search.provider === 'youcom' || currentBackends.search.provider === 'exa' || currentBackends.search.provider === 'tavily' || currentBackends.search.provider === 'tokenin')) {
       currentBackends.search.fallback = 'duckduckgo';
     } else {
       delete currentBackends.search.fallback;

package/dist/extensions/pi-web-agent/src/search/tokenin.ts

@@ -0,0 +1,130 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { getAgentDir } from '@selesai/code';
+import { buildSearchPresentation } from '../presentation/search-presentation.js';
+import type { SearchResult, WebSearchResponse } from '../types.js';
+
+export const TOKENIN_SEARCH_TOOL_NAME = 'firecrawl';
+export const TOKENIN_DEFAULT_BASE_URL = 'https://lite.andlet.me/v1';
+
+type TokenInAccount = { id: string; label: string; apiKey: string; baseUrl?: string };
+type TokenInAuth = { accounts: TokenInAccount[]; activeId: string | null };
+
+type LiteLLMSearchResult = { title?: unknown; url?: unknown; snippet?: unknown };
+type LiteLLMSearchResponse = { results?: LiteLLMSearchResult[] };
+
+/**
+ * Read the active Token-In account from tokenin-auth.json (written by the
+ * tokenin-onboarding extension). Returns undefined when no account is saved.
+ * Never throws.
+ */
+export function readActiveTokenInAccount(
+  authPath: string = join(getAgentDir(), 'tokenin-auth.json')
+): TokenInAccount | undefined {
+  try {
+    if (!existsSync(authPath)) return undefined;
+    const parsed = JSON.parse(readFileSync(authPath, 'utf-8')) as unknown;
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined;
+    const auth = parsed as TokenInAuth;
+    if (!Array.isArray(auth.accounts) || typeof auth.activeId !== 'string') return undefined;
+    return auth.accounts.find((a) => a && typeof a === 'object' && a.id === auth.activeId && typeof a.apiKey === 'string');
+  } catch {
+    return undefined;
+  }
+}
+
+function resultWithPresentation(result: WebSearchResponse): WebSearchResponse {
+  return { ...result, presentation: buildSearchPresentation(result) };
+}
+
+function normalizeResults(response: LiteLLMSearchResponse): SearchResult[] {
+  return (response.results ?? []).flatMap((item) => {
+    if (typeof item.title !== 'string' || typeof item.url !== 'string') return [];
+    return [
+      {
+        title: item.title,
+        url: item.url,
+        snippet: typeof item.snippet === 'string' ? item.snippet : ''
+      }
+    ];
+  });
+}
+
+export function createTokenInSearchTool({
+  readAccount = readActiveTokenInAccount,
+  fetchImpl = fetch
+}: {
+  readAccount?: () => TokenInAccount | undefined;
+  fetchImpl?: typeof fetch;
+} = {}) {
+  return async function tokenInSearch({ query }: { query: string }): Promise<WebSearchResponse> {
+    const normalizedQuery = query.trim();
+
+    if (!normalizedQuery) {
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'tokenin', cacheHit: false },
+        error: { code: 'INVALID_QUERY', message: 'Query must not be empty.' }
+      });
+    }
+
+    const account = readAccount();
+    if (!account) {
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'tokenin', cacheHit: false },
+        error: {
+          code: 'BACKEND_CONFIG_INVALID',
+          message: 'Token-In search requires an active Token-In account. Run /tokenin add first.'
+        }
+      });
+    }
+
+    const baseUrl = (account.baseUrl ?? TOKENIN_DEFAULT_BASE_URL).replace(/\/+$/, '');
+    const url = `${baseUrl}/v1/search/${TOKENIN_SEARCH_TOOL_NAME}`;
+
+    try {
+      const response = await fetchImpl(url, {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${account.apiKey}`
+        },
+        body: JSON.stringify({ query: normalizedQuery, max_results: 10 })
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}`);
+      }
+
+      const parsed = (await response.json()) as LiteLLMSearchResponse;
+      const results = normalizeResults(parsed);
+
+      if (results.length === 0) {
+        return resultWithPresentation({
+          status: 'error',
+          results: [],
+          metadata: { backend: 'tokenin', cacheHit: false },
+          error: { code: 'NO_RESULTS', message: 'Token-In search returned no usable results for this query.' }
+        });
+      }
+
+      return resultWithPresentation({
+        status: 'ok',
+        results,
+        metadata: { backend: 'tokenin', cacheHit: false }
+      });
+    } catch (error) {
+      const rawMessage = error instanceof Error ? error.message : String(error);
+      return resultWithPresentation({
+        status: 'error',
+        results: [],
+        metadata: { backend: 'tokenin', cacheHit: false },
+        error: { code: 'FETCH_FAILED', message: `Token-In search request failed: ${rawMessage}` }
+      });
+    }
+  };
+}

package/dist/extensions/pi-web-agent/src/types.ts

@@ -16,7 +16,7 @@ export type SearchResult = {
   snippet: string;
 };
 
-export type SearchProviderName = 'duckduckgo' | 'searxng' | 'brave' | 'youcom' | 'exa' | 'tavily';
+export type SearchProviderName = 'duckduckgo' | 'searxng' | 'brave' | 'youcom' | 'exa' | 'tavily' | 'tokenin';
 
 export type FanoutMode = 'off' | 'on' | 'auto';
 
@@ -32,9 +32,9 @@ export type ToolError = {
 };
 
 export type SearchMetadata = {
-  backend: 'duckduckgo' | 'searxng' | 'brave' | 'youcom' | 'exa' | 'tavily';
+  backend: SearchProviderName;
   cacheHit: boolean;
-  fallbackFrom?: 'searxng' | 'brave' | 'youcom' | 'exa' | 'tavily' | 'duckduckgo';
+  fallbackFrom?: Exclude<SearchProviderName, 'tokenin'>;
   fallbackReason?: string;
   fanout?: FanoutMetadata;
 };

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.12",
   "description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
   "type": "module",
   "repository": {