@miadi/connector 0.1.23 → 0.1.25

package/README.md

@@ -126,8 +126,23 @@ The drafter gets two rounds: a report and a revision, twice. The third report's
 
 In a client that renders MCP Apps (ChatGPT among them), `show_decisions` draws one card per request awaiting a decision: what is asked, by whom, and what approving does. The person decides on the card with their own click: Approve, Approve with my changes, Send back for revision, or Decline. The card then shows the receipt.
 
+A new card address needs a new URI, and the earlier ones stay readable (`DECISIONS_CARD_EARLIER_URIS`). A host keeps the tool metadata it read until its connection is refreshed by hand, and draws an empty card for a template it cannot read. The journal holds one line for each `show_decisions` call and each template read (`card_template_read`), so a blank card can be told from a card nobody asked for.
+
 A decision is recorded once. An approved run that calls another service (a review operation, Deep Diver, an episode door, a steer) is written to the ledger as approved and running before the call, so a restart can never offer the request for a second approval; a run the connector was recording when it stopped reads as failed and may be run again. A decision whose run takes longer than `MIADI_CONNECTOR_DECISION_WAIT_MS` is answered as recorded and running, and the card reads `get_run_result` every 3 seconds until the outcome is in. The same decision sent again (a host retrying a call, a second click, the page form sent twice) answers with the first one's receipt, marked `replayed`, and runs nothing. A different decision is refused as `decision_conflict`, with where the request stands. When the host gives up on a call, the card reads where the request stands before it offers the buttons again.
 
+**A created review gets its transcript (jgwill/Miadi#925).** An approved `create` calls the review service, then reads the video's original-language YouTube captions with a local `uvx yt-dlp` and stores them on the review as `[mm:ss] text`, so an agent reads them through `fetch` and the factory's kind briefs find them with `miadi_review.py transcript`. No model is called for the transcript. The service answers an empty `POST /api/reviews/:id/transcript` by asking Gemini, so an empty one is never sent. `completion_receipt.transcript` says where it stands, and the card and the approval page say the same:
+
+| outcome | meaning |
+|---|---|
+| `stored` | stored, with its source, word count, sha256 and the range the captions cover |
+| `already_present` | the review already held a transcript, which stays |
+| `waiting_for_captions` | YouTube has no captions yet or refused the read. The connector tries again every 15 minutes for three days, from the ledger, so a restart loses nothing |
+| `held_source_withheld` | the video's `source_intent` is `withheld`, so the captions are neither read nor stored. The transcript lands within 15 minutes of the source being released with `register_source_intent`, because a stored transcript is public at `/review/<id>/json` |
+| `no_captions` | three days passed with no captions |
+| `no_review` | the create left no review. Running the request again retries it |
+
+A transcript supplied with the request is stored instead of the captions. The captions hold what YouTube heard: they may stop before the video does, and they may hold a synthetic voice and not the person's. Their first line says what they are and the range they cover. The host needs `uvx` on the service's `PATH`.
+
 The model that asked cannot decide for the person:
 - `decide_request` is declared for the card only (`_meta.ui.visibility: ["app"]`), so the host does not offer it to the model.
 - It requires a decision token that travels only in the `_meta` of the `show_decisions` result. Hosts deliver that metadata to the card and keep it from the model. The token is bound to one request at the version its card shows, one person and one OAuth client, and expires after 7 days (`MIADI_CONNECTOR_DECISION_TOKEN_TTL`). A decided request no longer awaits a decision, so a token works once. The request itself does not expire: a card whose token expired names the request's approval page, and `show_decisions` gives a fresh card for the same request.

package/dist/approve.d.ts

@@ -19,6 +19,7 @@ import { type RequestProjection } from "./request-state.js";
 import type { DraftReviewService } from "./draft-review.js";
 import type { RuntimeDeps } from "./runtime-steer.js";
 import { type TmuxLike } from "./steer.js";
+import { type FetchCaptions } from "./captions.js";
 import { type ProviderAuthorization } from "./provider-policy.js";
 export { factoryDir, runBriefFile, readQueueState } from "./queue-state.js";
 export interface ApprovalDeps {
@@ -38,6 +39,8 @@ export interface ApprovalDeps {
     steerSettleMs?: number;
     /** Where sessions and their steering inboxes live (jgwill/Miadi#930). Absent, no runtime route is known. */
     steeringRuntime?: RuntimeDeps;
+    /** Reads a video's captions for an approved create; without it a create stores no transcript (tests, other embedders). */
+    captions?: FetchCaptions;
     /** Where decision events go (default: one JSON line on stdout, the service journal); tests collect them. */
     log?: (event: Record<string, unknown>) => void;
 }
@@ -73,6 +76,8 @@ export declare function runBrief(record: ConnectorRecord, approver: MiadiPerson,
 };
 /** A request's refs as episode references: an `owner/repo#n` becomes its issue link, anything else stays as written. */
 export declare function episodeReferences(record: ConnectorRecord): string[];
+/** Whether the owner of this video's source registered it as withheld. */
+export declare function sourceWithheld(records: ConnectorRecord[], videoId: unknown): boolean;
 export declare function executeApproved(record: ConnectorRecord, approver: MiadiPerson, deps: ApprovalDeps, instructions?: string): Promise<Record<string, unknown>>;
 /**
  * Record a person's decision on a request and, when approved, run it once as
@@ -137,6 +142,14 @@ export declare const INTERRUPTED_MESSAGE = "The connector stopped while this ran
  * starts; a run this process is still recording is left alone.
  */
 export declare function reconcileInterrupted(deps: Pick<ApprovalDeps, "ledger" | "log">): string[];
+/**
+ * Try again the transcripts an approved create could not store: captions YouTube had not made yet, a
+ * source that was withheld and may be released since. The ledger holds what waits, so a restart loses
+ * nothing. A new record is written only when the answer changes.
+ */
+export declare function settleTranscripts(deps: ApprovalDeps): Promise<string[]>;
+/** Runs settleTranscripts while the connector runs, one pass at a time. */
+export declare function startTranscriptSettling(deps: ApprovalDeps): void;
 /** Whether a request was approved and its run failed, so a person may run it again. */
 export declare function isRerunnable(r: ConnectorRecord | undefined): boolean;
 /**
@@ -155,7 +168,7 @@ export declare function rerun(r: ConnectorRecord, person: MiadiPerson, deps: App
 }>;
 export declare function isApprovable(r: ConnectorRecord | undefined): r is ConnectorRecord;
 /** What approving a request does, in one sentence, for the card a person decides on. */
-export declare function consequenceOf(r: ConnectorRecord, authorization?: ProviderAuthorization): string;
+export declare function consequenceOf(r: ConnectorRecord, authorization?: ProviderAuthorization, records?: ConnectorRecord[]): string;
 export declare function registerApprovalRoutes(app: Express, deps: ApprovalDeps): void;
 /** The request, and the decision form for a write-tier person (their token carried in the form they just signed into). */
 /**

package/dist/approve.js

@@ -24,6 +24,8 @@ import { factoryDir, runBriefFile, readQueueState } from "./queue-state.js";
 import { factoryLedgerPath, readFactoryReceipts, receiptsForRecord } from "./factory-receipt.js";
 import { steerAttempts, steerSession, tmuxAdapter } from "./steer.js";
 import { contentHash, versionOf } from "./revisions.js";
+import { TRANSCRIPT_RETRY_MS, transcriptStep } from "./captions.js";
+import { ReviewClient } from "./reviews.js";
 import { canReadReading } from "./reading/privacy.js";
 import { authorizationReceipt, authorizeProvider, briefAttributes, CHOICE_TTL_MS, CODEX_POLICIES, isPersonId, needsPersonChoice, providerPolicyOf, } from "./provider-policy.js";
 export { factoryDir, runBriefFile, readQueueState } from "./queue-state.js";
@@ -180,28 +182,55 @@ export function episodeReferences(record) {
         return m ? `https://github.com/${m[1]}/${m[2]}/issues/${m[3]}` : ref;
     });
 }
+async function callReview(deps, method, path, payload) {
+    const f = deps.fetchImpl ?? fetch;
+    if (!deps.config.reviewToken)
+        throw new Error("The connector host has no review service token");
+    const res = await f(`${deps.config.reviewUrl}${path}`, {
+        method,
+        headers: { accept: "application/json", "content-type": "application/json", authorization: `Bearer ${deps.config.reviewToken}` },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(290_000),
+    });
+    const text = await res.text();
+    let parsed = text;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        /* text */
+    }
+    return { status: res.status, ok: res.ok, response: parsed };
+}
+/** Whether the owner of this video's source registered it as withheld. */
+export function sourceWithheld(records, videoId) {
+    return records.some((r) => r.kind === "source_intent" && r.body.video_id === videoId && r.body.readiness === "withheld");
+}
+function transcriptIo(deps) {
+    return {
+        withheld: (video) => sourceWithheld(current(deps.ledger.all()), video),
+        captions: deps.captions,
+        store: (reviewId, transcript) => callReview(deps, "POST", `/api/reviews/${reviewId}/transcript`, { transcript }),
+    };
+}
+/** The review a create left: its answer names it, also when generation failed and a stub stands; else search by video. */
+async function reviewLeftBy(deps, response, videoId) {
+    const id = response?.id;
+    if (typeof id === "string")
+        return id;
+    try {
+        const rows = await new ReviewClient(deps.config.reviewUrl, deps.config.reviewToken, deps.fetchImpl ?? fetch).search(videoId, 100);
+        const match = rows.find((row) => row.video_id === videoId);
+        return typeof match?.id === "string" ? match.id : null;
+    }
+    catch {
+        return null;
+    }
+}
 export async function executeApproved(record, approver, deps, instructions) {
     const f = deps.fetchImpl ?? fetch;
     const b = record.body;
-    const reviewCall = async (method, path, payload) => {
-        if (!deps.config.reviewToken)
-            throw new Error("The connector host has no review service token");
-        const res = await f(`${deps.config.reviewUrl}${path}`, {
-            method,
-            headers: { accept: "application/json", "content-type": "application/json", authorization: `Bearer ${deps.config.reviewToken}` },
-            body: JSON.stringify(payload),
-            signal: AbortSignal.timeout(290_000),
-        });
-        const text = await res.text();
-        let parsed = text;
-        try {
-            parsed = JSON.parse(text);
-        }
-        catch {
-            /* text */
-        }
-        return { status: res.status, ok: res.ok, response: parsed };
-    };
+    const reviewCall = (method, path, payload) => callReview(deps, method, path, payload);
     const queueBrief = () => {
         // Checked again where the brief is written: an approval, and every rerun of it (jgwill/Miadi#926).
         const authorization = record.kind === "run_request" ? authorizeProvider(record, deps.ledger.all()) : undefined;
@@ -241,7 +270,12 @@ export async function executeApproved(record, approver, deps, instructions) {
                     : b.operation === "new_version"
                         ? await reviewCall("POST", `/api/reviews/${b.review_id}/versions`, b.transcript ? { transcript: b.transcript } : {})
                         : await reviewCall("POST", `/api/reviews/${b.review_id}/transcript`, { transcript: b.transcript });
-            return { outcome: r.ok ? "done" : "failed", operation: b.operation, status: r.status, response: r.response };
+            const result = { outcome: r.ok ? "done" : "failed", operation: b.operation, status: r.status, response: r.response };
+            if (b.operation !== "create" || !deps.captions)
+                return result;
+            const transcript = await transcriptStep({ video_id: b.video_id, review_id: await reviewLeftBy(deps, r.response, b.video_id), since: new Date().toISOString(), ...(b.transcript ? { supplied: b.transcript } : {}) }, transcriptIo(deps));
+            logDecision(deps, { phase: "transcript", record: record.id, video: b.video_id, outcome: transcript.outcome });
+            return { ...result, transcript };
         }
         case "deep_diver_request": {
             const r = await reviewCall("PUT", `/api/reviews/${b.review_id}/diver`, { ready: true, version: b.version, by: plainName(approver.name) });
@@ -369,7 +403,7 @@ blockquote{margin:.2rem 0 .6rem;padding-left:.8rem;border-left:2px solid var(--l
 @media (prefers-color-scheme:dark){.err{color:#ff8a80}}
 </style></head><body><main>${body}</main></body></html>`;
 }
-function summary(r) {
+function summary(r, o = {}) {
     const shown = { ...r.body };
     for (const k of ["markdown", "transcript"])
         if (typeof shown[k] === "string")
@@ -380,7 +414,7 @@ function summary(r) {
 <dt>By</dt><dd>${escapeHtml(r.actor.name)}${r.actor.client_name ? ` through ${escapeHtml(r.actor.client_name)}` : ""}</dd>
 <dt>When</dt><dd>${escapeHtml(r.created_at)}</dd>
 ${r.circle ? `<dt>Circle</dt><dd>${escapeHtml(r.circle)}</dd>` : ""}
-${r.intention ? `<dt>Intention</dt><dd>${escapeHtml(r.intention)}</dd>` : ""}
+${r.intention && o.intention !== false ? `<dt>Intention</dt><dd>${escapeHtml(r.intention)}</dd>` : ""}
 ${r.refs.length ? `<dt>References</dt><dd>${r.refs.map(escapeHtml).join("<br>")}</dd>` : ""}
 <dt>State</dt><dd>${escapeHtml(r.approval_state ?? "—")}</dd>
 ${versionOf(r) > 1 ? `<dt>Version</dt><dd>${versionOf(r)}, the one a decision here decides. Earlier versions stay in the ledger.</dd>` : ""}
@@ -535,6 +569,68 @@ export function reconcileInterrupted(deps) {
     }
     return out;
 }
+/**
+ * Try again the transcripts an approved create could not store: captions YouTube had not made yet, a
+ * source that was withheld and may be released since. The ledger holds what waits, so a restart loses
+ * nothing. A new record is written only when the answer changes.
+ */
+export async function settleTranscripts(deps) {
+    const out = [];
+    if (!deps.captions)
+        return out;
+    for (const r of current(deps.ledger.all())) {
+        const receipt = (r.completion_receipt ?? {});
+        const waiting = receipt.transcript;
+        if (r.kind !== "review_operation_request" || deciding.has(r.id))
+            continue;
+        if (waiting?.outcome !== "waiting_for_captions" && waiting?.outcome !== "held_source_withheld")
+            continue;
+        const b = r.body;
+        const next = await transcriptStep({
+            video_id: waiting.video_id,
+            review_id: waiting.review_id ?? null,
+            // The three days start when the source is released, not when it was held.
+            since: waiting.outcome === "held_source_withheld" ? new Date().toISOString() : waiting.since,
+            ...(b.transcript ? { supplied: b.transcript } : {}),
+        }, transcriptIo(deps));
+        if (next.outcome === waiting.outcome)
+            continue;
+        deps.ledger.append({
+            id: newRecordId(r.kind),
+            kind: r.kind,
+            created_at: new Date().toISOString(),
+            actor: { person_id: "system:miadi-connector", name: "Miadi connector", client_id: "captions" },
+            refs: r.refs,
+            evidence_refs: [],
+            supersedes: r.id,
+            approval_state: r.approval_state,
+            state: r.state,
+            completion_receipt: { ...receipt, transcript: next },
+            body: { decision: "transcript" },
+        });
+        logDecision(deps, { phase: "transcript", record: r.id, video: waiting.video_id, outcome: next.outcome });
+        out.push(r.id);
+    }
+    return out;
+}
+/** Runs settleTranscripts while the connector runs, one pass at a time. */
+export function startTranscriptSettling(deps) {
+    if (!deps.captions)
+        return;
+    let busy = false;
+    const pass = () => {
+        if (busy)
+            return;
+        busy = true;
+        settleTranscripts(deps)
+            .catch((error) => logDecision(deps, { phase: "transcript", error: error instanceof Error ? error.message : String(error) }))
+            .finally(() => {
+            busy = false;
+        });
+    };
+    setTimeout(pass, 30_000).unref();
+    setInterval(pass, TRANSCRIPT_RETRY_MS).unref();
+}
 /** Whether a request was approved and its run failed, so a person may run it again. */
 export function isRerunnable(r) {
     return !!r && r.approval_state === "approved" && r.state === "blocked";
@@ -676,7 +772,7 @@ export function isApprovable(r) {
     return Boolean(r && APPROVABLE.has(r.kind));
 }
 /** What approving a request does, in one sentence, for the card a person decides on. */
-export function consequenceOf(r, authorization) {
+export function consequenceOf(r, authorization, records = []) {
     const b = r.body;
     switch (r.kind) {
         case "run_request":
@@ -686,6 +782,11 @@ export function consequenceOf(r, authorization) {
         case "work_proposal":
             return "Approving starts the work: a brief written from the proposal and your instructions is queued for an agent session.";
         case "review_operation_request":
+            if (b.operation === "create") {
+                return `Approving calls the review service once to create the review, then stores the video's YouTube captions as its transcript, with no model call for the transcript. ${sourceWithheld(records, b.video_id)
+                    ? "This source is registered as withheld: the review is still created, and the transcript waits until the source is released."
+                    : "If YouTube has no captions yet, it tries again every 15 minutes for three days."}`;
+            }
             return `Approving calls the review service once: ${String(b.operation ?? "operation").replace(/_/g, " ")}.`;
         case "deep_diver_request":
             return `Approving marks review version ${b.version ?? "?"} ready for Deep Diver, which queues its pass.`;
@@ -883,14 +984,14 @@ function signInToRead(r, error) {
     // The label names no one and no instruction: this page is shown before sign-in.
     const open = r.approval_state === "awaiting_approval";
     const label = projectRequest(r, { recording: isBeingDecided(r.id) })?.label ?? r.approval_state ?? "";
-    return page(open ? "A Miadi request awaits a decision" : "A Miadi request was decided", `<h1>${open ? "A request awaits a decision" : "A request was decided"}</h1>
+    return page(open ? "A Miadi request awaits a decision" : "A Miadi request was decided", `<h1>${open ? "Sign in to read this request" : "A request was decided"}</h1>
 <p>${escapeHtml(KIND_LABELS[r.kind] ?? r.kind)}, asked ${escapeHtml(r.created_at.slice(0, 16).replace("T", " "))} UTC. ${escapeHtml(label)}.</p>
-<p>${open ? "Sign in to read it. A person with Miadi's write tier then decides; whoever asked can read it." : "Sign in to read what was decided and what came of it. Whoever asked, and anyone with Miadi's write tier, can read it."}</p>
+<p>${open ? "Signing in approves nothing. The next page shows the request, and a person with Miadi's write tier decides there. Whoever asked can read it." : "Sign in to read what was decided and what came of it. Whoever asked, and anyone with Miadi's write tier, can read it."}</p>
 ${error ? `<p class="err" role="alert">${escapeHtml(error)}</p>` : ""}
 <form method="post">
 <label for="t">Your Miadi person token</label>
 <input id="t" name="person_token" type="password" autocomplete="off" required>
-<div class="row"><button class="primary" type="submit">Read the request</button></div>
+<div class="row"><button class="primary" type="submit">Sign in and read the request</button></div>
 </form>`);
 }
 /** The request, and the decision form for a write-tier person (their token carried in the form they just signed into). */
@@ -980,12 +1081,20 @@ function approvePage(deps, r, o = {}) {
     // Freshness binds a decision still to come; a decided run shows the authorization it holds (#926 review R1).
     const authorization = r.kind === "run_request" ? authorizeProvider(r, deps.ledger.all(), { requireFresh: open }) : undefined;
     const blocked = Boolean(authorization && !authorization.authorized);
-    return page("Approve a Miadi request", `<h1>${open ? "Approve a request" : "A decided request"}</h1>
-${actionable ? `<p>${escapeHtml(consequenceOf(r, authorization))} Declining records your refusal. Either is kept in the ledger with your name.</p>` : ""}
+    // Signed in and able to decide: the decision comes before the record's details, and no line says it waits for someone else.
+    const canDecideHere = Boolean(actionable && o.token);
+    const heading = canDecideHere ? "Not approved yet: decide here" : open ? "A request awaiting a decision" : (projectionOf(r, deps)?.label ?? "A decided request");
+    const details = canDecideHere
+        ? `<details><summary>What exactly is asked</summary>${summary(r, { intention: false })}</details>`
+        : `${summary(r)}
+${open ? draftReviewSection(r, deps.draftReview?.stored(r), false) : ""}
+${projectionBlock(projectionOf(r, deps), open ? undefined : r.completion_receipt)}`;
+    return page("Approve a Miadi request", `<h1>${escapeHtml(heading)}</h1>
+${canDecideHere ? `<p>You are signed in. Nothing is approved until you press a button below.</p>` : ""}
+${actionable ? `<p>${escapeHtml(consequenceOf(r, authorization, current(deps.ledger.all())))} Declining records your refusal. Either is kept in the ledger with your name.</p>` : ""}
+${canDecideHere && r.intention ? `<p><strong>Intention:</strong> ${escapeHtml(r.intention)}</p>` : ""}
 ${authorization ? providerSection(r, authorization, actionable ? o.chooserToken : undefined) : ""}
-${summary(r)}
-${open ? draftReviewSection(r, deps.draftReview?.stored(r), Boolean(actionable && o.token && !blocked)) : ""}
-${projectionBlock(projectionOf(r, deps), open ? undefined : r.completion_receipt)}
+${canDecideHere ? draftReviewSection(r, deps.draftReview?.stored(r), !blocked) : ""}
 ${o.error ? `<p class="err" role="alert">${escapeHtml(o.error)}</p>` : ""}
 ${actionable && o.token
         ? `<form method="post">
@@ -1010,7 +1119,8 @@ ${blocked
 <form method="post">
 <input type="hidden" name="person_token" value="${escapeHtml(o.token)}">
 <div class="row"><button class="primary" type="submit" name="decision" value="rerun">Run it again</button></div></form>`
-                    : ""}`);
+                    : ""}
+${details}`);
 }
 /**
  * Which provider a run launches with, who chose it, and, when the requester's own choice is

package/dist/bin.js

@@ -5,6 +5,7 @@ import { identifyThroughMiadi } from "./people.js";
 import { steeringTransport } from "./tools.js";
 import { tmuxAdapter } from "./steer.js";
 import { defaultRuntime } from "./runtime-steer.js";
+import { youtubeCaptions } from "./captions.js";
 import { VERSION } from "./version.js";
 const config = configFromEnv();
 // The host's steering surface (jgwill/Miadi#909): the tmux server of the user the service runs as,
@@ -16,6 +17,8 @@ const { app } = createConnectorApp(config, {
     tmuxSessions: () => tmux.listSessions(),
     // Each session's own steering inbox and Claude Code's registry of running sessions (jgwill/Miadi#930).
     steeringRuntime: defaultRuntime(),
+    // An approved create stores the video's YouTube captions as the review's transcript, with no model call.
+    captions: youtubeCaptions,
 });
 app.listen(config.port, config.host, () => {
     console.log(`@miadi/connector ${VERSION} on http://${config.host}:${config.port}`);

package/dist/captions.d.ts

@@ -0,0 +1,68 @@
+export declare const TRANSCRIPT_RETRY_MS: number;
+export declare const TRANSCRIPT_WINDOW_MS: number;
+export type CaptionsAnswer = {
+    state: "found";
+    text: string;
+    language: string;
+    track: string;
+    words: number;
+    first_ms: number;
+    last_ms: number;
+    duration_s?: number;
+    fetched_at: string;
+} | {
+    state: "none_yet";
+    message?: string;
+};
+export type FetchCaptions = (videoId: string) => Promise<CaptionsAnswer>;
+export interface TranscriptReceipt {
+    outcome: "stored" | "already_present" | "waiting_for_captions" | "held_source_withheld" | "no_captions" | "no_review";
+    video_id: string;
+    review_id?: string;
+    since: string;
+    source?: string;
+    language?: string;
+    chars?: number;
+    words?: number;
+    sha256?: string;
+    covers?: string;
+    stored_at?: string;
+    message?: string;
+}
+export interface TranscriptIo {
+    withheld: (videoId: string) => boolean;
+    captions: FetchCaptions;
+    store: (reviewId: string, transcript: string) => Promise<{
+        status: number;
+        ok: boolean;
+    }>;
+    now?: () => number;
+}
+/**
+ * YouTube's json3 captions as the plain `[mm:ss] text` paragraphs the review service parses into turns.
+ * The words stay as YouTube wrote them. The first line says what they are. Null when they hold no words.
+ */
+export declare function transcriptFromJson3(raw: string, o: {
+    language: string;
+    duration_s?: number;
+    fetched_at: string;
+}): {
+    text: string;
+    words: number;
+    first_ms: number;
+    last_ms: number;
+} | null;
+/** The video's original-language automatic captions, through a local yt-dlp in a directory of its own. */
+export declare const youtubeCaptions: FetchCaptions;
+/**
+ * One attempt at the transcript of a created review. A source its owner registered as withheld is
+ * neither read nor stored until it is released: the transcript the service holds is public.
+ */
+export declare function transcriptStep(input: {
+    video_id: string;
+    review_id: string | null;
+    since: string;
+    supplied?: string;
+}, io: TranscriptIo): Promise<TranscriptReceipt>;
+/** What a transcript receipt says on a request's card and approval page. */
+export declare function transcriptLines(transcript: unknown): string[];

package/dist/captions.js

@@ -0,0 +1,185 @@
+/**
+ * The transcript of a reviewed video, taken from the video's own YouTube captions.
+ *
+ * Guillaume, 2026-11-06: "when this gets triggered and I approve it, the actual transcript of the
+ * video will be available ... And I don't want us to call the API for Gemini to do it because it
+ * costs too much." So an approved `create` reads the captions with a local yt-dlp and stores them.
+ * Nothing here calls a model, and `store` is never sent an empty transcript, because the review
+ * service answers an empty one by asking Gemini (`POST /api/reviews/:id/transcript`).
+ *
+ * YouTube gives a video its address before its captions exist (Episode 550, thread beat 01f2e53e),
+ * so a transcript that cannot be stored yet stays in the request's receipt and is tried again.
+ */
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const VIDEO_ID = /^[A-Za-z0-9_-]{11}$/;
+/** A silence this long, or a paragraph this long, starts the next timestamped paragraph. */
+const PAUSE_MS = 3000;
+const PARAGRAPH_CHARS = 900;
+export const TRANSCRIPT_RETRY_MS = 15 * 60_000;
+export const TRANSCRIPT_WINDOW_MS = 72 * 3_600_000;
+function clock(ms) {
+    const total = Math.floor(ms / 1000);
+    const h = Math.floor(total / 3600);
+    const m = Math.floor((total % 3600) / 60);
+    const s = String(total % 60).padStart(2, "0");
+    return h ? `${h}:${String(m).padStart(2, "0")}:${s}` : `${String(m).padStart(2, "0")}:${s}`;
+}
+/** The covered range in words a person reads: "00:02 to 33:03 of 62:38". */
+function coverage(a) {
+    return `${clock(a.first_ms)} to ${clock(a.last_ms)}${a.duration_s ? ` of ${clock(a.duration_s * 1000)}` : ""}`;
+}
+/**
+ * YouTube's json3 captions as the plain `[mm:ss] text` paragraphs the review service parses into turns.
+ * The words stay as YouTube wrote them. The first line says what they are. Null when they hold no words.
+ */
+export function transcriptFromJson3(raw, o) {
+    const events = JSON.parse(raw).events ?? [];
+    const paragraphs = [];
+    let end = 0;
+    let first = -1;
+    let last = 0;
+    for (const e of events) {
+        const words = (e.segs ?? []).map((s) => s.utf8 ?? "").join("").replace(/\s+/g, " ").trim();
+        if (!words)
+            continue;
+        const start = e.tStartMs ?? 0;
+        const open = paragraphs[paragraphs.length - 1];
+        if (!open || start - end >= PAUSE_MS || words.startsWith(">>") || open.text.length >= PARAGRAPH_CHARS)
+            paragraphs.push({ at: start, text: words });
+        else
+            open.text += ` ${words}`;
+        end = Math.max(end, start + (e.dDurationMs ?? 0));
+        if (first < 0)
+            first = start;
+        last = end;
+    }
+    if (!paragraphs.length)
+        return null;
+    const covered = { first_ms: first, last_ms: last, duration_s: o.duration_s };
+    const header = `(YouTube automatic captions, language ${o.language}, uncorrected, fetched ${o.fetched_at.slice(0, 10)}. They run from ${coverage(covered)}. Names may be misheard, and a voice the captions did not catch is absent.)`;
+    const body = paragraphs.map((p) => `[${clock(p.at)}] ${p.text}`).join("\n\n");
+    return { text: `${header}\n\n${body}\n`, words: paragraphs.reduce((n, p) => n + p.text.split(" ").length, 0), first_ms: first, last_ms: last };
+}
+const run = promisify(execFile);
+/** The video's original-language automatic captions, through a local yt-dlp in a directory of its own. */
+export const youtubeCaptions = async (videoId) => {
+    if (!VIDEO_ID.test(videoId))
+        return { state: "none_yet", message: "Not a YouTube video id." };
+    const dir = mkdtempSync(join(tmpdir(), "miadi-captions-"));
+    try {
+        await run("uvx", [
+            "--quiet",
+            "yt-dlp@latest",
+            "--ignore-config",
+            "--js-runtimes",
+            `node:${process.execPath}`,
+            "--skip-download",
+            "--no-playlist",
+            "--no-warnings",
+            "--write-auto-subs",
+            "--sub-langs",
+            ".*-orig",
+            "--sub-format",
+            "json3",
+            "--write-info-json",
+            "--output",
+            "video.%(ext)s",
+            `https://youtu.be/${videoId}`,
+        ], { cwd: dir, timeout: 180_000, maxBuffer: 16 * 1024 * 1024 });
+        const file = readdirSync(dir).find((f) => /^video\.[\w-]+-orig\.json3$/.test(f));
+        if (!file)
+            return { state: "none_yet" };
+        const track = file.slice("video.".length, -".json3".length);
+        const language = track.slice(0, -"-orig".length);
+        let duration_s;
+        try {
+            const d = JSON.parse(readFileSync(join(dir, "video.info.json"), "utf8")).duration;
+            if (typeof d === "number" && d > 0)
+                duration_s = d;
+        }
+        catch {
+            /* the length is only said when it is known */
+        }
+        const fetched_at = new Date().toISOString();
+        const rendered = transcriptFromJson3(readFileSync(join(dir, file), "utf8"), { language, fetched_at, ...(duration_s ? { duration_s } : {}) });
+        if (!rendered)
+            return { state: "none_yet", message: "The caption track holds no words." };
+        return { state: "found", ...rendered, language, track, ...(duration_s ? { duration_s } : {}), fetched_at };
+    }
+    catch (error) {
+        // A refusal or a timeout today may answer tomorrow, so it waits with the captions that are not there yet.
+        const message = error instanceof Error ? error.message : String(error);
+        return { state: "none_yet", message: message.split("\n").filter(Boolean).pop()?.slice(0, 300) ?? "yt-dlp failed" };
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+};
+/**
+ * One attempt at the transcript of a created review. A source its owner registered as withheld is
+ * neither read nor stored until it is released: the transcript the service holds is public.
+ */
+export async function transcriptStep(input, io) {
+    const { video_id, since } = input;
+    const review_id = input.review_id ?? undefined;
+    const base = { video_id, since, ...(review_id ? { review_id } : {}) };
+    if (!review_id)
+        return { ...base, outcome: "no_review", message: "The review service left no review for this video, so nothing holds a transcript. Running the request again retries it." };
+    if (io.withheld(video_id)) {
+        return { ...base, outcome: "held_source_withheld", message: "The source is registered as withheld. The transcript is stored once the source is released." };
+    }
+    const now = (io.now ?? Date.now)();
+    const expired = now - Date.parse(since) >= TRANSCRIPT_WINDOW_MS;
+    const waiting = (message) => expired ? { ...base, outcome: "no_captions", message: `No transcript after three days of trying, and no model was called. Last answer: ${message}` } : { ...base, outcome: "waiting_for_captions", message };
+    const supplied = input.supplied?.trim();
+    const answer = supplied ? undefined : await io.captions(video_id);
+    if (answer && answer.state !== "found")
+        return waiting(answer.message ?? "YouTube has no captions for this video yet.");
+    const text = (supplied ?? answer.text).trim();
+    if (!text)
+        return waiting("The captions hold no words.");
+    let stored;
+    try {
+        stored = await io.store(review_id, text);
+    }
+    catch (error) {
+        return waiting(`The review service could not be reached: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (stored.status === 409)
+        return { ...base, outcome: "already_present", message: "The review already holds a transcript, which stays." };
+    if (!stored.ok)
+        return waiting(`The review service answered ${stored.status}.`);
+    return {
+        ...base,
+        outcome: "stored",
+        source: supplied ? "supplied with the request" : `YouTube captions (${answer.track})`,
+        chars: text.length,
+        sha256: createHash("sha256").update(text).digest("hex"),
+        stored_at: new Date(now).toISOString(),
+        ...(answer?.state === "found" ? { language: answer.language, words: answer.words, covers: coverage(answer) } : {}),
+    };
+}
+/** What a transcript receipt says on a request's card and approval page. */
+export function transcriptLines(transcript) {
+    const t = transcript;
+    switch (t?.outcome) {
+        case "stored":
+            return [`Transcript: stored from ${t.source}${t.words ? `, ${t.words} words, ${t.covers}` : ""}. No model was called for it.`];
+        case "already_present":
+            return ["Transcript: the review already held one, which stays."];
+        case "waiting_for_captions":
+            return [`Transcript: not stored yet. ${t.message ?? ""} It is tried again every 15 minutes for three days, with no model call.`.trim()];
+        case "held_source_withheld":
+            return ["Transcript: held. The source is registered as withheld, and the transcript is stored once the source is released."];
+        case "no_captions":
+        case "no_review":
+            return [`Transcript: not stored. ${t.message ?? ""}`.trim()];
+        default:
+            return [];
+    }
+}

package/dist/decisions.d.ts

@@ -1,4 +1,10 @@
 export declare const DECISIONS_CARD_URI = "ui://miadi/decisions-v2.html";
+/**
+ * Addresses the card had before. Every one stays readable, because a host keeps the tool metadata it read
+ * until the connection is refreshed by hand, and it renders nothing for a template it cannot read: removing
+ * v1 in 0.1.22 left ChatGPT drawing an empty card (jgwill/Miadi#939).
+ */
+export declare const DECISIONS_CARD_EARLIER_URIS: string[];
 /** The default lifetime of a card's decision token, in seconds; MIADI_CONNECTOR_DECISION_TOKEN_TTL changes it. */
 export declare const DECISION_TOKEN_TTL: number;
 /** Where the tokens travel in a result's `_meta`, keyed by record id. */

package/dist/decisions.js

@@ -25,6 +25,12 @@ import { join } from "node:path";
 import { newSecret } from "./store.js";
 import { DEFAULT_DECISION_TOKEN_TTL } from "./config.js";
 export const DECISIONS_CARD_URI = "ui://miadi/decisions-v2.html";
+/**
+ * Addresses the card had before. Every one stays readable, because a host keeps the tool metadata it read
+ * until the connection is refreshed by hand, and it renders nothing for a template it cannot read: removing
+ * v1 in 0.1.22 left ChatGPT drawing an empty card (jgwill/Miadi#939).
+ */
+export const DECISIONS_CARD_EARLIER_URIS = ["ui://miadi/decisions-v1.html"];
 /** The default lifetime of a card's decision token, in seconds; MIADI_CONNECTOR_DECISION_TOKEN_TTL changes it. */
 export const DECISION_TOKEN_TTL = DEFAULT_DECISION_TOKEN_TTL;
 /** Where the tokens travel in a result's `_meta`, keyed by record id. */

package/dist/reading/contract.d.ts

@@ -35,9 +35,9 @@ export declare const sourcePart: z.ZodObject<{
     locator: z.ZodString;
     provider: z.ZodString;
     caption_kind: z.ZodEnum<{
+        supplied: "supplied";
         manual: "manual";
         automatic: "automatic";
-        supplied: "supplied";
         local_stt: "local_stt";
     }>;
     fetched_at: z.ZodString;

package/dist/request-state.d.ts

@@ -1,23 +1,3 @@
-/**
- * Where a request stands, read once for every surface that shows it: the
- * decision card in the conversation, the approval page, get_run_result and
- * Miadi's /research (jgwill/Miadi#889, Mission A). A surface shows the
- * projection's `label` and `lines`. It does not read the record's state,
- * approval state or receipt by itself.
- *
- * Stages, from the ledger's folded record (see `current()`):
- * - awaiting_decision: awaiting_approval, nothing decided
- * - recording: a decision is being recorded, or it was approved and its run is
- *   going (written ahead as outcome `running`, jgwill/Miadi#924)
- * - declined, sent_back: decided, nothing ran
- * - dispatching: approved, and its brief is queued or running (state in_progress)
- * - completed: approved, and its run finished (state completed)
- * - failed: approved, and its run failed (state blocked); the same approval may run it again
- *
- * Approving with changes keeps the changes with the decision. A kind whose run
- * does not carry instructions (approve.ts runBrief carries them only for runs and
- * work proposals) lists them as outstanding. The projection never says they ran.
- */
 import type { ConnectorRecord } from "./records.js";
 export declare const APPROVABLE_KINDS: readonly ["run_request", "review_operation_request", "deep_diver_request", "review_episode_link_request", "work_proposal", "session_completion_proposal", "inquiry_episode_request", "session_steer_request"];
 export declare const APPROVABLE: ReadonlySet<string>;

package/dist/request-state.js

@@ -1,3 +1,24 @@
+/**
+ * Where a request stands, read once for every surface that shows it: the
+ * decision card in the conversation, the approval page, get_run_result and
+ * Miadi's /research (jgwill/Miadi#889, Mission A). A surface shows the
+ * projection's `label` and `lines`. It does not read the record's state,
+ * approval state or receipt by itself.
+ *
+ * Stages, from the ledger's folded record (see `current()`):
+ * - awaiting_decision: awaiting_approval, nothing decided
+ * - recording: a decision is being recorded, or it was approved and its run is
+ *   going (written ahead as outcome `running`, jgwill/Miadi#924)
+ * - declined, sent_back: decided, nothing ran
+ * - dispatching: approved, and its brief is queued or running (state in_progress)
+ * - completed: approved, and its run finished (state completed)
+ * - failed: approved, and its run failed (state blocked); the same approval may run it again
+ *
+ * Approving with changes keeps the changes with the decision. A kind whose run
+ * does not carry instructions (approve.ts runBrief carries them only for runs and
+ * work proposals) lists them as outstanding. The projection never says they ran.
+ */
+import { transcriptLines } from "./captions.js";
 export const APPROVABLE_KINDS = [
     "run_request",
     "review_operation_request",
@@ -134,6 +155,7 @@ function projectCore(record, ctx = {}) {
         const lines = [...decisionLines(decision), `Failure: ${failure}`];
         if (receipt.outcome)
             lines.push(`Outcome: ${outcomeWord}.`);
+        lines.push(...transcriptLines(receipt.transcript));
         lines.push(...outstanding);
         return finish({
             ...base,
@@ -183,6 +205,7 @@ function projectCore(record, ctx = {}) {
         lines.push(`Outcome: ${outcomeWord}.`);
     if (receiptUrl)
         lines.push(`Review: ${receiptUrl}`);
+    lines.push(...transcriptLines(receipt.transcript));
     lines.push(...outstanding);
     return finish({
         ...base,

package/dist/server.d.ts

@@ -12,6 +12,7 @@
 import type { RuntimeDeps } from "./runtime-steer.js";
 import { MiadiOAuthProvider } from "./oauth.js";
 import type { MiadiPerson } from "./people.js";
+import type { FetchCaptions } from "./captions.js";
 import { Ledger } from "./store.js";
 import type { ConnectorRecord } from "./records.js";
 import type { ConnectorConfig } from "./config.js";
@@ -40,6 +41,8 @@ export interface ConnectorDeps {
     steerSettleMs?: number;
     /** Where sessions and their steering inboxes live (jgwill/Miadi#930). */
     steeringRuntime?: RuntimeDeps;
+    /** Reads a video's captions for an approved create; the service passes youtubeCaptions, tests their own. */
+    captions?: FetchCaptions;
     /** Person-token attempts allowed per address in 15 minutes on each sign-in form (default 30). */
     tokenAttemptsPerWindow?: number;
     /** Where decision events go (default: one JSON line on stdout, the service journal); tests collect them (jgwill/Miadi#924). */

package/dist/server.js

@@ -5,7 +5,7 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 import { mcpAuthRouter, createOAuthMetadata, getOAuthProtectedResourceMetadataUrl } from "@modelcontextprotocol/sdk/server/auth/router.js";
 import { requireBearerAuth } from "@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js";
 import { MiadiOAuthProvider, SCOPES, SCOPE_CONTRIBUTE, SCOPE_READ, emptyOAuthState } from "./oauth.js";
-import { reconcileInterrupted, registerApprovalRoutes, registerProviderPolicyRoutes } from "./approve.js";
+import { logDecision, reconcileInterrupted, registerApprovalRoutes, registerProviderPolicyRoutes, startTranscriptSettling } from "./approve.js";
 import { DecisionTokens } from "./decisions.js";
 import { JsonFile, Ledger, ensureStateDir, statePaths } from "./store.js";
 import { registerTools } from "./tools.js";
@@ -80,10 +80,12 @@ export function createConnectorApp(config, deps) {
         tmux: deps.tmux,
         steerSettleMs: deps.steerSettleMs,
         ...(deps.steeringRuntime ? { steeringRuntime: deps.steeringRuntime } : {}),
+        ...(deps.captions ? { captions: deps.captions } : {}),
         log: deps.log,
     };
     // A run the connector was recording when it last stopped is failed now, so a person may run it again (#924).
     reconcileInterrupted(approvalDeps);
+    startTranscriptSettling(approvalDeps);
     registerApprovalRoutes(app, approvalDeps);
     registerProviderPolicyRoutes(app, approvalDeps);
     const decisionTokens = new DecisionTokens(config.stateDir, config.decisionTokenTtl);
@@ -105,6 +107,12 @@ export function createConnectorApp(config, deps) {
         bearer(req, res, next);
     };
     const handle = async (req, res) => {
+        // What a host asks for to draw the card, for the journal: a blank card is otherwise invisible from here (jgwill/Miadi#939).
+        const rpc = (req.body ?? {});
+        if (rpc.method === "resources/read")
+            logDecision(approvalDeps, { phase: "card_template_read", uri: String(rpc.params?.uri ?? "").slice(0, 120) });
+        if (rpc.method === "tools/call" && rpc.params?.name === "show_decisions")
+            logDecision(approvalDeps, { phase: "show_decisions" });
         const ctx = {
             config,
             miadi,

package/dist/tools.js

@@ -18,7 +18,7 @@ import { CIRCLES, CIRCLE_IDS, CLAIM_CATEGORIES, DOMAINS, HANDOFF_STATES, current
 import { VERSION } from "./version.js";
 import { AlreadyDecided, DECISIONS, DecisionConflict, KIND_LABELS, ProviderChoiceRequired, STILL_RUNNING, StaleVersion, approvalStateOf, consequenceOf, decide, decisionWaitOf, isApprovable, isBeingDecided, logDecision, readQueueState, requestProjection, settleWithin, } from "./approve.js";
 import { RevisionRefused, requestHistory, revisionRecord, supersedeRecords, versionOf } from "./revisions.js";
-import { DECISIONS_CARD_HTML, DECISIONS_CARD_URI, DECISION_TOKENS_META } from "./decisions.js";
+import { DECISIONS_CARD_EARLIER_URIS, DECISIONS_CARD_HTML, DECISIONS_CARD_URI, DECISION_TOKENS_META } from "./decisions.js";
 import { discoverProviders, jevConfigOf, resolveProvider, routerPreflight, PROVIDERS } from "./providers.js";
 import { authorizesActions, missionStatus, primaryIssueOf, resolveMissionSubject } from "./mission-status.js";
 import { authorizationReceipt, authorizeProvider, CHOICE_PROVIDERS, isPersonId, needsPersonChoice, providerPolicyOf } from "./provider-policy.js";
@@ -1066,7 +1066,16 @@ export function registerTools(server, ctx) {
             const r = await reviews.get(reviewId);
             if (!r)
                 return { id, state: "not_found" };
-            return { id, title: r.title, text: r.version?.markdown ?? "", url: `${config.reviewUrl}/review/${reviewId}`, metadata: { latest_version: r.latest_version, video_id: r.video_id } };
+            // The review's stored transcript comes with it, so the agent that asked for the review can read what was said.
+            const turns = Array.isArray(r.transcript?.turns) ? r.transcript.turns : [];
+            const said = turns.map((t) => `${t.at ? `[${t.at}] ` : ""}${t.speaker || t.label ? `${t.speaker || t.label}: ` : ""}${t.text}`).join("\n\n");
+            return {
+                id,
+                title: r.title,
+                text: `${r.version?.markdown ?? ""}${said ? `\n\n## Transcript\n\n${said}\n` : ""}`,
+                url: `${config.reviewUrl}/review/${reviewId}`,
+                metadata: { latest_version: r.latest_version, video_id: r.video_id, has_transcript: Boolean(said), ...(r.transcript?.source ? { transcript_source: r.transcript.source } : {}) },
+            };
         }
         const rec = records().find((x) => x.id === id);
         if (!rec)
@@ -1946,7 +1955,7 @@ export function registerTools(server, ctx) {
     }));
     server.registerTool("request_review_operation", {
         title: "Request a review operation",
-        description: "Ask for one review-service operation: create (a review from a YouTube URL), import_markdown (a hand-written version), new_version (regenerate), store_transcript. It waits for a person's approval; check review_lookup first so nothing is duplicated.",
+        description: "Ask for one review-service operation: create (a review from a YouTube URL; once approved it also stores the video's YouTube captions as the review's transcript, with no model call), import_markdown (a hand-written version), new_version (regenerate), store_transcript. It waits for a person's approval; check review_lookup first so nothing is duplicated.",
         inputSchema: {
             operation: z.enum(["create", "import_markdown", "new_version", "store_transcript"]),
             review_id: z.string().optional(),
@@ -2247,16 +2256,18 @@ export function registerTools(server, ctx) {
                 shown[k] = `${shown[k].length} chars`;
         return JSON.stringify({ ...shown, refs: r.refs.length ? r.refs : undefined }, null, 2);
     };
-    server.registerResource("miadi-decisions-card", DECISIONS_CARD_URI, { title: "Miadi decisions", description: "Requests awaiting a person's decision, decided by the person's own click.", mimeType: "text/html;profile=mcp-app" }, async () => ({
-        contents: [
-            {
-                uri: DECISIONS_CARD_URI,
-                mimeType: "text/html;profile=mcp-app",
-                text: DECISIONS_CARD_HTML,
-                _meta: { ui: { prefersBorder: true, csp: { connectDomains: [], resourceDomains: [] } }, "openai/widgetDescription": "Cards for the requests awaiting the person's decision." },
-            },
-        ],
-    }));
+    for (const uri of [DECISIONS_CARD_URI, ...DECISIONS_CARD_EARLIER_URIS]) {
+        server.registerResource(uri === DECISIONS_CARD_URI ? "miadi-decisions-card" : `miadi-decisions-card-${uri.replace(/\W+/g, "-")}`, uri, { title: "Miadi decisions", description: "Requests awaiting a person's decision, decided by the person's own click.", mimeType: "text/html;profile=mcp-app" }, async () => ({
+            contents: [
+                {
+                    uri,
+                    mimeType: "text/html;profile=mcp-app",
+                    text: DECISIONS_CARD_HTML,
+                    _meta: { ui: { prefersBorder: true, csp: { connectDomains: [], resourceDomains: [] } }, "openai/widgetDescription": "Cards for the requests awaiting the person's decision." },
+                },
+            ],
+        }));
+    }
     server.registerTool("show_decisions", {
         title: "Show the requests awaiting a decision",
         description: "Show the requests that await a person's decision (runs, work proposals, review operations, Deep Diver, episode links, session endings) as cards in the conversation. The person approves, approves with changes, sends back or declines each one with their own click; you cannot decide for them. Call it after making a request, or when the person asks what waits for them. Optionally pass record_id to show one request.",
@@ -2290,7 +2301,7 @@ export function registerTools(server, ctx) {
                 created_at: r.created_at,
                 circle: r.circle,
                 intention: r.intention,
-                consequence: consequenceOf(r, providerAuthorizationOf(r)),
+                consequence: consequenceOf(r, providerAuthorizationOf(r), records()),
                 detail: detailOf(r),
                 ...(r.kind === "run_request" || r.kind === "work_proposal"
                     ? {
@@ -2513,7 +2524,7 @@ export const TOOL_STATUS = {
     supersede_pending_requests: "live, contribute (retires named earlier requests still waiting and joins them as earlier versions of the one that stands)",
     request_session_steer: "live, contribute, write tier (one correction to a working agent, forwarded to its runtime; runs inside an approved run's steering grant, else one scoped human decision; get_capabilities.steering says whether the transport works now and which providers have an adapter)",
     revoke_session_steering: "live, contribute, write tier (stops a run's steering, or one steer not yet consumed)",
-    request_review_operation: "live, contribute, needs_approval",
+    request_review_operation: "live, contribute, needs_approval (create also stores the video's YouTube captions as the review's transcript, no model call)",
     request_screenwalk_reading: "live, contribute, needs_approval (host provider adapter required; stops at editorial decision)",
     request_reading_import: "live, contribute, needs_approval (exact public import; atomic service contract required)",
     request_deep_diver: "live, contribute, needs_approval",

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.23";
+export declare const VERSION = "0.1.25";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "0.1.23";
+export const VERSION = "0.1.25";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miadi/connector",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "The Miadi connector: one remote MCP service through which a person signed in with their Miadi person token, from ChatGPT or any MCP client, reads sessions, reviews, episodes and circles and records observations, inquiries, handoffs and proposals with their name on each record.",
   "license": "MIT",
   "author": "Miadi",