@code-yeongyu/senpi 2026.10.8 → 2026.10.10-2

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";
@@ -1319,6 +1328,9 @@ export type RpcExtensionUIRequest = {
     title: string;
     options: string[];
     timeout?: number;
+    /** The tool call this dialog approves, when it is a permission request. */
+    toolCallId?: string;
+    parentToolCallId?: string;
 } | {
     type: "extension_ui_request";
     id: string;
@@ -1333,6 +1345,8 @@ export type RpcExtensionUIRequest = {
     title: string;
     placeholder?: string;
     timeout?: number;
+    toolCallId?: string;
+    parentToolCallId?: string;
 } | {
     type: "extension_ui_request";
     id: string;

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
@@ -3562,6 +3597,19 @@ Prompt the user to choose from a list. Dialog methods with a `timeout` field inc
 
 Expected response: `extension_ui_response` with `value` (the selected option string) or `cancelled: true`.
 
+A permission prompt (title `Permission required: <permission>`) also carries `toolCallId`, the id of the tool call it approves, and `parentToolCallId` when another tool (for example a codemode script) issued that call. Clients bind the prompt to that call by id: the engine raises the prompts for every call of a message before any of them runs, so the order of `tool_execution_start` events does not say which call a prompt belongs to. The `input` that follows a "Deny with feedback" choice carries the same fields.
+
+```json
+{
+  "type": "extension_ui_request",
+  "id": "uuid-3",
+  "method": "select",
+  "title": "Permission required: read\n\nPath: /project/a.txt\n\nPatterns:\n  - /project/a.txt",
+  "options": ["Allow once", "Allow always", "Deny", "Deny with feedback"],
+  "toolCallId": "call-a"
+}
+```
+
 #### confirm
 
 Prompt the user for yes/no confirmation.

package/package.json

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

package/dist/bundle/chunks/chunk-VJJ53ORU.js

@@ -1,2 +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{engineBuildIdentity}from"./chunk-ZJHRDQCH.js";import{HOST_GENERATION_ENV,HOST_INSTANCE_ID_ENV}from"./chunk-CIRZTP7W.js";import{parseArgs,resolveSessionRuntime}from"./chunk-MH2BFYGN.js";import*as crypto from"node:crypto";var CUSTOM_UNSUPPORTED_CAPABILITY="custom_unsupported",EXTENSION_EVENTS_CAPABILITY="extension_events",AUTO_TITLE_SESSIONS_CAPABILITY="auto_title_sessions",CONTINUE_FROM_LEAF_CAPABILITY="continue_from_leaf",MEDIA_PLACEHOLDERS_CAPABILITY="media_placeholders",QUESTION_CAPABILITY="question",RETAIN_ON_DISCONNECT_CAPABILITY="retain_on_disconnect",SESSION_CONTEXT_CAPABILITY="session_context",SESSION_KIND_CAPABILITY="session_kind",AUTO_TITLE_PER_SESSION_CAPABILITY="auto_title_per_session",WARM_CAPABILITY="warm",DURABLE_SESSION_ID_CAPABILITY="durable_session_id",PROMPT_SURFACE_CAPABILITY="prompt_surface",BROWSER_ENGINE_CAPABILITY="browser_engine",RETRY_FALLBACK_PROFILE_CAPABILITY="retry_fallback_profile",PROMPT_SURFACE_CHAT_CAPABILITY="prompt_surface_chat",RPC_CLIENT_CAPABILITIES_ENV="SENPI_RPC_CLIENT_CAPABILITIES";function parseClientCapabilities(value){return value?value.split(",").map(part=>part.trim()).filter(part=>part.length>0):[]}var DEFAULT_CUSTOM_EXTENSION_LABEL="custom UI component";function buildCustomUnsupportedRequest(capabilities,extensionName){if(!capabilities?.includes(CUSTOM_UNSUPPORTED_CAPABILITY))return;let name=extensionName.trim()||DEFAULT_CUSTOM_EXTENSION_LABEL;return{type:"extension_ui_request",id:crypto.randomUUID(),method:"custom_unsupported",extensionName:name}}import{createHash,randomUUID as randomUUID2}from"node:crypto";import{resolve}from"node:path";var INSTANCE_ID=resolveInstanceId(process.env[HOST_INSTANCE_ID_ENV]);function resolveInstanceId(value){return value!==void 0&&value.trim()!==""?value:randomUUID2()}function hostInstanceId(){return INSTANCE_ID}var cachedProfile;function hostGeneration(env){let value=env[HOST_GENERATION_ENV];return value!==void 0&&/^\d+$/.test(value)?Number(value):0}function hostLaunchProfile(argv,cwd){let parsed=parseArgs([...argv],{grokNeoEnabled:!1}),core={extensions:[...new Set((parsed.extensions??[]).map(path=>resolve(cwd,path)))].sort(),multi_session:parsed.multiSession===!0,session_runtime:resolveSessionRuntime(parsed)},canonical=JSON.stringify({extensions:core.extensions,multi_session:core.multi_session,session_runtime:core.session_runtime});return{profile_id:createHash("sha256").update(canonical).digest("hex"),core}}function socketHostLaunchProfile(hostArgs,cwd){return hostLaunchProfile(["--mode","rpc","--multi-session","--listen","unix://",...hostArgs],cwd)}function protocolIdentity(){cachedProfile??=hostLaunchProfile(process.argv.slice(2),process.cwd());let build=engineBuildIdentity();return{instanceId:INSTANCE_ID,generation:hostGeneration(process.env),engineVersion:build.text,engineOrdinal:build.ordinal,launch_profile:cachedProfile}}export{CUSTOM_UNSUPPORTED_CAPABILITY,EXTENSION_EVENTS_CAPABILITY,AUTO_TITLE_SESSIONS_CAPABILITY,CONTINUE_FROM_LEAF_CAPABILITY,MEDIA_PLACEHOLDERS_CAPABILITY,QUESTION_CAPABILITY,RETAIN_ON_DISCONNECT_CAPABILITY,SESSION_CONTEXT_CAPABILITY,SESSION_KIND_CAPABILITY,AUTO_TITLE_PER_SESSION_CAPABILITY,WARM_CAPABILITY,DURABLE_SESSION_ID_CAPABILITY,PROMPT_SURFACE_CAPABILITY,BROWSER_ENGINE_CAPABILITY,RETRY_FALLBACK_PROFILE_CAPABILITY,PROMPT_SURFACE_CHAT_CAPABILITY,RPC_CLIENT_CAPABILITIES_ENV,parseClientCapabilities,DEFAULT_CUSTOM_EXTENSION_LABEL,buildCustomUnsupportedRequest,hostInstanceId,hostGeneration,hostLaunchProfile,socketHostLaunchProfile,protocolIdentity};