@code-yeongyu/senpi 2026.10.9 → 2026.10.10-3

package/dist/modes/rpc/host-daemon-registration.js

@@ -53,12 +53,16 @@ export async function readHostRegistration(paths) {
  * Registers a generation and points the daemon directory at it, under this process's writer stamp.
  * The stamp is what authorizes a later stop: only the process that wrote a record may signal the
  * host it names, and the recorded start time keeps a recycled pid from inheriting that right.
+ *
+ * `fresh` says the directory cannot hold an earlier generation (a terminal's endpoint, named by a
+ * socket built from a new instance id), so there is nothing to prune.
  */
-export async function writeHostRegistration(paths, registration) {
+export async function writeHostRegistration(paths, registration, options = {}) {
     // Every write is also the moment to drop what is no longer running: records of dead generations
     // and their session-path claims otherwise accumulate for the life of the agent directory, and a
     // stale pointer among them reads as "a daemon serves this endpoint" (#1893).
-    await pruneDeadGenerations(paths);
+    if (options.fresh !== true)
+        await pruneDeadGenerations(paths);
     const { generation, writer } = await writeGenerationRecord(paths, registration);
     // The pointer is replaced by rename: a reader either sees the generation that owned the socket
     // before this call or the one that owns it now, never a half-written pointer.

package/dist/modes/rpc/host-session-control.js

@@ -21,18 +21,18 @@ export class HostSessionControl {
                 wake("idle");
         });
         const unsubscribeEmitted = session.externalAdmission.onEmitted(() => wake("emitted"));
-        let stopInbox;
+        let inbox;
         const registration = {
             scheduler,
             release: () => {
                 unsubscribeIdle();
                 unsubscribeEmitted();
-                stopInbox?.();
+                inbox?.stop();
                 scheduler.dispose();
             },
         };
         try {
-            stopInbox = await watchInbox(options.inboxDir, () => wake("inbox"), (error) => this.report(`control inbox watch failed: ${errorText(error)}`));
+            inbox = await watchInbox(options.inboxDir, () => wake("inbox"), (error) => this.report(`control inbox watch failed: ${errorText(error)}`));
         }
         catch (error) {
             registration.release();
@@ -45,8 +45,10 @@ export class HostSessionControl {
         }
         this.releaseActive();
         this.active = registration;
-        // Anything that reached the inbox before the watch was armed is picked up by this first pass.
+        // Anything that reached the inbox before this point is picked up by this first pass, and anything
+        // written after it but before the watch was armed (no event for it) by the pass once arming settled.
         wake("inbox");
+        void inbox.armed.then(() => wake("inbox"));
         return {
             status: "registered",
             socket: this.socket,

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

@@ -330,6 +330,11 @@ export declare class RpcClient {
      * Abort in-progress retry.
      */
     abortRetry(): Promise<void>;
+    /**
+     * Give this single-session process its fallback chain before the first turn (`set_retry_fallback`).
+     * Requires the `retry_fallback_command` capability.
+     */
+    setRetryFallback(retryFallback: SessionRetryFallbackProfile): Promise<void>;
     /**
      * Execute a bash command.
      */

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

@@ -599,6 +599,13 @@ export class RpcClient {
     async abortRetry() {
         await this.send({ type: "abort_retry" });
     }
+    /**
+     * Give this single-session process its fallback chain before the first turn (`set_retry_fallback`).
+     * Requires the `retry_fallback_command` capability.
+     */
+    async setRetryFallback(retryFallback) {
+        await this.send({ type: "set_retry_fallback", retryFallback });
+    }
     /**
      * Execute a bash command.
      */

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

@@ -128,7 +128,7 @@ export async function runRpcMode(runtimeHost) {
     // it from a client handshake; a plain stdio client that sets nothing gets
     // byte-identical default behavior.
     const capabilities = parseClientCapabilities(envValue("RPC_CLIENT_CAPABILITIES"));
-    const handler = createRpcConnectionHandler(runtimeHost, sink, { capabilities });
+    const handler = createRpcConnectionHandler(runtimeHost, sink, { capabilities, retryFallbackCommand: true });
     const signalCleanupHandlers = [];
     const registerSignalHandlers = () => {
         const signals = ["SIGTERM"];

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

@@ -173,6 +173,10 @@ type RpcSessionCommand = {
 } | {
     id?: string;
     type: "abort_retry";
+} | {
+    id?: string;
+    type: "set_retry_fallback";
+    retryFallback: SessionRetryFallbackProfile;
 } | {
     id?: string;
     type: "bash";
@@ -991,6 +995,11 @@ export type RpcResponse = {
     type: "response";
     command: "abort_retry";
     success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "set_retry_fallback";
+    success: true;
 } | {
     id?: string;
     type: "response";

package/docs/json.md

@@ -22,6 +22,7 @@ type AgentSessionEvent =
   | { type: "compaction_end"; reason: "manual" | "threshold" | "overflow"; result: CompactionResult | undefined; aborted: boolean; willRetry: boolean; requestId?: string; accepted?: boolean; rejectionCause?: "cancelled-by-extension" | "external-owner" | "would-overflow" | "circuit-breaker" | "per-turn-cap"; errorMessage?: string }
   | { type: "session_info_changed"; name: string | undefined }
   | { type: "thinking_level_changed"; level: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" }
+  | { type: "thinking_level_clamped"; provider: string; modelId: string; requestedLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"; appliedLevel: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"; reason: "model-not-reasoning" | "level-unsupported" }
   | SystemPromptChangeEvent           // type: "system_prompt_change"
   | ExtensionToolHookLifecycleEvent   // type: "tool_hook_status"
   | { type: "auto_retry_start"; attempt: number; maxAttempts: number; delayMs: number; errorMessage: string }
@@ -55,6 +56,8 @@ type JsonAgentSessionEvent =
 
 `queue_update` emits the full pending steering and follow-up queues whenever they change. `compaction_start`, `compaction_progress`, and `compaction_end` cover both manual and automatic compaction. `session_info_changed` fires when the session display name changes, `thinking_level_changed` when the thinking level changes, `system_prompt_change` (see `SystemPromptChangeEvent` in [`extensions/types.ts`](../src/core/extensions/types.ts)) when a model switch changes the active system prompt, and `tool_hook_status` (see `ExtensionToolHookLifecycleEvent` in [`extensions/runner.ts`](../src/core/extensions/runner.ts)) for extension tool hook start/end phases.
 
+`thinking_level_clamped` fires once per model and requested level when an explicit thinking request (such as `--thinking`, `/thinking`, or a remembered per-model level) runs at a lower level than asked. A level that only comes from the global `defaultThinkingLevel` does not count as a request. In RPC mode, the `thinkingSelection` carried by `thinking_level_changed` and `get_state` then also has `requested` and `clampReason`.
+
 Other base events come from
 [`AgentEvent`](../../agent/src/types.ts):
 

package/docs/mcp.md

@@ -22,12 +22,27 @@ catalog costs almost nothing until the model actually needs it.
 }
 ```
 
-2. Start senpi. Run `/mcp` for the status panel, `/mcp status` for a one-line
+2. Start senpi. Run `/mcp` for the interactive server manager, `/mcp status` for a one-line
    summary, `/mcp add <name> <command...>` to add servers interactively.
 3. Servers needing OAuth: `/mcp auth <name>` (see [Auth](#auth)).
 4. Use it: small catalogs register directly; big ones surface through
    `tool_search` (see [Exposure tiers](#exposure-tiers)).
 
+## Interactive manager
+
+`/mcp` lists servers with their connection state, tool and available resource
+counts, exposure mode, and configuration source. Select a server to inspect its
+tools, details, or logs; test or reconnect it; or sign in/out when OAuth applies.
+The list updates when connections and catalogs change and preserves selection.
+Navigation, confirmation, and cancellation use your configured keybindings.
+
+Enable/disable and exposure changes are saved to the selected server's global
+or trusted project `mcp.json`. Imported, skill-owned, extension-owned, and
+untrusted definitions are read-only in this manager. OAuth actions close the
+manager before running the existing authorization flow, keeping its notices
+visible. Outside the TUI, `/mcp` reports status through the existing notification
+channel; existing subcommands remain available.
+
 ## Configuration reference
 
 Top-level shape: `{ "settings": { ... }, "mcpServers": { "<name>": { ... } } }`.

package/docs/models.md

@@ -142,6 +142,10 @@ Set `api` at provider level (default for all models) or model level (override pe
 | `authHeader` | Set `true` to add `Authorization: Bearer <apiKey>` automatically |
 | `models` | Array of model configurations |
 | `modelOverrides` | Per-model overrides for built-in or extension-registered models on this provider |
+| `whitelist` | Model ids to keep; every other model of the provider is removed (see [Hiding Providers and Models](#hiding-providers-and-models)) |
+| `blacklist` | Model ids to remove from the provider |
+| `hideFreeModels` | Set `true` to remove every model of the provider whose input and output cost are both `0` |
+| `disabled` | Set `true` to remove the whole provider |
 
 For providers with `models`, non-built-in provider configs need `baseUrl` and an `api` value at either provider or model level. `apiKey` is not required to load the file: models become available when auth is configured through `/login`/`auth.json`, CLI `--api-key`, or provider `apiKey`. If no auth is configured, the models load but stay unavailable in `/model` and `--list-models`.
 
@@ -510,6 +514,36 @@ Merge semantics:
 - If a custom model `id` matches a built-in model `id`, the custom model replaces that built-in model.
 - If a custom model `id` is new, it is added alongside built-in models.
 
+## Hiding Providers and Models
+
+Hidden models and providers disappear from the catalog everywhere it is read: `--list-models`, `/model`, Ctrl+P cycling, startup selection, and `enabledModels` / `favoriteModels` resolution.
+
+```json
+{
+  "disabledProviders": ["openrouter"],
+  "providers": {
+    "anthropic": { "whitelist": ["claude-sonnet-4-5"] },
+    "openai": { "blacklist": ["gpt-5.4"] },
+    "opencode": { "hideFreeModels": true }
+  }
+}
+```
+
+| Key | Where | Effect |
+|-----|-------|--------|
+| `disabledProviders` | Top level, array of provider ids | Removes each listed provider and all of its models. `providers.<id>.disabled: true` does the same for one provider. |
+| `whitelist` | Provider block, array of model ids | Keeps only the listed ids. |
+| `blacklist` | Provider block, array of model ids | Removes the listed ids. |
+| `hideFreeModels` | Provider block, boolean | Removes every model of that provider whose `cost.input` and `cost.output` are both `0`. |
+
+Behavior notes:
+- `whitelist` and `blacklist` match whole model ids exactly and case-sensitively; there are no globs. When both are set, a model must be in `whitelist` and not in `blacklist`.
+- All three provider filters run after custom `models` are merged in, and before `modelOverrides`. They also apply to the provider's custom `models` entries.
+- `hideFreeModels` is per provider. Other providers are unaffected, so a local provider whose models cost `0` (Ollama, LM Studio, vLLM) stays listed unless that provider sets the flag itself.
+- `hideFreeModels` also hides a custom `models` entry that omits `cost`, because an omitted `cost` is `0`. Give such a model a nonzero `cost`, or leave the flag off for that provider.
+- `hideFreeModels` reads the catalog `cost` (or the custom model's own `cost`). A `cost` set in `modelOverrides` is not considered.
+- A provider block that sets only `whitelist`, `blacklist`, or `hideFreeModels` is valid; no `baseUrl` or `models` is needed.
+
 ## Per-model Overrides
 
 Use `modelOverrides` to customize built-in models and matching extension-registered models without replacing the provider's full model list.

package/docs/rpc.md

@@ -1924,7 +1924,7 @@ The `model` field is a full [Model](#model) object.
 
 #### get_available_models
 
-List all configured models.
+List all configured models, refreshing credential availability on each request so credentials added or removed by another session take effect without reopening this session.
 
 ```json
 {"type": "get_available_models"}
@@ -2191,6 +2191,41 @@ Response:
 {"type": "response", "command": "abort_retry", "success": true}
 ```
 
+#### set_retry_fallback
+
+A single-session `--mode rpc` process has no `open_session`. A caller that spawns one process per session (e.g. a task
+child that runs as its own process) gives it its fallback policy with `set_retry_fallback`:
+
+```json
+{"type": "set_retry_fallback", "retryFallback": {"modelFallback": true, "fallbackChains": {"provider/model": ["provider/spare"]}}}
+```
+
+Response:
+```json
+{"type": "response", "command": "set_retry_fallback", "success": true}
+```
+
+The profile is the same shape, with the same limits, as `open_session.retryFallback`, and it has the same effect. It
+overrides the session's `retry.modelFallback` and `retry.fallbackChains` in memory only, it is never written to a
+settings file, and the process's later sessions (`new_session`, `switch_session`, `fork`) keep it.
+
+It is a launch-time setting:
+- It is accepted only before the session's first turn. It is refused once this connection has asked for a turn
+  (`prompt`, `steer`, `follow_up`, `continue_from_leaf`, `send_custom_message` with `triggerTurn`), even one that has
+  not started yet, while a turn streams (an extension's included), and once the session holds turn history (a resumed
+  session's). So a chain never changes under a provider request or a retry already in flight. Context messages added
+  before the first turn (role `custom`, from an extension on `session_start` or a `send_custom_message` without
+  `triggerTurn`) are not a turn and do not block it.
+- Send it on its own and await its response: a `set_retry_fallback` pipelined while a `new_session`, `switch_session`
+  or `fork` is still being created can answer success while the session being created runs without it.
+- A malformed profile is refused with the `open_session` shape message, and nothing is applied.
+- A multi-session host refuses the command on its session connections; a host session takes its policy from
+  `open_session.retryFallback`.
+
+Probe `retry_fallback_command` in `get_protocol_info` before sending it. Only a single-session process advertises it.
+Unlike an environment variable, the profile reaches this process only, never what its tools spawn. Unlike argv, it has
+no command-line length limit and is not visible in a process listing.
+
 ### Bash
 
 #### bash

package/docs/web-search.md

@@ -75,7 +75,9 @@ A config file replaces the free default completely: senpi uses only the provider
 | `nativeModel` | The model native search runs on; see [Choosing the model native search runs on](#choosing-the-model-native-search-runs-on). |
 | `providers[]` | The providers to use. Each entry takes `provider`, and optionally `id`, `apiKey`, `baseUrl`, `maxResults`, `timeoutMs`, `priority`, `weight`, `allowedDomains` or `blockedDomains`. |
 
-Free engines you can list without a key: `duckduckgo-html`, `exa-mcp`, `startpage`, `mojeek`, `ecosia`, `google-html`, and `searxng`. Providers that need `apiKey`: `exa`, `tavily`, `brave`, `serper`, `serpdive`, `kagi`, `perplexity`, `z-ai`, `xai`, `kimi`, `deepseek`, `anthropic`, `openai` (plus `searchEngineId` for `google-cse`). `chatgpt-subscription` and `google` use your senpi login when `apiKey` is omitted; see [Listing login-based routes](#listing-login-based-routes).
+Free engines you can list without a key: `duckduckgo-html`, `exa-mcp`, `startpage`, `mojeek`, `ecosia`, `google-html`, `searxng`, and `keenable`. Providers that need `apiKey`: `exa`, `tavily`, `brave`, `serper`, `serpdive`, `kagi`, `perplexity`, `z-ai`, `xai`, `kimi`, `deepseek`, `anthropic`, `openai` (plus `searchEngineId` for `google-cse`). `chatgpt-subscription` and `google` use your senpi login when `apiKey` is omitted; see [Listing login-based routes](#listing-login-based-routes).
+
+`keenable` ([Keenable](https://keenable.ai)) takes an `apiKey` but also works without one: a keyed entry posts to `https://api.keenable.ai/v1/search` with `X-API-Key`, while a keyless entry uses the shared public tier at `/v1/search/public` and identifies itself with an `X-Keenable-Title` app header instead of a credential. Because the public tier is a per-IP pool, `keenable` is never in the no-config default chain — list it explicitly in `websearch.json`. A single `allowedDomains` entry maps to Keenable's native `site` filter; multiple or blocked domains stay `site:`/`-site:` terms in the query.
 
 ## Limit or turn off the free engines
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.10.9",
+	"version": "2026.10.10-3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -57,9 +57,9 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.9",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.9",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.9",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.10-3",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.10-3",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.10-3",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"chalk": "6.0.0",
 		"cross-spawn": "7.0.6",
@@ -78,8 +78,8 @@
 		"yaml": "2.9.1",
 		"@anthropic-ai/claude-agent-sdk": "0.3.289",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.10.9",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.9",
+		"@code-yeongyu/senpi-codemode": "2026.10.10-3",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.10-3",
 		"@modelcontextprotocol/sdk": "1.30.0",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",

package/dist/bundle/chunks/chunk-6SMU7ANE.js

@@ -1,3 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{require_proper_lockfile}from"./chunk-GZVCRV7I.js";import{CONFIG_DIR_NAME,canonicalizePath,canonicalizePathStrict,resolvePath,stripBom}from"./chunk-463OK2Y4.js";import{__toESM}from"./chunk-IKOFCODM.js";var import_proper_lockfile=__toESM(require_proper_lockfile(),1);import{existsSync,mkdirSync,readFileSync,writeFileSync}from"node:fs";import{homedir}from"node:os";import{dirname,join}from"node:path";var TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES=["settings.json","mcp.json","extensions","skills","prompts","themes","SYSTEM.md","APPEND_SYSTEM.md"],LEGACY_PROJECT_CONFIG_DIR_NAME=".pi";function normalizeCwd(cwd){let resolved=resolvePath(cwd);try{return canonicalizePathStrict(resolved)}catch{return resolved}}function findNearestTrustEntry(data,cwd){let currentDir=normalizeCwd(cwd);for(;;){let value=data[currentDir];if(value===!0||value===!1)return{path:currentDir,decision:value};let parentDir=dirname(currentDir);if(parentDir===currentDir)return null;currentDir=parentDir}}function getProjectTrustParentPath(cwd){let trustPath=normalizeCwd(cwd),parentDir=dirname(trustPath);return parentDir===trustPath?void 0:parentDir}function getProjectTrustOptions(cwd,options){let trustPath=normalizeCwd(cwd),trustOptions=[{label:"Trust",trusted:!0,updates:[{path:trustPath,decision:!0}],savedPath:trustPath}],parentPath=getProjectTrustParentPath(cwd);return parentPath!==void 0&&trustOptions.push({label:`Trust parent folder (${parentPath})`,trusted:!0,updates:[{path:parentPath,decision:!0},{path:trustPath,decision:null}],savedPath:parentPath}),options?.includeSessionOnly&&trustOptions.push({label:"Trust (this session only)",trusted:!0,updates:[]}),trustOptions.push({label:"Do not trust",trusted:!1,updates:[{path:trustPath,decision:!1}],savedPath:trustPath}),options?.includeSessionOnly&&trustOptions.push({label:"Do not trust (this session only)",trusted:!1,updates:[]}),trustOptions}function readTrustFile(path){if(!existsSync(path))return{};let parsed;try{parsed=JSON.parse(stripBom(readFileSync(path,"utf-8")))}catch(error){let message=error instanceof Error?error.message:String(error);throw new Error(`Failed to read trust store ${path}: ${message}`)}if(typeof parsed!="object"||parsed===null||Array.isArray(parsed))throw new Error(`Invalid trust store ${path}: expected an object`);let data={};for(let[key,value]of Object.entries(parsed)){if(value!==!0&&value!==!1&&value!==null)throw new Error(`Invalid trust store ${path}: value for ${JSON.stringify(key)} must be true, false, or null`);data[key]=value}return data}function writeTrustFile(path,data){let sorted={};for(let key of Object.keys(data).sort()){let value=data[key];(value===!0||value===!1||value===null)&&(sorted[key]=value)}mkdirSync(dirname(path),{recursive:!0}),writeFileSync(path,`${JSON.stringify(sorted,null,2)}
-`,"utf-8")}function acquireTrustLockSync(path){let trustDir=dirname(path);mkdirSync(trustDir,{recursive:!0});let maxAttempts=10,delayMs=20,lastError;for(let attempt=1;attempt<=maxAttempts;attempt++)try{return import_proper_lockfile.default.lockSync(trustDir,{realpath:!1,lockfilePath:`${path}.lock`})}catch(error){if((typeof error=="object"&&error!==null&&"code"in error?String(error.code):void 0)!=="ELOCKED"||attempt===maxAttempts)throw error;lastError=error;let start=Date.now();for(;Date.now()-start<delayMs;);}throw lastError instanceof Error?lastError:new Error("Failed to acquire trust store lock")}function withTrustFileLock(path,fn){let release=acquireTrustLockSync(path);try{return fn()}finally{release()}}function hasTrustRequiringProjectResources(cwd){let homeDir=canonicalizePath(resolvePath(process.env.HOME||homedir())),userAgentsSkillsDir=join(homeDir,".agents","skills"),currentDir=canonicalizePath(resolvePath(cwd));if([join(currentDir,CONFIG_DIR_NAME),join(currentDir,LEGACY_PROJECT_CONFIG_DIR_NAME)].some(configDir=>TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES.some(entry=>existsSync(join(configDir,entry)))))return!0;for(;;){let agentsSkillsDir=join(currentDir,".agents","skills");if(agentsSkillsDir!==userAgentsSkillsDir&&existsSync(agentsSkillsDir))return!0;let parentDir=dirname(currentDir);if(parentDir===currentDir)return!1;currentDir=parentDir}}var ProjectTrustStore=class{constructor(agentDir){this.trustPath=join(resolvePath(agentDir),"trust.json")}get(cwd){return this.getEntry(cwd)?.decision??null}getEntry(cwd){return withTrustFileLock(this.trustPath,()=>{let data=readTrustFile(this.trustPath);return findNearestTrustEntry(data,cwd)})}set(cwd,decision){this.setMany([{path:cwd,decision}])}setMany(decisions){withTrustFileLock(this.trustPath,()=>{let data=readTrustFile(this.trustPath);for(let{path,decision}of decisions){let key=normalizeCwd(path);decision===null?delete data[key]:data[key]=decision}writeTrustFile(this.trustPath,data)})}};export{getProjectTrustOptions,hasTrustRequiringProjectResources,ProjectTrustStore};