@scotthuang/agent-knock-knock 0.13.16 → 0.13.18

package/dist/src/terminal-model-control.js

@@ -1,208 +1,16 @@
-import { isCodexPaginatedVersion } from "./codex-lifecycle-compatibility.js";
+export { terminalUserExplicitModelControlBindingToken, terminalUserExplicitModelControlRepairBindingToken, terminalUserExplicitModelControlResidualEntryBindingToken } from "./terminal-model-control-subject.js";
+export { probeTerminalModelControl, planTerminalModelControl } from "./terminal-model-control-profile.js";
+import { isTerminalModelReasoningEffort } from "./terminal-model-control-contract.js";
+import { observeCodexIdleModel, classifyTerminalModelControlSurface, modelControlCaptureBlocked, codexPersistencePostcondition } from "./terminal-model-control-surface.js";
+import { MODEL_CONTROL_SETTLE_TIMEOUT_MS, MODEL_CONTROL_POLL_MS, transitionModelControl, exactDispatchKeys, waitForObservation } from "./terminal-model-control-input.js";
+import { inspectClaudeModelEfforts, applyCodexModelSelection, applyClaudeModelSelection } from "./terminal-model-selection.js";
+export { TERMINAL_MODEL_REASONING_EFFORTS, isTerminalModelReasoningEffort } from "./terminal-model-control-contract.js";
+export { parseCodexNativeModelCatalog, observeTerminalModelControl, modelControlMoveKeys, modelControlSelectModelKeys, codexModelControlSelectEffortKeys, codexModelControlAllModesKeys, claudeModelControlEffortKey, claudeModelControlCommitKeys, classifyTerminalModelControlSurface } from "./terminal-model-control-surface.js";
 import { createHash } from "node:crypto";
-import { captureCodexFullscreenComposerFrame } from "./codex-fullscreen-composer-proof.js";
-import { isTerminalModelControlPlanForAgent, planTerminalModelControlProfile, probeTerminalModelControlProfile, terminalModelControlProfileForPlan } from "./terminal-model-control-profile.js";
-import { canonicalModelControlSubject } from "./terminal-model-control-subject.js";
+import { isTerminalModelControlPlanForAgent, terminalModelControlProfileForPlan } from "./terminal-model-control-profile.js";
 import { decideTerminalModelControlFailure, reduceTerminalModelControlTransactionPhase } from "./terminal-model-control-transaction.js";
-import { terminalPhysicalBindingToken } from "./terminal-control-ref.js";
 export { CLAUDE_MODEL_CONTROL_AGENT_VERSION, CODEX_MODEL_CONTROL_AGENT_VERSION, CODEX_MODEL_CONTROL_AGENT_VERSIONS, TERMINAL_MODEL_CONTROL_PROFILE_IDS, isCodexModelControlAgentVersion, isTerminalModelControlPlanForAgent, terminalModelControlPlanConforms, terminalModelControlProfileFor, terminalModelControlProfileForPlan, terminalModelControlProfiles, terminalModelControlAllowsStyledSlashPopupWithoutViewportPaint, terminalModelControlSlashCompletionRows } from "./terminal-model-control-profile.js";
 export { canonicalModelControlSubject } from "./terminal-model-control-subject.js";
-/** Caller-visible reasoning values. Native labels and menu positions stay private. */
-export const TERMINAL_MODEL_REASONING_EFFORTS = [
-    "low",
-    "medium",
-    "high",
-    "xhigh",
-    "max",
-    "ultra"
-];
-/**
- * One action-specific physical authority token for fresh Codex model control.
- * The domain separator and exact profile keep this authority from being reused
- * as Send or native-lifecycle authority even though all bind the same pane.
- */
-export function terminalUserExplicitModelControlBindingToken(value) {
-    const subject = requiredModelControlSubject({
-        ...value,
-        agent: "codex"
-    });
-    const physicalTerminalToken = terminalPhysicalBindingToken({
-        terminalId: subject.terminalId,
-        terminalControl: subject.terminalControl,
-        agent: "codex",
-        pid: subject.pid,
-        workspace: subject.workspace,
-        processUuid: subject.processUuid,
-        processBirth: subject.processBirth
-    });
-    return createHash("sha256")
-        .update(JSON.stringify({
-        version: 1,
-        authority: "terminal_user_explicit_model_control",
-        physical_terminal_token: physicalTerminalToken,
-        agent_version: subject.agentVersion,
-        behavior_profile: subject.behaviorProfile
-    }))
-        .digest("hex");
-}
-function requiredModelControlSubject(input) {
-    const subject = canonicalModelControlSubject(input);
-    if (!subject) {
-        throw new Error("model-control authority requires one canonical supported terminal subject");
-    }
-    return subject;
-}
-/**
- * Snapshot authority for adopting and cleaning one exact native `/model`
- * residual. The residual kind and normalized surface digest prevent a token
- * for one popup, pane generation, or bare Composer from authorizing another.
- */
-export function terminalUserExplicitModelControlRepairBindingToken(value) {
-    const modelControlToken = terminalUserExplicitModelControlBindingToken(value);
-    return createHash("sha256")
-        .update(JSON.stringify({
-        version: 1,
-        authority: "terminal_user_explicit_model_control_repair",
-        model_control_token: modelControlToken,
-        residual_kind: value.residualKind,
-        residual_fingerprint: value.residualFingerprint
-    }))
-        .digest("hex");
-}
-/**
- * Snapshot authority for continuing one exact native `/model` residual into
- * the read-only catalog picker. This is deliberately domain-separated from
- * cleanup-only repair: a repair offer never authorizes Enter, while this
- * offer authorizes exactly one profiled slash-command dispatch.
- */
-export function terminalUserExplicitModelControlResidualEntryBindingToken(value) {
-    const modelControlToken = terminalUserExplicitModelControlBindingToken(value);
-    return createHash("sha256")
-        .update(JSON.stringify({
-        version: 1,
-        authority: "terminal_user_explicit_model_control_residual_entry",
-        model_control_token: modelControlToken,
-        residual_kind: value.residualKind,
-        residual_fingerprint: value.residualFingerprint
-    }))
-        .digest("hex");
-}
-export function parseCodexNativeModelCatalog(value) {
-    if (!isPlainRecord(value) || !Array.isArray(value.models)) {
-        throw new Error("the exact running Codex model catalog has an unknown shape");
-    }
-    const models = value.models.flatMap((candidate) => {
-        if (!isPlainRecord(candidate) || candidate.visibility !== "list")
-            return [];
-        const id = nonBlank(candidate.slug);
-        const label = nonBlank(candidate.display_name) ?? id;
-        if (!id || !label || !/^[a-z0-9][a-z0-9._:/+\-]{0,127}$/u.test(id) ||
-            !Array.isArray(candidate.supported_reasoning_levels)) {
-            throw new Error("the exact running Codex model catalog contains an invalid visible row");
-        }
-        const efforts = candidate.supported_reasoning_levels.flatMap((entry) => {
-            const effort = isPlainRecord(entry) ? entry.effort : undefined;
-            return isTerminalModelReasoningEffort(effort) ? [effort] : [];
-        });
-        if (efforts.length === 0 || new Set(efforts).size !== efforts.length) {
-            throw new Error(`the exact running Codex model catalog has no unique supported efforts for ${id}`);
-        }
-        return [{ id, label, reasoningEfforts: efforts }];
-    });
-    if (models.length === 0 ||
-        new Set(models.map((model) => model.id)).size !== models.length) {
-        throw new Error("the exact running Codex model catalog has no unique visible models");
-    }
-    return { models };
-}
-function observeCodexIdleModel(screen, plan) {
-    const lines = stripAnsi(screen).replace(/\r\n?/gu, "\n").split("\n");
-    while (lines.length > 0 && lines.at(-1)?.trim() === "")
-        lines.pop();
-    const version = plan && terminalModelControlProfileForPlan(plan)?.agentVersion;
-    const modern = isCodexPaginatedVersion(version);
-    const frame = modern ? captureCodexFullscreenComposerFrame(screen, version) : undefined;
-    const footer = modern
-        ? frame?.hasShortcutFooter ? frame.plainLines[frame.footerIndex] : undefined
-        : lines.at(-1);
-    const match = footer
-        ? /^\s{2,}([A-Za-z0-9][A-Za-z0-9._:/+\-]{0,127})\s+(low|medium|high|xhigh|max|ultra)(?:\s+fast)?(?:\s+·.*|\s+Plan mode(?:\s+\([^)]*\))?)?\s*$/u
-            .exec(footer)
-        : undefined;
-    if (!match || !isTerminalModelReasoningEffort(match[2]))
-        return undefined;
-    const model = codexSemanticModelLabel(match[1], modern);
-    if (!model)
-        return undefined;
-    return {
-        model,
-        reasoningEffort: match[2],
-        planMode: /\bPlan mode\b/u.test(footer ?? "")
-    };
-}
-async function inspectClaudeModelEfforts(input, terminalControl, picker, model) {
-    const selected = await transitionModelControl(input, terminalControl, picker, modelControlSelectModelKeys(picker, model), ["claude_model_picker"]);
-    if (selected.observation.state !== "claude_model_picker" ||
-        selectedClaudeModelId(selected.observation) !== model) {
-        throw new Error("Claude highlighted a different model during catalog inspection");
-    }
-    let control = selected.capture.terminalControl;
-    let live = selected.observation;
-    const initial = live.displayedEffort;
-    if (!initial) {
-        return {
-            capture: selected.capture,
-            observation: live,
-            reasoningEfforts: []
-        };
-    }
-    const seen = new Set([initial]);
-    for (let count = 0; count < 8; count += 1) {
-        const next = await transitionModelControl(input, control, live, claudeModelControlEffortKey("higher"), ["claude_model_picker"]);
-        if (next.observation.state !== "claude_model_picker" ||
-            selectedClaudeModelId(next.observation) !== model) {
-            throw new Error("Claude changed the highlighted model while probing its effort ring");
-        }
-        control = next.capture.terminalControl;
-        live = next.observation;
-        const effort = live.displayedEffort;
-        if (!effort) {
-            throw new Error("Claude removed its effort row while it was being inspected");
-        }
-        if (effort === initial) {
-            return {
-                capture: next.capture,
-                observation: live,
-                reasoningEfforts: TERMINAL_MODEL_REASONING_EFFORTS.filter((effort) => seen.has(effort))
-            };
-        }
-        if (seen.has(effort)) {
-            throw new Error("Claude's native effort ring did not return to its initial value");
-        }
-        seen.add(effort);
-    }
-    throw new Error("Claude's native effort ring exceeded the verified bounded size");
-}
-export function isTerminalModelReasoningEffort(value) {
-    return typeof value === "string" &&
-        TERMINAL_MODEL_REASONING_EFFORTS.includes(value);
-}
-export function probeTerminalModelControl(agent, agentVersion) {
-    return probeTerminalModelControlProfile(agent, agentVersion);
-}
-export function planTerminalModelControl(capabilities) {
-    return planTerminalModelControlProfile(capabilities);
-}
-/**
- * Observe only complete, current model-control modal frames. Historical or
- * partial picker text is never sufficient to authorize a key dispatch.
- */
-export function observeTerminalModelControl(plan, screen) {
-    const normalized = stripAnsi(screen).replace(/\r\n?/gu, "\n");
-    return isTerminalModelControlPlanForAgent(plan, "codex")
-        ? observeCodexModelControl(normalized, plan)
-        : observeClaudeModelControl(normalized);
-}
 export function terminalModelCatalogFingerprint(input) {
     const canonical = {
         agent: input.agent,
@@ -223,161 +31,6 @@ export function terminalModelCatalogFingerprint(input) {
         .update(JSON.stringify(canonical))
         .digest("hex");
 }
-export function modelControlMoveKeys(currentIndex, targetIndex) {
-    if (!Number.isSafeInteger(currentIndex) ||
-        !Number.isSafeInteger(targetIndex) ||
-        currentIndex < 0 ||
-        targetIndex < 0) {
-        throw new Error("model-control selection index is invalid");
-    }
-    const key = targetIndex >= currentIndex ? "Down" : "Up";
-    return Array.from({ length: Math.abs(targetIndex - currentIndex) }, () => key);
-}
-/** Adapter-owned native navigation; never serialize these keys to a caller. */
-export function modelControlSelectModelKeys(observation, model) {
-    const row = observation.rows.find((candidate) => candidate.id === model);
-    if (!row)
-        throw new Error("the requested model is absent from the current native picker");
-    return [
-        ...modelControlMoveKeys(observation.selectedIndex, row.nativeIndex),
-        ...(observation.state === "codex_model_picker" ? ["C-m"] : [])
-    ];
-}
-function selectedClaudeModelId(observation) {
-    return observation.rows.find((row) => row.nativeIndex === observation.selectedIndex)?.id;
-}
-export function codexModelControlSelectEffortKeys(observation, effort) {
-    const direct = observation.rows.find((row) => row.kind === "effort" && row.effort === effort);
-    const target = direct ?? (observation.state === "codex_reasoning_picker" &&
-        (effort === "max" || effort === "ultra")
-        ? observation.rows.find((row) => row.kind === "advanced")
-        : undefined);
-    if (!target) {
-        throw new Error("the requested reasoning effort is absent from the current native picker");
-    }
-    const targetIndex = observation.rows.indexOf(target);
-    return [
-        ...modelControlMoveKeys(observation.selectedIndex, targetIndex),
-        "C-m"
-    ];
-}
-export function codexModelControlAllModesKeys(observation) {
-    const targetIndex = observation.rows.indexOf("Apply to global default and Plan mode override");
-    if (targetIndex < 0) {
-        throw new Error("Codex Plan-mode scope picker has no global-default choice");
-    }
-    return [
-        ...modelControlMoveKeys(observation.selectedIndex, targetIndex),
-        "C-m"
-    ];
-}
-export function claudeModelControlEffortKey(direction) {
-    return [direction === "lower" ? "Left" : "Right"];
-}
-export function claudeModelControlCommitKeys(plan) {
-    if (!isTerminalModelControlPlanForAgent(plan, "claude") ||
-        plan.scope !== "current_session") {
-        throw new Error("Claude model control cannot commit outside session-only scope");
-    }
-    return ["s"];
-}
-function isExactTerminalModelControlObservation(observation) {
-    return observation.state !== "none" && observation.state !== "ambiguous";
-}
-/** Pure capture classifier. It never authorizes input by itself. */
-export function classifyTerminalModelControlSurface(plan, capture) {
-    const observation = observeTerminalModelControl(plan, capture.screen);
-    // Approval and a positively identified non-model input owner remain hard
-    // safety boundaries even when stale transcript text resembles a picker.
-    const hardBlock = modelControlHardBlock(capture);
-    if (hardBlock)
-        return hardBlock;
-    // Exact profile-owned surfaces outrank generic lifecycle activity. Codex and
-    // Claude can report working/waiting while their native picker owns input.
-    if (isExactTerminalModelControlObservation(observation)) {
-        return {
-            state: "picker",
-            pickerKind: modelControlPickerKind(observation),
-            observation
-        };
-    }
-    // Only a complete picker owns the lifecycle override. Composer proofs do
-    // not supersede genuine working/approval lifecycle state.
-    const activityBlock = modelControlActivityBlock(capture);
-    if (activityBlock)
-        return activityBlock;
-    return classifyModelControlComposerSurface(capture, observation);
-}
-function modelControlHardBlock(capture) {
-    if (capture.approvalBlocked) {
-        return { state: "blocked", owner: "approval" };
-    }
-    return capture.inputBlocked === true
-        ? { state: "blocked", owner: "input" }
-        : undefined;
-}
-function modelControlActivityBlock(capture) {
-    return capture.activityState === "working" ||
-        capture.activityState === "awaiting_approval"
-        ? { state: "blocked", owner: "agent" }
-        : undefined;
-}
-function modelControlPickerKind(observation) {
-    if (observation.state === "codex_reasoning_picker" ||
-        observation.state === "codex_advanced_reasoning_picker") {
-        return "effort";
-    }
-    return observation.state === "codex_plan_scope_picker" ? "scope" : "model";
-}
-function classifyModelControlComposerSurface(capture, observation) {
-    const contradictoryComposerProof = capture.exactEmptyComposer && capture.exactCommandComposer ||
-        capture.exactCommandReady && capture.exactBareCommand === true ||
-        (capture.exactCommandReady || capture.exactBareCommand === true) &&
-            !capture.exactCommandComposer;
-    if (contradictoryComposerProof) {
-        return {
-            state: "unknown",
-            reason: "model-control Composer proofs conflict"
-        };
-    }
-    if (capture.exactCommandComposer &&
-        capture.exactCommandReady) {
-        return {
-            state: "command_popup",
-            ...(capture.exactCommandFingerprint
-                ? { fingerprint: capture.exactCommandFingerprint }
-                : {})
-        };
-    }
-    if (capture.exactCommandComposer &&
-        capture.exactBareCommand === true) {
-        return {
-            state: "bare_command",
-            ...(capture.exactCommandFingerprint
-                ? { fingerprint: capture.exactCommandFingerprint }
-                : {})
-        };
-    }
-    if (capture.exactCommandComposer) {
-        return {
-            state: "command_draft",
-            ...(capture.exactCommandFingerprint
-                ? { fingerprint: capture.exactCommandFingerprint }
-                : {})
-        };
-    }
-    if (capture.exactEmptyComposer && capture.activityState === "idle") {
-        return { state: "idle_empty" };
-    }
-    return {
-        state: "unknown",
-        reason: observation.state === "ambiguous"
-            ? observation.reason
-            : "no exact current model-control surface is proven"
-    };
-}
-const MODEL_CONTROL_SETTLE_TIMEOUT_MS = 5_000;
-const MODEL_CONTROL_POLL_MS = 40;
 function advanceTerminalModelControlTransaction(transaction, event) {
     transaction.phase = reduceTerminalModelControlTransactionPhase(transaction.phase, event);
 }
@@ -414,9 +67,6 @@ async function settleTerminalModelControlFailure(input, terminalControl) {
         ...(cleanupError ? { cleanupError } : {})
     };
 }
-function modelControlCaptureBlocked(capture) {
-    return capture.approvalBlocked || capture.inputBlocked === true;
-}
 function residualFromCapture(plan, capture) {
     const profile = terminalModelControlProfileForPlan(plan);
     if (!profile?.supportsResidualRepair) {
@@ -708,48 +358,8 @@ export async function switchTerminalModel(input) {
             codexPersistenceScreen = committed.capture.screen;
         }
         else if (picker.state === "claude_model_picker") {
-            const selected = await transitionModelControl(operation, control, picker, modelControlSelectModelKeys(picker, input.request.model), ["claude_model_picker"]);
-            control = selected.capture.terminalControl;
-            if (selected.observation.state !== "claude_model_picker") {
-                throw new Error("Claude model selection did not remain in its picker");
-            }
-            if (selectedClaudeModelId(selected.observation) !== input.request.model) {
-                throw new Error("Claude highlighted a different model before effort selection");
-            }
-            let effortPicker = selected.observation;
-            const seen = new Set();
-            for (let count = 0; count < 7; count += 1) {
-                const displayed = effortPicker.displayedEffort;
-                if (!displayed)
-                    throw new Error("Claude model picker has no exact effort value");
-                if (displayed === requestedEffort)
-                    break;
-                if (seen.has(displayed)) {
-                    throw new Error("the requested effort is absent from Claude's live effort ring");
-                }
-                seen.add(displayed);
-                const next = await transitionModelControl(operation, control, effortPicker, claudeModelControlEffortKey("higher"), ["claude_model_picker"]);
-                control = next.capture.terminalControl;
-                if (next.observation.state !== "claude_model_picker") {
-                    throw new Error("Claude effort adjustment left the model picker");
-                }
-                if (selectedClaudeModelId(next.observation) !== input.request.model) {
-                    throw new Error("Claude changed the highlighted model during effort selection");
-                }
-                effortPicker = next.observation;
-            }
-            if (effortPicker.displayedEffort !== requestedEffort) {
-                throw new Error("the requested effort is absent from Claude's live effort ring");
-            }
-            if (selectedClaudeModelId(effortPicker) !== input.request.model) {
-                throw new Error("Claude changed the highlighted model before session-only commit");
-            }
-            advanceTerminalModelControlTransaction(operation.transaction, "commit_attempted");
-            await exactDispatchKeys(operation, control, effortPicker, claudeModelControlCommitKeys(input.plan));
-            const closed = await waitForObservation(operation, control, ["none"], {
-                allowImmediateNone: true
-            });
-            control = closed.capture.terminalControl;
+            const committed = await applyClaudeModelSelection(operation, control, picker, input.request, () => advanceTerminalModelControlTransaction(operation.transaction, "commit_attempted"), (observedControl) => { control = observedControl; });
+            control = committed.capture.terminalControl;
         }
         else {
             throw new Error("the native model picker changed before selection");
@@ -846,51 +456,6 @@ export async function switchTerminalModel(input) {
         };
     }
 }
-async function applyCodexModelSelection(input, terminalControl, picker, request, beforeCommitAttempt) {
-    const target = picker.rows.find((row) => row.id === request.model);
-    if (!target) {
-        throw new Error("the requested Codex model left the current native picker");
-    }
-    const moved = await transitionModelControl(input, terminalControl, picker, modelControlMoveKeys(picker.selectedIndex, target.nativeIndex), ["codex_model_picker"]);
-    if (moved.observation.state !== "codex_model_picker") {
-        throw new Error("Codex model navigation left its native picker");
-    }
-    const movedSelection = moved.observation.selectedIndex;
-    if (moved.observation.rows.find((row) => row.nativeIndex === movedSelection)?.id !== request.model) {
-        throw new Error("Codex highlighted a different model before selection");
-    }
-    // A remotely refreshed model can become single-effort after discovery; in
-    // that case Enter may commit immediately instead of opening a submenu.
-    beforeCommitAttempt();
-    const reasoning = await transitionModelControl(input, moved.capture.terminalControl, moved.observation, ["C-m"], ["codex_reasoning_picker"]);
-    if (reasoning.observation.state !== "codex_reasoning_picker" ||
-        reasoning.observation.model !== request.model) {
-        throw new Error("Codex opened a different reasoning picker");
-    }
-    let selection = reasoning.observation;
-    let keys = codexModelControlSelectEffortKeys(selection, request.reasoningEffort);
-    const advanced = request.reasoningEffort === "max" ||
-        request.reasoningEffort === "ultra";
-    if (!advanced)
-        beforeCommitAttempt();
-    let selected = await transitionModelControl(input, reasoning.capture.terminalControl, selection, keys, advanced
-        ? ["codex_advanced_reasoning_picker"]
-        : ["none", "codex_plan_scope_picker"], advanced ? {} : { allowImmediateNone: true });
-    if (advanced) {
-        if (selected.observation.state !== "codex_advanced_reasoning_picker") {
-            throw new Error("Codex advanced-reasoning picker did not materialize");
-        }
-        selection = selected.observation;
-        keys = codexModelControlSelectEffortKeys(selection, request.reasoningEffort);
-        beforeCommitAttempt();
-        selected = await transitionModelControl(input, selected.capture.terminalControl, selection, keys, ["none", "codex_plan_scope_picker"], { allowImmediateNone: true });
-    }
-    if (selected.observation.state !== "codex_plan_scope_picker") {
-        return selected;
-    }
-    beforeCommitAttempt();
-    return transitionModelControl(input, selected.capture.terminalControl, selected.observation, codexModelControlAllModesKeys(selected.observation), ["none"], { allowImmediateNone: true });
-}
 async function openModelPicker(input, terminalControl) {
     let cleanupControl = terminalControl;
     try {
@@ -1134,87 +699,6 @@ async function waitForModelCommandCleanupState(input, terminalControl) {
     }
     throw new Error("/model suggestions did not close to an exact bare or empty composer");
 }
-async function transitionModelControl(input, terminalControl, observation, keys, expectedStates, options = {}) {
-    if (keys.length === 0) {
-        return waitForObservation(input, terminalControl, expectedStates, options);
-    }
-    let control = terminalControl;
-    let current = observation;
-    for (const [index, key] of keys.entries()) {
-        control = await exactDispatchKeys(input, control, current, [key]);
-        const isLast = index === keys.length - 1;
-        const next = await waitForObservation(input, control, isLast ? expectedStates : [current.state], {
-            ...(isLast ? options : {}),
-            ...(key === "Up" || key === "Down" || key === "Left" || key === "Right"
-                ? { excludeFingerprint: current.fingerprint }
-                : {})
-        });
-        current = next.observation;
-        control = next.capture.terminalControl;
-        if (isLast)
-            return next;
-    }
-    throw new Error("model-control transition dispatched no key");
-}
-async function exactDispatchKeys(input, terminalControl, observation, keys) {
-    if (keys.length === 0)
-        return terminalControl;
-    if (keys.length !== 1) {
-        throw new Error("model-control transport accepts exactly one native key per proof");
-    }
-    await input.ports.beforeInput();
-    const captured = await input.ports.capture({ terminalControl });
-    const surface = classifyTerminalModelControlSurface(input.plan, captured);
-    const current = surface.state === "picker"
-        ? surface.observation
-        : undefined;
-    if (!current ||
-        current.state !== observation.state ||
-        current.fingerprint !== observation.fingerprint) {
-        throw new Error("the native model-control frame changed before key dispatch");
-    }
-    await input.ports.sendKeys(captured.terminalControl, keys);
-    return captured.terminalControl;
-}
-async function waitForObservation(input, terminalControl, expectedStates, options = {}) {
-    const startedAt = Date.now();
-    let stableFingerprint;
-    let stableCaptures = 0;
-    while (Date.now() - startedAt <= MODEL_CONTROL_SETTLE_TIMEOUT_MS) {
-        const captured = await input.ports.capture({ terminalControl });
-        const surface = classifyTerminalModelControlSurface(input.plan, captured);
-        if (surface.state === "blocked") {
-            throw new Error("the terminal became busy or blocked during model control");
-        }
-        const observation = surface.state === "picker"
-            ? surface.observation
-            : observeTerminalModelControl(input.plan, captured.screen);
-        const expectedNone = observation.state === "none" && (options.allowImmediateNone === true && surface.state === "idle_empty" ||
-            options.allowExactCommandComposer === true &&
-                (surface.state === "command_popup" ||
-                    surface.state === "bare_command" ||
-                    surface.state === "command_draft"));
-        const expected = observation.fingerprint !== options.excludeFingerprint &&
-            expectedStates.includes(observation.state) &&
-            (observation.state !== "none" || expectedNone);
-        if (expected) {
-            if (observation.fingerprint === stableFingerprint)
-                stableCaptures += 1;
-            else {
-                stableFingerprint = observation.fingerprint;
-                stableCaptures = 1;
-            }
-            if (stableCaptures >= 2)
-                return { capture: captured, observation };
-        }
-        else {
-            stableFingerprint = undefined;
-            stableCaptures = 0;
-        }
-        await input.ports.sleep(MODEL_CONTROL_POLL_MS);
-    }
-    throw new Error("the expected native model-control frame did not become stable");
-}
 async function exactDismiss(input, terminalControl, observation) {
     const control = await exactDispatchKeys(input, terminalControl, observation, ["Escape"]);
     const closed = await waitForObservation(input, control, ["none"], {
@@ -1233,461 +717,6 @@ async function exactDismiss(input, terminalControl, observation) {
     }
     throw new Error("native model-control dismissal did not return to exact idle");
 }
-function observeCodexModelControl(screen, plan) {
-    const lines = terminalTailLines(screen);
-    const fingerprint = screenFingerprint(lines);
-    const entryHeader = lastIndex(lines, (line) => line.trim() === "Select Model");
-    const modelHeader = lastIndex(lines, (line) => line.trim() === "Select Model and Effort");
-    const reasoningHeader = lastIndex(lines, (line) => /^\s*Select Reasoning Level for \S+\s*$/u.test(line));
-    const advancedHeader = lastIndex(lines, (line) => line.trim() === "Advanced Reasoning");
-    const scopeHeader = lastIndex(lines, (line) => line.trim() === "Apply reasoning change");
-    const latest = Math.max(entryHeader, modelHeader, reasoningHeader, advancedHeader, scopeHeader);
-    if (latest < 0) {
-        return { state: "none", fingerprint, reason: "no current Codex model picker is visible" };
-    }
-    const modern = isCodexPaginatedVersion(terminalModelControlProfileForPlan(plan)?.agentVersion);
-    const region = currentPickerRegion(lines, latest, modern);
-    if (!region) {
-        return {
-            state: "ambiguous",
-            fingerprint,
-            reason: "the current Codex model picker is incomplete or has trailing content"
-        };
-    }
-    if (region.some((line) => line.includes("OpenAI base URL is overridden"))) {
-        return {
-            state: "ambiguous",
-            fingerprint,
-            reason: "Codex model control is unavailable with an overridden OpenAI base URL"
-        };
-    }
-    if (latest === entryHeader) {
-        const parsedEntry = parseCodexEntryModelPicker(region);
-        if (!parsedEntry) {
-            return {
-                state: "ambiguous",
-                fingerprint,
-                reason: "the Codex entry model picker is not exact"
-            };
-        }
-        return { state: "codex_entry_model_picker", fingerprint, ...parsedEntry };
-    }
-    if (latest === modelHeader) {
-        const parsedRows = parseCodexModelRows(region, modern);
-        if (!parsedRows || modern && ![
-            "enter select · esc back", "enter default · s session · esc back"
-        ].includes(region.at(-1).trim())) {
-            return { state: "ambiguous", fingerprint, reason: "the Codex model catalog frame is not exact" };
-        }
-        return { state: "codex_model_picker", fingerprint, ...parsedRows };
-    }
-    if (latest === reasoningHeader) {
-        const modelLabel = /^\s*Select Reasoning Level for (\S+)\s*$/u.exec(region[0] ?? "")?.[1];
-        const model = modelLabel && codexSemanticModelLabel(modelLabel, modern);
-        const parsedRows = parseCodexEffortRows(region, false);
-        if (!model || !parsedRows || modern &&
-            !codexFullscreenEffortFooterMatches(region, parsedRows.rows[parsedRows.selectedIndex])) {
-            return { state: "ambiguous", fingerprint, reason: "the Codex reasoning frame is not exact" };
-        }
-        return {
-            state: "codex_reasoning_picker",
-            fingerprint,
-            model,
-            ...parsedRows
-        };
-    }
-    if (latest === advancedHeader) {
-        const parsedRows = parseCodexEffortRows(region, true);
-        if (!parsedRows || modern &&
-            !codexFullscreenEffortFooterMatches(region, parsedRows.rows[parsedRows.selectedIndex])) {
-            return { state: "ambiguous", fingerprint, reason: "the Codex advanced-reasoning frame is not exact" };
-        }
-        return {
-            state: "codex_advanced_reasoning_picker",
-            fingerprint,
-            ...parsedRows
-        };
-    }
-    const rows = region.flatMap((line) => {
-        const match = (modern
-            ? /^\s*(?:›\s*)?\d+\.\s+(Apply to (?:Plan mode override|global default and Plan mode override))(?:\s{2,}.+)?\s*$/u
-            : /^\s*(?:›\s*)?\d+\.\s+(Apply to (?:Plan mode override|global default and Plan mode override))\s*$/u)
-            .exec(line);
-        return match ? [match[1]] : [];
-    });
-    const numberedLines = region.filter((line) => /^\s*(?:›\s*)?\d+\./u.test(line));
-    const selectedLines = numberedLines.filter((line) => /^\s*›\s*\d+\./u.test(line));
-    if (rows.length !== 2 ||
-        numberedLines.length !== rows.length ||
-        selectedLines.length !== 1 ||
-        rows[0] !== "Apply to Plan mode override" ||
-        rows[1] !== "Apply to global default and Plan mode override" ||
-        modern && region.at(-1)?.trim() !== "enter select · esc back" ||
-        !numberedLines.every((line, index) => new RegExp(`^\\s*(?:›\\s*)?${index + 1}\\.`).test(line))) {
-        return { state: "ambiguous", fingerprint, reason: "the Codex Plan-mode scope frame is not exact" };
-    }
-    const selectedRow = numberedLines.findIndex((line) => /^\s*›/u.test(line));
-    return {
-        state: "codex_plan_scope_picker",
-        fingerprint,
-        rows,
-        selectedIndex: selectedRow
-    };
-}
-function observeClaudeModelControl(screen) {
-    const lines = terminalTailLines(screen);
-    const fingerprint = screenFingerprint(lines);
-    const headerIndex = lastIndex(lines, (line) => line.trim() === "Select model");
-    if (headerIndex < 0) {
-        return { state: "none", fingerprint, reason: "no current Claude model picker is visible" };
-    }
-    if (headerIndex === 0 ||
-        !/^\s*[▔¯─━]{8,}\s*$/u.test(lines[headerIndex - 1])) {
-        return { state: "ambiguous", fingerprint, reason: "the Claude model picker is not anchored to its top border" };
-    }
-    const region = lines.slice(headerIndex);
-    const footerIndex = region.findIndex((line) => /^\s*Enter to set as default\s+·\s+s to use this session only\s+·\s+Esc to cancel\s*$/u
-        .test(line));
-    if (footerIndex < 0 || region.slice(footerIndex + 1).some((line) => line.trim())) {
-        return { state: "ambiguous", fingerprint, reason: "the current Claude model picker footer is incomplete" };
-    }
-    const picker = region.slice(0, footerIndex + 1);
-    const rows = [];
-    const nativeRows = [];
-    for (const line of picker) {
-        const match = /^\s*(❯\s*)?(\d+)\.\s+(.+?)(?:\s{2,})(\S.*)$/u.exec(line);
-        if (!match)
-            continue;
-        const rawLabel = match[3].trim();
-        const label = rawLabel.replace(/\s+✔\s*$/u, "").trim();
-        const description = match[4].trim();
-        nativeRows.push({
-            nativeIndex: Number(match[2]) - 1,
-            selected: Boolean(match[1]),
-            label,
-            description,
-            current: rawLabel.endsWith("✔")
-        });
-    }
-    const numberedClaudeLines = picker.filter((line) => /^\s*(?:❯\s*)?\d+\./u.test(line));
-    if (numberedClaudeLines.length !== nativeRows.length ||
-        nativeRows.some((row, index) => row.nativeIndex !== index)) {
-        return { state: "ambiguous", fingerprint, reason: "the Claude model numbering is not exact" };
-    }
-    for (const row of nativeRows) {
-        if (/^Default(?:\s+\(recommended\))?$/iu.test(row.label) ||
-            /Opus Plan Mode/iu.test(row.label) ||
-            /Opus Plan Mode/iu.test(row.description) ||
-            /\bFable\b/iu.test(row.label) ||
-            /\bFable\b/iu.test(row.description))
-            continue;
-        const id = claudeSemanticModelId(`${row.label} ${row.description}`);
-        if (!id)
-            continue;
-        rows.push({
-            id,
-            label: row.label,
-            nativeIndex: row.nativeIndex,
-            selected: row.selected,
-            current: row.current,
-            presetDefault: false
-        });
-    }
-    const selectedRows = nativeRows.filter((row) => row.selected);
-    const selectedNativeIndex = selectedRows[0]?.nativeIndex ?? -1;
-    const currentNativeRows = nativeRows.filter((row) => row.current);
-    const currentModel = currentNativeRows.length === 1
-        ? claudeSemanticModelId(`${currentNativeRows[0].label} ${currentNativeRows[0].description}`)
-        : undefined;
-    if (rows.length === 0 ||
-        selectedRows.length !== 1 ||
-        !currentModel ||
-        !rows.some((row) => row.id === currentModel) ||
-        new Set(rows.map((row) => row.id)).size !== rows.length) {
-        return { state: "ambiguous", fingerprint, reason: "the Claude model rows are not profiled" };
-    }
-    const displayedEfforts = picker.flatMap((line) => {
-        const match = /^\s*[●○◐◉◈✦]\s+(Low|Medium|High|Extra high|Xhigh|Max|Ultracode)\s+effort\b/iu
-            .exec(line);
-        const value = match ? claudeEffortFromNativeLabel(match[1]) : undefined;
-        return value ? [value] : [];
-    });
-    if (displayedEfforts.length > 1) {
-        return { state: "ambiguous", fingerprint, reason: "the Claude effort row is not exact" };
-    }
-    const displayedEffort = displayedEfforts[0];
-    return {
-        state: "claude_model_picker",
-        fingerprint,
-        rows,
-        selectedIndex: selectedNativeIndex,
-        currentNativeIndex: currentNativeRows[0].nativeIndex,
-        currentModel,
-        ...(displayedEffort && displayedEffort !== "ultracode"
-            ? { currentEffort: displayedEffort }
-            : {}),
-        ...(displayedEffort ? { displayedEffort } : {})
-    };
-}
-function codexSemanticModelLabel(label, fullscreen) {
-    if (/^[a-z0-9][a-z0-9._:/+\-]*$/u.test(label))
-        return label;
-    return fullscreen && /^GPT-[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(label)
-        ? label.toLowerCase()
-        : undefined;
-}
-function parseCodexModelRows(region, fullscreen = false) {
-    const rows = [];
-    for (const line of region.slice(1, -1)) {
-        const match = /^\s*(›\s*)?(\d+)\.\s+([A-Za-z0-9][A-Za-z0-9._:/+\-]*)(?:\s+((?:\((?:current|default)\)\s*){1,2}))?(?:\s{2,}.*)?$/u
-            .exec(line);
-        if (!match)
-            continue;
-        const id = codexSemanticModelLabel(match[3], fullscreen);
-        if (!id)
-            return undefined;
-        const flags = match[4] ?? "";
-        rows.push({
-            id,
-            label: match[3],
-            nativeIndex: Number(match[2]) - 1,
-            selected: Boolean(match[1]),
-            current: flags.includes("(current)"),
-            presetDefault: flags.includes("(default)")
-        });
-    }
-    const numberedLines = region.slice(1, -1).filter((line) => /^\s*(?:›\s*)?\d+\./u.test(line));
-    const selectedRows = rows.filter((row) => row.selected);
-    const selectedIndex = selectedRows[0]?.nativeIndex ?? -1;
-    const currentRows = rows.filter((row) => row.current);
-    if (rows.length === 0 ||
-        numberedLines.length !== rows.length ||
-        rows.some((row, index) => row.nativeIndex !== index) ||
-        selectedRows.length !== 1 ||
-        currentRows.length !== 1 ||
-        new Set(rows.map((row) => row.id)).size !== rows.length) {
-        return undefined;
-    }
-    return {
-        rows,
-        selectedIndex,
-        currentNativeIndex: currentRows[0].nativeIndex,
-        currentModel: currentRows[0].id
-    };
-}
-function parseCodexEntryModelPicker(region) {
-    const subtitle = region[1]?.trim();
-    const kind = subtitle === "Pick a quick auto mode or browse all models."
-        ? "quick_auto"
-        : subtitle === "Other models return when ordinary usage is available again."
-            ? "luna_reserve"
-            : undefined;
-    if (!kind)
-        return undefined;
-    const numbered = region.slice(2, -1).filter((line) => /^\s*(?:›\s*)?\d+\./u.test(line));
-    const rows = numbered.map((line) => {
-        const match = /^\s*(›\s*)?(\d+)\.\s+(.+)$/u.exec(line);
-        if (!match)
-            return undefined;
-        const current = /(?:^|\s)\(current\)(?:\s{2,}|\s*$)/u.test(match[3]);
-        const label = match[3]
-            .replace(/\s+\(current\)(?=\s{2,}|\s*$)/u, "")
-            .split(/\s{2,}/u, 1)[0]
-            ?.trim();
-        return {
-            nativeIndex: Number(match[2]) - 1,
-            selected: Boolean(match[1]),
-            current,
-            label
-        };
-    });
-    if (rows.some((row) => !row) ||
-        rows.length === 0 ||
-        rows.some((row, index) => row?.nativeIndex !== index))
-        return undefined;
-    const exactRows = rows.filter((row) => Boolean(row));
-    const selected = exactRows.filter((row) => row.selected);
-    const current = exactRows.filter((row) => row.current);
-    if (selected.length !== 1 || current.length !== 1)
-        return undefined;
-    if (kind === "quick_auto") {
-        const allModels = exactRows.filter((row) => row.label === "All models");
-        if (allModels.length !== 1 ||
-            exactRows.at(-1)?.label !== "All models" ||
-            exactRows.slice(0, -1).some((row) => !/^codex-auto-[a-z0-9][a-z0-9._:/+\-]*$/u.test(row.label ?? "")))
-            return undefined;
-        return {
-            kind,
-            selectedIndex: selected[0].nativeIndex,
-            currentNativeIndex: current[0].nativeIndex,
-            allModelsNativeIndex: allModels[0].nativeIndex
-        };
-    }
-    if (exactRows.length !== 1 || !exactRows[0].label)
-        return undefined;
-    return {
-        kind,
-        selectedIndex: selected[0].nativeIndex,
-        currentNativeIndex: current[0].nativeIndex
-    };
-}
-function parseCodexEffortRows(region, advanced) {
-    const rows = [];
-    for (const line of region.slice(1, -1)) {
-        const match = /^\s*(›\s*)?\d+\.\s+(Low|Medium|High|Extra high|Max|Ultra|Persistent|More reasoning…)(?:\s+((?:\((?:current|default)\)\s*){1,2}))?(?:\s{2,}.*)?$/u
-            .exec(line);
-        if (!match)
-            continue;
-        const effort = effortFromNativeLabel(match[2]);
-        const flags = match[3] ?? "";
-        rows.push({
-            ...(effort ? { effort } : {}),
-            kind: match[2] === "More reasoning…"
-                ? "advanced"
-                : match[2] === "Persistent"
-                    ? "unsupported"
-                    : "effort",
-            selected: Boolean(match[1]),
-            current: flags.includes("(current)"),
-            presetDefault: flags.includes("(default)")
-        });
-    }
-    const numberedLines = region.slice(1, -1).filter((line) => /^\s*(?:›\s*)?\d+\./u.test(line));
-    const selectedRows = rows.filter((row) => row.selected);
-    const selectedIndex = rows.findIndex((row) => row.selected);
-    const current = rows.filter((row) => row.current && row.effort);
-    const defaults = rows.filter((row) => row.presetDefault && row.effort);
-    const allowed = advanced
-        ? rows.every((row) => row.kind === "effort" && ["max", "ultra"].includes(row.effort ?? ""))
-        : rows.every((row) => row.kind === "advanced" || row.kind === "unsupported" ||
-            !["max", "ultra"].includes(row.effort ?? ""));
-    if (rows.length === 0 ||
-        numberedLines.length !== rows.length ||
-        !numberedLines.every((line, index) => new RegExp(`^\\s*(?:›\\s*)?${index + 1}\\.`).test(line)) ||
-        selectedRows.length !== 1 ||
-        selectedIndex < 0 ||
-        current.length > 1 ||
-        defaults.length > 1 ||
-        !allowed)
-        return undefined;
-    return {
-        rows,
-        selectedIndex,
-        ...(current[0]?.effort ? { currentEffort: current[0].effort } : {}),
-        ...(defaults[0]?.effort
-            ? { presetDefaultEffort: defaults[0].effort }
-            : {})
-    };
-}
-function currentPickerRegion(lines, headerIndex, fullscreen = false) {
-    const after = lines.slice(headerIndex);
-    const expectedFooters = fullscreen ? [
-        "enter select · esc back",
-        "enter default · s session · esc back",
-        "enter apply · s session · esc back"
-    ] : ["Press enter to confirm or esc to go back"];
-    const footerIndex = after.findIndex((line) => expectedFooters.includes(line.trim()));
-    if (footerIndex < 0 || after.slice(footerIndex + 1).some((line) => line.trim())) {
-        return undefined;
-    }
-    return after.slice(0, footerIndex + 1);
-}
-function codexFullscreenEffortFooterMatches(region, selected) {
-    const expected = selected.kind !== "effort"
-        ? "enter select · esc back"
-        : selected.effort === "ultra"
-            ? "enter apply · s session · esc back"
-            : "enter default · s session · esc back";
-    return region.at(-1)?.trim() === expected;
-}
-function effortFromNativeLabel(label) {
-    return {
-        Low: "low",
-        Medium: "medium",
-        High: "high",
-        "Extra high": "xhigh",
-        Max: "max",
-        Ultra: "ultra"
-    }[label];
-}
-function claudeEffortFromNativeLabel(label) {
-    const normalized = label.trim().toLowerCase();
-    return {
-        low: "low",
-        medium: "medium",
-        high: "high",
-        "extra high": "xhigh",
-        xhigh: "xhigh",
-        max: "max",
-        ultracode: "ultracode"
-    }[normalized];
-}
-function claudeSemanticModelId(label) {
-    const family = /\b(opus|sonnet|haiku)\b/iu.exec(label)?.[1].toLowerCase();
-    if (!family || !/^(?:opus|sonnet|haiku)$/u.test(family))
-        return undefined;
-    const version = new RegExp(`\\b${family}[-\\s]+(\\d+(?:\\.\\d+)?)\\b`, "iu").exec(label)?.[1] ?? /\b(\d+\.\d+)\b/u.exec(label)?.[1];
-    const longContext = /(?:\[?1m\]?|1\s*million)(?:\s+context)?\b/iu.test(label);
-    return [family, version, longContext ? "1m" : undefined]
-        .filter((part) => Boolean(part))
-        .join("-");
-}
-function terminalTailLines(screen) {
-    const lines = screen.split("\n").slice(-160);
-    while (lines.length > 0 && lines.at(-1)?.trim() === "")
-        lines.pop();
-    return lines;
-}
-function lastIndex(lines, predicate) {
-    for (let index = lines.length - 1; index >= 0; index -= 1) {
-        if (predicate(lines[index]))
-            return index;
-    }
-    return -1;
-}
-function screenFingerprint(lines) {
-    return createHash("sha256").update(lines.join("\n")).digest("hex");
-}
-function stripAnsi(value) {
-    return value.replace(/\x1B(?:\[[0-?]*[ -/]*[@-~]|\][^\x07]*(?:\x07|\x1B\\))/gu, "");
-}
-function isPlainRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function nonBlank(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function codexPersistencePostcondition(beforeScreen, afterScreen, request) {
-    const errorPatterns = [
-        /Failed to save default model:/giu,
-        /Failed to save Plan mode reasoning effort:/giu,
-        /Saved default model and reasoning effort, but a higher-priority configuration\s+layer overrides the saved value\./giu,
-        /Saved Plan mode reasoning effort, but a higher-priority configuration\s+layer overrides the saved value\./giu
-    ];
-    if (errorPatterns.some((pattern) => matchCount(afterScreen, pattern) > matchCount(beforeScreen, pattern))) {
-        return {
-            proven: false,
-            final: true,
-            reason: "Codex reported that its persisted model default failed or is overridden by a higher-priority configuration layer"
-        };
-    }
-    const model = escapeRegExp(request.model);
-    const effort = request.reasoningEffort === "xhigh"
-        ? "(?:xhigh|extra high)"
-        : escapeRegExp(request.reasoningEffort);
-    const suffix = request.reasoningEffort === "ultra"
-        ? "\\s+for this conversation"
-        : "";
-    const success = new RegExp(`Model changed to\\s+${model}\\s+${effort}${suffix}(?:\\s|$)`, "giu");
-    if (matchCount(afterScreen, success) <= matchCount(beforeScreen, success)) {
-        return {
-            proven: false,
-            final: false,
-            reason: "Codex did not expose a fresh exact model-default persistence success frame"
-        };
-    }
-    return { proven: true };
-}
 async function waitForCodexPersistencePostcondition(input, terminalControl, baselineScreen, request, initialScreen) {
     const startedAt = Date.now();
     let screen = initialScreen;
@@ -1717,10 +746,4 @@ async function waitForCodexPersistencePostcondition(input, terminalControl, base
         reason: "Codex model-default persistence evidence did not materialize in time"
     };
 }
-function matchCount(value, pattern) {
-    return [...value.matchAll(pattern)].length;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-}
 //# sourceMappingURL=terminal-model-control.js.map