@miadi/connector 0.1.20 → 0.1.22

package/dist/draft-review.d.ts

@@ -0,0 +1,96 @@
+import { type JevAdapter } from "./model-preflight.js";
+import { type MissionStandard, type SettledBy, type StandardSource } from "./mission-standard.js";
+import type { ConnectorRecord } from "./records.js";
+/** Two rounds of report and revision, then the open aspects go on the card (D4). */
+export declare const MAX_ROUNDS = 2;
+export interface Finding {
+    aspect: string;
+    name: string;
+    /** "code", or "jev 0.17" with the number that raised it. */
+    checked_by: string;
+    /** The words in the mission this is about. Jev picks the sentence for a finding it raised. */
+    span?: string;
+    /** A fact the check found, such as the mission running on the same issue. */
+    note?: string;
+    why: string;
+    ask: string;
+    /** What the drafting agent does with the answer. Not shown to the person deciding. */
+    fix?: string;
+    settled_by: SettledBy;
+}
+/** What a requester may read of another person's mission: as list_records shows it. A session names a seat, and it stays out (jgwill/Miadi#922 R2). */
+export interface RunningMission {
+    id: string;
+    intention?: string;
+    primary_issue?: string;
+    approved_at?: string;
+}
+export interface DraftReview {
+    /** The ledger's key: one report per record and version. */
+    id: string;
+    record_id: string;
+    version: number;
+    at: string;
+    standard: {
+        name: string;
+        version: number;
+        source: MissionStandard["source"];
+        note?: string;
+    };
+    needs_revision: Finding[];
+    /** What this report did not judge. A short list of findings is not a clean bill. */
+    not_checked: {
+        aspect: string;
+        name: string;
+        reason: string;
+    }[];
+    running_missions: RunningMission[];
+    preferences: string[];
+    round: number;
+    jev: {
+        state: "ran" | "unconfigured" | "unavailable";
+        model?: string;
+        uncalibrated?: true;
+        paid_input_tokens?: number;
+        message?: string;
+    };
+    next_action: string;
+}
+/** Ids, paths, hashes, URLs and repository names out of what goes to Jev. */
+export declare function redactForJev(text: string): string;
+/** A delivery code can vouch for, with no model: an address, an issue, a uuid or a path of more than one folder. "Or" means a choice, which code cannot judge. */
+export declare function namesExactPlace(delivery: string): boolean;
+/** Runs and proposals a person approved in the last 48 hours that have not finished. */
+export declare function runningMissions(records: ConnectorRecord[], selfId: string, now?: number): (RunningMission & {
+    issues: string[];
+})[];
+/** The mission cut into sentences to choose among: Jev picks, it does not write (Episode 564, read gate F3). */
+export declare function sentencesOf(text: string, limit?: number): string[];
+export interface ReviewInput {
+    record: ConnectorRecord;
+    records: ConnectorRecord[];
+    standard: MissionStandard;
+    adapter?: JevAdapter;
+    now?: number;
+}
+/** One report for one version of one mission. Jev's failure leaves the code's findings and names what went unchecked. */
+export declare function reviewDraft({ record, records, standard, adapter, now }: ReviewInput): Promise<DraftReview>;
+export declare const reportId: (recordId: string, version: number) => string;
+export interface DraftReviewService {
+    /** The stored report for this version, or a new one. Never throws. */
+    review(record: ConnectorRecord, records: ConnectorRecord[]): Promise<DraftReview | {
+        state: "unavailable";
+        message: string;
+    }>;
+    /** The report already made for this version, with no call out. */
+    stored(record: ConnectorRecord): DraftReview | undefined;
+    standard(): Promise<MissionStandard>;
+    jevConfigured: boolean;
+}
+export declare function draftReviewService(o: {
+    stateDir: string;
+    env?: NodeJS.ProcessEnv;
+    fetchImpl?: typeof fetch;
+    adapter?: JevAdapter;
+    source?: StandardSource;
+}): DraftReviewService;

package/dist/draft-review.js

@@ -0,0 +1,267 @@
+/**
+ * The report a drafted mission gets against the mission standard (jgwill/Miadi#939).
+ *
+ * It lists aspects to revise, each with why, the question to settle and who can
+ * settle it. It carries no overall verdict: in Episode 564's test a reviewer said
+ * `revise` on ten missions of ten, so a verdict says nothing. It advises and
+ * blocks nothing, a person decides whatever it says, and a failure here never
+ * refuses a request.
+ *
+ * What leaves the host: the mission's text and its delivery field, with ids,
+ * paths, hashes, URLs and repository names removed, to Jev when the connector
+ * holds a key. The tests that set the bars read text in the same form. Reports
+ * are kept beside the ledger, one line per record and version, so a person's
+ * decision on a version can be read against the aspects open on it.
+ */
+import { join } from "node:path";
+import { jevConfigOf } from "./providers.js";
+import { jevAdapter } from "./model-preflight.js";
+import { standardSource } from "./mission-standard.js";
+import { versionOf } from "./revisions.js";
+import { Ledger } from "./store.js";
+/** Two rounds of report and revision, then the open aspects go on the card (D4). */
+export const MAX_ROUNDS = 2;
+const RUNNING_WINDOW_MS = 48 * 3600 * 1000;
+const JEV_TIMEOUT_MS = 8000;
+const ISSUE_REF = /^[\w.-]+\/[\w.-]+#\d+$/;
+const EPISODE_REF = /^miadi-chronicle:/;
+/** Ids, paths, hashes, URLs and repository names out of what goes to Jev. */
+export function redactForJev(text) {
+    return String(text ?? "")
+        .replace(/https?:\/\/\S+/g, "[url]")
+        .replace(/\b(run_request|work_proposal|review_operation_request|session_steer_request|research_artifact|inquiry|observation|source_intent|session):[0-9a-f-]{6,}/gi, "[id]")
+        .replace(/\bmiadi-[a-z]+:\/*[\w./:-]+/gi, "[id]")
+        .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "[id]")
+        .replace(/\b[0-9a-f]{12,64}\b/gi, "[hash]")
+        .replace(/\b[\w.-]+\/[\w.-]+#\d+\b/g, "[issue]")
+        .replace(/#\d+\b/g, "[issue]")
+        .replace(/(?:^|(?<=[\s`"'(]))(?:\/|~\/|\.\/)[\w@.+-]+(?:\/[\w@.+-]*)*/g, "[path]")
+        .replace(/\b(?!and\/or\b)[\w.-]+\/[\w.-]+(?:\/[\w./-]*)?/g, "[path]")
+        .replace(/%\d+\b/g, "[pane]");
+}
+/** A delivery code can vouch for, with no model: an address, an issue, a uuid or a path of more than one folder. "Or" means a choice, which code cannot judge. */
+export function namesExactPlace(delivery) {
+    if (/\bor\b/i.test(delivery))
+        return false;
+    return (/\bmiadi-[a-z]+:/.test(delivery) ||
+        /(^|\s)[\w.-]+\/[\w.-]+#\d+\b/.test(delivery) ||
+        /#\d+\b/.test(delivery) ||
+        /\bepisode\s+\d+/i.test(delivery) ||
+        /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/i.test(delivery) ||
+        /(^|\s)(\/|~\/|\.\/)[\w@.+-]+/.test(delivery) ||
+        /[\w@.+-]+\/[\w@.+-]+\/[\w@.+-]/.test(delivery));
+}
+const issuesOf = (r) => {
+    const primary = r.body.primary_issue;
+    return [...new Set([...(primary ? [primary] : []), ...(r.refs ?? []).filter((x) => ISSUE_REF.test(x))])];
+};
+/** Runs and proposals a person approved in the last 48 hours that have not finished. */
+export function runningMissions(records, selfId, now = Date.now()) {
+    const out = [];
+    for (const r of records) {
+        if (r.id === selfId || (r.kind !== "run_request" && r.kind !== "work_proposal"))
+            continue;
+        if (r.approval_state !== "approved" || r.state === "completed" || r.state === "blocked")
+            continue;
+        // A mission carrying a private reading is read only by its owner and operators, and a report is read by others.
+        if (r.body.reading)
+            continue;
+        const decidedAt = r.completion_receipt?.decided_at;
+        if (!decidedAt || now - Date.parse(decidedAt) > RUNNING_WINDOW_MS)
+            continue;
+        const body = r.body;
+        out.push({
+            id: r.id,
+            ...(r.intention || body.title ? { intention: (r.intention ?? body.title).slice(0, 240) } : {}),
+            ...(body.primary_issue ? { primary_issue: body.primary_issue } : {}),
+            approved_at: decidedAt,
+            issues: issuesOf(r),
+        });
+    }
+    return out;
+}
+const finding = (a, checked_by, span) => ({
+    aspect: a.code,
+    name: a.name,
+    checked_by,
+    ...(span ? { span: span.slice(0, 300) } : {}),
+    why: a.why,
+    ask: a.ask,
+    ...(a.fix ? { fix: a.fix } : {}),
+    settled_by: a.settled_by,
+});
+/** The mission cut into sentences to choose among: Jev picks, it does not write (Episode 564, read gate F3). */
+export function sentencesOf(text, limit = 40) {
+    return text
+        .split(/\n+|(?<=[.!?;])\s+/)
+        .map((s) => s.trim())
+        .filter((s) => s.length >= 20)
+        .slice(0, limit);
+}
+const missionText = (r) => {
+    const b = r.body;
+    return b.task ?? [b.title, b.desired_outcome].filter(Boolean).join("\n\n");
+};
+function nextAction(r, version, needs) {
+    const ours = needs.filter((f) => f.settled_by !== "person");
+    if (version > MAX_ROUNDS)
+        return `This mission has had ${MAX_ROUNDS} rounds of review. Call show_decisions: what is still open goes on the person's card. Revise again only if the person asks.`;
+    if (ours.length)
+        return `For each ask: answer it from your conversation with the person, or put it to them, and do what its fix says. Then call revise_pending_request with request_id ${r.id} and expected_version ${version}, and show_decisions. If the person wants it as it stands, call show_decisions: what is open goes on their card.`;
+    if (needs.length)
+        return "Call show_decisions: only the person can answer what is open, and it goes on their card.";
+    return "Nothing was flagged on the aspects checked. That is not a verdict: not_checked lists what this report did not judge. Call show_decisions.";
+}
+/** One report for one version of one mission. Jev's failure leaves the code's findings and names what went unchecked. */
+export async function reviewDraft({ record, records, standard, adapter, now = Date.now() }) {
+    const version = versionOf(record);
+    const body = record.body;
+    const delivery = typeof body.delivery === "string" ? body.delivery.trim() : "";
+    const personWords = typeof body.person_words === "string" ? body.person_words.trim() : "";
+    const text = missionText(record);
+    const aspect = (code) => standard.aspects.find((a) => a.code === code);
+    const handledInCode = new Set(["S1", "S3", "S6"]);
+    // What goes to Jev: the delivery on its own when code cannot vouch for it, the mission for everything else.
+    const s1 = aspect("S1");
+    const askDelivery = Boolean(s1?.jev && delivery && !namesExactPlace(delivery));
+    const onTask = standard.aspects.filter((a) => a.jev && !handledInCode.has(a.code) && !(a.code === "S5" && personWords));
+    const asks = [];
+    const paid = [];
+    let jev = adapter ? { state: "ran", model: standard.jev_model, uncalibrated: true } : { state: "unconfigured" };
+    const decide = async (state, list) => {
+        const questions = Object.fromEntries(list.map((a) => [a.jev.id, { type: "noul", instructions: a.jev.instructions, criteria: a.jev.criteria }]));
+        const answer = await adapter.decide({ state, model: standard.jev_model, questions });
+        const tokens = Number(answer.billing?.paid_input_tokens_used);
+        if (Number.isFinite(tokens))
+            paid.push(tokens);
+        return answer.answers;
+    };
+    if (adapter) {
+        if (askDelivery)
+            asks.push(decide({ delivery: redactForJev(delivery) }, [s1]));
+        if (onTask.length)
+            asks.push(decide({ task: redactForJev(text) }, onTask));
+    }
+    const settled = await Promise.allSettled(asks);
+    const answers = Object.assign({}, ...settled.map((s) => (s.status === "fulfilled" ? s.value : {})));
+    const failed = settled.find((s) => s.status === "rejected");
+    if (failed)
+        jev = { state: "unavailable", message: failed.reason instanceof Error ? failed.reason.message : String(failed.reason) };
+    if (paid.length)
+        jev.paid_input_tokens = paid.reduce((a, b) => a + b, 0);
+    const scoreOf = (id) => {
+        const v = answers[id]?.noul;
+        return typeof v === "number" && v >= 0 && v <= 1 ? v : null;
+    };
+    const needs = [];
+    const notChecked = [];
+    const running = runningMissions(records, record.id, now);
+    for (const a of standard.aspects) {
+        if (a.code === "S1") {
+            if (!delivery)
+                needs.push(finding(a, "code"));
+            else if (askDelivery) {
+                const p = scoreOf(a.jev.id);
+                if (p === null)
+                    notChecked.push({ aspect: a.code, name: a.name, reason: "Jev did not answer, and code cannot vouch for this delivery." });
+                else if (p < a.jev.bar)
+                    needs.push(finding(a, `jev ${p.toFixed(2)}`, delivery));
+            }
+        }
+        else if (a.code === "S3") {
+            const mine = issuesOf(record);
+            const shared = running.filter((m) => m.issues.some((i) => mine.includes(i)) && !text.includes(m.id.split(":")[1]?.slice(0, 8) ?? m.id));
+            if (shared.length)
+                needs.push({ ...finding(a, "code"), note: `Running on the same issue: ${shared.map((m) => `${m.id.replace(/^([a-z_]+:[0-9a-f]{8}).*$/, "$1")}${m.intention ? ` (${m.intention.slice(0, 90)})` : ""}`).join(", ")}.` });
+        }
+        else if (a.code === "S6") {
+            const refs = record.refs ?? [];
+            const issues = refs.filter((x) => ISSUE_REF.test(x));
+            const declared = Boolean(record.body.primary_issue);
+            if ((!issues.length && !declared && !refs.some((x) => EPISODE_REF.test(x))) || (issues.length > 1 && !declared))
+                needs.push(finding(a, "code"));
+        }
+        else if (a.jev) {
+            if (a.code === "S5" && personWords)
+                continue;
+            const p = scoreOf(a.jev.id);
+            if (p === null)
+                notChecked.push({ aspect: a.code, name: a.name, reason: adapter ? "Jev did not answer." : "The connector holds no Jev key." });
+            else if (a.jev.fires === "above" ? p >= a.jev.bar : p < a.jev.bar)
+                needs.push(finding(a, `jev ${p.toFixed(2)}`));
+        }
+        else if (!a.not_checked) {
+            notChecked.push({ aspect: a.code, name: a.name, reason: "This version of the connector runs no check for it." });
+        }
+        if (a.not_checked)
+            notChecked.push({ aspect: a.code, name: a.name, reason: a.not_checked });
+    }
+    // For a finding Jev raised on the mission, the sentence it is about. A failure leaves the finding without one.
+    const raised = needs.flatMap((f) => {
+        const a = aspect(f.aspect);
+        return a?.jev && !handledInCode.has(a.code) ? [{ f, a }] : [];
+    });
+    const sentences = adapter && raised.length ? sentencesOf(text) : [];
+    if (sentences.length > 1) {
+        const criteria = Object.fromEntries(sentences.map((s, i) => [`s${i + 1}`, redactForJev(s).slice(0, 300)]));
+        const questions = Object.fromEntries(raised.map(({ a }) => [`${a.jev.id}_where`, { type: "choice", instructions: `Which sentence of \`task\` is the clearest case of this: ${a.jev.criteria.true}`, criteria }]));
+        try {
+            const answer = await adapter.decide({ state: { task: redactForJev(text) }, model: standard.jev_model, questions });
+            const tokens = Number(answer.billing?.paid_input_tokens_used);
+            if (Number.isFinite(tokens))
+                jev.paid_input_tokens = (jev.paid_input_tokens ?? 0) + tokens;
+            for (const { f, a } of raised) {
+                const pick = answer.answers[`${a.jev.id}_where`]?.choice;
+                const index = typeof pick === "string" && /^s\d+$/.test(pick) ? Number(pick.slice(1)) - 1 : -1;
+                if (sentences[index])
+                    f.span = sentences[index].slice(0, 300);
+            }
+        }
+        catch {
+            /* the finding stands without its sentence */
+        }
+    }
+    return {
+        id: reportId(record.id, version),
+        record_id: record.id,
+        version,
+        at: new Date(now).toISOString(),
+        standard: { name: standard.name, version: standard.version, source: standard.source, ...(standard.note ? { note: standard.note } : {}) },
+        needs_revision: needs,
+        not_checked: notChecked,
+        running_missions: running.map(({ issues: _issues, ...m }) => m),
+        preferences: standard.preferences[record.actor.person_id] ?? [],
+        round: Math.min(version, MAX_ROUNDS + 1),
+        jev,
+        next_action: nextAction(record, version, needs),
+    };
+}
+export const reportId = (recordId, version) => `${recordId}@${version}`;
+export function draftReviewService(o) {
+    const env = o.env ?? process.env;
+    const fetchImpl = o.fetchImpl ?? fetch;
+    const reports = new Ledger(join(o.stateDir, "draft-reviews.jsonl"));
+    const source = o.source ?? standardSource(env, fetchImpl);
+    const config = jevConfigOf(env);
+    const adapter = o.adapter ?? (config ? jevAdapter(config, fetchImpl, JEV_TIMEOUT_MS) : undefined);
+    const stored = (record) => {
+        const id = reportId(record.id, versionOf(record));
+        return reports.all().find((r) => r.id === id);
+    };
+    return {
+        stored,
+        standard: () => source.get(),
+        jevConfigured: Boolean(adapter),
+        async review(record, records) {
+            try {
+                const prior = stored(record);
+                if (prior)
+                    return prior;
+                return reports.append(await reviewDraft({ record, records, standard: await source.get(), adapter }));
+            }
+            catch (error) {
+                return { state: "unavailable", message: `The report could not be made (${error instanceof Error ? error.message : String(error)}). The request is recorded and awaits its decision as usual.` };
+            }
+        },
+    };
+}

package/dist/index.d.ts

@@ -11,4 +11,6 @@ export { PROVIDERS, discoverProviders, jevConfigOf, resolveProvider, routerPrefl
 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, composingText, isBusy, readSteerArtifact, steerAttempts, steerSession, steeringGrantOf, tmuxAdapter, type SteerDeps, type SteerResult, type SteerStatus, type SteeringGrant, type TmuxLike, } from "./steer.js";
+export { reviewDraft, redactForJev, namesExactPlace, runningMissions, draftReviewService, MAX_ROUNDS, type DraftReview, type DraftReviewService, type Finding } from "./draft-review.js";
+export { BUILT_IN_STANDARD, parseStandard, standardSource, STANDARD_NAME, type MissionStandard, type StandardAspect, type StandardSource } from "./mission-standard.js";
 export { VERSION } from "./version.js";

package/dist/index.js

@@ -11,4 +11,6 @@ export { PROVIDERS, discoverProviders, jevConfigOf, resolveProvider, routerPrefl
 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, composingText, isBusy, readSteerArtifact, steerAttempts, steerSession, steeringGrantOf, tmuxAdapter, } from "./steer.js";
+export { reviewDraft, redactForJev, namesExactPlace, runningMissions, draftReviewService, MAX_ROUNDS } from "./draft-review.js";
+export { BUILT_IN_STANDARD, parseStandard, standardSource, STANDARD_NAME } from "./mission-standard.js";
 export { VERSION } from "./version.js";

package/dist/mission-standard.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The mission standard (jgwill/Miadi#939): what a drafted mission owes before a
+ * person decides on it, as aspects with the words a report returns.
+ *
+ * The standard is a document, so it changes without a connector release: a text
+ * prompt named `mission-standard`, label `production`, in the prompt store's
+ * Engineering domain, holding JSON in the shape below. The built-in copy is what
+ * runs when the store has no keys, cannot be reached or answers outside the
+ * contract, and a report says which one it used. A person's standing preferences
+ * live only in the store: this package is published.
+ *
+ * The bars are uncalibrated. They were read from the tests in Episode 564
+ * (`mission-draft-review-261105/`) and move with a person's rulings.
+ */
+export declare const STANDARD_NAME = "mission-standard";
+/** Who can settle an aspect: the agent holding the conversation, only the person, or a local agent reading the running system. */
+export type SettledBy = "drafter" | "person" | "local_agent";
+export interface JevCheck {
+    id: string;
+    instructions: string;
+    criteria: {
+        true: string;
+        false: string;
+    };
+    /** A finding comes from a probability above or below the bar. */
+    fires: "above" | "below";
+    bar: number;
+}
+export interface StandardAspect {
+    code: string;
+    name: string;
+    requires: string;
+    why: string;
+    /** The question to settle, in words the person deciding can read. */
+    ask: string;
+    /** What the drafting agent does with the answer. It goes to that agent and not on the card. */
+    fix?: string;
+    settled_by: SettledBy;
+    jev?: JevCheck;
+    /** Why this version of the connector does not check it, or checks only part of it. */
+    not_checked?: string;
+}
+export interface MissionStandard {
+    name: string;
+    version: number;
+    source: "built_in" | "prompt_store";
+    /** What happened to the prompt store, when the built-in copy or an older read is in use. */
+    note?: string;
+    jev_model: string;
+    aspects: StandardAspect[];
+    /** Standing preferences by person id, returned to the agent drafting for that person. */
+    preferences: Record<string, string[]>;
+}
+export declare const BUILT_IN_STANDARD: MissionStandard;
+/** The stored document, or an error saying what is outside the contract. A model alias is refused: one pinned version per standard. */
+export declare function parseStandard(text: string, version: number): MissionStandard;
+export interface StandardSource {
+    get(): Promise<MissionStandard>;
+}
+/**
+ * Reads the standard from the prompt store, once per ten minutes. A failed read
+ * keeps the last good version and says so, and with no good version the built-in
+ * copy answers and says why: a report never hides which standard judged the mission.
+ */
+export declare function standardSource(env?: NodeJS.ProcessEnv, fetchImpl?: typeof fetch, now?: () => number): StandardSource;

package/dist/mission-standard.js

@@ -0,0 +1,178 @@
+/**
+ * The mission standard (jgwill/Miadi#939): what a drafted mission owes before a
+ * person decides on it, as aspects with the words a report returns.
+ *
+ * The standard is a document, so it changes without a connector release: a text
+ * prompt named `mission-standard`, label `production`, in the prompt store's
+ * Engineering domain, holding JSON in the shape below. The built-in copy is what
+ * runs when the store has no keys, cannot be reached or answers outside the
+ * contract, and a report says which one it used. A person's standing preferences
+ * live only in the store: this package is published.
+ *
+ * The bars are uncalibrated. They were read from the tests in Episode 564
+ * (`mission-draft-review-261105/`) and move with a person's rulings.
+ */
+export const STANDARD_NAME = "mission-standard";
+const CACHE_MS = 10 * 60 * 1000;
+const STORE_TIMEOUT_MS = 3000;
+const DEFAULT_STORE_URL = "https://cloud.langfuse.com";
+export const BUILT_IN_STANDARD = {
+    name: STANDARD_NAME,
+    version: 1,
+    source: "built_in",
+    jev_model: "jev-1.14.0",
+    preferences: {},
+    aspects: [
+        {
+            code: "S1",
+            name: "where the result lands",
+            requires: "One exact place the result lands: a path, a branch, a pull request, an issue, a review or an episode, in the delivery field.",
+            why: "Without one exact place the worker chooses, and the result may land where the person cannot open it.",
+            ask: "Which exact place receives the result?",
+            fix: "Put it in the delivery field.",
+            settled_by: "drafter",
+            jev: {
+                id: "delivery_exact",
+                instructions: "Does `delivery` name one exact place the result lands (a path, a branch, a pull request, an issue, a review or an episode)? A bracketed placeholder such as [path] or [issue] stands for a real one.",
+                criteria: { true: "It names one exact place.", false: "It names a kind of place, or a choice among places, or no place." },
+                fires: "below",
+                bar: 0.3,
+            },
+        },
+        {
+            code: "S2",
+            name: "who may release, deploy or start a session",
+            requires: "Each act that reaches production or starts a session names who performs it and what authorizes it.",
+            why: "A worker reads an unstated permission as its own, or stops at a step nobody can perform.",
+            ask: "Who performs this act, and does approving this mission authorize it?",
+            settled_by: "person",
+            not_checked: "The local reviewer checks this aspect, and it does not run yet (jgwill/Miadi#939 A3).",
+        },
+        {
+            code: "S3",
+            name: "running work on the same ground",
+            requires: "The mission says whether it waits for running work on its ground, builds on it or keeps clear of it.",
+            why: "Two missions on one issue overwrite or undo each other, and the person is left to notice.",
+            ask: "Does this mission wait for that work, build on it or keep clear of it?",
+            fix: "Say which in the mission.",
+            settled_by: "drafter",
+            not_checked: "Only shared issues are compared. The local reviewer judges other overlap, and it does not run yet (jgwill/Miadi#939 A3).",
+        },
+        {
+            code: "S4",
+            name: "a mechanism the mission dictates",
+            requires: "The end result, unless the person asked for the mechanism.",
+            why: "A dictated mechanism stops the worker from finding that the work belongs elsewhere.",
+            ask: "Was this mechanism asked for?",
+            fix: "Quote the person in person_words, or state the result instead.",
+            settled_by: "drafter",
+            jev: {
+                id: "names_mechanism",
+                instructions: "Does `task` tell the worker which mechanism to build (named components, queues, watchers, storage, workers)?",
+                criteria: { true: "It dictates the mechanism.", false: "It leaves the mechanism to the worker." },
+                fires: "above",
+                bar: 0.8,
+            },
+        },
+        {
+            code: "S5",
+            name: "the person's words",
+            requires: "The person's own words for any rule, correction or decision credited to them, in person_words.",
+            why: "Only this conversation holds what the person said, and a misstated rule carries into the work as if it were their decision.",
+            ask: "What was said, word for word?",
+            fix: "Put it in person_words.",
+            settled_by: "drafter",
+            jev: {
+                id: "credits_person",
+                instructions: "Does `task` present a rule, correction or decision as coming from the person who asked (the author, the creator, the requester or a named person)?",
+                criteria: { true: "It credits a rule, correction or decision to the person.", false: "It credits nothing to the person." },
+                fires: "above",
+                bar: 0.8,
+            },
+        },
+        {
+            code: "S6",
+            name: "what holds the work",
+            requires: "An episode or an issue that holds the work, and primary_issue when several issues are named.",
+            why: "Without a holder the result has no home, and mission_status has to guess which issue the mission implements.",
+            ask: "Which episode or issue holds this work, and which one issue does it implement?",
+            fix: "Name them in refs and primary_issue.",
+            settled_by: "drafter",
+        },
+    ],
+};
+const isText = (v) => typeof v === "string" && v.trim().length > 0;
+function checkOf(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (!isText(raw?.id) || !isText(raw?.instructions) || !isText(raw?.criteria?.true) || !isText(raw?.criteria?.false))
+        throw new Error("a Jev check needs id, instructions and both criteria");
+    if (raw.fires !== "above" && raw.fires !== "below")
+        throw new Error(`check ${raw.id}: fires must be above or below`);
+    if (typeof raw.bar !== "number" || raw.bar <= 0 || raw.bar >= 1)
+        throw new Error(`check ${raw.id}: bar must be between 0 and 1`);
+    return { id: raw.id, instructions: raw.instructions, criteria: { true: raw.criteria.true, false: raw.criteria.false }, fires: raw.fires, bar: raw.bar };
+}
+/** The stored document, or an error saying what is outside the contract. A model alias is refused: one pinned version per standard. */
+export function parseStandard(text, version) {
+    const raw = JSON.parse(text);
+    if (!isText(raw?.jev_model) || /^jev-(latest|preview)$/.test(raw.jev_model))
+        throw new Error("jev_model must be a pinned version, never an alias");
+    if (!Array.isArray(raw?.aspects) || raw.aspects.length === 0)
+        throw new Error("aspects must be a list");
+    const aspects = raw.aspects.map((a) => {
+        for (const k of ["code", "name", "requires", "why", "ask"])
+            if (!isText(a?.[k]))
+                throw new Error(`an aspect needs ${k}`);
+        if (!["drafter", "person", "local_agent"].includes(a.settled_by))
+            throw new Error(`aspect ${a.code}: settled_by is drafter, person or local_agent`);
+        const jev = checkOf(a.jev);
+        return { code: a.code, name: a.name, requires: a.requires, why: a.why, ask: a.ask, ...(isText(a.fix) ? { fix: a.fix } : {}), settled_by: a.settled_by, ...(jev ? { jev } : {}), ...(isText(a.not_checked) ? { not_checked: a.not_checked } : {}) };
+    });
+    const preferences = {};
+    for (const [person, list] of Object.entries(raw.preferences ?? {})) {
+        if (!Array.isArray(list) || !list.every(isText))
+            throw new Error(`preferences of ${person} must be a list of text`);
+        preferences[person] = list;
+    }
+    return { name: STANDARD_NAME, version, source: "prompt_store", jev_model: raw.jev_model, aspects, preferences };
+}
+/**
+ * Reads the standard from the prompt store, once per ten minutes. A failed read
+ * keeps the last good version and says so, and with no good version the built-in
+ * copy answers and says why: a report never hides which standard judged the mission.
+ */
+export function standardSource(env = process.env, fetchImpl = fetch, now = Date.now) {
+    let good = null;
+    const publicKey = env.ENG_LANGFUSE_PUBLIC_KEY;
+    const secretKey = env.ENG_LANGFUSE_SECRET_KEY;
+    const base = (env.ENG_LANGFUSE_BASE_URL || DEFAULT_STORE_URL).replace(/\/+$/, "");
+    return {
+        async get() {
+            if (!publicKey || !secretKey)
+                return { ...BUILT_IN_STANDARD, note: "The connector holds no prompt store keys." };
+            if (good && now() - good.at < CACHE_MS)
+                return good.standard;
+            try {
+                const res = await fetchImpl(`${base}/api/public/v2/prompts/${STANDARD_NAME}?label=production`, {
+                    headers: { authorization: `Basic ${Buffer.from(`${publicKey}:${secretKey}`).toString("base64")}`, accept: "application/json" },
+                    signal: AbortSignal.timeout(STORE_TIMEOUT_MS),
+                });
+                if (!res.ok)
+                    throw new Error(`the prompt store answered ${res.status}`);
+                const body = await res.json();
+                if (typeof body?.prompt !== "string" || typeof body?.version !== "number")
+                    throw new Error("the prompt store's answer holds no text prompt");
+                const standard = parseStandard(body.prompt, body.version);
+                good = { at: now(), standard };
+                return standard;
+            }
+            catch (error) {
+                const why = error instanceof Error ? error.message : String(error);
+                if (good)
+                    return { ...good.standard, note: `Read earlier: the last read failed (${why}).` };
+                return { ...BUILT_IN_STANDARD, note: `The prompt store did not answer with a usable standard (${why}).` };
+            }
+        },
+    };
+}

package/dist/mission-status.d.ts

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