handmux 0.27.2 → 0.29.1

package/dist/public/index.html

@@ -48,8 +48,8 @@
       @keyframes bootDot { 0%,100% { opacity: .22; transform: translateY(0); } 40% { opacity: 1; transform: translateY(-3px); } }
       @media (prefers-reduced-motion: reduce) { .boot-glow, .boot-dots i { animation: none; opacity: .8; } }
     </style>
-    <script type="module" crossorigin src="/assets/index-B4pKf3IW.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-Cdrh2CUp.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-Cdrh2CUp.css"></noscript>
+    <script type="module" crossorigin src="/assets/index-aBgNeovq.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BjnnFTLC.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-BjnnFTLC.css"></noscript>
   </head>
   <body>
     <div id="boot-splash" aria-hidden="true">

package/dist/src/agent-runtime/bridge.js

@@ -83,6 +83,9 @@ function channelKey(agentId, runId, name) {
 function consumerKey(agentId, name) {
     return `${agentId}\0${name}`;
 }
+// Retention sweep cadence. Reclaims are also attempted at construction (a restart is when the largest
+// dead set is present), so this only bounds growth during a long-lived server.
+const RECLAIM_INTERVAL_MS = 5 * 60_000;
 function mergeLimits(overrides) {
     const limits = { ...DEFAULT_BRIDGE_LIMITS, ...overrides };
     for (const [name, value] of Object.entries(limits)) {
@@ -198,9 +201,11 @@ export class LocalAgentBridge {
     #newRequestId;
     #now;
     #retryDelayMs;
+    #onReclaim;
     #writeTail = Promise.resolve();
+    #reclaimTimer;
     #closed = false;
-    constructor({ runs, adapterIds, store = new MemoryBridgeStateStore(), limits, newConnectionId = randomUUID, newRequestId = randomUUID, now = Date.now, retryDelayMs = 250, }) {
+    constructor({ runs, adapterIds, store = new MemoryBridgeStateStore(), limits, newConnectionId = randomUUID, newRequestId = randomUUID, now = Date.now, retryDelayMs = 250, onReclaim, }) {
         if (!runs || !Array.isArray(adapterIds) || adapterIds.length === 0) {
             throw new TypeError('LocalAgentBridge requires a run registry and static adapter ids');
         }
@@ -216,6 +221,7 @@ export class LocalAgentBridge {
         this.#newRequestId = newRequestId;
         this.#now = now;
         this.#retryDelayMs = Math.max(1, retryDelayMs);
+        this.#onReclaim = onReclaim;
         const persisted = parsePersistedState(this.#store.load());
         const spoolBytes = new Map();
         for (const channel of persisted.channels) {
@@ -244,9 +250,15 @@ export class LocalAgentBridge {
                 pumping: false,
                 pumpAgain: false,
                 retryTimer: undefined,
+                touchedAt: this.#now(),
                 durableWaiters: [],
             });
         }
+        // A restart is the natural point to drop channels whose runs died before it: nothing can attach to
+        // that run again, so their undelivered events are unreachable either way.
+        this.reclaimChannels();
+        this.#reclaimTimer = setInterval(() => this.reclaimChannels(), RECLAIM_INTERVAL_MS);
+        this.#reclaimTimer.unref?.();
     }
     connect(run) {
         this.#assertLive(run);
@@ -359,6 +371,10 @@ export class LocalAgentBridge {
         if (this.#closed)
             return;
         this.#closed = true;
+        if (this.#reclaimTimer) {
+            clearInterval(this.#reclaimTimer);
+            this.#reclaimTimer = undefined;
+        }
         for (const connection of this.#connections.values())
             connection.close();
         this.#connections.clear();
@@ -418,10 +434,12 @@ export class LocalAgentBridge {
                 pumping: false,
                 pumpAgain: false,
                 retryTimer: undefined,
+                touchedAt: this.#now(),
                 durableWaiters: [],
             };
             this.#channels.set(key, state);
         }
+        state.touchedAt = this.#now();
         return state;
     }
     async #withWrite(operation) {
@@ -442,6 +460,50 @@ export class LocalAgentBridge {
             channels: [...this.#channels.values()].map((state) => structuredClone(state.persisted)),
         });
     }
+    // Drops channels that can never be consumed again, so a reconnecting or flapping attachment cannot grow
+    // the bridge state without bound. A channel of a live run is never touched — it may reconnect and its
+    // undelivered events are still reachable. Returns what was dropped so a caller can log it.
+    reclaimChannels() {
+        const now = this.#now();
+        const dead = (state) => !state.subscription
+            && state.durableWaiters.length === 0 && state.live.length === 0
+            // The registry contract returns null for a run it no longer holds; treat any falsy result the same
+            // so a registry that omits the value cannot silently disable retention.
+            && !this.#runs.resolve(state.persisted.run);
+        let channels = 0;
+        let droppedEvents = 0;
+        const drop = (key, state) => {
+            if (state.retryTimer)
+                clearTimeout(state.retryTimer);
+            droppedEvents += state.persisted.durable.length;
+            this.#channels.delete(key);
+            channels += 1;
+        };
+        for (const [key, state] of [...this.#channels]) {
+            if (!dead(state))
+                continue;
+            // Drained ⇒ nothing can be lost. Still holding events ⇒ wait out the retention window first, so a
+            // transient gap in run bookkeeping cannot drop a notification that is still deliverable.
+            if (state.persisted.durable.length > 0 && now - state.touchedAt < this.limits.channelRetentionMs)
+                continue;
+            drop(key, state);
+        }
+        // Hard ceiling: retention must bound memory even while every dead channel is inside its window.
+        if (this.#channels.size > this.limits.maxChannels) {
+            const oldest = [...this.#channels].filter(([, state]) => dead(state))
+                .sort((left, right) => left[1].touchedAt - right[1].touchedAt);
+            for (const [key, state] of oldest) {
+                if (this.#channels.size <= this.limits.maxChannels)
+                    break;
+                drop(key, state);
+            }
+        }
+        if (channels > 0) {
+            this.#save();
+            this.#onReclaim?.({ channels, droppedEvents });
+        }
+        return { channels, droppedEvents };
+    }
     #nextSequence(state) {
         if (state.persisted.highWatermark >= Number.MAX_SAFE_INTEGER) {
             throw new BridgeContractError('Bridge channel sequence is exhausted');

package/dist/src/agent-runtime/bridgeTransport.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import net from 'node:net';
 import path from 'node:path';
 import { DEFAULT_BRIDGE_LIMITS } from './bridgeTypes.js';
+import { AgentRunError } from './run.js';
 const PROTOCOL_VERSION = 1;
 const NAME_RE = /^[a-z][a-z0-9._-]{0,63}$/;
 const MAX_HANDSHAKE_BYTES = 64 * 1024;
@@ -46,8 +47,6 @@ function wirePeer(socket, maxBytes, onMessage) {
             socket.write(encoded);
         },
         close() {
-            if (peer.closed)
-                return;
             peer.closed = true;
             socket.destroy();
         },
@@ -251,12 +250,28 @@ export class LocalAgentBridgeTransportServer {
         const peer = wirePeer(socket, MAX_HANDSHAKE_BYTES, (value) => {
             const operation = session.tail.then(() => this.#message(session, nonce, value));
             session.tail = operation.catch((error) => {
+                if (!session.ready) {
+                    if (!session.authenticated || peer.closed) {
+                        this.#closeSession(session);
+                        return;
+                    }
+                    // Flush the rejection before closing so old clients still observe EOF and new clients get
+                    // the actual cause. Only a validated, authenticated hello may receive diagnostics.
+                    try {
+                        peer.send({ type: 'handshake-error', error: errorMessage(error),
+                            ...(error instanceof AgentRunError ? { code: error.code } : {}) });
+                        peer.closed = true;
+                        peer.socket.end(() => this.#closeSession(session));
+                    }
+                    catch {
+                        this.#closeSession(session);
+                    }
+                    return;
+                }
                 try {
                     failure(peer, record(value)?.id, error);
                 }
                 catch { /* closing */ }
-                if (!session.connection)
-                    this.#closeSession(session);
             });
         });
         const handshakeTimer = setTimeout(() => this.#closeSession(session), this.#handshakeTimeoutMs);
@@ -270,6 +285,8 @@ export class LocalAgentBridgeTransportServer {
         peer.send({ type: 'challenge', protocolVersion: PROTOCOL_VERSION, nonce });
     }
     async #message(session, nonce, raw) {
+        if (session.peer.closed)
+            return;
         const value = record(raw);
         if (!value || typeof value.type !== 'string')
             throw new Error('Invalid Bridge transport frame');
@@ -285,6 +302,7 @@ export class LocalAgentBridgeTransportServer {
                 || (!replacing && value.generationId !== undefined)) {
                 throw new Error('Invalid Bridge transport generation');
             }
+            session.authenticated = true;
             const lease = await this.#authorize(value.adapterId, structuredClone(value.candidate), replacing ? { id: value.generationId, replace: true } : undefined);
             if (lease.ref.agentId !== value.adapterId)
                 throw new Error('Bridge transport authorization mismatch');
@@ -302,6 +320,7 @@ export class LocalAgentBridgeTransportServer {
                 clearTimeout(session.handshakeTimer);
             session.handshakeTimer = undefined;
             session.peer.maxBytes = Math.max(session.connection.limits.maxFrameBytes, session.connection.limits.maxSnapshotBytes) + WIRE_OVERHEAD_BYTES;
+            session.ready = true;
             session.peer.send({
                 type: 'ready', protocolVersion: PROTOCOL_VERSION,
                 connectionId: session.connection.connectionId,
@@ -483,6 +502,14 @@ export async function connectBridgeTransport({ socketPath, authToken, adapterId,
                 });
                 return;
             }
+            if (value.type === 'handshake-error' && !settled) {
+                const error = new Error(bounded(value.error, 4096) ? value.error : 'Bridge handshake rejected');
+                if (bounded(value.code, 128))
+                    Object.assign(error, { code: value.code });
+                finish({ error });
+                peer.close();
+                return;
+            }
             if (value.type === 'ready') {
                 finish({ value });
                 return;

package/dist/src/agent-runtime/bridgeTypes.js

@@ -10,4 +10,6 @@ export const DEFAULT_BRIDGE_LIMITS = Object.freeze({
     maxRequestTimeoutMs: 5 * 60_000,
     sustainedEventsPerSecond: 200,
     burstEvents: 500,
+    maxChannels: 2_000,
+    channelRetentionMs: 24 * 60 * 60_000,
 });

package/dist/src/agent-runtime/builtinRuntime.js

@@ -20,13 +20,16 @@ import { AgentRuntime, } from './runtime.js';
 export function createClaudeConversationActivityReader(events) {
     return {
         async read(run) {
-            const kind = events?.paneKind?.(run.ref.paneId) ?? null;
+            if (events?.paneSession && events.paneSession(run.ref.paneId)?.sessionId !== run.ref.sessionId) {
+                return { activity: 'unknown', activeTurn: { state: 'unknown' } };
+            }
+            const kind = events?.paneKind?.(run.ref.paneId, run.process) ?? null;
             const activity = kind === 'working' ? 'working'
                 : kind === 'permission' ? 'waiting'
                     : kind === 'compacting' ? 'compacting'
                         : kind === 'done' || kind === 'idle' || kind === 'end' || kind === 'error'
                             ? 'idle' : 'unknown';
-            const completionToken = events?.paneCompletionToken?.(run.ref.paneId) ?? null;
+            const completionToken = events?.paneCompletionToken?.(run.ref.paneId, run.process) ?? null;
             return {
                 activity,
                 activeTurn: activity === 'idle' ? { state: 'none' }
@@ -89,6 +92,11 @@ export function createBuiltinAgentRuntime({ home, claudeEvents, claudeProjectsRo
                 agentId: 'claude',
                 sourceId: 'claude.hooks',
                 label: 'Claude',
+                sourceEventSequence: (eventId) => {
+                    const match = /^claude-hook-([1-9]\d*)$/.exec(eventId);
+                    const sequence = match ? Number(match[1]) : NaN;
+                    return Number.isSafeInteger(sequence) ? sequence : null;
+                },
             });
             const conversationSessions = claudeEvents && typeof claudeEvents.paneSession === 'function'
                 ? claudeEvents

package/dist/src/agent-runtime/conversation.js

@@ -100,7 +100,7 @@ function normalizeInterrupt(raw) {
 }
 const PUBLIC_REASONS = new Set([
     'invalid_request', 'unsupported', 'stale_run', 'conflict',
-    'provider_rejected', 'temporarily_unavailable', 'delivery_unconfirmed',
+    'provider_rejected', 'terminal_draft_conflict', 'temporarily_unavailable', 'delivery_unconfirmed',
 ]);
 const LEGACY_REASON_MAP = Object.freeze({
     stale_lease: 'stale_run',
@@ -1648,7 +1648,7 @@ export class ConversationService {
                         delete detached.steerAnchor;
                         delete detached.steerDispatchPlan;
                         if (receipt.outcome === 'rejected')
-                            detached.autoDispatchBlockedReason = 'provider_rejected';
+                            detached.autoDispatchBlockedReason = receipt.reason === 'terminal_draft_conflict' ? 'terminal_draft_conflict' : 'provider_rejected';
                         else
                             delete detached.autoDispatchBlockedReason;
                         detached.revision = ++this.#state.ledgerRevision;
@@ -1755,7 +1755,7 @@ export class ConversationService {
                 current.state = 'queued';
                 delete current.dispatchOrigin;
                 if (receipt.outcome === 'rejected') {
-                    current.autoDispatchBlockedReason = 'provider_rejected';
+                    current.autoDispatchBlockedReason = receipt.reason === 'terminal_draft_conflict' ? 'terminal_draft_conflict' : 'provider_rejected';
                 }
                 else
                     delete current.autoDispatchBlockedReason;

package/dist/src/agent-runtime/conversationStore.js

@@ -32,7 +32,7 @@ function validBaseline(value) {
 }
 const SEND_STATUSES = new Set(['accepted', 'queued', 'rejected', 'unknown']);
 const SEND_REASONS = new Set([
-    'invalid_request', 'unsupported', 'stale_run', 'conflict', 'provider_rejected',
+    'invalid_request', 'unsupported', 'stale_run', 'conflict', 'provider_rejected', 'terminal_draft_conflict',
     'temporarily_unavailable', 'delivery_unconfirmed',
 ]);
 function validLegacyReceipt(value) {
@@ -120,7 +120,7 @@ export function parseConversationState(value) {
             throw new Error('Corrupt Conversation queue order');
         }
         if (row.autoDispatchBlockedReason !== undefined
-            && row.autoDispatchBlockedReason !== 'provider_rejected') {
+            && row.autoDispatchBlockedReason !== 'provider_rejected' && row.autoDispatchBlockedReason !== 'terminal_draft_conflict') {
             throw new Error('Corrupt Conversation dispatch barrier');
         }
         if (row.autoDispatchBlockedReason !== undefined && state !== 'queued') {

package/dist/src/agent-runtime/inbox.js

@@ -834,7 +834,9 @@ export class InboxService {
     async #submitTerminalReplay(agentId, replay) {
         const receivedAt = this.#now();
         if (!isRecord(replay) || !validRunRef(replay.run) || replay.run.agentId !== agentId
-            || this.#runs.status(replay.run) !== 'revoked'
+            || typeof replay.eventId !== 'string' || !EVENT_ID_RE.test(replay.eventId)
+            || (replay.historyOnly !== undefined && typeof replay.historyOnly !== 'boolean')
+            || this.#runs.status(replay.run) !== (replay.historyOnly ? 'current' : 'revoked')
             || (replay.state !== 'done' && replay.state !== 'error')) {
             return this.#result(receivedAt, false, { reason: 'invalid_operation' });
         }
@@ -852,7 +854,12 @@ export class InboxService {
             return this.#result(receivedAt, false, { reason: 'invalid_operation' });
         }
         const operation = normalized.operation;
+        const currentLease = replay.historyOnly ? this.#runs.resolve(replay.run) : undefined;
         return this.#withWrite(async () => {
+            if (replay.historyOnly && (!currentLease || currentLease.signal.aborted
+                || this.#runs.resolve(replay.run) !== currentLease)) {
+                return this.#result(receivedAt, false, { reason: 'stale_lease' });
+            }
             const before = structuredClone(this.#state);
             const run = this.#ensureRun(replay.run);
             const sourceDuplicate = this.#sourceReceipt(run, operation.source);
@@ -906,7 +913,12 @@ export class InboxService {
             }
             try {
                 const inboxSequence = this.#nextSequence(run);
-                const acceptedAt = receivedAt;
+                const historicalEvents = replay.historyOnly ? this.#crossRunEventReceipts(replay.run, operation.eventId) : [];
+                if (historicalEvents.some((receipt) => receipt.operationHash !== normalized.hash)) {
+                    throw new InboxContractError('Historical terminal event payload changed');
+                }
+                const acceptedAt = historicalEvents.length
+                    ? Math.min(...historicalEvents.map((receipt) => receipt.acceptedAt)) : receivedAt;
                 run.events.push({
                     eventId: operation.eventId,
                     operationHash: normalized.hash,
@@ -919,6 +931,12 @@ export class InboxService {
                     acceptedAt,
                     ...(operation.eventId === undefined ? {} : { eventId: operation.eventId }),
                 });
+                if (replay.historyOnly || historicalEvents.length) {
+                    this.#pruneExpired(receivedAt);
+                    this.#save();
+                    this.#revision += 1;
+                    return this.#result(receivedAt, true, { inboxSequence, acceptedAt });
+                }
                 const terminal = this.#terminalNotification(replay.run, {
                     state: operation.state,
                     ...(operation.eventId === undefined ? {} : { eventId: operation.eventId }),

package/dist/src/agent-runtime/run.js

@@ -159,12 +159,13 @@ export class AgentRunRuntime {
     }
     async #verify(verify, candidate) {
         let accepted = false;
+        let timedOut = false;
         let timer;
         try {
             accepted = await Promise.race([
                 Promise.resolve(verify(candidate)).then(Boolean, () => false),
                 new Promise((resolve) => {
-                    timer = setTimeout(() => resolve(false), this.#verifyTimeoutMs);
+                    timer = setTimeout(() => { timedOut = true; resolve(false); }, this.#verifyTimeoutMs);
                 }),
             ]);
         }
@@ -173,6 +174,9 @@ export class AgentRunRuntime {
             if (timer)
                 clearTimeout(timer);
         }
+        if (timedOut) {
+            throw new AgentRunError('attachment-verification-timeout', `Agent process verification timed out after ${this.#verifyTimeoutMs} ms; check slow process queries and retry`);
+        }
         if (!accepted) {
             throw new AgentRunError('attachment-unverified', 'Agent attachment no longer matches the live process');
         }

package/dist/src/agent-runtime/runtime.js

@@ -219,6 +219,7 @@ export class AgentRuntime {
                 runs: this.runs,
                 adapterIds,
                 store: new FileBridgeStateStore(bridgeStateFile),
+                onReclaim: (result) => logger.info('Reclaimed Bridge channels for Agent runs that are no longer live', result),
                 ...(newBridgeConnectionId === undefined ? {} : { newConnectionId: newBridgeConnectionId }),
             }),
         });

package/dist/src/agent-runtime/tmuxRuntime.js

@@ -1,3 +1,4 @@
+import { promises as fsp } from 'node:fs';
 import { executablePath } from '../agents/processIdentity.js';
 import { defaultRun, etimeToMs, normTty } from '../agents/scanUtils.js';
 function pane(value) {
@@ -124,6 +125,30 @@ function foregroundLeaf(rows, tty, paneCommand) {
         .sort((first, second) => second.elapsedMs - first.elapsedMs
         || depth(first) - depth(second) || second.pid - first.pid)[0] ?? null;
 }
+// Process start time, in a form that only depends on the process itself.
+//
+// `ps -o lstart` is a wall-clock derivation (boot time + start ticks). A host that steps the guest clock
+// (WSL2 syncs from Hyper-V, moving the guest forward every few tens of seconds) therefore makes the same
+// live process report a *different* start time after every step, which every identity comparison reads as
+// "the process was replaced". Linux exposes the raw start tick instead, and macOS does not step its clock
+// this way, so it keeps lstart. The Hook records the same value per platform — keep the two in step
+// (server/hooks/handmux-notify.sh).
+// Exported so the platform split can be unit-tested; callers use inspectForeground.
+export async function processStartedAt(run, pid) {
+    if (process.platform === 'linux') {
+        try {
+            const stat = await fsp.readFile(`/proc/${pid}/stat`, 'utf8');
+            // comm may contain spaces and parentheses: start from the last ')' to reach field 3 (state).
+            const fields = stat.slice(stat.lastIndexOf(')') + 2).trim().split(/\s+/);
+            const startTicks = Number(fields[19]); // field 22 of /proc/<pid>/stat
+            if (Number.isSafeInteger(startTicks) && startTicks >= 0)
+                return startTicks;
+        }
+        catch { /* fall back to the portable lstart read */ }
+    }
+    const parsed = Date.parse(String(await run('ps', ['-p', String(pid), '-o', 'lstart='])).trim());
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
 export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
     return {
         async inspectForeground(pane) {
@@ -137,12 +162,11 @@ export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
             const row = foregroundLeaf(foregroundRows(output), tty, pane.currentCommand);
             if (!row)
                 return null;
-            const rawStartedAt = String(await run('ps', ['-p', String(row.pid), '-o', 'lstart='])).trim();
-            const parsedStartedAt = Date.parse(rawStartedAt);
+            const startedAt = await processStartedAt(run, row.pid);
             const executable = await executablePath(run, row.pid);
             return {
                 pid: row.pid,
-                ...(Number.isFinite(parsedStartedAt) ? { startedAt: parsedStartedAt } : {}),
+                ...(startedAt === undefined ? {} : { startedAt }),
                 tty: pane.tty ?? `/dev/${tty}`,
                 ...(executable ? { executable } : {}),
                 ...(row.command ? { commandLine: row.command } : {}),

package/dist/src/agents/claudeConversation.js

@@ -79,8 +79,9 @@ export async function findClaudeSessionFile(root, sessionId) {
     }
     return matches[0] ?? null;
 }
-function sourceViewId(sessionId) {
-    return `claude-session:${sessionId}`;
+function sourceViewId(sessionId, reordered) {
+    const suffix = reordered.length ? `:${createHash('sha256').update(JSON.stringify(reordered)).digest('hex')}` : '';
+    return `claude-session:${sessionId}${suffix}`;
 }
 function sourceTime(value) {
     if (typeof value !== 'string')
@@ -167,11 +168,28 @@ function toolItems(message, sessionId, id, tool) {
     }
     return items;
 }
+// Read only the provider's human-facing scalar fields. This is not an XML document loader:
+// nested markup, output-file paths, internal IDs and external entities are never interpreted.
+function taskNotificationText(value) {
+    const entities = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+    const field = (name) => {
+        const text = new RegExp(`<${name}>([^<>]*)</${name}>`).exec(value)?.[1] ?? '';
+        return text.replace(/&(amp|lt|gt|quot|apos);/g, (_match, entity) => entities[entity])
+            .trim();
+    };
+    const summary = field('summary') || 'Background task update';
+    const details = [...new Set([field('status'), field('event')].filter(Boolean))];
+    return clipped(`${summary}${details.length ? ` (${details.join(', ')})` : ''}`, 4096).text;
+}
 function projectMessage(message, sessionId, ordinal) {
     const id = `claude:${message.i}:${ordinal}:${message.type}`;
     if (message.type === 'thinking')
         return [];
     if (message.type === 'text' && message.role && typeof message.text === 'string' && message.text) {
+        if (message.source === 'task-notification') {
+            return [{ ...itemBase(message, sessionId, id), kind: 'notice', level: 'info',
+                    code: 'background_task', message: taskNotificationText(message.text) }];
+        }
         return [textItem(message, sessionId, id, message.role, message.text)];
     }
     if (message.type === 'tool' && message.tool)
@@ -196,6 +214,11 @@ function projectMessage(message, sessionId, ordinal) {
     }
     if (message.type === 'slash') {
         const command = `${message.name ?? '/command'}${message.args ? ` ${message.args}` : ''}`;
+        // /compact starts as the user's submitted message. Keep that role when its canonical scaffold
+        // arrives so the canonical user occurrence replaces the local bubble; the result stays separate.
+        if (message.name?.toLowerCase() === '/compact') {
+            return [textItem(message, sessionId, id, 'user', command)];
+        }
         return [{
                 ...itemBase(message, sessionId, id), kind: 'notice', level: 'info',
                 code: 'slash_command', message: clipped(command, 4096).text,
@@ -203,8 +226,36 @@ function projectMessage(message, sessionId, ordinal) {
     }
     return [];
 }
+function normalizedOrder(messages) {
+    // Assign IDs in native append order, before normalizing display order. A late command must not
+    // rename a summary already shown to a client (or any of the following records).
+    const groups = messages.map((message, ordinal) => ({ message, ordinal }));
+    const reordered = [];
+    for (let index = 1; index < groups.length; index++) {
+        const current = groups[index];
+        const previous = groups[index - 1];
+        if (current.message.type !== 'slash' || current.message.name?.toLowerCase() !== '/compact'
+            || previous.message.type !== 'compact')
+            continue;
+        const commandTime = sourceTime(current.message.ts);
+        const summaryTime = sourceTime(previous.message.ts);
+        if (commandTime === undefined || summaryTime === undefined || commandTime >= summaryTime)
+            continue;
+        // Claude may append the command scaffold after its summary, retaining the earlier command time.
+        // Only this adjacent, proven inversion is normalized; ordinary history is never time-sorted.
+        groups[index - 1] = current;
+        groups[index] = previous;
+        reordered.push(`claude:${current.message.i}:${current.ordinal}:${current.message.type}`);
+        index++;
+    }
+    return { groups, reordered };
+}
 function project(messages, sessionId) {
-    return messages.flatMap((message, ordinal) => projectMessage(message, sessionId, ordinal));
+    const { groups, reordered } = normalizedOrder(messages);
+    return {
+        items: groups.flatMap(({ message, ordinal }) => projectMessage(message, sessionId, ordinal)),
+        viewId: sourceViewId(sessionId, reordered),
+    };
 }
 export function createClaudeConversationAdapter({ projectsRoot = projectsDir(), sessions = null, reader = transcriptReader, findSessionFile = findClaudeSessionFile, control, livePollMs = 750, } = {}) {
     if (!path.isAbsolute(projectsRoot)) {
@@ -242,7 +293,7 @@ export function createClaudeConversationAdapter({ projectsRoot = projectsDir(),
     async function readPage(session, request) {
         const file = await fileForSession(session.sessionId);
         const parsed = file ? await reader.read(file, createTranscriptParser) : [];
-        const all = project(parsed, session.sessionId);
+        const { items: all, viewId } = project(parsed, session.sessionId);
         let end = all.length;
         if (request.beforeSourceCursor !== undefined) {
             if (!/^\d+$/.test(request.beforeSourceCursor))
@@ -255,7 +306,7 @@ export function createClaudeConversationAdapter({ projectsRoot = projectsDir(),
         const start = Math.max(0, end - request.limit);
         return {
             sessionId: session.sessionId,
-            sourceViewId: sourceViewId(session.sessionId),
+            sourceViewId: viewId,
             sourceHistoryToken: createHash('sha256').update(JSON.stringify(all)).digest('hex'),
             items: all.slice(start, end),
             ...(start > 0 ? { previousSourceCursor: String(start) } : {}),
@@ -271,10 +322,13 @@ export function createClaudeConversationAdapter({ projectsRoot = projectsDir(),
             if (!file)
                 return null;
             boundFiles.set(target.sessionId, file);
+            // Discovery needs only the order epoch, not a second projection/hash of every tool result.
+            const parsed = await reader.read(file, createTranscriptParser);
+            const viewId = sourceViewId(target.sessionId, normalizedOrder(parsed).reordered);
             return {
                 session: { agentId: 'claude', sessionId: target.sessionId },
                 ...(isRun(target) ? { run: target } : {}),
-                sourceViewId: sourceViewId(target.sessionId),
+                sourceViewId: viewId,
                 capabilities: isRun(target) && control ? {
                     history: true, live: 'settled', sendable: true, send: ['prompt'], interrupt: true,
                 } : { history: true, live: 'poll' },
@@ -307,6 +361,12 @@ export function createClaudeConversationAdapter({ projectsRoot = projectsDir(),
                             if (closed || run.signal.aborted)
                                 return;
                             const next = await readPage(session, { limit: 1 });
+                            if (next.sourceViewId !== baseline.sourceViewId) {
+                                close();
+                                await sink({ type: 'stream.gap', sourceSequence: ++sourceSequence,
+                                    afterSourceSequence: sourceSequence - 1 });
+                                return;
+                            }
                             if (next.sourceHistoryToken !== historyToken) {
                                 historyToken = next.sourceHistoryToken;
                                 await sink({
@@ -345,6 +405,9 @@ export function createClaudeConversationAdapter({ projectsRoot = projectsDir(),
                         : control.sendPrompt(run.ref.paneId, request.text));
                     if (result && typeof result === 'object'
                         && result.nativeMutation === false) {
+                        if (result.reason === 'terminal_draft_conflict') {
+                            return { outcome: 'rejected', nativeMutation: false, reason: 'terminal_draft_conflict' };
+                        }
                         return { outcome: 'busy', nativeMutation: false };
                     }
                     return { outcome: 'accepted' };

package/dist/src/agents/claudeLocalCommand.js

@@ -0,0 +1,54 @@
+import path from 'node:path';
+import { isSessionUuid } from './scanUtils.js';
+const METADATA = new Set(['last-prompt', 'ai-title', 'mode', 'permission-mode', 'file-history-snapshot']);
+const record = (value) => (value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null);
+// undefined: no native evidence newer than the Hook. null: newer history is not a proven completion.
+// Keeping those separate prevents falling back from a native completion token to an older Hook token
+// while another user turn is being appended, which would look like an additional completion to Core.
+export function claudeLocalCommandCompletion(payload, after, now, rows) {
+    const sessionId = payload.session_id;
+    const file = payload.transcript_path;
+    if (!isSessionUuid(sessionId) || typeof file !== 'string'
+        || path.basename(file) !== `${sessionId}.jsonl`)
+        return undefined;
+    const native = [];
+    for (let index = rows.length - 1; index >= 0 && native.length < 2; index--) {
+        const item = rows[index];
+        if (!item)
+            return null;
+        if (typeof item.type === 'string' && METADATA.has(item.type))
+            continue;
+        const timestamp = typeof item.timestamp === 'string' ? Date.parse(item.timestamp) : NaN;
+        if (!Number.isFinite(timestamp))
+            return null;
+        if (timestamp <= after && !native.length)
+            return undefined;
+        if (timestamp > now)
+            return null;
+        native.unshift(item);
+    }
+    if (!native.length)
+        return undefined;
+    if (native.length !== 2)
+        return null;
+    const [command, output] = native;
+    for (const item of native) {
+        if (item.type !== 'user' || item.sessionId !== sessionId || item.isMeta === true
+            || item.isCompactSummary === true || item.isSidechain === true || !isSessionUuid(item.uuid)
+            || record(item.message)?.role !== 'user')
+            return null;
+    }
+    const commandText = record(command.message)?.content;
+    const outputText = record(output.message)?.content;
+    if (typeof commandText !== 'string' || typeof outputText !== 'string'
+        || !/^\s*<command-name>\/[a-z][\w-]*<\/command-name>(?:\s*<command-message>[^<>]*<\/command-message>)?(?:\s*<command-args>[^<>]*<\/command-args>)?\s*$/i.test(commandText)
+        || !/^\s*<local-command-stdout>[\s\S]+<\/local-command-stdout>\s*$/.test(outputText)
+        || output.parentUuid !== command.uuid
+        || Date.parse(String(output.timestamp)) < Date.parse(String(command.timestamp)))
+        return null;
+    if (Date.parse(String(command.timestamp)) <= after) {
+        // PostCompact already supplies the completion edge before /compact's stdout is appended.
+        return /^\s*<command-name>\/compact<\/command-name>/i.test(commandText) ? undefined : null;
+    }
+    return `claude-local-command:${sessionId}:${output.uuid}`;
+}