handmux 0.29.2 → 0.31.0

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

@@ -3,6 +3,8 @@ import { createClaudeConversationAdapter } from '../agents/claudeConversation.js
 import { createClaudeInteractionAdapter } from '../agents/claudeInteraction.js';
 import { NativeInboxCoordinator } from '../agents/nativeInbox.js';
 import { createCodexNativeInboxSource, } from '../agents/nativeInboxSources.js';
+import { createCodeBuddyConversationAdapter } from '../agents/codebuddyConversation.js';
+import { createCodeBuddyInteractionAdapter } from '../agents/codebuddyInteraction.js';
 import { createCodexConversationAdapter } from '../agents/codexConversation.js';
 import { createCodexInteractionAdapter } from '../agents/codexInteraction.js';
 import { createPiConversationActivityReader, createPiConversationAdapter, } from '../agents/piConversation.js';
@@ -16,6 +18,7 @@ import { createCodexConversationActivationController } from '../agents/codexConv
 import { createClaudeSubscriptionUsageAdapter } from '../agents/claudeSubscriptionUsage.js';
 import { createCodexSubscriptionUsageAdapter } from '../agents/codexSubscriptionUsage.js';
 import { BridgeInboxCoordinator, PiInboxBridgeCoordinator, } from '../agents/piInboxBridge.js';
+import { hookEventSequence } from '../agents/hookEvents.js';
 import { AgentRuntime, } from './runtime.js';
 export function createClaudeConversationActivityReader(events) {
     return {
@@ -40,6 +43,29 @@ export function createClaudeConversationActivityReader(events) {
         },
     };
 }
+// The same table Claude's reader uses, from CodeBuddy's own classification: the wave the 对话 lens draws
+// and the roster row come from one source, so they cannot disagree about what the pane is doing.
+export function createCodebuddyConversationActivityReader(events) {
+    return {
+        async read(run) {
+            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';
+            return {
+                activity,
+                activeTurn: activity === 'idle' ? { state: 'none' }
+                    : activity === 'unknown' ? { state: 'unknown' }
+                        : { state: 'active', nativeTurnId: `codebuddy-run:${run.ref.runId}` },
+            };
+        },
+    };
+}
 export function createCodexConversationActivityReader(app) {
     return {
         async read(run) {
@@ -80,7 +106,7 @@ export function createCodexConversationActivityReader(app) {
 }
 // Built-in wiring is deliberately static and product-owned. This is not a plugin loader: Agent identity
 // still comes only from BUILTIN_AGENT_ADAPTERS, while factories close over local provider clients/Bridge.
-export function createBuiltinAgentRuntime({ home, claudeEvents, claudeProjectsRoot, claudeConversationControl, claudeInteractionControl, codexApp, codexClear, codexActivationCommands, codexActivationReceipts, codexSessionsRoot, piSessionsRoot, ...runtimeOptions }) {
+export function createBuiltinAgentRuntime({ home, codebuddyEvents, codebuddyConversationControl, codebuddyInteractionControl, claudeEvents, claudeProjectsRoot, claudeConversationControl, claudeInteractionControl, codexApp, codexClear, codexActivationCommands, codexActivationReceipts, codexSessionsRoot, piSessionsRoot, ...runtimeOptions }) {
     const factories = {
         claude: (context) => {
             const subscriptionUsage = createClaudeSubscriptionUsageAdapter({
@@ -92,11 +118,9 @@ 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;
-                },
+                // The Hook spool's event ID carries its durable source sequence; the interpreter is the SHARED one
+                // because CodeBuddy's spool is written by the same script with the same ID shape.
+                sourceEventSequence: hookEventSequence,
             });
             const conversationSessions = claudeEvents && typeof claudeEvents.paneSession === 'function'
                 ? claudeEvents
@@ -146,6 +170,43 @@ export function createBuiltinAgentRuntime({ home, claudeEvents, claudeProjectsRo
                 onBridgeConnected: (lease) => inbox.bind(lease).then(() => undefined),
             };
         },
+        // CodeBuddy is Claude's twin on this path: the same file Hooks, the same shared writer, the same Bridge
+        // durable lane, so it reuses the same coordinator. There is deliberately no native/legacy source — the
+        // Connector publishes both the neutral pane baseline and every lifecycle edge, and the ordered projector
+        // is the only authority for CodeBuddy state from day one.
+        codebuddy: (context) => {
+            const inbox = new BridgeInboxCoordinator({
+                host: context.bridge,
+                projector: context.inbox,
+                agentId: 'codebuddy',
+                sourceId: 'codebuddy.hooks',
+                label: 'CodeBuddy',
+                sourceEventSequence: hookEventSequence,
+            });
+            const conversationSessions = codebuddyEvents && typeof codebuddyEvents.paneSession === 'function'
+                ? codebuddyEvents
+                : undefined;
+            return {
+                inbox: true,
+                conversation: createCodeBuddyConversationAdapter({
+                    ...(conversationSessions === undefined ? {} : { sessions: conversationSessions }),
+                    ...(codebuddyConversationControl === undefined ? {} : { control: codebuddyConversationControl }),
+                }),
+                conversationActivity: createCodebuddyConversationActivityReader(codebuddyEvents),
+                ...(codebuddyInteractionControl === undefined ? {} : {
+                    interaction: createCodeBuddyInteractionAdapter(codebuddyInteractionControl, 750, (availability, message) => context.health.report({
+                        capability: 'interaction', availability,
+                        ...(message ? { message } : {}),
+                        ...(availability === 'ready' ? { lastSuccessAt: Date.now() } : {}),
+                    })),
+                }),
+                start: () => {
+                    inbox.start();
+                    return () => inbox.close();
+                },
+                onBridgeConnected: (lease) => inbox.bind(lease).then(() => undefined),
+            };
+        },
         codex: (context) => {
             const resolvedCodexSessionsRoot = codexSessionsRoot ?? codexSessionsDir(home);
             const subscriptionUsage = createCodexSubscriptionUsageAdapter({

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

@@ -179,6 +179,8 @@ function capabilities(raw) {
         return null;
     if (raw.steer !== undefined && raw.steer !== true)
         return null;
+    if (raw.promptWhileActive !== undefined && raw.promptWhileActive !== true)
+        return null;
     if (raw.branching !== undefined && raw.branching !== true)
         return null;
     return {
@@ -186,6 +188,7 @@ function capabilities(raw) {
         live: raw.live,
         ...(raw.sendable === true ? { sendable: true } : {}),
         ...(raw.steer === true ? { steer: true } : {}),
+        ...(raw.promptWhileActive === true ? { promptWhileActive: true } : {}),
         ...(raw.send === undefined ? {} : {
             send: [...raw.send],
         }),
@@ -579,6 +582,9 @@ export class ConversationService {
             };
         }
         const activity = await this.#activitySource.read(run);
+        // Probed before the transaction: whether this provider's own input takes a prompt while a turn runs is
+        // a provider capability (the descriptor), while the decision below is state.
+        const promptWhileActive = await this.#promptWhileActive(adapter, run);
         const begin = await this.#withWrite(() => {
             const existing = this.#submission(session.agentId, session.sessionId, request.clientRequestId);
             if (existing) {
@@ -602,8 +608,15 @@ export class ConversationService {
             }
             const hasQueue = this.#state.submissions.some((item) => item.agentId === session.agentId
                 && item.sessionId === session.sessionId && item.state === 'queued');
-            const direct = activity.activity === 'idle' && activity.activeTurn.state === 'none'
-                && cycle.state === 'closed' && !hasQueue;
+            // A provider whose TUI queues the text natively can be written to WHILE its turn runs, so a phone
+            // send does not have to wait for idle — the user's message joins the turn in progress, exactly as if
+            // they had typed it in the terminal. Only a running turn qualifies: a permission gate, a compaction
+            // or an unknown state is not an input the pane will take (see ConversationCapabilities).
+            const inTurn = promptWhileActive && !hasQueue
+                && activity.activity === 'working' && activity.activeTurn.state === 'active'
+                && cycle.state !== 'closed';
+            const direct = inTurn || (activity.activity === 'idle' && activity.activeTurn.state === 'none'
+                && cycle.state === 'closed' && !hasQueue);
             const revision = ++this.#state.ledgerRevision;
             const submission = {
                 agentId: session.agentId, sessionId: session.sessionId,
@@ -616,7 +629,9 @@ export class ConversationService {
                 ...this.#currentBaseline(session.agentId, session.sessionId),
             };
             this.#state.submissions.push(submission);
-            if (direct)
+            // An in-turn send joins a turn that is ALREADY claimed: claiming (or reopening) the cycle here would
+            // tell the Core a new turn started, and the running turn's completion would then never be observed.
+            if (direct && !inTurn)
                 this.#claimCycle(cycle, submission, activity);
             try {
                 this.#save();
@@ -628,7 +643,7 @@ export class ConversationService {
                     } };
             }
             return direct
-                ? { kind: 'dispatch', id: submission.clientRequestId }
+                ? { kind: 'dispatch', id: submission.clientRequestId, inTurn }
                 : { kind: 'receipt', value: this.#submitReceipt(submission) };
         });
         if (begin.kind === 'receipt') {
@@ -636,7 +651,7 @@ export class ConversationService {
                 this.#wake(owner);
             return begin.value;
         }
-        return this.#dispatchClaim(run, begin.id, 'direct');
+        return this.#dispatchClaim(run, begin.id, 'direct', undefined, begin.inTurn);
     }
     async queueSnapshot(run) {
         this.#requireRun(run);
@@ -1487,7 +1502,11 @@ export class ConversationService {
         }
         this.#state.submissions = this.#state.submissions.filter((candidate) => candidate !== item);
     }
-    async #dispatchClaim(run, submissionId, origin, detached) {
+    async #dispatchClaim(run, submissionId, origin, detached, 
+    // This dispatch was admitted knowing a turn is running, because the provider's own input takes a prompt
+    // while it works (ConversationCapabilities.promptWhileActive). Only send() passes it: a queued delivery
+    // still waits for idle, and that is what keeps the queue's ordering promise intact.
+    promptWhileActive = false) {
         const runRef = copyRun(run.ref);
         if (!runRef.sessionId) {
             return { status: 'rejected', reason: 'invalid_request', nativeMutation: false };
@@ -1512,8 +1531,9 @@ export class ConversationService {
                     || preDispatchActivity.activeTurn.state !== 'none')))) {
             receipt = { outcome: 'rejected', nativeMutation: false, reason: 'conflict' };
         }
-        else if (origin !== 'steer' && (preDispatchActivity.activity !== 'idle'
+        else if (!promptWhileActive && origin !== 'steer' && (preDispatchActivity.activity !== 'idle'
             || preDispatchActivity.activeTurn.state !== 'none')) {
+            // A busy provider that has NOT declared in-turn input gets the message queued, never written to.
             receipt = { outcome: 'busy', nativeMutation: false };
         }
         else
@@ -1538,8 +1558,12 @@ export class ConversationService {
                             return !run.signal.aborted && this.#runs.resolve(runRef) === run
                                 && current.epoch === preDispatchActivity.epoch
                                 && current.revision === preDispatchActivity.revision
-                                && current.activity === 'idle'
-                                && current.activeTurn.state === 'none';
+                                // Every dispatch requires the world it was decided in. The idle path additionally requires
+                                // the pane to STILL be idle; the in-turn path was decided knowing a turn is running, so it
+                                // requires only that nothing has moved — if it has, the adapter writes nothing and the
+                                // message falls back to the queue.
+                                && (promptWhileActive
+                                    || (current.activity === 'idle' && current.activeTurn.state === 'none'));
                         },
                     });
                 if (!operation)
@@ -2102,6 +2126,22 @@ export class ConversationService {
         if (changed)
             this.#wake(owner);
     }
+    // Provider capability: does its own input accept a prompt while a turn is running? Read from the
+    // descriptor, the same place every other provider capability comes from, and never fatal — an
+    // unavailable or mismatched probe simply means "no", leaving the ordinary queue path in charge.
+    async #promptWhileActive(adapter, run) {
+        try {
+            const raw = await adapter.discoverNative(run.ref);
+            if (raw === null)
+                return false;
+            const descriptor = this.#descriptor(raw, run.ref.agentId);
+            return descriptor.session.sessionId === run.ref.sessionId
+                && descriptor.capabilities.promptWhileActive === true;
+        }
+        catch {
+            return false;
+        }
+    }
     #wake(owner) {
         const state = this.#dispatchers.get(owner) ?? { running: false, wakePending: false, timer: undefined };
         this.#dispatchers.set(owner, state);

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

@@ -343,17 +343,16 @@ export class InteractionService {
                     }
                 }
                 for (const item of baseline) {
-                    let record = this.#recordBySource(run.ref, item.id);
+                    let record = this.#pendingRecordBySource(run.ref, item.id);
                     if (!record) {
                         record = this.#createRecord(run.ref, item);
                         this.#state.interactions.push(record);
                     }
-                    else if (record.state === 'pending') {
+                    else {
                         record.pending = item;
                         record.updatedAt = this.#now();
                     }
-                    if (record.state === 'pending')
-                        state.pendingBySource.set(item.id, record);
+                    state.pendingBySource.set(item.id, record);
                 }
                 this.#save();
             });
@@ -496,8 +495,14 @@ export class InteractionService {
     #recordsFor(run) {
         return this.#state.interactions.filter((record) => (record.agentId === run.agentId && record.run.runId === run.runId));
     }
-    #recordBySource(run, sourceId) {
-        return this.#recordsFor(run).find((record) => record.sourceInteractionId === sourceId);
+    // A native id names the SHAPE of the gate its adapter reads off the screen (see hookInteraction), so the
+    // same id legitimately comes back for a new occurrence: every AskUserQuestion review screen parses to
+    // "Ready to submit your answers?" with the same two options. Only a still-pending record IS that item —
+    // a resolved one belongs to an occurrence that is over, and re-publishing must mint a new public identity
+    // for the new one instead of silently dropping it (a dropped re-appearance left the phone with no card at
+    // all while the pane sat on the review screen).
+    #pendingRecordBySource(run, sourceId) {
+        return this.#recordsFor(run).find((record) => (record.sourceInteractionId === sourceId && record.state === 'pending'));
     }
     #accept(state, event) {
         if (state.phase === 'closed')
@@ -567,10 +572,7 @@ export class InteractionService {
             const item = pending(event.interaction);
             if (!item)
                 throw new InteractionContractError('Interaction opened payload is invalid');
-            let record = this.#recordBySource(state.run.ref, item.id);
-            if (record && record.state !== 'pending') {
-                throw new InteractionContractError('Resolved native interaction id was reused');
-            }
+            let record = this.#pendingRecordBySource(state.run.ref, item.id);
             await this.#withWrite(() => {
                 if (!record) {
                     record = this.#createRecord(state.run.ref, item);
@@ -596,8 +598,16 @@ export class InteractionService {
             throw new InteractionContractError('Interaction terminal payload is invalid');
         }
         const record = state.pendingBySource.get(event.interactionId);
-        if (!record)
+        if (!record) {
+            // A dispatched answer already retired this item, so the adapter reporting that the gate left the screen
+            // is the same fact arriving a second time — and an adapter only stops reporting it once its next poll
+            // sees a different screen. Failing the observation closed here killed every later card with it: the
+            // phone was left with no card while the pane sat on the next gate (the review screen after a question).
+            const settled = this.#recordsFor(state.run.ref).some((candidate) => (candidate.sourceInteractionId === event.interactionId && candidate.state !== 'pending'));
+            if (settled)
+                return;
             throw new InteractionContractError('Interaction terminal event targets unknown pending item');
+        }
         await this.#withWrite(() => {
             record.state = 'resolved';
             record.receipt = event.type === 'resolved'
@@ -658,7 +668,11 @@ export class InteractionService {
             });
             if (!finalized || !live || !live.exposed || live.phase === 'closed')
                 return;
-            live.pendingBySource.delete(record.sourceInteractionId);
+            // The index is keyed by native id, and a new occurrence of the same gate may already have taken that
+            // key over — only retire the entry this response actually answered.
+            if (live.pendingBySource.get(record.sourceInteractionId) === record) {
+                live.pendingBySource.delete(record.sourceInteractionId);
+            }
             if (result.status === 'accepted' || result.status === 'already_resolved') {
                 await this.#emit(live, {
                     type: 'resolved', revision: ++live.revision, interactionId: record.publicInteractionId,

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

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 const DEFAULT_MAX_BUFFERED_EVENTS = 256;
 const DEFAULT_IDLE_GRACE_MS = 5_000;
 export class InteractionLiveHubError extends Error {
@@ -128,6 +129,7 @@ export class InteractionLiveHub {
     #create(run) {
         const shared = {
             run,
+            epoch: randomUUID(),
             ready: Promise.resolve(),
             subscribers: new Set(),
             idleTimer: undefined,
@@ -144,6 +146,7 @@ export class InteractionLiveHub {
             }
             shared.handle = handle;
             shared.checkpoint = {
+                epoch: shared.epoch,
                 revision: handle.revision,
                 pending: structuredClone(handle.pending),
             };
@@ -181,6 +184,7 @@ export class InteractionLiveHub {
             throw new InteractionLiveHubError('unavailable', 'Interaction terminal event is invalid');
         }
         shared.checkpoint = {
+            epoch: shared.epoch,
             revision: event.revision,
             pending: [...pending.values()],
         };

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

@@ -542,16 +542,30 @@ export class AgentRuntime {
             .sort((first, second) => first.paneId.localeCompare(second.paneId)
             || first.agentId.localeCompare(second.agentId));
     }
+    // Per-pane process evidence for a single identity decision. Both probes are lazily memoized so a decision
+    // that only needs one of them costs one `ps` read, and every evidence method the host offers must be
+    // forwarded here or adapters silently lose it.
+    #processContext(pane) {
+        const source = this.#process;
+        let inspected;
+        let group;
+        return {
+            inspectForeground: () => {
+                inspected ??= source.inspectForeground(pane);
+                return inspected;
+            },
+            ...(source.inspectForegroundGroup === undefined ? {} : {
+                inspectForegroundGroup: () => {
+                    group ??= source.inspectForegroundGroup(pane);
+                    return group;
+                },
+            }),
+        };
+    }
     async identifyPanes(panes) {
         const activeAdapters = this.adapters.filter((adapter) => (!this.#lifecycles.get(adapter.id)?.abort.signal.aborted));
         const resolved = await Promise.all(panes.map(async (pane) => {
-            let inspected;
-            const context = {
-                inspectForeground: () => {
-                    inspected ??= this.#process.inspectForeground(pane);
-                    return inspected;
-                },
-            };
+            const context = this.#processContext(pane);
             const identity = await resolveAgentIdentity(pane, activeAdapters, context, {
                 verifyTimeoutMs: this.#verifyTimeoutMs,
             });
@@ -905,16 +919,63 @@ export class AgentRuntime {
             return false;
         }
         const pane = panes.find((value) => value.paneId === candidate.paneId);
-        return pane ? (await this.#verifyAgainst(adapter, candidate, pane)) === 'valid' : false;
+        if (!pane)
+            return false;
+        if (await this.#anchorStillOwnsPane(candidate, pane))
+            return true;
+        return (await this.#verifyAgainst(adapter, candidate, pane)) === 'valid';
+    }
+    // The hook that produced this candidate already named the process that owns the pane (pid, start time and
+    // tty). While that exact generation is alive on the pane's own tty the pane cannot have changed under it, and
+    // re-deriving the identity by scanning the pane's foreground group is both slower and flakier: while the
+    // Agent runs a tool, the group's foreground owner is that tool, so the scan intermittently finds no Agent and
+    // the attachment is refused — which is what makes an Agent's row blink in and out of the roster, each
+    // refusal revoking the run and the next attempt creating a new one. Anything else — the pid gone, a
+    // different start time, a tty we cannot tie to this pane, no probe on this host, a probe that threw — falls
+    // through to the full verification, so this only ever skips work.
+    async #anchorStillOwnsPane(candidate, pane) {
+        const anchor = candidate.process;
+        const inspectProcess = this.#process.inspectProcess;
+        if (!inspectProcess || !anchor || anchor.startedAt === undefined)
+            return false;
+        try {
+            const alive = await inspectProcess(anchor.pid);
+            if (alive === null || alive.startedAt !== anchor.startedAt)
+                return false;
+            // A recycled pid on another pane is not this attachment.
+            const tty = alive.tty ?? anchor.tty;
+            return !!tty && !!pane.tty && tty === pane.tty;
+        }
+        catch {
+            return false;
+        }
+    }
+    // Steady-state recheck for a lease that already exists. The lease carries the process generation it was
+    // attached to — pid AND start time — and while that exact generation is alive the pane cannot have changed
+    // under it, so the full identity probe (a `ps -t` plus the lsof that resolves an executable, ~100ms for a
+    // Node pane) would only re-derive what the anchor already proves. Confirm the anchor with the one cheap
+    // probe instead. Anything else — the pid gone, a different start time, no probe on this host, a probe that
+    // threw — falls through to the full verification, so this can only ever skip work, never revoke on doubt.
+    async #verifyTracked(tracked, pane) {
+        const anchor = tracked.candidate.process;
+        const inspectProcess = this.#process.inspectProcess;
+        if (inspectProcess) {
+            try {
+                const alive = await inspectProcess(anchor.pid);
+                // Alive with the start time we anchored on — or alive with no start time to compare, which the hook
+                // sometimes cannot read: a live anchor is not doubt. Falling through to the full verification would
+                // scan the pane's foreground group, find the TOOL the Agent is running rather than the Agent, and
+                // revoke a run that is plainly still there.
+                if (alive !== null && (anchor.startedAt === undefined || alive.startedAt === anchor.startedAt)) {
+                    return 'valid';
+                }
+            }
+            catch { /* fall through to the full verification */ }
+        }
+        return this.#verifyAgainst(tracked.adapter, tracked.candidate, pane);
     }
     async #verifyAgainst(adapter, candidate, pane) {
-        let inspected;
-        const context = {
-            inspectForeground: () => {
-                inspected ??= this.#process.inspectForeground(pane);
-                return inspected;
-            },
-        };
+        const context = this.#processContext(pane);
         try {
             return await lifecycleWithin((async () => {
                 const identity = await resolveAgentIdentity(pane, this.adapters, context, {
@@ -924,7 +985,9 @@ export class AgentRuntime {
                     return 'unknown';
                 if (identity.kind !== 'matched' || identity.adapter.id !== adapter.id)
                     return 'invalid';
-                const foreground = await context.inspectForeground(pane);
+                // An adapter that names its own process anchors the lease on it. The foreground leaf is only the
+                // default, for the Agents that are themselves the pane's foreground process.
+                const foreground = identity.process ?? await context.inspectForeground(pane);
                 if (foreground === null)
                     return 'unknown';
                 // A partial best-effort probe cannot prove that the process generation changed. Preserve the
@@ -944,9 +1007,7 @@ export class AgentRuntime {
             if (tracked.lease.signal.aborted || this.runs.resolve(tracked.lease.ref) !== tracked.lease)
                 continue;
             const pane = panes.get(tracked.lease.ref.paneId);
-            const verdict = pane
-                ? await this.#verifyAgainst(tracked.adapter, tracked.candidate, pane)
-                : 'invalid';
+            const verdict = pane ? await this.#verifyTracked(tracked, pane) : 'invalid';
             if (verdict === 'invalid' && this.runs.resolve(tracked.lease.ref) === tracked.lease) {
                 await this.runs.revokePane(tracked.lease.ref.paneId, pane ? 'process_exit' : 'pane_detached');
             }
@@ -955,13 +1016,7 @@ export class AgentRuntime {
         for (const pane of panes.values()) {
             if (this.#closed || this.runs.currentForPane(pane.paneId))
                 continue;
-            let inspected;
-            const context = {
-                inspectForeground: () => {
-                    inspected ??= this.#process.inspectForeground(pane);
-                    return inspected;
-                },
-            };
+            const context = this.#processContext(pane);
             const identity = await resolveAgentIdentity(pane, activeAdapters, context, {
                 verifyTimeoutMs: this.#verifyTimeoutMs,
             });
@@ -971,7 +1026,8 @@ export class AgentRuntime {
             try {
                 // Exact command matches skip Adapter verification, so bound this probe at its own use site.
                 // A timed-out result must not attach later or block other panes and subsequent snapshots.
-                foreground = await lifecycleWithin(context.inspectForeground(pane), this.#verifyTimeoutMs, 'Agent process discovery');
+                // A verifier-named process was already resolved inside the verification budget.
+                foreground = identity.process ?? await lifecycleWithin(context.inspectForeground(pane), this.#verifyTimeoutMs, 'Agent process discovery');
             }
             catch {
                 continue;

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

@@ -150,16 +150,24 @@ export async function processStartedAt(run, pid) {
     return Number.isFinite(parsed) ? parsed : undefined;
 }
 export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
+    const PS_FORMAT = 'pid=,ppid=,stat=,etime=,tty=,command=';
+    // One `ps` read, shared by both evidence methods below. The full-system scan is only the fallback for a
+    // platform whose targeted query returns nothing; rows are always re-filtered to the pane's own tty.
+    const foregroundGroup = async (pane) => {
+        const tty = normTty(pane.tty);
+        if (!tty)
+            return { tty: '', rows: [] };
+        let output = await run('ps', ['-t', tty, '-o', PS_FORMAT]);
+        if (!String(output).trim())
+            output = await run('ps', ['-Ao', PS_FORMAT]);
+        return { tty, rows: foregroundRows(output).filter((row) => row.tty === tty) };
+    };
     return {
         async inspectForeground(pane) {
-            const tty = normTty(pane.tty);
+            const { tty, rows } = await foregroundGroup(pane);
             if (!tty)
                 return null;
-            let output = await run('ps', ['-t', tty, '-o', 'pid=,ppid=,stat=,etime=,tty=,command=']);
-            if (!String(output).trim()) {
-                output = await run('ps', ['-Ao', 'pid=,ppid=,stat=,etime=,tty=,command=']);
-            }
-            const row = foregroundLeaf(foregroundRows(output), tty, pane.currentCommand);
+            const row = foregroundLeaf(rows, tty, pane.currentCommand);
             if (!row)
                 return null;
             const startedAt = await processStartedAt(run, row.pid);
@@ -172,5 +180,27 @@ export function createLocalAgentProcessContext({ run = defaultRun, } = {}) {
                 ...(row.command ? { commandLine: row.command } : {}),
             };
         },
+        async inspectForegroundGroup(pane) {
+            const { rows } = await foregroundGroup(pane);
+            // Start time is resolved per row: a returned row can become a lease anchor, and a pid without a
+            // process generation is not an identity. Executable is deliberately NOT resolved — one lsof per row
+            // is expensive, and the adapters that need the group match on the command line.
+            return Promise.all(rows.map(async (row) => {
+                const startedAt = await processStartedAt(run, row.pid);
+                return {
+                    pid: row.pid,
+                    ppid: row.ppid,
+                    tty: pane.tty ?? `/dev/${row.tty}`,
+                    ...(startedAt === undefined ? {} : { startedAt }),
+                    ...(row.command ? { commandLine: row.command } : {}),
+                };
+            }));
+        },
+        // One `ps -p`, and deliberately no executable lookup: a lease only needs to know that the pid it was
+        // attached to is still the same process generation.
+        async inspectProcess(pid) {
+            const startedAt = await processStartedAt(run, pid);
+            return startedAt === undefined ? null : { pid, startedAt };
+        },
     };
 }

package/dist/src/agents/claude.js

@@ -13,6 +13,7 @@ import os from 'node:os';
 import { resolveEncodedDirSession, isSessionUuid } from './scanUtils.js';
 import { resolveByExecutable, executableBasename } from './processIdentity.js';
 import { createTranscriptParser, parseTranscript } from '../transcriptParse.js';
+import { hookErrorMessage } from './hookEvents.js';
 const record = (value) => (value !== null && typeof value === 'object' && !Array.isArray(value)
     ? value
     : null);
@@ -59,24 +60,6 @@ function permMsg(body) {
         return '需要你批准计划';
     return t ? `需要你授权：${t}` : '需要你';
 }
-// Friendly Chinese for the StopFailure error type (matcher values, see the hooks doc). The payload shape
-// isn't verified against a live rate-limit yet, so read the type defensively from several likely fields and
-// always fall back to a bare 本轮出错 — a wrong field name degrades to the generic label, never throws.
-const STOPFAIL_LABEL = {
-    rate_limit: '触发限流', overloaded: '服务过载', authentication_failed: '认证失败',
-    oauth_org_not_allowed: '组织未授权', billing_error: '额度/账单问题', invalid_request: '请求无效',
-    model_not_found: '模型不可用', server_error: '服务端错误', max_output_tokens: '输出超长', unknown: '未知错误',
-};
-function stopFailMsg(body) {
-    const error = record(body.error);
-    const type = text(body.error_type) || text(body.reason) || text(body.type)
-        || text(body.error) || text(error?.type);
-    const label = STOPFAIL_LABEL[type];
-    if (label)
-        return label;
-    const raw = text(body.error) || text(body.message);
-    return raw ? String(raw).replace(/\s+/g, ' ').trim().slice(0, 80) : '';
-}
 // Build the 进行中 one-liner for a resume (PostToolUse after the user answered/approved), surfacing the
 // choice they just made — AskUserQuestion stores it in tool_input.answers, keyed by question.
 function resumeMsg(body) {
@@ -136,7 +119,7 @@ export function classifyClaude(src, rawBody = {}) {
     if (src === 'compact')
         return null; // PostCompact: done → clear 压缩中/进行中
     if (src === 'stopfail')
-        return { kind: 'error', msg: stopFailMsg(body) }; // turn died on an API error
+        return { kind: 'error', msg: hookErrorMessage(body) }; // turn died on an API error
     if (src === 'end')
         return { kind: 'end' };
     if (src === 'start')