@scotthuang/agent-knock-knock 0.13.3 → 0.13.4

package/dist/src/native-thread-lifecycle-cli-adapter.js

@@ -12,7 +12,8 @@ import { isSessionSendBlockingStatus, turnIdForConversation } from "./protocol.j
 import { listManagedSessions, loadNativeThreadTransition } from "./session-store.js";
 import { isExactClaudeNativeInspectionIdleComposer, NativeInspectionSubmissionError } from "./terminal-agent-bridge.js";
 import { terminalControlAliasMatches, selectRootTerminalProcesses, withCodexCompanionFences } from "./terminal-authority-policy.js";
-import { isTerminalModelReasoningEffort, terminalUserExplicitModelControlBindingToken, terminalUserExplicitModelControlResidualEntryBindingToken, terminalUserExplicitModelControlRepairBindingToken } from "./terminal-model-control.js";
+import { decideModelControlAvailability } from "./terminal-model-control-availability.js";
+import { CODEX_MODEL_CONTROL_AGENT_VERSION, isTerminalModelControlPlanForAgent, isTerminalModelReasoningEffort, terminalModelControlPlanConforms, terminalModelControlProfileForPlan, terminalUserExplicitModelControlBindingToken } from "./terminal-model-control.js";
 import { nonBlankString } from "./value-guards.js";
 export const CODEX_FOREGROUND_IDENTIFICATION_TTL_MS = 30_000;
 export const CODEX_FOREGROUND_IDENTIFICATION_SCROLLBACK_LINES = 240;
@@ -238,11 +239,9 @@ class NativeThreadLifecycleCliApplication {
             return snapshot;
         }
         const adapter = this.agentAdapter(options, terminal.agent);
-        const capability = adapter.probeModelControl?.(snapshot.version);
-        const plan = capability?.status === "supported"
-            ? adapter.planModelControl?.(capability)
-            : undefined;
-        if (!plan || plan.behaviorProfile !== "codex-model-control-0.154.0") {
+        const { capability, plan, profile } = modelControlProfileObservation(adapter, snapshot.version);
+        if (!plan || profile?.agent !== "codex" ||
+            !profile.supportsZeroRolloutPhysicalAuthority) {
             throw new Error(capability?.reason ?? "Codex has no verified physical model-control profile");
         }
         const bindingToken = this.physicalModelControlBindingToken(terminal, snapshot.version, plan.behaviorProfile);
@@ -917,22 +916,21 @@ class NativeThreadLifecycleCliApplication {
             const terminal = await bridge.resolveStoredTerminal(initiallyResolved.agent, initiallyResolved.pid, initiallyResolved.terminalControl, { pid: initiallyResolved.pid });
             this.assertSameInspectionTerminal(initiallyResolved, terminal, "while waiting for model-control repair ownership");
             if (terminal.agent !== "codex") {
-                throw new Error("model-control residual repair currently supports only Codex 0.154.0");
+                throw new Error("model-control residual repair currently supports only Codex " +
+                    CODEX_MODEL_CONTROL_AGENT_VERSION);
             }
             const snapshot = await this.modelControlSnapshot(options, terminal);
             const agentVersion = required(nonBlankString(snapshot.version), "model-control repair requires an exact running agent version");
             const adapter = runtimeFacade.createAgentRegistry().require(terminal.agent);
-            const capability = adapter.probeModelControl?.(agentVersion);
-            const plan = capability?.status === "supported"
-                ? adapter.planModelControl?.(capability)
-                : undefined;
-            if (!plan || plan.behaviorProfile !== "codex-model-control-0.154.0") {
+            const { capability, plan, profile } = modelControlProfileObservation(adapter, agentVersion);
+            if (!plan || profile?.agent !== "codex" ||
+                !profile.supportsResidualRepair) {
                 throw new Error(capability?.reason ??
                     "the running Codex version has no verified model-control repair profile");
             }
             await this.assertModelControlExclusive({ options, terminal, snapshot });
             const runtime = this.inspectionRuntime(terminal, snapshot);
-            await this.assertModelControlRepairReady({
+            const status = await this.assertModelControlRepairReady({
                 options,
                 terminal,
                 snapshot,
@@ -943,13 +941,26 @@ class NativeThreadLifecycleCliApplication {
             if (residual.state !== "recoverable") {
                 throw new Error(residual.reason);
             }
-            const actualBindingToken = this.modelControlRepairBindingToken({
+            const availability = this.modelControlAvailability({
+                options,
                 terminal,
+                snapshot,
                 agentVersion,
                 plan,
-                residual
+                status,
+                surface: {
+                    kind: "residual",
+                    residualKind: residual.kind,
+                    residualFingerprint: residual.fingerprint,
+                    activityState: status.activity_state
+                }
             });
-            if (actualBindingToken !== expectedBindingToken) {
+            const repairBindingToken = availability.availability === "residual_continuation"
+                ? availability.repairBindingToken
+                : availability.availability === "repair_only"
+                    ? availability.expectedBindingToken
+                    : undefined;
+            if (repairBindingToken !== expectedBindingToken) {
                 throw new Error("the exact model-control residual changed after it was listed; refresh AKK list");
             }
             return await operation({
@@ -983,10 +994,7 @@ class NativeThreadLifecycleCliApplication {
         if (expectedNativeThreadId !== actualNativeThreadId) {
             throw new Error("the current native Session changed during model-control repair");
         }
-        const capability = context.adapter.probeModelControl?.(snapshot.version);
-        const plan = capability?.status === "supported"
-            ? context.adapter.planModelControl?.(capability)
-            : undefined;
+        const { plan } = modelControlProfileObservation(context.adapter, snapshot.version);
         if (!plan || JSON.stringify(plan) !== JSON.stringify(context.plan)) {
             throw new Error("the exact model-control repair profile changed during the operation");
         }
@@ -1028,35 +1036,43 @@ class NativeThreadLifecycleCliApplication {
         if (this.ports.state.orphanedForRecovery(input.terminal.terminalControl)) {
             throw new Error("the terminal has unresolved input ownership during model-control repair");
         }
+        return status;
     }
-    modelControlRepairBindingToken(input) {
-        const incarnation = this.ports.identity.physicalProcessIncarnation(input.terminal.pid);
-        return terminalUserExplicitModelControlRepairBindingToken({
-            terminalId: input.terminal.conversationId,
-            terminalControl: input.terminal.terminalControl,
-            pid: input.terminal.pid,
-            workspace: required(nonBlankString(input.terminal.terminalControl.currentPath), "model-control repair requires an exact terminal cwd"),
-            processUuid: incarnation.processUuid,
-            processBirth: incarnation.processBirth,
-            agentVersion: input.agentVersion,
-            behaviorProfile: input.plan.behaviorProfile,
-            residualKind: input.residual.kind,
-            residualFingerprint: input.residual.fingerprint
-        });
-    }
-    modelControlResidualEntryBindingToken(input) {
+    modelControlAvailability(input) {
+        const nativeThreadId = input.snapshot.identity?.sessionId ??
+            input.snapshot.session?.binding?.native_thread_id;
+        const zeroRolloutVerified = input.terminal.agent === "codex" &&
+            !input.snapshot.identity && !input.snapshot.session;
         const incarnation = this.ports.identity.physicalProcessIncarnation(input.terminal.pid);
-        return terminalUserExplicitModelControlResidualEntryBindingToken({
+        const storeDir = this.ports.state.storeDir(input.options);
+        return decideModelControlAvailability({
+            exactTerminalRow: true,
             terminalId: input.terminal.conversationId,
+            processState: "active",
             terminalControl: input.terminal.terminalControl,
+            agent: input.terminal.agent,
             pid: input.terminal.pid,
-            workspace: required(nonBlankString(input.terminal.terminalControl.currentPath), "model-control continuation requires an exact terminal cwd"),
             processUuid: incarnation.processUuid,
             processBirth: incarnation.processBirth,
             agentVersion: input.agentVersion,
             behaviorProfile: input.plan.behaviorProfile,
-            residualKind: input.residual.kind,
-            residualFingerprint: input.residual.fingerprint
+            nativeAuthority: isExactNativeThreadId(nativeThreadId)
+                ? {
+                    kind: "exact_session",
+                    ordinaryBindingToken: input.snapshot.bindingToken
+                }
+                : zeroRolloutVerified
+                    ? { kind: "verified_zero_rollout" }
+                    : { kind: "unavailable" },
+            modelControlSupported: true,
+            approvalScanned: input.status.approval_state.scanned === true,
+            approvalBlocked: input.status.approval_state.blocked === true,
+            terminalHasInteraction: input.status.interaction_state !== undefined,
+            terminalHasBlockingTurn: this.ports.state.terminalBlockingTurns(storeDir, input.terminal.terminalControl).length > 0,
+            hasOrphanedDispatch: this.ports.state.dispatchOwnership(input.terminal.terminalControl)
+                .state !== "none" ||
+                this.ports.state.orphanedForRecovery(input.terminal.terminalControl) !== undefined,
+            surface: input.surface
         });
     }
     async withPreparedModelControl(options, expectedBindingToken, operation, behavior = {}) {
@@ -1079,14 +1095,13 @@ class NativeThreadLifecycleCliApplication {
             }
             const agentVersion = required(nonBlankString(snapshot.version), "model control requires an exact running agent version");
             const adapter = runtimeFacade.createAgentRegistry().require(terminal.agent);
-            const capability = adapter.probeModelControl?.(agentVersion);
+            const { capability, plan } = modelControlProfileObservation(adapter, agentVersion);
             if (capability?.status !== "supported" ||
                 capability.modelSelection !== true ||
                 capability.reasoningEffortSelection !== true) {
                 throw new Error(capability?.reason ??
                     `${adapter.displayName} has no verified model-control profile`);
             }
-            const plan = adapter.planModelControl?.(capability);
             if (!plan) {
                 throw new Error("the agent adapter did not produce a model-control plan");
             }
@@ -1094,21 +1109,38 @@ class NativeThreadLifecycleCliApplication {
             let initialResidual;
             let runtime;
             if (hasOrdinaryAuthority) {
-                runtime = await this.assertInitialInspectionReady(options, terminal, snapshot, bridge);
-                const modelStatus = await bridge.status(terminal.agent, terminal.terminalControl, { runtime });
-                if (modelStatus.approval_state.scanned !== true ||
-                    modelStatus.approval_state.blocked === true ||
-                    modelStatus.interaction_state !== undefined) {
+                const ready = await this.observeInitialInspectionReady(options, terminal, snapshot, bridge);
+                runtime = ready.runtime;
+                if (ready.status.approval_state.scanned !== true ||
+                    ready.status.approval_state.blocked === true ||
+                    ready.status.interaction_state !== undefined) {
                     throw new Error("model control requires a freshly scanned terminal with no approval or questionnaire");
                 }
+                const availability = this.modelControlAvailability({
+                    options,
+                    terminal,
+                    snapshot,
+                    agentVersion,
+                    plan,
+                    status: ready.status,
+                    surface: {
+                        kind: "idle_empty",
+                        screenState: ready.status.screen_state
+                    }
+                });
+                if (availability.availability !== "open_from_empty" ||
+                    availability.expectedBindingToken !== ordinaryBindingToken) {
+                    throw new Error("model control requires an exact verified idle pane with an empty composer and no blocking interaction");
+                }
             }
             else {
                 if (terminal.agent !== "codex" ||
-                    plan.behaviorProfile !== "codex-model-control-0.154.0") {
+                    terminalModelControlProfileForPlan(plan)
+                        ?.supportsResidualContinuation !== true) {
                     throw new Error("terminal binding changed after it was listed; refresh AKK list and retry");
                 }
                 runtime = this.inspectionRuntime(terminal, snapshot);
-                await this.assertModelControlRepairReady({
+                const status = await this.assertModelControlRepairReady({
                     options,
                     terminal,
                     snapshot,
@@ -1119,13 +1151,22 @@ class NativeThreadLifecycleCliApplication {
                 if (observed.state !== "recoverable") {
                     throw new Error(observed.reason);
                 }
-                const residualEntryToken = this.modelControlResidualEntryBindingToken({
+                const availability = this.modelControlAvailability({
+                    options,
                     terminal,
+                    snapshot,
                     agentVersion,
                     plan,
-                    residual: observed
+                    status,
+                    surface: {
+                        kind: "residual",
+                        residualKind: observed.kind,
+                        residualFingerprint: observed.fingerprint,
+                        activityState: status.activity_state
+                    }
                 });
-                if (residualEntryToken !== expectedBindingToken) {
+                if (availability.availability !== "residual_continuation" ||
+                    availability.expectedBindingToken !== expectedBindingToken) {
                     throw new Error("the exact model-control residual changed after it was listed; refresh AKK list");
                 }
                 initialResidual = observed;
@@ -1143,9 +1184,9 @@ class NativeThreadLifecycleCliApplication {
                 ordinaryBindingToken,
                 initialResidual,
                 ...(terminal.agent === "codex" &&
-                    plan.behaviorProfile === "codex-model-control-0.154.0"
+                    isTerminalModelControlPlanForAgent(plan, "codex")
                     ? {
-                        loadCodexCatalog: async () => runtimeFacade.codexModelCatalogForRunningProcess(terminal.pid, "0.154.0", terminal.terminalControl.currentPath)
+                        loadCodexCatalog: async () => runtimeFacade.codexModelCatalogForRunningProcess(terminal.pid, CODEX_MODEL_CONTROL_AGENT_VERSION, terminal.terminalControl.currentPath)
                     }
                     : {})
             });
@@ -1169,10 +1210,7 @@ class NativeThreadLifecycleCliApplication {
         if (expectedNativeThreadId !== actualNativeThreadId) {
             throw new Error("the current native Session changed during model control; inspect the pane before retrying");
         }
-        const capability = context.adapter.probeModelControl?.(snapshot.version);
-        const plan = capability?.status === "supported"
-            ? context.adapter.planModelControl?.(capability)
-            : undefined;
+        const { plan } = modelControlProfileObservation(context.adapter, snapshot.version);
         if (!plan || JSON.stringify(plan) !== JSON.stringify(context.plan)) {
             throw new Error("the exact model-control profile changed during the operation");
         }
@@ -1198,7 +1236,11 @@ class NativeThreadLifecycleCliApplication {
         }
         catch (idleError) {
             if (context.terminal.agent !== "claude" ||
-                context.plan.behaviorProfile !== "claude-model-control-2.1.266" ||
+                !terminalModelControlPlanConforms({
+                    agent: context.terminal.agent,
+                    agentVersion: context.agentVersion,
+                    plan: context.plan
+                }) ||
                 context.runtime.requireExactClaudeAgentRow !== true ||
                 context.runtime.exactClaudeAgentState !== "idle") {
                 throw idleError;
@@ -1374,6 +1416,9 @@ class NativeThreadLifecycleCliApplication {
         };
     }
     async assertInitialInspectionReady(options, terminal, snapshot, bridge) {
+        return (await this.observeInitialInspectionReady(options, terminal, snapshot, bridge)).runtime;
+    }
+    async observeInitialInspectionReady(options, terminal, snapshot, bridge) {
         this.assertInspectionAgentIdentity({
             options, terminal, snapshot, stage: "before native status inspection"
         });
@@ -1384,7 +1429,7 @@ class NativeThreadLifecycleCliApplication {
             options, terminal, terminalStatus: status, session: snapshot.session
         });
         await this.assertInspectionComposerReady({ options, terminal });
-        return runtime;
+        return { runtime, status };
     }
     async submitInspection(context) {
         try {
@@ -1669,6 +1714,17 @@ function nativeInspectionComposerEmpty(agent, screen) {
         ? codexComposerEmpty(screen)
         : isExactClaudeNativeInspectionIdleComposer(String(screen ?? ""));
 }
+function modelControlProfileObservation(adapter, agentVersion) {
+    const capability = adapter.probeModelControl?.(agentVersion);
+    const plan = capability?.status === "supported"
+        ? adapter.planModelControl?.(capability)
+        : undefined;
+    return {
+        capability,
+        plan,
+        profile: plan ? terminalModelControlProfileForPlan(plan) : undefined
+    };
+}
 function required(value, message) {
     if (value === undefined || value === "")
         throw new Error(message);