@ixo/openhands-sdk 0.0.0-stage → 0.1.0

package/dist/cjs/rubric/roundTrips.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roundTrips.d.ts","sourceRoot":"","sources":["../../../src/rubric/roundTrips.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEvD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,GAAI,OAAO,QAAQ,KAAG,OAG5C,CAAC"}

package/dist/cjs/rubric/roundTrips.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roundTrips = void 0;
+const terms_ts_1 = require("./terms.js");
+/**
+ * The round-trip guard the tests lean on: published terms must survive
+ * parsing, byte for byte, or a reader sees different terms than the poster
+ * signed. It is the drift trap's alarm — the one this estate has paid for
+ * twice, when `campaign` and then `followUp` joined the type and not the
+ * parser.
+ *
+ * **Its own module because `parseTerms` is expensive to carry.** This lived
+ * in `compose.ts`, which the composer imports for `formTerms` — so every
+ * phone that opened /ask downloaded the whole validation apparatus (every
+ * gate check, every trim, every field the parser rebuilds) to run a guard
+ * that only ever runs in tests. Measured: moving it here paid for the
+ * `+ Then` chip's kilobyte on three pages that had none to spare.
+ */
+const roundTrips = (terms) => {
+    const back = (0, terms_ts_1.parseTerms)(JSON.parse(JSON.stringify(terms)));
+    return back !== null && JSON.stringify(back) === JSON.stringify(terms);
+};
+exports.roundTrips = roundTrips;
+//# sourceMappingURL=roundTrips.js.map

package/dist/cjs/rubric/roundTrips.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"roundTrips.js","sourceRoot":"","sources":["../../../src/rubric/roundTrips.ts"],"names":[],"mappings":";;;AAAA,yCAAuD;AAEvD;;;;;;;;;;;;;GAaG;AACI,MAAM,UAAU,GAAG,CAAC,KAAe,EAAW,EAAE;IACrD,MAAM,IAAI,GAAG,IAAA,qBAAU,EAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAY,CAAC,CAAC;IACtE,OAAO,IAAI,KAAK,IAAI,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AACzE,CAAC,CAAC;AAHW,QAAA,UAAU,cAGrB"}

package/dist/cjs/rubric/terms.d.ts

@@ -0,0 +1,611 @@
+/**
+ * What would count as done — derived from the ask itself, before the work
+ * exists. Shared deliberately: the agent that judges work and the app that
+ * posts it must read a sentence the same way, or a poster is promised one
+ * thing and a worker is held to another.
+ *
+ * This half is pure and tiny because the browser loads it. The judging half
+ * lived in ./verdict.ts until the oracle migration retired the in-repo checker;
+ * the receipt shape it wrote survives in ./receipt.ts for the readers.
+ */
+import type { GeoBox } from "../geo/box.ts";
+export type SkillId = "url-check" | "read" | "write" | "answer";
+export interface SkillMatch {
+    skill: SkillId;
+    url?: string;
+}
+export declare function firstUrl(text: string): string | null;
+export declare function matchSkill(title: string): SkillMatch | null;
+export declare function matchHuman(title: string): boolean;
+export declare function hostOf(url?: string): string;
+export type GateId = "non-empty" | "min-length" | "mentions-url" | "reports-status" | "mentions-terms" | "re-measure" | "file-type" | "max-bytes" | "with-file" | "mapped-grid" | "located" | "not-already-mapped" | "at-registered-point" | "within-radius" | "weather-consistent" | "daylight-consistent" | "before-after";
+export type Gate = {
+    id: "non-empty";
+} | {
+    id: "min-length";
+    chars: number;
+} | {
+    id: "mentions-url";
+    url: string;
+} | {
+    id: "reports-status";
+} | {
+    id: "mentions-terms";
+    terms: string[];
+} | {
+    id: "re-measure";
+    url: string;
+} | {
+    id: "file-type";
+    accept: string;
+} | {
+    id: "max-bytes";
+    bytes: number;
+}
+/**
+ * A second file comes with the deliverable. The claim's primary file is the
+ * photograph (or the pair); this one rides beside it in the envelope's
+ * `extra`, held to the same ceiling a file deliverable has. The capture asks
+ * for it and the checker measures it — a block, not a courtesy.
+ */
+ | {
+    id: "with-file";
+    bytes: number;
+}
+/**
+ * Work that happened on a map, judged by what appeared on the map.
+ *
+ * The only gate here whose evidence is not the deliverable: the checker
+ * asks OpenStreetMap what changed inside `box`, within `days` of the ask
+ * opening, and whether the mapper the worker named is the one who did it.
+ * The deliverable's job is to say which OSM account to credit.
+ */
+ | {
+    id: "mapped-grid";
+    box: GeoBox;
+    tag: "building" | "highway";
+    minEdits: number;
+    minFeatures: number;
+    days: number;
+    place?: string;
+}
+/**
+ * **The worker names the place.** Every other located gate checks a
+ * submission against coordinates the poster chose; a mapping ask has none,
+ * because finding the coordinates *is* the work. So this establishes only
+ * that a position was reported at all — and records how it was known, since
+ * a camera's own EXIF and a browser's word are not the same evidence and the
+ * receipt must not let them read alike.
+ */
+ | {
+    id: "located";
+}
+/**
+ * Nothing already mapped this close.
+ *
+ * The rule that makes paying for found messes survivable: without it the
+ * same pile earns a fee from everyone who walks past. Judged against the
+ * *approved* claims on the same ask, so it needs no service the checker does
+ * not already hold.
+ */
+ | {
+    id: "not-already-mapped";
+    metres: number;
+}
+/**
+ * The waste reached one of the places it was allowed to go.
+ *
+ * Unlike every other located gate this one has a *set* of targets, because
+ * a campaign has several containers and a volunteer uses whichever is
+ * nearest. Nearest-of-many, and the note names which.
+ */
+ | {
+    id: "at-registered-point";
+    points: {
+        lat: number;
+        lon: number;
+        label?: string;
+    }[];
+    metres: number;
+}
+/**
+ * **Falsifiers: they catch a lie, they do not establish a truth.**
+ *
+ * Neither of these carries a place or a time, and that is the design. The
+ * place comes from the ask's `within-radius` gate and the moment from the
+ * submission itself — a gate holding its own copy of either could disagree
+ * with the gate that actually decides, and then two rules on the same ask
+ * would be measuring different worlds.
+ *
+ * Each reads only the handful of claims the world can contradict: an answer
+ * that says it rained where the archive recorded none, or that says bright
+ * midday at local midnight. **Saying nothing about the weather is not
+ * lying**, so silence passes. And an archive that is unreachable is
+ * `unverifiable`, never a fail — a service being down must never cost an
+ * honest worker their payout.
+ */
+ | {
+    id: "weather-consistent";
+} | {
+    id: "daylight-consistent";
+}
+/**
+ * **A delta, where every other gate measures a state.**
+ *
+ * Everything else here asks what was true at one moment: a device was inside
+ * a radius, the archive recorded rain. A cleanup is a claim about a
+ * *change* — this place was like that, and now it is like this, and I am why.
+ * Two photographs of one place, and the measurable half of that claim is
+ * whether they are both of the right place and in the right order.
+ *
+ * It carries no radius and no window, for the reason the falsifiers carry no
+ * coordinates: the place comes from the ask's own `within-radius` gate and
+ * the moments from the photographs. A gate holding its own copy could
+ * disagree with the gate that actually decides.
+ *
+ * **What it cannot do is the important half**, and it is stated everywhere
+ * this appears: it says the same place got visibly cleaner between two
+ * moments. It does not say who did it, or where the waste went.
+ */
+ | {
+    id: "before-after";
+}
+/**
+ * Somewhere the work was supposed to happen.
+ *
+ * Weaker evidence than anything else here and named accordingly: it checks
+ * the location a submission REPORTED — a browser's own reading or a photo's
+ * EXIF — and both can be set by a determined person. It exists to catch the
+ * ordinary mistake, not the determined liar, so it never carries a claim on
+ * its own.
+ */
+ | {
+    id: "within-radius";
+    lat: number;
+    lon: number;
+    meters: number;
+    place?: string;
+};
+/**
+ * The document. It cannot carry its own id — identity IS the hash of the exact
+ * bytes, the same rule the eval-engine's rubrics follow, so rewording one gate
+ * mints a new document and in-flight claims stay pinned to the old one.
+ */
+export interface DoneMeans {
+    v: 1;
+    task: string;
+    gates: Gate[];
+}
+/** Terms an ask demands verbatim — quoted phrases are the only unambiguous signal. */
+export declare function requiredTerms(title: string): string[];
+/**
+ * The terms an ask implies. A brain may propose richer gates when one is
+ * configured; this is the floor, and it needs no key — so an ask can always
+ * say what it means, even with nothing but the sentence.
+ */
+export declare function deriveRubric(title: string): DoneMeans | null;
+/** One phrase per gate, for a chip or a list. Own keys only — see `isGate`. */
+export declare const gatePhrase: (gate: Gate) => string;
+/** The readback: what a poster is shown before they commit money to an ask. */
+export declare function doneMeansSentence(rubric: DoneMeans): string;
+/**
+ * Terms v2 — the anatomy of an ask.
+ *
+ * v1 could only say "these gates must pass", which confined the product to
+ * work a regular expression can judge. Real asks want a photo of a notice
+ * board, a translation that reads naturally, a logo someone likes. So an ask
+ * now names three things: what gets handed over, what makes it complete, and
+ * who rules.
+ *
+ * The load-bearing idea is that **every criterion wears its kind**, and the
+ * kind is a promise about who can honestly judge it:
+ *
+ * - `measure` — a machine checks it, deterministically, replayable by anyone.
+ * - `judge`   — a model rules on a written sentence, with the evidence frozen
+ *               first and its reasoning published (see BD11 in the V build
+ *               plan). Auditable, not bit-reproducible.
+ * - `attest`  — only a person can say. No machine may claim it did.
+ *
+ * That last kind is the honest one. A system that cannot say "this cannot be
+ * machine-judged" will eventually pretend it judged something it did not, and
+ * a poster will be told their taste was verified by a regular expression.
+ */
+/**
+ * What an ask can ask for.
+ *
+ * **The list is the source and the type derives from it**, rather than a type
+ * beside a hand-copied array. `parseTerms` validates against this list, and
+ * when `photo-pair` was added to the type and not to that copy, every cleanup
+ * ask ever posted read as *"the terms could not be read"* — a checker
+ * declining to judge work against a document it thought was malformed, which
+ * is the correct behaviour on a bad document and a silent outage on a good
+ * one. It cost a live smoke to find. One list now.
+ *
+ * `photo-pair` is the cleanup shape: two photographs of one place, before and
+ * after. It is its own type rather than "two photos" because everything
+ * downstream treats it differently — the submission envelope carries two cids,
+ * the checker freezes both for the judge, and the leg is priced for two
+ * screens.
+ */
+export declare const DELIVERABLE_TYPES: readonly ["url", "text", "photo", "photo-pair", "mess-report", "field-report", "commitment", "file", "answer"];
+export type DeliverableType = (typeof DELIVERABLE_TYPES)[number];
+export interface Deliverable {
+    type: DeliverableType;
+    /** What the worker is being asked to hand over, in the poster's words. */
+    prompt: string;
+}
+export type CriterionKind = "measure" | "judge" | "attest";
+/**
+ * The kinds of claim an ask can take, where it takes more than one.
+ *
+ * Only a site does: a `patch` (before, after, the bags) which is judged and
+ * held, and the `site` shot which shows the whole area clear and releases
+ * every held patch. The claim says which in its own `kind` field. An ordinary
+ * cleanup's envelope says `pair` and nothing reads it — one kind of claim
+ * needs no vocabulary, and a criterion on such an ask is about the only
+ * claim there is.
+ *
+ * **The list is the source and the type derives from it**, as with
+ * `DELIVERABLE_TYPES` and for the same reason: the parser validates against
+ * this array and the bridge writes it into the rubric, so a kind added in one
+ * place cannot go missing in the other.
+ */
+export declare const CLAIM_KINDS: readonly ["patch", "site"];
+export type ClaimKind = (typeof CLAIM_KINDS)[number];
+export interface MeasureCriterion {
+    id: string;
+    kind: "measure";
+    gate: Gate;
+    /**
+     * Which kind of claim this rule is about — absent means every kind.
+     *
+     * The chain allows exactly one rubric per collection, so both of a site's
+     * claims are judged against the same criteria. A rule written for a patch
+     * ("the two photographs show the same place") is then also asked of the one
+     * wide photograph, and the honest answer is no: a site claim was rejected
+     * on devnet for not being a pair, and the held patches were never released.
+     * This field is where a criterion says which kind it is about, at the point
+     * it is written, so nothing downstream has to guess from position or
+     * wording — the bridge skips such a rule for the other kind rather than
+     * failing it.
+     *
+     * Only a criterion a builder generated for a known shape ever carries one.
+     * A line a poster wrote themselves has none and is therefore asked of every
+     * claim, which is what somebody who wrote a sentence expects.
+     */
+    appliesTo?: ClaimKind;
+}
+export interface JudgeCriterion {
+    id: string;
+    kind: "judge";
+    /** The sentence the model rules on. Written to be ruled on, not to be pretty. */
+    text: string;
+    /** Below this the ruling is not trusted and the claim is flagged, never rejected. */
+    confidence?: number;
+    /** Which kind of claim this sentence is about — see `MeasureCriterion.appliesTo`. */
+    appliesTo?: ClaimKind;
+}
+export interface AttestCriterion {
+    id: string;
+    kind: "attest";
+    text: string;
+}
+export type Criterion = MeasureCriterion | JudgeCriterion | AttestCriterion;
+/**
+ * Who rules. The chain is the authority on this — whoever holds the EVALUATE
+ * grant casts the one verdict a claim ever gets — so this field records *what
+ * the poster was shown at post time*, which is what makes the ask a contract
+ * rather than a surprise. The two must agree; where they cannot, the chain wins
+ * and the receipt says so.
+ */
+export interface JudgeSpec {
+    kind: "poster" | "oracle";
+    address?: string;
+    rewardUixo?: number;
+}
+export interface AskTerms {
+    v: 2;
+    task: string;
+    deliverable: Deliverable;
+    /**
+     * Which campaign this ask belongs to, if any — the tag the receipt wall
+     * gathers by. Frozen into the terms at posting, like the place name, so a
+     * campaign cannot be re-labelled after the fact.
+     */
+    campaign?: string;
+    /**
+     * One job posted many times — two hundred storefronts, one per address —
+     * named by its poster so the board shows the batch as one card rather than
+     * guessing at it (docs/verified-work-board-volume-plan.md, D4). Lowercase
+     * letters, digits and dashes. Each member is still its own ask with its own
+     * escrow; the tag only says they belong together.
+     */
+    series?: string;
+    /**
+     * This ask is a site: cleared by several people, a patch at a time.
+     *
+     * The checker reads it from the chain to know that a claim saying
+     * `kind: "patch"` should be judged and then **held** — its share cannot be
+     * known until the last patch exists — and that a claim saying
+     * `kind: "site"` releases every held patch with the pot split between
+     * them. Absent means an ordinary cleanup: one pair of photographs, paid.
+     */
+    site?: boolean;
+    /**
+     * What an approved answer here spawns — the ask that follows this one.
+     *
+     * This is the campaign machinery said as a term anyone can write: an ask
+     * whose approvals each open a follow-on ask, funded either by the poster's
+     * own standing allowance or by anyone who backs the spot. The chain's tag
+     * is the parent's collection id — all digits, which is why a human
+     * campaign tag must contain a letter: the two namespaces can never
+     * collide, and a child is traceable to its parent by its tag alone.
+     *
+     * One level by construction: a child's terms are built at spawn time and
+     * carry no chain of their own until someone deliberately writes one.
+     */
+    chain?: {
+        /** The follow-on task, with `{place}` standing where the answer's place name goes. */
+        task: string;
+        deliverable: Deliverable;
+        /** What the follow-on must raise before it posts, in base units. */
+        target: {
+            mode: "fixed";
+            base: string;
+        };
+        /** Who funds it: the poster's own standing allowance, or anyone. */
+        funding: "poster" | "crowd";
+        /** The child inherits the answer's coordinates as its place gate. */
+        atAnswersPlace?: boolean;
+    };
+    /**
+     * This ask is one leg of an open call (docs/verified-work-open-call-demo-
+     * build.md): a company's brief, answered by people working with their own
+     * AI, judged in public, the pick chosen by the poster. A call is three
+     * ordinary asks under one campaign tag — the entries, the prize, the
+     * runners-up — because a collection carries one amount and one rubric; each
+     * carries the whole brief, so any leg's page can draw the call.
+     */
+    call?: CallTerms;
+    /**
+     * Buy a look back at this place later.
+     *
+     * An approved cleanup spawns a sealed re-visit ask at the same coordinates
+     * after `days`, paying `pay`. What comes back is **reported, never clawed
+     * back**: the original verdict stands, and persistence is a separate fact
+     * about the place rather than a retroactive judgement on the person.
+     */
+    followUp?: {
+        days: number;
+        pay: string;
+        /**
+         * A window rather than a date, when the campaign's rule seals one.
+         *
+         * A look-back that always lands on +7 is a spot that only has to stay
+         * clean for eight. The day is drawn from this range at posting, so
+         * nobody planning to re-dump knows when somebody will be paid to look.
+         */
+        daysMin?: number;
+        daysMax?: number;
+    };
+    /**
+     * The cleanup this ask looks back at.
+     *
+     * A re-visit is not a spot of its own — it is what happened to one — and
+     * without the link a wall can only say "a look-back was bought" and never
+     * "it was still clear". Frozen at posting like everything else.
+     */
+    revisitOf?: string;
+    /**
+     * Whether an approved answer may be read while the ask is still open.
+     *
+     * A claim body is withheld until its ask stops taking answers, so that
+     * answers cannot be copied. That is right for a question with one answer and
+     * wrong for an ask whose *whole output* is meant to be looked at — a standing
+     * mapping ask stays open for a campaign, and withholding would hide every pin
+     * it collected. `"on-approval"` releases a body once a verdict has approved
+     * it, and changes nothing for anything unjudged.
+     *
+     * Safe here because an approved mess report cannot usefully be copied: the
+     * novelty gate refuses the duplicate. Do not put it on an ask where two
+     * people could honestly hand in the same answer.
+     */
+    publish?: "on-approval";
+    /**
+     * The mapped pin this cleanup clears — the mapping claim's own id.
+     *
+     * Without it a map could only know a spot was funded by reading somebody's
+     * ledger, and a public record that depends on a private list is not a
+     * public record. With it, "funded" and "cleaned" are folded from the chain
+     * exactly as every other state on this network is.
+     */
+    clears?: string;
+    /**
+     * Where the waste may be taken, and how close counts.
+     *
+     * The third photograph exists because a before/after pair cannot tell
+     * clearing a place from moving the pile out of frame. Registered points
+     * make the difference checkable: the load has to arrive somewhere real,
+     * chosen in advance, and published so a volunteer knows where to drive.
+     */
+    disposal?: {
+        points: {
+            lat: number;
+            lon: number;
+            label?: string;
+        }[];
+        metres: number;
+    };
+    criteria: Criterion[];
+    judge: JudgeSpec;
+    /**
+     * How the ask came: `"mcp"` when our MCP posted it for an agent
+     * (docs/verified-work-marketplace-volume-plan.md, D1). The board says so
+     * on the card, because agents hiring people here is the point, not a
+     * secret. Self-declared and only ever this one value; last in the
+     * document, after the judge, where every writer appends it.
+     */
+    via?: "mcp";
+}
+/**
+ * The poster's canvas: what a call says between its lede and its terms.
+ *
+ * Text and https addresses only — no HTML, no colours, no fonts — so a brief
+ * can carry pictures, a diagram and data without carrying anything a page
+ * would have to trust. Every block is the poster's words, and every reader
+ * (the page, `read_ask`) labels it so.
+ */
+export type CallBlock = {
+    kind: "story";
+    paragraphs: string[];
+} | {
+    kind: "cover";
+    url: string;
+    alt: string;
+    caption?: string;
+} | {
+    kind: "pictures";
+    items: {
+        url: string;
+        alt: string;
+        caption?: string;
+    }[];
+} | {
+    kind: "diagram";
+    title: string;
+    steps: {
+        title: string;
+        text?: string;
+    }[];
+    source?: string;
+} | {
+    kind: "data";
+    title: string;
+    csv: string;
+    note?: string;
+} | {
+    kind: "files";
+    items: {
+        url: string;
+        name: string;
+        note?: string;
+    }[];
+} | {
+    kind: "start";
+    prompt: string;
+};
+export declare const CALL_LEGS: readonly ["entries", "prize", "runnersUp"];
+export type CallLeg = (typeof CALL_LEGS)[number];
+export interface CallTerms {
+    /** The call's own name, and its page's: `/opencall/<slug>`. */
+    slug: string;
+    leg: CallLeg;
+    title: string;
+    lede: string;
+    /** Who posts it, as they want to be named. */
+    poster: string;
+    /** What each judged line is worth towards the score, in criteria order. */
+    points: number[];
+    /** Whole PAY, for the page; the chain is the truth. */
+    money: {
+        prize: number;
+        runnersN: number;
+        runnersEach: number;
+        entryEach: number;
+        entryUpTo: number;
+    };
+    /** ISO dates: entries close, the shortlist shows, the poster picks. */
+    closes: string;
+    drop: string;
+    pick: string;
+    /** The other legs' collection ids, as they were posted before this one. */
+    legs?: {
+        entries?: string;
+        prize?: string;
+        runnersUp?: string;
+    };
+    blocks: CallBlock[];
+}
+/** A call's slug: what its page and its tag are named by. */
+export declare const CALL_SLUG: RegExp;
+/** The limits a call is read with, and written to. */
+export declare const CALL_LIMITS: {
+    readonly title: 160;
+    readonly lede: 500;
+    readonly poster: 80;
+    readonly blocks: 8;
+    readonly paragraphs: 8;
+    readonly paragraph: 1500;
+    readonly url: 2048;
+    readonly alt: 300;
+    readonly caption: 300;
+    readonly items: 6;
+    readonly steps: 8;
+    readonly stepTitle: 120;
+    readonly stepText: 300;
+    readonly source: 2000;
+    readonly csv: 4000;
+    readonly note: 300;
+    readonly name: 120;
+    readonly start: 1500;
+    readonly lines: 5;
+};
+export declare const DEFAULT_CONFIDENCE = 0.7;
+/**
+ * A distance as a person says it: metres up to a kilometre, kilometres past
+ * it. "Within 18000 m of Ljubljana" is a sentence a machine wrote; the gate
+ * still measures the metres.
+ */
+export declare const distanceWords: (metres: number) => string;
+export declare const criterionText: (criterion: Criterion) => string;
+/** What a reader is promised about who checked this line. */
+export declare const KIND_BADGE: Record<CriterionKind, string>;
+/** The readback for a v2 ask — the contract, in one line. */
+export declare const askSentence: (terms: AskTerms) => string;
+/**
+ * An ask whose judge cannot rule on all of it is a trap: the chain allows
+ * exactly one verdict per claim, so there is no "the oracle does its half and
+ * the poster does the rest". Any `attest` criterion therefore forces the
+ * poster to hold the pen.
+ */
+export declare const requiresPoster: (terms: AskTerms) => boolean;
+/**
+ * Whether a given checker can serve this ask in full. The evaluator calls this
+ * before accepting work and declines out loud when it cannot — the same
+ * honesty the keyless worker already practises when a skill needs a brain.
+ */
+export declare function servableByOracle(terms: AskTerms, options: {
+    canJudge: boolean;
+}): {
+    ok: boolean;
+    reason?: string;
+};
+/**
+ * One shape for every consumer. A v1 rubric is a v2 ask whose criteria are all
+ * machine-checked and whose judge was never written down — which is exactly
+ * what a v1 ask was. Nothing in flight has to be migrated: the stored bytes
+ * stay as they are, and identity is still the hash of those bytes.
+ */
+export declare function normalizeTerms(doc: DoneMeans | AskTerms): AskTerms;
+export declare function callOf(raw: unknown): {
+    call: CallTerms;
+} | null;
+export declare function parseTerms(value: unknown): AskTerms | null;
+/**
+ * What an ask is asking for, read off its own sentence. The deliverable is
+ * what decides which box a worker is shown — and on a phone, `photo` is the
+ * difference between a file picker and the camera opening.
+ */
+export declare function inferDeliverable(title: string): Deliverable;
+/**
+ * The floor, in v2 clothing — what an ask means when nothing else is said.
+ *
+ * Note what this deliberately does NOT do: it never invents a `judge`
+ * criterion. Everything derived here is machine-checkable, because a criterion
+ * the poster did not write is a criterion nobody agreed to. Judged criteria
+ * come from a person or from A1's draft-and-edit, never from a regex.
+ */
+export declare function deriveTerms(title: string, judge?: JudgeSpec): AskTerms;
+/** Append a criterion, keeping ids unique and stable for everything already there. */
+export declare function addCriterion(terms: AskTerms, criterion: Omit<JudgeCriterion, "id"> | Omit<AttestCriterion, "id"> | Omit<MeasureCriterion, "id">): AskTerms;
+//# sourceMappingURL=terms.d.ts.map

package/dist/cjs/rubric/terms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terms.d.ts","sourceRoot":"","sources":["../../../src/rubric/terms.ts"],"names":[],"mappings":"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"}