@miadi/connector 0.1.19 → 0.1.21

package/README.md

@@ -20,9 +20,9 @@ Call `get_capabilities` first. It names the signed-in person, their Miadi API ti
 
 | kind | tools |
 |---|---|
-| reads | `get_capabilities` `get_context` `list_circles` `get_circle` `list_sessions` `get_session` `get_evidence` `read_episode_file` `get_evaluations` `get_narrative_beats` `review_lookup` `review_versions` `handoff_status` `list_records` `get_run_result` `mission_status` `provider_capabilities` `mission_model_preflight` `search` `fetch` |
+| reads | `get_capabilities` `get_context` `list_circles` `get_circle` `list_sessions` `get_session` `get_evidence` `read_episode_file` `get_evaluations` `get_narrative_beats` `review_lookup` `review_versions` `handoff_status` `list_records` `get_run_result` `mission_status` `provider_capabilities` `mission_model_preflight` `search` `fetch` `list_research_artifacts` `read_research_artifact` |
 | contributions | `append_observation` `open_inquiry` `link_records` `propose_narrative_beat` `record_evaluation` `register_source_intent` `record_handoff` `update_handoff` `prepare_calendar_event` `save_research` |
-| requests (approved by a person) | `propose_work` `propose_session_completion` `request_authorized_run` `request_session_steer` `request_review_operation` `request_deep_diver` `link_review_to_episode` `request_inquiry_episode` |
+| requests (approved by a person) | `propose_work` `propose_session_completion` `request_authorized_run` `request_session_steer` `revoke_session_steering` `request_review_operation` `request_deep_diver` `link_review_to_episode` `request_inquiry_episode` |
 | decisions in the conversation | `show_decisions` (cards), `decide_request` (called by the card only) |
 
 - **Reads** need Miadi's read tier and stay within it. A person Miadi gives no API tier reaches only `get_capabilities`. Sessions need the write tier, because a session's name and pane are operator data. For the same reason, below the write tier a record someone else made shows no session, working folder or seat, and no long bodies.
@@ -60,9 +60,44 @@ A mission is found by the issue it implements (jgwill/Miadi#913). `request_autho
 
 **The agent's result (jgwill/Miadi#921).** An agent returns its work with `propose_session_completion` naming the mission in `mission`, from its bound session, with its evidence refs and, optionally, a structured `result`: `summary`, `outputs` (`ref`, `label`, `git_sha`), `tests` (`command`, `passed`, `failed`, `skipped`) and `blockers`. `mission_status` and `get_run_result` read it back by the mission id as `result`: the standing submission (the newest `verified` one: it names the mission, ends a bound session and was submitted with Miadi's write tier or the factory's writer token, which the connector records on the ending as `submitted_with_tier`; anything else naming the mission is `unverified_association` with an `association_code`, a mere citation `cited_only` and never a result), its summary, tests and blockers as the agent's claim, and each output typed and checked when read. A commit or file on GitHub is read through GitHub (`GITHUB_TOKEN` when the host has one): `verified` with its sha, `changed_since_submission` when its declared `git_sha` no longer matches or the file changed on its branch after the submission, `unverified` with the reason when GitHub cannot be read, never `not_found`. A connector record id the ledger does not hold is `not_found`. Bound sessions are taken from the factory's receipts for every reader, so the verdict is the same at every tier; below the write tier the session ids are left out. The completion decision stays the person's, and only a verified submission sets it: `stage_truth.completion` is `pending_approval`, `accepted`, `declined` or `revision_requested` (`none` for an unverified one, whose stage is `result_submitted_unverified`; an approved exit submitted below the write tier closes nothing), `pending_human_gates` lists what waits on a person with its approval page, and `mission_stage` names the furthest stage with evidence (`result_submitted_awaiting_completion_approval`, `completion_accepted`, `merged`, `released`, `closed`…). A duplicate submission (same session, ending and mission, still pending) is handed back with `replayed: true`, and `not_recorded` names what the second call carried that was not kept.
 
-`request_session_steer` sends one authorized follow-up to one existing live agent, within the steering grant an approved run carries (`steering: { max_attempts, expires_at, pane }` on `request_authorized_run`). It peeks at the bound pane — the grant's pane or the session's first pane, never whichever pane is active — refuses a busy agent or a pane that is not an agent, types the exact instruction literally, and re-peeks to verify the agent accepted it (`accepted`) or only holds it at the prompt (`submitted`). Every attempt leaves a durable artifact with the instruction's sha256, its grant, its target and both captures. When the factory recorded the mission's pane, the steer goes to that pane id and nowhere else: another session is `stale_binding`, another pane `wrong_pane`, a replaced pane `stale_binding`, and text already at the prompt `composing` (nothing typed, Enter not pressed). A pane whose prompt box cannot be read (any TUI but Claude Code's today) is `blocked`. Every tmux address is exact (`=name:w.p`), because tmux otherwise matches a session by the start of its name. Only a steer that typed its instruction uses one of the grant's attempts (`typed`, and `attempts` in the answer). The connector's service steers through the tmux server of the user it runs as; `get_capabilities.steering` says whether that transport answers now, and while it does not, `request_session_steer` records nothing and uses no attempt. A steer the grant does not cover waits for one explicit scoped human decision on its `approval_url`, which runs exactly that instruction once.
+`request_session_steer` sends one person's correction to a running agent, within the steering grant an approved run carries (`steering: { max_attempts, expires_at, pane }` on `request_authorized_run`). Busy is the normal case (jgwill/Miadi#930).
 
-`request_authorized_run` may name a `provider` (`codex`, `pi`, `copilot`, `claude`). The connector verifies it is installed on the host before recording anything; an unknown or unavailable provider answers `provider_unavailable` and the mission stays unstarted. With no provider named, the first installed provider in the preference order is resolved and named in the brief; Claude Code is never chosen silently — it runs only when named. `provider_capabilities` (write tier) reports what the host has installed, the sign-in evidence, the preference order, and the read-only Jev check: `unconfigured` without `JEV_AI_API_KEY` or `TYPESAFE_API_KEY` in the connector's environment, else the models Jev lists for the key (no charge). A provider name inside a task's text selects nothing.
+| who | owns | never does |
+|---|---|---|
+| The person, through ChatGPT or any client | one correction, in scope | watch tools, wait for idle, send it again |
+| The connector | who may send it, the grant, mission → session → runtime, idempotency, handing it to that session's inbox, reporting what happened | decide when the model reads it, type into a working agent's pane, call a forward a delivery |
+| The runtime (Claude Code hooks: `miadi-session-observability` 0.1.34, `hooks/steering_inbox.mjs`) | the inbox, its order, the checks again at consumption, when its model reads it | deliver anything to a subagent or to another session |
+| The model | reading it and changing what it does next | |
+
+The route comes from what each part signed: the factory's receipt names the session, Claude Code's own registry says it runs and in which pane, and the adapter's `adapter.json` says this session loaded its hooks. A wrong session is `stale_binding`, a wrong pane `wrong_pane`. A provider with no adapter, or a Claude session started before the adapter (hooks load at session start), answers `unsupported` with the reason and uses no attempt. No Claude Code behaviour is assumed of Codex, Copilot or Pi, and `get_capabilities.steering.contract` names the adapters that exist.
+
+The inbox is `$MIADI_STEERING_DIR` (default `<factory>/steering`), `<session_id>/pending/` and its siblings, one Unix account's, `0700`. The connector writes one envelope with fsync and rename. The adapter takes it at the next `PostToolUse` or `PostToolUseFailure` as `additionalContext` in the same turn, or at `Stop` with `decision: block` when no further tool follows. A correction landing while the turn ends, after `Stop` has looked, is caught by a background watcher that runs for 30 seconds after each turn (`asyncRewake`): exit 2 wakes the model with it, so a working agent never waits for idle or a timer. A seat already idle is typed at once (below). The factory runner's next pass is the last net for anything left (`wakeIdleSteers`, once per envelope, only if the prompt box is clear), for example a session that resumed with a correction waiting. `delivery.continuation` says which of these is coming: `next_tool_or_turn_end`, `runner_wakes_idle_seat` or `session_not_running`. One rename into `claimed/` decides who delivers, so it is delivered once and never replayed. The adapter checks the session, the hash, the expiry (the grant's, or one day) and revocation again when it consumes. The hook does not poll: it runs in the agent's own lifecycle, and nothing outside watches it. A hook on an interrupted tool does not consume, because Claude Code drops hook messages there, and a subagent's tool does not consume either.
+
+Why hooks: Claude Code 2.1.318 has a native mid-turn queue, and `claude --help` offers no outside door to it. Typing reaches it through the keyboard, which is the terminal heuristic this replaces. The cross-session socket (`messagingSocketPath`) belongs to Claude sessions speaking to each other: its protocol is not published, and a connector speaking it would pose as a session. `PostToolUse.additionalContext` and `Stop` are its documented interface, so that is the adapter. Pi, Codex and Copilot have their own in-turn mechanisms, and none has an adapter here yet.
+
+`delivery` in the answer, in `get_run_result` on the steer's id, and in `mission_status.steering.steers` (write tier) says where it stands, each state with its source and time:
+
+| state | means | source |
+|---|---|---|
+| `authorized` | the grant or a person's decision covered it | connector |
+| `forwarded_to_runtime`, `queued_at_runtime` | it is in the session's inbox; the model has not necessarily read it | connector, runtime inbox |
+| `delivered_to_agent_context` | Claude Code recorded it entering the context | the transcript's attachment record |
+| `acknowledged` | the agent's own next text names `steer <id> received` | the transcript |
+| `behavior_adjusted` | a later tool input holds what the steer named in `expect_next_action`; without that, `behavior: not_judged` and the next actions are shown for a person to judge | the transcript |
+| `unsupported`, `expired`, `blocked` | it never reached the model, with the reason | connector or runtime hook |
+| `unknown` | claimed with no transcript record: ambiguous, and it is not sent again | |
+
+The record itself moves with its evidence: `completed` once the model has it, `blocked` once it never will, on the next read by anyone. So the ledger, `mission_status` and the decision surfaces say the same thing.
+
+`revoke_session_steering` stops a run's steering or one steer. What is still pending moves out at once, a marker stops anything later, and the answer says exactly what was revoked and what the agent had already consumed. The same idempotency key gets the first answer back, and the same words under a new key answer `duplicate`. Only a typed or forwarded steer uses one of the grant's attempts.
+
+An idle seat has no continuation coming, so it is the one case still typed: into the mission's bound pane, never whichever pane is active, with an exact tmux address (`=name:w.p`). It peeks first and re-peeks after. Text already at the prompt, or a prompt box that cannot be read, goes to the inbox when the seat has one and otherwise is `composing` or `blocked`, with nothing typed. A pane echo is not delivery: only a user record in the transcript moves it to `delivered_to_agent_context`. Every attempt leaves a durable artifact with the instruction's sha256, its grant and its target. The connector's service reaches the tmux server of the user it runs as; `get_capabilities.steering` says whether that answers now, and while it does not, `request_session_steer` records nothing and uses no attempt. A steer the grant does not cover waits for one explicit scoped human decision on its `approval_url`, which runs exactly that instruction once.
+
+Rollback: run the connector version before this one (`git checkout` of its `dist`, then `systemctl --user restart miadi-connector`). A working agent's steer then answers `busy` again and nothing else changes. To stop the runtime half, remove the plugin's `steering_inbox.sh` entries from `hooks/hooks.json`; a new session then has no `adapter.json` and answers `unsupported`. Envelopes already queued stay on disk, unread.
+
+`request_authorized_run` may name a `provider` (`codex`, `pi`, `copilot`, `claude`). The connector verifies it is installed on the host before recording anything; an unknown or unavailable provider answers `provider_unavailable` and the mission stays unstarted. With no provider named, the first installed provider in the preference order that may be picked by default (Pi, then Copilot) is resolved and named in the brief; Codex and Claude Code are never chosen silently, each runs only when named. `provider_capabilities` (write tier) reports what the host has installed, the sign-in evidence, the preference order, and the read-only Jev check: `unconfigured` without `JEV_AI_API_KEY` or `TYPESAFE_API_KEY` in the connector's environment, else the models Jev lists for the key (no charge). A provider name inside a task's text selects nothing.
+
+**Codex runs only on its requester's own choice (jgwill/Miadi#926).** The provider field is the caller's: the connector cannot read the chat, so `provider: "codex"` chooses nothing for the person. A run that names Codex is recorded, and its answer says it `needs_person_choice`. The approval page then shows no Approve button. Only the requester, signed in there with their own Miadi person token, can tick and send "Choose codex for this mission". That `provider_choice` record is bound to the request id, its version and its content hash, must be under 24 hours old when the request is approved, and covers that one mission. A revision makes it stale. A generic Approve, on the page or on a card, is refused as `provider_choice_required`, and so is a choice by any other person or by a service token. The requester can instead set their own policy at `/providers` so their requests may name Codex without a per-mission choice; that policy is theirs only and revisable. The check runs at request, revision, approval, and where the brief is written (approval and every rerun). The brief carries `provider_authorization` and `provider_choice` (or `provider_policy`), and the factory runner refuses to launch Codex for a connector brief without them. `request_authorized_run`, `revise_pending_request`, `mission_status`, `show_decisions` and `mission_model_preflight` show `provider_authorization`; after approval it is also in the request's `completion_receipt`, which `get_run_result` returns. A Codex launch without it is named on the mission and fails the preflight closed as `provider_not_authorized`. A brief the runner refuses goes to `queue/refused/` with its reason, and the request shows it. Other providers keep their regular policy, and nothing falls back to Codex. What this does not cover: anyone who can write `/srv/miadi/factory/queue` or the connector's state directory can forge a brief or a record (the folder's permissions are the boundary); a configured launcher that runs Codex behind a wrapper whose name does not say codex is trusted as configured; a brief to an existing session reaches only an idle Claude Code agent today, so it is not checked; and an agent that starts `codex` itself from inside its session is outside the connector's reach.
 
 `mission_model_preflight` (write tier) answers, for one mission, which provider and model fit its task type and criticality, and how that is known: contract `miadi.mission_model_preflight` v1, candidates with their configured default model, sign-in evidence (config directory only), quota `unknown`, policy eligibility, a review floor, and a recommendation or an abstention with reasons. Its `decider.source` is `static_fallback`, `jev` or `synthetic_fixture`. Jev is asked only with `consult_jev: true` and a key on the host; it is sent task type, criticality and candidates, never task text, mission id or repository, and its answer is advisory: uncalibrated, below 0.8 or outside the contract, the preflight abstains. A reported `launch` on another provider than the approved one answers `provider_mismatch` before anything is asked. It authorizes nothing. `bench/model-preflight-bench.mjs` compares the 0.1.12 baseline, the static preflight and Jev on synthetic scenarios; `bench/results/` keeps the runs.
 
@@ -99,7 +134,7 @@ MIADI_CONNECTOR_PUBLIC_URL=https://mcp.sanctuaireagentique.com node packages/con
 | `MIADI_REVIEW_BASE_URL` | `https://miadi-review-service.vercel.app` | the review service |
 | `MIADI_REVIEW_TOKEN` | read from `~/.env` | review search and approved review operations |
 | `MIADI_FACTORY_DIR` | `~/.miadi/factory` | the queue approved runs are written to |
-| `MIADI_INQUIRY_DIR` | `/a/src/IAIP/prototypes/artefacts` | the inquiry shelf `save_research` writes to, inside a git checkout it pushes |
+| `MIADI_INQUIRY_DIR` | `/a/src/IAIP/prototypes/artefacts` | the inquiry shelf `save_research` writes to, inside a git checkout it pushes, and `list_research_artifacts` and `read_research_artifact` read back |
 | `MIADI_INQUIRY_GITHUB_REPO` | `miadisabelle/Etuaptmumk-RSM` | where a saved report's inquiry issue is opened, with the host's `gh` login |
 | `MIADI_CONNECTOR_DECISION_TOKEN_TTL` | `604800` (7 days) | seconds a card's decision token stays usable, held between 300 and 2592000 |
 | `MIADI_CONNECTOR_DECISION_WAIT_MS` | `20000` | how long a decision answer waits for its run before answering it as recorded and running, at most 50000 |

package/dist/approve.d.ts

@@ -16,7 +16,9 @@ import type { MiadiClient } from "./miadi.js";
 import { type MiadiPerson } from "./people.js";
 import { type ConnectorRecord } from "./records.js";
 import { type RequestProjection } from "./request-state.js";
+import type { RuntimeDeps } from "./runtime-steer.js";
 import { type TmuxLike } from "./steer.js";
+import { type ProviderAuthorization } from "./provider-policy.js";
 export { factoryDir, runBriefFile, readQueueState } from "./queue-state.js";
 export interface ApprovalDeps {
     config: ConnectorConfig;
@@ -31,6 +33,8 @@ export interface ApprovalDeps {
     tmux?: TmuxLike;
     /** Re-peek delay after a steer is typed (default 4000ms; tests pass 0). */
     steerSettleMs?: number;
+    /** Where sessions and their steering inboxes live (jgwill/Miadi#930). Absent, no runtime route is known. */
+    steeringRuntime?: RuntimeDeps;
     /** Where decision events go (default: one JSON line on stdout, the service journal); tests collect them. */
     log?: (event: Record<string, unknown>) => void;
 }
@@ -55,7 +59,7 @@ export declare const DECISIONS: readonly ["approve", "approve_with_changes", "re
 export type Decision = (typeof DECISIONS)[number];
 /** The task a work proposal asks for, written from the proposal's own fields. */
 export declare function proposalTask(record: ConnectorRecord): string;
-export declare function runBrief(record: ConnectorRecord, approver: MiadiPerson, sessions: string[], instructions?: string): {
+export declare function runBrief(record: ConnectorRecord, approver: MiadiPerson, sessions: string[], instructions?: string, providerAttrs?: Record<string, string>): {
     to: string;
     brief: string;
 };
@@ -83,6 +87,14 @@ export declare class StaleVersion extends AlreadyDecided {
     readonly decidedVersion: number;
     constructor(currentVersion: number, decidedVersion: number);
 }
+/**
+ * An approval of a run whose provider needs the requester's own choice for this mission,
+ * and has none (jgwill/Miadi#926). Declining or sending it back stays possible.
+ */
+export declare class ProviderChoiceRequired extends Error {
+    readonly authorization: ProviderAuthorization;
+    constructor(authorization: ProviderAuthorization);
+}
 /** What a decision answers: the state it left, its receipt, and `replayed` when it repeats a decision already taken. */
 export interface Decided {
     decision: NonNullable<ConnectorRecord["approval_state"]>;
@@ -135,7 +147,7 @@ export declare function rerun(r: ConnectorRecord, person: MiadiPerson, deps: App
 }>;
 export declare function isApprovable(r: ConnectorRecord | undefined): r is ConnectorRecord;
 /** What approving a request does, in one sentence, for the card a person decides on. */
-export declare function consequenceOf(r: ConnectorRecord): string;
+export declare function consequenceOf(r: ConnectorRecord, authorization?: ProviderAuthorization): string;
 export declare function registerApprovalRoutes(app: Express, deps: ApprovalDeps): void;
 /** The request, and the decision form for a write-tier person (their token carried in the form they just signed into). */
 /**
@@ -146,5 +158,7 @@ export declare function requestProjection(record: ConnectorRecord, opts?: {
     reviewBase?: string;
     factoryDir?: string;
 }): RequestProjection | null;
+/** The person's own provider policy page: read and change it, signed in with their person token (jgwill/Miadi#926). */
+export declare function registerProviderPolicyRoutes(app: Express, deps: Pick<ApprovalDeps, "ledger" | "identify" | "log">): void;
 /** How a request is named to a person. */
 export declare const KIND_LABELS: Record<string, string>;

package/dist/approve.js

@@ -24,6 +24,8 @@ import { factoryDir, runBriefFile, readQueueState } from "./queue-state.js";
 import { factoryLedgerPath, readFactoryReceipts, receiptsForRecord } from "./factory-receipt.js";
 import { steerAttempts, steerSession, tmuxAdapter } from "./steer.js";
 import { contentHash, versionOf } from "./revisions.js";
+import { canReadReading } from "./reading/privacy.js";
+import { authorizationReceipt, authorizeProvider, briefAttributes, CHOICE_TTL_MS, CODEX_POLICIES, isPersonId, needsPersonChoice, providerPolicyOf, } from "./provider-policy.js";
 export { factoryDir, runBriefFile, readQueueState } from "./queue-state.js";
 /**
  * One line per step of a decision, for the journal: the request, a correlation id,
@@ -103,8 +105,10 @@ export function proposalTask(record) {
     }
     return lines.join("\n");
 }
-export function runBrief(record, approver, sessions, instructions) {
+export function runBrief(record, approver, sessions, instructions, providerAttrs = {}) {
     const body = (record.kind === "work_proposal" ? { task: proposalTask(record) } : record.body);
+    // A request recorded before providers were resolved (jgwill/Miadi#893) names only what was asked (#926 review RR7).
+    const provider = body.resolved_provider ?? body.provider;
     const short = record.id.split(":")[1]?.slice(0, 8) ?? "run";
     const to = body.session && sessions.includes(body.session) ? body.session : `new:${body.session ?? `connector-${yymmdd()}-${short}`}`;
     // A new session opens where the request says, else where the factory runner's config says (defaultCwd): no host path here (#911).
@@ -116,7 +120,9 @@ export function runBrief(record, approver, sessions, instructions) {
         `record="${attr(record.id)}"`,
         `version="${versionOf(record)}"`,
         // The provider the connector verified at request time (jgwill/Miadi#893); the intake may honour it or record why not.
-        ...(body.resolved_provider ? [`provider="${attr(body.resolved_provider)}"`] : []),
+        ...(provider ? [`provider="${attr(provider)}"`] : []),
+        // What authorizes a provider that needs the requester's own choice; the runner refuses Codex without it (jgwill/Miadi#926).
+        ...Object.entries(providerAttrs).map(([k, v]) => `${k}="${attr(v)}"`),
         ...(to.startsWith("new:") && cwd ? [`cwd="${attr(cwd)}"`] : []),
     ];
     const lines = [
@@ -189,6 +195,11 @@ export async function executeApproved(record, approver, deps, instructions) {
         return { status: res.status, ok: res.ok, response: parsed };
     };
     const queueBrief = () => {
+        // Checked again where the brief is written: an approval, and every rerun of it (jgwill/Miadi#926).
+        const authorization = record.kind === "run_request" ? authorizeProvider(record, deps.ledger.all()) : undefined;
+        if (authorization && !authorization.authorized) {
+            return { outcome: "failed", provider_authorization: authorizationReceipt(authorization), message: `No brief was written. ${authorization.explanation}` };
+        }
         const queue = join(deps.factoryDir ?? factoryDir(), "queue");
         mkdirSync(queue, { recursive: true });
         // A lister that cannot answer means no session is known live: the brief opens a new one (#922 R16).
@@ -199,10 +210,16 @@ export async function executeApproved(record, approver, deps, instructions) {
         catch {
             sessions = [];
         }
-        const { to, brief } = runBrief(record, approver, sessions, instructions);
+        const { to, brief } = runBrief(record, approver, sessions, instructions, authorization ? briefAttributes(authorization) : {});
         const file = runBriefFile(record);
         writeFileSync(join(queue, file), brief, { flag: "wx", mode: 0o640 });
-        return { outcome: "queued", to, file, note: "The factory intake delivers queued briefs every 5 minutes." };
+        return {
+            outcome: "queued",
+            to,
+            file,
+            ...(authorization ? { provider_authorization: authorizationReceipt(authorization) } : {}),
+            note: "The factory intake delivers queued briefs every 5 minutes.",
+        };
     };
     switch (record.kind) {
         case "run_request":
@@ -272,18 +289,21 @@ export async function executeApproved(record, approver, deps, instructions) {
                 return { outcome: "failed", message: "The run whose grant this steer cites is gone." };
             // The pane the factory delivered the mission to, when it recorded one (jgwill/Miadi#909).
             const bound = receiptsForRecord(readFactoryReceipts(factoryLedgerPath(deps.factoryDir ?? factoryDir())), grantRecord.id)[0];
-            const result = await steerSession({ tmux: deps.tmux ?? tmuxAdapter(), stateDir: deps.config.stateDir, ...(deps.steerSettleMs !== undefined ? { settleMs: deps.steerSettleMs } : {}) }, {
+            const result = await steerSession({ tmux: deps.tmux ?? tmuxAdapter(), stateDir: deps.config.stateDir, ...(deps.steeringRuntime ? { runtime: deps.steeringRuntime } : {}), ...(deps.steerSettleMs !== undefined ? { settleMs: deps.steerSettleMs } : {}) }, {
                 record,
                 grantRecord,
                 priorAttempts: steerAttempts(current(deps.ledger.all()), grantRecord.id),
                 authorized: true,
-                ...(bound ? { binding: { session: bound.tmux_session, ...(bound.pane_id ? { pane_id: bound.pane_id } : {}) } } : {}),
+                ...(bound ? { binding: { session: bound.tmux_session, ...(bound.pane_id ? { pane_id: bound.pane_id } : {}), ...(bound.session_id ? { session_id: bound.session_id } : {}), ...(bound.provider ? { provider: bound.provider } : {}) } } : {}),
             });
-            // A typed steer is never "failed": failed is re-runnable, and that would type it twice (#922 R8).
+            // A typed or forwarded steer is never "failed": failed is re-runnable, and that would send it twice (#922 R8).
             return {
-                outcome: result.typed ? result.status : "failed",
+                outcome: result.typed || result.forwarded ? result.status : "failed",
                 steer_status: result.status,
                 typed: result.typed,
+                ...(result.forwarded ? { forwarded: true } : {}),
+                ...(result.route ? { route: result.route } : {}),
+                ...(result.transcript_offset !== undefined ? { transcript_offset: result.transcript_offset } : {}),
                 message: result.message,
                 ...(result.target ? { target: result.target } : {}),
                 ...(result.artifact ? { artifact: result.artifact } : {}),
@@ -357,6 +377,17 @@ export class StaleVersion extends AlreadyDecided {
         this.decidedVersion = decidedVersion;
     }
 }
+/**
+ * An approval of a run whose provider needs the requester's own choice for this mission,
+ * and has none (jgwill/Miadi#926). Declining or sending it back stays possible.
+ */
+export class ProviderChoiceRequired extends Error {
+    authorization;
+    constructor(authorization) {
+        super(authorization.explanation);
+        this.authorization = authorization;
+    }
+}
 /** The decisions being recorded now, by request id: one at a time per request, in this process. */
 const deciding = new Map();
 /** Whether a decision on this request is being recorded now, its run may still be going. */
@@ -414,6 +445,14 @@ export async function decide(r, person, choice, deps, opts) {
     }
     if (versionOf(live) !== decidedVersion)
         throw new StaleVersion(versionOf(live), decidedVersion);
+    // A generic approval never chooses Codex: the requester's own fresh choice or policy must already stand (jgwill/Miadi#926).
+    if (live.kind === "run_request" && approvalStateOf(choice) === "approved") {
+        const authorization = authorizeProvider(live, deps.ledger.all(), { requireFresh: true });
+        if (!authorization.authorized) {
+            logDecision(deps, { phase: "provider_choice_required", record: r.id, via: opts.via, choice, provider: authorization.provider });
+            throw new ProviderChoiceRequired(authorization);
+        }
+    }
     const entry = { ...asked, correlation: randomUUID(), started: Date.now() };
     deciding.set(r.id, entry);
     entry.promise = decideOnce(live, person, choice, deps, { ...opts, correlation: entry.correlation, started: entry.started });
@@ -497,7 +536,7 @@ export async function rerun(r, person, deps, opts) {
             receipt = { ...receipt, ...outcome };
             if (outcome.outcome === "failed")
                 state = "blocked";
-            if (outcome.outcome === "queued")
+            if (outcome.outcome === "queued" || outcome.outcome === "queued_at_runtime")
                 state = "in_progress";
         }
         catch (error) {
@@ -564,7 +603,7 @@ async function decideOnce(r, person, choice, deps, opts) {
             receipt = { ...receipt, ...outcome };
             if (outcome.outcome === "failed")
                 state = "blocked";
-            if (outcome.outcome === "queued")
+            if (outcome.outcome === "queued" || outcome.outcome === "queued_at_runtime")
                 state = "in_progress";
         }
         catch (error) {
@@ -602,11 +641,13 @@ export function isApprovable(r) {
     return Boolean(r && APPROVABLE.has(r.kind));
 }
 /** What approving a request does, in one sentence, for the card a person decides on. */
-export function consequenceOf(r) {
+export function consequenceOf(r, authorization) {
     const b = r.body;
     switch (r.kind) {
         case "run_request":
-            return "Approving queues a brief for the factory intake, which opens or reaches an agent session within minutes.";
+            return authorization && !authorization.authorized
+                ? `Approving is refused until ${r.actor.name} chooses ${authorization.provider} for this mission on its approval page; approving does not choose it. Declining or sending it back stays possible.`
+                : `Approving queues a brief for the factory intake, which opens or reaches an agent session within minutes${authorization?.provider ? ` with ${authorization.provider}` : ""}.`;
         case "work_proposal":
             return "Approving starts the work: a brief written from the proposal and your instructions is queued for an agent session.";
         case "review_operation_request":
@@ -658,8 +699,43 @@ export function registerApprovalRoutes(app, deps) {
         if (!writer && r.actor.person_id !== person.id) {
             return void res.status(403).type("html").send(signInToRead(r, `Reading and deciding this request needs Miadi's write tier; ${person.name} has ${person.api_tier ?? "no API tier"}.`));
         }
+        const requester = r.actor.person_id === person.id && isPersonId(person.id);
         if (!body.decision)
-            return void res.type("html").send(approvePage(deps, r, { token: writer ? token : undefined }));
+            return void res.type("html").send(approvePage(deps, r, { token: writer ? token : undefined, chooserToken: requester ? token : undefined }));
+        if (body.decision === "choose_provider") {
+            // The requester's own, separate choice of a provider that needs one, for this version only (jgwill/Miadi#926).
+            const live = find(r.id);
+            const again = (status, error) => void res.status(status).type("html").send(approvePage(deps, live, { token: writer ? token : undefined, chooserToken: requester ? token : undefined, error }));
+            if (!requester) {
+                return again(403, isPersonId(r.actor.person_id)
+                    ? `Only ${r.actor.name}, who asked, can choose a provider for their own mission.`
+                    : `${r.actor.name} is a service token: only a person chooses a provider, for a request of their own. Name another provider for this request.`);
+            }
+            if (live.approval_state !== "awaiting_approval" || isBeingDecided(live.id))
+                return again(409, "A provider is chosen only while the request awaits a decision.");
+            const provider = String(body.provider ?? "");
+            const named = authorizeProvider(live, deps.ledger.all(), { requireFresh: true });
+            if (!needsPersonChoice(provider) || provider !== named.provider)
+                return again(400, `This request names ${named.provider ?? "no provider"}; only that provider can be chosen here.`);
+            if (Number(body.version) !== versionOf(live))
+                return again(409, `This request is now at version ${versionOf(live)}. Read it and choose again.`);
+            if (body.confirm !== "yes")
+                return again(400, `Tick the box to choose ${provider} for this mission.`);
+            if (!named.authorized || named.state !== "person_choice") {
+                deps.ledger.append({
+                    id: newRecordId("provider_choice"),
+                    kind: "provider_choice",
+                    created_at: new Date().toISOString(),
+                    actor: { person_id: person.id, name: person.name, client_id: "approval-page" },
+                    refs: [live.id],
+                    evidence_refs: [],
+                    claim_category: "observed",
+                    body: { request_id: live.id, provider, version: versionOf(live), content_hash: contentHash(live) },
+                });
+                logDecision(deps, { phase: "provider_chosen", record: live.id, provider, version: versionOf(live) });
+            }
+            return void res.type("html").send(approvePage(deps, find(r.id), { token: writer ? token : undefined, chooserToken: token }));
+        }
         if (!writer)
             return void res.status(403).type("html").send(approvePage(deps, r, { error: `Deciding needs Miadi's write tier; ${person.name} has ${person.api_tier ?? "no API tier"}.` }));
         if (body.decision === "rerun") {
@@ -705,6 +781,9 @@ export function registerApprovalRoutes(app, deps) {
             decided = settled;
         }
         catch (error) {
+            if (error instanceof ProviderChoiceRequired) {
+                return void res.status(409).type("html").send(approvePage(deps, find(r.id), { token, chooserToken: requester ? token : undefined, error: error.message }));
+            }
             if (error instanceof StaleVersion)
                 return void res.status(409).type("html").send(approvePage(deps, find(r.id), { token, error: error.message }));
             if (error instanceof AlreadyDecided)
@@ -746,6 +825,9 @@ export function registerApprovalRoutes(app, deps) {
         const r = find(String(req.params.id));
         if (!r)
             return void res.status(404).type("html").send(page("Not found", "<h1>No record with that id</h1>"));
+        if (!canReadReading(r, current(deps.ledger.all()), person)) {
+            return void res.status(403).type("html").send(page("Miadi record", recordForm(String(req.params.id), "This source and its reading are private to the source owner and factory operators.")));
+        }
         if (!person.api_tier && r.actor.person_id !== person.id) {
             return void res.status(403).type("html").send(page("Miadi record", recordForm(String(req.params.id), `Reading records needs Miadi's read tier; ${person.name} has none.`)));
         }
@@ -806,8 +888,12 @@ function approvePage(deps, r, o = {}) {
     const open = r.approval_state === "awaiting_approval";
     // A decision being recorded offers no buttons: a second click would decide the same request again.
     const actionable = open && !isBeingDecided(r.id);
+    // Freshness binds a decision still to come; a decided run shows the authorization it holds (#926 review R1).
+    const authorization = r.kind === "run_request" ? authorizeProvider(r, deps.ledger.all(), { requireFresh: open }) : undefined;
+    const blocked = Boolean(authorization && !authorization.authorized);
     return page("Approve a Miadi request", `<h1>${open ? "Approve a request" : "A decided request"}</h1>
-${actionable ? `<p>${escapeHtml(consequenceOf(r))} Declining records your refusal. Either is kept in the ledger with your name.</p>` : ""}
+${actionable ? `<p>${escapeHtml(consequenceOf(r, authorization))} Declining records your refusal. Either is kept in the ledger with your name.</p>` : ""}
+${authorization ? providerSection(r, authorization, actionable ? o.chooserToken : undefined) : ""}
 ${summary(r)}
 ${projectionBlock(projectionOf(r, deps), open ? undefined : r.completion_receipt)}
 ${o.error ? `<p class="err" role="alert">${escapeHtml(o.error)}</p>` : ""}
@@ -818,8 +904,10 @@ ${actionable && o.token
 <label for="i">Instructions (needed to approve with changes or to send back)</label>
 <textarea id="i" name="instructions" rows="4"></textarea>
 <div class="row">
-<button class="primary" type="submit" name="decision" value="approve">Approve and run</button>
-<button type="submit" name="decision" value="approve_with_changes">Approve with my changes</button>
+${blocked
+            ? ""
+            : `<button class="primary" type="submit" name="decision" value="approve">Approve and run</button>
+<button type="submit" name="decision" value="approve_with_changes">Approve with my changes</button>`}
 <button type="submit" name="decision" value="request_revision">Send back for revision</button>
 <button type="submit" name="decision" value="decline">Decline</button>
 </div></form>`
@@ -834,6 +922,87 @@ ${actionable && o.token
 <div class="row"><button class="primary" type="submit" name="decision" value="rerun">Run it again</button></div></form>`
                     : ""}`);
 }
+/**
+ * Which provider a run launches with, who chose it, and, when the requester's own choice is
+ * missing, the separate control only the requester sees (jgwill/Miadi#926).
+ */
+function providerSection(r, a, chooserToken) {
+    const lines = [
+        `<dt>Provider</dt><dd>${escapeHtml(a.provider ?? "the factory runner's default")}</dd>`,
+        `<dt>Asked for</dt><dd>${escapeHtml(a.requested ?? "none named")}${a.requester.client ? ` (through ${escapeHtml(a.requester.client)})` : ""}</dd>`,
+        `<dt>Authorized by</dt><dd>${escapeHtml(a.state.replace(/_/g, " "))}</dd>`,
+    ].join("");
+    const choose = a.state === "needs_person_choice" && chooserToken && a.provider
+        ? `<form method="post">
+<input type="hidden" name="person_token" value="${escapeHtml(chooserToken)}">
+<input type="hidden" name="version" value="${versionOf(r)}">
+<input type="hidden" name="provider" value="${escapeHtml(a.provider)}">
+<label><input type="checkbox" name="confirm" value="yes" required> I choose ${escapeHtml(a.provider)} for this mission (version ${versionOf(r)}) myself. It does not cover any other mission.</label>
+<div class="row"><button type="submit" name="decision" value="choose_provider">Choose ${escapeHtml(a.provider)} for this mission</button></div>
+</form>`
+        : a.state === "needs_person_choice" && !isPersonId(r.actor.person_id)
+            ? ""
+            : a.state === "needs_person_choice"
+                ? `<p>Only ${escapeHtml(r.actor.name)}, who asked, can choose ${escapeHtml(a.provider ?? "")} for this mission, signed in here. Within ${CHOICE_TTL_MS / 3_600_000} hours of that choice it can be approved.</p>`
+                : "";
+    return `<section aria-label="Provider"><dl>${lines}</dl><p>${escapeHtml(a.explanation)}</p>${choose}</section>`;
+}
+/** The person's own provider policy page: read and change it, signed in with their person token (jgwill/Miadi#926). */
+export function registerProviderPolicyRoutes(app, deps) {
+    const form = express.urlencoded({ extended: false, limit: "16kb" });
+    const signIn = (error) => page("Your provider policy", `<h1>Your provider policy</h1><p>Which agent providers a request made in your name may name. Sign in to read or change yours; it applies to your requests only.</p>
+${error ? `<p class="err" role="alert">${escapeHtml(error)}</p>` : ""}
+<form method="post"><label for="t">Your Miadi person token</label><input id="t" name="person_token" type="password" autocomplete="off" required>
+<div class="row"><button class="primary" type="submit">Read my policy</button></div></form>`);
+    app.get("/providers", (_req, res) => void res.type("html").send(signIn()));
+    app.post("/providers", form, async (req, res) => {
+        const body = (req.body ?? {});
+        const token = String(body.person_token ?? "").trim();
+        let person;
+        try {
+            person = await deps.identify(token);
+        }
+        catch (error) {
+            if (!(error instanceof MiadiUnavailable))
+                throw error;
+            return void res.status(503).type("html").send(signIn("Miadi could not be reached. Try again in a minute."));
+        }
+        if (!person)
+            return void res.status(401).type("html").send(signIn("Miadi did not recognise that person token."));
+        if (!isPersonId(person.id))
+            return void res.status(403).type("html").send(signIn("A service token has no provider policy; a person sets their own."));
+        let saved = "";
+        if (body.codex !== undefined) {
+            if (!CODEX_POLICIES.includes(body.codex))
+                return void res.status(400).type("html").send(signIn("Unknown Codex policy."));
+            if (providerPolicyOf(deps.ledger.all(), person.id).codex !== body.codex) {
+                deps.ledger.append({
+                    id: newRecordId("provider_policy"),
+                    kind: "provider_policy",
+                    created_at: new Date().toISOString(),
+                    actor: { person_id: person.id, name: person.name, client_id: "providers-page" },
+                    refs: [],
+                    evidence_refs: [],
+                    claim_category: "observed",
+                    body: { codex: body.codex },
+                });
+                logDecision(deps, { phase: "provider_policy_set", person: person.id, codex: body.codex });
+            }
+            saved = "<p>Saved. It applies to your requests from now on, including a failed run of yours that is run again. A per-mission choice you already made still covers its mission.</p>";
+        }
+        const policy = providerPolicyOf(deps.ledger.all(), person.id);
+        const option = (value, label) => `<label><input type="radio" name="codex" value="${value}"${policy.codex === value ? " checked" : ""}> ${escapeHtml(label)}</label>`;
+        res.type("html").send(page("Your provider policy", `<h1>${escapeHtml(person.name)}'s provider policy</h1>${saved}
+<dl><dt>Codex</dt><dd>${escapeHtml(policy.codex.replace(/_/g, " "))}${policy.source === "default" ? " (the default)" : `, set ${escapeHtml(policy.set_at ?? "")}`}</dd>
+<dt>Other providers</dt><dd>Pi, Copilot and Claude Code run when a request names them and they are installed; Pi and Copilot may also be picked by the host's order.</dd></dl>
+<form method="post"><input type="hidden" name="person_token" value="${escapeHtml(token)}">
+<fieldset><legend>When a request in my name names Codex</legend>
+${option("per_mission_choice", "Codex runs only when I choose it for that mission on its approval page (default).")}
+${option("selectable", "Codex may be named for my requests without a per-mission choice.")}
+</fieldset>
+<div class="row"><button class="primary" type="submit">Save my policy</button></div></form>`));
+    });
+}
 /** How a request is named to a person. */
 export const KIND_LABELS = {
     run_request: "Agent run",

package/dist/bin.js

@@ -4,6 +4,7 @@ import { createConnectorApp } from "./server.js";
 import { identifyThroughMiadi } from "./people.js";
 import { steeringTransport } from "./tools.js";
 import { tmuxAdapter } from "./steer.js";
+import { defaultRuntime } from "./runtime-steer.js";
 import { VERSION } from "./version.js";
 const config = configFromEnv();
 // The host's steering surface (jgwill/Miadi#909): the tmux server of the user the service runs as,
@@ -13,6 +14,8 @@ const { app } = createConnectorApp(config, {
     identify: identifyThroughMiadi(config.miadiUrl),
     tmux,
     tmuxSessions: () => tmux.listSessions(),
+    // Each session's own steering inbox and Claude Code's registry of running sessions (jgwill/Miadi#930).
+    steeringRuntime: defaultRuntime(),
 });
 app.listen(config.port, config.host, () => {
     console.log(`@miadi/connector ${VERSION} on http://${config.host}:${config.port}`);

package/dist/mission-status.d.ts

@@ -21,6 +21,7 @@
  */
 import type { ConnectorRecord } from "./records.js";
 import type { RequestProjection } from "./request-state.js";
+import type { SteerDelivery } from "./runtime-steer.js";
 import type { FactoryReceipt } from "./factory-receipt.js";
 import { type GithubGet, type MissionResult } from "./mission-result.js";
 export interface MissionSession {
@@ -184,9 +185,18 @@ export interface MissionStatus {
         access?: string;
     }[];
     steering?: {
-        grant: "none" | "active" | "expired_grant" | "exhausted";
+        grant: "none" | "active" | "expired_grant" | "exhausted" | "revoked";
         attempts_used: number;
         max_attempts?: number;
+        /** Each correction sent under this mission and where it stands, by its own evidence (jgwill/Miadi#930; write tier). */
+        steers?: {
+            id: string;
+            at: string;
+            by: string;
+            state: string;
+            route: string;
+            delivery: SteerDelivery;
+        }[];
     };
     stage_truth?: MissionStageTruth;
     /**
@@ -216,6 +226,8 @@ export interface MissionStatusDeps {
     tmuxSessions?: () => string[];
     /** Read-only peek: is the named session's pane mid-turn? The pane id when the binding names one, else the first pane. (write tier only.) */
     paneBusy?: (session: string, paneId?: string) => "busy" | "idle" | "unknown";
+    /** Where one steer stands, read from the runtime's inbox and the session's transcript (write tier only). */
+    steerDeliveryOf?: (steer: ConnectorRecord) => SteerDelivery | null;
     /** Whether the tmux session still holds the pane id (write tier only); undefined when it cannot be listed. */
     panePresent?: (session: string, paneId: string) => boolean | undefined;
     /** The factory runner's delivery receipts for one record, newest first (write tier only). */

package/dist/mission-status.js

@@ -1,4 +1,4 @@
-import { steerAttempts, steeringGrantOf, checkGrant } from "./steer.js";
+import { steerAttempts, steeringGrantOf, steeringRevoked, checkGrant } from "./steer.js";
 import { missionResult, redactResult, submittedWithWriteTier } from "./mission-result.js";
 const ISSUE_REF = /^([\w.-]+)\/([\w.-]+)#(\d+)$/;
 const SESSION_REF = /^session:([0-9a-f-]{36})$/;
@@ -108,7 +108,9 @@ function nextAction(record, standing, queue, result) {
         case "dispatching":
             return queue?.state === "delivered"
                 ? "The brief is with its session. Follow it, or steer it with request_session_steer inside the approved grant."
-                : "Wait for the factory intake to deliver the brief.";
+                : queue?.state === "refused"
+                    ? "The factory runner refused to launch its provider; nothing runs. The requester decides on a new request with a provider they chose."
+                    : "Wait for the factory intake to deliver the brief.";
         case "failed":
             return standing.rerun.available ? "A write-tier person may run it again with the same approval." : "Read the failure and decide.";
         case "completed":
@@ -387,8 +389,14 @@ export async function missionStatus(ref, records, deps) {
     }
     const grant = steeringGrantOf(record);
     const attempts = steerAttempts(records, record.id);
-    const grantCheck = grant ? checkGrant(grant, attempts, now) : null;
-    const grantState = grantCheck === null ? "none" : grantCheck === "ok" ? "active" : grantCheck === "expired_grant" ? "expired_grant" : "exhausted";
+    const grantCheck = grant ? checkGrant(grant, attempts, now, steeringRevoked(records, record.id)) : null;
+    const grantState = grantCheck === null ? "none" : grantCheck === "ok" ? "active" : grantCheck === "expired_grant" ? "expired_grant" : grantCheck === "revoked" ? "revoked" : "exhausted";
+    const steers = deps.steerDeliveryOf
+        ? records.filter((r) => r.kind === "session_steer_request" && r.refs.includes(record.id)).flatMap((r) => {
+            const delivery = deps.steerDeliveryOf(r);
+            return delivery ? [{ id: r.id, at: r.created_at, by: r.actor.name, state: delivery.state, route: delivery.route, delivery }] : [];
+        })
+        : [];
     const receipt = (record.completion_receipt ?? {});
     const anyLive = sessions.some((s) => s.live === "running");
     const prs = issues.filter((i) => i.merged !== undefined);
@@ -462,7 +470,7 @@ export async function missionStatus(ref, records, deps) {
         ...(queue ? { queue } : {}),
         sessions,
         issues,
-        steering: { grant: grantState, attempts_used: attempts, ...(grant?.max_attempts !== undefined ? { max_attempts: grant.max_attempts } : {}) },
+        steering: { grant: grantState, attempts_used: attempts, ...(grant?.max_attempts !== undefined ? { max_attempts: grant.max_attempts } : {}), ...(steers.length ? { steers } : {}) },
         ...(provider ? { provider } : {}),
         stage_truth: stageTruth,
         mission_stage: missionStage(standing ?? null, stageTruth),

package/dist/model-preflight.d.ts

@@ -1,4 +1,5 @@
 import { type JevConfig, type ProviderAvailability, type ProviderId } from "./providers.js";
+import { type ProviderAuthorization } from "./provider-policy.js";
 export declare const PREFLIGHT_CONTRACT = "miadi.mission_model_preflight";
 export declare const PREFLIGHT_VERSION = 1;
 /** Below this, a Jev choice is not acted on (the ≥0.8 practice of jgwill/Miadi#770). */
@@ -34,7 +35,7 @@ export interface LaunchEvidence {
     /** What shows it (a process line, a pane header); reported by the caller, not checked by the connector. */
     evidence: string;
 }
-export type PreflightState = "recommended" | "abstained" | "provider_mismatch";
+export type PreflightState = "recommended" | "abstained" | "provider_mismatch" | "provider_not_authorized";
 export type DeciderSource = "jev" | "static_fallback" | "synthetic_fixture";
 export type RouterState = "answered" | "not_requested" | "router_unconfigured" | "router_unavailable" | "invalid_answer";
 export interface ModelPreflight {
@@ -57,6 +58,8 @@ export interface ModelPreflight {
     /** approved: the request was approved with this provider. requested: it is not approved (yet); the provider is only asked for. */
     provider_basis: "approved" | "requested";
     candidates: ModelCandidate[];
+    /** Whether the mission's provider is authorized and by whom (jgwill/Miadi#926). */
+    provider_authorization?: Record<string, unknown>;
     decider: {
         source: DeciderSource;
         router: RouterState;
@@ -117,7 +120,7 @@ export interface JevRequest {
 }
 /** The model a provider's own config names, when it names one. Only that key is read. */
 export declare function configuredModel(provider: ProviderId, home?: string): string | null;
-export declare function candidatesFor(found: ProviderAvailability[], approved: ProviderId | null, modelOf?: (p: ProviderId) => string | null, basis?: "approved" | "requested"): ModelCandidate[];
+export declare function candidatesFor(found: ProviderAvailability[], approved: ProviderId | null, modelOf?: (p: ProviderId) => string | null, basis?: "approved" | "requested", authorization?: Pick<ProviderAuthorization, "authorized" | "provider" | "requester">): ModelCandidate[];
 /** The least review a task gets, whatever any decider says. Jev may raise it, never lower it. */
 export declare function reviewFloor(task: TaskType, criticality: Criticality): ReviewTier;
 export declare function decisionState(task: TaskType, criticality: Criticality, candidates: ModelCandidate[]): Record<string, unknown>;
@@ -134,6 +137,10 @@ export interface PreflightInput {
     task: TaskType;
     criticality: Criticality;
     candidates: ModelCandidate[];
+    /** Whether the mission's provider is authorized, and by whom (jgwill/Miadi#926); shown as given. */
+    provider_authorization?: Record<string, unknown> & {
+        authorized?: boolean;
+    };
     launch?: LaunchEvidence;
     /** The decider to consult, when the caller asked for one; absent means static fallback only. */
     adapter?: JevAdapter;