pi2web 0.2.6 → 0.2.8

package/README.md

@@ -110,11 +110,19 @@ pi2web \
 - 摘要 LLM 使用流式 Chat Completions；Remote Pi 在完整句子出现后立即调用流式 TTS，因此无需等待整段摘要完成。
 - Web UI 中点击“启用语音”后，会播放服务端推送的 PCM16 或 MP3 音频；新的 Agent 运行会取消该 Agent 尚未完成的播报。
 - 多个 Session 接近同时完成时，语音摘要会进入全局队列依次播放，不会重叠；有 Session 名称时以“会话{name}已完成：”开头。
-- 只有配置 `--voice-stt-model` 时，Web UI 才显示麦克风按钮；识别文字只插入输入框，不会自动发送。
+- 只有配置 `--voice-stt-model`，或在 Web UI「配置 → Sotto 语音输入」开启 Sotto 时，才显示麦克风按钮；识别文字只插入输入框，不会自动发送。
 - API key 通过 `--voice-api-key-env` 和 `--voice-summary-api-key-env` 指定环境变量名，避免把密钥放入命令行参数。
 
 语音流目前通过已认证的 Agent WebSocket 发送，只会实时投递，不写入 Session 或事件 replay。浏览器麦克风通常要求 HTTPS 安全上下文（`localhost` 例外）。
 
+### 使用本机 Sotto 进行语音输入（无需另一份 STT 模型）
+
+先在**与 pi2web Backend 同一台机器**启动支持 `/api/capabilities` 和 `/api/transcribe` 的 Sotto Web 版本，再在 pi2web 网页「配置 → Sotto 语音输入」勾选启用并保存。默认 endpoint 为 `http://127.0.0.1:8766`，指的是 **Backend 所在机器**，不是访问网页的手机或电脑；服务端只允许配置 IPv4 回环 HTTP 地址，不允许指向公网。启用时会探测 endpoint，不可用则不会保存开启状态。设置保存在 pi2web 的数据目录，所有使用该 Backend 的网页共享；默认关闭，不配语音识别时麦克风按钮保持隐藏。
+
+浏览器点击麦克风后持续采集单声道 float32 PCM，经 pi2web 已认证的 Agent WebSocket 转发至本机 Sotto；Sotto 持续返回 **partial/final**，网页边说边更新输入框；再次点击停止并定稿，**不会自动发送给 Agent**。切到 Terminal 等其他视图时录音继续；连续 1 分钟没有新的识别文字会自动停止并保留已识别内容。Sotto 复用已加载的 ASR（首次请求才加载一次），使用独立本机 WS 端口（默认 `8768`，即 Web 端口 +2），不对外开放。浏览器需支持安全上下文、Web Audio、麦克风权限；`Alt+Shift+V` 可启停。Sotto 的 ASR 实时测试运行时不能并用实时输入，普通监听可并存但共享同一个识别器。原有 `--voice-*` 语音摘要和 STT 功能保持独立；不要同时配置另一套 STT 模型，除非确实需要第二个识别服务。
+
+实时听写采用**点击开始、再次点击停止**：停顿只用于分句定稿，不会结束录音，也没有固定一分钟的录音上限。停止时先发送 Worklet 中尚未发送的尾部音频，再等待最终结果。切换 Agent 或归档录音所属 Agent 会取消录音，切到 Terminal 则继续；关闭 Sotto 或修改其服务地址会结束该 Backend 所有网页已经建立的实时语音连接，当前网页尚在启动的采集也会取消。停止已有录音不受“能否开始新录音”的条件限制；连接、麦克风或音频积压异常会停止并提示原因。代理仍限制单帧大小及发送积压，连续 30 秒没有收到音频帧会报错关闭连接（静音也会产生音频帧，因此不是“静音超时”）。启动中再次点击可取消；后台运行时请留意浏览器的麦克风指示并主动停止录音。
+
 ### Edge TTS（仅语音合成）
 
 项目提供了一个基于 Python `edge-tts` 和 `aiohttp` 的轻量本地服务。它直接返回 MP3，不需要 Docker 或 FFmpeg：
@@ -188,7 +196,7 @@ python scripts/migrate_data_dir.py             # 复制 ~/.pi/remote-pi -> ~/.pi
 - `workspaces`：Workspace ID、名称、根目录和创建时间。
 - `agents`：Agent 与 Workspace/Session 的映射、cwd、状态、创建/最后活动时间以及 Archive 状态。
 - `sessions`：用于 Session 列表、排序和分页的轻量索引，包括名称、文件路径、消息数量、文件 mtime/size 和最后活动时间。
-- `agents.template`：Agent 创建时选定的 System Prompt 模板快照（JSON），之后不可修改。
+- `agents.template`：Agent 的 System Prompt 模板快照（JSON）。仅在第一条会话消息前可修改，保存成功后才生效；对话开始后固定，卸载或重启不会改变。
 - `agent-templates/*.md`：可分享的 Agent 模板文件，见下文「System Prompt 与 Agent 模板」。
 - `auth.json`：配对码的 SHA-256 hash、创建和轮换时间；认证数据仍单独保存，不保存配对码明文，文件权限为 `0600`。
 
@@ -376,7 +384,7 @@ mode: append        # append：追加在 Pi Prompt 之后；replace：替换 Pi
 You are a meticulous code reviewer. ...
 ```
 
-新建 Agent 时可选择模板（默认是 Pi 自己的 Prompt）。模板内容在创建时复制到 Agent 记录中，**之后不能更改**：修改或删除模板文件不影响已有 Agent，Fork 出的 Agent 沿用同一模板。两种模式下 Pi 仍会加上 AGENTS.md 等项目上下文、skills 和 cwd；`replace` 会去掉 Pi 内置的工具说明、规则和文档段落，`APPEND_SYSTEM.md` 仍然生效。Agent 工具栏的「Prompt」按钮显示该 Agent 当前生效的完整 System Prompt。
+新建 Agent 时可选择模板（默认是 Pi 自己的 Prompt）。模板内容复制为 Agent 自己的快照；**第一条会话消息前可以修改，开始对话后不能更改**。模板替换与会话写入共用准入检查，写入期间不能替换，替换期间不能写入。修改操作先保存到数据库再启用，保存失败则保留原模板；Stop 或归档会使未完成的替换失效，迟到的候选会话会被释放，不会重新启用 Agent。后端重启或 Agent 重新加载仍使用最后保存的快照，不会退回创建时的选择。修改或删除模板文件不影响已有 Agent，Fork 出的 Agent 沿用同一模板。两种模式下 Pi 仍会加上 AGENTS.md 等项目上下文、skills 和 cwd；`replace` 会去掉 Pi 内置的工具说明、规则和文档段落，`APPEND_SYSTEM.md` 仍然生效。Agent 工具栏的「Prompt」按钮显示该 Agent 当前生效的完整 System Prompt。
 
 运行时使用真实 `@earendil-works/pi-coding-agent` SDK，并复用 Pi CLI 的 `~/.pi/agent` 模型、认证和设置。`MockBackend` 只用于自动化测试。
 

package/dist/agents.js

@@ -5,6 +5,7 @@ import { createSdkBackend } from './sdk-backend.js';
 import { ActivityTracker } from './activity.js';
 import { AgentFeed } from './agent-feed.js';
 import { buildTimeline, itemBody, pageTimeline } from './timeline.js';
+import { sessionPerformance } from './session-performance.js';
 /**
  * Reduce a Pi SDK event to the fields server-side consumers and clients use, or drop it.
  * Heavy SDK events are whitelisted field by field (Pi attaches whole messages to many of
@@ -125,6 +126,17 @@ export class MockBackend {
         this.emitQueue();
         return cleared;
     }
+    async moveQueue(from, index, expected) {
+        if (this.state.status !== 'streaming' || this.queue[from][index] !== expected)
+            throw Object.assign(new Error('Queued message has changed or already been consumed'), {
+                code: 'QUEUE_CHANGED'
+            });
+        const to = from === 'steering' ? 'followUp' : 'steering';
+        this.queue[from].splice(index, 1);
+        this.queue[to].push(expected);
+        this.emitQueue();
+        return this.getQueue();
+    }
     emitQueue() {
         this.emit({ type: 'queue_update', steering: [...this.queue.steering], followUp: [...this.queue.followUp] });
     }
@@ -340,6 +352,7 @@ export class AgentManager {
         const entry = {
             record,
             backend,
+            writes: 0,
             activity: new ActivityTracker(),
             dialogRequests: new Map(),
             queue: emptyQueue()
@@ -369,6 +382,7 @@ export class AgentManager {
                 };
                 this.agents.set(saved.agentId, {
                     record,
+                    writes: 0,
                     activity: new ActivityTracker(),
                     dialogRequests: new Map(),
                     queue: emptyQueue()
@@ -391,8 +405,31 @@ export class AgentManager {
     isLoaded(id) {
         return !!this.get(id).backend;
     }
+    assertCurrent(entry, backend) {
+        if (entry.unloading ||
+            this.agents.get(entry.record.agentId) !== entry ||
+            (backend && entry.backend !== backend))
+            throw Object.assign(new Error('Agent session changed; retry the command'), { code: 'SESSION_BUSY' });
+    }
+    /** All session mutations share admission. Replacement is exclusive; ordinary writes remain concurrent. */
+    async writeSession(id, action) {
+        const entry = this.get(id);
+        this.assertCurrent(entry);
+        if (entry.templateChanging)
+            throw Object.assign(new Error('System Prompt is being changed'), { code: 'SESSION_BUSY' });
+        entry.writes++;
+        try {
+            const backend = await this.ensureLoaded(id);
+            this.assertCurrent(entry, backend);
+            return await action(backend, entry);
+        }
+        finally {
+            entry.writes--;
+        }
+    }
     async ensureLoaded(id) {
         const entry = this.get(id);
+        this.assertCurrent(entry);
         if (entry.backend)
             return entry.backend;
         if (entry.record.status === 'stopped')
@@ -403,7 +440,15 @@ export class AgentManager {
         entry.loading = (async () => {
             try {
                 const backend = await this.factory(id, entry.record.cwd, entry.record.sessionFile, entry.record.profile, entry.record.template ? { template: entry.record.template } : {});
-                const state = await backend.getState();
+                let state;
+                try {
+                    state = await backend.getState();
+                    this.assertCurrent(entry);
+                }
+                catch (error) {
+                    await backend.dispose();
+                    throw error;
+                }
                 entry.record = {
                     ...entry.record,
                     ...state,
@@ -416,7 +461,8 @@ export class AgentManager {
                 return backend;
             }
             catch (error) {
-                entry.record.status = 'error';
+                if (!entry.unloading)
+                    entry.record.status = 'error';
                 throw error;
             }
             finally {
@@ -426,18 +472,30 @@ export class AgentManager {
         return entry.loading;
     }
     async command(id, kind, message = '') {
-        const entry = this.get(id);
-        if (kind === 'abort' && !entry.backend)
-            return;
-        if (entry.record.status === 'stopped')
-            throw Object.assign(new Error('Agent is not running'), { code: 'AGENT_NOT_RUNNING' });
-        const backend = await this.ensureLoaded(id);
         if (kind === 'abort') {
+            const entry = this.get(id);
+            if (!entry.backend)
+                return;
             if (entry.activity.stopping())
                 this.publishActivity(entry);
-            return backend.abort();
+            return entry.backend.abort();
         }
-        return backend[kind === 'follow-up' ? 'followUp' : kind](message);
+        return this.writeSession(id, async (backend, entry) => {
+            const state = await backend.getState();
+            this.assertCurrent(entry, backend);
+            // Read and reserve without yielding: simultaneous idle inputs start exactly one turn.
+            const busy = entry.promptPending || entry.streaming || state.status === 'streaming';
+            const effective = busy ? (kind === 'prompt' ? 'follow-up' : kind) : 'prompt';
+            if (effective === 'prompt')
+                entry.promptPending = true;
+            try {
+                return await backend[effective === 'follow-up' ? 'followUp' : effective](message);
+            }
+            finally {
+                if (effective === 'prompt' && entry.backend === backend)
+                    entry.promptPending = false;
+            }
+        });
     }
     /** Queued steering and follow-up messages waiting for the running turn. */
     // Both read through to the backend and leave the cache to `queue_update`, which stays correct when a
@@ -451,7 +509,10 @@ export class AgentManager {
     /** Drop queued messages and return them so the caller can restore them to its composer. */
     async clearQueue(id) {
         const entry = this.get(id);
-        return entry.backend ? entry.backend.clearQueue() : emptyQueue();
+        return entry.backend ? this.writeSession(id, backend => backend.clearQueue()) : emptyQueue();
+    }
+    async moveQueue(id, from, index, expected) {
+        return this.writeSession(id, backend => backend.moveQueue(from, index, expected));
     }
     snapshotState(id) {
         const a = this.get(id);
@@ -490,20 +551,36 @@ export class AgentManager {
         this.globalListeners.add(listener);
         return () => this.globalListeners.delete(listener);
     }
-    async dispose(id) {
-        const a = this.get(id);
-        if (a.loading)
-            await a.loading.catch(() => { });
-        await a.backend?.dispose();
-        a.backend = undefined;
-        a.feed?.close();
-        a.feed = undefined;
-        a.record.status = 'unloaded';
-        a.streaming = false;
-        a.dialogRequests.clear();
-        a.activity.reset(); // agent_unloaded below tells clients the activity is gone.
-        a.queue = emptyQueue();
-        this.publish(a, { type: 'agent_unloaded' });
+    dispose(id) {
+        const entry = this.get(id);
+        if (entry.unloading)
+            return entry.unloading;
+        // Reserve Stop synchronously. In-flight loads/replacements must validate before attaching.
+        entry.unloading = Promise.resolve()
+            .then(async () => {
+            if (entry.loading)
+                await entry.loading.catch(() => { });
+            const backend = entry.backend;
+            entry.backend = undefined;
+            entry.feed?.close();
+            entry.feed = undefined;
+            try {
+                await backend?.dispose();
+            }
+            finally {
+                entry.record.status = 'unloaded';
+                entry.streaming = false;
+                entry.promptPending = false;
+                entry.dialogRequests.clear();
+                entry.activity.reset();
+                entry.queue = emptyQueue();
+                this.publish(entry, { type: 'agent_unloaded' });
+            }
+        })
+            .finally(() => {
+            entry.unloading = undefined;
+        });
+        return entry.unloading;
     }
     async remove(id) {
         await this.dispose(id);
@@ -530,6 +607,11 @@ export class AgentManager {
             throw Object.assign(new Error('Timeline item not found'), { code: 'TIMELINE_ITEM_NOT_FOUND' });
         return { sessionId: source.sessionId, ...page };
     }
+    /** All timing records of the current branch; older sessions only have partial tool timings. */
+    async performance(id) {
+        const source = (await this.ensureLoaded(id)).timeline();
+        return { sessionId: source.sessionId, ...sessionPerformance(source.entries()) };
+    }
     /** The full body of one timeline item of the given session. It never changes. */
     async item(id, sessionId, itemId) {
         const source = (await this.ensureLoaded(id)).timeline(), body = source.sessionId === sessionId ? itemBody(buildTimeline(source.entries()), itemId) : undefined;
@@ -541,6 +623,57 @@ export class AgentManager {
         const info = await (await this.ensureLoaded(id)).getSystemPrompt();
         return { ...info, template: this.get(id).record.template ?? null };
     }
+    /** Prepare → persist → activate under the template lock. A failed save leaves the old session intact. */
+    async setTemplate(id, template, persist) {
+        const entry = this.get(id);
+        this.assertCurrent(entry);
+        if (entry.record.profile !== 'default' ||
+            entry.record.status === 'stopped' ||
+            entry.streaming ||
+            entry.writes)
+            throw Object.assign(new Error('System Prompt can only change before the first turn'), {
+                code: 'SESSION_STARTED'
+            });
+        if (entry.templateChanging)
+            throw Object.assign(new Error('System Prompt is being changed'), { code: 'SESSION_BUSY' });
+        entry.templateChanging = true;
+        try {
+            const old = await this.ensureLoaded(id);
+            this.assertCurrent(entry, old);
+            const session = await old.getSession();
+            if (session.entries.some(x => x.type === 'message'))
+                throw Object.assign(new Error('This session already has messages'), { code: 'SESSION_STARTED' });
+            const capabilities = await old.getCapabilities();
+            this.assertCurrent(entry, old);
+            const replacement = await this.factory(id, entry.record.cwd, entry.record.sessionFile, entry.record.profile, template ? { template } : {});
+            try {
+                const model = capabilities.model;
+                if (model?.provider && model?.id)
+                    await replacement.setModel(model.provider, model.id);
+                if (typeof capabilities.thinkingLevel === 'string')
+                    await replacement.setThinkingLevel(capabilities.thinkingLevel);
+                if (entry.record.sessionName)
+                    await replacement.setSessionName(entry.record.sessionName);
+                const state = await replacement.getState();
+                this.assertCurrent(entry, old);
+                const record = { ...entry.record, ...state, template };
+                // Persistence is synchronous: no command can observe a choice that has not been committed.
+                persist(record);
+                entry.record = record;
+                this.connect(entry, replacement);
+                this.publish(entry, { type: 'agent_loaded' });
+                await old.dispose().catch(() => { });
+                return record;
+            }
+            catch (error) {
+                await replacement.dispose();
+                throw error;
+            }
+        }
+        finally {
+            entry.templateChanging = false;
+        }
+    }
     async capabilities(id) {
         return (await this.ensureLoaded(id)).getCapabilities();
     }
@@ -557,40 +690,49 @@ export class AgentManager {
         return { ...info, sessionName: name };
     }
     async compact(id, instructions) {
-        return (await this.ensureLoaded(id)).compact(instructions);
+        return this.writeSession(id, backend => backend.compact(instructions));
     }
     async setModel(id, provider, modelId) {
-        return (await this.ensureLoaded(id)).setModel(provider, modelId);
+        return this.writeSession(id, backend => backend.setModel(provider, modelId));
     }
     async setThinkingLevel(id, level) {
-        return (await this.ensureLoaded(id)).setThinkingLevel(level);
+        return this.writeSession(id, backend => backend.setThinkingLevel(level));
     }
     async setSessionName(id, name) {
-        await (await this.ensureLoaded(id)).setSessionName(name);
-        this.get(id).record.sessionName = name.trim();
+        return this.writeSession(id, async (backend, entry) => {
+            await backend.setSessionName(name);
+            this.assertCurrent(entry, backend);
+            entry.record.sessionName = name.trim();
+        });
     }
     async navigate(id, entryId) {
-        const result = await (await this.ensureLoaded(id)).navigate(entryId);
-        this.get(id).feed?.sync(); // Moving the leaf back is no event; tell viewers to reload.
-        return result;
+        return this.writeSession(id, async (backend, entry) => {
+            const result = await backend.navigate(entryId);
+            this.assertCurrent(entry, backend);
+            entry.feed?.sync(); // Moving the leaf back is no event; tell viewers to reload.
+            return result;
+        });
     }
     async fork(id, entryId) {
-        const source = this.get(id), result = await (await this.ensureLoaded(id)).fork(entryId);
-        if (!result.sessionFile)
-            throw Object.assign(new Error('Session persistence is disabled'), { code: 'SESSION_NOT_PERSISTED' });
-        const ws = this.workspaces.get(source.record.workspaceId);
-        const agent = await this.create(source.record.workspaceId, pathRelative(ws.rootPath, source.record.cwd), result.sessionFile, source.record.profile, source.record.template);
-        return { agent, selectedText: result.selectedText };
+        return this.writeSession(id, async (backend, source) => {
+            const result = await backend.fork(entryId);
+            this.assertCurrent(source, backend);
+            if (!result.sessionFile)
+                throw Object.assign(new Error('Session persistence is disabled'), { code: 'SESSION_NOT_PERSISTED' });
+            const ws = this.workspaces.get(source.record.workspaceId);
+            const agent = await this.create(source.record.workspaceId, pathRelative(ws.rootPath, source.record.cwd), result.sessionFile, source.record.profile, source.record.template);
+            return { agent, selectedText: result.selectedText };
+        });
     }
     async extensionResponse(id, requestId, value) {
-        return (await this.ensureLoaded(id)).extensionResponse(requestId, value);
+        return this.writeSession(id, backend => backend.extensionResponse(requestId, value));
     }
     async listCommands(id) {
         return (await this.ensureLoaded(id)).listCommands();
     }
     /** Session-scoped bash. Output is streamed as `bash_execution_update` events and recorded in the Session. */
     async runBash(id, command, excludeFromContext = false) {
-        return (await this.ensureLoaded(id)).runBash(command, excludeFromContext);
+        return this.writeSession(id, backend => backend.runBash(command, excludeFromContext));
     }
     async abortBash(id) {
         const entry = this.get(id);

package/dist/http/agent-routes.js

@@ -81,6 +81,8 @@ export async function handleAgentRoutes(ctx, req, res, u, parts) {
             return send(200, {
                 data: await ctx.agents.timeline(id, Number(u.searchParams.get('limit') ?? 50), u.searchParams.get('before') ?? undefined)
             });
+        if (req.method === 'GET' && parts[4] === 'performance' && parts.length === 5)
+            return send(200, { data: await ctx.agents.performance(id) });
         // /agents/:id/sessions/:sessionId/items/:itemId — items never change, and the session is part of the
         // URL so a cached body is never served for another one: let the browser keep it for good.
         if (req.method === 'GET' && parts[4] === 'sessions' && parts[6] === 'items' && parts.length === 8) {
@@ -90,6 +92,14 @@ export async function handleAgentRoutes(ctx, req, res, u, parts) {
         }
         if (req.method === 'GET' && parts[4] === 'system-prompt')
             return send(200, { data: await ctx.agents.systemPrompt(id) });
+        if (req.method === 'POST' && parts[4] === 'system-prompt') {
+            const b = await ctx.body();
+            if (b.templateId !== undefined && typeof b.templateId !== 'string')
+                throw Object.assign(new Error('templateId must be a string'), { code: 'INVALID_REQUEST' });
+            const template = b.templateId ? ctx.templates.snapshot(b.templateId) : undefined;
+            const record = await ctx.agents.setTemplate(id, template, candidate => ctx.metadata.commitAgentTemplate(candidate));
+            return send(200, { data: { template: record.template ?? null } });
+        }
         if (req.method === 'GET' && parts[4] === 'capabilities')
             return send(200, { data: await ctx.agents.capabilities(id) });
         if (req.method === 'GET' && parts[4] === 'session')
@@ -154,6 +164,15 @@ export async function handleAgentRoutes(ctx, req, res, u, parts) {
                 return send(200, { data: await ctx.agents.queue(id) });
             if (req.method === 'DELETE')
                 return send(200, { data: await ctx.agents.clearQueue(id) });
+            if (req.method === 'POST' && parts[5] === 'move') {
+                const { from, index, expected } = await ctx.body();
+                if ((from !== 'steering' && from !== 'followUp') ||
+                    !Number.isSafeInteger(index) ||
+                    index < 0 ||
+                    typeof expected !== 'string')
+                    throw Object.assign(new Error('from, index and expected are required'), { code: 'INVALID_REQUEST' });
+                return send(200, { data: await ctx.agents.moveQueue(id, from, index, expected) });
+            }
         }
         if (parts[4] === 'mcp') {
             const cwd = ctx.agents.get(id).record.cwd;
@@ -172,10 +191,17 @@ export async function handleAgentRoutes(ctx, req, res, u, parts) {
             return send(200, { data: { success: true } });
         }
         if (req.method === 'POST' && parts[4] === 'transcribe') {
+            ctx.agents.get(id);
+            const mime = String(req.headers['content-type'] ?? 'audio/webm').split(';')[0];
+            if (ctx.sottoStt.getSettings().enabled) {
+                if (mime !== 'application/octet-stream')
+                    throw Object.assign(new Error('Sotto requires 16 kHz float32 PCM'), { code: 'INVALID_REQUEST' });
+                const audio = await ctx.binaryBody();
+                return send(200, { data: await ctx.sottoStt.transcribe(audio) });
+            }
             if (!ctx.voice)
                 throw Object.assign(new Error('Voice service is disabled'), { code: 'VOICE_DISABLED' });
-            ctx.agents.get(id);
-            const audio = await ctx.binaryBody(), mime = String(req.headers['content-type'] ?? 'audio/webm').split(';')[0], filename = String(req.headers['x-audio-filename'] ?? 'recording.webm');
+            const audio = await ctx.binaryBody(), filename = String(req.headers['x-audio-filename'] ?? 'recording.webm');
             return send(200, { data: await ctx.voice.transcribe(audio, mime, filename) });
         }
         if (req.method === 'POST' && ['prompt', 'steer', 'follow-up', 'abort'].includes(parts[4])) {

package/dist/http/utils.js

@@ -35,7 +35,11 @@ export function errorStatus(code) {
         return 403;
     if (code === 'FILE_TOO_LARGE' || code === 'REQUEST_TOO_LARGE')
         return 413;
-    if (code === 'VOICE_DISABLED' || code === 'VOICE_STT_DISABLED' || code === 'MAIL_NOTIFICATIONS_DISABLED')
+    if (code === 'VOICE_DISABLED' ||
+        code === 'VOICE_STT_DISABLED' ||
+        code === 'SOTTO_DISABLED' ||
+        code === 'SOTTO_UNAVAILABLE' ||
+        code === 'MAIL_NOTIFICATIONS_DISABLED')
         return 503;
     if (code?.endsWith('NOT_FOUND'))
         return 404;

package/dist/http/web-assets.js

@@ -10,6 +10,7 @@ const webFiles = {
     '/': { file: 'index.html', type: 'text/html; charset=utf-8' },
     '/index.html': { file: 'index.html', type: 'text/html; charset=utf-8' },
     '/app.js': { file: 'app.js', type: 'text/javascript; charset=utf-8' },
+    '/voice-pcm.js': { file: 'voice-pcm.js', type: 'text/javascript; charset=utf-8' },
     '/backend-state.js': { file: 'backend-state.js', type: 'text/javascript; charset=utf-8' },
     '/hid-keyboard.js': { file: 'hid-keyboard.js', type: 'text/javascript; charset=utf-8' },
     '/activity-view.js': { file: 'activity-view.js', type: 'text/javascript; charset=utf-8' },

package/dist/metadata-store.js

@@ -176,7 +176,8 @@ export class MetadataStore {
     writeAgent(record, archivedAt) {
         this.database
             .prepare(
-        // `template` is written on insert only: an Agent's system prompt template never changes.
+        // Ordinary state/index writes must not overwrite the conversation's template snapshot.
+        // Only commitAgentTemplate may change it after creation.
         `INSERT INTO agents(id,workspace_id,session_id,session_file,session_name,cwd,status,profile,template,created_at,last_active_at,archived_at) VALUES(?,?,?,?,?,?,?,?,?,?,?,?) ON CONFLICT(id) DO UPDATE SET workspace_id=excluded.workspace_id,session_id=excluded.session_id,session_file=excluded.session_file,session_name=excluded.session_name,cwd=excluded.cwd,status=excluded.status,profile=excluded.profile,last_active_at=excluded.last_active_at,archived_at=excluded.archived_at`)
             .run(record.agentId, record.workspaceId, record.sessionId, record.sessionFile ?? null, record.sessionName ?? null, record.cwd, record.status, record.profile ?? 'default', record.template ? JSON.stringify(record.template) : null, asTime(record.createdAt), asTime(record.lastActiveAt), archivedAt);
     }
@@ -186,6 +187,18 @@ export class MetadataStore {
         this.pendingAgents.delete(record.agentId);
         this.writeAgent(record, null);
     }
+    /** Commit the validated pre-conversation choice and its session identity together. */
+    commitAgentTemplate(record) {
+        this.database.transaction(() => {
+            const updated = this.database
+                .prepare('UPDATE agents SET template=? WHERE id=? AND archived_at IS NULL')
+                .run(record.template ? JSON.stringify(record.template) : null, record.agentId);
+            if (!updated.changes)
+                throw Object.assign(new Error('Agent not found'), { code: 'AGENT_NOT_FOUND' });
+            this.writeAgent(record, null);
+        })();
+        this.pendingAgents.delete(record.agentId);
+    }
     scheduleAgent(record) {
         if (this.archivedAgents.has(record.agentId))
             return;

package/dist/sdk-backend.js

@@ -1,6 +1,7 @@
 import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } from '@earendil-works/pi-coding-agent';
 import { EventEmitter } from 'node:events';
 import { randomUUID } from 'node:crypto';
+import { PERFORMANCE_ENTRY, SessionPerformanceTracker } from './session-performance.js';
 import { createCollabExtension } from './collab/pi-extension.js';
 /** Older Pi builds resolved steer()/followUp() with undefined; treat anything but an explicit `handled` as queued. */
 const normalizeDisposition = (value) => value === 'handled' ? 'handled' : 'queued';
@@ -16,6 +17,8 @@ export class SdkBackend {
         this.session = session;
         this.agentId = agentId;
         this.cwd = cwd;
+        const performance = new SessionPerformanceTracker(run => this.session.sessionManager.appendCustomEntry(PERFORMANCE_ENTRY, run));
+        this.session.subscribe(event => performance.apply(event));
     }
     static async create(agentId, cwd, sessionFile, profile = 'default', collabBridge, options = {}) {
         const sessionManager = sessionFile ? SessionManager.open(sessionFile) : SessionManager.create(cwd);
@@ -81,6 +84,31 @@ export class SdkBackend {
         const cleared = this.session.clearQueue();
         return { steering: [...cleared.steering], followUp: [...cleared.followUp] };
     }
+    async moveQueue(from, index, expected) {
+        const before = {
+            steering: [...this.session.getSteeringMessages()],
+            followUp: [...this.session.getFollowUpMessages()]
+        };
+        if (!this.session.isStreaming || before[from][index] !== expected)
+            throw Object.assign(new Error('Queued message has changed or already been consumed'), {
+                code: 'QUEUE_CHANGED'
+            });
+        const to = from === 'steering' ? 'followUp' : 'steering';
+        before[from].splice(index, 1);
+        before[to].push(expected);
+        if ([...before.steering, ...before.followUp].some(text => text.startsWith('/')))
+            throw Object.assign(new Error('Slash commands cannot be moved safely'), { code: 'QUEUE_CHANGED' });
+        // Pi exposes clearQueue(), but no per-message move. Clear and requeue in the same JS turn:
+        // steer()/followUp() enqueue synchronously before their promises settle. No model callback can
+        // drain the half-updated queue between these calls. Never replace a stale queue by index alone.
+        this.session.clearQueue();
+        const pending = [
+            ...before.steering.map(text => this.session.steer(text)),
+            ...before.followUp.map(text => this.session.followUp(text))
+        ];
+        await Promise.all(pending);
+        return this.getQueue();
+    }
     abort() {
         return this.session.abort();
     }