@code-yeongyu/senpi 2026.10.10-4 → 2026.10.10-6

package/dist/core/extensions/builtin/compaction/lane-policy.js

@@ -1,22 +1,28 @@
 /**
- * Provider-scoped compaction opt-out for the `anthropic-subscription` main lane.
+ * Provider-scoped compaction ownership for the `anthropic-subscription` main lane.
  *
- * That lane keeps one resident SDK session per senpi session, and the Claude
- * Agent SDK runs its own native auto-compaction over that session's transcript.
- * Running senpi's compaction on top of it would rewrite a history senpi no
- * longer owns, so senpi stands down for the lane: no auto-compaction triggers,
- * no context reduction. Every other provider is untouched.
+ * That lane keeps one resident SDK session per senpi session. By default senpi
+ * owns its compaction (speculative, idle, restoration, degradation recovery): an
+ * accepted compaction invalidates the resident binding and the next turn
+ * cold-seeds the compacted branch (`tainted_compaction` always flattens), while
+ * the SDK's native auto-compact is pinned off so exactly one side compacts.
  *
- * The stand-down is conditional on the lane actually being resident: with the
- * `resumeMode: "off"` escape hatch senpi flattens its own history into every
- * request, so senpi's compaction must stay fully active there.
+ * `compactionOwner: "sdk"` opts out: the Claude Agent SDK runs its own native
+ * auto-compaction over the resident transcript and senpi stands down for the
+ * lane (no auto-compaction triggers, no context reduction). The stand-down lifts
+ * with the `resumeMode: "off"` escape hatch, where senpi flattens its own
+ * history into every request. Every other provider is untouched.
+ *
+ * The owner is read per call, from the same settings snapshot the query options
+ * use for the next turn, so a mid-session change can never leave the two sides
+ * disagreeing about who compacts.
  *
  * This module also owns the shape of the mirrored `compact_boundary` ledger
  * entry, so the SDK's native compactions stay visible in senpi history.
  */
 import { ANTHROPIC_SUBSCRIPTION_PROVIDER_ID } from "../anthropic-subscription/account-management.js";
 import { isColdSeedOverflowMessage } from "../anthropic-subscription/cold-seed-budget.js";
-import { loadAnthropicSubscriptionProviderSettingsFromDisk } from "../anthropic-subscription/settings.js";
+import { loadAnthropicSubscriptionProviderSettingsFromDisk, resolveCompactionOwner, } from "../anthropic-subscription/settings.js";
 /** Custom session entry type carrying a mirrored SDK compaction boundary. */
 export const ANTHROPIC_SUBSCRIPTION_COMPACT_ENTRY_TYPE = "claude-sdk-oauth-compact";
 /** Assistant-message diagnostic the lane uses to transport a received boundary. */
@@ -55,33 +61,27 @@ function isRecord(value) {
 export function isSdkNativeCompactionLane(input) {
     if (input.model?.provider !== ANTHROPIC_SUBSCRIPTION_PROVIDER_ID)
         return false;
-    return input.resumeMode !== "off";
+    return input.compactionOwner === "sdk" && input.resumeMode !== "off";
 }
 /**
- * Per-extension-instance policy holding one memoized provider-settings read.
- * Settings are only read when the active model actually belongs to the lane, so
- * other providers never pay for the lookup.
+ * Per-extension-instance lane policy. Settings are only read when the active
+ * model actually belongs to the lane, so other providers never pay for the
+ * lookup; the loader itself is cached by settings-file revision.
  */
 export function createCompactionLanePolicy(options = {}) {
     const load = options.loadProviderSettings ?? loadAnthropicSubscriptionProviderSettingsFromDisk;
-    let cachedCwd;
-    let cachedResumeMode;
-    // Per-cwd cache is the intended contract (pinned by lane-policy.test.ts):
-    // resumeMode is read once per cwd. A mid-session switch takes effect on
-    // the next cwd or session. Returns false when the settings cannot be read,
-    // so callers fail closed to senpi's full behavior.
-    const resolveResumeMode = (cwd) => {
-        if (cachedCwd === cwd)
-            return true;
+    // Read on every call, never memoized here: the query options re-read the same
+    // settings for every turn, and a cached owner would let a mid-session change
+    // leave senpi and the resident process disagreeing about who compacts. Returns
+    // undefined when the settings cannot be read, so callers fail closed to
+    // senpi's full behavior.
+    const readProviderSettings = (cwd) => {
         try {
-            cachedResumeMode = load(cwd).resumeMode;
+            return load(cwd);
         }
         catch {
-            cachedCwd = undefined;
-            return false;
+            return undefined;
         }
-        cachedCwd = cwd;
-        return true;
     };
     // Declared as a local so `ownsCompaction` never depends on `this`: the policy object
     // is routinely destructured at call sites, which would otherwise unbind the receiver.
@@ -93,20 +93,25 @@ export function createCompactionLanePolicy(options = {}) {
         // the escape hatch for lanes whose SDK never fires native compaction.
         if (context.getCompactionSettings?.().model)
             return false;
-        // A settings read failure must never silently disable senpi compaction:
-        // fail closed by keeping senpi's own compaction fully active.
-        if (!resolveResumeMode(context.cwd))
+        // A settings read failure must never silently disable senpi compaction.
+        const providerSettings = readProviderSettings(context.cwd);
+        if (!providerSettings)
             return false;
-        return isSdkNativeCompactionLane({ model: context.model, resumeMode: cachedResumeMode });
+        return isSdkNativeCompactionLane({
+            model: context.model,
+            resumeMode: providerSettings.resumeMode,
+            compactionOwner: resolveCompactionOwner(providerSettings),
+        });
     };
     return {
         disablesSenpiCompaction,
         hasAppendOnlyTranscript(context) {
             if (context.model?.provider !== ANTHROPIC_SUBSCRIPTION_PROVIDER_ID)
                 return false;
-            if (!resolveResumeMode(context.cwd))
+            const providerSettings = readProviderSettings(context.cwd);
+            if (!providerSettings)
                 return false;
-            return cachedResumeMode !== "off";
+            return providerSettings.resumeMode !== "off";
         },
         ownsCompaction(context, reason) {
             // Manual is senpi-owned everywhere: it is the user's explicit recovery path,

package/dist/core/extensions/builtin/html-render/bootstrap.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A page is a static snapshot: everything it shows is in the document (inline,
+ * data: or blob:), and it reaches no network. Its scripts run whenever it
+ * opens, but fetch, XHR, WebSocket, EventSource, remote scripts, styles,
+ * images and fonts, frames, form posts and <base> are refused. The policy is
+ * the document's first element, so nothing the page writes loads before it.
+ * Mirrors the desktop's packages/shared/src/htmlRenderBootstrap.ts.
+ */
+export declare const HTML_RENDER_CONTENT_SECURITY_POLICY: string;
+/**
+ * Inserts the theme bootstrap at the start of the document head, and the
+ * snapshot policy ahead of everything the page wrote.
+ */
+export declare function injectHtmlRenderBootstrap(html: string): string;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/core/extensions/builtin/html-render/bootstrap.js

@@ -0,0 +1,123 @@
+// The theme bootstrap injection and base stylesheet, mirroring the desktop's
+// packages/shared/src/htmlRender.ts (upstream t3code #15968). Kept small and
+// dependency-light: pure string functions, no Effect, no server. A page the
+// agent writes here is the same shape the desktop stores on publish.
+const BASE_CSS = "html{background:var(--background);color:var(--foreground);font-family:var(--font-sans);font-size:14px;line-height:1.5;-webkit-font-smoothing:antialiased;-webkit-text-size-adjust:100%;scrollbar-width:none}" +
+    "html::-webkit-scrollbar{display:none}body{margin:0}code,kbd,pre,samp{font-family:var(--font-mono)}";
+const DARK_VARS = {
+    "--background": "#0a0a0a",
+    "--foreground": "#f5f5f5",
+    "--muted-foreground": "#818181",
+    "--chart-1": "#60a5fa",
+    "--font-sans": '-apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif',
+    "--font-mono": '"SF Mono", "SFMono-Regular", Menlo, Consolas, "Liberation Mono", monospace',
+    "--radius": "0.625rem",
+};
+const LIGHT_VARS = {
+    ...DARK_VARS,
+    "--background": "#ffffff",
+    "--foreground": "#0a0a0a",
+    "--muted-foreground": "#525252",
+    "--chart-1": "#1d4ed8",
+};
+function rootRule(appearance, variables) {
+    const declarations = Object.entries(variables)
+        .map(([name, value]) => `${name}:${value};`)
+        .join("");
+    return `:root{color-scheme:${appearance};${declarations}}`;
+}
+const BOOTSTRAP_SCRIPT = `(function(){var s=document.getElementById("t3-theme");if(!s)return;var b=${JSON.stringify(BASE_CSS)};try{var m=window.matchMedia("(prefers-color-scheme: light)");var a=function(){s.textContent=m.matches?${JSON.stringify(rootRule("light", LIGHT_VARS))}:${JSON.stringify(rootRule("dark", DARK_VARS))}+b;};a();if(m.addEventListener)m.addEventListener("change",a);}catch(e){}})();`;
+function bootstrapMarkup(markup) {
+    const defaultCss = `${rootRule("dark", DARK_VARS)}@media (prefers-color-scheme: light){${rootRule("light", LIGHT_VARS)}}${BASE_CSS}`;
+    return [
+        /<meta\s[^>]*charset/i.test(markup.slice(0, 4096)) ? "" : '<meta charset="utf-8">',
+        /<meta\s[^>]*name\s*=\s*["']?viewport/i.test(markup)
+            ? ""
+            : '<meta name="viewport" content="width=device-width, initial-scale=1">',
+        `<style id="t3-theme">${defaultCss}</style>`,
+        `<script>${BOOTSTRAP_SCRIPT}</script>`,
+    ].join("");
+}
+const blankNonMarkup = (html) => {
+    const scan = html.replace(/<!--[\s\S]*?(?:-->|$)|<(script|style|textarea|title|xmp|iframe|noembed|noframes|noscript)\b[\s\S]*?(?:<\/\1\s*>|$)|<plaintext\b[\s\S]*$/gi, (match) => " ".repeat(match.length));
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    let at = 0;
+    for (const match of scan.matchAll(/<(\/?)template(?:\s[^>]*)?\/?>/gi)) {
+        if (!match[1]) {
+            if (depth++ === 0)
+                start = match.index;
+        }
+        else if (depth > 0 && --depth === 0) {
+            const end = match.index + match[0].length;
+            parts.push(scan.slice(at, start), " ".repeat(end - start));
+            at = end;
+        }
+    }
+    if (depth > 0) {
+        parts.push(scan.slice(at, start), " ".repeat(scan.length - start));
+        at = scan.length;
+    }
+    parts.push(scan.slice(at));
+    return parts.join("");
+};
+/**
+ * A page is a static snapshot: everything it shows is in the document (inline,
+ * data: or blob:), and it reaches no network. Its scripts run whenever it
+ * opens, but fetch, XHR, WebSocket, EventSource, remote scripts, styles,
+ * images and fonts, frames, form posts and <base> are refused. The policy is
+ * the document's first element, so nothing the page writes loads before it.
+ * Mirrors the desktop's packages/shared/src/htmlRenderBootstrap.ts.
+ */
+export const HTML_RENDER_CONTENT_SECURITY_POLICY = [
+    "default-src 'none'",
+    "script-src 'unsafe-inline' 'unsafe-eval' data: blob:",
+    "style-src 'unsafe-inline' data:",
+    "img-src data: blob:",
+    "font-src data:",
+    "media-src data: blob:",
+    "worker-src blob:",
+    "connect-src 'none'",
+    "frame-src 'none'",
+    "form-action 'none'",
+    "base-uri 'none'",
+].join("; ");
+const POLICY_META = `<meta http-equiv="Content-Security-Policy" content="${HTML_RENDER_CONTENT_SECURITY_POLICY}">`;
+// Every written page starts with a UTF-8 byte order mark, a standards-mode
+// doctype and the policy, in that order and in plain ASCII. The mark makes the
+// browser decode the file as UTF-8 whatever charset the page declares, so no
+// declared encoding can turn the policy into text, and nothing the page wrote
+// comes before it. A leading doctype of the page's own is dropped only when it is
+// printable ASCII; anything else stays where it is, after the policy, where the
+// parser ignores a doctype.
+const PREAMBLE = `\uFEFF<!doctype html>${POLICY_META}`;
+const LEADING_ASCII_DOCTYPE = /^\uFEFF?[\t\n\f\r ]*<!doctype[ -=?-~]*>/i;
+/**
+ * Inserts the theme bootstrap at the start of the document head, and the
+ * snapshot policy ahead of everything the page wrote.
+ */
+export function injectHtmlRenderBootstrap(html) {
+    return PREAMBLE + injectThemeBootstrap(html).replace(LEADING_ASCII_DOCTYPE, "");
+}
+function injectThemeBootstrap(html) {
+    const scan = blankNonMarkup(html);
+    const markup = bootstrapMarkup(scan);
+    const headOpen = /<head(?:\s[^>]*)?>/i.exec(scan);
+    if (headOpen) {
+        const at = headOpen.index + headOpen[0].length;
+        return html.slice(0, at) + markup + html.slice(at);
+    }
+    const htmlOpen = /<html(?:\s[^>]*)?>/i.exec(scan);
+    if (htmlOpen) {
+        const at = htmlOpen.index + htmlOpen[0].length;
+        return `${html.slice(0, at)}<head>${markup}</head>${html.slice(at)}`;
+    }
+    const doctype = /^\s*<!doctype[^>]*>/i.exec(html);
+    if (doctype) {
+        const at = doctype[0].length;
+        return `${html.slice(0, at)}<head>${markup}</head>${html.slice(at)}`;
+    }
+    return `<!doctype html><head>${markup}</head>${html}`;
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/core/extensions/builtin/html-render/images.d.ts

@@ -0,0 +1,16 @@
+export declare class HtmlRenderImagesNotFoundError extends Error {
+    readonly paths: readonly string[];
+    constructor(paths: readonly string[]);
+}
+export declare class HtmlRenderImageTooLargeError extends Error {
+    constructor(path: string, sizeBytes: number);
+}
+export declare class HtmlRenderPageTooLargeError extends Error {
+    constructor(sizeBytes: number);
+}
+/** Replaces every local image reference with a data URI; unreadable paths throw. */
+export declare function inlineLocalImages(html: string): Promise<{
+    html: string;
+    missing: string[];
+}>;
+//# sourceMappingURL=images.d.ts.map

package/dist/core/extensions/builtin/html-render/images.js

@@ -0,0 +1,155 @@
+// Local-image preparation, mirroring the desktop's apps/server/src/htmlRender/
+// HtmlRender.ts (upstream t3code #15968): absolute-path images are inlined as
+// data URIs only after a magic-byte/SVG-root check, so a renamed secret is
+// refused, and the page stays within the size caps. Pure byte/string work.
+import { readFile, stat } from "node:fs/promises";
+const MIB = 1024 * 1024;
+const MAX_IMAGE_BYTES = 10 * MIB;
+const MAX_PAGE_BYTES = 25 * MIB;
+export class HtmlRenderImagesNotFoundError extends Error {
+    constructor(paths) {
+        super(`These local images could not be read: ${paths.join(", ")}. Use absolute paths to existing image files, or remove them.`);
+        this.name = "HtmlRenderImagesNotFoundError";
+        this.paths = paths;
+    }
+}
+export class HtmlRenderImageTooLargeError extends Error {
+    constructor(path, sizeBytes) {
+        super(`${path} is ${(sizeBytes / MIB).toFixed(1)} MiB; each local image must be at most 10 MiB.`);
+        this.name = "HtmlRenderImageTooLargeError";
+    }
+}
+export class HtmlRenderPageTooLargeError extends Error {
+    constructor(sizeBytes) {
+        super(`With its images inlined the page is ${(sizeBytes / MIB).toFixed(1)} MiB; the limit is 25 MiB. Use smaller images.`);
+        this.name = "HtmlRenderPageTooLargeError";
+    }
+}
+const IMAGE_MIME_TYPES = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    avif: "image/avif",
+    svg: "image/svg+xml",
+    bmp: "image/bmp",
+    ico: "image/x-icon",
+};
+const IMAGE_EXTENSIONS = Object.keys(IMAGE_MIME_TYPES).join("|");
+const ABSOLUTE_PATH = String.raw `(?:/(?!/)|[a-z]:[\\/])`;
+const LOCAL_IMAGE_PATTERN = new RegExp(String.raw `(["'\x60])(${ABSOLUTE_PATH}(?:(?!\1)[^\r\n]){0,2048}?\.(?:${IMAGE_EXTENSIONS}))\1` +
+    String.raw `|url\(\s*(${ABSOLUTE_PATH}[^\s"'\x60()]{0,2048}?\.(?:${IMAGE_EXTENSIONS}))\s*\)`, "gid");
+const findLocalImages = (html) => Array.from(html.matchAll(LOCAL_IMAGE_PATTERN)).flatMap((match) => {
+    const span = match.indices?.[2] ?? match.indices?.[3];
+    return span ? [{ start: span[0], end: span[1], path: html.slice(span[0], span[1]) }] : [];
+});
+const filePathFor = (reference) => /^[a-z]:/i.test(reference) ? reference.replaceAll("\\\\", "\\") : reference;
+const dataUriPrefix = (path) => `data:${IMAGE_MIME_TYPES[path.slice(path.lastIndexOf(".") + 1).toLowerCase()] ?? "application/octet-stream"};base64,`;
+const latin1 = (bytes, start, end) => String.fromCharCode(...bytes.subarray(start, end));
+const after = (text, token, from) => {
+    const at = text.indexOf(token, from);
+    return at === -1 ? -1 : at + token.length;
+};
+const afterDoctype = (text, from) => {
+    let inSubset = false;
+    let at = from;
+    while (at !== -1 && at < text.length) {
+        const char = text[at];
+        if (char === '"' || char === "'")
+            at = after(text, char, at + 1);
+        else if (inSubset && text.startsWith("<!--", at))
+            at = after(text, "-->", at + 4);
+        else if (inSubset && text.startsWith("<?", at))
+            at = after(text, "?>", at + 2);
+        else if (char === ">" && !inSubset)
+            return at + 1;
+        else {
+            if (char === "[")
+                inSubset = true;
+            else if (char === "]")
+                inSubset = false;
+            at += 1;
+        }
+    }
+    return -1;
+};
+const hasSvgRoot = (text) => {
+    let at = 0;
+    while (at !== -1) {
+        while (/\s/.test(text.charAt(at)))
+            at += 1;
+        if (text.startsWith("<?", at))
+            at = after(text, "?>", at + 2);
+        else if (text.startsWith("<!--", at))
+            at = after(text, "-->", at + 4);
+        else if (text.slice(at, at + 9).toLowerCase() === "<!doctype")
+            at = afterDoctype(text, at + 9);
+        else
+            return /^<svg[ \t\r\n/>]/.test(text.slice(at, at + 5));
+    }
+    return false;
+};
+/** Whether file bytes are an image, whatever the file is named. */
+const isImageBytes = (bytes) => {
+    const head = latin1(bytes, 0, 12);
+    if (head.startsWith("\x89PNG") ||
+        head.startsWith("\xff\xd8\xff") ||
+        head.startsWith("GIF8") ||
+        head.startsWith("\0\0\x01\0") ||
+        (head.startsWith("BM") && head.slice(6, 10) === "\0\0\0\0") ||
+        (head.startsWith("RIFF") && head.slice(8, 12) === "WEBP") ||
+        /^ftyp(?:avif|avis|mif1)$/.test(head.slice(4, 12))) {
+        return true;
+    }
+    return hasSvgRoot(new TextDecoder().decode(bytes.subarray(0, 4096)));
+};
+/** Replaces every local image reference with a data URI; unreadable paths throw. */
+export async function inlineLocalImages(html) {
+    const references = findLocalImages(html);
+    const uniquePaths = [...new Set(references.map((reference) => reference.path))];
+    const files = await Promise.all(uniquePaths.map(async (path) => {
+        try {
+            const info = await stat(filePathFor(path));
+            return { path, size: info.isFile() ? Number(info.size) : undefined };
+        }
+        catch {
+            return { path, size: undefined };
+        }
+    }));
+    const oversized = files.find((file) => file.size !== undefined && file.size > MAX_IMAGE_BYTES);
+    if (oversized?.size !== undefined) {
+        throw new HtmlRenderImageTooLargeError(oversized.path, oversized.size);
+    }
+    const images = new Map();
+    let readBytes = 0;
+    for (const file of files.filter((entry) => entry.size !== undefined)) {
+        const bytes = new Uint8Array(await readFile(filePathFor(file.path)));
+        if (!isImageBytes(bytes))
+            continue;
+        if (bytes.byteLength > MAX_IMAGE_BYTES) {
+            throw new HtmlRenderImageTooLargeError(file.path, bytes.byteLength);
+        }
+        readBytes += Math.ceil(bytes.byteLength / 3) * 4;
+        if (readBytes > MAX_PAGE_BYTES)
+            throw new HtmlRenderPageTooLargeError(readBytes);
+        images.set(file.path, bytes);
+    }
+    const parts = [];
+    let cursor = 0;
+    for (const reference of references) {
+        const bytes = images.get(reference.path);
+        if (bytes === undefined)
+            continue;
+        parts.push(html.slice(cursor, reference.start), dataUriPrefix(reference.path) + Buffer.from(bytes).toString("base64"));
+        cursor = reference.end;
+    }
+    parts.push(html.slice(cursor));
+    const inlined = parts.join("");
+    if (Buffer.byteLength(inlined) > MAX_PAGE_BYTES) {
+        throw new HtmlRenderPageTooLargeError(Buffer.byteLength(inlined));
+    }
+    const missing = files.filter((file) => !images.has(file.path)).map((file) => file.path);
+    return { html: inlined, missing };
+}
+//# sourceMappingURL=images.js.map

package/dist/core/extensions/builtin/html-render/index.d.ts

@@ -0,0 +1,3 @@
+import type { ExtensionAPI } from "../../types.ts";
+export default function htmlRenderExtension(pi: ExtensionAPI): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/extensions/builtin/html-render/index.js

@@ -0,0 +1,5 @@
+import { showHtmlPageTool } from "./tool.js";
+export default function htmlRenderExtension(pi) {
+    pi.registerTool(showHtmlPageTool);
+}
+//# sourceMappingURL=index.js.map

package/dist/core/extensions/builtin/html-render/tool.d.ts

@@ -0,0 +1,19 @@
+import { Type } from "typebox";
+export interface ShowHtmlPageDetails {
+    path: string;
+    title: string;
+    height: number | undefined;
+    prepared: boolean;
+    missingImages?: string[];
+    /**
+     * The page as the agent wrote it, for a host that publishes it itself (the
+     * desktop renders it in the thread). Never part of the model-visible content.
+     */
+    html: string;
+}
+export declare const showHtmlPageTool: import("../../types.ts").ToolDefinition<Type.TObject<{
+    html: Type.TString;
+    title: Type.TString;
+    height: Type.TOptional<Type.TInteger>;
+}>, ShowHtmlPageDetails, any> & import("../../types.ts").ToolDefinition<any, any, any>;
+//# sourceMappingURL=tool.d.ts.map

package/dist/core/extensions/builtin/html-render/tool.js

@@ -0,0 +1,74 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "typebox";
+import { defineTool } from "../../types.js";
+import { injectHtmlRenderBootstrap } from "./bootstrap.js";
+import { inlineLocalImages } from "./images.js";
+// The same input limit as the desktop's html_render. Images belong as absolute
+// file paths, which are inlined after the check, so the document itself stays
+// small: it travels in the tool call and again in the result details.
+const MAX_HTML_CHARACTERS = 512_000;
+const Params = Type.Object({
+    html: Type.String({
+        description: "A complete, self-contained HTML document.",
+        minLength: 1,
+        maxLength: MAX_HTML_CHARACTERS,
+    }),
+    title: Type.String({ description: "Short name for the page.", minLength: 1, maxLength: 200 }),
+    height: Type.Optional(Type.Integer({
+        description: "Frame height hint in CSS pixels, 80-2000. Defaults to the page's natural height.",
+    })),
+});
+const OUTPUT_DIR = ".senpi/html-pages";
+const clampHeight = (height) => height === undefined ? undefined : Math.min(2000, Math.max(80, Math.round(height)));
+export const showHtmlPageTool = defineTool({
+    name: "show_html_page",
+    label: "Show HTML Page",
+    description: "Show a finished self-contained HTML page (chart, table, diagram, mockup) to the reader. " +
+        "No network: inline every script, style and image (data: URIs). A <script src>, stylesheet link, font, image " +
+        "or fetch that points at a URL (a CDN included) is refused, and the page comes out blank or broken. " +
+        "Local images written as absolute file paths " +
+        "are inlined automatically after a byte check. In the desktop thread this renders inline above your " +
+        "reply; elsewhere it is written to a file you can open in the desktop.",
+    promptSnippet: "show_html_page: show a self-contained HTML page (chart/table/diagram) to the reader",
+    promptGuidelines: [
+        "No network: inline every script, style and image (data: URIs); a CDN <script src> or remote font is refused and leaves the page blank.",
+        "Absolute-path local images are inlined after a magic-byte check; a renamed non-image is refused.",
+    ],
+    parameters: Params,
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+        const inlined = await inlineLocalImages(params.html);
+        const prepared = injectHtmlRenderBootstrap(inlined.html);
+        const height = clampHeight(params.height);
+        const dir = join(ctx.cwd, OUTPUT_DIR);
+        await mkdir(dir, { recursive: true });
+        const safeName = params.title
+            .replace(/[\\/:*?"<>|\p{Cc}]+/gu, " ")
+            .replace(/\s+/g, " ")
+            .trim()
+            .slice(0, 60) || "page";
+        const path = join(dir, `${safeName}-${Date.now().toString(36)}.html`);
+        await writeFile(path, prepared, "utf8");
+        const missing = inlined.missing.length === 0 ? undefined : inlined.missing;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Wrote the page to ${path}. Open it in the desktop to see it rendered with your theme. ` +
+                        (missing === undefined
+                            ? "Local images were inlined."
+                            : `Some local images could not be read and were left as written: ${missing.join(", ")}.`),
+                },
+            ],
+            details: {
+                path,
+                title: params.title,
+                height,
+                prepared: true,
+                ...(missing ? { missingImages: missing } : {}),
+                html: params.html,
+            },
+        };
+    },
+});
+//# sourceMappingURL=tool.js.map

package/dist/core/extensions/builtin/index.js

@@ -19,6 +19,7 @@ import helpExtension from "./help/index.js";
 import herdrExtension from "./herdr/index.js";
 import historySearchExtension from "./history-search/index.js";
 import hooksExtension from "./hooks/index.js";
+import htmlRenderExtension from "./html-render/index.js";
 import imageGenExtension from "./imagegen/index.js";
 import importReproExtension from "./import-repro.js";
 import lookAtExtension from "./look-at/index.js";
@@ -103,6 +104,9 @@ export const builtinExtensions = [
     { id: "cache-keepalive", factory: cacheKeepAliveExtension },
     { id: "ttsr", factory: ttsrExtension },
     { id: "btw", factory: btwExtension },
+    // HTML page rendering for standalone senpi (TUI/local); the desktop thread reaches the
+    // same capability through the desktop's MCP server instead.
+    { id: "html-render", factory: htmlRenderExtension },
     // Provider-neutral account listing; sits before the provider lanes so their
     // dedicated commands (claude-account, cursor accounts) keep their own names.
     { id: "account", factory: accountExtension },

package/dist/core/extensions/builtin/mcp/auth/catalog-identity.d.ts

@@ -0,0 +1,4 @@
+import type { McpServerConfig } from "../config-schema.ts";
+/** Local snapshot only: never migrates credentials, acquires a lock, or refreshes authentication. */
+export declare function mcpCredentialIdentity(config: McpServerConfig, serverName: string, agentDir: string | undefined, env: Record<string, string | undefined> | undefined): string | undefined;
+//# sourceMappingURL=catalog-identity.d.ts.map

package/dist/core/extensions/builtin/mcp/auth/catalog-identity.js

@@ -0,0 +1,41 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { resolveAuthMode } from "./context.js";
+import { McpTokenStore } from "./token-store.js";
+/** Local snapshot only: never migrates credentials, acquires a lock, or refreshes authentication. */
+export function mcpCredentialIdentity(config, serverName, agentDir, env) {
+    const mode = resolveAuthMode(config);
+    if (mode === "none")
+        return "none";
+    if (mode === "bearer") {
+        const name = config.bearerTokenEnv;
+        if (name === undefined)
+            return undefined;
+        const token = env?.[name] ?? process.env[name];
+        if (token === undefined || token.length === 0)
+            return undefined;
+        return createHash("sha256")
+            .update(JSON.stringify(["mcp-catalog-bearer", token]))
+            .digest("hex");
+    }
+    try {
+        const store = new McpTokenStore({ serverName, serverUrl: config.url ?? "", agentDir });
+        const value = JSON.parse(readFileSync(store.tokensPath, "utf8"));
+        if (typeof value !== "object" || value === null || !("accessToken" in value))
+            return undefined;
+        if (typeof value.accessToken !== "string" || value.accessToken.length === 0)
+            return undefined;
+        const refreshToken = "refreshToken" in value ? value.refreshToken : undefined;
+        if (refreshToken !== undefined && typeof refreshToken !== "string")
+            return undefined;
+        return createHash("sha256")
+            .update(JSON.stringify(["mcp-catalog-oauth", value.accessToken, refreshToken]))
+            .digest("hex");
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return undefined;
+        throw error;
+    }
+}
+//# sourceMappingURL=catalog-identity.js.map

package/dist/core/extensions/builtin/mcp/auth/legacy-lock.d.ts

@@ -0,0 +1,3 @@
+/** Shares the existing O_EXCL file with synchronous migrators without blocking the event loop. */
+export declare function acquireLegacyLock(path: string, stale: number): Promise<() => Promise<void>>;
+//# sourceMappingURL=legacy-lock.d.ts.map

package/dist/core/extensions/builtin/mcp/auth/legacy-lock.js

@@ -0,0 +1,39 @@
+import { open, rm, stat } from "node:fs/promises";
+import { safeDelay } from "../wrap.js";
+/** Shares the existing O_EXCL file with synchronous migrators without blocking the event loop. */
+export async function acquireLegacyLock(path, stale) {
+    const deadline = Date.now() + stale;
+    for (;;) {
+        try {
+            const file = await open(path, "wx", 0o600);
+            return async () => {
+                try {
+                    await file.close();
+                }
+                finally {
+                    await rm(path, { force: true });
+                }
+            };
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST")
+                throw error;
+            try {
+                const age = Date.now() - (await stat(path)).mtimeMs;
+                if (age >= stale) {
+                    await rm(path, { force: true });
+                    continue;
+                }
+            }
+            catch (error) {
+                if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                    continue;
+                throw error;
+            }
+            if (Date.now() >= deadline)
+                throw new Error("Legacy OAuth migration lock acquisition timed out");
+            await safeDelay(20);
+        }
+    }
+}
+//# sourceMappingURL=legacy-lock.js.map