@miadi/connector 0.1.21 → 0.1.22

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/model-preflight.d.ts

@@ -113,7 +113,7 @@ export interface JevRequest {
     state: Record<string, unknown>;
     model: string;
     questions: Record<string, {
-        type: "choice";
+        type: "choice" | "noul";
         instructions: string;
         criteria: Record<string, string>;
     }>;

package/dist/server.d.ts

@@ -18,6 +18,7 @@ import type { ConnectorConfig } from "./config.js";
 import type { TmuxLike } from "./steer.js";
 import type { DiscoveryProbe, ProviderId } from "./providers.js";
 import type { JevAdapter } from "./model-preflight.js";
+import type { StandardSource } from "./mission-standard.js";
 export interface ConnectorDeps {
     identify: (token: string) => Promise<MiadiPerson | null>;
     fetchImpl?: typeof fetch;
@@ -31,6 +32,10 @@ export interface ConnectorDeps {
     /** A provider's configured default model and a Jev decider (jgwill/Miadi#913); tests inject fakes. */
     modelOf?: (provider: ProviderId) => string | null;
     jevAdapter?: JevAdapter;
+    /** The environment the draft review reads its keys from (default process.env); tests pass their own (jgwill/Miadi#939). */
+    draftReviewEnv?: NodeJS.ProcessEnv;
+    /** Where the mission standard comes from (default the prompt store, then the built-in copy); tests pass their own. */
+    standardSource?: StandardSource;
     /** Re-peek delay after a steer is typed (default 4000ms; tests pass 0). */
     steerSettleMs?: number;
     /** Where sessions and their steering inboxes live (jgwill/Miadi#930). */
@@ -45,4 +50,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\nEvery tool is offered on every connection. A client that loads tools on demand shows only those its last tool search matched: a tool you do not see is not missing. Search for it by its exact name, get_capabilities first, before telling the person a tool is absent. The main reads are get_capabilities, get_context, search, fetch, list_records, list_sessions, get_session, review_lookup, read_episode_file and show_decisions.\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.";
+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\nEvery tool is offered on every connection. A client that loads tools on demand shows only those its last tool search matched: a tool you do not see is not missing. Search for it by its exact name, get_capabilities first, before telling the person a tool is absent. The main reads are get_capabilities, get_context, search, fetch, list_records, list_sessions, get_session, review_lookup, read_episode_file and show_decisions.\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 new or revised run or work proposal answers with draft_review: the aspects of the mission standard to revise, each with why, the question to settle and who can settle it. Read it before show_decisions. It carries no verdict, it advises and blocks nothing, and next_action says what to do. Answer what your conversation holds, ask the person the rest, then revise. preferences lists the person's standing preferences for you to apply. Fill delivery with the one exact place the result lands, and person_words with the person's own words, verbatim, for anything credited to them.\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

@@ -11,6 +11,7 @@ import { JsonFile, Ledger, ensureStateDir, statePaths } from "./store.js";
 import { registerTools } from "./tools.js";
 import { MiadiClient } from "./miadi.js";
 import { ReviewClient } from "./reviews.js";
+import { draftReviewService } from "./draft-review.js";
 import { VERSION } from "./version.js";
 export function createConnectorApp(config, deps) {
     ensureStateDir(config.stateDir);
@@ -66,8 +67,10 @@ export function createConnectorApp(config, deps) {
     app.post("/authorize/confirm", confirmLimit, express.urlencoded({ extended: false, limit: "16kb" }), (req, res, next) => {
         provider.confirm(req, res).catch(next);
     });
+    const draftReview = draftReviewService({ stateDir: config.stateDir, fetchImpl: deps.fetchImpl, adapter: deps.jevAdapter, env: deps.draftReviewEnv, source: deps.standardSource });
     const approvalDeps = {
         config,
+        draftReview,
         ledger,
         miadi,
         identify: deps.identify,
@@ -116,6 +119,7 @@ export function createConnectorApp(config, deps) {
             providersProbe: deps.providersProbe,
             modelOf: deps.modelOf,
             jevAdapter: deps.jevAdapter,
+            draftReview,
             steerSettleMs: deps.steerSettleMs,
             ...(deps.steeringRuntime ? { steeringRuntime: deps.steeringRuntime } : {}),
         };
@@ -155,6 +159,7 @@ Every tool is offered on every connection. A client that loads tools on demand s
 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 revise it in place with revise_pending_request), or decline.
+- A new or revised run or work proposal answers with draft_review: the aspects of the mission standard to revise, each with why, the question to settle and who can settle it. Read it before show_decisions. It carries no verdict, it advises and blocks nothing, and next_action says what to do. Answer what your conversation holds, ask the person the rest, then revise. preferences lists the person's standing preferences for you to apply. Fill delivery with the one exact place the result lands, and person_words with the person's own words, verbatim, for anything credited to them.
 - 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.

package/dist/tools.d.ts

@@ -8,6 +8,7 @@ import { type ConnectorRecord } from "./records.js";
 import { type ApprovalDeps } from "./approve.js";
 import { type DecisionTokens } from "./decisions.js";
 import { type DiscoveryProbe, type ProviderId } from "./providers.js";
+import type { DraftReviewService } from "./draft-review.js";
 import { type JevAdapter } from "./model-preflight.js";
 import { type RuntimeDeps } from "./runtime-steer.js";
 import { type TmuxLike } from "./steer.js";
@@ -34,6 +35,8 @@ export interface ToolContext {
     modelOf?: (provider: ProviderId) => string | null;
     /** A Jev decider; tests inject a synthetic fixture. Absent, the connector's env decides (jgwill/Miadi#913). */
     jevAdapter?: JevAdapter;
+    /** The report a drafted mission gets against the mission standard (jgwill/Miadi#939). */
+    draftReview?: DraftReviewService;
     /** Re-peek delay after a steer is typed (default 4000ms; tests pass 0). */
     steerSettleMs?: number;
 }