@youweichen/pi-harness 0.0.0-stage → 1.0.0

package/dist/server/slash-commands.js

@@ -0,0 +1,280 @@
+import { reloadSession } from "./session-reload.js";
+/** Slash commands implemented natively by the web server (the pi CLI's built-in
+ * interactive commands like /model and /new are NOT handled by the SDK's
+ * prompt() — without this they'd be sent to the model as plain text). Keep in
+ * sync with exec(). */
+export const NATIVE_COMMANDS = [
+    { name: "tree", description: "查看会话树与切换分支", descriptionEn: "Browse the session tree and switch branches" },
+    { name: "clone", description: "复制当前分支为新会话", descriptionEn: "Clone this branch into a new session" },
+    { name: "fork", description: "选择用户消息派生新会话", descriptionEn: "Choose a user message to fork" },
+    { name: "name", description: "重命名当前会话", descriptionEn: "Rename this session", argumentHint: "<名称>", argumentHintEn: "<name>" },
+    { name: "new", description: "新建会话，保留当前会话历史", descriptionEn: "Start a new session, keeping previous history" },
+    { name: "model", description: "切换模型", descriptionEn: "Switch model", argumentHint: "[名称]", argumentHintEn: "[name]" },
+    { name: "compact", description: "压缩上下文", descriptionEn: "Compact context", argumentHint: "[说明]", argumentHintEn: "[instructions]" },
+    { name: "cwd", description: "切换工作目录", descriptionEn: "Switch workspace", argumentHint: "<路径>", argumentHintEn: "<path>" },
+    {
+        name: "thinking",
+        description: "设置思考强度",
+        descriptionEn: "Set thinking level",
+        argumentHint: "<off|low|medium|high|xhigh|max>",
+        argumentHintEn: "<off|low|medium|high|xhigh|max>",
+    },
+    { name: "resume", description: "刷新会话列表", descriptionEn: "Refresh session list" },
+    { name: "reload", description: "重新加载扩展、技能与模板", descriptionEn: "Reload extensions, skills & templates" },
+    { name: "help", description: "显示全部命令", descriptionEn: "Show all commands" },
+    { name: "copy", description: "复制上一条助手回复", descriptionEn: "Copy last assistant reply" },
+    { name: "pi-harness:quit", description: "退出服务", descriptionEn: "Quit server (supervisor will restart)" },
+];
+/** Parse a prompt into "/command args" — returns null when it isn't one. */
+export function parseSlash(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("/"))
+        return null;
+    const m = trimmed.match(/^\/([^\s]+)\s*([\s\S]*)$/);
+    if (!m || !m[1])
+        return null;
+    return { name: m[1], args: m[2].trim() };
+}
+export class SlashCommandsService {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    /**
+     * Catalog of slash commands for the chat input: web-native builtins first,
+     * then the SDK's invokable commands for the ACTIVE conversation (extension
+     * commands, prompt templates, skills) — the same set the SDK expands when a
+     * prompt text starts with "/" (see AgentSession.prompt).
+     */
+    async push() {
+        const commands = [];
+        const seen = new Set();
+        for (const c of NATIVE_COMMANDS) {
+            commands.push({ ...c, source: "builtin" });
+            seen.add(c.name);
+        }
+        try {
+            const s = this.host.getSession();
+            // Extension commands — the SDK already suffixes collisions with builtin
+            // names ("new:2"), and those still reach the SDK since exec() only
+            // intercepts the exact native names.
+            for (const cmd of s.extensionRunner.getRegisteredCommands()) {
+                if (seen.has(cmd.invocationName))
+                    continue;
+                commands.push({
+                    name: cmd.invocationName,
+                    description: cmd.description,
+                    source: "extension",
+                });
+                seen.add(cmd.invocationName);
+            }
+            // Prompt templates: /templatename args
+            for (const t of s.promptTemplates) {
+                if (seen.has(t.name))
+                    continue;
+                commands.push({
+                    name: t.name,
+                    description: t.description,
+                    source: "prompt",
+                });
+                seen.add(t.name);
+            }
+            // Skills: /skill:name args
+            for (const skill of s.resourceLoader.getSkills().skills) {
+                const name = `skill:${skill.name}`;
+                if (seen.has(name))
+                    continue;
+                commands.push({
+                    name,
+                    description: skill.description,
+                    source: "skill",
+                });
+                seen.add(name);
+            }
+        }
+        catch {
+            // Session not ready yet — native-only catalog still serves the picker.
+        }
+        // UI 插件注册的命令（host.registerCommand）——全局，不依赖会话就绪。
+        this.host.emit({ type: "slash_commands", commands });
+    }
+    /** Run a native slash command (see NATIVE_COMMANDS). Returns false when the
+     *  name is not a native command (the prompt falls through to the SDK). */
+    async exec(name, args, context) {
+        switch (name) {
+            case "tree":
+            case "clone":
+            case "fork":
+            case "name":
+                await this.host.treeCommand?.(name, args, context);
+                return true;
+            case "new":
+                await this.host.startNewSession();
+                return true;
+            case "model": {
+                if (!args) {
+                    const current = this.host.getSession().model;
+                    this.host.emit({
+                        type: "notice",
+                        level: "info",
+                        text: current
+                            ? `当前模型：${current.name}（${current.provider}/${current.id}）。用法：/model <名称>`
+                            : `用法：/model <名称>`,
+                    });
+                    return true;
+                }
+                const query = args.toLowerCase();
+                const available = await this.host.getSession().modelRuntime.getAvailable();
+                // Prefer an exact "provider/id" match, else id/name substring.
+                const exact = available.find((m) => m.provider + "/" + m.id === args.trim());
+                const matches = exact
+                    ? [exact]
+                    : available.filter((m) => m.id.toLowerCase().includes(query) ||
+                        m.name.toLowerCase().includes(query) ||
+                        m.provider.toLowerCase().includes(query));
+                if (matches.length === 0) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "error",
+                        text: `没有匹配到模型：${args}（可用模型见顶栏模型列表）`,
+                    });
+                    return true;
+                }
+                const pick = matches[0];
+                if (matches.length > 1) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "warning",
+                        text: `找到 ${matches.length} 个匹配模型，已选用：${pick.name}（精确匹配请用 provider/id）`,
+                    });
+                }
+                await this.host.setModel(`${pick.provider}/${pick.id}`);
+                return true;
+            }
+            case "compact":
+                try {
+                    await this.host.getSession().compact(args || undefined);
+                }
+                catch (err) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "error",
+                        text: `压缩上下文失败：${err.message}`,
+                    });
+                }
+                return true;
+            case "cwd":
+                if (!args) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "info",
+                        text: `当前工作目录：${this.host.cwd()}。用法：/cwd <路径>`,
+                    });
+                }
+                else {
+                    await this.host.setCwd(args);
+                }
+                return true;
+            case "thinking": {
+                const ALIAS = {
+                    off: "off",
+                    minimal: "minimal",
+                    low: "low",
+                    medium: "medium",
+                    high: "high",
+                    xhigh: "xhigh",
+                    max: "max",
+                    关闭: "off",
+                    极简: "minimal",
+                    低: "low",
+                    中: "medium",
+                    高: "high",
+                    极高: "xhigh",
+                    最大: "max",
+                };
+                const level = ALIAS[args.trim().toLowerCase()];
+                if (!level) {
+                    this.host.emit({
+                        type: "notice",
+                        level: "error",
+                        text: `无效的思考强度：${args || "（空）"}。可用：off / minimal / low / medium / high / xhigh / max`,
+                    });
+                    return true;
+                }
+                this.host.setThinking(level);
+                return true;
+            }
+            case "resume":
+                await this.host.refreshSessions();
+                this.host.emit({
+                    type: "notice",
+                    level: "info",
+                    text: "会话列表已刷新，请在左侧「历史对话」中选择",
+                });
+                return true;
+            case "reload":
+                const startedAt = Date.now();
+                const s = this.host.getSession();
+                this.host.emit({ type: "reload_status", ...context, phase: "running", timestamp: startedAt });
+                try {
+                    // Re-discovers extensions / skills / prompt templates from disk and
+                    // re-pushes the picker catalog (the CLI's /reload semantics).
+                    await reloadSession(s);
+                    // reload() 会把 custom 工具加回活跃集——重放设置门控（终端开关等）。
+                    if (this.host.getSession() === s) {
+                        this.host.afterReload?.();
+                        await this.push();
+                    }
+                    const extensions = s.resourceLoader.getExtensions();
+                    const skills = s.resourceLoader.getSkills();
+                    const prompts = s.resourceLoader.getPrompts();
+                    const errors = [
+                        ...extensions.errors.map((e) => ({ path: e.path, message: e.error })),
+                        ...skills.diagnostics.filter((d) => d.type === "error").map((d) => ({ path: d.path ?? "", message: d.message })),
+                        ...prompts.diagnostics.filter((d) => d.type === "error").map((d) => ({ path: d.path ?? "", message: d.message })),
+                    ];
+                    this.host.emit({
+                        type: "reload_status", ...context, phase: "done", timestamp: startedAt,
+                        durationMs: Date.now() - startedAt,
+                        extensions: extensions.extensions.length, skills: skills.skills.length,
+                        prompts: prompts.prompts.length, errors,
+                        resources: {
+                            extensions: extensions.extensions.map((extension) => extension.path),
+                            skills: skills.skills.map((skill) => skill.name),
+                            prompts: prompts.prompts.map((prompt) => prompt.name),
+                        },
+                    });
+                }
+                catch (err) {
+                    this.host.emit({
+                        type: "reload_status", ...context, phase: "done", timestamp: startedAt,
+                        durationMs: Date.now() - startedAt,
+                        errors: [{ path: "", message: err.message }],
+                    });
+                }
+                return true;
+            case "pi-harness:quit": {
+                this.host.emit({
+                    type: "notice",
+                    level: "info",
+                    text: "正在退出 pi-harness… supervisor 将自动重启服务",
+                });
+                setTimeout(() => {
+                    const didSchedule = this.host.onQuit?.() ?? false;
+                    if (!didSchedule) {
+                        setTimeout(() => process.exit(0), 100);
+                    }
+                }, 300);
+                return true;
+            }
+            case "help":
+            case "copy":
+                // Client-side UI actions — the client handles them before sending;
+                // swallow here so the SDK never sees them as plain prompt text.
+                return true;
+            default:
+                // 插件命令：拦截执行（纯配置动作，与内置命令同级，不到 SDK）。
+                return false;
+        }
+    }
+}

package/dist/server/sqlite-preview.js

@@ -0,0 +1,58 @@
+import { fork } from "node:child_process";
+import { realpathSync, statSync } from "node:fs";
+import { workspacePath } from "./files-service.js";
+let running = 0;
+/** Queries run outside the chat process, with bounded concurrency and a hard deadline. */
+export function readSqlitePreview(request, signal) {
+    if (signal?.aborted)
+        return Promise.reject(new Error("Request cancelled"));
+    if (running >= 2)
+        return Promise.reject(new Error("Database viewer is busy; retry shortly"));
+    if (!Number.isSafeInteger(request.offset) || request.offset < 0 || request.offset > 10_000_000)
+        return Promise.reject(new Error("Invalid page offset"));
+    const root = realpathSync(request.cwd);
+    const path = workspacePath(root, request.path);
+    if (!path)
+        throw new Error("Path outside workspace");
+    const absolute = realpathSync(path.abs);
+    if (!workspacePath(root, absolute) || !statSync(absolute).isFile())
+        throw new Error("Path outside workspace");
+    return new Promise((resolve, reject) => {
+        const workerUrl = new URL(import.meta.url.endsWith(".ts") ? "./sqlite-worker.ts" : "./sqlite-worker.js", import.meta.url);
+        const child = fork(workerUrl, [], {
+            stdio: ["ignore", "ignore", "pipe", "ipc"], serialization: "json",
+            execArgv: process.execArgv.filter((arg) => !arg.startsWith("--watch")),
+        });
+        running++;
+        // Consume experimental-runtime warnings without leaking paths into the UI.
+        child.stderr?.resume();
+        let settled = false;
+        const finish = (error, data) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            child.kill("SIGKILL");
+            if (error)
+                reject(error);
+            else
+                resolve(data);
+        };
+        const abort = () => finish(new Error("Request cancelled"));
+        const timer = setTimeout(() => finish(new Error("Database query timed out")), 8000);
+        child.once("exit", () => { running--; finish(new Error("Database reader stopped unexpectedly")); });
+        child.once("error", (error) => finish(error));
+        child.once("message", (message) => {
+            if (message.data)
+                finish(undefined, message.data);
+            else
+                finish(new Error(message.error || "Unable to read database"));
+        });
+        signal?.addEventListener("abort", abort, { once: true });
+        if (signal?.aborted)
+            abort();
+        else
+            child.send({ absolute, table: request.table, offset: request.offset });
+    });
+}

package/dist/server/sqlite-query.js

@@ -0,0 +1,67 @@
+import { DatabaseSync } from "node:sqlite";
+import { closeSync, openSync, readSync } from "node:fs";
+const PAGE_SIZE = 50;
+const MAX_COLUMNS = 64;
+const MAX_CELL_TEXT = 256;
+function identifier(name) { return '"' + name.replace(/"/g, '""') + '"'; }
+/** Only fixed, parameterized read queries; no user SQL or extension loading. */
+export function querySqlite(absolute, table, offset) {
+    const fd = openSync(absolute, "r");
+    const header = Buffer.alloc(16);
+    try {
+        readSync(fd, header, 0, 16, 0);
+    }
+    finally {
+        closeSync(fd);
+    }
+    if (header.toString("utf8") !== "SQLite format 3\0")
+        throw new Error("Not a SQLite database (encrypted databases are not supported)");
+    const db = new DatabaseSync(absolute, { readOnly: true, allowExtension: false, timeout: 200 });
+    try {
+        db.exec("PRAGMA query_only=ON; PRAGMA trusted_schema=OFF; PRAGMA temp_store=MEMORY; BEGIN");
+        const allTables = db.prepare("SELECT name, type, sql FROM sqlite_schema WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' ORDER BY name LIMIT 501").all();
+        const tables = allTables.slice(0, 500).map((row) => ({ name: String(row.name), type: row.type === "view" ? "view" : "table" }));
+        const chosen = table === undefined ? tables[0]?.name : table;
+        const selected = allTables.find((row) => row.name === chosen);
+        const base = { tables, tablesTruncated: allTables.length > 500, offset, pageSize: PAGE_SIZE };
+        if (chosen === undefined)
+            return { ...base, table: null, schema: "", columns: [], columnsTruncated: false, rows: [], hasMore: false };
+        if (!selected || !tables.some((entry) => entry.name === chosen))
+            throw new Error("Table or view no longer exists");
+        try {
+            const info = db.prepare("SELECT name, type, pk FROM pragma_table_xinfo(?) WHERE hidden != 1 ORDER BY cid LIMIT 65").all(chosen);
+            const columns = info.slice(0, MAX_COLUMNS).map((column) => ({ name: String(column.name), type: String(column.type || ""), primaryKey: Number(column.pk) }));
+            if (!columns.length)
+                throw new Error("No readable columns");
+            const projection = columns.flatMap((column, index) => {
+                const name = identifier(column.name);
+                return [
+                    `CASE typeof(${name}) WHEN 'blob' THEN NULL WHEN 'text' THEN substr(${name},1,${MAX_CELL_TEXT + 1}) ELSE ${name} END AS v${index}`,
+                    `typeof(${name}) AS t${index}`,
+                    `CASE WHEN typeof(${name})='blob' THEN length(${name}) END AS b${index}`,
+                ];
+            }).join(",");
+            const keys = columns.filter((column) => column.primaryKey).sort((a, b) => a.primaryKey - b.primaryKey);
+            const order = keys.length ? " ORDER BY " + keys.map((column) => identifier(column.name)).join(",") : "";
+            const statement = db.prepare(`SELECT ${projection} FROM ${identifier(chosen)}${order} LIMIT ? OFFSET ?`);
+            statement.setReadBigInts(true);
+            const records = statement.all(PAGE_SIZE + 1, offset);
+            const rows = records.slice(0, PAGE_SIZE).map((record) => columns.map((_, index) => {
+                const kind = record[`t${index}`];
+                if (kind === "null")
+                    return { kind: "null", value: "" };
+                if (kind === "blob")
+                    return { kind: "blob", value: String(record[`b${index}`] ?? 0) };
+                const value = String(record[`v${index}`] ?? "");
+                return { kind: kind === "integer" || kind === "real" ? "number" : "text", value: value.slice(0, MAX_CELL_TEXT), truncated: value.length > MAX_CELL_TEXT };
+            }));
+            return { ...base, table: chosen, schema: String(selected.sql ?? "").slice(0, 16384), columns, columnsTruncated: info.length > MAX_COLUMNS, rows, hasMore: records.length > PAGE_SIZE };
+        }
+        catch (error) {
+            return { ...base, table: chosen, schema: String(selected.sql ?? "").slice(0, 16384), columns: [], columnsTruncated: false, rows: [], hasMore: false, queryError: error.message };
+        }
+    }
+    finally {
+        db.close();
+    }
+}

package/dist/server/sqlite-worker.js

@@ -0,0 +1,12 @@
+import { querySqlite } from "./sqlite-query.js";
+process.once("message", (request) => {
+    try {
+        process.send?.({ data: querySqlite(request.absolute, request.table, request.offset) });
+    }
+    catch (error) {
+        process.send?.({ error: error.message });
+    }
+    finally {
+        process.disconnect();
+    }
+});

package/dist/server/system-prompt-files.js

@@ -0,0 +1,158 @@
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { promptView, estimatePromptTokens } from "./system-prompt-view.js";
+import { reloadSession } from "./session-reload.js";
+const LIMIT = 512 * 1024;
+const hash = (value) => createHash("sha256").update(value).digest("hex");
+/** Include the canonical target in CAS, so changing a symlink cannot redirect an outstanding edit. */
+function read(path) {
+    if (!existsSync(path)) {
+        if (lstatMissing(path))
+            return { content: "", version: hash(`missing:${canonicalParent(path)}`), exists: false };
+        throw Error("Broken symlink");
+    }
+    const target = realpathSync(path), info = statSync(target);
+    if (!info.isFile() || info.size > LIMIT)
+        throw Error("Prompt file must be text and at most 512 KB");
+    const data = readFileSync(target);
+    const content = new TextDecoder("utf-8", { fatal: true }).decode(data);
+    return { content, version: hash(Buffer.concat([Buffer.from(`${target}\0`), data])), exists: true };
+}
+function lstatMissing(path) { try {
+    lstatSync(path);
+    return false;
+}
+catch (e) {
+    if (e.code === "ENOENT")
+        return true;
+    throw e;
+} }
+function canonicalParent(path) { let parent = dirname(path), suffix = path.slice(parent.length); while (!existsSync(parent)) {
+    const previous = parent;
+    parent = dirname(parent);
+    suffix = previous.slice(parent.length) + suffix;
+} return realpathSync(parent) + suffix; }
+function catalog(session, cwd, agentDir) {
+    const loader = session.resourceLoader, files = [];
+    const systemPath = loader.getSystemPromptSource()?.path, appendPaths = loader.getAppendSystemPromptSources().map(f => resolve(f.path));
+    for (const scope of ["user", "project"])
+        for (const kind of ["system", "append"]) {
+            const path = join(scope === "user" ? agentDir : join(cwd, ".pi"), kind === "system" ? "SYSTEM.md" : "APPEND_SYSTEM.md");
+            files.push({ id: `${kind}:${scope}`, path, kind, scope, active: kind === "system" ? !!systemPath && resolve(systemPath) === resolve(path) : appendPaths.includes(resolve(path)), editable: scope === "user" || session.settingsManager.isProjectTrusted(), tokens: 0, content: "", version: "", exists: false });
+        }
+    for (const file of loader.getAgentsFiles().agentsFiles)
+        files.push({ id: `context:${hash(resolve(file.path))}`, path: resolve(file.path), kind: "context", scope: "context", active: true, editable: true, tokens: 0, content: "", version: "", exists: true });
+    if (session.settingsManager.isProjectTrusted() && !files.some(file => file.kind === "context") && !existsSync(join(cwd, "AGENTS.md")))
+        files.push({ id: "context:new", path: join(cwd, "AGENTS.md"), kind: "context", scope: "context", active: false, editable: true, tokens: 0, content: "", version: "", exists: false });
+    for (const file of files)
+        try {
+            Object.assign(file, read(file.path));
+            const loaded = file.kind === "context" ? loader.getAgentsFiles().agentsFiles.find(f => resolve(f.path) === file.path)?.content : file.active ? (file.kind === "system" ? loader.getSystemPrompt() : loader.getAppendSystemPrompt().join("\n\n")) : undefined;
+            file.tokens = estimatePromptTokens(loaded ?? file.content);
+            file.changedOnDisk = loaded !== undefined && loaded !== file.content;
+        }
+        catch (e) {
+            file.editable = false;
+            file.error = e.message;
+        }
+    return files;
+}
+export function getSystemPromptState(session, cwd, agentDir) {
+    const view = promptView(session, cwd), definitions = session.getAllTools();
+    const files = catalog(session, cwd, agentDir);
+    if (view.opaque)
+        for (const file of files)
+            file.editable = false;
+    const options = view.options;
+    const toolNames = options?.selectedTools ?? session.getActiveToolNames();
+    return { raw: view.raw, tokens: estimatePromptTokens(view.raw), defaultPreamble: view.defaultPreamble, sections: view.sections, rules: view.rules, opaque: view.opaque, forced: view.forced,
+        custom: !!options?.customPrompt, tools: toolNames.map(name => { const tool = definitions.find(t => t.name === name); return { name, custom: !!tool?.sourceInfo && !tool.sourceInfo.path.startsWith("builtin:") && !/^<inline:(codemode|mcp|tool-search)>$/.test(tool.sourceInfo.path), path: tool?.sourceInfo.path }; }), files, trusted: session.settingsManager.isProjectTrusted(), ...promptReloadStatus(session), busy: !session.isIdle };
+}
+export function writeSystemPromptFile(session, cwd, agentDir, id, version, content, restore = false) {
+    const state = getSystemPromptState(session, cwd, agentDir), file = state.files.find(f => f.id === id);
+    if (!file?.editable || state.opaque)
+        throw Error("This prompt source is read-only");
+    if (file.version !== version)
+        throw Error("File changed externally; reopen it before saving");
+    if (restore) {
+        if (file.kind !== "system" || !file.exists)
+            throw Error("Only an existing SYSTEM.md can be restored");
+        unlinkSync(file.path);
+        return file.path;
+    }
+    if (typeof content !== "string" || Buffer.byteLength(content) > LIMIT)
+        throw Error("Prompt text exceeds 512 KB");
+    const target = file.exists ? realpathSync(file.path) : canonicalParent(file.path);
+    mkdirSync(dirname(target), { recursive: true });
+    const temp = `${target}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temp, content, { flag: "wx", mode: file.exists ? statSync(target).mode : 0o600 });
+        renameSync(temp, target);
+    }
+    finally {
+        if (existsSync(temp))
+            unlinkSync(temp);
+    }
+    return file.path;
+}
+export function promptUsesFile(session, cwd, agentDir, path) {
+    const identity = (file) => { try {
+        return realpathSync(file);
+    }
+    catch {
+        return resolve(file);
+    } };
+    const target = identity(path);
+    return session.settingsManager.isProjectTrusted() && resolve(path) === join(cwd, "AGENTS.md") || catalog(session, cwd, agentDir).some(file => resolve(file.path) === resolve(path) || identity(file.path) === target);
+}
+const reloads = new WeakMap();
+export function promptReloadStatus(session) {
+    const state = reloads.get(session);
+    return { pending: !!state && (state.dirty || !!state.promise), ...(state?.error ? { reloadError: state.error } : {}) };
+}
+export async function flushPromptReload(session, retry = false) {
+    const state = reloads.get(session);
+    if (!state)
+        return;
+    if (state.promise)
+        return state.promise;
+    if (!state.dirty || !session.isIdle || (state.error && !retry))
+        return;
+    state.error = undefined;
+    state.dirty = false;
+    state.promise = (async () => {
+        try {
+            await reloadSession(session);
+            state.refreshed();
+        }
+        catch (e) {
+            state.error = e.message;
+            state.dirty = true;
+        }
+        finally {
+            state.promise = undefined;
+            if (!state.dirty) {
+                state.unsubscribe?.();
+                reloads.delete(session);
+            }
+        }
+    })();
+    await state.promise;
+    if (state.dirty && !state.error && session.isIdle)
+        await flushPromptReload(session);
+}
+export async function queuePromptReload(session, refreshed) {
+    let state = reloads.get(session);
+    if (!state) {
+        state = { dirty: true, refreshed };
+        reloads.set(session, state);
+        state.unsubscribe = session.subscribe((event) => {
+            if (event.type === "agent_settled")
+                void flushPromptReload(session);
+        });
+    }
+    state.dirty = true;
+    state.error = undefined;
+    await flushPromptReload(session);
+}

package/dist/server/system-prompt-routes.js

@@ -0,0 +1,40 @@
+/** File changes stay outside agent messages and use the native resource reload. */
+export function installSystemPromptRoutes(app, service, originAllowed) {
+    app.post("/api/system-prompt", async (req, res) => {
+        res.setHeader("Cache-Control", "no-store");
+        if (!originAllowed(req) || !req.is("application/json")) {
+            res.status(403).json({ error: "Forbidden" });
+            return;
+        }
+        const { clientId, cwd, conversationId, action, id, version, content } = req.body ?? {};
+        const cs = typeof clientId === "string" ? service().get(clientId) : undefined;
+        if (!cs || cs.switchingWorkspace || cs.cwd !== cwd || cs.conversationId !== conversationId) {
+            res.status(409).json({ error: "Conversation unavailable" });
+            return;
+        }
+        const session = cs.session;
+        const valid = () => cs.cwd === cwd && cs.session === session && !cs.switchingWorkspace;
+        try {
+            if (!["get", "save", "restore", "retry"].includes(action))
+                throw Error("Invalid prompt action");
+            if (action !== "get" && service().quiesceInfo().quiesced)
+                throw Error("Service draining");
+            if (action === "save" || action === "restore") {
+                if (typeof id !== "string" || typeof version !== "string")
+                    throw Error("Invalid file request");
+                await cs.savePromptFile(id, version, content, action === "restore");
+            }
+            if (action === "retry")
+                await cs.retryPromptReload();
+            if (!valid())
+                throw Error("Conversation changed");
+            const state = await cs.systemPromptState();
+            if (!valid())
+                throw Error("Conversation changed");
+            res.json(state);
+        }
+        catch (error) {
+            res.status(400).json({ error: error.message });
+        }
+    });
+}