@miadi/connector 0.1.15 → 0.1.16

package/README.md

@@ -56,7 +56,11 @@ Requests made before this, one new request per revision, are joined with `supers
 
 A mission is found by the issue it implements (jgwill/Miadi#913). `request_authorized_run` and `propose_work` take `primary_issue`; older requests are read by their first issue ref, as an inference. An issue held as primary by several requests answers `ambiguous_mission` with the candidates, an issue only cited answers `related_only`, and only a record id or a declared primary that no older request holds by inference (`contested`) authorizes a steer, release or closure (`identity.authorizes_actions`). A release receipt names artifact, target, production check and check time; record it as `completion_receipt.release` on a handoff that cites the mission. `released` is `verified` only when the connector confirms it itself (the target is `miadi-connector` and the running version is the one released); any other complete receipt within seven days is `receipt_recorded`, with who recorded it and whether that was the approver. Old checks are `stale`; a version string, a future date or an incomplete receipt is `claimed_unverified`. `closed` needs an approved `propose_session_completion` ending (`exit` or `complete_then_exit`) that names the mission in its `mission` field and ends one of the mission's sessions; a completed request is `request_completed`. A GitHub reference the connector cannot read is `unverified`, with the reason (`no_github_token`, `not_visible_to_token`…), never `not_found`.
 
-`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. A steer the grant does not cover waits for one explicit scoped human decision on its `approval_url`, which runs exactly that instruction once.
+**The factory binding (jgwill/Miadi#909).** The factory runner records every brief it hands to a seat in `delivered.jsonl`: the record, the tmux session, the pane id and the Claude Code session id that took the line. `mission_status` reads that receipt (write tier) and checks it against Miadi's session registry: `binding` is `verified` when both agree on session, tmux session and pane, `receipt_only` when the registry cannot confirm it, `unverified_association` when the registry places the session elsewhere or the pane is gone. Busy or idle comes from the registry when the binding is verified, else from a read-only peek of the bound pane, and is never read as completion. `mission_status` with `session:<uuid>` finds the one mission the factory delivered to that session (`factory_bound`); two are `ambiguous_mission`. `provider` names the provider requested, resolved and actually run, and `match: false` when they differ; nothing is re-run because of it. `get_session` lists the missions the factory delivered to the session.
+
+**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_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.
 

package/dist/approve.js

@@ -19,6 +19,7 @@ import { MiadiUnavailable } from "./people.js";
 import { current, newRecordId } from "./records.js";
 import { APPROVABLE, projectRequest } from "./request-state.js";
 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";
 export { factoryDir, runBriefFile, readQueueState } from "./queue-state.js";
@@ -108,6 +109,8 @@ export function runBrief(record, approver, sessions, instructions) {
             : []),
         "",
         "When it is done, reply with what was achieved, the evidence (commits, paths, URLs), what is still open, and whether this session should end. Then record the receipt through the connector's update_handoff if a handoff names this record, and end the session per its lifecycle.",
+        // The return path a requester reads by the mission id (jgwill/Miadi#921).
+        `Return the result to the requester with the connector's propose_session_completion: your Claude Code session id as session_id, mission "${text(record.id)}", the ending, the reason, evidence_refs, and result { summary, outputs (ref, label, git_sha), tests (command, passed, failed), blockers }. mission_status and get_run_result read it back by the mission id; a person decides the ending.`,
         "",
         "Queued by the Miadi connector's approval door, delivered by the factory runner (@miadi/factory-runner).",
         "</input>",
@@ -150,7 +153,15 @@ export async function executeApproved(record, approver, deps, instructions) {
     const queueBrief = () => {
         const queue = join(deps.factoryDir ?? factoryDir(), "queue");
         mkdirSync(queue, { recursive: true });
-        const { to, brief } = runBrief(record, approver, (deps.tmuxSessions ?? liveTmux)(), instructions);
+        // A lister that cannot answer means no session is known live: the brief opens a new one (#922 R16).
+        let sessions;
+        try {
+            sessions = (deps.tmuxSessions ?? liveTmux)();
+        }
+        catch {
+            sessions = [];
+        }
+        const { to, brief } = runBrief(record, approver, sessions, instructions);
         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." };
@@ -221,11 +232,20 @@ export async function executeApproved(record, approver, deps, instructions) {
             const grantRecord = grantId ? current(deps.ledger.all()).find((x) => x.id === grantId) : undefined;
             if (!grantRecord)
                 return { outcome: "failed", message: "The run whose grant this steer cites is gone." };
-            const result = await steerSession({ tmux: deps.tmux ?? tmuxAdapter(), stateDir: deps.config.stateDir, ...(deps.steerSettleMs !== undefined ? { settleMs: deps.steerSettleMs } : {}) }, { record, grantRecord, priorAttempts: steerAttempts(current(deps.ledger.all()), grantRecord.id), authorized: true });
-            const delivered = result.status === "accepted" || result.status === "submitted";
+            // 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 } : {}) }, {
+                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 } : {}) } } : {}),
+            });
+            // A typed steer is never "failed": failed is re-runnable, and that would type it twice (#922 R8).
             return {
-                outcome: delivered ? result.status : "failed",
+                outcome: result.typed ? result.status : "failed",
                 steer_status: result.status,
+                typed: result.typed,
                 message: result.message,
                 ...(result.target ? { target: result.target } : {}),
                 ...(result.artifact ? { artifact: result.artifact } : {}),

package/dist/bin.js

@@ -2,13 +2,24 @@
 import { configFromEnv } from "./config.js";
 import { createConnectorApp } from "./server.js";
 import { identifyThroughMiadi } from "./people.js";
+import { steeringTransport } from "./tools.js";
+import { tmuxAdapter } from "./steer.js";
 import { VERSION } from "./version.js";
 const config = configFromEnv();
-const { app } = createConnectorApp(config, { identify: identifyThroughMiadi(config.miadiUrl) });
+// The host's steering surface (jgwill/Miadi#909): the tmux server of the user the service runs as,
+// reached only through request_session_steer inside an approved grant, at the mission's bound pane.
+const tmux = tmuxAdapter();
+const { app } = createConnectorApp(config, {
+    identify: identifyThroughMiadi(config.miadiUrl),
+    tmux,
+    tmuxSessions: () => tmux.listSessions(),
+});
 app.listen(config.port, config.host, () => {
     console.log(`@miadi/connector ${VERSION} on http://${config.host}:${config.port}`);
     console.log(`  public:  ${config.publicUrl}/mcp`);
     console.log(`  miadi:   ${config.miadiUrl}`);
     console.log(`  reviews: ${config.reviewUrl} (search ${config.reviewToken ? "enabled" : "disabled: no MIADI_REVIEW_TOKEN"})`);
     console.log(`  state:   ${config.stateDir}`);
+    const steering = steeringTransport(tmux);
+    console.log(`  steering: ${steering.transport}${steering.reason ? ` (${steering.reason})` : ""}`);
 });

package/dist/factory-receipt.d.ts

@@ -0,0 +1,28 @@
+export interface FactoryReceipt {
+    /** The runner's dedupe key for the delivered block. */
+    key: string;
+    /** When the runner recorded the delivery. */
+    at: string;
+    /** The connector record the brief carried, e.g. run_request:<uuid>. */
+    record: string;
+    /** The tmux session the brief went to (without the runner's `new:` prefix). */
+    tmux_session: string;
+    /** Whether the runner opened that session for this brief. */
+    created: boolean;
+    /** tmux pane id the line was typed into, e.g. %140. */
+    pane_id?: string;
+    /** Claude Code session id the runner saw take the line. */
+    session_id?: string;
+    provider?: string;
+    launcher?: string;
+    /** The brief file the line pointed the seat at. */
+    brief?: string;
+}
+/** The runner's ledger file: MIADI_FACTORY_LEDGER, else `<factory>/delivered.jsonl`, as the runner resolves it. */
+export declare function factoryLedgerPath(dir?: string, env?: NodeJS.ProcessEnv): string;
+/** Every delivery the runner recorded as sent, oldest first. Unreadable or malformed lines are skipped, never guessed. */
+export declare function readFactoryReceipts(file: string): FactoryReceipt[];
+/** The receipts for one connector record, newest first. */
+export declare function receiptsForRecord(receipts: FactoryReceipt[], recordId: string): FactoryReceipt[];
+/** The distinct records delivered to one Claude Code session id. */
+export declare function recordsForSession(receipts: FactoryReceipt[], sessionId: string): string[];

package/dist/factory-receipt.js

@@ -0,0 +1,69 @@
+/**
+ * The factory runner's delivery receipts (jgwill/Miadi#911, read here for #909 and #921).
+ *
+ * `@miadi/factory-runner` appends one line to `<factory>/delivered.jsonl` for every
+ * brief it hands to a seat: the connector record it carried, the tmux session it
+ * went to, the pane, and the Claude Code session id the runner saw take the line
+ * (from Claude's own session registry and transcript, deliver.js `submitLine`).
+ * That line is the binding between an approved run and the agent that runs it.
+ * The connector only reads it: a receipt never dispatches, steers or closes.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { factoryDir } from "./queue-state.js";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const str = (v) => (typeof v === "string" && v.trim() ? v.trim() : undefined);
+/** The runner's ledger file: MIADI_FACTORY_LEDGER, else `<factory>/delivered.jsonl`, as the runner resolves it. */
+export function factoryLedgerPath(dir = factoryDir(), env = process.env) {
+    return env.MIADI_FACTORY_LEDGER || join(dir, "delivered.jsonl");
+}
+/** Every delivery the runner recorded as sent, oldest first. Unreadable or malformed lines are skipped, never guessed. */
+export function readFactoryReceipts(file) {
+    if (!existsSync(file))
+        return [];
+    let text;
+    try {
+        text = readFileSync(file, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        let r;
+        try {
+            r = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const record = str(r.record);
+        const to = str(r.to)?.replace(/^new:/, "");
+        if (r.sent !== true || !record || !to)
+            continue;
+        const sessionId = str(r.session_id);
+        out.push({
+            key: str(r.key) ?? "",
+            at: str(r.at) ?? "",
+            record,
+            tmux_session: to,
+            created: r.created === true,
+            ...(str(r.pane) ? { pane_id: str(r.pane) } : {}),
+            ...(sessionId && UUID.test(sessionId) ? { session_id: sessionId } : {}),
+            ...(str(r.provider) ? { provider: str(r.provider) } : {}),
+            ...(str(r.launcher) ? { launcher: str(r.launcher) } : {}),
+            ...(str(r.brief) ? { brief: str(r.brief) } : {}),
+        });
+    }
+    return out;
+}
+/** The receipts for one connector record, newest first. */
+export function receiptsForRecord(receipts, recordId) {
+    return receipts.filter((r) => r.record === recordId).sort((a, b) => b.at.localeCompare(a.at));
+}
+/** The distinct records delivered to one Claude Code session id. */
+export function recordsForSession(receipts, sessionId) {
+    return [...new Set(receipts.filter((r) => r.session_id === sessionId).map((r) => r.record))];
+}

package/dist/index.d.ts

@@ -3,10 +3,12 @@ export { configFromEnv, type ConnectorConfig } from "./config.js";
 export { identifyThroughMiadi, MiadiUnavailable, type MiadiPerson, type ApiTier } from "./people.js";
 export { MiadiOAuthProvider, SCOPES, SCOPE_READ, SCOPE_CONTRIBUTE, type Person } from "./oauth.js";
 export { CIRCLES, CIRCLE_IDS, CLAIM_CATEGORIES, DOMAINS, HANDOFF_STATES, RECORD_KINDS, current, type ConnectorRecord, type CircleId, type ClaimCategory, type RecordKind, } from "./records.js";
-export { TOOL_STATUS } from "./tools.js";
+export { TOOL_STATUS, githubGetter, steeringTransport } from "./tools.js";
+export { factoryLedgerPath, readFactoryReceipts, receiptsForRecord, recordsForSession, type FactoryReceipt } from "./factory-receipt.js";
+export { classifyOutput, missionResult, type GithubAnswer, type GithubGet, type MissionOutput, type MissionResult, type OutputCheck, type ResultSubmission, } from "./mission-result.js";
 export { runBrief, readQueueState } from "./approve.js";
 export { PROVIDERS, discoverProviders, jevConfigOf, resolveProvider, routerPreflight, type JevConfig, type ProviderAvailability, type ProviderId, type ProviderResolution, type RouterPreflight, } from "./providers.js";
-export { missionStatus, primaryIssueOf, resolveMissionSubject, type MissionStatus, type MissionStatusDeps, type MissionIdentity } from "./mission-status.js";
+export { missionStage, missionStatus, primaryIssueOf, resolveMissionSubject, type MissionIdentity, type MissionProvider, type MissionSession, type MissionStatus, type MissionStatusDeps, } from "./mission-status.js";
 export { modelPreflight, candidatesFor, buildJevRequest, decisionState, jevAdapter, reviewFloor, PREFLIGHT_CONTRACT, PREFLIGHT_VERSION, JEV_CONFIDENCE_FLOOR, type ModelPreflight, type ModelCandidate, type JevAdapter, type JevRequest, } from "./model-preflight.js";
-export { AGENT_COMMANDS, BUSY_PATTERNS, STEER_STATUSES, checkGrant, isBusy, readSteerArtifact, steerAttempts, steerSession, steeringGrantOf, tmuxAdapter, type SteerDeps, type SteerResult, type SteerStatus, type SteeringGrant, type TmuxLike, } from "./steer.js";
+export { AGENT_COMMANDS, BUSY_PATTERNS, STEER_STATUSES, checkGrant, composingText, isBusy, readSteerArtifact, steerAttempts, steerSession, steeringGrantOf, tmuxAdapter, type SteerDeps, type SteerResult, type SteerStatus, type SteeringGrant, type TmuxLike, } from "./steer.js";
 export { VERSION } from "./version.js";

package/dist/index.js

@@ -3,10 +3,12 @@ export { configFromEnv } from "./config.js";
 export { identifyThroughMiadi, MiadiUnavailable } from "./people.js";
 export { MiadiOAuthProvider, SCOPES, SCOPE_READ, SCOPE_CONTRIBUTE } from "./oauth.js";
 export { CIRCLES, CIRCLE_IDS, CLAIM_CATEGORIES, DOMAINS, HANDOFF_STATES, RECORD_KINDS, current, } from "./records.js";
-export { TOOL_STATUS } from "./tools.js";
+export { TOOL_STATUS, githubGetter, steeringTransport } from "./tools.js";
+export { factoryLedgerPath, readFactoryReceipts, receiptsForRecord, recordsForSession } from "./factory-receipt.js";
+export { classifyOutput, missionResult, } from "./mission-result.js";
 export { runBrief, readQueueState } from "./approve.js";
 export { PROVIDERS, discoverProviders, jevConfigOf, resolveProvider, routerPreflight, } from "./providers.js";
-export { missionStatus, primaryIssueOf, resolveMissionSubject } from "./mission-status.js";
+export { missionStage, missionStatus, primaryIssueOf, resolveMissionSubject, } from "./mission-status.js";
 export { modelPreflight, candidatesFor, buildJevRequest, decisionState, jevAdapter, reviewFloor, PREFLIGHT_CONTRACT, PREFLIGHT_VERSION, JEV_CONFIDENCE_FLOOR, } from "./model-preflight.js";
-export { AGENT_COMMANDS, BUSY_PATTERNS, STEER_STATUSES, checkGrant, isBusy, readSteerArtifact, steerAttempts, steerSession, steeringGrantOf, tmuxAdapter, } from "./steer.js";
+export { AGENT_COMMANDS, BUSY_PATTERNS, STEER_STATUSES, checkGrant, composingText, isBusy, readSteerArtifact, steerAttempts, steerSession, steeringGrantOf, tmuxAdapter, } from "./steer.js";
 export { VERSION } from "./version.js";

package/dist/mission-result.d.ts

@@ -0,0 +1,142 @@
+/**
+ * A mission's result, as its agent submitted it (jgwill/Miadi#921).
+ *
+ * The agent returns its work through the record it already makes at the end:
+ * `propose_session_completion` naming the mission in `mission`, with its reason,
+ * its evidence refs and, since 0.1.16, an optional structured `result` (summary,
+ * outputs with hashes, tests, blockers). This file joins those submissions to the
+ * mission by exact id and checks them:
+ *
+ * - A submission is `verified` when it names the mission, ends one of the sessions
+ *   the mission is bound to (the factory receipt's session id or a signed
+ *   `session:` ref) and was made with Miadi's write tier (the factory's writer
+ *   token included): a session id is a field anyone can type (#922 R3). Anything
+ *   else naming the mission is `unverified_association`; citing it only in refs is
+ *   `cited_only`. Only a verified submission sets the completion decision (#922 R4).
+ * - What the agent wrote (summary, tests, blockers) is the agent's claim. Outputs
+ *   on GitHub are checked through GitHub as the connector can read it; a reference
+ *   it cannot read is `unverified` with the reason, never `not_found`.
+ * - The completion decision stays the person's: pending, accepted, declined or
+ *   sent back, read from the proposal's own decision. An idle pane is none of these.
+ */
+import type { ConnectorRecord } from "./records.js";
+export type GithubAnswer = {
+    ok: true;
+    json: any;
+} | {
+    ok: false;
+    status: number;
+    access: string;
+};
+/** GET a GitHub REST path (e.g. /repos/o/r/commits/sha) as the connector can read it. */
+export type GithubGet = (path: string) => Promise<GithubAnswer>;
+export type OutputType = "commit" | "file" | "issue_or_pr" | "review" | "episode_file" | "record" | "link" | "unrecognized";
+export interface OutputCheck {
+    /**
+     * verified: the connector read it now. changed_since_submission: it reads now, but its content
+     * changed after the agent submitted it. unverified: it could not be read (see access).
+     * not_found: a connector record id the ledger does not hold. unrecognized: not a reference the
+     * connector can resolve. not_checked: a kind the connector does not read here.
+     */
+    state: "verified" | "changed_since_submission" | "unverified" | "not_found" | "unrecognized" | "not_checked";
+    access?: string;
+    /** The commit sha, or the file's git blob sha, as read now. */
+    sha?: string;
+    size?: number;
+    committed_at?: string;
+    /** The file's latest commit on its ref, when its ref is a branch. */
+    last_changed_at?: string;
+    /** The ref is a branch, so the content behind the URL can move. */
+    ref_moves?: boolean;
+    checked_at: string;
+    note?: string;
+}
+export interface MissionOutput {
+    ref: string;
+    type: OutputType;
+    label?: string;
+    repository?: string;
+    commit?: string;
+    path?: string;
+    git_ref?: string;
+    /** The git sha the agent declared for it, when it declared one. */
+    declared_sha?: string;
+    check: OutputCheck;
+    /** How to read the whole of it, with the reader's own access. */
+    read?: string;
+}
+export type CompletionDecision = "pending_approval" | "accepted" | "declined" | "revision_requested";
+/** Why a submission is not verified, as a code a viewer of any tier may read. */
+export type AssociationReason = "cited_only" | "no_binding" | "not_bound_session" | "submitter_below_write_tier";
+export interface ResultSubmission {
+    record: string;
+    submitted_at: string;
+    submitted_by: {
+        name: string;
+        person_id: string;
+    };
+    /** verified: names this mission and ends one of its bound sessions. unverified_association: names it, from a session the mission is not bound to (or none to compare). cited_only: cites it in refs only. */
+    association: "verified" | "unverified_association" | "cited_only";
+    association_code?: AssociationReason;
+    association_reason?: string;
+    session_id?: string;
+    ending?: string;
+    decision: CompletionDecision;
+    decided_by?: string;
+    decided_at?: string;
+}
+export interface ResultTests {
+    /** agent_claim: the agent's own count. not_structured: no test receipt beyond the summary's words. */
+    state: "agent_claim" | "not_structured";
+    command?: string;
+    passed?: number;
+    failed?: number;
+    skipped?: number;
+    note?: string;
+}
+export interface MissionResult {
+    state: "no_result_submitted" | "submitted";
+    /** The standing submission is verified; only then does it set the completion decision. */
+    verified: boolean;
+    /** The submission that stands: the newest verified one, else the newest naming the mission. */
+    current?: ResultSubmission & {
+        /** The agent's own account: a claim, not a verification. */
+        summary: string;
+        summary_claim: "agent_claim";
+        outputs: MissionOutput[];
+        tests: ResultTests;
+        blockers: string[];
+        /** Where a write-tier person decides the ending, while it is pending. */
+        approval_url?: string;
+    };
+    /** Every record that submits or cites a result for this mission, newest first. */
+    submissions: ResultSubmission[];
+    /** The completion decision of the standing submission when it is verified; "none" otherwise. */
+    completion: CompletionDecision | "none";
+    notes: string[];
+}
+export interface MissionResultDeps {
+    githubGet?: GithubGet;
+    /** Whether the submitter of a record held Miadi's write tier when it was made. Default: the record says so. */
+    submittedWithWriteTier?: (r: ConnectorRecord) => boolean;
+    approvalUrl?: (id: string) => string;
+    now?: () => Date;
+}
+/** What one reference is, before anything is read. */
+export declare function classifyOutput(ref: string): Omit<MissionOutput, "check">;
+/**
+ * The result a mission's agent submitted, checked. `boundSessions` are the Claude
+ * Code session ids the mission is bound to (empty when the viewer may not see them).
+ */
+export declare function missionResult(mission: ConnectorRecord, records: ConnectorRecord[], boundSessions: Set<string>, deps?: MissionResultDeps): Promise<MissionResult>;
+/** Endings made before 0.1.16 carry no recorded tier; from this time on every ending carries one (#922 R18). */
+export declare const TIER_RECORDED_SINCE = "2026-11-05T00:00:00.000Z";
+/**
+ * Whether a submission was made with Miadi's write tier. The factory's writer token is write tier
+ * by construction. Since 0.1.16 the connector records the submitter's tier on every ending. An
+ * ending without it is trusted only when it is older than TIER_RECORDED_SINCE: nobody can add a
+ * tier to it now, and a newer one without a tier was not written by this connector.
+ */
+export declare function submittedWithWriteTier(r: ConnectorRecord): boolean;
+/** The result as a viewer below the write tier reads it: no session ids, which are operator data. */
+export declare function redactResult(result: MissionResult): MissionResult;