@code-yeongyu/senpi 2026.10.26-2 → 2026.10.27-1

package/dist/core/extensions/builtin/mcp/modern/request.js

@@ -1,6 +1,6 @@
 import { beginLegacyMcpOperation, physicalMcpClient, takeMcpRequestOrigin, } from "../request-origin.js";
 import { AuthError } from "../errors.js";
-import { loadMcpSdkTypes, loadMcpSdkZodCompat } from "../sdk.lazy.js";
+import { loadMcpSdkProtocol, loadMcpSdkTypes, loadMcpSdkZodCompat } from "../sdk.lazy.js";
 import { mcpElapsedClock } from "../wrap.js";
 import { collectMrtrForm } from "./elicitation.js";
 import { isRecord, validateMrtrForm } from "./form-schema.js";
@@ -45,8 +45,9 @@ export function installModernRequestAdapter(client, protocol, clock = mcpElapsed
         if (own(request.params ?? {}, "requestState") || own(request.params ?? {}, "inputResponses") || options?.task)
             throw new McpMrtrError("MCP_MRTR_INVALID_INPUT");
         const params = structuredClone(request.params ?? {});
+        const { DEFAULT_REQUEST_TIMEOUT_MSEC } = await loadMcpSdkProtocol();
         const start = clock.now();
-        const timeout = sdkOptions.timeout ?? 60_000;
+        const timeout = sdkOptions.timeout ?? DEFAULT_REQUEST_TIMEOUT_MSEC;
         const duration = Math.min(sdkOptions.maxTotalTimeout ?? Infinity, 9 * timeout + 300_000);
         const deadline = start + duration;
         const operation = new AbortController();

package/dist/core/extensions/builtin/mcp/sdk.lazy.d.ts

@@ -21,6 +21,8 @@ export declare const loadMcpSdkZodCompat: () => Promise<typeof import("@modelcon
 export declare const loadMcpSdkStdioTransport: () => Promise<typeof import("@modelcontextprotocol/sdk/client/stdio.js")>;
 /** SDK-owned protocol schemas for elicitation and modern request results. */
 export declare const loadMcpSdkTypes: () => Promise<typeof import("@modelcontextprotocol/sdk/types.js")>;
+/** SDK-owned request defaults, loaded only by negotiated modern operations. */
+export declare const loadMcpSdkProtocol: () => Promise<typeof import("@modelcontextprotocol/sdk/shared/protocol.js")>;
 /** OAuth 2.1 discovery, authorization, token exchange and refresh. */
 export declare const loadMcpSdkAuth: () => Promise<typeof import("@modelcontextprotocol/sdk/client/auth.js")>;
 /**

package/dist/core/extensions/builtin/mcp/sdk.lazy.js

@@ -42,6 +42,8 @@ export const loadMcpSdkZodCompat = memoizeLoader(() => import("@modelcontextprot
 export const loadMcpSdkStdioTransport = memoizeLoader(() => import("@modelcontextprotocol/sdk/client/stdio.js"));
 /** SDK-owned protocol schemas for elicitation and modern request results. */
 export const loadMcpSdkTypes = memoizeLoader(() => import("@modelcontextprotocol/sdk/types.js"));
+/** SDK-owned request defaults, loaded only by negotiated modern operations. */
+export const loadMcpSdkProtocol = memoizeLoader(() => import("@modelcontextprotocol/sdk/shared/protocol.js"));
 let authModule;
 /** OAuth 2.1 discovery, authorization, token exchange and refresh. */
 export const loadMcpSdkAuth = memoizeLoader(async () => {

package/dist/core/extensions/builtin/mcp/transport-sdk.js

@@ -89,6 +89,17 @@ function pipeStderr(transport, logger, sink, protocol) {
     const stderr = transport.stderr;
     if (stderr === undefined || stderr === null)
         return;
+    const start = transport.start.bind(transport);
+    transport.start = async () => {
+        const onclose = transport.onclose;
+        transport.onclose = () => {
+            stderrEnded = true;
+            if (protocol.version === undefined)
+                protocol.resolveStdioDiagnostics?.(false);
+            onclose?.();
+        };
+        await start();
+    };
     const logLine = (line) => {
         // Arbitrary server text may echo private messages, schemas, or answers. Keep diagnostic
         // events and allowlisted system error codes, never untrusted payload text under enforcement.
@@ -127,7 +138,7 @@ function pipeStderr(transport, logger, sink, protocol) {
             return;
         const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
         if (!protocol.legacy && !protocol.privateForms) {
-            // Only legacy-positive negotiation may release startup diagnostics.
+            // Release only after legacy classification or an unclassified child's exit.
             undecided += text.slice(0, Math.max(0, 512 * 1024 - undecided.length));
             return;
         }

package/dist/modes/interactive/interactive-mode.d.ts

@@ -329,7 +329,8 @@ export declare class InteractiveMode {
      */
     private unsubscribeSecurityNotices?;
     private detachMcpGrantPresentation?;
-    private mcpMrtrPresentationLifetime;
+    /** A presentation is optional until extension UI is created; shutdown may precede it. */
+    private mcpMrtrPresentationLifetime?;
     private mcpLocalPresenter?;
     private bindCurrentSessionExtensions;
     private applyFullscreenScrollbarSetting;

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

@@ -691,7 +691,6 @@ export class InteractiveMode {
         this.onRightClickPaste = () => {
             void this.handleRightClickPaste();
         };
-        this.mcpMrtrPresentationLifetime = new AbortController();
         /**
          * Gracefully shutdown the agent.
          * Stops the TUI before emitting shutdown events so extension UI cleanup cannot
@@ -2859,6 +2858,8 @@ export class InteractiveMode {
     }
     createExtensionUIContext() {
         this.mcpMrtrPresentationLifetime ??= new AbortController();
+        if (this.isShuttingDown)
+            this.mcpMrtrPresentationLifetime.abort();
         const context = {
             select: (title, options, opts) => this.withBlockedHostDialog(crypto.randomUUID(), title, () => this.showExtensionSelector(title, options, opts), opts),
             confirm: async (title, message, opts) => (await this.withBlockedHostDialog(crypto.randomUUID(), title, () => this.showExtensionConfirm(title, message, opts), opts)) ?? false,

package/dist/modes/rpc/compact-commit-dependencies.d.ts

@@ -0,0 +1,13 @@
+import type { CompactContentStore, LeafId } from "./compact-content-store.ts";
+/** Per-owner readiness, independent of counted references: one leaf can unblock many rows/trees. */
+export declare class CompactCommitDependencies<Key> {
+    private readonly pending;
+    private readonly dependants;
+    private readonly store;
+    constructor(store: CompactContentStore, ready: (key: Key) => void);
+    get size(): number;
+    has(key: Key): boolean;
+    set(key: Key, refs: readonly LeafId[]): void;
+    delete(key: Key): void;
+}
+//# sourceMappingURL=compact-commit-dependencies.d.ts.map

package/dist/modes/rpc/compact-commit-dependencies.js

@@ -0,0 +1,48 @@
+/** Per-owner readiness, independent of counted references: one leaf can unblock many rows/trees. */
+export class CompactCommitDependencies {
+    constructor(store, ready) {
+        this.pending = new Map();
+        this.dependants = new Map();
+        this.store = store;
+        store.subscribeCommitted((id) => {
+            const keys = this.dependants.get(id);
+            this.dependants.delete(id);
+            for (const key of keys ?? []) {
+                const pending = this.pending.get(key);
+                pending?.delete(id);
+                if (pending?.size === 0) {
+                    this.pending.delete(key);
+                    ready(key);
+                }
+            }
+        });
+    }
+    get size() {
+        return this.pending.size;
+    }
+    has(key) {
+        return this.pending.has(key);
+    }
+    set(key, refs) {
+        this.delete(key);
+        const pending = new Set(refs.filter((id) => !this.store.isCommitted(id)));
+        if (pending.size === 0)
+            return;
+        this.pending.set(key, pending);
+        for (const id of pending) {
+            const keys = this.dependants.get(id) ?? new Set();
+            keys.add(key);
+            this.dependants.set(id, keys);
+        }
+    }
+    delete(key) {
+        for (const id of this.pending.get(key) ?? []) {
+            const keys = this.dependants.get(id);
+            keys?.delete(key);
+            if (keys?.size === 0)
+                this.dependants.delete(id);
+        }
+        this.pending.delete(key);
+    }
+}
+//# sourceMappingURL=compact-commit-dependencies.js.map

package/dist/modes/rpc/compact-content-index.d.ts

@@ -41,10 +41,10 @@ export declare class CompactContentIndex<Row extends object> {
     private readonly overrides;
     /** Uncommitted leaves per row override; only overrides absent here are eligible to fold. */
     private readonly unsettledLeaves;
-    private readonly leafKey;
     private compacting;
     private tombstones;
     private tombstoneKeyUnits;
+    private readonly frozen;
     constructor(store: CompactContentStore, leavesOf: (row: Row) => readonly LeafId[], compactAboveRows: number);
     has(key: string): boolean;
     set(key: string, row: Row): void;
@@ -64,7 +64,6 @@ export declare class CompactContentIndex<Row extends object> {
     };
     /** The acceptance path checks counts only: an override is eligible once none of its leaves is uncommitted. */
     maybeCompact(): void;
-    private committed;
     /** Folds eligible overrides and every small base page; false leaves the previous base untouched. */
     private compact;
     /**

package/dist/modes/rpc/compact-content-index.js

@@ -1,18 +1,18 @@
+import { CompactCommitDependencies } from "./compact-commit-dependencies.js";
 import { isSmallPage, packPages } from "./compact-index-pages.js";
+import { CompactReadError } from "./compact-read-lease.js";
 export class CompactContentIndex {
     constructor(store, leavesOf, compactAboveRows) {
         this.base = { pages: [], pageOf: new Map() };
         this.overrides = new Map();
-        /** Uncommitted leaves per row override; only overrides absent here are eligible to fold. */
-        this.unsettledLeaves = new Map();
-        this.leafKey = new Map();
         this.compacting = false;
         this.tombstones = 0;
         this.tombstoneKeyUnits = 0;
+        this.frozen = new WeakSet();
         this.store = store;
         this.leavesOf = leavesOf;
         this.compactAboveRows = compactAboveRows;
-        store.onCommitted = (id) => this.committed(id);
+        this.unsettledLeaves = new CompactCommitDependencies(store, () => this.maybeCompact());
     }
     has(key) {
         const override = this.overrides.get(key);
@@ -42,9 +42,13 @@ export class CompactContentIndex {
             page.pins++;
         for (const override of this.overrides.values())
             this.pinRow(override, 1);
-        return { base: this.base, overrides: new Map(this.overrides) };
+        const frozen = { base: this.base, overrides: new Map(this.overrides) };
+        this.frozen.add(frozen);
+        return frozen;
     }
     release(frozen) {
+        if (!this.frozen.delete(frozen))
+            return;
         for (const override of frozen.overrides.values())
             this.pinRow(override, -1);
         for (const page of frozen.base.pages) {
@@ -55,6 +59,8 @@ export class CompactContentIndex {
     }
     /** Every row visible at a frozen root, reading only that root's own pages. */
     async entries(frozen) {
+        if (!this.frozen.has(frozen))
+            throw new CompactReadError("released");
         const rows = new Map();
         for (const page of frozen.base.pages)
             for (const [key, row] of await this.readPage(page))
@@ -90,18 +96,6 @@ export class CompactContentIndex {
                 this.maybeCompact();
         });
     }
-    committed(id) {
-        const key = this.leafKey.get(id);
-        if (key === undefined)
-            return;
-        this.leafKey.delete(id);
-        const left = (this.unsettledLeaves.get(key) ?? 0) - 1;
-        if (left > 0)
-            this.unsettledLeaves.set(key, left);
-        else
-            this.unsettledLeaves.delete(key);
-        this.maybeCompact();
-    }
     /** Folds eligible overrides and every small base page; false leaves the previous base untouched. */
     async compact() {
         const base = this.base;
@@ -204,11 +198,7 @@ export class CompactContentIndex {
             this.store.adjust(id, 1, 0);
         this.drop(key);
         this.overrides.set(key, override);
-        const unsettled = leaves.filter((id) => !this.store.isCommitted(id));
-        for (const id of unsettled)
-            this.leafKey.set(id, key);
-        if (unsettled.length > 0)
-            this.unsettledLeaves.set(key, unsettled.length);
+        this.unsettledLeaves.set(key, leaves);
         if (override.kind === "tombstone")
             this.countTombstone(key, 1);
         this.maybeCompact();
@@ -221,7 +211,6 @@ export class CompactContentIndex {
         this.unsettledLeaves.delete(key);
         if (old.kind === "row") {
             for (const id of this.leavesOf(old.row)) {
-                this.leafKey.delete(id);
                 this.store.adjust(id, -1, 0);
             }
         }

package/dist/modes/rpc/compact-content-store.d.ts

@@ -1,5 +1,6 @@
 import { CompactSpoolStorage } from "./compact-spool-storage.ts";
 import { type CompactStorageFailure, type CompactStorageIo } from "./compact-storage-io.ts";
+import { CompactTextRoots } from "./compact-text-roots.ts";
 /**
  * Owned bounded leaves for compact current state (senpi#4272, R3.C6.4 / R3.C2.4).
  *
@@ -41,8 +42,11 @@ export declare class CompactContentStore extends CompactSpoolStorage {
     private residentPayloadBytes;
     private pinnedOnlyBytes;
     private spilledLiveBytes;
-    /** Called after a leaf commits, so index compaction can include rows that now reference only disk. */
-    onCommitted: ((id: LeafId) => void) | undefined;
+    private readonly subscribers;
+    readonly text: CompactTextRoots;
+    subscribeCommitted(listener: (id: LeafId) => void): void;
+    committed(id: LeafId): void;
+    leafUnits(id: LeafId): number;
     constructor(options: CompactContentStoreOptions);
     /** Takes ownership of an immutable value with one live reference. */
     createLeaf(text: string): LeafId;

package/dist/modes/rpc/compact-content-store.js

@@ -1,5 +1,7 @@
 import { CompactSpoolStorage, RECLAIM_WORK_ALLOWANCE_BYTES } from "./compact-spool-storage.js";
 import { nodeCompactStorageIo } from "./compact-storage-io.js";
+import { CompactReadError } from "./compact-read-lease.js";
+import { CompactTextRoots } from "./compact-text-roots.js";
 /**
  * Owned bounded leaves for compact current state (senpi#4272, R3.C6.4 / R3.C2.4).
  *
@@ -11,6 +13,19 @@ import { nodeCompactStorageIo } from "./compact-storage-io.js";
 /** 32,768 UTF-16 code units (64 KiB as UTF-16LE), so a split surrogate survives a leaf boundary exactly. */
 export const COMPACT_LEAF_CODE_UNITS = 32_768;
 export class CompactContentStore extends CompactSpoolStorage {
+    subscribeCommitted(listener) {
+        this.subscribers.add(listener);
+    }
+    committed(id) {
+        for (const listener of this.subscribers)
+            listener(id);
+    }
+    leafUnits(id) {
+        const leaf = this.leaves.get(id);
+        if (!leaf)
+            throw new CompactReadError("ownership");
+        return leaf.units;
+    }
     constructor(options) {
         super(options.dir, options.io ?? nodeCompactStorageIo);
         this.leaves = new Map();
@@ -20,11 +35,16 @@ export class CompactContentStore extends CompactSpoolStorage {
         this.residentPayloadBytes = 0;
         this.pinnedOnlyBytes = 0;
         this.spilledLiveBytes = 0;
+        this.subscribers = new Set();
+        this.text = new CompactTextRoots(this);
         this.spillAboveBytes = options.spillAboveBytes ?? 4 * 1024 * 1024;
         this.spillTargetBytes = options.spillTargetBytes ?? 2 * 1024 * 1024;
     }
     /** Takes ownership of an immutable value with one live reference. */
     createLeaf(text) {
+        this.assertReadable();
+        if (text.length > COMPACT_LEAF_CODE_UNITS)
+            throw new CompactReadError("size_limit");
         const id = this.nextLeafId++;
         this.leaves.set(id, { text, units: text.length, live: 1, pins: 0, state: "ram" });
         this.ramLeaves.add(id);
@@ -34,9 +54,13 @@ export class CompactContentStore extends CompactSpoolStorage {
     }
     /** Moves live and cut-pin references; the last reference drops RAM or reclaims the file. */
     adjust(id, live, pins) {
+        if (id === 0)
+            return;
+        if (id < 0)
+            return this.text.adjust(id, live, pins);
         const leaf = this.leaves.get(id);
-        if (!leaf)
-            throw new Error(`compact leaf ${id} is not owned`);
+        if (!leaf || leaf.live + live < 0 || leaf.pins + pins < 0)
+            throw new CompactReadError("ownership");
         const pinnedOnly = leaf.live === 0 && leaf.pins > 0;
         leaf.live += live;
         leaf.pins += pins;
@@ -54,16 +78,25 @@ export class CompactContentStore extends CompactSpoolStorage {
         this.residentPayloadBytes -= leaf.units * 2;
     }
     isCommitted(id) {
+        if (id <= 0)
+            return id === 0 || this.text.isCommitted(id);
         return this.leaves.get(id)?.state === "committed";
     }
     /** Reads a leaf the caller still references, from RAM or its committed file. */
     async readLeaf(id) {
+        this.assertReadable();
         const leaf = this.leaves.get(id);
         if (!leaf)
-            throw new Error(`compact leaf ${id} is not owned`);
-        if (leaf.text !== undefined)
-            return leaf.text;
-        return (await this.readFile(leaf.path ?? "", leaf.units * 2, "leaf_read")).toString("utf16le");
+            throw new CompactReadError("ownership");
+        this.adjust(id, 0, 1);
+        try {
+            if (leaf.text !== undefined)
+                return leaf.text;
+            return (await this.readFile(leaf.path ?? "", leaf.units * 2, "leaf_read")).toString("utf16le");
+        }
+        finally {
+            this.adjust(id, 0, -1);
+        }
     }
     status() {
         return {
@@ -121,7 +154,7 @@ export class CompactContentStore extends CompactSpoolStorage {
             leaf.text = undefined;
             this.residentPayloadBytes -= bytes;
             this.spilledLiveBytes += bytes;
-            this.onCommitted?.(id);
+            this.committed(id);
         }
         this.spillQueued = false;
         if (this.residentPayloadBytes > this.spillTargetBytes) {

package/dist/modes/rpc/compact-read-lease.d.ts

@@ -0,0 +1,15 @@
+export declare class CompactReadError extends Error {
+    readonly reason: "released" | "retired" | "range" | "size_limit" | "count_limit" | "ownership";
+    constructor(reason: CompactReadError["reason"]);
+}
+/** Invalidates immediately, but holds the owner's references until its last operation unwinds. */
+export declare class CompactReadLease {
+    private released;
+    private operations;
+    private readonly dispose;
+    constructor(dispose: () => void);
+    assert(): void;
+    run<T>(read: () => Promise<T>): Promise<T>;
+    release(): void;
+}
+//# sourceMappingURL=compact-read-lease.d.ts.map

package/dist/modes/rpc/compact-read-lease.js

@@ -0,0 +1,40 @@
+export class CompactReadError extends Error {
+    constructor(reason) {
+        super(`compact read refused (${reason})`);
+        this.name = "CompactReadError";
+        this.reason = reason;
+    }
+}
+/** Invalidates immediately, but holds the owner's references until its last operation unwinds. */
+export class CompactReadLease {
+    constructor(dispose) {
+        this.released = false;
+        this.operations = 0;
+        this.dispose = dispose;
+    }
+    assert() {
+        if (this.released)
+            throw new CompactReadError("released");
+    }
+    async run(read) {
+        this.assert();
+        this.operations++;
+        try {
+            const result = await read();
+            this.assert();
+            return result;
+        }
+        finally {
+            if (--this.operations === 0 && this.released)
+                this.dispose();
+        }
+    }
+    release() {
+        if (this.released)
+            return;
+        this.released = true;
+        if (this.operations === 0)
+            this.dispose();
+    }
+}
+//# sourceMappingURL=compact-read-lease.js.map

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

@@ -1,22 +1,7 @@
 import { CompactContentIndex, type FrozenIndex } from "./compact-content-index.ts";
-import { type CompactContentStoreOptions, type CompactStorageStatus, type LeafId } from "./compact-content-store.ts";
-import { type CompactBlockKind, type CompactPersistence, type CompactTransition } from "./compact-transition.ts";
-/**
- * The in-memory current-state owner over compact storage (senpi#4272, R3.C6.4 first half).
- *
- * `accept` is synchronous: it validates a typed transition completely, then publishes the next
- * sequence, or throws and leaves the prior root untouched. Block text lives in owned bounded leaves
- * that spill asynchronously; settled messages live in a spillable index whose persistence status
- * changes only through `message_status`, never through storage success or failure. `freeze` pins
- * an immutable cut synchronously, and `read` materializes it asynchronously from RAM or disk.
- */
-interface FrozenBlock {
-    readonly contentIndex: number;
-    readonly kind: CompactBlockKind;
-    readonly leaves: readonly LeafId[];
-    /** A cut shares the immutable active tail string (under one leaf) instead of minting a leaf per freeze. */
-    readonly tail: string;
-}
+import { type CompactMessageView, type FrozenBlock } from "./compact-text-view.ts";
+import { type CompactContentStoreOptions, type CompactStorageStatus } from "./compact-content-store.ts";
+import { type CompactPersistence, type CompactTransition } from "./compact-transition.ts";
 interface SettledRow {
     readonly persistence: CompactPersistence;
     readonly blocks: readonly FrozenBlock[];
@@ -26,15 +11,6 @@ interface FrozenCompactState {
     readonly active: ReadonlyMap<string, readonly FrozenBlock[]>;
     readonly settled: FrozenIndex<SettledRow>;
 }
-interface CompactMessageView {
-    readonly messageId: string;
-    readonly persistence: CompactPersistence | undefined;
-    readonly blocks: readonly {
-        readonly contentIndex: number;
-        readonly kind: CompactBlockKind;
-        readonly text: string;
-    }[];
-}
 export interface CompactSessionStateOptions extends CompactContentStoreOptions {
     /** Index compaction is considered once this many override slots exist (one page by default). */
     readonly compactAboveRows?: number;
@@ -45,6 +21,7 @@ export declare class CompactSessionState {
     private readonly active;
     private sequence;
     private frozenTailBytes;
+    private readonly cuts;
     constructor(options: CompactSessionStateOptions);
     get acceptedSequence(): number;
     accept(transition: CompactTransition): number;
@@ -55,11 +32,14 @@ export declare class CompactSessionState {
         sequence: number;
         messages: CompactMessageView[];
     }>;
+    private cutLease;
     storageStatus(): CompactStorageStatus & ReturnType<CompactContentIndex<SettledRow>["status"]> & {
         readonly residentTailBytes: number;
         /** Active tails held by unreleased cuts; may share storage with `residentTailBytes`. */
         readonly frozenTailBytes: number;
         readonly hotWitnessBytes: number;
+        readonly residentTextNodes: number;
+        readonly residentTextIndexBytes: number;
     };
     idle(): Promise<void>;
     retire(): Promise<void>;
@@ -77,7 +57,6 @@ export declare class CompactSessionState {
     /** Settling mints the final tail into a spillable leaf; a freeze of an active block shares the tail. */
     private seal;
     private pin;
-    private texts;
 }
 export {};
 //# sourceMappingURL=compact-session-state.d.ts.map