@leuduan/lagent 0.0.0-stage → 0.1.2

package/dist/plugins/tools/index.js

@@ -0,0 +1 @@
+import{a,b,c,d,e}from"../../chunks/ENWFSU27.js";import"../../chunks/OVZFGILJ.js";import"../../chunks/JPZFKSWT.js";import"../../chunks/NAOUTU7A.js";import"../../chunks/UKXMCHHT.js";import"../../chunks/WUUKTSRT.js";import"../../chunks/NDIM7MEW.js";import"../../chunks/34KW6VNQ.js";import"../../chunks/PUSUPTAT.js";import"../../chunks/G6RXC3AL.js";import"../../chunks/DXFXAYDN.js";import"../../chunks/YLNJXQ3Z.js";import"../../chunks/DDANMY45.js";import"../../chunks/37YOGDGY.js";import"../../chunks/KESCTXGO.js";import"../../chunks/TYTQRLTX.js";import"../../chunks/D7E6EWIE.js";export{a as READ_ONLY_TOOLS,b as RG_TOOLS,c as WEB_TOOLS,e as builtinTools,d as builtinToolsFor};

package/dist/plugins/tools/network.d.ts

@@ -0,0 +1,23 @@
+import type { LookupAddress, LookupAllOptions } from 'node:dns';
+import { type LookupFunction } from 'node:net';
+/** What a refused address is, for the message that names it. */
+type AddressKind = string;
+/**
+ * Why an IP address is not on the public internet, or `null` when it is. A zone index (`%eth0`) is
+ * ignored; anything that is not an IP address is `null`, for the resolver to judge.
+ */
+export declare function privateAddressKind(address: string): AddressKind | null;
+/** Refuses a fetch that would reach a private address, naming the host and what the address is. */
+export declare class PrivateAddressError extends Error {
+    readonly name = "PrivateAddressError";
+    constructor(host: string, address: string, kind: AddressKind);
+}
+/** Resolves every address of a host, as `dns.lookup` does with `all: true`. */
+export type ResolveAll = (hostname: string, options: LookupAllOptions, callback: (error: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void) => void;
+/**
+ * A socket `lookup` that resolves every address of the host and refuses the connection when any of
+ * them is private, so a mixed answer cannot pick its way past the check. The socket connects to an
+ * address checked here; TLS still verifies the certificate against the host name.
+ */
+export declare const refusingLookup: (resolveAll: ResolveAll) => LookupFunction;
+export {};

package/dist/plugins/tools/ripgrep.d.ts

@@ -0,0 +1,20 @@
+import type { Tool } from '../../loop/index.js';
+import { type SpawnEnvironment } from '../../sys/spawn.js';
+/**
+ * What both search tools run: the trusted `rg`, in the host's spawn environment, and how long one
+ * search's `rg` may run before what it found so far is returned as partial.
+ */
+export type SearchProgram = {
+    rg: string;
+    environment: SpawnEnvironment;
+    timeoutMs: number;
+};
+/** The most matches one search returns. */
+export declare const MAX_RG_RESULTS = 200;
+/** `rg_search`, running the trusted `rg` in the host's environment; its name and description say so. */
+export declare const rgSearchTool: (program: SearchProgram) => Tool;
+/**
+ * `rg_files`: `rg --files` lists what the search admits, and the pattern is matched against each
+ * listed path, relative to the search directory, so a pattern never lets an ignored file in.
+ */
+export declare const rgFilesTool: (program: SearchProgram) => Tool;

package/dist/plugins/tools/textEdit.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The text side of `edit_files`: decoding a file as text and encoding it back exactly as it was
+ * kept, and locating a hunk's old text in it.
+ *
+ * A hunk is matched exactly first, then in the three looser passes Codex's `apply_patch` uses
+ * (`codex-rs/apply-patch/src/seek_sequence.rs`): line by line ignoring trailing whitespace, then
+ * surrounding whitespace, then also typographic punctuation. Unlike Codex, which takes the first
+ * place a pass finds, a pass here decides only when it finds exactly one: a second place fails the
+ * hunk as ambiguous, and so does a second exact match.
+ *
+ * A pass that ignores surrounding whitespace can match lines indented differently from the old text.
+ * The new text is then shifted by the same difference, so what replaces the lines sits where they
+ * did; see {@link reindent}.
+ */
+/** A text file as `edit_files` keeps it: its text, and what it writes back around the text unchanged. */
+export type TextFile = {
+    /** Whether the file starts with a UTF-8 byte-order mark, which `text` leaves out. */
+    readonly bom: boolean;
+    readonly text: string;
+    /** The file's line ending, from its first line; `\n` for a file with none. */
+    readonly eol: '\n' | '\r\n';
+    /** Whether the file ends with a line ending. */
+    readonly finalNewline: boolean;
+};
+/** Why a file is not text `edit_files` will edit, or `null` and the file. */
+export declare function decodeText(bytes: Buffer): {
+    file: TextFile;
+    refusal: null;
+} | {
+    file: null;
+    refusal: string;
+};
+/** `text` as the file's bytes, with the BOM the file had. */
+export declare function encodeText(file: Pick<TextFile, 'bom'>, text: string): Buffer;
+/** `text` with its line endings made the file's. */
+export declare function withLineEndings(text: string, eol: TextFile['eol']): string;
+/**
+ * New text for a file whose old text was `file`, ending in a newline exactly when the old text
+ * did: one is added when it had one, and every trailing line ending removed when it had none. An
+ * empty file has no ending to keep, so its new text is taken as given.
+ */
+export declare function keepFinalNewline(file: TextFile, text: string): string;
+export type Hunk = {
+    readonly old_text: string;
+    readonly new_text: string;
+};
+/** How a hunk's old text was found, or why it was not. */
+export type HunkMatch = {
+    readonly found: true;
+    readonly text: string;
+    readonly pass: MatchPass;
+    /** Whether the new text was shifted to the file's indentation. */
+    readonly reindented: boolean;
+} | {
+    readonly found: false;
+    readonly reason: string;
+};
+export type MatchPass = 'exact' | 'trailing-whitespace' | 'whitespace' | 'punctuation';
+export declare const PASS_WORDING: Record<Exclude<MatchPass, 'exact'>, string>;
+/**
+ * `text` with `hunk` applied, in the file's line endings. The old text must be found in exactly
+ * one place; when it is found nowhere, the reason shows what was looked for and the lines of the
+ * file nearest to it.
+ */
+export declare function applyHunk(text: string, hunk: Hunk, eol: TextFile['eol']): HunkMatch;
+/** Codex's normalization: trimmed, with dashes, quotes and odd spaces made ASCII. */
+export declare function normalized(line: string): string;

package/dist/plugins/tools/web.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/**
+ * What web_fetch may reach: `refuse` keeps it on the public internet, refusing a host that is, or
+ * resolves to, a loopback, link-local, private, unique-local, CGNAT, unspecified, multicast or
+ * reserved address, in any of its IPv6 forms; `allow` reaches whatever the host can.
+ */
+export type PrivateNetwork = 'allow' | 'refuse';
+/** web_fetch, reaching what {@link PrivateNetwork} allows. */
+export declare const webFetchTool: (privateNetwork: PrivateNetwork) => import("../../plugin.js").Tool;
+/**
+ * What `web_search` runs on: the Codex login it searches through (`authPath`, with the refresh
+ * deadline every client of that login shares), the model the endpoint requires, and how much one
+ * search may return (`maxOutputTokens` bounds the text, `responseLength` the number of results).
+ */
+export declare const WebSearchConfigSchema: z.ZodObject<{
+    authPath: z.ZodString;
+    refreshTimeoutMs: z.ZodNumber;
+    model: z.ZodString;
+    maxOutputTokens: z.ZodNumber;
+    responseLength: z.ZodEnum<{
+        medium: "medium";
+        short: "short";
+        long: "long";
+    }>;
+}, z.core.$strict>;
+export type WebSearchConfig = z.output<typeof WebSearchConfigSchema>;
+/**
+ * web_search, through Codex's search endpoint over the Codex login. The server's text is returned as
+ * it is: each result's title and URL, its age and an excerpt. `results`, the same list as data, is
+ * kept for the host in `metadata`, opaque, and `null` when the server sent none.
+ */
+export declare const webSearchTool: (config: WebSearchConfig) => import("../../plugin.js").Tool;

package/dist/plugins/truncateToolOutput.d.ts

@@ -0,0 +1,26 @@
+import type { Plugin } from '@leuduan/cordis';
+import { z } from 'zod';
+import type { ToolResult } from '../models/index.js';
+/** Where full outputs go inside a thread's directory. */
+export declare const TOOL_OUTPUTS_DIR = "tool-outputs";
+/** The least limit that holds the longest gap marker and a character each of head and tail. */
+export declare const MIN_TOOL_OUTPUT_LENGTH: number;
+export declare const TruncateToolOutputConfigSchema: z.ZodObject<{
+    maxToolOutputLength: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type TruncateToolOutputConfig = z.input<typeof TruncateToolOutputConfigSchema>;
+/**
+ * Caps tool output at a character limit, keeping its head and its tail around a marker that says how
+ * much of the middle was cut, and writes the full text to the thread's own directory
+ * (`<thread dir>/tool-outputs/`), where file tools can read it back when available. Characters are
+ * UTF-16 code units, as `string.length` counts them, and no cut splits a surrogate pair. A tool may opt
+ * out by setting `no_truncation: true` in its result metadata. Because this wraps
+ * `lagent/tool/execute`, the journal records exactly what the model saw. A call that waits has
+ * no output to cap.
+ */
+export declare const truncateToolOutput: Plugin.Object<TruncateToolOutputConfig | undefined>;
+/**
+ * Truncates `result` to `limit` characters, head and tail with the gap marker between them, writing the
+ * full output into `directory` when it was cut. `limit` is at least {@link MIN_TOOL_OUTPUT_LENGTH}.
+ */
+export declare function applyTruncation(result: ToolResult, limit: number, directory: string): Promise<ToolResult>;

package/dist/plugins/truncateToolOutput.js

@@ -0,0 +1 @@
+import{a,b,c,d,e}from"../chunks/3LQHQRIU.js";import"../chunks/YLNJXQ3Z.js";import"../chunks/DDANMY45.js";import"../chunks/37YOGDGY.js";import"../chunks/KESCTXGO.js";import"../chunks/TYTQRLTX.js";import"../chunks/D7E6EWIE.js";export{b as MIN_TOOL_OUTPUT_LENGTH,a as TOOL_OUTPUTS_DIR,c as TruncateToolOutputConfigSchema,e as applyTruncation,d as truncateToolOutput};

package/dist/plugins/usage/index.d.ts

@@ -0,0 +1,24 @@
+import { Context, Service } from '@leuduan/cordis';
+import { UsageSnapshot } from './tracker.js';
+export { UsageSnapshot } from './tracker.js';
+export type { UsageSnapshotInit } from './tracker.js';
+declare module '@leuduan/cordis' {
+    interface Context {
+        /** Model usage totals per thread (optional plugin). */
+        usage: UsageService;
+    }
+}
+/**
+ * Model usage as a fold over each thread's journal. The engine itself counts nothing — without
+ * this service mounted, nobody is keeping score. There is no journal-wide total: a thread's spend
+ * is a function of its own rows, and a sum over several threads is the host's, over the threads it
+ * shows, as a caller-chain rollup is, by joining threads on `origin`.
+ */
+export declare class UsageService extends Service {
+    static inject: string[];
+    constructor(ctx: Context);
+    /** Everything one thread has spent so far. */
+    thread(threadId: string): UsageSnapshot;
+    /** What one thread's most recent completed turn spent. */
+    lastTurn(threadId: string): UsageSnapshot;
+}

package/dist/plugins/usage/index.js

@@ -0,0 +1 @@
+import{h as _}from"../../chunks/37YOGDGY.js";import"../../chunks/KESCTXGO.js";import"../../chunks/TYTQRLTX.js";import"../../chunks/D7E6EWIE.js";import{Service as a}from"@leuduan/cordis";var n=class e{request_count;input_tokens;output_tokens;cache_read_input_tokens;cache_write_input_tokens;reasoning_output_tokens;constructor(t={}){this.request_count=t.request_count??0,this.input_tokens=t.input_tokens??0,this.output_tokens=t.output_tokens??0,this.cache_read_input_tokens=t.cache_read_input_tokens??0,this.cache_write_input_tokens=t.cache_write_input_tokens??0,this.reasoning_output_tokens=t.reasoning_output_tokens??0,Object.freeze(this)}get totalTokens(){return this.input_tokens+this.output_tokens}get cacheMissInputTokens(){return this.input_tokens-this.cache_read_input_tokens}delta(t){return new e({request_count:this.request_count-t.request_count,input_tokens:this.input_tokens-t.input_tokens,output_tokens:this.output_tokens-t.output_tokens,cache_read_input_tokens:this.cache_read_input_tokens-t.cache_read_input_tokens,cache_write_input_tokens:this.cache_write_input_tokens-t.cache_write_input_tokens,reasoning_output_tokens:this.reasoning_output_tokens-t.reasoning_output_tokens})}plus(t){return new e({request_count:this.request_count+t.request_count,input_tokens:this.input_tokens+t.input_tokens,output_tokens:this.output_tokens+t.output_tokens,cache_read_input_tokens:this.cache_read_input_tokens+t.cache_read_input_tokens,cache_write_input_tokens:this.cache_write_input_tokens+t.cache_write_input_tokens,reasoning_output_tokens:this.reasoning_output_tokens+t.reasoning_output_tokens})}toJSON(){return{request_count:this.request_count,input_tokens:this.input_tokens,output_tokens:this.output_tokens,cache_read_input_tokens:this.cache_read_input_tokens,cache_write_input_tokens:this.cache_write_input_tokens,reasoning_output_tokens:this.reasoning_output_tokens}}},s=()=>({request_count:0,input_tokens:0,output_tokens:0,cache_read_input_tokens:0,cache_write_input_tokens:0,reasoning_output_tokens:0}),u=(e,t)=>{t&&(e.input_tokens+=t.input_tokens,e.output_tokens+=t.output_tokens,e.cache_read_input_tokens+=t.cache_read_input_tokens,e.cache_write_input_tokens+=t.cache_write_input_tokens,e.reasoning_output_tokens+=t.reasoning_output_tokens)};function r(e,t){switch(t.type){case"llm/request":case"auxiliary/request":e.request_count+=1;return;case"assistant/message":u(e,t.data.response.message.usage);return;case"auxiliary/result":u(e,t.data.usage);return;default:return}}var c=()=>({totals:s(),baseline:s(),lastTurn:s()}),o=_({key:"lagent:usage:thread",onFork:"reset",init:c,apply(e,t){return r(e.totals,t),t.type==="turn/start"?e.baseline={...e.totals}:t.type==="turn/end"&&(e.lastTurn=new n(e.totals).delta(new n(e.baseline)).toJSON()),e}}),i=class extends a{static inject=["journal"];constructor(t){super(t,"usage"),t.effect(()=>t.journal.register(o))}thread(t){return new n(this.ctx.journal.state(o,t).totals)}lastTurn(t){return new n(this.ctx.journal.state(o,t).lastTurn)}};export{i as UsageService,n as UsageSnapshot};

package/dist/plugins/usage/tracker.d.ts

@@ -0,0 +1,34 @@
+import type { JournalEvent } from '../../models/index.js';
+export type UsageSnapshotInit = Partial<{
+    request_count: number;
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_input_tokens: number;
+    cache_write_input_tokens: number;
+    reasoning_output_tokens: number;
+}>;
+export declare class UsageSnapshot {
+    readonly request_count: number;
+    readonly input_tokens: number;
+    readonly output_tokens: number;
+    readonly cache_read_input_tokens: number;
+    readonly cache_write_input_tokens: number;
+    readonly reasoning_output_tokens: number;
+    constructor(init?: UsageSnapshotInit);
+    get totalTokens(): number;
+    get cacheMissInputTokens(): number;
+    delta(previous: UsageSnapshot): UsageSnapshot;
+    /** This and `other` together: how a host sums the threads it shows, since nothing rolls up for it. */
+    plus(other: UsageSnapshot): UsageSnapshot;
+    toJSON(): Required<UsageSnapshotInit>;
+}
+/** A thread's usage counters as plain data: what the usage fold keeps, and what a snapshot is built from. */
+export type UsageCounters = Required<UsageSnapshotInit>;
+export declare const emptyCounters: () => UsageCounters;
+/**
+ * Counts model requests and aggregates token usage from `llm/request` and `assistant/message`, and
+ * from the auxiliary calls plugins make beside the conversation, `auxiliary/request` and
+ * `auxiliary/result`: a summary that was discarded was still paid for, so every result counts,
+ * whatever became of its text. Mutates `counters`; a fold reducer's state is its own to change.
+ */
+export declare function countEvent(counters: UsageCounters, event: JournalEvent): void;

package/dist/plugins/verify/facts.d.ts

@@ -0,0 +1,356 @@
+import { z } from 'zod';
+import { type PluginJournal } from '../../journal/index.js';
+import { type Refusal, type StopVerdict } from '../../loop/index.js';
+import type { Seq } from '../../models/index.js';
+import type { ReadonlyState } from '../../util/foldState.js';
+/** The verify preset's id. */
+export declare const VERIFY_PRESET = "verify";
+/** Times a thread is sent back to verify, since its last change, the person's last message or a requirement's arming, before its answer is rejected. */
+export declare const VERIFY_REMINDERS = 2;
+/** A verification: the command text `run_command` must be given, and the absolute directory it must run in. */
+export type Verification = {
+    readonly command: string;
+    readonly cwd: string;
+};
+/** What the model is told up front: the verification this conversation finishes with. Neither a change nor a reminder. */
+export declare const notice: {
+    record: (value: {
+        command: string;
+        cwd: string;
+    }) => import("../../models/index.js").ExtensionRecord;
+    parse: (value: {
+        command: string;
+        cwd: string;
+    }) => {
+        command: string;
+        cwd: string;
+    };
+    entry: (value: {
+        command: string;
+        cwd: string;
+    }, options: import("../../journal/journal.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../journal/journal.js").AppendOptions;
+    };
+    append(journal: PluginJournal, value: {
+        command: string;
+        cwd: string;
+    }, options: import("../../journal/journal.js").AppendOptions): Promise<import("../../models/index.js").JournalEvent<"ext">>;
+    read(event: import("../../models/index.js").JournalEvent): {
+        command: string;
+        cwd: string;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../models/index.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        command: string;
+        cwd: string;
+    }, options?: {
+        sourceSeqs?: readonly Seq[];
+    }): import("../../models/index.js").StepContribution;
+    matchesSource(record: import("../../util/json.js").DeepReadonly<import("../../models/index.js").ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        command: string;
+        cwd: string;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: import("../../models/index.js").ExtensionRecord;
+    };
+    readContribution: (event: import("../../models/index.js").JournalEvent) => {
+        command: string;
+        cwd: string;
+    } | undefined;
+    readSource: (source: import("../../util/json.js").DeepReadonly<import("../../models/index.js").ExtensionRecord> | null) => {
+        command: string;
+        cwd: string;
+    } | undefined;
+    told: import("../../journal/projection.js").PluginProjection<import("../../kit/extension.js").ToldNotices<{
+        command: string;
+        cwd: string;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            command: string;
+            cwd: string;
+        }, event: import("../../models/index.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../journal/projection.js").PluginProjection<State>;
+};
+/** An `edit_files` or `run_command` call the model asked for, until its result lands. */
+type TrackedCall = {
+    /** A `run_command`'s command, by {@link commandKey}, and the directory it runs in; `null` for an `edit_files` call. */
+    readonly run: PlacedRun | null;
+    /** Its latest allowed `tool/authorization` row: the moment it may have begun. `null` while it has none. */
+    allowedAt: Seq | null;
+};
+/** A `run_command` call as it is placed: its key, and the directory, when the thread's cwd is known. */
+type PlacedRun = {
+    readonly key: string;
+    readonly cwd: string | null;
+};
+/** What the thread's runs of one command text in one directory came to. */
+type CommandFacts = {
+    /** The latest result row of an allowed run, whatever its outcome. */
+    resultAt: Seq | null;
+    /** The latest result row of an allowed run that did not pass. */
+    failedAt: Seq | null;
+    /** The latest allowed attempt of a run that passed: everything settled before it is proven. */
+    provenAt: Seq | null;
+    /** The latest `tool/authorization` row of a call of it, and whether policy denied it. */
+    decision: {
+        readonly seq: Seq;
+        readonly denied: boolean;
+    } | null;
+};
+/**
+ * What every gate needs of a thread, folded from its rows whatever the gate's verification is: the
+ * calls in flight, and what each command run, each other change and the person came to. A gate
+ * judges its own verification from these when it is asked, so one fold serves every configuration.
+ */
+export type VerifyFacts = {
+    /** The thread's cwd, from its spawn row: what a `run_command` without `workdir` runs in. */
+    threadCwd: string | null;
+    calls: Map<string, TrackedCall>;
+    /** The latest row settling a change no verification could be: an `edit_files` result, a background command's start or end. */
+    changedAt: Seq | null;
+    /** Each command text and directory run, by {@link commandKey}. */
+    commands: Map<string, CommandFacts>;
+    /** The person's latest message. */
+    personAt: Seq | null;
+    /**
+     * The reminder rows of each verification, by {@link commandKey}, since the last row that starts
+     * its count over: the person writing, or a change other than a run of that verification.
+     */
+    reminders: Map<string, Seq[]>;
+};
+/** A command text and the directory it runs in, as one key; a directory not known never matches a verification. */
+export declare const commandKey: (command: string, cwd: string | null) => string;
+export declare const verifyFacts: import("../../journal/projection.js").PluginProjection<VerifyFacts>;
+/**
+ * What a thread's catalog entry says of its changes, for a caller above it whose work it is
+ * ({@link delegatedChange}), contributed for every thread while the `verify` service is mounted. A
+ * thread whose facts cannot be read reads `unavailable`, which nothing reads as "none".
+ */
+export declare const changes: import("../../services/contributions.js").ContributionDefinition<{
+    changed_at: number | null;
+}>;
+/** The last change a thread's delegated work made, or why it cannot be read. */
+export type DelegatedChange = {
+    readonly at: Seq | null;
+} | {
+    readonly unreadable: string;
+};
+/**
+ * The last change made by the work `threadId` delegated ({@link lastChange}): each thread
+ * its calls started, at any depth, from its facts when it is loaded, else its catalog entry, so it
+ * holds across a restart; or why one of them cannot be read, which fails closed. A thread an owner
+ * assigned (an assignment origin, such as a workflow's isolated participant) is that owner's work,
+ * judged by its own verification, so neither it nor anything under it is the caller's.
+ *
+ * Row seqs are one journal's, assigned in append order whichever thread a row belongs to, so a
+ * descendant's change and the caller's verification attempt compare directly: a change whose row
+ * was written before the attempt settled before the verification began.
+ */
+export declare function delegatedChange(journal: PluginJournal, threadId: string): DelegatedChange;
+/** What one verification's gate judges from a thread's facts. */
+type Judgment = {
+    /** The latest row settling a possible change, the thread's own or its delegated work's: a verification that passed is not one. */
+    readonly mutatedAt: Seq | null;
+    /** The allowed attempt of the latest verification that passed. */
+    readonly provenAt: Seq | null;
+    /** Whether policy denied the latest verification attempt since the person last wrote or the requirement armed. */
+    readonly denied: boolean;
+    /** Reminders since the last change other than a verification run, the person's last message, or the arming. */
+    readonly reminders: number;
+};
+/**
+ * One verification's judgment of a thread's facts, `delegatedAt` the last change its delegated work
+ * made: one starts the count of reminders over as the thread's own change does, which its fold
+ * already did for its own.
+ */
+export declare function judgment(facts: ReadonlyState<VerifyFacts>, verification: Verification, armedAt: Seq | null, delegatedAt: Seq | null): Judgment;
+/**
+ * A verification owed for one assignment, recorded on the thread serving it: the assignment's
+ * identity (its owner, id and participant generation, as an assignment origin names them), the
+ * input whose claim activates it, and the pinned verification. Its identity is the assignment's.
+ */
+declare const RequirementSchema: z.ZodObject<{
+    owner: z.ZodString;
+    assignment: z.ZodString;
+    generation: z.ZodNumber;
+    input: z.ZodString;
+    command: z.ZodString;
+    cwd: z.ZodString;
+}, z.core.$strict>;
+export type RequirementInput = z.input<typeof RequirementSchema>;
+export type Requirement = z.output<typeof RequirementSchema>;
+declare const requirement: {
+    record: (value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }) => import("../../models/index.js").ExtensionRecord;
+    parse: (value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }) => {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    };
+    entry: (value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }, options: import("../../journal/journal.js").AppendOptions) => {
+        type: "ext";
+        data: {
+            plugin: string;
+            instance_id: string;
+            kind: string;
+            version: number;
+            data: z.core.util.JSONType;
+        };
+        options: import("../../journal/journal.js").AppendOptions;
+    };
+    append(journal: PluginJournal, value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }, options: import("../../journal/journal.js").AppendOptions): Promise<import("../../models/index.js").JournalEvent<"ext">>;
+    read(event: import("../../models/index.js").JournalEvent): {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    } | undefined;
+    contribution(message: {
+        role?: import("../../models/index.js").InputRole;
+        content: string | readonly import("../../llm/content.js").ContentPartInput[];
+    }, value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }, options?: {
+        sourceSeqs?: readonly Seq[];
+    }): import("../../models/index.js").StepContribution;
+    matchesSource(record: import("../../util/json.js").DeepReadonly<import("../../models/index.js").ExtensionRecord>): boolean;
+    rejection(reason: string, value: {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }): {
+        decision: "reject";
+        reason: string;
+        source: import("../../models/index.js").ExtensionRecord;
+    };
+    readContribution: (event: import("../../models/index.js").JournalEvent) => {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    } | undefined;
+    readSource: (source: import("../../util/json.js").DeepReadonly<import("../../models/index.js").ExtensionRecord> | null) => {
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    } | undefined;
+    told: import("../../journal/projection.js").PluginProjection<import("../../kit/extension.js").ToldNotices<{
+        owner: string;
+        assignment: string;
+        generation: number;
+        input: string;
+        command: string;
+        cwd: string;
+    }>>;
+    projection<State>(fold: {
+        key: string;
+        init(): State;
+        apply(state: State, value: {
+            owner: string;
+            assignment: string;
+            generation: number;
+            input: string;
+            command: string;
+            cwd: string;
+        }, event: import("../../models/index.js").JournalEvent<"ext">): State;
+        onFork?: "inherit" | "reset";
+    }): import("../../journal/projection.js").PluginProjection<State>;
+};
+/** `value` validated as a requirement, its directory normalized as a placed run's is. */
+export declare function requirementValue(value: RequirementInput): Requirement;
+/**
+ * The rows recording `value` on `threadId`, decided inside its write: one row for a requirement
+ * not recorded yet; none for one recorded already exactly so (a replay renews nothing); a refusal
+ * for one recorded under its identity otherwise. A thread being opened has none recorded.
+ */
+export declare function requirementRows(journal: PluginJournal, threadId: string, opening: boolean, parsed: Requirement): ReturnType<typeof requirement.entry>[] | {
+    refuse: Refusal;
+};
+/**
+ * The requirement in force on a thread: the one armed last, with the moment it armed, the later of
+ * its input's claim and its own row (so one recorded after the claim arms at its row); `null` while
+ * none has armed. A participant serves one assignment at a time, so a later arming supersedes every
+ * earlier requirement: two of them, pinned to different commands, would otherwise each count the
+ * other's runs as changes and never both pass. A requirement lives for the assignment that armed it:
+ * a delegation task opened on the thread after it armed, a successor assignment owing no
+ * verification included, retires it. Row seqs are one journal's, so the two compare directly.
+ */
+export declare function inForce(journal: PluginJournal, threadId: string): {
+    verification: Verification;
+    at: Seq;
+} | null;
+/**
+ * The gate's say on a thread's answer for one verification, `armedAt` the moment its latest
+ * requirement armed, if one did, and `delegated` the last change its delegated work made
+ * ({@link delegatedChange}). What must be proven is everything settled before the barrier, the
+ * later of the last possible change, the thread's own or its delegated work's, and that arming, kept
+ * apart: an arming is no change, and a thread that changed nothing still owes its requirement a
+ * pass. It holds the answer until a verification whose allowed attempt came after the barrier
+ * passed, sending the model back at most {@link VERIFY_REMINDERS} times since the last change other
+ * than a verification run, the person's last message or the arming, then rejecting; it rejects at
+ * once when policy denied the latest attempt since the person last wrote or the requirement armed,
+ * and when the delegated work's changes cannot be read.
+ */
+export declare function verdict(facts: ReadonlyState<VerifyFacts>, verification: Verification, armedAt: Seq | null, delegated: DelegatedChange): StopVerdict | undefined;
+export {};