@miadi/connector 0.1.20 → 0.1.22

package/dist/mission-status.js

@@ -1,4 +1,4 @@
-import { steerAttempts, steeringGrantOf, checkGrant } from "./steer.js";
+import { steerAttempts, steeringGrantOf, steeringRevoked, checkGrant } from "./steer.js";
 import { missionResult, redactResult, submittedWithWriteTier } from "./mission-result.js";
 const ISSUE_REF = /^([\w.-]+)\/([\w.-]+)#(\d+)$/;
 const SESSION_REF = /^session:([0-9a-f-]{36})$/;
@@ -389,8 +389,14 @@ export async function missionStatus(ref, records, deps) {
     }
     const grant = steeringGrantOf(record);
     const attempts = steerAttempts(records, record.id);
-    const grantCheck = grant ? checkGrant(grant, attempts, now) : null;
-    const grantState = grantCheck === null ? "none" : grantCheck === "ok" ? "active" : grantCheck === "expired_grant" ? "expired_grant" : "exhausted";
+    const grantCheck = grant ? checkGrant(grant, attempts, now, steeringRevoked(records, record.id)) : null;
+    const grantState = grantCheck === null ? "none" : grantCheck === "ok" ? "active" : grantCheck === "expired_grant" ? "expired_grant" : grantCheck === "revoked" ? "revoked" : "exhausted";
+    const steers = deps.steerDeliveryOf
+        ? records.filter((r) => r.kind === "session_steer_request" && r.refs.includes(record.id)).flatMap((r) => {
+            const delivery = deps.steerDeliveryOf(r);
+            return delivery ? [{ id: r.id, at: r.created_at, by: r.actor.name, state: delivery.state, route: delivery.route, delivery }] : [];
+        })
+        : [];
     const receipt = (record.completion_receipt ?? {});
     const anyLive = sessions.some((s) => s.live === "running");
     const prs = issues.filter((i) => i.merged !== undefined);
@@ -464,7 +470,7 @@ export async function missionStatus(ref, records, deps) {
         ...(queue ? { queue } : {}),
         sessions,
         issues,
-        steering: { grant: grantState, attempts_used: attempts, ...(grant?.max_attempts !== undefined ? { max_attempts: grant.max_attempts } : {}) },
+        steering: { grant: grantState, attempts_used: attempts, ...(grant?.max_attempts !== undefined ? { max_attempts: grant.max_attempts } : {}), ...(steers.length ? { steers } : {}) },
         ...(provider ? { provider } : {}),
         stage_truth: stageTruth,
         mission_stage: missionStage(standing ?? null, stageTruth),

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

@@ -36,7 +36,7 @@ export declare const DOMAINS: readonly ["creative", "ceremonial", "engineering"]
 /** #815 "claim category": what kind of statement a record makes. */
 export declare const CLAIM_CATEGORIES: readonly ["observed", "hypothesis", "desired_future", "fiction", "verified_implementation"];
 export type ClaimCategory = (typeof CLAIM_CATEGORIES)[number];
-export declare const RECORD_KINDS: readonly ["observation", "inquiry", "link", "work_proposal", "run_request", "handoff", "source_intent", "review_operation_request", "deep_diver_request", "review_episode_link_request", "calendar_event_draft", "session_completion_proposal", "research_artifact", "inquiry_episode_request", "session_steer_request", "provider_choice", "provider_policy"];
+export declare const RECORD_KINDS: readonly ["observation", "inquiry", "link", "work_proposal", "run_request", "handoff", "source_intent", "review_operation_request", "deep_diver_request", "review_episode_link_request", "calendar_event_draft", "session_completion_proposal", "research_artifact", "inquiry_episode_request", "session_steer_request", "steering_revocation", "provider_choice", "provider_policy"];
 export type RecordKind = (typeof RECORD_KINDS)[number];
 /** #816 handoff states. */
 export declare const HANDOFF_STATES: readonly ["pending", "blocked", "ready", "in_progress", "completed", "withdrawn"];

package/dist/records.js

@@ -61,6 +61,8 @@ export const RECORD_KINDS = [
     "research_artifact",
     "inquiry_episode_request",
     "session_steer_request",
+    // A person stops a run's steering, or one steer still waiting at the runtime (jgwill/Miadi#930).
+    "steering_revocation",
     // A requester's own per-mission provider choice and provider policy, made on the connector's pages (jgwill/Miadi#926).
     "provider_choice",
     "provider_policy",

package/dist/request-state.js

@@ -29,7 +29,12 @@ const OUTCOME_WORDS = {
     marked_ready: "marked ready for Deep Diver",
     decided: "recorded",
     nothing_to_run: "nothing to run",
-    accepted: "accepted by the session",
+    accepted: "typed into an idle session, which turned busy; its delivery says whether the model read it",
+    queued_at_runtime: "handed to the session's inbox, on its way to the model",
+    delivered_to_agent_context: "delivered: the model has it",
+    acknowledged: "delivered, and the agent said so",
+    behavior_adjusted: "delivered, and the agent's next action shows it",
+    expired: "expired before the model read it",
     submitted: "typed into the session, acceptance unconfirmed",
     failed: "failed",
 };

package/dist/research-digest.d.ts

@@ -0,0 +1,30 @@
+/**
+ * What a shelf report is, read from its own Markdown, for a shelf a person can look through: its
+ * title, its opening, how long it is, what is inside, how many sources it cites. Everything here is
+ * computed from the file; nothing is summarised or invented. jgwill/Miadi#879.
+ */
+export interface ReportDigest {
+    title: string;
+    /** The document names itself; otherwise the title is its folder's name. */
+    titled: boolean;
+    /** The report's first paragraph of prose, without Markdown marks. */
+    excerpt?: string;
+    words: number;
+    minutes: number;
+    /** Its `##` and `###` headings, in order. */
+    headings: string[];
+    sections: number;
+    /** Distinct web addresses it cites. */
+    sources: number;
+}
+/** `jacqueline-m-quinless-…-261029-0e1f…` → `jacqueline m quinless …`: the date and uuid a folder name ends in are not its name. */
+export declare function folderTitle(name: string): string;
+export declare function digestReport(markdown: string, folder: string): ReportDigest;
+/**
+ * The text as the page shows it. A stray fence would turn the rest of a report into one code box, so
+ * a fence with no close in reach is left out of the display. The file itself is never changed.
+ */
+export declare function readableMarkdown(markdown: string): {
+    markdown: string;
+    repaired: boolean;
+};

package/dist/research-digest.js

@@ -0,0 +1,104 @@
+/**
+ * What a shelf report is, read from its own Markdown, for a shelf a person can look through: its
+ * title, its opening, how long it is, what is inside, how many sources it cites. Everything here is
+ * computed from the file; nothing is summarised or invented. jgwill/Miadi#879.
+ */
+const WORDS_PER_MINUTE = 230;
+const MAX_HEADINGS = 6;
+const MAX_EXCERPT = 280;
+/** A stray fence must not swallow a report: a block longer than this is not treated as code. */
+const MAX_FENCE_LINES = 60;
+const MAX_TITLE = 100;
+/** `jacqueline-m-quinless-…-261029-0e1f…` → `jacqueline m quinless …`: the date and uuid a folder name ends in are not its name. */
+export function folderTitle(name) {
+    const bare = name
+        .replace(/^ep\d+[-_]/i, "")
+        .replace(/-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, "")
+        .replace(/-\d{6,10}(-[0-9a-f]{6,})?$/i, "")
+        .replace(/[-_]+/g, " ")
+        .trim();
+    return bare ? bare[0].toUpperCase() + bare.slice(1) : name;
+}
+function plain(text) {
+    return text
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, "")
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+        .replace(/[`*_~]+/g, "")
+        .replace(/<[^>]+>/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+/** The lines outside fenced code, with a fence left alone when no close comes within reach. */
+function outsideFences(lines) {
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const open = /^(```|~~~)/.exec(lines[i]);
+        if (!open) {
+            out.push(lines[i]);
+            continue;
+        }
+        const close = lines.slice(i + 1, i + 1 + MAX_FENCE_LINES).findIndex((l) => l.trimEnd() === open[1]);
+        if (close < 0)
+            continue;
+        i += close + 1;
+    }
+    return out;
+}
+/** A heading that is a prompt, a command or a chat fragment is not the document's name. */
+const nameable = (t) => t.length > 0 && t.length <= MAX_TITLE && !/^@/.test(t) && !/\s--[a-z]/.test(t) && !/^(hey|hi|ok|okay|so|please|can you|could you)\b/i.test(t);
+/** How a document was made is not what it is about. */
+const PROVENANCE = /^(parent vessel|inquiry vessel|author role|mission|seed for|for the author's review|rendered from|status:|date:|woven to|generated)\b|\/(srv|workspace|a\/src|home)\/|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i;
+export function digestReport(markdown, folder) {
+    const clean = outsideFences(markdown.replace(/^---\n[\s\S]*?\n---\n/, "").split("\n"));
+    const body = clean.join("\n");
+    const h1 = clean.find((l) => /^#\s+\S/.test(l));
+    const h1Text = h1 ? plain(h1.replace(/^#\s+/, "")) : "";
+    const headings = clean.filter((l) => /^#{2,3}\s+\S/.test(l)).map((l) => plain(l.replace(/^#+\s+/, "")));
+    let excerpt;
+    for (const block of body.split(/\n\s*\n/)) {
+        const t = block.trim();
+        if (!t || /^(#|\||>|[-*+]\s|\d+\.\s|!\[|<|---|===)/.test(t))
+            continue;
+        const p = plain(t);
+        if (p.split(" ").length < 8 || PROVENANCE.test(p))
+            continue;
+        excerpt = p.length > MAX_EXCERPT ? `${p.slice(0, MAX_EXCERPT).replace(/\s+\S*$/, "")}…` : p;
+        break;
+    }
+    const words = plain(body.replace(/^#+\s+/gm, "")).split(" ").filter(Boolean).length;
+    const titled = nameable(h1Text);
+    return {
+        title: titled ? h1Text : folderTitle(folder),
+        titled,
+        ...(excerpt ? { excerpt } : {}),
+        words,
+        minutes: Math.max(1, Math.round(words / WORDS_PER_MINUTE)),
+        headings: headings.slice(0, MAX_HEADINGS),
+        sections: headings.length,
+        sources: new Set(markdown.match(/https?:\/\/[^\s)\]>"']+/g) ?? []).size,
+    };
+}
+/**
+ * The text as the page shows it. A stray fence would turn the rest of a report into one code box, so
+ * a fence with no close in reach is left out of the display. The file itself is never changed.
+ */
+export function readableMarkdown(markdown) {
+    const lines = markdown.split("\n");
+    const out = [];
+    let repaired = false;
+    for (let i = 0; i < lines.length; i++) {
+        const open = /^(```|~~~)/.exec(lines[i]);
+        if (!open) {
+            out.push(lines[i]);
+            continue;
+        }
+        const close = lines.slice(i + 1, i + 1 + MAX_FENCE_LINES).findIndex((l) => l.trimEnd() === open[1]);
+        if (close < 0) {
+            repaired = true;
+            continue;
+        }
+        out.push(...lines.slice(i, i + close + 2));
+        i += close + 1;
+    }
+    return { markdown: out.join("\n"), repaired };
+}

package/dist/research-shelf.d.ts

@@ -0,0 +1,173 @@
+import { type ArtefactWeave } from "@miadi/inquiry-weave";
+import { type ReportDigest } from "./research-digest.js";
+/** A saved report may be 1 MB of characters; several times that is not a document anyone reads through a tool. */
+export declare const MAX_SHELF_FILE_BYTES: number;
+export declare class ShelfRefusal extends Error {
+    readonly code: "invalid_ref" | "not_found" | "forbidden";
+    constructor(code: "invalid_ref" | "not_found" | "forbidden", message: string);
+}
+/** Who may read a folder. `weave` is undefined for a folder no one saved through a door. */
+export declare function canReadShelf(weave: ArtefactWeave | undefined, person: {
+    id: string;
+    api_tier: string | null;
+}): boolean;
+export interface ShelfReadOptions {
+    file?: string;
+    offset?: number;
+    revision?: string;
+    maxBytes?: number;
+}
+/** The folder's manifest, and one file's page when a file is named or the folder holds its report. */
+export declare function readShelfArtefact(root: string, name: string, person: {
+    id: string;
+    api_tier: string | null;
+}, opts?: ShelfReadOptions): Promise<{
+    note: string;
+    files_truncated?: string | undefined;
+    episodes: string[];
+    git: {
+        commit?: string;
+        committed_at?: string;
+        uncommitted_changes?: boolean;
+        state: "known" | "unknown";
+    };
+    files: {
+        path: string;
+        bytes: number;
+        sha256?: string;
+        readable: boolean;
+    }[];
+    saved?: {
+        file: string;
+        sha256: string;
+        bytes: number;
+        saved_at: string;
+        via: string | undefined;
+        refs: string[];
+    } | undefined;
+    issue?: string | undefined;
+    issue_url?: string | undefined;
+    circle?: string | undefined;
+    visibility: "circle" | "published" | "private" | "proposed";
+    owner?: {
+        person_id: string;
+        name: string | undefined;
+    } | undefined;
+    artefact: string;
+} | {
+    page: {
+        offset: number;
+        end: number;
+        bytes: number;
+        sha256: string;
+        complete: boolean;
+        next: {
+            offset: number;
+            revision: string;
+        } | null;
+    };
+    text: string;
+    modified_at?: string | undefined;
+    verification?: string | undefined;
+    bytes: number;
+    sha256: string;
+    verified: boolean;
+    file: string;
+    content_type: string;
+    integrity: string;
+    file_git: {
+        commit?: string;
+        committed_at?: string;
+        uncommitted_changes?: boolean;
+        state: "known" | "unknown";
+    };
+    files_truncated?: string | undefined;
+    episodes: string[];
+    git: {
+        commit?: string;
+        committed_at?: string;
+        uncommitted_changes?: boolean;
+        state: "known" | "unknown";
+    };
+    files: {
+        path: string;
+        bytes: number;
+        sha256?: string;
+        readable: boolean;
+    }[];
+    saved?: {
+        file: string;
+        sha256: string;
+        bytes: number;
+        saved_at: string;
+        via: string | undefined;
+        refs: string[];
+    } | undefined;
+    issue?: string | undefined;
+    issue_url?: string | undefined;
+    circle?: string | undefined;
+    visibility: "circle" | "published" | "private" | "proposed";
+    owner?: {
+        person_id: string;
+        name: string | undefined;
+    } | undefined;
+    artefact: string;
+}>;
+/** One thing on the shelf, as its own files say it is: computed from them, never summarised. */
+export interface ShelfListing extends ReportDigest {
+    ref: string;
+    artefact: string;
+    /** `report`: saved through a door, with its hash. `folder`: anything else with a document. `notes`: agent instructions or unreadable files only. */
+    kind: "report" | "folder" | "notes";
+    /** The document its title and opening come from, the one a reader opens on. */
+    main?: string;
+    files: number;
+    /** Saved, or last woven, or its main document's last change. */
+    at?: string;
+    owner?: {
+        person_id: string;
+        name?: string;
+    };
+    visibility: string;
+    circle?: string;
+    issue?: string;
+    issue_url?: string;
+    episodes: {
+        number?: number;
+        title: string;
+    }[];
+    saved?: {
+        sha256: string;
+        bytes: number;
+        saved_at: string;
+        via?: string;
+        refs: string[];
+    };
+}
+/** One folder's listing. A folder that cannot be read is listed by its name. */
+export declare function shelfListing(root: string, name: string, weave: ArtefactWeave | undefined): ShelfListing;
+export type ShelfSort = "newest" | "oldest" | "longest" | "title";
+export declare function sortListings(items: ShelfListing[], sort?: ShelfSort): ShelfListing[];
+/**
+ * The shelf as this person may read it. `mine` is what they own. `all` is every folder, the write
+ * tier's alone, because a folder another person owns or no one owns is theirs to read and no one else's.
+ */
+export declare function listShelfArtefacts(root: string, person: {
+    id: string;
+    api_tier: string | null;
+}, opts?: {
+    scope?: "mine" | "all";
+    query?: string;
+    kind?: ShelfListing["kind"];
+    sort?: ShelfSort;
+    limit?: number;
+    offset?: number;
+}): Promise<{
+    scope: "mine" | "all";
+    total: number;
+    offset: number;
+    limit: number;
+    items: ShelfListing[];
+    next_offset: number | null;
+    read_with: string;
+}>;