ainize 0.1.0

package/dist/commands/patch.d.ts

@@ -0,0 +1,852 @@
+import type { BenchmarkSpec, CatalogEntry, Contributor, LedgerRecord, PatchAnchor } from '@ainize/core';
+import { NodeClient } from '../client.js';
+import { type ResolveOptions } from '../ens.js';
+import { type CliContext } from '../context.js';
+export interface LsArgs {
+    status?: string;
+    model?: string;
+    schema?: string;
+    branch?: string;
+    author?: string;
+    q?: string;
+    sort?: string;
+    limit?: number;
+    mine?: boolean;
+    drafts?: boolean;
+}
+/** Position in the serving model's stack, by knowledge id (`GET /api/runtime/stack`) — item 216. */
+export declare function loadedPositions(client: NodeClient): Promise<Map<string, number>>;
+/**
+ * A catalogue row as `/api/catalog` returns it: the derived entry plus the demand numbers the marketplace computes
+ * (item 201). `downloads` is the raw settlement count and stays for compatibility; `sales` is what a sale is.
+ */
+export type CatalogRow = CatalogEntry & {
+    sales?: {
+        sales_all: number;
+        sales_30d: number;
+    };
+    built_on?: number;
+};
+export declare function patchLs(ctx: CliContext, a?: LsArgs): Promise<CatalogRow[]>;
+/**
+ * What this knowledge is built on, in the words the browse card uses (item 282).
+ *
+ * `add-on: <ids>` — `base.stack`, a body trained against those tables: it does not work without them, and its price
+ * has to be read together with theirs. `<ids>` alone — declared `parents`: it stands on its own and shares revenue
+ * with them. `-` — a root. Ids are listed, not counted, because the one thing the reader needs is WHICH knowledge
+ * they also have to hold.
+ */
+export declare function builtOnCell(e: CatalogRow): string;
+/** `2/2 passed ✓ quorum` — clamped, with the extra evidence spelled out instead of an unreadable `3/2`. */
+export declare function verificationLine(e: CatalogEntry): string;
+/**
+ * How many distinct model servers are behind those attestations (item 329). Two verifier processes pointed at one
+ * vLLM sign two attestations and are not two independent verifications; the record can now tell the difference, so
+ * the line says which of the two it is instead of printing a fraction that means either.
+ */
+export declare function executorLine(e: CatalogEntry): string;
+/**
+ * "3 CREDIT → node-b 2.1 (seller) · node-a 0.9 (creator of pixel-parent)" (item 280).
+ *
+ * The seller returns the whole split in `x-payment-response` on the same reply that hands over the manifest, and
+ * the buyer's receipt printed six timeline steps and a tx hash. A payee this node's own lineage view did not
+ * expect is marked, because that is the one thing the split is worth checking for.
+ */
+export declare function payeeLines(r: PurchaseResult, currency: string): string[];
+/** `split` as `GET /api/patches/:id` returns it. */
+export interface SaleSplitView {
+    patch_id: string;
+    amount: string;
+    currency: string;
+    share: number;
+    verifier_share: number;
+    /** The rule that decides the split, in one sentence (item 322). */
+    rule?: string;
+    payees?: number;
+    /** What one sale costs to settle on this chain, from measured gas (item 366); null when nothing has been charged. */
+    cost?: {
+        writes: number;
+        gas_avg: number;
+        floor: string;
+        measured_writes: number;
+    } | null;
+    lines: {
+        address: string;
+        amount: string;
+        name: string | null;
+        role: 'seller' | 'ancestor' | 'contributor' | 'verifier';
+        knowledge: string[];
+    }[];
+    parents: {
+        id: string;
+        name: string;
+        price: string | null;
+        currency: string;
+        author: string | null;
+        author_name: string | null;
+        status: string | null;
+    }[];
+    cheaper_than: {
+        id: string;
+        price: string;
+        currency: string;
+    }[];
+    unresolved: Record<string, string>;
+}
+/**
+ * "Each sale of 3 CREDIT → 2.1 to you, 0.9 shared by the creators of krx-all-2761" (item 189), and the one thing a
+ * publisher undercutting their own base is never told (item 318). Printed at publish, before the announce, because
+ * afterwards the price is on the permanent record.
+ */
+export declare function splitLines(s: SaleSplitView): string[];
+/** A parent or child as `GET /api/patches/:id` returns it, with its price and (for the author) what it has paid. */
+export interface LineageRef {
+    id: string;
+    name: string;
+    author: string;
+    status: string;
+    price?: string;
+    currency?: string;
+    author_name?: string | null;
+    sales?: number | null;
+    earned?: string | null;
+}
+export interface PatchDetail extends CatalogEntry {
+    lineage: {
+        parents: LineageRef[];
+        children: LineageRef[];
+        earned?: {
+            amount: string;
+            currency: string;
+            sales: number;
+        };
+    };
+    conflicts: {
+        patch_id: string;
+        overlap_rows: number;
+        same_schema: boolean;
+        status: string;
+        cross_branch?: boolean;
+        same_author?: boolean;
+        author?: string;
+        author_name?: string | null;
+        created_at?: number;
+        sales?: number;
+        lineage?: 'parent' | 'child' | null;
+    }[];
+    /** What one sale pays and to whom, by name (items 189, 318) — from the node's `royaltyPlan`. */
+    split?: SaleSplitView;
+    retired_at?: number | null;
+    retire_reason?: string | null;
+    branches: {
+        name: string;
+        context: Record<string, string>;
+    }[];
+    /** The bases this knowledge needs underneath it, deepest first, with their prices (item 270). */
+    requires?: {
+        id: string;
+        name: string;
+        held: boolean;
+        price: string | null;
+        currency?: string;
+        author?: string;
+        author_name?: string | null;
+        depth?: number;
+        known?: boolean;
+        purchased?: boolean;
+        mine?: boolean;
+    }[];
+    owned: boolean;
+    purchased: boolean;
+    has_body: boolean;
+    applied: boolean;
+    gateway_url: string | null;
+    /**
+     * What is still to happen before this is LISTED (item 254) — who has not attested, how many of them can run this
+     * model, and how long verification has actually taken on this node. Null once the quorum is met.
+     */
+    verifying?: {
+        patch_id: string;
+        since: number;
+        waited_ms: number;
+        counted: number;
+        quorum: number;
+        waiting_on: {
+            name: string;
+            address: string;
+            model: string | null;
+            can_run: boolean;
+        }[];
+        capable: number;
+        typical_ms: number | null;
+        eta_ms: number | null;
+        samples: number;
+    } | null;
+    /** Why an announced knowledge has not been verified yet — null while it is still within its normal wait (item 154). */
+    stalled?: {
+        patch_id: string;
+        since: number;
+        waited_minutes: number;
+        counted: number;
+        quorum: number;
+        hash_only: number;
+        needs_benchmark: boolean;
+        model: string;
+        verifiers: {
+            name: string | null;
+            endpoint: string;
+            address: string | null;
+            model: string | null;
+            attested: 'no' | 'hash-only' | 'executed';
+        }[];
+        reason: string;
+    } | null;
+}
+/**
+ * Holding a file is not owning the knowledge (items 173, 343).
+ *
+ * A verifier fetches every body it scores, so `body on this node: yes` was true on knowledge nobody had bought and
+ * nobody was licensed to use, teach on, or subscribe with — and `patch buy` then charged for it and reported
+ * "body already present", which reads as "nothing happened". The node has known the difference all along
+ * (`licenseOf(e).source === 'verification'`); this is that fact, in the buyer's words.
+ */
+export declare function licenceLine(e: {
+    owned: boolean;
+    purchased: boolean;
+    has_body: boolean;
+}, tx?: string | null): string;
+export declare function patchGet(ctx: CliContext, id: string): Promise<PatchDetail>;
+export interface PublishArgs {
+    file: string;
+    name: string;
+    model: string;
+    benchmark: string;
+    id?: string;
+    price?: string;
+    description?: string;
+    parents?: string;
+    branch?: string;
+    topic?: string;
+    license?: string;
+    billing?: 'per_download' | 'per_apply_hour' | 'per_hit';
+    announce?: boolean;
+    /**
+     * The day the DATA is true of (item 267), YYYY-MM-DD — not the day it was uploaded. Everything else on an anchor
+     * is a publishing timestamp, so a daily baker had nowhere to put the one date a consumer needs and put it in the
+     * name string instead. The node validates it (a real date, not in the future) and every surface reads it.
+     */
+    asOf?: string;
+    /** What this knowledge is to its bases (item 188): extend | contradict | update | merge. The node measures the rows. */
+    kind?: 'extend' | 'contradict' | 'update' | 'merge';
+    /** hidden from public catalogs (e2e/test publishing on a shared chain) */
+    test?: boolean;
+    /** data providers credited on the record: `addr:name:share` (name optional: `addr:share`), up to 4, Σ share ≤ 1 */
+    contributor?: string[];
+    /** the training set beside the body (lineage design §12.4): a local .jsonl/.csv the node pins under its own sha */
+    dataset?: string;
+    datasetAccess?: 'public' | 'derivative' | 'private';
+    datasetLicense?: string;
+    /** publish past `duplicate_body` (your own bytes, same subject) and `model_mismatch` — never past another author's bytes */
+    force?: boolean;
+    /**
+     * The listings this publish retires: required when the overlap rule found any (item 150), and the DECLARATION
+     * when it did not — today's bake replacing yesterday's on rows that do not overlap (item 248).
+     */
+    supersede?: string[];
+    /** Keep every overlapping listing of yours on sale — a dated snapshot published on purpose (item 248). */
+    keepOthers?: boolean;
+}
+/**
+ * `--contributor 0xabc…:Alice:0.7` → Contributor (role data_provider, proof declared — the operator vouches for the address;
+ * a *signed* proof only comes from the browser teach flow). `0xabc…:0.7` omits the name; `0xabc…:Alice:0` is credit-only.
+ */
+export declare function parseContributors(list: string[] | undefined): Contributor[] | undefined;
+/** The node's own id rule (`market.createDraft`), mirrored so the CLI can say what will happen before it happens. */
+export declare const slugForId: (name: string) => string;
+/**
+ * The id of a knowledge whose publisher did not choose one (item 158).
+ *
+ * The node derives it from the name by dropping everything outside `a-z 0-9 . _ -`, so every Korean, Japanese or
+ * Chinese name collapsed to the empty string and the publisher was told `invalid patch id (use 2-64 chars …)` —
+ * a rule about a flag they never passed, on the product's own flagship subject. A name with no usable ASCII gets a
+ * derived, stable id here instead, and the command says so; `--id` still wins over everything.
+ */
+export declare function idFromName(name: string): {
+    id: string;
+    from: 'name' | 'hash';
+};
+/** The benchmark, from a path or from inline JSON — with the three mistakes told apart (item 159). */
+export declare function readBenchmarkArg(value: string): unknown;
+/**
+ * A knowledge body is a numpy archive, which is a ZIP (item 159). Publishing something else used to reach the npz
+ * reader on the node and come back as `npz: end of central directory not found` — a ZIP structure term, with no
+ * filename, that gives no hint the file is simply the wrong kind.
+ */
+export declare function assertNpzBody(file: string): void;
+export declare function patchPublish(ctx: CliContext, a: PublishArgs): Promise<{
+    anchor: PatchAnchor;
+    announced: boolean;
+}>;
+/** `ainize --json publish` — the record hash, the derived status and what the announce retired, without the sketch. */
+export declare function publishDocument(anchor: PatchAnchor, announced: AnnounceResult | null): Record<string, unknown>;
+/** What the node's `verifierReach()` reports back with an announce (item 147). */
+export interface VerifierReach {
+    known: number;
+    reachable: number;
+    verifiers: number;
+    quorum: number;
+    self_attest: boolean;
+    endpoints: string[];
+}
+/** Everything an announce establishes: the record it wrote, what it retired, and who can verify it (item 253). */
+export interface AnnounceResult {
+    patch_id: string;
+    record: LedgerRecord;
+    retires: PatchDetail['conflicts'];
+    verifiers: VerifierReach | null;
+    visibility: string;
+}
+/**
+ * The overlaps an announce would RETIRE: same subject, same branch, still tradeable, and published by this same node
+ * — the node's own rule (market.supersedable). A cross-author overlap is not in this list any more: it coexists.
+ */
+export declare function retiredByAnnounce(d: PatchDetail): PatchDetail['conflicts'];
+/**
+ * DRAFT → ANNOUNCED, with the two things the publisher was never told (items 147, 150):
+ *  - what this announce retires, listed with each item's status and sales, and refused until every one of them is
+ *    named with `--supersede` — the same friction the console demands before the same, permanent, irreversible write;
+ *  - whether any reachable peer on this network actually verifies. Below the quorum nothing announced here can ever
+ *    be LISTED, so the old unconditional "verifiers will now attest" was a promise the node could not keep.
+ */
+export declare function patchAnnounce(ctx: CliContext, id: string, opts?: {
+    supersede?: string[];
+    keepOthers?: boolean;
+    document?: boolean;
+}): Promise<AnnounceResult>;
+/**
+ * `ainize patch retire <id>` — the exit (item 148). `patch forget` deletes this node's copy of the file and keeps
+ * selling it; this writes an author-signed `retire` record: off the catalogue, 410 at the gateway, permanent.
+ */
+export declare function patchRetire(ctx: CliContext, id: string, opts?: {
+    reason?: string;
+}): Promise<{
+    patch_id: string;
+    retired_at: number;
+    reason: string;
+}>;
+/**
+ * A Python traceback from the model container, turned into one English line (item 160).
+ *
+ * `Runtime.verify` rethrows the applier's stderr verbatim, so a failed verification reached the operator as eight
+ * lines of `scripts/patch.py` and `engram/live.py` internals ending in a Korean sentence — a stack trace from a file
+ * they do not own, in a language the rest of the product does not use, with no statement of what failed or where to
+ * look. The trace is not hidden (its last line is the container's own words, quoted as such); it is framed.
+ */
+export declare function runtimeFailure(err: unknown, nodeUrl: string, what: string): unknown;
+export declare function patchVerify(ctx: CliContext, id: string, opts?: {
+    recheck?: boolean;
+}): Promise<unknown>;
+/**
+ * `ainize patch challenge <id> --reason …`. A challenge is free to file and expensive for everyone else: it stops
+ * every sale of the knowledge and spends another operator's GPU minutes on the re-run (item 328). The command says
+ * that before it sends, and afterwards it reports what actually happens next — which, for a knowledge that was never
+ * LISTED, is not "off sale" but "the verifiers are asked to run it again" (item 242).
+ */
+export declare function patchChallenge(ctx: CliContext, id: string, reason: string): Promise<void>;
+export interface PurchaseResult {
+    patch_id: string;
+    steps: {
+        step: string;
+        detail: string;
+        at: number;
+    }[];
+    manifest: {
+        patch_sha256: string;
+        size_bytes: number;
+        rows: number;
+    };
+    path: string;
+    tx_hash: string;
+    amount: string;
+    scheme: string;
+    /** every knowledge this call paid for, bases first (item 270) */
+    purchases?: {
+        patch_id: string;
+        amount: string;
+        currency: string;
+        scheme: string;
+        tx_hash: string;
+        free?: boolean;
+    }[];
+    total?: string;
+    currency?: string;
+    /** the payment was already settled and the seller re-issued the manifest — nothing was charged (item 273) */
+    redeemed?: boolean;
+    /** who this purchase paid, from the seller's `x-payment-response` (item 280) */
+    royalty?: Record<string, string>;
+    payees?: {
+        address: string;
+        amount: string;
+        name: string | null;
+        role: string;
+        knowledge: string[];
+        promised: boolean;
+    }[];
+}
+/** `GET /api/patches/:id/quote` — what this purchase costs before anyone pays for it (item 270). */
+export interface PatchQuote {
+    patch_id: string;
+    price: string;
+    currency: string;
+    requires: {
+        id: string;
+        name: string;
+        price: string;
+        currency: string;
+        author: string;
+        author_name?: string | null;
+        depth: number;
+        known: boolean;
+        held: boolean;
+        licensed: boolean;
+        purchased: boolean;
+        mine: boolean;
+    }[];
+    missing: string[];
+    unknown: string[];
+    total: string;
+    self_contained: boolean;
+    export: 'delta' | 'squash' | null;
+    derivation: string | null;
+}
+/** `GET /api/credit/:address` — where local credit comes from and what it is worth (item 364). */
+export interface CreditInfo {
+    address: string;
+    currency: string;
+    balance: number;
+    grant: {
+        amount: string;
+        reason: string;
+        granted_at: number;
+    } | null;
+    would_grant: string | null;
+    issued_by: {
+        address: string;
+        name: string | null;
+        url: string;
+    };
+    issuance: {
+        cap: number;
+        addresses: number;
+        amount: number;
+        per_address: string;
+        currency: string;
+        issues: boolean;
+    };
+    note: string;
+}
+/**
+ * `ainize patch price <id> <price>` — change what a published knowledge sells for (item 278).
+ *
+ * Anchors are immutable, so this was impossible: no discount, no raise, no "make it free". The only path was
+ * republishing, which supersedes your own item, restarts verification and splits its sales history — so every
+ * price was a one-shot guess made before a single sale. The change is a signed record on the ledger, it applies to
+ * the next sale, and it takes nothing away from anyone who already bought.
+ */
+export declare function patchPrice(ctx: CliContext, id: string, price: string, opts?: {
+    reason?: string;
+    yes?: boolean;
+}): Promise<PriceChange>;
+export interface PriceChange {
+    ok: true;
+    patch_id: string;
+    price: string;
+    previous: string;
+    currency: string;
+    created_at: number;
+    history: {
+        price: string;
+        created_at: number;
+    }[];
+}
+export interface BuyArgs {
+    apply?: boolean;
+    /** buy the bases this knowledge needs underneath it too, deepest first */
+    withRequired?: boolean;
+    /** answer the confirmation in advance */
+    yes?: boolean;
+    /** refuse if the TOTAL (this knowledge plus the bases it needs) is above this */
+    maxPrice?: number;
+    /** pay a second time for something this node has already bought (item 271) — off, so a retry never charges twice */
+    again?: boolean;
+    /** one step of `use a b` / `buy a b`: the terminal still gets its lines, the JSON document is the batch's (item 219) */
+    batched?: boolean;
+    /** buy a SUPERSEDED version on purpose (item 236) — without it, a script is stopped instead of silently stacking last month's build */
+    allowSuperseded?: boolean;
+}
+/**
+ * `ainize patch buy <id>` — the quote, the decision, then the money (item 102).
+ *
+ * It used to print `✓ bought <id> for 25 (local-credit)` as its FIRST line: the price was never quoted, no
+ * confirmation existed anywhere in this CLI, and on an AIN node the first keystroke moved real money. Now the
+ * quote is printed, `--max-price` is checked against the family total (not just this item), a terminal is asked,
+ * and a non-terminal without `--yes` is refused instead of taken as a yes.
+ */
+export declare function patchBuy(ctx: CliContext, id: string, opts?: BuyArgs | boolean): Promise<PurchaseResult>;
+/**
+ * A seller's refusal, as a sentence (item 293).
+ *
+ * `market.buy` throws `payment rejected: 402 {"error":"insufficient credit: 2 < 5"}` and every surface printed it
+ * verbatim: at the moment a purchase fails, the buyer was shown a status code and a JSON blob. The seller's reasons
+ * are readable sentences on the other side; this unwraps them and names the seller, the balance and the price.
+ */
+export declare function refusalError(err: unknown, ctxInfo: {
+    seller: string;
+    id: string;
+    price: string;
+    currency: string;
+    balance: number | null;
+}): unknown;
+/**
+ * `ainize patch download <id>` — collect a knowledge this node has ALREADY paid for, without paying again (item 273).
+ *
+ * The recovery path existed in the node and was invisible: a buyer whose manifest was lost, or whose purchase died
+ * between the transfer and the download (item 274), was told "payment already used" and offered "Buy again".
+ */
+export declare function patchDownload(ctx: CliContext, id: string): Promise<PurchaseResult>;
+/** One layer of the runtime stack as the node reports it (design §5.4). */
+export interface StackLayer {
+    patch_id: string;
+    name: string | null;
+    sha256: string;
+    position: number;
+    applied_at: number;
+    reason: string;
+    rows: number | null;
+    export: 'delta' | 'squash' | null;
+    base_stack: string[];
+    journal: boolean;
+    journal_path: string | null;
+    stack_sha256: string | null;
+    body_present: boolean;
+}
+/** A queued apply/remove on the node (`GET /api/runtime/jobs/:id`). */
+export interface RuntimeJob {
+    id: string;
+    kind: 'apply' | 'remove';
+    patch_id: string;
+    state: 'queued' | 'running' | 'done' | 'failed';
+    queued_at: number;
+    started_at: number | null;
+    finished_at: number | null;
+    result: string | null;
+    error: string | null;
+    status?: number;
+    queue?: {
+        running: {
+            label: string;
+            since: number;
+        } | null;
+        waiting: number;
+        lock: {
+            label: string;
+            owner: string;
+            since: number;
+            mine: boolean;
+        } | null;
+    };
+}
+export declare function patchApply(ctx: CliContext, id: string, opts?: {
+    withBase?: boolean;
+    batched?: boolean;
+}): Promise<string>;
+export declare function patchRemove(ctx: CliContext, id: string, opts?: {
+    cascade?: boolean;
+    batched?: boolean;
+}): Promise<string>;
+/**
+ * `ainize use a b`, `patch apply a b`, `patch buy a,b` — a set, in the order given (item 219).
+ *
+ * The product's stated purpose is combining several knowledges, and `use a,b` answered `patch not found` while
+ * `patch apply a b` answered `Unknown argument: b`: the set had to be assembled one command at a time, with no
+ * stated order. The order typed IS the load order, and the last one wins on any memory entry two of them share —
+ * so the run ends by saying which order that was. Under `--json` the batch writes one document, not one per step.
+ */
+export declare function overIds<T>(ctx: CliContext, ids: string[], verb: 'loaded' | 'unloaded' | 'bought' | null, one: (id: string, batched: boolean) => Promise<T>): Promise<T[]>;
+/**
+ * `a,b`, `a b` and repeated flags all mean the same set, in the order typed (item 219). `chat` had this and
+ * nothing else did, so the comma form was sent to the node verbatim as one id and came back "patch not found".
+ */
+export declare function parseIds(input: string | string[] | undefined): string[];
+/**
+ * `ainize patch stack` — what is loaded in the serving model, bottom first, and what each layer sits on.
+ *
+ * Item 216: the position, why the layer is there and when it was loaded were all in the answer and none of them on
+ * screen, and the rows two neighbouring layers share — the thing that decides which of them the model actually
+ * answers from — were nowhere at all. Positions are 1-based here and in `patch ls`'s LOADED column, so the two
+ * listings cannot disagree about where a knowledge sits.
+ */
+export declare function patchStack(ctx: CliContext): Promise<StackLayer[]>;
+/** One knowledge in the tree, as the node reports it (`GET /api/patches/:id/tree`). */
+export interface TreeNodeView {
+    id: string;
+    name: string;
+    missing?: boolean;
+    author_name?: string | null;
+    taught_by?: string | null;
+    status?: string;
+    added: {
+        questions: number;
+        changed: number;
+        removed: number;
+        rows: number;
+        new: number;
+    };
+    signals: Record<string, number>;
+    depth: number;
+    legacy?: boolean;
+    export?: 'delta' | 'squash' | null;
+}
+export interface TreeView {
+    root: string;
+    depth: number;
+    truncated: boolean;
+    nodes: TreeNodeView[];
+    edges: {
+        from: string;
+        to: string;
+        kind: string;
+    }[];
+    family: {
+        sales: number;
+        knowledges: number;
+        authors: number;
+    };
+    money: {
+        seller_pct: number;
+        lineage_pct: number;
+        contributor_pct: number;
+        seller_name: string | null;
+        lineage_names: string[];
+        recipients: {
+            address: string;
+            pct: number;
+            name: string | null;
+            kind: 'lineage' | 'contributor';
+        }[];
+    };
+}
+/**
+ * `ainize patch tree <id>` — the family tree as text: ancestors above, this knowledge, then what was built on it,
+ * each line saying what that knowledge ADDED. The relation is the child's own claim ("built on" / "newer version" /
+ * "correction" / "combined"), and `declared` prints as the honest "declared parent — not trained on top" (§14).
+ */
+export declare function patchTree(ctx: CliContext, id: string, opts?: {
+    depth?: number;
+    dir?: 'up' | 'down' | 'both';
+}): Promise<TreeView>;
+export interface IssueView {
+    id: string;
+    kind: string;
+    count: number;
+    people: number;
+    topic: string | null;
+    text: string | null;
+    sample_index: number | null;
+    status: string;
+    covered_by: string | null;
+    first_seen: number;
+    last_seen: number;
+}
+/**
+ * `ainize patch missing <id>` — the open questions of a knowledge. A row with no text is not a bug: the question was
+ * counted without being kept, because nobody consented to share it (§10).
+ */
+export declare function patchMissing(ctx: CliContext, id: string, opts?: {
+    kind?: string;
+    limit?: number;
+    all?: boolean;
+}): Promise<IssueView[]>;
+/** `ainize patch signals <id>` — what it is doing, with the two scopes kept apart (SC-11). */
+export declare function patchSignals(ctx: CliContext, id: string): Promise<{
+    network: Record<string, number | string>;
+    node: Record<string, number>;
+}>;
+/**
+ * `ainize patch conflicts <id>` — the bodies that write the same memory rows, and which of them is winning (item 216).
+ *
+ * The table used to print an overlap and stop, leaving the only question that matters — whose answer does the model
+ * actually give on those rows — unanswerable from any surface. An overlap decides nothing until both are loaded;
+ * when they are, the one loaded later wins, and that is what the row says.
+ */
+export declare function patchConflicts(ctx: CliContext, id: string): Promise<PatchDetail['conflicts']>;
+/** One purchase this node made, as `GET /api/me/purchases` reports it (the row plus the anchor it belongs to). */
+export interface PurchaseRowView {
+    patch_id: string;
+    sha256: string;
+    tx_hash: string;
+    scheme: string;
+    amount: string;
+    path: string | null;
+    created_at: number;
+    applied?: boolean;
+    entry?: (CatalogEntry & {
+        anchor: PatchAnchor;
+    }) | null;
+}
+/**
+ * `ainize purchases` — what this node bought, from whom, for how much, and whether it is loaded.
+ *
+ * `patch ls --mine` is "knowledge I registered" and hid every purchase (item 216), so a buyer's own node could not
+ * list what it owned; and the purchase row itself names no counterparty (item 289), which is the first thing anyone
+ * needs for a refund, a dispute or an audit. The seller is resolved here from the anchor the same call returns.
+ */
+export declare function purchasesLs(ctx: CliContext): Promise<PurchaseRowView[]>;
+export declare function patchRecords(ctx: CliContext, id: string): Promise<LedgerRecord[]>;
+/**
+ * `ainize patch rm <id>` — delete a draft, after saying what goes (item 168).
+ *
+ * The friction was inverted twice over: the console makes you type the full id to delete a draft, while this
+ * command did it on one keystroke — no prompt, no `--yes`, no report of what was deleted, and no undo. The draft
+ * may be the only record of a lesson trained somewhere else, whose recipe the operator no longer has.
+ */
+export declare function patchRm(ctx: CliContext, id: string, opts?: {
+    yes?: boolean;
+}): Promise<void>;
+export interface SharedBody {
+    id: string;
+    name: string;
+    status: string;
+    sales: number;
+}
+export interface ForgetResult {
+    ok: true;
+    patch_id: string;
+    sha256: string;
+    deleted_file: boolean;
+    also_affects: SharedBody[];
+}
+/** `ainize patch forget <id>` — stop serving the knowledge file from this node (the public record is untouched). */
+/**
+ * `ainize patch forget <id>` — stop serving the body from this node. The file is content-addressed, so it is also
+ * the body of every other id trained from the same output: the node refuses and lists them, and `--all-sharing`
+ * is the operator saying yes to the whole list (item 149).
+ */
+export declare function patchForget(ctx: CliContext, id: string, opts?: {
+    allSharing?: boolean;
+}): Promise<ForgetResult>;
+/**
+ * `ainize use <id>` — the one-line consumer path: check it is verified, pay automatically (x402), download,
+ * verify the body hash and load it into this node's model. Falls back gracefully when the runtime is off.
+ */
+export declare function patchUse(ctx: CliContext, id: string, opts?: BuyArgs): Promise<PurchaseResult | {
+    already: true;
+}>;
+/** `recipe.json` as served by `GET /api/teach/jobs/:id/recipe` (trainer recipe + node-side `lesson` block + `benchmark`); every field optional. */
+export interface LessonRecipe {
+    model_id?: string;
+    model?: {
+        id_M?: string;
+        [k: string]: unknown;
+    };
+    facts?: {
+        prompt: string;
+        answer: string;
+        alt_prompt?: string;
+    }[];
+    benchmark_samples?: {
+        prompt: string;
+        expect: string;
+    }[];
+    benchmark?: Partial<BenchmarkSpec> & {
+        schema?: string;
+    };
+    lesson?: {
+        job_id?: string;
+        draft_id?: string | null;
+        name?: string;
+        model_id?: string;
+        sha256?: string;
+        rows?: number;
+        filename?: string;
+        facts?: {
+            prompt: string;
+            answer: string;
+            alt_prompt?: string;
+        }[];
+        contributor?: {
+            address: string;
+            name?: string;
+        };
+        context_patch_ids?: string[];
+        builds_on_context?: boolean;
+        node?: {
+            address?: string;
+            name?: string;
+            url?: string;
+        };
+    };
+    [k: string]: unknown;
+}
+export interface ImportArgs {
+    file: string;
+    recipe: string;
+    id?: string;
+    name?: string;
+    model?: string;
+    price?: string;
+    license?: string;
+    description?: string;
+    dropLineage?: boolean;
+}
+export interface ImportResult {
+    anchor: PatchAnchor;
+    sha256: string;
+    sha_matches: boolean | null;
+    model_matches: boolean | null;
+    first_prompt: string | null;
+}
+/** What the draft is built from — pure, so the unit test can pin the mapping without a node. */
+export declare function draftFromRecipe(file: string, r: LessonRecipe, a?: Partial<ImportArgs>): {
+    id: string;
+    name: string;
+    model_id: string | undefined;
+    benchmark: BenchmarkSpec;
+    description: string;
+    contributors?: Contributor[];
+    parents: string[];
+    first_prompt: string | null;
+};
+/**
+ * Import a downloaded lesson (`lesson-<slug>.npz` + `recipe.json`) as a PRIVATE draft on this node: the file stays where it is
+ * (`keepInPlace`), the benchmark comes from the recipe, nothing is announced and no ledger record is written.
+ * The data provider is kept on the draft as credit only (share 0) and the origin is `teach`, so a later `patch announce`
+ * still shows "Taught by …" — raise the share with `PATCH /api/patches/:id` / the web form before announcing if you want to pay them.
+ */
+export declare function patchImport(ctx: CliContext, a: ImportArgs): Promise<ImportResult>;
+export interface ByNameArgs extends BuyArgs, ResolveOptions {
+    /** stop after resolving and printing where the name points — do not buy anything */
+    resolveOnly?: boolean;
+    /** do not add the seller's node as a peer (the blob then has to come from somewhere this node already knows) */
+    noPeer?: boolean;
+}
+/**
+ * One line to use knowledge somebody else published, given only its name.
+ *
+ * This replaces a three-command sequence in which the operator carried an id between two machines by hand:
+ *
+ *   ainize patch ls --node http://their-node:3402 --status LISTED -q "<topic>"
+ *   ainize login && ainize use <id>
+ *
+ * WHAT THE NAME SUPPLIES is exactly what those commands supplied by hand: `ainize.node` is the `--node` of the
+ * first line, `ainize.patch` is the `<id>` of the third. Nothing else changes, and in particular THE BUYING
+ * STILL HAPPENS ON YOUR OWN NODE. `--node` in `patch ls` points at the seller because you are reading their
+ * catalogue; `use` has always run against your node, because your node is what pays, downloads and applies.
+ * Resolving a name must not quietly move that: a command that logged you into someone else's node and applied
+ * knowledge there would be a different operation wearing this one's name.
+ *
+ * So the seller's endpoint is used for the one thing it is for — telling your node where to fetch from, as a
+ * peer — and the rest of the flow is the local one you would have typed.
+ */
+export declare function patchByName(ctx: CliContext, name: string, a?: ByNameArgs): Promise<unknown>;
+//# sourceMappingURL=patch.d.ts.map