@miadi/connector 0.1.12 → 0.1.14

package/dist/revisions.d.ts

@@ -0,0 +1,110 @@
+import type { ConnectorRecord } from "./records.js";
+/** The kinds that open a session when approved, and the only ones revised in place. */
+export declare const REVISABLE_KINDS: ReadonlySet<string>;
+/** A request is revised only before a decision runs it: waiting, or sent back by its approver. */
+export declare const REVISABLE_STATES: ReadonlySet<string>;
+/** What a revision record carries beside the new content. */
+export interface RequestRevision {
+    /** The version this record makes current, counted across the lineage (2, 3, …). */
+    version: number;
+    previous_version: number;
+    reason: string;
+    /** The fields that differ from the previous version. */
+    changed: string[];
+    content_hash: string;
+    previous_hash: string;
+    author: {
+        person_id: string;
+        name: string;
+    };
+    at: string;
+}
+/** What a lineage record carries: the requests the standing one adopted as its earlier versions. */
+export interface RequestLineage {
+    adopted: string[];
+    reason: string;
+    author: {
+        person_id: string;
+        name: string;
+    };
+    at: string;
+}
+/** The fields that make a request's content: what a version is. */
+export declare const CONTENT_FIELDS: readonly ["intention", "circle", "refs", "body"];
+/** The content of a request version, as the hash and the history show it. */
+export declare function contentOf(r: Pick<ConnectorRecord, "kind" | "intention" | "circle" | "refs" | "body">): Record<string, unknown>;
+/** sha256 of the canonical JSON of a version's content. */
+export declare function contentHash(r: Pick<ConnectorRecord, "kind" | "intention" | "circle" | "refs" | "body">): string;
+/** The version a folded request is at: 1 for a request never revised. */
+export declare function versionOf(r: Pick<ConnectorRecord, "version"> | undefined): number;
+/** The names of the content fields (body fields by name) that differ between two versions. */
+export declare function changedFields(before: Record<string, unknown>, after: Record<string, unknown>): string[];
+/** One version of a request, as the history returns it. */
+export interface RequestVersion {
+    version: number;
+    /** The record whose content this version is: the request itself, a revision record, or an adopted request. */
+    record_id: string;
+    /** The request this version belongs to when it is not the standing one (an adopted, retired request). */
+    request_id: string;
+    at: string;
+    author: string;
+    reason?: string;
+    changed?: string[];
+    content_hash: string;
+    content: Record<string, unknown>;
+    current: boolean;
+}
+/**
+ * Every version of a request, oldest first, numbered across its lineage: the requests
+ * it adopted (each with its own versions) and then its own. `raw` is the unfolded ledger,
+ * `folded` the folded one (`current()`).
+ */
+export declare function requestHistory(id: string, raw: ConnectorRecord[], folded?: ConnectorRecord[]): RequestVersion[];
+/** A revision refused, with the code a tool answers. */
+export declare class RevisionRefused extends Error {
+    readonly code: "not_found" | "not_revisable" | "forbidden" | "stale_version" | "being_decided" | "no_change" | "invalid_request";
+    readonly detail?: Record<string, unknown> | undefined;
+    constructor(code: "not_found" | "not_revisable" | "forbidden" | "stale_version" | "being_decided" | "no_change" | "invalid_request", message: string, detail?: Record<string, unknown> | undefined);
+}
+/**
+ * The new record that revises a waiting request, or a refusal. `next` holds the new
+ * content (kind, intention, circle, refs, body); `live` is the folded request.
+ */
+export declare function revisionRecord(live: ConnectorRecord | undefined, next: {
+    intention?: string;
+    circle?: ConnectorRecord["circle"];
+    refs: string[];
+    body: Record<string, unknown>;
+}, o: {
+    id: string;
+    person: {
+        id: string;
+        name: string;
+        writer: boolean;
+    };
+    actor: ConnectorRecord["actor"];
+    expectedVersion: number;
+    reason: string;
+    beingDecided: boolean;
+    idempotency_key?: string;
+    now?: string;
+}): ConnectorRecord;
+/**
+ * The records that make `standingId` the one request of a lineage: one retirement for
+ * each named request still waiting, and one lineage record on the standing request.
+ * Every named request is checked before anything is written; one refusal writes none.
+ * Only a request named by its exact id is retired, never one that looks similar, and a
+ * request already decided (approved, queued, declined) is refused, never cancelled.
+ */
+export declare function supersedeRecords(folded: ConnectorRecord[], standingId: string, retire: string[], o: {
+    person: {
+        id: string;
+        name: string;
+        writer: boolean;
+    };
+    actor: ConnectorRecord["actor"];
+    reason: string;
+    beingDecided: (id: string) => boolean;
+    newId: (kind: ConnectorRecord["kind"]) => string;
+    now?: string;
+}): ConnectorRecord[];

package/dist/revisions.js

@@ -0,0 +1,245 @@
+/**
+ * One mission, many versions, one decision (jgwill/Miadi#919).
+ *
+ * A request that still waits for a decision is revised in place: a revision is a
+ * record appended to the ledger that supersedes the request and carries the whole
+ * new content, so the request keeps its id, its approval page and its card, and
+ * every earlier version stays readable verbatim. Requests made separately before
+ * this existed (one new request per revision) are joined by `supersedePending`: the
+ * request that stands adopts the others as its earlier versions, and each adopted
+ * one is retired, so only the standing request can be approved.
+ *
+ * A decision names the version it decides. The approval page and the card carry it,
+ * and a decision on any other version is refused as stale, so no brief is ever
+ * queued for a version the person did not read.
+ */
+import { createHash } from "node:crypto";
+/** The kinds that open a session when approved, and the only ones revised in place. */
+export const REVISABLE_KINDS = new Set(["run_request", "work_proposal"]);
+/** A request is revised only before a decision runs it: waiting, or sent back by its approver. */
+export const REVISABLE_STATES = new Set(["awaiting_approval", "revision_requested"]);
+/** The fields that make a request's content: what a version is. */
+export const CONTENT_FIELDS = ["intention", "circle", "refs", "body"];
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.keys(value)
+            .filter((k) => value[k] !== undefined)
+            .sort()
+            .map((k) => [k, canonical(value[k])]));
+    }
+    return value;
+}
+/** The content of a request version, as the hash and the history show it. */
+export function contentOf(r) {
+    return { kind: r.kind, intention: r.intention, circle: r.circle, refs: r.refs ?? [], body: r.body ?? {} };
+}
+/** sha256 of the canonical JSON of a version's content. */
+export function contentHash(r) {
+    return `sha256:${createHash("sha256").update(JSON.stringify(canonical(contentOf(r)))).digest("hex")}`;
+}
+/** The version a folded request is at: 1 for a request never revised. */
+export function versionOf(r) {
+    return typeof r?.version === "number" && r.version >= 1 ? r.version : 1;
+}
+/** The names of the content fields (body fields by name) that differ between two versions. */
+export function changedFields(before, after) {
+    const out = [];
+    const same = (a, b) => JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
+    for (const k of ["intention", "circle", "refs"])
+        if (!same(before[k], after[k]))
+            out.push(k);
+    const b = (before.body ?? {});
+    const a = (after.body ?? {});
+    for (const k of [...new Set([...Object.keys(b), ...Object.keys(a)])].sort())
+        if (!same(b[k], a[k]))
+            out.push(k);
+    return out;
+}
+/**
+ * Every version of a request, oldest first, numbered across its lineage: the requests
+ * it adopted (each with its own versions) and then its own. `raw` is the unfolded ledger,
+ * `folded` the folded one (`current()`).
+ */
+export function requestHistory(id, raw, folded = []) {
+    // `current` marks the version the request holds now: the last one.
+    const own = (rid, seen) => {
+        if (seen.has(rid))
+            return [];
+        seen.add(rid);
+        const base = raw.find((r) => r.id === rid);
+        if (!base)
+            return [];
+        const out = [];
+        const lineage = raw.filter((r) => r.supersedes === rid && r.lineage).flatMap((r) => r.lineage.adopted);
+        const adopted = lineage
+            .map((a) => raw.find((r) => r.id === a))
+            .filter((r) => !!r)
+            .sort((x, y) => x.created_at.localeCompare(y.created_at));
+        for (const a of adopted)
+            out.push(...own(a.id, seen));
+        out.push({ record_id: base.id, request_id: rid, at: base.created_at, author: base.actor?.name ?? "someone", content_hash: contentHash(base), content: contentOf(base) });
+        for (const rev of raw.filter((r) => r.supersedes === rid && r.revision)) {
+            out.push({
+                record_id: rev.id,
+                request_id: rid,
+                at: rev.revision.at,
+                author: rev.revision.author.name,
+                reason: rev.revision.reason,
+                changed: rev.revision.changed,
+                content_hash: rev.revision.content_hash,
+                content: contentOf(rev),
+            });
+        }
+        return out;
+    };
+    void folded;
+    const versions = own(id, new Set());
+    return versions.map((v, i) => ({ ...v, version: i + 1, current: i === versions.length - 1 }));
+}
+/** A revision refused, with the code a tool answers. */
+export class RevisionRefused extends Error {
+    code;
+    detail;
+    constructor(code, message, detail) {
+        super(message);
+        this.code = code;
+        this.detail = detail;
+    }
+}
+/**
+ * The new record that revises a waiting request, or a refusal. `next` holds the new
+ * content (kind, intention, circle, refs, body); `live` is the folded request.
+ */
+export function revisionRecord(live, next, o) {
+    if (!live)
+        throw new RevisionRefused("not_found", "No request with that id.");
+    if (!REVISABLE_KINDS.has(live.kind))
+        throw new RevisionRefused("invalid_request", `A ${live.kind} is not revised in place; only agent runs and work proposals are.`);
+    if (!o.person.writer && live.actor?.person_id !== o.person.id) {
+        throw new RevisionRefused("forbidden", "Only whoever asked, or a person with Miadi's write tier, revises a request.");
+    }
+    if (o.beingDecided)
+        throw new RevisionRefused("being_decided", "A decision on this request is being recorded; it cannot be revised now.");
+    if (!REVISABLE_STATES.has(live.approval_state ?? "")) {
+        throw new RevisionRefused("not_revisable", `This request is already ${live.approval_state ?? "decided"}. A change after a decision is a new request, or a steer of the session it opened (request_session_steer).`);
+    }
+    const current = versionOf(live);
+    if (o.expectedVersion !== current) {
+        throw new RevisionRefused("stale_version", `The request is at version ${current}, not ${o.expectedVersion}. Read it with get_request_history and revise version ${current}.`, {
+            current_version: current,
+        });
+    }
+    const before = contentOf(live);
+    const after = contentOf({ kind: live.kind, intention: next.intention, circle: next.circle, refs: next.refs, body: next.body });
+    const changed = changedFields(before, after);
+    if (!changed.length)
+        throw new RevisionRefused("no_change", `Version ${current} already says this; nothing was recorded.`, { current_version: current });
+    const at = o.now ?? new Date().toISOString();
+    const sentBack = live.approval_state === "revision_requested";
+    return {
+        id: o.id,
+        kind: live.kind,
+        created_at: at,
+        actor: o.actor,
+        refs: next.refs,
+        evidence_refs: [],
+        ...(next.intention !== undefined ? { intention: next.intention } : {}),
+        ...(next.circle !== undefined ? { circle: next.circle } : {}),
+        body: next.body,
+        supersedes: live.id,
+        approval_state: "awaiting_approval",
+        state: "pending",
+        next_action: `Awaiting a decision on version ${current + 1}.`,
+        ...(o.idempotency_key ? { idempotency_key: o.idempotency_key } : {}),
+        // A request sent back keeps the approver's instructions on its receipt, now as what the revision answers.
+        ...(sentBack && live.completion_receipt ? { completion_receipt: { ...live.completion_receipt, answered_by_version: current + 1 } } : {}),
+        revision: {
+            version: current + 1,
+            previous_version: current,
+            reason: o.reason,
+            changed,
+            content_hash: contentHash({ kind: live.kind, intention: next.intention, circle: next.circle, refs: next.refs, body: next.body }),
+            previous_hash: contentHash(live),
+            author: { person_id: o.person.id, name: o.person.name },
+            at,
+        },
+    };
+}
+/**
+ * The records that make `standingId` the one request of a lineage: one retirement for
+ * each named request still waiting, and one lineage record on the standing request.
+ * Every named request is checked before anything is written; one refusal writes none.
+ * Only a request named by its exact id is retired, never one that looks similar, and a
+ * request already decided (approved, queued, declined) is refused, never cancelled.
+ */
+export function supersedeRecords(folded, standingId, retire, o) {
+    const standing = folded.find((r) => r.id === standingId);
+    if (!standing)
+        throw new RevisionRefused("not_found", `No request ${standingId}.`);
+    if (!REVISABLE_KINDS.has(standing.kind))
+        throw new RevisionRefused("invalid_request", "Only agent runs and work proposals carry versions.");
+    if (!REVISABLE_STATES.has(standing.approval_state ?? "")) {
+        throw new RevisionRefused("not_revisable", `The request that stands is already ${standing.approval_state}; earlier versions are joined only to a request still waiting.`);
+    }
+    if (o.beingDecided(standingId))
+        throw new RevisionRefused("being_decided", "A decision on the request that stands is being recorded; nothing was retired.");
+    // Earlier requests come before the standing one's own versions: joined after an in-place revision,
+    // the numbers it was given would shift (#919 review F4).
+    if (versionOf(standing) > 1) {
+        throw new RevisionRefused("not_revisable", `The request that stands is already at version ${versionOf(standing)}: join earlier requests to it before revising it in place, or revise it instead.`);
+    }
+    const ids = [...new Set(retire.map((x) => x.trim()).filter(Boolean))];
+    if (!ids.length)
+        throw new RevisionRefused("invalid_request", "Name at least one earlier request by its exact id.");
+    if (ids.includes(standingId))
+        throw new RevisionRefused("invalid_request", "The request that stands cannot also be retired.");
+    const may = (r) => o.person.writer || r.actor?.person_id === o.person.id;
+    if (!may(standing))
+        throw new RevisionRefused("forbidden", "Only whoever asked, or a person with Miadi's write tier, joins versions of a request.");
+    const olds = [];
+    for (const id of ids) {
+        const r = folded.find((x) => x.id === id);
+        if (!r)
+            throw new RevisionRefused("not_found", `No request ${id}; nothing was retired.`);
+        if (r.kind !== standing.kind)
+            throw new RevisionRefused("invalid_request", `${id} is a ${r.kind}, the request that stands a ${standing.kind}; nothing was retired.`);
+        if (!may(r))
+            throw new RevisionRefused("forbidden", `${id} was asked by someone else; nothing was retired.`);
+        if (o.beingDecided(id))
+            throw new RevisionRefused("being_decided", `A decision on ${id} is being recorded; nothing was retired.`);
+        if (!REVISABLE_STATES.has(r.approval_state ?? "")) {
+            throw new RevisionRefused("not_revisable", `${id} is already ${r.approval_state}: a decided request is never retired. Nothing was retired.`);
+        }
+        olds.push(r);
+    }
+    const at = o.now ?? new Date().toISOString();
+    const by = { person_id: o.person.id, name: o.person.name };
+    const out = olds.map((r) => ({
+        id: o.newId(r.kind),
+        kind: r.kind,
+        created_at: at,
+        actor: o.actor,
+        refs: r.refs,
+        evidence_refs: [],
+        supersedes: r.id,
+        approval_state: "declined",
+        state: "withdrawn",
+        next_action: `Superseded by ${standingId}: decide that request instead.`,
+        completion_receipt: { decision: "superseded", superseded_by: standingId, decided_by: by, decided_at: at, via: o.actor.client_name ?? o.actor.client_id, reason: o.reason },
+        body: { decision: "superseded", superseded_by: standingId },
+    }));
+    out.push({
+        id: o.newId(standing.kind),
+        kind: standing.kind,
+        created_at: at,
+        actor: o.actor,
+        refs: standing.refs,
+        evidence_refs: [],
+        supersedes: standingId,
+        body: { decision: "lineage" },
+        lineage: { adopted: olds.map((r) => r.id), reason: o.reason, author: by, at },
+    });
+    return out;
+}

package/dist/server.d.ts

@@ -4,17 +4,21 @@ import { Ledger } from "./store.js";
 import type { ConnectorRecord } from "./records.js";
 import type { ConnectorConfig } from "./config.js";
 import type { TmuxLike } from "./steer.js";
-import type { DiscoveryProbe } from "./providers.js";
+import type { DiscoveryProbe, ProviderId } from "./providers.js";
+import type { JevAdapter } from "./model-preflight.js";
 export interface ConnectorDeps {
     identify: (token: string) => Promise<MiadiPerson | null>;
     fetchImpl?: typeof fetch;
-    /** The factory directory holding queue/ (default ~/.miadi/factory). */
+    /** The factory directory holding queue/ (default /srv/miadi/factory). */
     factoryDir?: string;
     tmuxSessions?: () => string[];
     /** The steering surface (jgwill/Miadi#893); tests inject a fake, production uses tmux. */
     tmux?: TmuxLike;
     /** Provider discovery probes (jgwill/Miadi#893); tests inject fakes. */
     providersProbe?: DiscoveryProbe;
+    /** A provider's configured default model and a Jev decider (jgwill/Miadi#913); tests inject fakes. */
+    modelOf?: (provider: ProviderId) => string | null;
+    jevAdapter?: JevAdapter;
     /** Re-peek delay after a steer is typed (default 4000ms; tests pass 0). */
     steerSettleMs?: number;
     /** Person-token attempts allowed per address in 15 minutes on each sign-in form (default 30). */
@@ -25,4 +29,4 @@ export declare function createConnectorApp(config: ConnectorConfig, deps: Connec
     provider: MiadiOAuthProvider;
     ledger: Ledger<ConnectorRecord>;
 };
-export declare const INSTRUCTIONS = "Miadi is a relational software factory: agent sessions, Miadi reviews of screenwalks, Chronicle episodes, talking circles and the five accountable circles (Story, Stewardship, Engineering, Evaluation, Continuity) across three domains (Creative, Ceremonial, Engineering).\n\nStart with get_capabilities: it says who you are signed in as, which tools are live, and which return not_implemented.\n\nRules every tool keeps:\n- Every record names the person who made it, with a claim category: observed, hypothesis, desired_future, fiction or verified_implementation. Keep fiction and desired futures apart from what was observed.\n- Requests (runs, work proposals, review operations, Deep Diver, review-to-episode links, inquiry-to-episode weaves, session completion) are recorded as awaiting_approval. Nothing runs, publishes or closes until a person decides. After making a request, call show_decisions: it shows the request as a card in the conversation, where the person decides with their own click (or follows its approval page). Never claim a decision the card has not reported. The person may approve, approve with changes (their instructions are carried into what runs), send it back for revision with instructions (approval_state revision_requested; read the instructions with get_run_result and submit a revised request citing the old id in refs), or decline.\n- A research report (a Deep Research report) is delivered with save_research exactly as written, never summarised or shortened, with its sources; a long report goes in parts. Check the bytes and first and last lines the answer returns against what you sent.\n- An unknown id is answered as not found, never invented. A missing backing service is answered as unavailable.\n- Use the miadi-review:<uuid>, miadi-chronicle://<n>, owner/repo#n and session:<uuid> reference forms.";
+export declare const INSTRUCTIONS = "Miadi is a relational software factory: agent sessions, Miadi reviews of screenwalks, Chronicle episodes, talking circles and the five accountable circles (Story, Stewardship, Engineering, Evaluation, Continuity) across three domains (Creative, Ceremonial, Engineering).\n\nStart with get_capabilities: it says who you are signed in as, which tools are live, and which return not_implemented.\n\nRules every tool keeps:\n- Every record names the person who made it, with a claim category: observed, hypothesis, desired_future, fiction or verified_implementation. Keep fiction and desired futures apart from what was observed.\n- Requests (runs, work proposals, review operations, Deep Diver, review-to-episode links, inquiry-to-episode weaves, session completion) are recorded as awaiting_approval. Nothing runs, publishes or closes until a person decides. After making a request, call show_decisions: it shows the request as a card in the conversation, where the person decides with their own click (or follows its approval page). Never claim a decision the card has not reported. The person may approve, approve with changes (their instructions are carried into what runs), send it back for revision with instructions (approval_state revision_requested; read the instructions with get_run_result and revise it in place with revise_pending_request), or decline.\n- A mission is revised, never re-requested: to change a run or work proposal that still awaits a decision, call revise_pending_request with its id and the version you read (expected_version). It keeps one id, one approval page and one card; get_request_history shows every version. A new request_authorized_run or propose_work is for a new mission only. Requests made earlier as separate versions are joined with supersede_pending_requests, naming their exact ids, only when the person names or confirms them.\n- A research report (a Deep Research report) is delivered with save_research exactly as written, never summarised or shortened, with its sources; a long report goes in parts. Check the bytes and first and last lines the answer returns against what you sent.\n- An unknown id is answered as not found, never invented. A missing backing service is answered as unavailable.\n- Use the miadi-review:<uuid>, miadi-chronicle://<n>, owner/repo#n and session:<uuid> reference forms.";

package/dist/server.js

@@ -108,6 +108,8 @@ export function createConnectorApp(config, deps) {
             tmux: deps.tmux,
             tmuxSessions: deps.tmuxSessions,
             providersProbe: deps.providersProbe,
+            modelOf: deps.modelOf,
+            jevAdapter: deps.jevAdapter,
             steerSettleMs: deps.steerSettleMs,
         };
         const server = new McpServer({ name: "miadi", version: VERSION }, { instructions: INSTRUCTIONS });
@@ -143,7 +145,8 @@ Start with get_capabilities: it says who you are signed in as, which tools are l
 
 Rules every tool keeps:
 - Every record names the person who made it, with a claim category: observed, hypothesis, desired_future, fiction or verified_implementation. Keep fiction and desired futures apart from what was observed.
-- Requests (runs, work proposals, review operations, Deep Diver, review-to-episode links, inquiry-to-episode weaves, session completion) are recorded as awaiting_approval. Nothing runs, publishes or closes until a person decides. After making a request, call show_decisions: it shows the request as a card in the conversation, where the person decides with their own click (or follows its approval page). Never claim a decision the card has not reported. The person may approve, approve with changes (their instructions are carried into what runs), send it back for revision with instructions (approval_state revision_requested; read the instructions with get_run_result and submit a revised request citing the old id in refs), or decline.
+- Requests (runs, work proposals, review operations, Deep Diver, review-to-episode links, inquiry-to-episode weaves, session completion) are recorded as awaiting_approval. Nothing runs, publishes or closes until a person decides. After making a request, call show_decisions: it shows the request as a card in the conversation, where the person decides with their own click (or follows its approval page). Never claim a decision the card has not reported. The person may approve, approve with changes (their instructions are carried into what runs), send it back for revision with instructions (approval_state revision_requested; read the instructions with get_run_result and revise it in place with revise_pending_request), or decline.
+- A mission is revised, never re-requested: to change a run or work proposal that still awaits a decision, call revise_pending_request with its id and the version you read (expected_version). It keeps one id, one approval page and one card; get_request_history shows every version. A new request_authorized_run or propose_work is for a new mission only. Requests made earlier as separate versions are joined with supersede_pending_requests, naming their exact ids, only when the person names or confirms them.
 - A research report (a Deep Research report) is delivered with save_research exactly as written, never summarised or shortened, with its sources; a long report goes in parts. Check the bytes and first and last lines the answer returns against what you sent.
 - An unknown id is answered as not found, never invented. A missing backing service is answered as unavailable.
 - Use the miadi-review:<uuid>, miadi-chronicle://<n>, owner/repo#n and session:<uuid> reference forms.`;

package/dist/tools.d.ts

@@ -7,7 +7,8 @@ import type { OAuthState } from "./oauth.js";
 import { type ConnectorRecord } from "./records.js";
 import { type ApprovalDeps } from "./approve.js";
 import { type DecisionTokens } from "./decisions.js";
-import { type DiscoveryProbe } from "./providers.js";
+import { type DiscoveryProbe, type ProviderId } from "./providers.js";
+import { type JevAdapter } from "./model-preflight.js";
 import { type TmuxLike } from "./steer.js";
 export interface ToolContext {
     config: ConnectorConfig;
@@ -15,7 +16,7 @@ export interface ToolContext {
     reviews: ReviewClient;
     ledger: Ledger<ConnectorRecord>;
     oauthState: JsonFile<OAuthState>;
-    /** The factory directory holding queue/ (default ~/.miadi/factory). */
+    /** The factory directory holding queue/ (default /srv/miadi/factory). */
     factoryDir?: string;
     /** What the in-chat approval card needs to run a decided request. */
     approval?: ApprovalDeps;
@@ -25,9 +26,19 @@ export interface ToolContext {
     tmuxSessions?: () => string[];
     /** Provider discovery probes; tests inject fakes (jgwill/Miadi#893). */
     providersProbe?: DiscoveryProbe;
+    /** The configured default model of a provider; tests inject fakes (jgwill/Miadi#913). */
+    modelOf?: (provider: ProviderId) => string | null;
+    /** A Jev decider; tests inject a synthetic fixture. Absent, the connector's env decides (jgwill/Miadi#913). */
+    jevAdapter?: JevAdapter;
     /** Re-peek delay after a steer is typed (default 4000ms; tests pass 0). */
     steerSettleMs?: number;
 }
+/**
+ * Why GitHub did not answer a reference (jgwill/Miadi#913 B). A 404 without a
+ * token is a private repository as often as a missing issue, so nothing here is
+ * ever reported as not found.
+ */
+export declare function githubAccess(status: number, hasToken: boolean): 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>;