@scotthuang/agent-knock-knock 0.12.25 → 0.12.26

package/dist/src/terminal-list-cli-adapter.js

@@ -10,6 +10,7 @@ import { resolveSessionSelector, sessionShortRef } from "./session-selector.js";
 import { projectSessionSelectorCandidate } from "./terminal-selector-projection-service.js";
 import { listManagedSessions, loadNativeThreadTransition, nativeThreadTransitionsDir, tryLoadManagedSession } from "./session-store.js";
 import { defaultStoreDir, ensureStoreWritable, inspectStoreCompatibility, listConversations, storeManifestPath, STORE_SESSION_AUTHORITY_PROTOCOL } from "./store.js";
+import { parseTerminalConversationId } from "./terminal-agent-adapter.js";
 import { exactCodexReadyStyledComposerCapture } from "./terminal-agent-bridge.js";
 import { captureCodexHumanStartedActiveTaskAnchor } from "./terminal-submission-acceptance.js";
 import { applySessionAuthorityToDispatch, authoritativeTerminalIdentity, compareManagedConversationRecency, decideManagedTerminalAssociation, decideLocalTerminalDispatchOwnership, decideTerminalSendAuthority, decideTerminalSessionAuthorityConflict, decideTerminalUserExplicitSendAuthority, managedTurnNeedsAttention as terminalManagedTurnNeedsAttention, nonOwnerTerminalActions, projectBlockingTurn, projectHandoffDecision, projectHandoffPresentation, projectPublicManagementConflict, projectReconcileBindingAction, projectTerminalDispatchConflict, projectTerminalManagement, selectManagedTerminalHistory, selectTerminalAvailableActions } from "./terminal-action-projection.js";
@@ -262,6 +263,14 @@ async function observeExactTerminal(request) {
     const scan = await buildTerminalListGroup({ options, terminalId });
     const matches = scan.terminalControlled.filter((terminal) => stringValue(terminal.id) === terminalId);
     if (matches.length !== 1) {
+        const state = scan.summary.error ? "unavailable" : "absent";
+        runtimeLog("info", "terminal_exact_observation", {
+            terminal_id: terminalId,
+            state,
+            matching_terminal_count: matches.length,
+            observed_terminal_ids: scan.terminalControlled.map((terminal) => terminal.id),
+            scan_summary: scan.summary
+        });
         return scan.summary.error
             ? {
                 state: "unavailable",
@@ -279,12 +288,25 @@ async function observeExactTerminal(request) {
     });
     const projectedMatches = projected.terminals.filter((terminal) => stringValue(terminal.id) === terminalId);
     if (projectedMatches.length !== 1) {
+        runtimeLog("info", "terminal_exact_observation", {
+            terminal_id: terminalId,
+            state: "unavailable",
+            stage: "projection",
+            matching_terminal_count: projectedMatches.length,
+            scan_summary: scan.summary
+        });
         return {
             state: "unavailable",
             reason: "the exact terminal could not be projected authoritatively",
             summary: scan.summary
         };
     }
+    runtimeLog("info", "terminal_exact_observation", {
+        terminal_id: terminalId,
+        state: "available",
+        matching_terminal_count: 1,
+        scan_summary: scan.summary
+    });
     return {
         state: "available",
         rawTerminal: matches[0],
@@ -359,18 +381,74 @@ async function buildTerminalListGroup({ options, agentFilter, statusFilter, term
     const terminalDiagnostics = options.terminalDebug
         ? await terminalControlDiagnostics(terminalProvider)
         : undefined;
+    const exactTarget = terminalId
+        ? exactTerminalTargetDiagnostic(terminalId)
+        : undefined;
+    if (terminalId) {
+        runtimeLog("info", "terminal_exact_scan", {
+            stage: "started",
+            terminal_id: terminalId,
+            target: exactTarget
+        });
+    }
     const terminalControlled = [];
     let activeCount = 0;
     const errors = [];
     try {
         const processSource = terminalListRuntime().createTerminalProcessSource(options);
         const snapshots = await processSource.listProcessSnapshots((snapshot) => adapters.some((adapter) => adapter.capabilities.processDiscovery && adapter.classifyProcess(snapshot) !== undefined), { includeAncestors: true });
+        if (terminalId) {
+            const targetPid = exactTarget?.pid;
+            runtimeLog("info", "terminal_exact_scan", {
+                stage: "process_inventory",
+                terminal_id: terminalId,
+                target_pid: targetPid,
+                snapshot_count: snapshots.length,
+                target_process_found: targetPid === undefined
+                    ? undefined
+                    : snapshots.some((snapshot) => snapshot.pid === targetPid),
+                target_process_snapshots: targetPid === undefined
+                    ? []
+                    : snapshots
+                        .filter((snapshot) => snapshot.pid === targetPid)
+                        .map((snapshot) => ({ pid: snapshot.pid, ppid: snapshot.ppid }))
+            });
+        }
         const activeSessions = await bridge.listProcesses(snapshots, adapters.map((adapter) => adapter.agent));
-        const rootSessions = selectRootTerminalProcesses(activeSessions);
+        const rootSessions = selectRootTerminalProcesses(activeSessions, snapshots);
         const controlledSessions = rootSessions.filter((session) => session.terminalControl !== undefined);
+        if (terminalId) {
+            const targetPid = exactTarget?.pid;
+            const targetSessions = targetPid === undefined
+                ? []
+                : activeSessions.filter((session) => session.pid === targetPid);
+            runtimeLog("info", "terminal_exact_scan", {
+                stage: "process_classification_and_association",
+                terminal_id: terminalId,
+                target_pid: targetPid,
+                classified_process_count: activeSessions.length,
+                root_process_count: rootSessions.length,
+                controlled_process_count: controlledSessions.length,
+                target_classified_count: targetSessions.length,
+                target_controlled_count: targetSessions.filter((session) => session.terminalControl !== undefined).length,
+                target_sessions: targetSessions.map((session) => ({
+                    agent: session.agent,
+                    pid: session.pid,
+                    ppid: session.ppid,
+                    kind: session.kind,
+                    confidence: session.confidence,
+                    selected_as_root: rootSessions.includes(session),
+                    terminal_conversation_id: session.terminalControl
+                        ? bridge.terminalConversationId(session)
+                        : undefined,
+                    terminal_control: terminalControlScanDiagnostic(session.terminalControl)
+                }))
+            });
+        }
         activeCount = controlledSessions.length;
         const selectedSessions = terminalId
-            ? controlledSessions.filter((session) => bridge.terminalConversationId(session) === terminalId)
+            ? activeSessions.filter((session) => session.terminalControl !== undefined &&
+                bridge.terminalConversationId(session) === terminalId)
             : controlledSessions;
         for (const session of selectedSessions) {
             try {
@@ -385,6 +463,16 @@ async function buildTerminalListGroup({ options, agentFilter, statusFilter, term
     catch (error) {
         errors.push(error instanceof Error ? error.message : String(error));
     }
+    if (terminalId) {
+        runtimeLog("info", "terminal_exact_scan", {
+            stage: "complete",
+            terminal_id: terminalId,
+            controlled_process_count: activeCount,
+            terminal_row_count: terminalControlled.length,
+            terminal_row_ids: terminalControlled.map((terminal) => terminal.id),
+            errors
+        });
+    }
     return {
         terminalControlled,
         summary: {
@@ -398,6 +486,37 @@ async function buildTerminalListGroup({ options, agentFilter, statusFilter, term
         }
     };
 }
+function exactTerminalTargetDiagnostic(terminalId) {
+    try {
+        const parsed = parseTerminalConversationId(terminalId);
+        return parsed ? {
+            provider: parsed.kind,
+            agent: parsed.agent,
+            route: parsed.target,
+            pid: parsed.pid
+        } : undefined;
+    }
+    catch (error) {
+        return {
+            parse_error: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function terminalControlScanDiagnostic(terminalControl) {
+    if (!terminalControl) {
+        return undefined;
+    }
+    const control = terminalControl;
+    return {
+        kind: terminalControl.kind,
+        target: terminalControl.target,
+        pane_pid: control.panePid,
+        process_anchor_pid: control.processAnchorPid,
+        endpoint_key: control.endpointKey,
+        resource_key: control.resourceKey,
+        terminal_id: control.terminalId
+    };
+}
 async function terminalControlDiagnostics(provider) {
     return provider.diagnostics();
 }
@@ -459,7 +578,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             : { sessionId: session.sessionId }),
         terminalTarget: terminalControl.target
     });
-    const { orphanedDispatch, nativeIdentityObservation, nativeAgentIdentity, codexOpenRootRolloutInventory, nativeProcessUuid, nativeProcessBirth, nativeProcessEvidence } = await observeTerminalNativeListIdentity(session, terminalControl, options, bridge);
+    const { orphanedDispatch, nativeIdentityObservation, nativeAgentIdentity, authorityNativeIdentityObservation, authorityNativeAgentIdentity, codexOpenRootRolloutInventory, nativeProcessUuid, nativeProcessBirth, nativeProcessEvidence } = await observeTerminalNativeListIdentity(session, terminalControl, options, bridge);
     const effectiveTerminalState = effectiveTerminalListState({
         session,
         terminalState,
@@ -522,6 +641,17 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         processBirth: nativeProcessBirth,
         rollout: nativeAgentIdentity?.rollout
     });
+    const authorityLifecycleBindingToken = unmanagedTerminalBindingToken({
+        terminalId: bridge.terminalConversationId(session),
+        terminalControl,
+        agent: session.agent,
+        pid: session.pid,
+        workspace: session.cwd ?? terminalControl.currentPath ?? cliCwd(),
+        nativeThreadId: authorityNativeAgentIdentity?.sessionId,
+        processUuid: nativeProcessUuid,
+        processBirth: nativeProcessBirth,
+        rollout: authorityNativeAgentIdentity?.rollout
+    });
     const codexLifecycleIncarnationAvailable = session.agent !== "codex" ||
         Boolean(nativeProcessUuid && nativeProcessBirth);
     let terminalHasBlockingTurn = true;
@@ -605,6 +735,11 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
         // human native-thread switch.
         _automated_input_composer_ready: automatedInputComposerReady,
         _user_explicit_composer_ready: userExplicitComposerReady,
+        _native_identity_authority: {
+            observation: authorityNativeIdentityObservation,
+            identity: authorityNativeAgentIdentity,
+            lifecycle_binding_token: authorityLifecycleBindingToken
+        },
         ...(codexLatentClearResumeObservationValue
             ? {
                 _codex_latent_clear_resume: {
@@ -639,7 +774,7 @@ async function terminalControlledListEntry(session, activeSessions, options, bri
             terminalState: effectiveTerminalState,
             lifecycleCapability,
             nativeInspectionCapability,
-            nativeAgentIdentity,
+            nativeAgentIdentity: authorityNativeAgentIdentity,
             nativeProcessUuid,
             nativeProcessBirth,
             codexLifecycleIncarnationAvailable,
@@ -821,8 +956,9 @@ async function observeTerminalNativeListIdentity(session, terminalControl, optio
         }
         catch (error) {
             // Preserve generic discovery when Store hints are unavailable. Once an
-            // exact hint exists, however, the constrained resolver below must fail
-            // closed rather than retrying without its managed lineage fences.
+            // exact hint exists, the constrained resolver below still evaluates it;
+            // a separate complete root inventory may later describe the physical
+            // read-only identity without granting managed mutation authority.
             runtimeLog("warn", "terminal_managed_identity_context_unavailable", {
                 agent: session.agent,
                 terminal_target: terminalControl.target,
@@ -850,8 +986,9 @@ async function observeTerminalNativeListIdentity(session, terminalControl, optio
             reason: error instanceof Error ? error.message : String(error)
         };
     }
-    const nativeAgentIdentity = nativeIdentityObservation.status === "resolved"
-        ? nativeIdentityObservation.identity
+    const authorityNativeIdentityObservation = nativeIdentityObservation;
+    const authorityNativeAgentIdentity = authorityNativeIdentityObservation.status === "resolved"
+        ? authorityNativeIdentityObservation.identity
         : undefined;
     let codexOpenRootRolloutInventory;
     if (session.agent === "codex") {
@@ -874,6 +1011,29 @@ async function observeTerminalNativeListIdentity(session, terminalControl, optio
             });
         }
     }
+    if (session.agent === "codex" &&
+        nativeIdentityObservation.status === "unavailable" &&
+        codexOpenRootRolloutInventory?.status === "resolved" &&
+        codexOpenRootRolloutInventory.pid === session.pid) {
+        const constrainedReason = nativeIdentityObservation.reason;
+        const [identity] = codexOpenRootRolloutInventory.roots;
+        if (identity.processUuid === codexOpenRootRolloutInventory.processUuid &&
+            identity.processBirth === codexOpenRootRolloutInventory.processBirth) {
+            nativeIdentityObservation = {
+                status: "resolved",
+                identity
+            };
+            runtimeLog("info", "terminal_native_session_identity_resolved_from_unique_root_inventory", {
+                agent: session.agent,
+                terminal_target: terminalControl.target,
+                pid: session.pid,
+                preferred_session_id: codexIdentityContext?.preferredSessionId,
+                resolved_session_id: identity.sessionId,
+                constrained_error: constrainedReason,
+                inventory_fingerprint: codexOpenRootRolloutInventory.inventoryFingerprint
+            });
+        }
+    }
     if (nativeIdentityObservation.status === "unavailable") {
         runtimeLog("warn", "terminal_native_session_identity_unavailable", {
             agent: session.agent,
@@ -882,6 +1042,9 @@ async function observeTerminalNativeListIdentity(session, terminalControl, optio
             error: nativeIdentityObservation.reason
         });
     }
+    const nativeAgentIdentity = nativeIdentityObservation.status === "resolved"
+        ? nativeIdentityObservation.identity
+        : undefined;
     let nativeProcessUuid = nativeAgentIdentity?.processUuid;
     let nativeProcessBirth = nativeAgentIdentity?.processBirth;
     let nativeProcessEvidence = nativeAgentIdentity?.evidence;
@@ -911,6 +1074,8 @@ async function observeTerminalNativeListIdentity(session, terminalControl, optio
         orphanedDispatch,
         nativeIdentityObservation,
         nativeAgentIdentity,
+        authorityNativeIdentityObservation,
+        authorityNativeAgentIdentity,
         codexOpenRootRolloutInventory,
         nativeProcessUuid,
         nativeProcessBirth,
@@ -953,9 +1118,10 @@ async function observeAutomatedInputComposerReady({ session, terminalControl, te
         userExplicitComposerReady: userExplicitReady
     };
 }
-function observeTerminalListBindingAuthority(terminal, context) {
+function observeTerminalListBindingAuthority(listedTerminal, context) {
     const { storeDir, managedSessions, allConversations, displayedConversations, mutationsAllowed, nonterminalDeferredTransfers } = context;
-    const { _automated_input_composer_ready: automatedInputComposerReady, _user_explicit_composer_ready: _userExplicitComposerReady, _codex_open_root_rollout_inventory: codexOpenRootRolloutInventoryValue, _codex_latent_clear_resume: codexLatentClearResumeValue, _terminal_user_explicit_send_action: terminalUserExplicitSendAction, _terminal_status_snapshot: _terminalStatusSnapshot, ...publicTerminal } = terminal;
+    const { _automated_input_composer_ready: automatedInputComposerReady, _user_explicit_composer_ready: _userExplicitComposerReady, _codex_open_root_rollout_inventory: codexOpenRootRolloutInventoryValue, _codex_latent_clear_resume: codexLatentClearResumeValue, _terminal_user_explicit_send_action: terminalUserExplicitSendAction, _terminal_status_snapshot: _terminalStatusSnapshot, _native_identity_authority: nativeIdentityAuthorityValue, ...publicTerminal } = listedTerminal;
+    const terminal = terminalIdentityAuthorityView(listedTerminal, nativeIdentityAuthorityValue);
     const codexOpenRootRolloutInventory = isRecord(codexOpenRootRolloutInventoryValue)
         ? codexOpenRootRolloutInventoryValue
         : undefined;
@@ -1111,6 +1277,7 @@ function observeTerminalListBindingAuthority(terminal, context) {
         }
         : undefined;
     return {
+        authorityTerminal: terminal,
         automatedInputComposerReady,
         codexOpenRootRolloutInventory,
         codexLatentClearResumeValue,
@@ -1149,12 +1316,33 @@ function observeTerminalListBindingAuthority(terminal, context) {
         codexSendAuthorityContext
     };
 }
+function terminalIdentityAuthorityView(terminal, authorityValue) {
+    if (!isRecord(authorityValue)) {
+        return terminal;
+    }
+    const observation = isRecord(authorityValue.observation)
+        ? authorityValue.observation
+        : { status: "not_observed" };
+    const identity = isRecord(authorityValue.identity)
+        ? authorityValue.identity
+        : undefined;
+    return {
+        ...terminal,
+        native_agent_session_id: stringValue(identity?.sessionId),
+        native_agent_rollout: isRecord(identity?.rollout)
+            ? identity.rollout
+            : undefined,
+        native_agent_identity_observation: observation,
+        lifecycle_binding_token: stringValue(authorityValue.lifecycle_binding_token) ??
+            terminal.lifecycle_binding_token
+    };
+}
 function observeVerifiedEmptyTerminalAuthority(terminal, context, binding) {
     const { storeDir, terminals, mutationsAllowed } = context;
     const { automatedInputComposerReady, terminalControl, matchingSessions, unresolvedSessionClaims, discoveredOwnership, rawActions, soleBindingConflict, blockingHandoffTurns, terminalBlockingTurns, nativeIdentityObservation, codexProcessUuid, codexProcessBirth, codexWorkspace, codexSendAuthorityContext } = binding;
     const verifiedEmptySourceNativeThreadId = stringValue(soleBindingConflict?.session.binding?.native_thread_id)?.toLowerCase();
     const verifiedEmptySourceActiveElsewhere = Boolean(verifiedEmptySourceNativeThreadId &&
-        terminals.some((candidate) => candidate !== terminal &&
+        terminals.some((candidate) => stringValue(candidate.id) !== stringValue(terminal.id) &&
             candidate.agent === "codex" &&
             stringValue(candidate.native_agent_session_id)?.toLowerCase() ===
                 verifiedEmptySourceNativeThreadId));
@@ -1254,7 +1442,7 @@ function observeDeferredSourceAuthority(terminal, context, observation) {
         });
     }
     const deferredCodexSourceActiveElsewhere = Boolean(deferredCodexSourceNativeThreadId &&
-        terminals.some((candidate) => candidate !== terminal &&
+        terminals.some((candidate) => stringValue(candidate.id) !== stringValue(terminal.id) &&
             candidate.agent === "codex" &&
             stringValue(candidate.native_agent_session_id)?.toLowerCase() ===
                 deferredCodexSourceNativeThreadId));
@@ -1735,7 +1923,10 @@ function terminalFirstListProjection({ storeDir, terminals, managedSessions, ses
         nonterminalDeferredTransfers,
         conversationHasNonterminalDeferredTransfer
     };
-    const projectedTerminals = terminals.map((terminal) => renderTerminalFirstListEntry(terminal, projectionContext, observeTerminalListActionAuthority(terminal, projectionContext, observeTerminalListBindingAuthority(terminal, projectionContext))));
+    const projectedTerminals = terminals.map((terminal) => {
+        const binding = observeTerminalListBindingAuthority(terminal, projectionContext);
+        return renderTerminalFirstListEntry(binding.authorityTerminal, projectionContext, observeTerminalListActionAuthority(binding.authorityTerminal, projectionContext, binding));
+    });
     const unavailableManagedTurns = displayedConversations
         .filter((conversation) => {
         const managedControl = terminalControlForManagedConversation(conversation);