@miadi/connector 0.1.15 → 0.1.17

package/dist/mission-status.js

@@ -1,4 +1,5 @@
 import { steerAttempts, steeringGrantOf, 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})$/;
 const MISSION_KINDS = new Set(["run_request", "work_proposal"]);
@@ -20,9 +21,9 @@ function candidate(r, relation, provenance) {
     const primary = primaryIssueOf(r);
     return { id: r.id, kind: r.kind, created_at: r.created_at, relation, provenance, ...(primary ? { primary_issue: primary.ref } : {}) };
 }
-/** Whether a resolved reference may be acted on: an exact id, or a declared primary nobody else holds. */
+/** Whether a resolved reference may be acted on: an exact id, the one record the factory delivered to a session, or a declared primary nobody else holds. */
 export function authorizesActions(found) {
-    return found.resolution === "exact" || (found.resolution === "declared_primary" && !found.contested);
+    return found.resolution === "exact" || found.resolution === "factory_bound" || (found.resolution === "declared_primary" && !found.contested);
 }
 /**
  * The record a mission reference resolves to, how it was found, and every other
@@ -30,12 +31,22 @@ export function authorizesActions(found) {
  * Expects the folded ledger (`current()`), so a superseding record never stands
  * as a mission of its own.
  */
-export function resolveMissionSubject(ref, records) {
+export function resolveMissionSubject(ref, records, opts = {}) {
     const exact = records.find((r) => r.id === ref);
     if (exact)
         return { record: exact, via: "record_id", resolution: "exact", candidates: [] };
     // A request retired as an earlier version of another (jgwill/Miadi#919) is not a mission of its own.
     const missions = records.filter((r) => MISSION_KINDS.has(r.kind) && r.completion_receipt?.decision !== "superseded").sort(newestFirst);
+    // A session the factory delivered a mission to is bound by the runner's receipt, not by a citation (jgwill/Miadi#909).
+    const sessionMatch = SESSION_REF.exec(ref);
+    if (sessionMatch && opts.recordsBoundTo) {
+        const ids = new Set(opts.recordsBoundTo(sessionMatch[1]));
+        const bound = missions.filter((r) => ids.has(r.id));
+        if (bound.length === 1)
+            return { record: bound[0], via: "factory_receipt", resolution: "factory_bound", candidates: [candidate(bound[0], "bound", "factory_receipt")] };
+        if (bound.length > 1)
+            return { via: "factory_receipt", resolution: "ambiguous_mission", candidates: bound.map((r) => candidate(r, "bound", "factory_receipt")) };
+    }
     if (SESSION_REF.test(ref)) {
         const citing = missions.filter((r) => r.refs.includes(ref));
         if (!citing.length)
@@ -68,9 +79,24 @@ export function resolveMissionSubject(ref, records) {
     }
     return null;
 }
-function nextAction(record, standing, queue) {
+function nextAction(record, standing, queue, result) {
     if (!standing)
         return "Read the record itself; it is not an approvable request.";
+    if (result?.current && !result.verified && (standing.stage === "dispatching" || standing.stage === "completed")) {
+        return `A result names this mission but is not verified (${result.current.association_reason}) Read it as a claim; its decision does not complete the mission.`;
+    }
+    if (result?.current && (standing.stage === "dispatching" || standing.stage === "completed")) {
+        switch (result.completion) {
+            case "pending_approval":
+                return `The agent submitted its result (${result.current.record}). Read result.current; a person with Miadi's write tier decides its ending on its approval page. Nothing closes before that.`;
+            case "accepted":
+                return "The person accepted the ending. What remains is any merge or release this mission needs, each by its own receipt.";
+            case "declined":
+                return "The person declined the ending; the session stays open. Follow it, or steer it inside the approved grant.";
+            case "revision_requested":
+                return "The person sent the ending back; the agent revises its result and submits again.";
+        }
+    }
     switch (standing.stage) {
         case "awaiting_decision":
             return "A person with Miadi's write tier decides on its approval page or a decisions card.";
@@ -144,6 +170,9 @@ function closureTruth(record, records, missionSessions) {
             return false;
         if (!CLOSING_ENDINGS.has(str(b.ending)))
             return false;
+        // The same trust as a verified result: an ending submitted below the write tier closes nothing (#922 R3, R4).
+        if (!submittedWithWriteTier(r))
+            return false;
         return missionSessions.size === 0 || missionSessions.has(str(b.session_id));
     })
         .sort(newestFirst);
@@ -163,7 +192,7 @@ function closureTruth(record, records, missionSessions) {
 }
 export async function missionStatus(ref, records, deps) {
     const notes = [];
-    const found = resolveMissionSubject(ref, records);
+    const found = resolveMissionSubject(ref, records, { recordsBoundTo: deps.recordsBoundTo });
     if (!found)
         return { ref, found: false, notes: ["No mission record resolves from this reference."] };
     if (!found.record) {
@@ -198,10 +227,101 @@ export async function missionStatus(ref, records, deps) {
     const now = deps.now?.() ?? new Date();
     // The sessions this mission names, each with how it is bound.
     const sessions = [];
-    const live = deps.tmuxSessions ? new Set(deps.tmuxSessions()) : undefined;
+    // A lister that fails says nothing: unknown, never absent (#922 R10).
+    let live;
+    try {
+        live = deps.tmuxSessions ? new Set(deps.tmuxSessions()) : undefined;
+    }
+    catch {
+        live = undefined;
+    }
     const briefTo = (record.completion_receipt ?? {}).to;
     const named = String(record.body.session ?? "") || undefined;
     const seen = new Set();
+    const seenIds = new Set();
+    const view = async (id) => (deps.sessionOf ? deps.sessionOf(id).catch(() => ({ state: "unavailable" })) : undefined);
+    // 1. The factory runner's receipt: the record, the tmux session, the pane and the session id that took the brief (jgwill/Miadi#909).
+    const receipts = deps.factoryReceiptsOf?.(record.id) ?? [];
+    let provider;
+    for (const rc of receipts) {
+        if (seen.has(rc.tmux_session) && (!rc.session_id || seenIds.has(rc.session_id)))
+            continue;
+        seen.add(rc.tmux_session);
+        if (rc.session_id)
+            seenIds.add(rc.session_id);
+        const miadi = rc.session_id ? (await view(rc.session_id)) : undefined;
+        // Miadi's door answers { session: {...}, read_at }; the session itself holds live (jgwill/Miadi#921 F1).
+        const seat = miadi && typeof miadi === "object" ? (miadi.session && typeof miadi.session === "object" ? miadi.session : miadi) : undefined;
+        const reg = seat && seat.live && typeof seat.live === "object" ? seat.live : undefined;
+        let binding;
+        let binding_reason;
+        let binding_compared;
+        if (!rc.session_id) {
+            binding = "receipt_only";
+            binding_reason = "The runner recorded no session id for this delivery.";
+        }
+        else if (!miadi || miadi.state === "unavailable" || miadi.error) {
+            binding = "receipt_only";
+            binding_reason = "Miadi's session registry could not be read; only the runner's receipt binds this session.";
+        }
+        else if (!reg) {
+            binding = "receipt_only";
+            binding_reason = "Miadi's session registry knows the session but shows no live seat for it now.";
+        }
+        else if (str(reg.tmux_session) === rc.tmux_session && (!rc.pane_id || !str(reg.pane_id) || str(reg.pane_id) === rc.pane_id)) {
+            binding = "verified";
+            binding_compared = ["session_id", "tmux_session", ...(rc.pane_id && str(reg.pane_id) ? ["pane_id"] : [])];
+            binding_reason = `The factory receipt and Miadi's session registry agree on ${binding_compared.join(", ")}.`;
+        }
+        else {
+            binding = "unverified_association";
+            binding_reason = `The receipt names ${rc.tmux_session} ${rc.pane_id ?? ""}, but the registry places session ${rc.session_id} in ${str(reg.tmux_session) || "(none)"} ${str(reg.pane_id)}.`.replace(/\s+/g, " ");
+        }
+        const inTmux = live ? live.has(rc.tmux_session) : undefined;
+        const paneThere = inTmux && rc.pane_id && deps.panePresent ? deps.panePresent(rc.tmux_session, rc.pane_id) : undefined;
+        const liveState = live ? (inTmux && paneThere !== false ? "running" : "absent") : reg ? "running" : "unknown";
+        if (inTmux && paneThere === false) {
+            binding_reason += ` Pane ${rc.pane_id} is no longer in ${rc.tmux_session}; the seat was replaced or restored.`;
+            if (binding === "verified")
+                binding = "unverified_association";
+        }
+        const regStatus = str(reg?.status);
+        const activity = binding === "verified" && (regStatus === "busy" || regStatus === "idle")
+            ? regStatus
+            : liveState === "running" && deps.paneBusy
+                ? deps.paneBusy(rc.tmux_session, rc.pane_id)
+                : undefined;
+        sessions.push({
+            association: "factory_receipt",
+            session: rc.tmux_session,
+            ...(rc.session_id ? { session_id: rc.session_id } : {}),
+            ...(rc.pane_id ? { pane_id: rc.pane_id } : {}),
+            delivered_at: rc.at,
+            live: liveState,
+            ...(activity ? { activity, activity_source: binding === "verified" && regStatus ? "miadi_registry" : "pane_peek" } : {}),
+            ...(activity && binding === "verified" && str(reg?.updated_at) ? { activity_at: str(reg.updated_at) } : {}),
+            binding,
+            binding_reason,
+            ...(binding_compared ? { binding_compared } : {}),
+            ...(miadi ? { miadi } : {}),
+        });
+        if (!provider) {
+            const b = record.body;
+            const requested = str(b.provider) || null;
+            const resolved = str(b.resolved_provider) || null;
+            const actual = rc.provider || str(seat?.agent) || null;
+            provider = {
+                requested,
+                resolved,
+                actual,
+                ...(actual ? { actual_source: rc.provider ? "factory_receipt" : "miadi_registry" } : {}),
+                match: !actual || !(resolved ?? requested) ? "unknown" : actual === (resolved ?? requested),
+            };
+            if (provider.match === false) {
+                notes.push(`The mission asked for ${requested ?? "(none)"}${resolved && resolved !== requested ? ` (resolved ${resolved})` : ""}; the factory ran ${actual}. Nothing was re-run because of it.`);
+            }
+        }
+    }
     const addSession = (session, association) => {
         if (seen.has(session))
             return;
@@ -210,7 +330,7 @@ export async function missionStatus(ref, records, deps) {
             association,
             session,
             live: live ? (live.has(session) ? "running" : "absent") : "unknown",
-            ...(deps.paneBusy && live?.has(session) ? { activity: deps.paneBusy(session) } : {}),
+            ...(deps.paneBusy && live?.has(session) ? { activity: deps.paneBusy(session), activity_source: "pane_peek" } : {}),
         });
     };
     if (typeof briefTo === "string" && briefTo)
@@ -220,12 +340,31 @@ export async function missionStatus(ref, records, deps) {
     for (const r of record.refs) {
         const m = SESSION_REF.exec(r);
         if (m) {
-            const miadi = deps.sessionOf ? await deps.sessionOf(m[1]).catch(() => ({ state: "unavailable" })) : undefined;
-            sessions.push({ association: "signed_ref", session: r, live: "unknown", ...(miadi ? { miadi } : {}) });
+            if (seenIds.has(m[1]))
+                continue; // the receipt already binds it
+            const miadi = await view(m[1]);
+            sessions.push({ association: "signed_ref", session: r, session_id: m[1], live: "unknown", ...(miadi ? { miadi } : {}) });
         }
     }
     if (!live)
         notes.push("Live session state was not joined (the viewer's tier or the host does not allow it).");
+    if (deps.factoryReceiptsOf && !receipts.length && record.approval_state === "approved") {
+        notes.push("The factory has no delivery receipt for this mission; its session is known only by name.");
+    }
+    // The sessions a result must come from: the runner's receipts (for every tier), else the session refs the record carries.
+    const boundIds = new Set([...seenIds, ...(deps.boundSessionIdsOf?.(record.id) ?? [])]);
+    if (!boundIds.size)
+        for (const r of record.refs) {
+            const m = SESSION_REF.exec(r);
+            if (m)
+                boundIds.add(m[1]);
+        }
+    const evidence = deps.trustedRecords ?? records;
+    const operator = deps.operator ?? true;
+    // The closure set is built from the record as stored, not as this viewer is shown it (#922 R15).
+    const stored = evidence.find((r) => r.id === record.id) ?? record;
+    const storedTo = str((stored.completion_receipt ?? {}).to).replace(/^new:/, "");
+    const storedNamed = str(stored.body.session);
     const issues = [];
     if (deps.issueOf) {
         for (const r of [...new Set([...record.refs, ...record.evidence_refs])]) {
@@ -255,8 +394,16 @@ export async function missionStatus(ref, records, deps) {
     const prs = issues.filter((i) => i.merged !== undefined);
     const unverifiedRefs = issues.some((i) => i.state === "unverified");
     const release = releaseTruth(record, records, deps, now);
-    const missionSessions = new Set(sessions.map((x) => x.session.replace(/^session:/, "")));
-    const closure = closureTruth(record, records, missionSessions);
+    const missionSessions = new Set([
+        ...sessions.map((x) => x.session.replace(/^session:/, "")),
+        ...boundIds,
+        ...(storedTo ? [storedTo] : []),
+        ...(storedNamed ? [storedNamed] : []),
+    ]);
+    const closureFound = closureTruth(record, evidence, missionSessions);
+    const closure = closureFound && !operator ? (({ session_id: _s, ...rest }) => rest)(closureFound) : closureFound;
+    const checked = await missionResult(record, evidence, boundIds, { githubGet: deps.githubGet, approvalUrl: deps.approvalUrl, now: () => now });
+    const result = operator ? checked : redactResult(checked);
     const choice = standing?.decision?.choice ?? (str(receipt.decision) || undefined);
     const instructions = standing?.decision?.instructions ?? (str(receipt.instructions) || undefined);
     const stageTruth = {
@@ -274,9 +421,18 @@ export async function missionStatus(ref, records, deps) {
         pr_merged: unverifiedRefs ? "unverified" : prs.length ? (prs.every((p) => p.merged) ? "merged" : "open_or_absent") : "no_pr",
         released: release.released,
         ...(release.release_evidence ? { release_evidence: release.release_evidence } : {}),
+        result_submitted: result.state === "submitted",
+        result_verified: result.verified,
+        completion: result.completion,
         closed: Boolean(closure),
         ...(closure ? { closure_evidence: closure } : {}),
     };
+    if (result.state === "submitted" && result.verified && result.completion === "pending_approval") {
+        notes.push("The agent submitted its result; its ending waits for a person's decision. Submitted is not accepted, and accepted is not closed.");
+    }
+    if (stageTruth.running === "evidence" && result.state === "no_result_submitted") {
+        notes.push("A live seat, busy or idle, is not a result: nothing names this mission as its submitted result yet.");
+    }
     if (stageTruth.running === "no_evidence" && record.approval_state === "approved") {
         notes.push("No bound session shows live; an idle or absent pane is not proof of completion or failure.");
     }
@@ -307,10 +463,57 @@ export async function missionStatus(ref, records, deps) {
         sessions,
         issues,
         steering: { grant: grantState, attempts_used: attempts, ...(grant?.max_attempts !== undefined ? { max_attempts: grant.max_attempts } : {}) },
+        ...(provider ? { provider } : {}),
         stage_truth: stageTruth,
+        mission_stage: missionStage(standing ?? null, stageTruth),
+        pending_human_gates: pendingGates(record, records, result, deps.approvalUrl),
+        result,
         next_authorized_action: identity.authorizes_actions
-            ? nextAction(record, standing ?? null, queue)
-            : `Not authorizing (${found.contested ? "contested" : "inferred"}): call mission_status with ${record.id} before acting. ${nextAction(record, standing ?? null, queue)}`,
+            ? nextAction(record, standing ?? null, queue, result)
+            : `Not authorizing (${found.contested ? "contested" : "inferred"}): call mission_status with ${record.id} before acting. ${nextAction(record, standing ?? null, queue, result)}`,
         notes,
     };
 }
+/** The furthest stage the evidence reaches. Each stage keeps its own truth in stage_truth. */
+export function missionStage(standing, t) {
+    if (standing && ["awaiting_decision", "recording", "sent_back", "declined"].includes(standing.stage))
+        return standing.stage;
+    if (t.closed)
+        return "closed";
+    if (t.released === "verified" || t.released === "receipt_recorded")
+        return "released";
+    if (t.pr_merged === "merged")
+        return "merged";
+    if (t.completion === "accepted")
+        return "completion_accepted";
+    if (t.result_submitted && !t.result_verified)
+        return "result_submitted_unverified";
+    if (t.result_submitted) {
+        if (t.completion === "declined")
+            return "result_submitted_completion_declined";
+        if (t.completion === "revision_requested")
+            return "result_submitted_revision_requested";
+        return "result_submitted_awaiting_completion_approval";
+    }
+    if (t.running === "evidence")
+        return "running";
+    if (t.delivered)
+        return "delivered";
+    if (t.queued)
+        return "queued";
+    return t.approved ? "approved" : (standing?.stage ?? "recorded");
+}
+function pendingGates(record, records, result, approvalUrl) {
+    const gates = [];
+    const url = (id) => (approvalUrl ? { approval_url: approvalUrl(id) } : {});
+    if (record.approval_state === "awaiting_approval")
+        gates.push({ gate: "run_approval", record: record.id, ...url(record.id) });
+    if (result.current && result.current.decision === "pending_approval") {
+        gates.push({ gate: result.verified ? "completion_approval" : "unverified_completion_approval", record: result.current.record, ...url(result.current.record) });
+    }
+    for (const r of records) {
+        if (r.kind === "session_steer_request" && r.approval_state === "awaiting_approval" && r.refs.includes(record.id))
+            gates.push({ gate: "steer_approval", record: r.id, ...url(r.id) });
+    }
+    return gates;
+}

package/dist/steer.d.ts

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
 import type { ConnectorRecord } from "./records.js";
-export declare const STEER_STATUSES: readonly ["prepared", "submitted", "accepted", "busy", "blocked", "wrong_pane", "stale_binding", "expired_grant", "duplicate"];
+export declare const STEER_STATUSES: readonly ["prepared", "submitted", "accepted", "busy", "blocked", "wrong_pane", "stale_binding", "expired_grant", "duplicate", "composing"];
 export type SteerStatus = (typeof STEER_STATUSES)[number];
 /** The steering grant an approved run carries: `body.steering` on the run_request or work proposal. */
 export interface SteeringGrant {
@@ -25,18 +25,39 @@ export interface TmuxLike {
     capture(target: string): string;
     sendLiteral(target: string, text: string): void;
     sendEnter(target: string): void;
+    /** Whether the tmux server answers at all. False means the transport is down: no steer is recorded or counted. */
+    available?(): boolean;
+    /** Every live tmux session name. */
+    listSessions?(): string[];
 }
 /** Commands that mark a pane as an agent seat a steer may land in. */
 export declare const AGENT_COMMANDS: string[];
 /** Signs a seat is mid-turn; typed text would queue behind its work. */
 export declare const BUSY_PATTERNS: RegExp[];
+/**
+ * An exact tmux target. Without the `=` prefix tmux matches a session name by its start, so
+ * `mission-x` reaches `mission-x-miette-insight` once `mission-x` has gone (jgwill/Miadi#922 R1).
+ * `=name:` is a session, `=name:w.p` a pane; tmux 3.7 still prefix-matches a bare `=name` for list-panes.
+ */
+export declare function exactTarget(target: string): string;
 /** The production adapter. All tmux addressing is by exact session and window.pane. */
 export declare function tmuxAdapter(exec?: typeof execFileSync): TmuxLike;
+/**
+ * The text a person (or anyone) left at the agent's prompt: the region between the last two
+ * horizontal rules of the Claude TUI, without its furniture. The same reading as the factory's
+ * pane-write-guard.sh. Empty when the prompt is clear or the pane has no such box.
+ */
+export declare function composingText(capture: string): string | null;
 export declare function steeringGrantOf(run: ConnectorRecord): SteeringGrant | null;
 export type GrantCheck = "ok" | "no_grant" | "expired_grant" | "duplicate";
 /** Whether a grant covers one more steer. `priorAttempts` counts the steers already run under it. */
 export declare function checkGrant(grant: SteeringGrant | null, priorAttempts: number, now?: Date): GrantCheck;
-/** Steers already run under a grant: decided (or grant-covered) steer records that cite it. */
+/**
+ * Steers already run under a grant: decided (or grant-covered) steer records that cite it and
+ * typed their instruction (jgwill/Miadi#909). A steer stopped before typing (busy, composing,
+ * wrong or stale pane, transport down) uses none of the grant's attempts. Receipts made before
+ * `typed` was recorded count when their outcome says the text was delivered.
+ */
 export declare function steerAttempts(records: ConnectorRecord[], grantId: string): number;
 export declare function isBusy(capture: string, patterns?: RegExp[]): boolean;
 export interface SteerDeps {
@@ -51,6 +72,8 @@ export interface SteerResult {
     status: SteerStatus;
     message: string;
     target?: string;
+    /** Whether the instruction was typed into the pane. Only a typed steer uses one of the grant's attempts. */
+    typed: boolean;
     artifact?: {
         file: string;
         sha256: string;
@@ -68,4 +91,13 @@ export declare function steerSession(deps: SteerDeps, args: {
     grantRecord: ConnectorRecord;
     priorAttempts: number;
     authorized?: boolean;
+    /**
+     * The binding the factory runner recorded for this mission (jgwill/Miadi#909): the tmux
+     * session and the pane id the brief was typed into. With it, the steer goes to that pane and
+     * nowhere else; a session or pane that does not match is refused before anything is typed.
+     */
+    binding?: {
+        session: string;
+        pane_id?: string;
+    };
 }): Promise<SteerResult>;

package/dist/steer.js

@@ -28,17 +28,32 @@ export const STEER_STATUSES = [
     "stale_binding",
     "expired_grant",
     "duplicate",
+    "composing",
 ];
 /** Commands that mark a pane as an agent seat a steer may land in. */
 export const AGENT_COMMANDS = ["claude", "codex", "copilot", "pi", "gemini", "node"];
 /** Signs a seat is mid-turn; typed text would queue behind its work. */
-export const BUSY_PATTERNS = [/esc (to )?interrupt/i, /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/, /\bWorking\b/, /\bThinking\b/];
+// The last pattern is Claude Code's spinner on a narrow pane that cuts "esc to interrupt": a glyph,
+// then one verb ending in "…" ("✽ Cerebrating… (3s)"); an answered turn reads "✻ Cooked for 18s".
+// The same reading as the factory's pane-write-guard.sh (etc-claude-code dispatch-discipline).
+export const BUSY_PATTERNS = [/esc (to )?interrupt/i, /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/, /\bWorking\b/, /\bThinking\b/, /^\s*(·|✢|✳|✶|✻|✽|\*) [^ …]+…/m];
+/**
+ * An exact tmux target. Without the `=` prefix tmux matches a session name by its start, so
+ * `mission-x` reaches `mission-x-miette-insight` once `mission-x` has gone (jgwill/Miadi#922 R1).
+ * `=name:` is a session, `=name:w.p` a pane; tmux 3.7 still prefix-matches a bare `=name` for list-panes.
+ */
+export function exactTarget(target) {
+    if (target.startsWith("=") || target.startsWith("%"))
+        return target;
+    const colon = target.indexOf(":");
+    return colon < 0 ? `=${target}:` : `=${target}`;
+}
 /** The production adapter. All tmux addressing is by exact session and window.pane. */
 export function tmuxAdapter(exec = execFileSync) {
     const tmux = (args) => exec("tmux", args, { encoding: "utf8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"] });
     return {
         listPanes(session) {
-            const out = tmux(["list-panes", "-s", "-t", session, "-F", "#{pane_id}\t#{window_index}\t#{pane_index}\t#{pane_current_command}\t#{pane_active}"]);
+            const out = tmux(["list-panes", "-s", "-t", exactTarget(session), "-F", "#{pane_id}\t#{window_index}\t#{pane_index}\t#{pane_current_command}\t#{pane_active}"]);
             return out
                 .split("\n")
                 .filter(Boolean)
@@ -49,17 +64,51 @@ export function tmuxAdapter(exec = execFileSync) {
                 .sort((a, b) => a.window - b.window || a.pane - b.pane);
         },
         capture(target) {
-            return tmux(["capture-pane", "-p", "-t", target]);
+            return tmux(["capture-pane", "-p", "-t", exactTarget(target)]);
         },
         // -l: the text is literal; no tmux key names in an instruction are interpreted.
         sendLiteral(target, text) {
-            tmux(["send-keys", "-t", target, "-l", "--", text]);
+            tmux(["send-keys", "-t", exactTarget(target), "-l", "--", text]);
         },
         sendEnter(target) {
-            tmux(["send-keys", "-t", target, "Enter"]);
+            tmux(["send-keys", "-t", exactTarget(target), "Enter"]);
+        },
+        // tmux exits when its last session closes, so "no server" and "no session" are one answer: nothing to steer.
+        available() {
+            try {
+                tmux(["list-sessions", "-F", "#{session_name}"]);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        // Throws when the server cannot be listed: the caller reports unknown, never absent.
+        listSessions() {
+            return tmux(["list-sessions", "-F", "#{session_name}"]).split("\n").filter(Boolean);
         },
     };
 }
+/**
+ * The text a person (or anyone) left at the agent's prompt: the region between the last two
+ * horizontal rules of the Claude TUI, without its furniture. The same reading as the factory's
+ * pane-write-guard.sh. Empty when the prompt is clear or the pane has no such box.
+ */
+export function composingText(capture) {
+    const lines = capture.split("\n");
+    const rules = lines.map((l, i) => (/[─━]{10,}/.test(l) ? i : -1)).filter((i) => i >= 0);
+    // No input box: whether someone is writing cannot be told, so the caller types nothing (#922 R7).
+    if (rules.length < 2)
+        return null;
+    const region = lines.slice(rules[rules.length - 2] + 1, rules[rules.length - 1]);
+    return region
+        .map((l) => l.replace(/\u00a0/g, " ").trim().replace(/^[❯>]\s*/, "").trim())
+        // Only whole status lines are furniture; words a person typed are never dropped for containing them (#922 R6).
+        .filter((l) => l && !STATUS_LINE.test(l))
+        .join("\n");
+}
+/** A whole TUI status line, never a phrase inside someone's text: the mode line, or the bare /rc echo. */
+const STATUS_LINE = /^(?:(?:⏵⏵|⏸)\s.*|\/rc|\(?esc to interrupt\)?)$/i;
 export function steeringGrantOf(run) {
     const g = run.body.steering;
     if (!g || typeof g !== "object")
@@ -81,12 +130,26 @@ export function checkGrant(grant, priorAttempts, now = new Date()) {
         return "duplicate";
     return "ok";
 }
-/** Steers already run under a grant: decided (or grant-covered) steer records that cite it. */
+/**
+ * Steers already run under a grant: decided (or grant-covered) steer records that cite it and
+ * typed their instruction (jgwill/Miadi#909). A steer stopped before typing (busy, composing,
+ * wrong or stale pane, transport down) uses none of the grant's attempts. Receipts made before
+ * `typed` was recorded count when their outcome says the text was delivered.
+ */
 export function steerAttempts(records, grantId) {
-    return records.filter((r) => r.kind === "session_steer_request" &&
-        r.refs.includes(grantId) &&
-        (r.approval_state === "approved" || r.approval_state === "not_required") &&
-        r.completion_receipt !== undefined).length;
+    return records.filter((r) => {
+        if (r.kind !== "session_steer_request" || !r.refs.includes(grantId))
+            return false;
+        if (r.approval_state !== "approved" && r.approval_state !== "not_required")
+            return false;
+        const receipt = r.completion_receipt;
+        if (!receipt)
+            return false;
+        if (typeof receipt.typed === "boolean")
+            return receipt.typed;
+        const outcome = String(receipt.steer_status ?? receipt.outcome ?? "");
+        return outcome === "accepted" || outcome === "submitted";
+    }).length;
 }
 const targetName = (session, pane) => `${session}:${pane.window}.${pane.pane}`;
 export function isBusy(capture, patterns = BUSY_PATTERNS) {
@@ -130,7 +193,8 @@ export async function steerSession(deps, args) {
     const grant = steeringGrantOf(grantRecord);
     const instruction = String(body.instruction ?? "");
     const grantSession = String(grantRecord.body.session ?? "") || undefined;
-    const session = body.session ?? grantSession;
+    const session = body.session ?? args.binding?.session ?? grantSession;
+    let typed = false;
     const finish = (status, message, extra = {}, target) => {
         const artifact = persistArtifact(deps.stateDir, record.id, {
             record: record.id,
@@ -139,18 +203,23 @@ export async function steerSession(deps, args) {
             session,
             status,
             message,
+            typed,
+            ...(args.binding ? { binding: args.binding } : {}),
             at: now().toISOString(),
             ...extra,
         });
-        return { status, message, ...(target ? { target } : {}), artifact };
+        return { status, message, typed, ...(target ? { target } : {}), artifact };
     };
     if (!instruction.trim())
-        return { status: "blocked", message: "The steer carries no instruction." };
+        return { status: "blocked", message: "The steer carries no instruction.", typed: false };
     if (!session)
         return finish("stale_binding", "Neither the steer nor its grant names a session; a steer never targets whichever pane is active.");
     if (body.session && grantSession && body.session !== grantSession) {
         return finish("stale_binding", `The steer names session "${body.session}" but its grant covers "${grantSession}".`);
     }
+    if (args.binding && session !== args.binding.session) {
+        return finish("stale_binding", `The steer names session "${session}" but the factory delivered this mission to "${args.binding.session}"; nothing was typed.`);
+    }
     // A person's approval of this exact steer covers one attempt even when the
     // run's grant is exhausted; without it, the grant's own limits decide.
     if (!args.authorized) {
@@ -171,12 +240,21 @@ export async function steerSession(deps, args) {
     if (!panes.length)
         return finish("stale_binding", `Session "${session}" has no panes; the binding is stale.`, {}, session);
     const wanted = body.pane ?? grant?.pane;
+    const boundId = args.binding?.pane_id;
     let pane;
     if (wanted) {
         const [w, p] = wanted.split(".").map(Number);
         pane = panes.find((x) => x.window === w && x.pane === p);
         if (!pane)
             return finish("stale_binding", `Pane ${wanted} of "${session}" is gone (stale or renumbered); nothing was typed anywhere else.`, {}, session);
+        if (boundId && pane.id !== boundId) {
+            return finish("wrong_pane", `Pane ${wanted} of "${session}" is ${pane.id}, not ${boundId}, the pane the factory bound to this mission; nothing was typed.`, { pane: { ...pane } }, targetName(session, pane));
+        }
+    }
+    else if (boundId) {
+        pane = panes.find((x) => x.id === boundId);
+        if (!pane)
+            return finish("stale_binding", `The pane the factory bound to this mission, ${boundId}, is no longer in "${session}" (the seat was replaced or restored); nothing was typed.`, {}, session);
     }
     else {
         pane = panes[0]; // listPanes is sorted: lowest window, lowest pane (jgwill/Miadi#725).
@@ -195,8 +273,26 @@ export async function steerSession(deps, args) {
     if (isBusy(before)) {
         return finish("busy", `The agent in ${target} is mid-turn; the steer was not typed. Ask again when it is idle.`, { peek: before.split("\n").slice(-CAPTURE_LINES) }, target);
     }
-    deps.tmux.sendLiteral(target, instruction);
-    deps.tmux.sendEnter(target);
+    const composing = composingText(before);
+    if (composing === null) {
+        return finish("blocked", `The prompt box of ${target} (${pane.command}) cannot be read, so whether someone is writing there cannot be told. Nothing was typed.`, { peek: before.split("\n").slice(-CAPTURE_LINES) }, target);
+    }
+    if (composing) {
+        return finish("composing", `Text already sits at the prompt in ${target}; someone may be writing. Nothing was typed and Enter was not pressed.`, { peek: before.split("\n").slice(-CAPTURE_LINES) }, target);
+    }
+    try {
+        deps.tmux.sendLiteral(target, instruction);
+    }
+    catch (error) {
+        return finish("blocked", `tmux refused the text for ${target} (${error instanceof Error ? error.message : String(error)}); nothing was typed.`, { peek: before.split("\n").slice(-CAPTURE_LINES) }, target);
+    }
+    typed = true;
+    try {
+        deps.tmux.sendEnter(target);
+    }
+    catch (error) {
+        return finish("submitted", `Typed into ${target}, but Enter failed (${error instanceof Error ? error.message : String(error)}); the text may sit at the prompt.`, { peek: before.split("\n").slice(-CAPTURE_LINES) }, target);
+    }
     await sleep(deps.settleMs ?? 4000);
     let after;
     try {

package/dist/tools.d.ts

@@ -10,6 +10,7 @@ import { type DecisionTokens } from "./decisions.js";
 import { type DiscoveryProbe, type ProviderId } from "./providers.js";
 import { type JevAdapter } from "./model-preflight.js";
 import { type TmuxLike } from "./steer.js";
+import { type GithubGet } from "./mission-result.js";
 export interface ToolContext {
     config: ConnectorConfig;
     miadi: MiadiClient;
@@ -39,6 +40,14 @@ export interface ToolContext {
  * ever reported as not found.
  */
 export declare function githubAccess(status: number, hasToken: boolean): string;
+/** A GitHub REST read as the connector can make it: GITHUB_TOKEN when the host has one, else anonymous. */
+export declare function githubGetter(fetchImpl?: typeof fetch, token?: string | undefined): GithubGet;
+/** Whether the steering transport works now: registered is not operational (jgwill/Miadi#909). */
+export declare function steeringTransport(tmux: TmuxLike | undefined): {
+    tool: "registered";
+    transport: "operational" | "unavailable";
+    reason?: string;
+};
 export declare function registerTools(server: McpServer, ctx: ToolContext): void;
 /** What get_capabilities reports for each tool. */
 export declare const TOOL_STATUS: Record<string, string>;