@code-yeongyu/senpi 2026.11.3-1 → 2026.11.3-2

package/dist/core/retry-fallback/settings.d.ts

@@ -43,7 +43,14 @@ export interface ResolvedRetryFallbackSettings {
  * `claude-opus-4-8` or `claude-opus-4-6` (senpi#3727).
  */
 export declare const DEFAULT_FALLBACK_CHAINS: FallbackChains;
-export declare function resolveRetryFallbackSettings(settings: RetrySettings | undefined): ResolvedRetryFallbackSettings;
+/**
+ * `sessionPolicy`: the chains were supplied by the session's opener (`open_session.retryFallback`,
+ * `set_retry_fallback`), so they are the session's whole policy and the shipped defaults are not merged
+ * back under them (senpi#4673). Settings-file chains still layer over the defaults.
+ */
+export declare function resolveRetryFallbackSettings(settings: RetrySettings | undefined, options?: {
+    readonly sessionPolicy?: boolean;
+}): ResolvedRetryFallbackSettings;
 export declare function resolveAbortServerSideFallback(settings: RetrySettings | undefined): boolean;
 export declare const DEFAULT_HINTED_WAIT_CAP_MS = 300000;
 export declare const DEFAULT_PROBE_BACK_MAX_MS = 3600000;

package/dist/core/retry-fallback/settings.js

@@ -46,13 +46,14 @@ function isStringArray(value) {
  * Cross-scope replacement (global vs project) stays wholesale and is handled by
  * `deepMergeSettings`; this only resolves defaults against the merged result.
  */
-function resolveFallbackChains(value) {
+function resolveFallbackChains(value, sessionPolicy) {
+    const base = () => (sessionPolicy ? {} : cloneDefaultFallbackChains());
     if (value === undefined || !isPlainObject(value))
-        return cloneDefaultFallbackChains();
-    const chains = cloneDefaultFallbackChains();
+        return base();
+    const chains = base();
     for (const [key, entries] of Object.entries(value)) {
         if (!isStringArray(entries))
-            return cloneDefaultFallbackChains();
+            return base();
         // An empty list stays in the map as a tombstone: canonicalization needs it to
         // suppress the expanded default for that family or provider variant, and
         // dropping it here would let the shipped default reappear after expansion.
@@ -60,10 +61,15 @@ function resolveFallbackChains(value) {
     }
     return chains;
 }
-export function resolveRetryFallbackSettings(settings) {
+/**
+ * `sessionPolicy`: the chains were supplied by the session's opener (`open_session.retryFallback`,
+ * `set_retry_fallback`), so they are the session's whole policy and the shipped defaults are not merged
+ * back under them (senpi#4673). Settings-file chains still layer over the defaults.
+ */
+export function resolveRetryFallbackSettings(settings, options = {}) {
     return {
         modelFallback: typeof settings?.modelFallback === "boolean" ? settings.modelFallback : true,
-        chains: resolveFallbackChains(settings?.fallbackChains),
+        chains: resolveFallbackChains(settings?.fallbackChains, options.sessionPolicy === true),
         revertPolicy: settings?.fallbackRevertPolicy === "never" ? "never" : "cooldown-expiry",
     };
 }

package/dist/core/session-log.js

@@ -7,7 +7,7 @@ const DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
 const MAX_STRING_LENGTH = 200;
 const DEBUG_PREFIX = `[${APP_NAME}-session]`;
 const BLOCKED_KEY = /^(?:__proto__|constructor|prototype|headers?|env(?:ironment)?|authorization|credential(?:s)?|password|secret|token|api_?key|client_?secret)$/i;
-const ALLOWED_DATA_KEY = /^(?:action|attemptId|disposition|stage|error|mode|count|willRetry|deferAdmission|delivered|restored|cause|accepted|skipped|rejectionCause|reason|durationMs|kind|retryable|phase|op|bytes|generation|requestId|tokens|tokensBefore|tokensAfter|contextWindow|attempt|aborted|sessionId|role|provider|model|source|actor|from|to|duringTurn|persistDefault|extension|handlerEvent|queuedId|ageMs)$/;
+const ALLOWED_DATA_KEY = /^(?:action|attemptId|disposition|stage|error|mode|count|willRetry|deferAdmission|delivered|restored|cause|accepted|skipped|rejectionCause|reason|durationMs|kind|retryable|phase|op|bytes|generation|requestId|tokens|tokensBefore|tokensAfter|contextWindow|attempt|aborted|sessionId|role|provider|model|source|actor|from|to|duringTurn|persistDefault|extension|handlerEvent|queuedId|ageMs|seat|until|shared)$/;
 const SENSITIVE_TEXT = /((?:authorization\s*[:=]\s*(?:bearer|basic)\s+)|(?:bearer\s+)|(?:[?&](?:api[_-]?key|token|secret|password|auth(?:orization)?)=))[^\s&,"'}\]]+/gi;
 export function createSessionLogger(agentDir, options = {}) {
     if (typeof agentDir !== "string" || agentDir.length === 0) {

package/dist/core/settings-manager.js

@@ -1285,7 +1285,10 @@ export class SettingsManager {
         return undefined;
     }
     getRetryFallbackSettings() {
-        return resolveRetryFallbackSettings(this.settings.retry);
+        // Chains in the session-only override layer (applyRetryFallbackProfile, or an SDK applyOverrides call) are the session's whole policy.
+        return resolveRetryFallbackSettings(this.settings.retry, {
+            sessionPolicy: this.runtimeOverrides.retry?.fallbackChains !== undefined,
+        });
     }
     getFallbackCircuitSettings() {
         return resolveFallbackCircuitSettings(this.settings.fallback);

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

@@ -1705,7 +1705,9 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
                         ...(origin === undefined ? {} : { origin }),
                     };
                 });
-                return success(id, "get_auth_providers", { providers });
+                // Read after the rows: building them re-reads a store that failed to load (#4413).
+                const storeError = modelRegistry.authStorage.getLoadError();
+                return success(id, "get_auth_providers", { providers, ...(storeError ? { storeError } : {}) });
             }
             case "login_start": {
                 // Respond IMMEDIATELY: success:true means the flow has started. The

package/dist/modes/rpc/effect-commands.d.ts

@@ -817,6 +817,7 @@ export declare function runSetThinkingLevel(ctx: EffectCommandContext, command:
     success: true;
     data: {
         providers: import("./rpc-session-state-types.ts").RpcAuthProvider[];
+        storeError?: import("./rpc-session-state-types.ts").RpcAuthStoreError;
     };
 } | {
     id?: string;

package/dist/modes/rpc/loopless-execute-grant.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Who may run tool calls on a loopless runtime (senpi#5413). Until the remote tool executor runs the extensions'
+ * `tool_call`/`tool_result` handlers (permission checks among them) for a tool-execution-only process, nothing in the
+ * product may execute through a loopless runtime: the only allowed caller is the in-process test harness. Closed and
+ * fail-closed: a runtime built without a grant this module issued refuses every call.
+ */
+declare const LOOPLESS_EXECUTE_CALLERS: readonly ["in-process-test-harness"];
+export type LooplessExecuteCaller = (typeof LOOPLESS_EXECUTE_CALLERS)[number];
+export interface LooplessExecuteGrant {
+    readonly caller: LooplessExecuteCaller;
+}
+export declare class LooplessExecuteRefusedError extends Error {
+    constructor(reason: string);
+}
+/** Issues the test harness's grant; anywhere but a Vitest run it refuses. */
+export declare function grantLooplessExecuteToTestHarness(): LooplessExecuteGrant;
+/** True only for a grant this module issued to an allowed caller. */
+export declare function isLooplessExecuteGranted(grant: LooplessExecuteGrant | undefined): boolean;
+export {};
+//# sourceMappingURL=loopless-execute-grant.d.ts.map

package/dist/modes/rpc/loopless-execute-grant.js

@@ -0,0 +1,26 @@
+/**
+ * Who may run tool calls on a loopless runtime (senpi#5413). Until the remote tool executor runs the extensions'
+ * `tool_call`/`tool_result` handlers (permission checks among them) for a tool-execution-only process, nothing in the
+ * product may execute through a loopless runtime: the only allowed caller is the in-process test harness. Closed and
+ * fail-closed: a runtime built without a grant this module issued refuses every call.
+ */
+const LOOPLESS_EXECUTE_CALLERS = ["in-process-test-harness"];
+const issued = new WeakSet();
+export class LooplessExecuteRefusedError extends Error {
+    constructor(reason) {
+        super(`loopless_execute_refused: ${reason}`);
+    }
+}
+/** Issues the test harness's grant; anywhere but a Vitest run it refuses. */
+export function grantLooplessExecuteToTestHarness() {
+    if (process.env.VITEST !== "true")
+        throw new LooplessExecuteRefusedError("only the in-process test harness may execute");
+    const grant = Object.freeze({ caller: "in-process-test-harness" });
+    issued.add(grant);
+    return grant;
+}
+/** True only for a grant this module issued to an allowed caller. */
+export function isLooplessExecuteGranted(grant) {
+    return grant !== undefined && issued.has(grant) && LOOPLESS_EXECUTE_CALLERS.includes(grant.caller);
+}
+//# sourceMappingURL=loopless-execute-grant.js.map

package/dist/modes/rpc/loopless-runtime-settings.d.ts

@@ -0,0 +1,30 @@
+import type { AgentSessionRuntimeDiagnostic } from "../../core/agent-session-services.ts";
+import type { ResourceLoaderReloadOptions } from "../../core/resource-loader.ts";
+import { SettingsManager } from "../../core/settings-manager.ts";
+import type { Args } from "../../cli/args.ts";
+import type { CliRuntimeConfiguration } from "../../main.ts";
+import type { LooplessRuntimeProfile } from "./runtime-factory-loopless.ts";
+export interface LooplessRuntimeSettings {
+    readonly settingsManager: SettingsManager;
+    readonly flagValues: Map<string, boolean | string>;
+    readonly reloadOptions: ResourceLoaderReloadOptions | undefined;
+}
+/**
+ * The project trust a session opened from this configuration would get, decided without a UI: a runtime without a
+ * loop has no one to ask, exactly like an RPC worker today (`createCliRuntimeFactory`, main.ts). A `project_trust`
+ * handler's error is reported to `diagnostics`, as the CLI factory reports it.
+ */
+export declare function resolveLooplessSettings(configuration: CliRuntimeConfiguration, startupSettingsManager: SettingsManager, profile: LooplessRuntimeProfile, diagnostics: AgentSessionRuntimeDiagnostic[]): Promise<LooplessRuntimeSettings>;
+export declare function resolveCliPaths(cwd: string, paths: string[] | undefined): string[] | undefined;
+export interface LooplessToolFilters {
+    readonly defaultToolNames?: ReadonlySet<string>;
+    readonly allowedToolNames?: ReadonlySet<string>;
+    readonly excludedToolNames?: ReadonlySet<string>;
+}
+/**
+ * The CLI's tool filters (`--tools`, `--no-tools`, `--no-builtin-tools`, `--exclude-tools`, settings `defaultTools`),
+ * mapped as `main.ts` maps them and resolved as `createAgentSession` resolves them (sdk.ts), so a loopless runtime
+ * registers exactly the tools a session registers for the same flags and settings.
+ */
+export declare function looplessToolFilters(parsed: Args, settingsManager: SettingsManager): LooplessToolFilters;
+//# sourceMappingURL=loopless-runtime-settings.d.ts.map

package/dist/modes/rpc/loopless-runtime-settings.js

@@ -0,0 +1,69 @@
+import { presetTrustsProject, resolveProjectTrusted } from "../../core/project-trust.js";
+import { sessionExtensionFlagValues } from "../../core/session-extension-flags.js";
+import { SettingsManager } from "../../core/settings-manager.js";
+import { getSavedProjectTrust, hasTrustRequiringProjectResources, ProjectTrustStore, } from "../../core/trust-manager.js";
+import { createProjectTrustContext } from "../../cli/project-trust.js";
+import { isLocalPath, resolvePath } from "../../utils/paths.js";
+/**
+ * The project trust a session opened from this configuration would get, decided without a UI: a runtime without a
+ * loop has no one to ask, exactly like an RPC worker today (`createCliRuntimeFactory`, main.ts). A `project_trust`
+ * handler's error is reported to `diagnostics`, as the CLI factory reports it.
+ */
+export async function resolveLooplessSettings(configuration, startupSettingsManager, profile, diagnostics) {
+    const { parsed, agentDir, appMode } = configuration;
+    const { cwd, launchProfile } = profile;
+    const trustStore = new ProjectTrustStore(agentDir);
+    const flagValues = sessionExtensionFlagValues(parsed.unknownFlags, launchProfile);
+    const hasTrustRequiringResources = hasTrustRequiringProjectResources(cwd);
+    const savedProjectTrust = await getSavedProjectTrust(trustStore, cwd);
+    const globalPreset = startupSettingsManager.getGlobalSettings()
+        .permissionPreset;
+    const fullAccessTrust = presetTrustsProject(flagValues.get("permission-preset"), globalPreset) && savedProjectTrust !== false;
+    const shouldResolveProjectTrust = parsed.projectTrustOverride === undefined && !fullAccessTrust && hasTrustRequiringResources;
+    const projectTrusted = shouldResolveProjectTrust
+        ? false
+        : (parsed.projectTrustOverride ?? (fullAccessTrust || !hasTrustRequiringResources || savedProjectTrust === true));
+    const trustFromFullAccess = fullAccessTrust &&
+        hasTrustRequiringResources &&
+        parsed.projectTrustOverride === undefined &&
+        savedProjectTrust !== true;
+    const settingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted, trustFromFullAccess });
+    const reloadOptions = shouldResolveProjectTrust
+        ? {
+            resolveProjectTrust: ({ extensionsResult }) => resolveProjectTrusted({
+                cwd,
+                trustStore,
+                trustOverride: parsed.projectTrustOverride,
+                defaultProjectTrust: startupSettingsManager.getDefaultProjectTrust(),
+                extensionsResult,
+                projectTrustContext: createProjectTrustContext({
+                    cwd,
+                    mode: appMode,
+                    settingsManager: startupSettingsManager,
+                    hasUI: false,
+                }),
+                onExtensionError: (message) => diagnostics.push({ type: "warning", message }),
+            }),
+        }
+        : undefined;
+    return { settingsManager, flagValues, reloadOptions };
+}
+export function resolveCliPaths(cwd, paths) {
+    return paths?.map((value) => (isLocalPath(value) ? resolvePath(value, cwd) : value));
+}
+/**
+ * The CLI's tool filters (`--tools`, `--no-tools`, `--no-builtin-tools`, `--exclude-tools`, settings `defaultTools`),
+ * mapped as `main.ts` maps them and resolved as `createAgentSession` resolves them (sdk.ts), so a loopless runtime
+ * registers exactly the tools a session registers for the same flags and settings.
+ */
+export function looplessToolFilters(parsed, settingsManager) {
+    const noTools = parsed.noTools ? "all" : parsed.noBuiltinTools ? "builtin" : undefined;
+    const defaultToolNames = parsed.tools === undefined && noTools === undefined ? settingsManager.getDefaultTools() : undefined;
+    const allowedToolNames = parsed.tools ?? (noTools === "all" ? [] : undefined);
+    return {
+        ...(defaultToolNames === undefined ? {} : { defaultToolNames: new Set(defaultToolNames) }),
+        ...(allowedToolNames === undefined ? {} : { allowedToolNames: new Set(allowedToolNames) }),
+        ...(parsed.excludeTools === undefined ? {} : { excludedToolNames: new Set(parsed.excludeTools) }),
+    };
+}
+//# sourceMappingURL=loopless-runtime-settings.js.map

package/dist/modes/rpc/loopless-tool-call.d.ts

@@ -0,0 +1,12 @@
+import type { AgentTool, AgentToolResult } from "@earendil-works/pi-agent-core";
+/**
+ * Runs one tool call the way the agent loop runs a model-issued one up to its hooks (`runToolCall`, agent-loop.ts):
+ * argument preparation and schema validation, then the tool. Invalid arguments and a failing tool come back as an
+ * `isError` result, never a rejection (senpi#5413).
+ */
+export declare function runLooplessToolCall(tool: AgentTool, call: {
+    readonly toolCallId: string;
+    readonly params: unknown;
+    readonly signal?: AbortSignal;
+}): Promise<AgentToolResult<unknown>>;
+//# sourceMappingURL=loopless-tool-call.d.ts.map

package/dist/modes/rpc/loopless-tool-call.js

@@ -0,0 +1,22 @@
+import { validateToolArguments } from "@earendil-works/pi-ai";
+function errorResult(message) {
+    return { content: [{ type: "text", text: message }], details: undefined, isError: true };
+}
+/**
+ * Runs one tool call the way the agent loop runs a model-issued one up to its hooks (`runToolCall`, agent-loop.ts):
+ * argument preparation and schema validation, then the tool. Invalid arguments and a failing tool come back as an
+ * `isError` result, never a rejection (senpi#5413).
+ */
+export async function runLooplessToolCall(tool, call) {
+    const { toolCallId, signal } = call;
+    try {
+        const prepared = tool.prepareArguments ? tool.prepareArguments(call.params) : call.params;
+        const toolCall = { type: "toolCall", id: toolCallId, name: tool.name, arguments: prepared };
+        const args = validateToolArguments(tool, toolCall);
+        return await tool.execute(toolCallId, args, signal, undefined);
+    }
+    catch (error) {
+        return errorResult(error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=loopless-tool-call.js.map

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

@@ -11,7 +11,7 @@ import type { ThinkingLevelSource } from "../../core/session-thinking-memory.ts"
 import type { EffectStatus } from "./effect-record.ts";
 import type { RpcSlashCommand } from "./rpc-command-surface.ts";
 import type { RpcEvalCell, RpcEvalCellSnapshot } from "./rpc-result-types.ts";
-import type { RpcAuthProvider, RpcLoadedExtension, RpcLoadedMcpServer, RpcProviderAccount, RpcSessionState } from "./rpc-session-state-types.ts";
+import type { RpcAuthProvider, RpcAuthStoreError, RpcLoadedExtension, RpcLoadedMcpServer, RpcProviderAccount, RpcSessionState } from "./rpc-session-state-types.ts";
 import type { RpcSnapshot } from "./snapshot-types.ts";
 export type RpcReadResponse = {
     id?: string;
@@ -215,6 +215,7 @@ export type RpcReadResponse = {
     success: true;
     data: {
         providers: RpcAuthProvider[];
+        storeError?: RpcAuthStoreError;
     };
 } | {
     id?: string;

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

@@ -27,6 +27,16 @@ export interface RpcAuthProvider {
     /** Where the provider is defined, so a client can name the file or extension to edit (senpi#4328). */
     origin?: ProviderOrigin;
 }
+/**
+ * `get_auth_providers` `storeError`: auth.json exists but could not be loaded, so stored sign-ins read
+ * as unconfigured and every write is refused until it is repaired. `write_back_failed` is the exception:
+ * the file was read, so its sign-ins stay configured and writes are not refused (senpi#4413).
+ * Never a path or contents.
+ */
+export interface RpcAuthStoreError {
+    kind: "malformed_json" | "invalid_format" | "unreadable" | "write_back_failed";
+    reason: string;
+}
 /** Auth status mirror (no credential values), from getProviderAuthStatus. */
 export interface RpcAuthStatus {
     configured: boolean;

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

@@ -16,7 +16,7 @@ export type { EditAssistantMessageResult, EditUserMessageResult, NavigateTreeRes
 export type { RpcWhenIdle } from "./rpc-session-command-types.ts";
 export { STEER_WHEN_IDLE_CAPABILITY, USER_ACTIVITY_CAPABILITY } from "./rpc-session-command-types.ts";
 export type { RpcAccountFailoverEvent, RpcAuthAccountsChangedEvent, RpcExtensionEvent, RpcHighReasoningWarningEvent, RpcLoadedSurfacesChangedEvent, RpcModelChangedEvent, RpcOpenQueuedEvent, RpcPendingInputUpdateEvent, RpcServiceTierChangedEvent, RpcSessionClosedEvent, RpcSessionClosedReason, RpcSessionOpenedEvent, RpcSessionParkedEvent, RpcSessionReplacedEvent, RpcSettingsSourceSelectedEvent, RpcSkillInvocationEvent, RpcThinkingLevelChangedEvent, } from "./rpc-session-event-types.ts";
-export type { RpcAuthProvider, RpcAuthStatus, RpcLoadedExtension, RpcLoadedMcpServer, RpcMcpServerStatus, RpcProviderAccount, RpcSessionModelEntry, RpcSessionState, } from "./rpc-session-state-types.ts";
+export type { RpcAuthProvider, RpcAuthStatus, RpcAuthStoreError, RpcLoadedExtension, RpcLoadedMcpServer, RpcMcpServerStatus, RpcProviderAccount, RpcSessionModelEntry, RpcSessionState, } from "./rpc-session-state-types.ts";
 export type { SessionEffectStatusRecord as RpcEffectStatusEvent } from "./session-effect-status.ts";
 export type { SessionStatusRecord as RpcSessionStatusEvent } from "./session-status.ts";
 //# sourceMappingURL=rpc-types.d.ts.map

package/dist/modes/rpc/runtime-factory-loopless.d.ts

@@ -0,0 +1,57 @@
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { AgentSessionLaunchProfile } from "../../core/agent-session-runtime.ts";
+import { type AgentSessionRuntimeDiagnostic } from "../../core/agent-session-services.ts";
+import type { InlineExtension } from "../../core/extensions/types.ts";
+import { type ToolDefinitionEntry } from "../../core/runtime/bootstrap.ts";
+import { SettingsManager } from "../../core/settings-manager.ts";
+import type { CliRuntimeConfiguration } from "../../main.ts";
+import { type LooplessExecuteGrant } from "./loopless-execute-grant.ts";
+/**
+ * A session worker's runtime with the agent loop removed (brain/hand split, senpi#5413): the same
+ * built-in and extension tools a full session serves, executed one call at a time, with no agent loop,
+ * no model binding and no transcript. Its extension runtime is never bound to a loop, so an extension
+ * that tries to drive one (`pi.sendUserMessage`, `pi.setModel`, ...) is refused.
+ */
+export interface LooplessRuntime {
+    readonly cwd: string;
+    /** Every tool this runtime serves: built-ins first, then extension tools, a later name replacing an earlier one. */
+    readonly definitions: ReadonlyMap<string, ToolDefinitionEntry>;
+    /** What building the runtime reported: settings, extension load and `project_trust` handler diagnostics. */
+    readonly diagnostics: readonly AgentSessionRuntimeDiagnostic[];
+    /**
+     * Runs one tool call: argument preparation and schema validation as the loop does, then the tool. An unknown
+     * name is refused before anything runs; invalid arguments and a failing tool come back as an `isError` result.
+     *
+     * It does NOT run the extensions' `tool_call`/`tool_result` handlers (permission checks among them): where those
+     * run for a call that reaches a tool-execution-only process is decided by the remote tool executor that calls
+     * this runtime, including forwarding a two-sided extension's handlers to the process that owns the session.
+     * Until that executor exists, a runtime refuses every call unless it was built with a grant from the closed
+     * allowlist in `loopless-execute-grant.ts` (the in-process test harness only).
+     */
+    execute(name: string, toolCallId: string, params: unknown, signal?: AbortSignal): Promise<AgentToolResult<unknown>>;
+    /** Marks its extension contexts stale, then closes the tool work and the tool child it still runs. */
+    dispose(): Promise<void>;
+}
+export interface LooplessRuntimeProfile {
+    cwd: string;
+    launchProfile?: Readonly<AgentSessionLaunchProfile>;
+}
+export type LooplessRuntimeFactory = (profile: LooplessRuntimeProfile) => Promise<LooplessRuntime>;
+export declare class LooplessToolNotFoundError extends Error {
+    readonly toolName: string;
+    constructor(toolName: string);
+}
+/**
+ * Builds loopless runtimes from the same launch configuration as `createCliRuntimeFactory`: the same
+ * cwd-bound services (settings, project trust, model registry, extensions and their flags), then the tool
+ * registry through `bootstrapRuntime()` / `buildToolRegistry()` (senpi#5222) on a runner without a session
+ * (senpi#5223), so nothing is ever written to a session file. Tools are placed by the same tool-child runtime
+ * a session builds (senpi#5227), so `--tool-runtime child` runs child-placed work on this runtime's own child.
+ */
+export declare function createLooplessRuntimeFactory(configuration: CliRuntimeConfiguration, local?: {
+    extensionFactories?: InlineExtension[];
+    startupSettingsManager?: SettingsManager;
+    /** Required for `execute`; see `loopless-execute-grant.ts`. */
+    executeGrant?: LooplessExecuteGrant;
+}): LooplessRuntimeFactory;
+//# sourceMappingURL=runtime-factory-loopless.d.ts.map

package/dist/modes/rpc/runtime-factory-loopless.js

@@ -0,0 +1,131 @@
+import { randomUUID } from "node:crypto";
+import { createAgentSessionServices } from "../../core/agent-session-services.js";
+import { bootstrapRuntime, buildToolRegistry } from "../../core/runtime/bootstrap.js";
+import { SettingsManager } from "../../core/settings-manager.js";
+import { childModuleRoots } from "../../core/tool-dispatch/offload.js";
+import { createToolChildRuntime } from "../../core/tool-dispatch/tool-child-runtime.js";
+import { builtInExtensions } from "../../extensions/index.js";
+import { looplessToolFilters, resolveCliPaths, resolveLooplessSettings } from "./loopless-runtime-settings.js";
+import { isLooplessExecuteGranted, LooplessExecuteRefusedError, } from "./loopless-execute-grant.js";
+import { runLooplessToolCall } from "./loopless-tool-call.js";
+import { toolChildModuleRoots } from "./tool-child/session-child.js";
+export class LooplessToolNotFoundError extends Error {
+    constructor(toolName) {
+        super(`loopless_tool_not_found: ${toolName}`);
+        this.toolName = toolName;
+    }
+}
+/**
+ * Builds loopless runtimes from the same launch configuration as `createCliRuntimeFactory`: the same
+ * cwd-bound services (settings, project trust, model registry, extensions and their flags), then the tool
+ * registry through `bootstrapRuntime()` / `buildToolRegistry()` (senpi#5222) on a runner without a session
+ * (senpi#5223), so nothing is ever written to a session file. Tools are placed by the same tool-child runtime
+ * a session builds (senpi#5227), so `--tool-runtime child` runs child-placed work on this runtime's own child.
+ */
+export function createLooplessRuntimeFactory(configuration, local = {}) {
+    const { parsed, agentDir, toolRuntime } = configuration;
+    const extensionFactories = local.extensionFactories ?? builtInExtensions;
+    const startupSettingsManager = local.startupSettingsManager ?? SettingsManager.create(configuration.cwd, configuration.agentDir);
+    return async (profile) => {
+        const { cwd } = profile;
+        const diagnostics = [];
+        const { settingsManager, flagValues, reloadOptions } = await resolveLooplessSettings(configuration, startupSettingsManager, profile, diagnostics);
+        const services = await createAgentSessionServices({
+            cwd,
+            agentDir,
+            settingsManager,
+            modelRuntimeSignal: AbortSignal.timeout(15_000),
+            extensionFlagValues: flagValues,
+            ...(reloadOptions ? { resourceLoaderReloadOptions: reloadOptions } : {}),
+            resourceLoaderOptions: {
+                sessionKind: profile.launchProfile?.sessionKind,
+                sessionContext: profile.launchProfile?.sessionContext,
+                additionalExtensionPaths: resolveCliPaths(cwd, parsed.extensions),
+                additionalSkillPaths: resolveCliPaths(cwd, parsed.skills),
+                additionalPromptTemplatePaths: resolveCliPaths(cwd, parsed.promptTemplates),
+                additionalThemePaths: resolveCliPaths(cwd, parsed.themes),
+                noExtensions: parsed.noExtensions,
+                noSkills: parsed.noSkills,
+                noPromptTemplates: parsed.noPromptTemplates,
+                noThemes: parsed.noThemes,
+                noContextFiles: parsed.noContextFiles,
+                extensionFactories,
+            },
+        });
+        const extensionsResult = services.resourceLoader.getExtensions();
+        diagnostics.push(...services.diagnostics, ...extensionsResult.errors.map(({ path, error }) => ({
+            type: "warning",
+            message: `Failed to load extension "${path}": ${error}`,
+        })), ...(extensionsResult.warnings ?? []).map(({ path, warning }) => ({
+            type: "warning",
+            message: `Extension package "${path}": ${warning}`,
+        })));
+        let execute = () => Promise.reject(new Error("Loopless runtime is not ready"));
+        let toolNames = () => [];
+        const toolChildRuntime = createToolChildRuntime({
+            toolRuntime: toolRuntime ?? "in-process",
+            agentDir,
+            scopeId: `loopless-${randomUUID()}`,
+            cwd: services.cwd,
+            moduleRoots: () => [
+                ...toolChildModuleRoots(runtime.extensionRunner.getAllRegisteredTools()),
+                ...childModuleRoots(runtime.extensionRunner.getAllChildModules()),
+            ],
+            hostCallDeps: {
+                cwd: services.cwd,
+                executeNested: async (_parentToolCallId, name, args, signal) => {
+                    const toolCall = { type: "toolCall", id: `nested-${randomUUID()}`, name, arguments: {} };
+                    const result = await execute(name, toolCall.id, args, signal);
+                    return { toolCall, result, isError: result.isError === true };
+                },
+                callableToolNames: () => toolNames(),
+                target: () => undefined,
+                filesystemPolicy: () => runtime.filesystemPolicy,
+            },
+            onRecord: () => { },
+        });
+        const { dispatcher, toolChild } = toolChildRuntime;
+        const runtime = bootstrapRuntime({
+            cwd: services.cwd,
+            settingsManager: services.settingsManager,
+            extensionsResult,
+            modelRegistry: services.modelRegistry,
+            toolDispatcher: dispatcher,
+        });
+        const registry = buildToolRegistry({
+            baseToolDefinitions: runtime.baseToolDefinitions,
+            runner: runtime.extensionRunner,
+            dispatcher,
+            ...looplessToolFilters(parsed, services.settingsManager),
+        });
+        toolNames = () => [...registry.toolRegistry.keys()];
+        execute = (name, toolCallId, params, signal) => {
+            if (!isLooplessExecuteGranted(local.executeGrant))
+                return Promise.reject(new LooplessExecuteRefusedError("no executor runs the tool_call/tool_result handlers for this runtime yet"));
+            const tool = registry.toolRegistry.get(name);
+            if (tool === undefined)
+                return Promise.reject(new LooplessToolNotFoundError(name));
+            return runLooplessToolCall(tool, {
+                toolCallId,
+                params,
+                ...(signal ? { signal } : {}),
+            });
+        };
+        return {
+            cwd: services.cwd,
+            definitions: registry.definitions,
+            diagnostics,
+            execute: (name, toolCallId, params, signal) => execute(name, toolCallId, params, signal),
+            dispose: async () => {
+                // Stale first, as a session disposes: a close that fails must not leave the contexts usable.
+                runtime.extensionRunner.invalidate("This loopless runtime was disposed.");
+                // Both closes run to the end; the first failure is then reported to the caller.
+                const closed = await Promise.allSettled([dispatcher.dispose(), toolChild?.close()]);
+                const failure = closed.find((outcome) => outcome.status === "rejected");
+                if (failure !== undefined)
+                    throw failure.reason;
+            },
+        };
+    };
+}
+//# sourceMappingURL=runtime-factory-loopless.js.map

package/docs/development.md

@@ -70,7 +70,7 @@ Never use `__dirname` directly for package assets.
 ```bash
 bun run test            # Vitest across workspaces (skips live-API; default test runner)
 ./pi-test.sh        # Launch the CLI from source via tsx for manual testing (--no-env unsets API keys)
-bun run check       # oxlint + oxfmt + lint ratchet + tsc + browser-smoke check (pre-commit equivalent)
+bun run check       # oxlint + bun fmt + lint ratchet + tsc + browser-smoke check (pre-commit equivalent)
 ```
 
 Live-API tests are env-gated vitest tests. Set `PI_ENABLE_LIVE_API_TESTS=1` (or a per-provider flag from `packages/ai/test/live-api-gates.ts`) plus the provider API keys, then run `bun run test`.

package/docs/rpc.md

@@ -6268,6 +6268,8 @@ A provider whose API-key login asks a region (Kimi Code: `"mainland-cn"` or `"gl
 
 A provider holds logins of one kind. If it had an OAuth login, the key replaces it: `auth.json` is backed up first, and the response `data` is `{replaced: "oauth", backupPath?}`, where `backupPath` is absent when the credential store is not a file (a failed backup fails the login instead). A key added over another key has no `data`.
 
+When `auth.json` exists but cannot be loaded, `get_auth_providers` `data` also carries `storeError` `{kind, reason}`. `kind` is `malformed_json` (not valid JSON), `invalid_format` (the document is not a JSON object), `unreadable` (the file cannot be read, for example a permission error) or `write_back_failed` (the file was read, but saving its repaired or migrated copy failed; the sign-ins it read stay configured and writes are not refused for this kind). `reason` is a short message that never includes the file's path or contents. While `storeError` has any other kind, a stored sign-in reads as unconfigured because it could not be read, not because it is missing (a store that loaded earlier in the process keeps its last loaded sign-ins). Every write, such as `login_api_key`, a login, or `logout`, fails and leaves the file unchanged. A client should say the sign-in store could not be read and ask the user to repair or move `auth.json`. The next `get_auth_providers` after the file becomes readable no longer has `storeError`. A store that is only locked by another writer is not a `storeError`.
+
 `get_auth_providers` API-key rows carry `keyHint`, the last four characters of a literal key the app stored when it is at least 12 characters long. OAuth rows, `!command` and `$ENV` references, and short keys have none.
 
 Every `get_auth_providers` row whose provider is defined carries `origin`, which says where the definition lives so a client can name what to edit when the app cannot remove the entry itself:

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.11.3-1",
+	"version": "2026.11.3-2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -83,9 +83,9 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.11.3-1",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.11.3-1",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.11.3-1",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.11.3-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.11.3-2",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.11.3-2",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"ajv": "8.20.0",
 		"chalk": "6.0.0",
@@ -106,8 +106,8 @@
 		"yaml": "2.9.1",
 		"@anthropic-ai/claude-agent-sdk": "0.3.306",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.11.3-1",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.11.3-1",
+		"@code-yeongyu/senpi-codemode": "2026.11.3-2",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.11.3-2",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",