handmux 0.27.2 → 0.29.0

package/dist/src/agents/claudeNativeTail.js

@@ -0,0 +1,271 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isSessionUuid } from './scanUtils.js';
+import { claudeLocalCommandCompletion } from './claudeLocalCommand.js';
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+const METADATA = new Set(['last-prompt', 'ai-title', 'mode', 'permission-mode', 'file-history-snapshot']);
+const MAX_BYTES = 65536;
+const MAX_SESSIONS = 128;
+function interruption(rows, sessionId, promptId, after, now) {
+    let duration;
+    for (let index = rows.length - 1; index >= 0; index--) {
+        const row = rows[index];
+        if (!row)
+            return null;
+        if (typeof row.type === 'string' && METADATA.has(row.type))
+            continue;
+        if (row.sessionId !== sessionId || row.isSidechain !== false || !isSessionUuid(row.uuid)
+            || row.isMeta === true || row.isCompactSummary === true)
+            return null;
+        const timestamp = typeof row.timestamp === 'string' ? Date.parse(row.timestamp) : NaN;
+        if (!Number.isFinite(timestamp) || timestamp <= after || timestamp > now)
+            return null;
+        if (row.type === 'system' && row.subtype === 'turn_duration' && !duration) {
+            duration = row;
+            continue;
+        }
+        if (row.type !== 'user' || (promptId !== undefined && promptId !== row.promptId)
+            || ['promptSource', 'origin', 'permissionMode'].some((key) => Object.hasOwn(row, key)))
+            return null;
+        const message = record(row.message);
+        const content = message?.content;
+        if (message?.role !== 'user' || !Array.isArray(content) || content.length !== 1)
+            return null;
+        const block = record(content[0]);
+        if (block?.type !== 'text')
+            return null;
+        if (block.text !== '[Request interrupted by user for tool use]'
+            && !(block.text === '[Request interrupted by user]' && typeof row.interruptedMessageId === 'string'
+                && row.interruptedMessageId.length > 0 && row.interruptedMessageId.length <= 256))
+            return null;
+        if (duration && (duration.parentUuid !== row.uuid || Date.parse(String(duration.timestamp)) < timestamp))
+            return null;
+        return `claude-interrupted:${sessionId}:${row.uuid}`;
+    }
+    return null;
+}
+// Shared by the Claude activity reader and its Inbox Connector. No timer: existing polls stat first,
+// and one changed file produces at most one 64 KiB read and JSON parse across both consumers.
+export class ClaudeNativeTailReader {
+    #tails = new Map();
+    #nativeProcesses = new Set();
+    #statuses = new Map();
+    read(payload, after, now, process, src) {
+        const native = this.#readTranscript(payload, after, now);
+        const file = payload.transcript_path;
+        if (!process || !Number.isSafeInteger(process.pid) || process.pid <= 0
+            || !Number.isFinite(process.startedAt) || typeof file !== 'string' || !path.isAbsolute(file)
+            || !isSessionUuid(payload.session_id) || path.basename(file) !== `${payload.session_id}.jsonl`
+            || path.basename(path.dirname(path.dirname(file))) !== 'projects')
+            return native;
+        const registry = path.join(path.dirname(path.dirname(path.dirname(file))), 'sessions', `${process.pid}.json`);
+        const identity = `${payload.session_id}:${process.pid}:${process.startedAt}`;
+        const unknown = () => this.#nativeProcesses.has(identity) ? { ...native, status: 'unknown', settled: null, localCommand: null } : native;
+        let row;
+        try {
+            const stat = fs.statSync(registry);
+            this.#nativeProcesses.add(identity);
+            while (this.#nativeProcesses.size > MAX_SESSIONS)
+                this.#nativeProcesses.delete(this.#nativeProcesses.values().next().value);
+            if (!stat.isFile() || stat.size > 16384)
+                return unknown();
+            const fingerprint = [stat.dev, stat.ino, stat.size, stat.mtimeMs, stat.ctimeMs].join(':');
+            const cached = this.#statuses.get(registry);
+            if (cached?.fingerprint === fingerprint)
+                row = cached.row;
+            else {
+                const fd = fs.openSync(registry, 'r');
+                try {
+                    const buffer = Buffer.alloc(stat.size);
+                    const read = fs.readSync(fd, buffer, 0, buffer.length, 0);
+                    const current = fs.fstatSync(fd);
+                    if (read !== buffer.length
+                        || [current.dev, current.ino, current.size, current.mtimeMs, current.ctimeMs].join(':') !== fingerprint)
+                        return unknown();
+                    row = record(JSON.parse(buffer.toString('utf8')));
+                }
+                finally {
+                    fs.closeSync(fd);
+                }
+                this.#statuses.delete(registry);
+                this.#statuses.set(registry, { fingerprint, row });
+                while (this.#statuses.size > MAX_SESSIONS)
+                    this.#statuses.delete(this.#statuses.keys().next().value);
+            }
+        }
+        catch {
+            this.#statuses.delete(registry);
+            return unknown();
+        }
+        if (!row || row.pid !== process.pid || row.sessionId !== payload.session_id || row.kind !== 'interactive'
+            || typeof row.procStart !== 'string' || Date.parse(`${row.procStart} UTC`) !== process.startedAt)
+            return unknown();
+        this.#nativeProcesses.add(identity);
+        while (this.#nativeProcesses.size > MAX_SESSIONS)
+            this.#nativeProcesses.delete(this.#nativeProcesses.values().next().value);
+        const hookSettled = src === 'stop' || src === 'stopfail'
+            || (src === 'start' && ['startup', 'clear', 'resume'].includes(String(payload.source)))
+            || (src === 'compact' && payload.trigger === 'manual');
+        // An explicit terminal Hook owns that completion identity, even if its native idle effect lands
+        // later. This also handles /clear, which may never transition out of native idle at all.
+        if (hookSettled && typeof row.statusUpdatedAt === 'number'
+            && (row.statusUpdatedAt <= after || row.status === 'idle'))
+            return native;
+        if (typeof row.statusUpdatedAt === 'number' && row.statusUpdatedAt <= after) {
+            return { ...native, settled: null, localCommand: null };
+        }
+        if (typeof row.statusUpdatedAt !== 'number' || row.statusUpdatedAt < process.startedAt || row.statusUpdatedAt > now
+            || (row.status === 'idle' && (!native.transcriptComplete || row.statusUpdatedAt <= after || row.statusUpdatedAt < (native.latestNativeAt ?? 0)))
+            || !['idle', 'busy', 'waiting'].includes(String(row.status)))
+            return unknown();
+        const status = row.status;
+        const statusEventId = `claude-native:${payload.session_id}:${process.pid}:${process.startedAt}:${row.statusUpdatedAt}:${status}`;
+        if (status !== 'idle')
+            return { ...native, status, statusEventId, settled: null, localCommand: null };
+        // statusUpdatedAt changes only on native activity transitions, unlike metadata updatedAt.
+        return { ...native, status, settled: `claude-native-idle:${payload.session_id}:${process.pid}:${process.startedAt}:${row.statusUpdatedAt}` };
+    }
+    #readTranscript(payload, after, now) {
+        const sessionId = payload.session_id;
+        const file = payload.transcript_path;
+        const absent = { interruption: null, localCommand: undefined };
+        if (!isSessionUuid(sessionId) || typeof file !== 'string' || path.basename(file) !== `${sessionId}.jsonl`)
+            return absent;
+        let tail;
+        try {
+            const stat = fs.statSync(file);
+            if (!stat.isFile())
+                return { interruption: null, localCommand: null };
+            const fingerprint = [stat.dev, stat.ino, stat.size, stat.mtimeMs, stat.ctimeMs].join(':');
+            const cached = this.#tails.get(file);
+            if (cached?.fingerprint === fingerprint)
+                tail = cached;
+            else {
+                const fd = fs.openSync(file, 'r');
+                let text;
+                try {
+                    const current = fs.fstatSync(fd);
+                    if ([current.dev, current.ino, current.size, current.mtimeMs, current.ctimeMs].join(':') !== fingerprint) {
+                        this.#invalidate(file, after);
+                        return { interruption: null, localCommand: null };
+                    }
+                    const length = Math.min(stat.size, MAX_BYTES);
+                    const buffer = Buffer.alloc(length);
+                    const read = fs.readSync(fd, buffer, 0, length, stat.size - length);
+                    const finished = fs.fstatSync(fd);
+                    if (read !== length
+                        || [finished.dev, finished.ino, finished.size, finished.mtimeMs, finished.ctimeMs].join(':') !== fingerprint) {
+                        this.#invalidate(file, after);
+                        return { interruption: null, localCommand: null };
+                    }
+                    text = buffer.subarray(0, read).toString('utf8');
+                }
+                finally {
+                    fs.closeSync(fd);
+                }
+                const lines = text.split('\n');
+                if (stat.size > MAX_BYTES)
+                    lines.shift();
+                const rows = lines.filter((line) => line.trim()).map((line) => {
+                    try {
+                        return record(JSON.parse(line));
+                    }
+                    catch {
+                        return null;
+                    }
+                });
+                const invalidatedThrough = cached && (cached.fingerprint.split(':')[1] !== String(stat.ino)
+                    || cached.fingerprint.split(':')[0] !== String(stat.dev)
+                    || Number(cached.fingerprint.split(':')[2]) > stat.size)
+                    ? Math.max(cached.lastHookTime, cached.invalidatedThrough ?? 0) : cached?.invalidatedThrough;
+                tail = { sessionId, fingerprint, rows, complete: !text || text.endsWith('\n'), lastHookTime: Math.max(cached?.lastHookTime ?? 0, after),
+                    ...(invalidatedThrough === undefined ? {} : { invalidatedThrough }) };
+            }
+            this.#tails.delete(file);
+            this.#tails.set(file, tail);
+            while (this.#tails.size > MAX_SESSIONS)
+                this.#tails.delete(this.#tails.keys().next().value);
+        }
+        catch {
+            this.#invalidate(file, after);
+            return { interruption: null, localCommand: null };
+        }
+        if (!tail.complete)
+            return { interruption: null, localCommand: null };
+        tail.lastHookTime = Math.max(tail.lastHookTime, after);
+        const interrupted = interruption(tail.rows, sessionId, payload.prompt_id, after, now);
+        const localCommand = claudeLocalCommandCompletion(payload, after, now, tail.rows);
+        // A local picker dispatched after an interrupt fires no new Hook either. Only inherit the idle
+        // lifecycle when that exact command/output pair immediately follows a proven interruption.
+        let settled = interrupted;
+        if (!settled && localCommand) {
+            let native = tail.rows.filter((row) => !row || typeof row.type !== 'string' || !METADATA.has(row.type));
+            while (native.length >= 3 && claudeLocalCommandCompletion(payload, after, now, native)) {
+                const commandTime = Date.parse(String(native.at(-2)?.timestamp));
+                native = native.slice(0, -2);
+                if (Date.parse(String(native.at(-1)?.timestamp)) > commandTime)
+                    break;
+                if (interruption(native, sessionId, payload.prompt_id, after, now)) {
+                    settled = localCommand;
+                    break;
+                }
+            }
+        }
+        return {
+            interruption: interrupted,
+            settled,
+            localCommand: localCommand === undefined && tail.invalidatedThrough !== undefined && after <= tail.invalidatedThrough
+                ? null : localCommand,
+            lastRecord: tail.rows.at(-1) ?? null,
+            transcriptComplete: true,
+            latestNativeAt: Math.max(0, ...tail.rows.map((row) => typeof row?.timestamp === 'string' ? Date.parse(row.timestamp) || 0 : 0)),
+            ...this.#restoredPrompt(tail.rows, payload),
+        };
+    }
+    #restoredPrompt(rows, payload) {
+        // Match native auto_restore_cancel: thinking alone is not visible output. Require the exact
+        // Hook prompt and its main-chain user record; malformed or unknown rows cannot authorize deletion.
+        for (let index = rows.length - 1; index >= 0; index--) {
+            const row = rows[index];
+            if (!row)
+                return {};
+            if (typeof row.type === 'string' && METADATA.has(row.type))
+                continue;
+            if (row.sessionId !== payload.session_id || row.isSidechain !== false || row.isMeta === true)
+                return {};
+            const message = record(row.message);
+            if (row.type === 'assistant' && Array.isArray(message?.content)
+                && message.content.every((block) => record(block)?.type === 'thinking'))
+                continue;
+            if (row.type !== 'user' || row.promptId !== payload.prompt_id || row.promptSource !== 'typed'
+                || message?.role !== 'user' || typeof payload.prompt !== 'string' || !payload.prompt)
+                return {};
+            const content = message.content;
+            const text = typeof content === 'string' ? content
+                : Array.isArray(content) && content.length === 1 && record(content[0])?.type === 'text'
+                    ? record(content[0])?.text : null;
+            return text === payload.prompt ? { restoredPrompt: payload.prompt } : {};
+        }
+        return {};
+    }
+    retain(sessionIds) {
+        for (const [file, tail] of this.#tails)
+            if (!sessionIds.has(tail.sessionId))
+                this.#tails.delete(file);
+    }
+    #invalidate(file, after) {
+        const previous = this.#tails.get(file);
+        if (!previous)
+            return;
+        // Keep only the invalidation boundary across a rotation's temporary ENOENT, never old evidence.
+        this.#tails.set(file, { ...previous, fingerprint: '', rows: [], complete: false,
+            lastHookTime: Math.max(previous.lastHookTime, after),
+            invalidatedThrough: Math.max(previous.lastHookTime, previous.invalidatedThrough ?? 0, after) });
+    }
+    release(sessionId) {
+        for (const [file, tail] of this.#tails)
+            if (tail.sessionId === sessionId)
+                this.#tails.delete(file);
+    }
+    clear() { this.#tails.clear(); this.#statuses.clear(); this.#nativeProcesses.clear(); }
+}

package/dist/src/agents/claudePaneInput.js

@@ -0,0 +1,47 @@
+import { serializePaneInput } from '../paneInput.js';
+const SUBMIT_GAP_MS = 120;
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Read the entire one-line native editor, bounded by its two rules. Wrapped input, attachments,
+// selection menus and unknown layouts fail closed. End is sent first: placeholder text is painted
+// after the cursor but isn't part of the editor; actual text places the cursor at its end.
+export function claudeSingleLineDraft(screen, cursor) {
+    const lines = screen.split('\n');
+    const line = lines[cursor.cursorY];
+    if (!line || !/^─{3,}$/.test(lines[cursor.cursorY - 1]?.trim() ?? '')
+        || !/^─{3,}$/.test(lines[cursor.cursorY + 1]?.trim() ?? '')
+        || !/^❯[ \u00a0]/.test(line))
+        return null;
+    const value = line.slice(2).trimEnd();
+    if (cursor.cursorX === 2)
+        return ''; // Native suggestions are painted here but End does not enter them.
+    if (!value || /[\x00-\x1f\x7f]/.test(value) || cursor.cursorX <= 2)
+        return null;
+    return value;
+}
+export function sendClaudePanePrompt(commands, paneId, text, restoredPrompt, guard) {
+    return serializePaneInput(paneId, async () => {
+        if (guard && !await guard.validate())
+            return { nativeMutation: false };
+        await commands.exitCopyModeIfActive(paneId);
+        await commands.sendKey(paneId, 'End');
+        await delay(SUBMIT_GAP_MS);
+        const readDraft = async () => claudeSingleLineDraft(await commands.capturePlain(paneId), await commands.paneInfo(paneId));
+        const draft = await readDraft();
+        if (draft === null || (draft !== '' && draft !== restoredPrompt())) {
+            return { nativeMutation: false, reason: 'terminal_draft_conflict' };
+        }
+        if (guard && !await guard.validate())
+            return { nativeMutation: false };
+        if (draft) {
+            await commands.sendKey(paneId, 'C-u');
+            await delay(SUBMIT_GAP_MS);
+            if (await readDraft() !== '')
+                return { nativeMutation: false, reason: 'terminal_draft_conflict' };
+        }
+        await commands.sendText(paneId, text);
+        if (text)
+            await delay(SUBMIT_GAP_MS);
+        await commands.sendEnter(paneId);
+        return { nativeMutation: true };
+    });
+}

package/dist/src/agents/codexConversation.js

@@ -1,4 +1,6 @@
 import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
 import { stat } from 'node:fs/promises';
 import { transcriptReader } from '../transcriptReader.js';
 import { createCodexTranscriptParser, } from '../codexTranscriptParse.js';
@@ -6,6 +8,35 @@ import { projectCodexConversationMutation } from '../codexConversationProjection
 import { parseCodexStreamEvent } from '../codexStreamProtocol.js';
 import { resolveCodexRollout, sessionsDir } from './codex.js';
 import { clipConversationText, safeProviderDiffPath, sanitizeToolInputWithMetadata, sanitizeToolResultText, } from './conversationProjectionSafety.js';
+// Display labels deliberately erase the home-directory identity. Downloads must use the
+// original tool input instead; the existing file API still checks realpath and allowed roots.
+function toolImagePath(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        return null;
+    const value = input;
+    const path = value.path;
+    if (typeof path !== 'string' || !path || path.includes('\0'))
+        return null;
+    const absolute = (raw) => {
+        if (typeof raw !== 'string' || raw.includes('\0'))
+            return null;
+        if (raw.startsWith('/'))
+            return raw;
+        if (raw === '~')
+            return homedir();
+        if (raw.startsWith('~/'))
+            return resolve(homedir(), raw.slice(2));
+        return null;
+    };
+    const direct = absolute(path);
+    if (direct)
+        return direct;
+    // Other users' shell abbreviations, URLs and Windows paths are not POSIX relative paths.
+    if (path.startsWith('~') || /^[a-zA-Z][\w+.-]*:/.test(path))
+        return null;
+    const cwd = absolute(value.cwd);
+    return cwd ? resolve(cwd, path) : null;
+}
 const DURABLE_QUIET_MS = 100;
 const DEFAULT_DURABLE_SETTLE_TIMEOUT_MS = 15_000;
 const MAX_OPENING_NATIVE_EVENTS = 4_096;
@@ -328,6 +359,10 @@ function projectDurableMessage(message, sessionId, suppressedCompactorItems) {
                 } : {}),
             }];
     }
+    if (message.type === 'notice' && typeof message.text === 'string') {
+        return [{ ...itemBase(message, sessionId), kind: 'notice', level: message.noticeLevel || 'info',
+                code: 'provider_error', message: clipConversationText(message.text).text }];
+    }
     if (message.type === 'thinking' && typeof message.text === 'string') {
         // Codex rollout stores the provider's public reasoning summary, not hidden reasoning content.
         const output = clipConversationText(message.text);
@@ -364,6 +399,8 @@ function projectDurableMessage(message, sessionId, suppressedCompactorItems) {
                 extensions: {
                     'conversation.tool': {
                         name, input: extensionInput, result: result?.text ?? null,
+                        ...((name === 'view_image' || name === 'functions.view_image')
+                            ? { imagePath: toolImagePath(message.tool.input) } : {}),
                         isError: message.tool.isError === true,
                         ...(outcome === undefined ? {} : { outcome }),
                         ...(safeDiff === undefined ? {} : { diff: safeDiff }),
@@ -926,6 +963,15 @@ export function createCodexConversationAdapter({ app, sessionsRoot = sessionsDir
                     }
                 }
                 if (event.type === 'cursorReset' || event.type === 'disconnected' || event.type === 'error') {
+                    if (event.type === 'error' && event.message.trim()) {
+                        const provisionalId = `codex-stream-error:${sessionId}:${live.sourceSequence + 1}`;
+                        const draft = {
+                            kind: 'notice', level: 'warning', code: 'provider_error', message: event.message.trim(),
+                        };
+                        await emit({ type: 'item.opened', provisionalId, draft });
+                        await emit({ type: 'item.settled', provisionalId,
+                            item: { ...draft, id: provisionalId, sessionId, status: 'complete' } });
+                    }
                     await emit({ type: 'stream.gap', afterSourceSequence: live.sourceSequence });
                     return;
                 }

package/dist/src/agents/piInboxBridge.js

@@ -61,7 +61,9 @@ function parseSnapshot(value, availability, run, sourceId, sequence, label = 'Pi
     }
     if (!isRecord(value) || typeof value.availability !== 'string'
         || !AVAILABILITIES.has(value.availability)
-        || !optionalText(value.message, 1024)) {
+        || !optionalText(value.message, 1024)
+        || (value.sourceSequence !== undefined && (!Number.isSafeInteger(value.sourceSequence)
+            || Number(value.sourceSequence) < 1))) {
         throw new PiInboxBridgeError(`${label} Inbox Bridge returned an invalid snapshot`);
     }
     const snapshotAvailability = value.availability;
@@ -78,7 +80,9 @@ function parseSnapshot(value, availability, run, sourceId, sequence, label = 'Pi
             ...current,
         }] : [];
     return {
+        cursor: `bridge:${sequence}:empty`,
         current: current ?? undefined,
+        ...(typeof value.sourceSequence === 'number' ? { sourceSequence: value.sourceSequence } : {}),
         result: {
             availability: snapshotAvailability,
             ...(snapshotAvailability === 'unavailable' ? {} : { snapshot: baseline }),
@@ -133,16 +137,18 @@ export class BridgeInboxCoordinator {
     #agentId;
     #sourceId;
     #label;
+    #sourceEventSequence;
     #bindings = new Map();
     #stopConsumer;
     #restoreTail = Promise.resolve();
     #closed = false;
-    constructor({ host, projector, agentId = 'pi', sourceId = 'pi.bridge.inbox', label = 'Pi', }) {
+    constructor({ host, projector, agentId = 'pi', sourceId = 'pi.bridge.inbox', label = 'Pi', sourceEventSequence, }) {
         this.#host = host;
         this.#projector = projector;
         this.#agentId = agentId;
         this.#sourceId = sourceId;
         this.#label = label;
+        this.#sourceEventSequence = sourceEventSequence;
     }
     start() {
         if (this.#closed)
@@ -265,6 +271,10 @@ export class BridgeInboxCoordinator {
         if (!binding || !sameRun(binding.lease.ref, replay.run) || binding.phase === 'opening'
             || binding.phase === 'closed')
             return 'retry';
+        if (this.#historical(binding, operation)) {
+            const result = await this.#submitHistory(binding, operation);
+            return this.#replayResult(result.accepted, result.reason);
+        }
         if (binding.phase === 'prebaseline') {
             if (replay.event.sequence > binding.baselineSequence)
                 return 'retry';
@@ -285,18 +295,53 @@ export class BridgeInboxCoordinator {
             return 'retry';
         return 'invalid';
     }
+    #historical(binding, operation) {
+        if (!this.#sourceEventSequence || !operation.eventId)
+            return false;
+        const sequence = this.#sourceEventSequence(operation.eventId);
+        if (sequence === null)
+            return false;
+        const current = binding.baseline?.sourceSequence
+            ?? (binding.baseline?.current?.eventId
+                ? this.#sourceEventSequence(binding.baseline.current.eventId) : null);
+        // An upgrade may expose a pre-existing durable event before any versioned snapshot. It must
+        // progress without publishing an unproven old status or waiting for a snapshot behind itself.
+        // An explicit equal watermark with a different current identity also proves native state has
+        // superseded that Hook. Matching identities must still deliver their real terminal notification.
+        return current == null || sequence < current
+            || (binding.baseline?.sourceSequence === sequence
+                && binding.baseline.result.availability !== 'unavailable'
+                && (!binding.baseline.current || (binding.baseline.current.eventId !== undefined
+                    && binding.baseline.current.eventId !== operation.eventId)));
+    }
+    async #submitHistory(binding, operation) {
+        if (operation.kind !== 'set' || (operation.state !== 'done' && operation.state !== 'error')
+            || !operation.eventId)
+            return { accepted: true };
+        return this.#projector.submitTerminalReplay({
+            run: binding.lease.ref,
+            source: operation.source,
+            state: operation.state,
+            eventId: operation.eventId,
+            historyOnly: true,
+            ...(operation.message === undefined ? {} : { message: operation.message }),
+            ...(operation.reason === undefined ? {} : { reason: operation.reason }),
+            ...(operation.correlationId === undefined ? {} : { correlationId: operation.correlationId }),
+            ...(operation.sourceOccurredAt === undefined ? {} : { sourceOccurredAt: operation.sourceOccurredAt }),
+        });
+    }
     #enqueue(binding, operation) {
         const pending = binding.tail.then(operation);
         binding.tail = pending.catch(() => { });
         return pending;
     }
     #restore(result) {
-        const pending = this.#restoreTail.then(() => this.#projector.restore(result()).then(() => undefined));
+        const pending = this.#restoreTail.then(async () => this.#projector.restore(await result()).then(() => undefined));
         this.#restoreTail = pending.catch(() => { });
         return pending;
     }
     #restoreBindings() {
-        return this.#restore(() => {
+        return this.#restore(async () => {
             const bindings = [...this.#bindings.values()].filter((binding) => binding.phase !== 'closed');
             const available = bindings.filter((binding) => (binding.baselineReady && binding.baseline?.result.availability !== 'unavailable'));
             const pending = bindings.filter((binding) => !binding.baselineReady || !binding.baseline);
@@ -309,6 +354,19 @@ export class BridgeInboxCoordinator {
                 };
             }
             const baselines = available.map((binding) => binding.baseline);
+            // A partial restore preserves omitted runs. Claude's explicit versioned empty snapshot proves
+            // this particular pane is clear even when a different pane or its historical spool is degraded.
+            if (this.#sourceEventSequence)
+                for (const binding of available) {
+                    const baseline = binding.baseline;
+                    if (baseline.sourceSequence === undefined || baseline.current || !baseline.cursor)
+                        continue;
+                    const cleared = await binding.projector.submit({ kind: 'clear', source: {
+                            sourceId: this.#sourceId, cursor: baseline.cursor,
+                        } });
+                    if (!cleared.accepted)
+                        throw new PiInboxBridgeError(`${this.#label} Inbox empty snapshot could not be persisted`);
+                }
             const degraded = baselines.find((baseline) => baseline.result.availability === 'degraded');
             return {
                 availability: degraded || pending.length || unavailable.length ? 'degraded' : 'ready',
@@ -341,7 +399,8 @@ export class BridgeInboxCoordinator {
             throw new PiInboxBridgeError(`${this.#label} Inbox Bridge returned an invalid live event`);
         if (isControlOperation(operation))
             return;
-        const result = await binding.projector.submit(operation);
+        const result = this.#historical(binding, operation)
+            ? await this.#submitHistory(binding, operation) : await binding.projector.submit(operation);
         if (!result.accepted) {
             throw new PiInboxBridgeError(`${this.#label} Inbox live operation rejected: ${result.reason ?? 'unknown'}`);
         }

package/dist/src/agents/processIdentity.js

@@ -6,20 +6,27 @@ const FAILURE_TTL_MS = 3_000;
 // Real executable path of a pid. lsof resolves launch symlinks on macOS; /proc is the cheap Linux path.
 // A transient lsof failure is inconclusive, not a negative identity verdict that should escape the call.
 export async function executablePath(run, pid) {
+    if (process.platform === 'linux') {
+        try {
+            return await fsp.readlink(`/proc/${pid}/exe`);
+        }
+        catch { /* fall back to lsof */ }
+    }
     let out = '';
     try {
         out = await run('lsof', ['-a', '-p', String(pid), '-d', 'txt', '-Fn']);
     }
-    catch { /* try /proc */ }
+    catch { /* unavailable or timed out */ }
     for (const line of String(out).split('\n'))
         if (line[0] === 'n')
             return line.slice(1).trim();
-    try {
-        return await fsp.readlink(`/proc/${pid}/exe`);
-    }
-    catch {
-        return '';
+    if (process.platform !== 'linux') {
+        try {
+            return await fsp.readlink(`/proc/${pid}/exe`);
+        }
+        catch { /* unavailable */ }
     }
+    return '';
 }
 function parseForegroundProcesses(out) {
     const rows = [];

package/dist/src/apiAccountProviders.js

@@ -14,6 +14,7 @@ export class ProviderQueryError extends Error {
     }
 }
 const DECIMAL = /^\d{1,128}(?:\.\d{1,128})?$/;
+const SIGNED_DECIMAL = /^-?\d{1,128}(?:\.\d{1,128})?$/;
 const MAX_RESPONSE_BYTES = 64 * 1024;
 const MAX_MOONSHOT_BALANCE = 1_000_000_000_000_000;
 function isRecord(value) {
@@ -52,8 +53,8 @@ async function boundedResponseText(response) {
     }
     return new TextDecoder().decode(bytes);
 }
-function decimalString(value) {
-    return typeof value === 'string' && DECIMAL.test(value);
+function decimalString(value, allowNegative = false) {
+    return typeof value === 'string' && (allowNegative ? SIGNED_DECIMAL : DECIMAL).test(value);
 }
 function boundedAmount(value, allowNegative = false) {
     return typeof value === 'number' && Number.isFinite(value) && Math.abs(value) <= MAX_MOONSHOT_BALANCE
@@ -69,7 +70,7 @@ function parseDeepSeekBalance(value) {
             || !hasExactKeys(candidate, ['currency', 'total_balance', 'topped_up_balance', 'granted_balance'])
             || typeof candidate.currency !== 'string'
             || candidate.currency.length < 1 || candidate.currency.length > 32
-            || !decimalString(candidate.total_balance)
+            || !decimalString(candidate.total_balance, true)
             || !decimalString(candidate.topped_up_balance)
             || !decimalString(candidate.granted_balance)) {
             throw new ProviderQueryError('unsupported_response');
@@ -160,7 +161,7 @@ function validDeepSeekResult(value) {
         && value.balances.every((balance) => isRecord(balance)
             && hasExactKeys(balance, ['currency', 'totalBalance', 'toppedUpBalance', 'grantedBalance'])
             && typeof balance.currency === 'string' && balance.currency.length >= 1 && balance.currency.length <= 32
-            && decimalString(balance.totalBalance) && decimalString(balance.toppedUpBalance)
+            && decimalString(balance.totalBalance, true) && decimalString(balance.toppedUpBalance)
             && decimalString(balance.grantedBalance));
 }
 function validMoonshotResult(value) {

package/dist/src/browser/bootstrap.js

@@ -18,6 +18,11 @@ export function createBrowserBootstrapStore({ randomToken = () => randomBytes(24
                 tickets.delete(token);
     };
     return {
+        revokeDevice(deviceId) {
+            for (const [token, entry] of tickets)
+                if (entry.deviceId === deviceId)
+                    tickets.delete(token);
+        },
         issue({ url, origin, deviceId, preserveMethod = false, redirectStatus = 302, }) {
             prune();
             const expectedOrigin = normalizedOrigin(origin);