@code-yeongyu/senpi 2026.10.9 → 2026.10.10-2

package/dist/modes/rpc/connection-handler.js

@@ -34,7 +34,7 @@ import { ClientAdmissions } from "./client-admissions.js";
 import { handleClientInput } from "./client-input-handler.js";
 import { ClientMessageEvents } from "./client-message-events.js";
 import { ConnectionQuestionBridge, degradeQuestion, sessionQuestionBridges } from "./connection-question-bridge.js";
-import { AUTO_TITLE_SESSIONS_CAPABILITY, buildCustomUnsupportedRequest, CONTINUE_FROM_LEAF_CAPABILITY, DEFAULT_CUSTOM_EXTENSION_LABEL, EXTENSION_EVENTS_CAPABILITY, MEDIA_PLACEHOLDERS_CAPABILITY, QUESTION_CAPABILITY, } from "./custom-capability.js";
+import { AUTO_TITLE_SESSIONS_CAPABILITY, buildCustomUnsupportedRequest, CONTINUE_FROM_LEAF_CAPABILITY, DEFAULT_CUSTOM_EXTENSION_LABEL, EXTENSION_EVENTS_CAPABILITY, MEDIA_PLACEHOLDERS_CAPABILITY, QUESTION_CAPABILITY, RETRY_FALLBACK_COMMAND_CAPABILITY, } from "./custom-capability.js";
 import { createRpcEventOutputBuffer } from "./event-output-buffer.js";
 import { settleExtensionUiResponse } from "./extension-ui-response.js";
 import { HostSessionControl } from "./host-session-control.js";
@@ -42,7 +42,7 @@ import { createRpcLoginPromptCallbacks } from "./login-prompts.js";
 import { answerMemoryReport } from "./memory-report-command.js";
 import { protocolIdentity } from "./protocol-identity.js";
 import { buildRpcCommandsForSession, createCommandsChangedEvent, rpcCommandListDigest } from "./rpc-command-surface.js";
-import { rpcCommandPayloadError, rpcCommandShapeError, rpcMessageLengthError } from "./rpc-input-validation.js";
+import { rpcCommandPayloadError, rpcCommandShapeError, rpcMessageLengthError, sessionRetryFallbackError, } from "./rpc-input-validation.js";
 import { buildRpcSessionState } from "./rpc-session-state.js";
 import { RPC_ERROR_MEDIA_NOT_FOUND } from "./rpc-types.js";
 import { SessionExtensionUiRequests } from "./session-extension-ui-requests.js";
@@ -158,6 +158,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     let session = runtimeHost.session;
     let sessionControl;
     const promptCalls = new Set();
+    // Set by the first command that asks this session for a turn; `set_retry_fallback` is refused after it.
+    let turnRequested = false;
     let unsubscribe;
     let unsubscribeBackpressure;
     let unsubscribeLoadedSurfaces;
@@ -737,6 +739,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                                 MEDIA_PLACEHOLDERS_CAPABILITY,
                                 DURABLE_CLIENT_MESSAGE_ID_CAPABILITY,
                                 CONTINUE_FROM_LEAF_CAPABILITY,
+                                ...(options.retryFallbackCommand ? [RETRY_FALLBACK_COMMAND_CAPABILITY] : []),
                                 ...(options.capabilities ?? []),
                             ]),
                         ],
@@ -750,6 +753,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             // Prompting
             // =================================================================
             case "prompt": {
+                turnRequested = true;
                 const admission = handleClientInput(session, command, { output, promptCalls });
                 promptCalls.add(admission);
                 void admission.finally(() => promptCalls.delete(admission));
@@ -769,6 +773,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 return success(id, "append_session_entry");
             }
             case "continue_from_leaf": {
+                turnRequested = true;
                 try {
                     await session.continueFromLeaf();
                     return success(id, "continue_from_leaf");
@@ -780,6 +785,9 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 }
             }
             case "send_custom_message": {
+                // A context message that asks for no turn does not block a launch-time chain, like an extension's.
+                if (command.triggerTurn === true)
+                    turnRequested = true;
                 await session.sendCustomMessage({
                     customType: command.customType,
                     content: command.content,
@@ -790,6 +798,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
             }
             case "steer":
             case "follow_up": {
+                turnRequested = true;
                 await handleClientInput(session, command, { output, promptCalls });
                 return undefined;
             }
@@ -883,7 +892,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 return success(id, "cycle_model", result);
             }
             case "get_available_models": {
-                const models = await session.modelRegistry.getAvailable();
+                const models = await session.modelRegistry.modelRuntime.getAvailable();
                 return success(id, "get_available_models", {
                     models: models.map((model) => ({
                         ...model,
@@ -989,6 +998,24 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                 session.abortRetry();
                 return success(id, "abort_retry");
             }
+            case "set_retry_fallback": {
+                if (!options.retryFallbackCommand) {
+                    return error(id, "set_retry_fallback", "set_retry_fallback is for a single-session rpc process; a host session takes open_session.retryFallback.");
+                }
+                const profileError = sessionRetryFallbackError(command.retryFallback);
+                if (profileError !== undefined || command.retryFallback === undefined) {
+                    return error(id, "set_retry_fallback", profileError ?? "set_retry_fallback needs retryFallback.");
+                }
+                // A launch-time setting: refused once this connection asked for a turn (even one not started yet), while
+                // any turn runs, or once the session holds turn history, so a chain never changes under a turn or a
+                // retry already in flight. Extension context messages (`custom`, e.g. one a component adds on
+                // session_start) are not a turn and do not count.
+                if (turnRequested || session.isStreaming || session.messages.some((message) => message.role !== "custom")) {
+                    return error(id, "set_retry_fallback", "set_retry_fallback must arrive before the session's first turn.");
+                }
+                runtimeHost.setRetryFallback(command.retryFallback);
+                return success(id, "set_retry_fallback");
+            }
             // =================================================================
             // Bash
             // =================================================================

package/dist/modes/rpc/custom-capability.d.ts

@@ -80,6 +80,12 @@ export declare const BROWSER_ENGINE_CAPABILITY = "browser_engine";
  * never written to a settings file and never seen by another session on the host.
  */
 export declare const RETRY_FALLBACK_PROFILE_CAPABILITY = "retry_fallback_profile";
+/**
+ * SINGLE-SESSION capability: this `--mode rpc` process accepts `set_retry_fallback` (the
+ * `open_session.retryFallback` shape) before its first turn, so a caller that spawns one process per
+ * session can give it its own fallback chain without a settings file.
+ */
+export declare const RETRY_FALLBACK_COMMAND_CAPABILITY = "retry_fallback_command";
 /**
  * HOST capability: `open_session.promptSurface` also accepts `chat` (a chat bridge: no routing line,
  * no handoff block, no todo cues). A host without it refuses `chat` with `invalid_launch_profile`,

package/dist/modes/rpc/custom-capability.js

@@ -80,6 +80,12 @@ export const BROWSER_ENGINE_CAPABILITY = "browser_engine";
  * never written to a settings file and never seen by another session on the host.
  */
 export const RETRY_FALLBACK_PROFILE_CAPABILITY = "retry_fallback_profile";
+/**
+ * SINGLE-SESSION capability: this `--mode rpc` process accepts `set_retry_fallback` (the
+ * `open_session.retryFallback` shape) before its first turn, so a caller that spawns one process per
+ * session can give it its own fallback chain without a settings file.
+ */
+export const RETRY_FALLBACK_COMMAND_CAPABILITY = "retry_fallback_command";
 /**
  * HOST capability: `open_session.promptSurface` also accepts `chat` (a chat bridge: no routing line,
  * no handoff block, no todo cues). A host without it refuses `chat` with `invalid_launch_profile`,

package/dist/modes/rpc/host-daemon-paths.d.ts

@@ -101,10 +101,11 @@ export declare class HostDaemonStateError extends Error {
     constructor(path: string, cause: unknown);
 }
 /**
- * Creates this endpoint's directories and publishes the flat marker. The modes are set explicitly
- * rather than left to `mkdir`, because a directory that already exists keeps whatever mode it was
- * created with - and this one holds the evidence that decides who may signal the daemon. A `tui`
- * registrant passes its kind; everything else is an `rpc_host`.
+ * Creates this endpoint's directories and publishes the flat marker. A directory that already exists
+ * keeps whatever mode it was created with - and this one holds the evidence that decides who may
+ * signal the daemon - so an existing one is re-moded explicitly; one `mkdir` just created already
+ * has the mode. The siblings inside the endpoint directory and the marker are written concurrently.
+ * A `tui` registrant passes its kind; everything else is an `rpc_host`.
  */
 export declare function createDaemonDirectories(paths: HostDaemonPaths, identity?: {
     readonly kind?: EndpointKind;

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

@@ -159,27 +159,35 @@ export class HostDaemonStateError extends Error {
     }
 }
 /**
- * Creates this endpoint's directories and publishes the flat marker. The modes are set explicitly
- * rather than left to `mkdir`, because a directory that already exists keeps whatever mode it was
- * created with - and this one holds the evidence that decides who may signal the daemon. A `tui`
- * registrant passes its kind; everything else is an `rpc_host`.
+ * Creates this endpoint's directories and publishes the flat marker. A directory that already exists
+ * keeps whatever mode it was created with - and this one holds the evidence that decides who may
+ * signal the daemon - so an existing one is re-moded explicitly; one `mkdir` just created already
+ * has the mode. The siblings inside the endpoint directory and the marker are written concurrently.
+ * A `tui` registrant passes its kind; everything else is an `rpc_host`.
  */
 export async function createDaemonDirectories(paths, identity = {}) {
     try {
         // The flat directory may predate this layout and may hold a legacy host's files: it is created
         // when missing and never re-moded, so a legacy host keeps whatever it set up for itself.
         await mkdir(paths.flatDir, { recursive: true, mode: DIRECTORY_MODE });
-        for (const directory of [paths.dir, paths.generationsDir, paths.reservationsDir]) {
-            await mkdir(directory, { recursive: true, mode: DIRECTORY_MODE });
-            await chmod(directory, DIRECTORY_MODE);
-        }
-        await writeFile(paths.layoutMarker, `${JSON.stringify({ layout: HOST_DAEMON_LAYOUT, dir: basename(paths.dir) })}\n`, { mode: HOST_STATE_FILE_MODE });
+        await makePrivateDirectory(paths.dir);
+        await Promise.all([
+            makePrivateDirectory(paths.generationsDir),
+            makePrivateDirectory(paths.reservationsDir),
+            writeFile(paths.layoutMarker, `${JSON.stringify({ layout: HOST_DAEMON_LAYOUT, dir: basename(paths.dir) })}\n`, { mode: HOST_STATE_FILE_MODE }),
+        ]);
     }
     catch (cause) {
         throw new HostDaemonStateError(paths.dir, cause);
     }
     await ensureEndpointIdentity(paths, paths.socket, identity);
 }
+/** `mkdir` names the directory it created; only one that already existed needs its mode set. */
+async function makePrivateDirectory(directory) {
+    const created = await mkdir(directory, { recursive: true, mode: DIRECTORY_MODE });
+    if (created === undefined)
+        await chmod(directory, DIRECTORY_MODE);
+}
 /**
  * Writes `endpoint.json` when it is absent and never rewrites a valid one: the first writer's
  * `created_at` is the endpoint's birth. The file is written whole to a temporary name and LINKED

package/dist/modes/rpc/host-daemon-registration.d.ts

@@ -40,8 +40,13 @@ export declare function readHostRegistration(paths: HostDaemonPaths): Promise<Re
  * 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 declare function writeHostRegistration(paths: HostDaemonPaths, registration: HostRegistration): Promise<void>;
+export declare function writeHostRegistration(paths: HostDaemonPaths, registration: HostRegistration, options?: {
+    readonly fresh?: boolean;
+}): Promise<void>;
 /**
  * Records ONE generation's process in its own directory without moving the pointer. A handoff writes
  * this the moment its successor is spawned: until the rename lands the pointer must keep naming the

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/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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.10.9",
+	"version": "2026.10.10-2",
 	"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-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.10-2",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.10-2",
 		"@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-2",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.10-2",
 		"@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};