@tangle-network/agent-app 0.45.53 → 0.45.55

package/dist/work-product/index.d.ts

@@ -1,850 +1,17 @@
-import { b as WorkProductProvenance, d as WorkProductStorePort, e as WorkProductAuditEvent, c as WorkProductRecord, f as WorkProductArtifact, Q as QualityCheck, E as EvidenceEntry, g as ExceptionEntry, h as WorkProductStatus, W as WorkProductPersistedPart } from '../types-CCeYywdS.js';
-export { A as AgentCheckInput, i as EvidenceLocator, j as EvidenceSpan, k as ExceptionSeverity, P as ProfileBacktestSummary, l as QuoteBasis, m as WorkProductParseResult, n as WorkProductPatch, a as WorkProductRef, o as WorkProductUpdateGuard, p as WorkProductVersionEntry, q as isWorkProductStatus, r as parseAgentCheckInput, s as parseArtifactInput, t as parseEvidenceInput, u as parseExceptionInput, v as persistedPartToWorkProduct, w as unresolvedBlockingExceptions, x as workProductToPersistedPart } from '../types-CCeYywdS.js';
-import { A as AppToolContext, b as AppToolDefinition } from '../types-B25Mib1r.js';
-import { JudgeVerdict } from '@tangle-network/agent-eval';
-import { T as TrustItem } from '../trust-gate-Dcm5xSva.js';
-export { R as ReviewQueueInputs, a as ReviewQueueItem, b as ReviewQueuePendingAsk, c as ReviewQueueState, d as ReviewQueueThread, p as parseReviewQueueItem, e as projectReviewQueue } from '../queue-VTBA5ONX.js';
-
 /**
- * The guarded work-product status machine — the `/missions` service PATTERN
- * (load → validate against a transition table → CAS-write guarded on what was
- * read → audit event) over {@link WorkProductStorePort}. Deliberately NOT a
- * reuse of the mission service: missions' cursor/plan/budget machinery does
- * not apply here, and the six-status review machine is a different contract.
- *
- * Concurrency contract: a scope's draft is driven by a single serialized turn
- * owner, so real contention is rare. The service is the typed guard layer,
- * not a serializer — every mutation re-reads the record and CAS-writes
- * guarded on the `{status, version}` it read. A guard miss surfaces as
- * `{ succeeded: false, conflict: true }` (retryable: re-read and re-apply),
- * never a silent clobber.
- */
-
-/** Discriminated outcome for guarded operations — `conflict` distinguishes a
- *  lost guarded race (retryable) from a logic rejection (illegal edge,
- *  missing row — deterministic, never retried). */
-type WorkProductOutcome<T> = {
-    succeeded: true;
-    value: T;
-} | {
-    succeeded: false;
-    error: string;
-    conflict: boolean;
-};
-/** Whether a legal edge exists from `from` to `to` in the review machine. */
-declare function canTransitionWorkProduct(from: WorkProductStatus, to: WorkProductStatus): boolean;
-/** Statuses a work product can never leave. */
-declare function isWorkProductTerminal(status: WorkProductStatus): boolean;
-/** Define the input required to create a new draft work product row */
-interface CreateWorkProductInput {
-    /** Explicit row id — omit to use the service's generator. The MODEL never
-     *  supplies ids; this is for deterministic server-side creation. */
-    id?: string;
-    workspaceId: string;
-    threadId: string | null;
-    scopeKey: string;
-    /** Version this draft will become; default 1. The tool layer passes
-     *  `last reviewed version + 1` when a scope is re-engaged after approval. */
-    version?: number;
-    provenance: WorkProductProvenance;
-    /** Opaque product-column values handed VERBATIM to the store's insert. */
-    extras?: Record<string, unknown>;
-}
-/** Payload for the draft→ready submit transition */
-interface SubmitWorkProductInput {
-    artifact: WorkProductArtifact;
-    checks: QualityCheck[];
-    provenance: WorkProductProvenance;
-    /** Frozen snapshot ref of this version's body for the history entry;
-     *  defaults to `artifact.path`. */
-    artifactPath?: string;
-}
-/** Reviewer verdict payload for the ready→approved / ready→changes_requested transition */
-interface WorkProductVerdictInput {
-    verdict: 'approve' | 'request_changes';
-    reviewedBy: string;
-    note?: string;
-}
-/** Guarded mutation surface over the work-product store */
-interface WorkProductService {
-    create(input: CreateWorkProductInput): Promise<WorkProductRecord>;
-    get(id: string): Promise<WorkProductRecord | null>;
-    /** The scope's open accumulator row (`draft`/`blocked`), or null. */
-    openDraft(workspaceId: string, scopeKey: string): Promise<WorkProductRecord | null>;
-    /** The scope's `changes_requested` row awaiting its correction turn, or null. */
-    awaitingCorrection(workspaceId: string, scopeKey: string): Promise<WorkProductRecord | null>;
-    /** The scope's `ready` row awaiting review, or null. */
-    awaitingReview(workspaceId: string, scopeKey: string): Promise<WorkProductRecord | null>;
-    /** `max(version over the scope's approved/superseded rows) + 1` — the
-     *  version a fresh draft for the scope should carry. */
-    nextVersion(workspaceId: string, scopeKey: string): Promise<number>;
-    /** Re-open a `changes_requested` row as the next draft: version bumps +1
-     *  and the correction turn accumulates into the same scope row. */
-    reopen(id: string): Promise<WorkProductOutcome<WorkProductRecord>>;
-    /** Merge evidence entries by id AND by what they assert (target + source +
-     *  claim), so re-stating a fact already recorded replaces it under whatever
-     *  id this batch minted rather than appending a near-copy. Legal only while
-     *  `draft`/`blocked`. */
-    upsertEvidence(id: string, entries: readonly EvidenceEntry[]): Promise<WorkProductOutcome<WorkProductRecord>>;
-    /** Merge exception entries by id, then reconcile the blocked flag: any
-     *  unresolved blocking entry parks `draft`→`blocked`; resolving the last
-     *  one releases `blocked`→`draft`. */
-    upsertExceptions(id: string, entries: readonly ExceptionEntry[]): Promise<WorkProductOutcome<WorkProductRecord>>;
-    /** Persist a checks array without transitioning — how a failed platform
-     *  gate (e.g. evidence_coverage) stays visible on the still-draft row. */
-    recordChecks(id: string, checks: readonly QualityCheck[]): Promise<WorkProductOutcome<WorkProductRecord>>;
-    /** The terminal agent call: CAS `draft`→`ready` with artifact + checks +
-     *  provenance, appending the version-history entry. Refuses while an
-     *  unresolved blocking exception exists. */
-    submit(id: string, input: SubmitWorkProductInput): Promise<WorkProductOutcome<WorkProductRecord>>;
-    /** Reviewer verdict: CAS `ready`→`approved`/`changes_requested` + history
-     *  entry. Approval also supersedes the scope's prior approved versions so
-     *  exactly one approved version is current per scope. */
-    applyVerdict(id: string, input: WorkProductVerdictInput): Promise<WorkProductOutcome<WorkProductRecord>>;
-    /** Explicit replacement: CAS to `superseded` (legal from ready /
-     *  changes_requested / approved). */
-    supersede(id: string): Promise<WorkProductOutcome<WorkProductRecord>>;
-}
-/** Configuration options for creating a work product service */
-interface WorkProductServiceOptions {
-    store: WorkProductStorePort;
-    /** Injectable clock (epoch ms). Default `Date.now`. */
-    now?: () => number;
-    /** Row-id generator. Default `crypto.randomUUID()`. */
-    generateId?: () => string;
-}
-/** Create the guarded work-product service over a store port */
-declare function createWorkProductService(options: WorkProductServiceOptions): WorkProductService;
-/** In-memory store surface with audit trail access and unguarded direct writes for tests */
-interface InMemoryWorkProductStore extends WorkProductStorePort {
-    /** The full audit trail, append order. */
-    events(): WorkProductAuditEvent[];
-    /** Unguarded direct write — simulates a concurrent owner in tests. */
-    put(record: WorkProductRecord): void;
-}
-/**
- * In-memory {@link WorkProductStorePort} — the portable backend for tests and
- * reference assemblies. Records are deep-copied on every boundary so callers
- * can never mutate stored state around the guards.
- */
-declare function createInMemoryWorkProductStore(): InMemoryWorkProductStore;
-
-/**
- * Provenance stamping — the backtest spine. Every version of every work
- * product carries `profileHash + runId + servingModels`, stamped at the two
- * honest moments:
- *
- *  1. At dispatch, the product route composes the turn's profile and computes
- *     agent-eval's `agentProfileHash(profile)` — the SAME hash that keys the
- *     app's scorecard cells — and closes it (plus runId/sessionId) into the
- *     `provenance` seam `buildWorkProductTools` receives, so the model can
- *     neither omit nor forge it.
- *  2. At turn completion, the route's existing lifecycle seam calls
- *     {@link finalizeWorkProductProvenance}: serving model and cost come from
- *     the usage receipt, because only the completed turn knows what actually
- *     served. `servingModels` is honestly EMPTY until then.
- *
- * The trust bridge ({@link workProductTrustInputs}) maps judge-sourced
- * quality verdicts into `/eval-campaign`'s `trustVerdicts()` input with
- * type-only imports — products call `trustVerdicts` from
- * `@tangle-network/agent-app/eval-campaign` (which they already import for
- * their ensemble loop). Deliberately NOT a value re-export here: it would put
- * agent-eval's runtime on `/work-product`'s import path and drag the eval
- * engine into every product worker bundle.
- */
-
-/** The dispatch-time provenance closure's output: everything the route knows
- *  before the turn completes. */
-type WorkProductProvenanceBase = Omit<WorkProductProvenance, 'servingModels' | 'producedAt'>;
-/** Stamp a full provenance from the dispatch-time base. `servingModels` starts
- *  empty (honestly absent — never guessed) until the completion back-fill. */
-declare function stampProvenance(base: WorkProductProvenanceBase, now?: () => number): WorkProductProvenance;
-/** Completion receipt for one run, from the turn's usage/lifecycle seam. */
-interface FinalizeWorkProductProvenanceInput {
-    workspaceId: string;
-    /** The chat turnId / mission-step run id the records were stamped with. */
-    runId: string;
-    /** What actually served, from the usage receipt / serving-model header. */
-    servingModels: readonly string[];
-    costUsd?: number;
-    logger?: Pick<Console, 'warn'>;
-}
-/**
- * Back-fill `servingModels`/`costUsd` onto every record (and its history
- * entries) stamped with `runId` — wire it into the chat route's existing
- * `lifecycle.onTurnComplete` seam; no new hook. Returns the updated records.
- * A CAS miss on one record is logged and skipped (the next completion or a
- * re-read re-applies); it never throws mid-fleet.
- */
-declare function finalizeWorkProductProvenance(store: WorkProductStorePort, input: FinalizeWorkProductProvenanceInput): Promise<WorkProductRecord[]>;
-/**
- * Trust-gate bridge: one `TrustItem` per work product whose production
- * quality was scored by the product's eval-campaign ensemble. `verdictsFor`
- * returns the per-judge raw verdicts the product retained for a record (the
- * same verdicts `aggregateJudgeVerdicts` reduces); records without verdicts
- * are omitted. Feed the result to `/eval-campaign`'s `trustVerdicts()` —
- * an untrusted verdict renders as "quality: unverified", never a naked
- * number. Zero statistics code here: pure mapping.
- */
-declare function workProductTrustInputs<D extends string = string>(records: readonly WorkProductRecord[], verdictsFor: (record: WorkProductRecord) => readonly JudgeVerdict<D>[] | undefined): TrustItem<D>[];
-
-/**
- * Claim support and target correctness — is this citation attached to the RIGHT
- * place, and does the text it names actually say what the entry claims?
- *
- * Three checks live here, each answering a different half of "is this evidence
- * row honest": {@link verifyClaimSupport} (claim ↔ cited text),
- * {@link verifyTargetLabel} (target ↔ cited line), and
- * {@link verifyArtifactAgreement} (claim ↔ the artifact field it decorates).
- * They share the numeric canonicalization below, which is why they share a
- * file — a second copy of "what counts as the same figure" is how two gates
- * drift into disagreeing about the same row.
- *
- * ── Check one: claim support ────────────────────────────────────────────────
- *
- * The two gates before this one answer different questions. `sourceContainsQuote`
- * asks whether the quote is really in the document; `findSourceLine` /
- * `sliceSourceSpan` make the platform produce the quote so it cannot be typed
- * wrong. Both are about the TEXT's provenance. Neither one looks at `claim`.
- *
- * Production row `7256ef49` is what that gap costs. Four evidence entries, all
- * `quoteBasis:'span'`, every quote a genuine slice of the document it named —
- * and every one landing on the employer/payer line about 200 characters above
- * the figure:
- *
- *     claim 128450.00  ->  "tics LLC   EIN 84-2213907\nEmployee: Dana"
- *     claim 812.44     ->  "nt Savings Bank   TIN 22-5510983\nRecip"
- *     claim 2204.18    ->  "ndex Fund Trust   TIN 47-3320115\nRec"
- *     claim 1955.02    ->  "pient: Dana R. Whitfield\n------------"
- *
- * That is strictly worse than a fabricated quote. A fabricated quote fails the
- * verbatim gate; this one passes every gate, is real text from the right
- * document, and reads to a reviewer as an authoritative citation while
- * supporting nothing. `locator.find` (the platform locating a value the model
- * names) prevents the model from ADDRESSING the wrong line, and it is the right
- * primary fix. This module is the independent check underneath it: whatever
- * anchoring form produced the text, the text has to contain the figure.
- *
- * That also settles what a raw `locator.span` is worth. Hand-computed offsets
- * stay accepted, but only when they independently verify — which is exactly
- * "the slice contains the claimed value".
- *
- * ── The rule, and why it is drawn here ──────────────────────────────────────
- *
- * Strict on figures, silent on everything else. An unsatisfiable gate does not
- * stop a bad submit, it SELECTS for one — that is the measured mechanism behind
- * the 38 fabricated quotes on row `a68b1943`, where a coverage gate demanded
- * document lineage for computed values and got thirteen invented citations
- * forty seconds later. So the rule fires only where an honest citation can
- * always satisfy it:
- *
- *  - The claim IS a value (`"128450.00"`, `"$30,000"`, `"3"`) — the anchored
- *    text MUST contain that value. No latitude. This is the shape every tax
- *    figure takes and the shape row `7256ef49` failed.
- *  - The claim is prose naming figures (`"indemnity capped at $5,000,000"`) —
- *    at least one of its currency-shaped figures must occur. Not all of them:
- *    a claim may legitimately narrate a computation over several lines while
- *    anchoring to the one line under discussion, and refusing that would make
- *    an honest citation unrepresentable for the sake of a stricter-sounding
- *    rule. One is enough to keep the anchor tethered to the claim's subject.
- *  - The claim carries no figure at all (`"Married Filing Jointly"`,
- *    `"Dana R. Whitfield"`, `"2025-04-15"`) — nothing to check, and the entry
- *    passes. A filing status has no number to find, and inventing a
- *    word-overlap score here would re-open the hole the verbatim gate closes.
- *  - The entry has no anchored text at all — nothing to check. A computed
- *    value cites its computation, not a document.
- *
- * A bare year, a form number and a box number are deliberately NOT figures:
- * `2025`, `1040` and `Box 1` have no thousands separator, no cent pair and no
- * currency symbol, so prose mentioning them does not trip the rule.
- *
- * ── Matching is value-wise, never substring ─────────────────────────────────
- *
- * `text.includes(claim)` would be the obvious implementation and it is wrong in
- * the direction that matters: it passes `"450.00"` against `"128,450.00"`, so a
- * claim citing the wrong figure survives whenever its digits happen to be a tail
- * of a real one. Both sides are tokenized into numbers and compared as VALUES,
- * so `450` and `128450` are simply different.
- */
-/**
- * Reduce a numeric token to the form both sides are compared in: no currency,
- * no grouping, no trailing zeros in the fraction, no leading zeros.
- *
- * Sign and accounting parentheses are stripped rather than preserved, so
- * `(1,234.00)`, `-1,234.00` and `1,234.00` all reduce to `1234`. A document
- * renders the same deduction all three ways depending on the form and the
- * extractor, and the sign is a property of the TARGET LINE's semantics, not of
- * the document's typography. Comparing magnitudes keeps those honest citations
- * working, and it concedes nothing to fabrication: the digits still have to be
- * the document's digits.
- *
- * Returns `null` for anything that is not a plain number.
- */
-declare function canonicalizeValue(token: string): string | null;
-/** Every distinct value appearing in `text`, canonicalized. */
-declare function valuesInText(text: string): string[];
-/**
- * The values a claim asserts, canonicalized — empty when the claim asserts no
- * figure, which is the "nothing to check" case.
- *
- * A claim that is ENTIRELY one value yields that value (strict path). Otherwise
- * only currency-shaped figures inside the prose count, so an assertion that
- * merely mentions a year or a form number yields nothing.
- */
-declare function claimValues(claim: string): string[];
-type ClaimSupport = 
-/** No figure to check: a non-numeric claim, or no anchored text. */
-{
-    status: 'not_applicable';
-} | {
-    status: 'supported';
-    matched: string;
-} | {
-    status: 'unsupported';
-    claimed: string[];
-    present: string[];
-};
-/**
- * Does `quote` carry the figure `claim` asserts?
- *
- * `supported` requires ONE claimed value to occur, which is exact for the
- * single-value claim (there is only one) and deliberate latitude for prose (see
- * the rule note at the top of the file).
- */
-declare function verifyClaimSupport(quote: string, claim: string): ClaimSupport;
-/**
- * The sentence a model can act on without re-reading the document: what it
- * claimed, what the line it cited actually says, what figures that line does
- * carry, and the two ways out — cite the value, or drop the locator because the
- * figure was computed. Naming both keeps the gate satisfiable, which is the
- * property that stops it manufacturing the citation it screens for.
- */
-declare function claimSupportErrorDetail(failure: Extract<ClaimSupport, {
-    status: 'unsupported';
-}>, quote: string): string;
-/**
- * Does the cited line belong to the target the entry attaches it to?
- *
- * `verifyClaimSupport` asks whether the anchored text carries the claimed
- * figure. It is blind, BY CONSTRUCTION, to whether that figure belongs on that
- * line. Production row `95105c8a` is what the blindness costs — two entries,
- * both anchored to a real line of the right document, both carrying the figure
- * they claim, and both attached to the wrong form line:
- *
- *     f1040.line_3b  claim 1955.02  ->  "Box 1b  Qualified dividends ..... 1,955.02"
- *     f1040.line_3a  claim 2204.18  ->  "Box 1a  Total ordinary dividends . 2,204.18"
- *
- * Form 1040 line 3a is QUALIFIED dividends and line 3b is ORDINARY, so each
- * citation points a reviewer at the other one's line. `quote_verification`,
- * `claim_support` and `evidence_coverage` were all green on that row. A
- * citation that points at the wrong line is a wrong citation even when every
- * character of it is real, and it is the failure a reviewer is least able to
- * catch by eye, because it looks exactly like a good one.
- *
- * ── Why the domain supplies LABELS and the shell supplies the COMPARISON ────
- *
- * The shell cannot know that line 3a means qualified dividends; that is tax
- * vocabulary and baking it here would violate the one rule this package is
- * built on. So the product declares which targets are CONFUSABLE with each
- * other and what each one's line looks like in a source document — a
- * {@link ConfusableTargetGroup} — and the shell does the comparing.
- *
- * ── Why a group of labels, and not a per-target expectation ─────────────────
- *
- * The obvious shape is a per-target expectation read POSITIVELY: "a citation
- * for line_3a must contain 'Qualified'". It is stricter, it is easier to
- * explain, and it is the wrong shape, because it refuses honest work. A
- * consolidated broker statement writing "Qual. div. income", a payer writing
- * "Dividends that are qualified", an OCR layer dropping a word — each one turns
- * a correct citation into a refusal. And this codebase has already measured
- * what refusing honest work does: a coverage gate that demanded document
- * lineage for computed values produced 38 fabricated quotes on row `a68b1943`,
- * because a gate a model cannot satisfy honestly is a gate it satisfies
- * dishonestly. An unsatisfiable rule does not stop bad work; it SELECTS for
- * invented work.
- *
- * So the same labels are read NEGATIVELY and COMPARATIVELY. An entry is
- * refused only when the cited line positively identifies a SIBLING target and
- * says nothing that identifies its own:
- *
- *  - the line carries one of the target's own labels  → `identified`, pass
- *  - the line carries no label from the group at all  → `not_applicable`, pass
- *  - the line carries a sibling's label and none of its own → `crossed`, refuse
- *
- * Silence therefore always passes. An unusually-labelled document costs
- * nothing, a target the product never grouped costs nothing, and the only way
- * to fail is for the document itself to say the line belongs to a different
- * target — which is not a phrasing accident, it is the crossed pair. The rule
- * is satisfiable by the honest citation in every case, and unsatisfiable only
- * by the wrong one.
- *
- * Matching is punctuation- and case-insensitive: a label is a semantic marker
- * for which LINE this is, not a quotation. (`sourceContainsQuote` stays exact —
- * different question, different tolerance.)
- */
-/** One set of targets whose source lines are mistakable for each other, with
- *  the phrases that tell them apart. Every string is product vocabulary; the
- *  shell reads none of them as meaning anything. */
-interface ConfusableTargetGroup {
-    /** Named in the refusal so the model is told which distinction it missed
-     *  ("Form 1099-DIV boxes 1a/1b"). */
-    note?: string;
-    /** Target → phrases that identify THAT target's line in a source document.
-     *  Targets must be spelled the way evidence targets are spelled after the
-     *  product's `normalizeTarget`, so one canonical name is written once. */
-    labels: Record<string, readonly string[]>;
-}
-type TargetLabelVerdict = 
-/** No group covers this target, or the line says nothing either way. */
-{
-    status: 'not_applicable';
-}
-/** The cited line carries one of this target's own labels. */
- | {
-    status: 'identified';
-    label: string;
-}
-/** The cited line identifies a DIFFERENT target in the same group. */
- | {
-    status: 'crossed';
-    rival: string;
-    rivalLabel: string;
-    expected: readonly string[];
-    note?: string;
-};
-declare function verifyTargetLabel(quote: string, target: string, groups: readonly ConfusableTargetGroup[]): TargetLabelVerdict;
-/** The sentence a model can act on: which line it actually cited, which target
- *  that line belongs to, and what its own target's line looks like. */
-declare function targetLabelErrorDetail(failure: Extract<TargetLabelVerdict, {
-    status: 'crossed';
-}>, target: string, quote: string): string;
-/**
- * Does the entry agree with the artifact it is evidence FOR?
- *
- * The two checks above compare evidence to the SOURCE. This one compares it to
- * the DELIVERABLE, and it needs no product vocabulary at all: when the artifact
- * states a value for a target and an evidence entry attached to that target
- * asserts a different one, the work product contradicts itself, and a reviewer
- * clicking that line is shown a figure the package does not report there.
- *
- * ── The rule, and the honest citation it must not refuse ────────────────────
- *
- * "Claim must equal the field" is the tempting rule and it is unsatisfiable for
- * every aggregated or derived line. Measured on production row `a68b1943`:
- * line 1a is 189,750.00 and its two evidence rows cite $128,450.00 and
- * $61,300.00 — one per W-2, which is exactly the lineage a reviewer wants.
- * Line 8 is a Schedule C net profit of 11,056.56 evidenced by gross receipts of
- * 14,750.00 and four expense lines. Refusing those would delete correct work
- * and, on this codebase's measured history, buy invented citations in its place.
- *
- * So the refusal is narrower and it is a CONTRADICTION rather than an
- * inequality: the claim asserts a figure that the artifact itself assigns to a
- * DIFFERENT target. On row `95105c8a` that is precisely the crossed pair —
- * `line_3a` is 1955.02 in the artifact and its evidence claims 2204.18, which
- * the same artifact reports on `line_3b`. There is no honest reading of that:
- * the package cannot simultaneously say the number belongs on 3b and offer it
- * as the support for 3a.
- *
- * A component that appears nowhere else in the field map (128,450.00 of a
- * 189,750.00 total) is not a contradiction and is not refused. A claim
- * narrating a computation passes as soon as one of its figures is the target's
- * own value, which is what a narration of line 9 does by definition.
- */
-/** Canonical target → canonical value, for the artifact fields that state a
- *  figure. Non-numeric fields are dropped: a filing status or a name has no
- *  numeric contradiction to detect, and inventing a string comparison here
- *  would re-open the fuzzy-matching hole the quote gate closes. */
-declare function indexArtifactValues(fields: Readonly<Record<string, unknown>> | undefined, normalizeTarget?: (target: string) => string): Map<string, string>;
-type ArtifactAgreement = 
-/** The artifact states no figure for this target, or the claim asserts none. */
-{
-    status: 'not_applicable';
-} | {
-    status: 'agrees';
-    value: string;
-}
-/** The claim asserts a figure the artifact reports on a different target. */
- | {
-    status: 'contradicts';
-    claimed: string;
-    expected: string;
-    belongsTo: string;
-};
-declare function verifyArtifactAgreement(target: string, claim: string, fieldValues: ReadonlyMap<string, string>): ArtifactAgreement;
-/** The sentence a model can act on: both numbers, both lines, and the two ways
- *  out — move the citation, or correct the artifact. */
-declare function artifactAgreementErrorDetail(failure: Extract<ArtifactAgreement, {
-    status: 'contradicts';
-}>, target: string): string;
-
-/**
- * The agent-facing work-product side channel — three registry `customTools`
- * built on `/tools`' `defineAppTool`, dispatched through `dispatchAppTool`'s
- * single validation/outcome path (a thrown `ToolInputError` → correctable 4xx
- * back to the model; any other throw → internal error; a call never silently
- * succeeds without its effect). Deliberately NOT new `/tools` built-ins:
- * extending `AppToolHandlers` would break every existing consumer, and the
- * registry seam exists precisely for a product tool family like this.
- *
- * Partial-emission contract across a long turn: the draft ROW is the
- * accumulator. Evidence and exceptions stream in as found via small batched
- * calls; the artifact arrives once at the end. The agent addresses everything
- * by `scopeKey` — the server mints row ids, the model never invents them, and
- * identity (userId/workspaceId/threadId) rides the trusted `AppToolContext`
- * from headers, never model args. A turn that dies mid-emission leaves a
- * consistent draft the next turn resumes by the same scopeKey.
- */
-
-/** Max entries per `upsert_evidence`/`flag_exception` call — keeps each call a
- *  small batch the model can correct precisely on a named-index failure. */
-declare const MAX_WORK_PRODUCT_BATCH = 50;
-/** Platform check: every material target has ≥1 evidence row. Recorded as
- *  `QualityCheck{source:'platform'}`. */
-declare const EVIDENCE_COVERAGE_CHECK = "evidence_coverage";
-/** Platform check: how many evidence entries carry a quote the shell PROVED
- *  occurs in the source it names. Recorded when `readSourceText` is wired, so
- *  a reviewer reads the strength of the lineage off the row itself rather than
- *  trusting that a quote was checked. */
-declare const QUOTE_VERIFICATION_CHECK = "quote_verification";
-/** Platform check: how many quoted evidence entries anchor to text that
- *  actually CARRIES the figure the entry claims. Distinct from
- *  `quote_verification`, which only proves the text came from the document —
- *  production row `7256ef49` passed that one on all four entries while
- *  supporting none of them. */
-declare const CLAIM_SUPPORT_CHECK = "claim_support";
-/** Platform check: how many citations anchor to a line that belongs to the
- *  TARGET they are attached to, rather than to a sibling target's line.
- *  Recorded when the product declares `confusableTargets`; `claim_support`
- *  passes a crossed pair by construction, because the figure really is on the
- *  line — the wrong one. */
-declare const TARGET_CORRECTNESS_CHECK = "target_correctness";
-/** Platform check: how many evidence claims agree with the artifact field they
- *  decorate. A package whose evidence reports one figure on a line and whose
- *  artifact reports another contradicts itself; every other gate on this row
- *  reads only one of the two halves. */
-declare const ARTIFACT_AGREEMENT_CHECK = "artifact_agreement";
-/** Domain seams for the three work-product tools — every domain word is a
- *  parameter; the shell bakes none. */
-interface WorkProductToolConfig {
-    store: WorkProductStorePort;
-    /** PARAMETER — accepted `artifact.kind` values, validated on submit. */
-    artifactKinds: readonly string[];
-    /** PARAMETER — accepted exception `kind` values. */
-    exceptionKinds: readonly string[];
-    /** Fail-loud source check: resolve an evidence `sourceRef` to existence
-     *  (vault stat / attachment lookup). A dangling ref is a `ToolInputError`
-     *  naming the entry index — lineage can never point at nothing. */
-    resolveSourceRef: (ref: string, ctx: AppToolContext) => Promise<boolean>;
-    /** Fail-loud QUOTE verification: return the source document's TEXT for a
-     *  ref so the shell can prove each `locator.quote` occurs in it verbatim.
-     *  Wiring this turns the gate ON — a quote that does not occur is a
-     *  `ToolInputError` naming the entry index, so the model re-extracts from
-     *  the document instead of persisting invented lineage.
-     *
-     *  Return `null` ONLY when the ref genuinely has no extractable text (an
-     *  image scan, an opaque blob). The gate is fail-CLOSED on `null`: a quote
-     *  that cannot be checked is refused, because "unverifiable" and "verified"
-     *  must never look the same to a reviewer. Such an entry is still recordable
-     *  without `locator.quote` — `claim` carries the assertion.
-     *
-     *  Omit the seam entirely and no quote is checked. */
-    readSourceText?: (ref: string, ctx: AppToolContext) => Promise<string | null>;
-    /** The material targets the platform coverage check requires evidence for.
-     *  Product-owned vocabulary; omit to skip the coverage gate.
-     *
-     *  Return ONLY targets a source document can actually evidence. A gate that
-     *  demands document lineage for a value the session COMPUTED is not
-     *  satisfiable by any honest answer, and an unsatisfiable gate does not stop
-     *  a submit — it selects for an invented one. Computed values belong to a
-     *  product's own computation check, where "matches what we already
-     *  calculated" is satisfiable by construction. */
-    materialTargets?: (artifact: WorkProductArtifact) => string[];
-    /** Require every material target to carry a SOURCE ANCHOR — a span-sliced or
-     *  verified quote — not merely an evidence row. Off by default (a bare
-     *  `claim` is legitimate lineage for products with no readable sources);
-     *  turn it ON once `readSourceText` is wired and `materialTargets` names only
-     *  document-derived targets, and coverage stops being satisfiable by
-     *  assertion. */
-    requireAnchoredEvidence?: boolean;
-    /** Verify that each anchored quote CARRIES the figure its entry claims.
-     *  ON by default — an anchor that does not support its claim is the one
-     *  failure mode every other gate here passes, and it reads to a reviewer as
-     *  the most authoritative citation on the row.
-     *
-     *  Only claims that assert a figure are checked, so a filing status, a name
-     *  or a date is unaffected; see `./claim-support` for exactly where the line
-     *  is drawn and why it is drawn to stay satisfiable. Set `false` only for a
-     *  product whose claims are figures the source states in a form no numeric
-     *  comparison can reach. */
-    verifyClaimSupport?: boolean;
-    /** Fold an evidence `target` (and every `materialTargets` name) to the
-     *  product's ONE canonical spelling.
-     *
-     *  Without it a target namespace forks and every check that joins evidence
-     *  to the artifact by name silently half-works. Measured on production row
-     *  `95105c8a`: the same seven form lines arrived as `line_3a` and
-     *  `f1040.line_3a` in one turn, so coverage, deduplication and artifact
-     *  agreement each saw two unrelated targets where the return has one line.
-     *
-     *  Pure and total — it runs on every ingested entry and on the coverage
-     *  target list, so a target it does not recognize must come back unchanged
-     *  rather than throw. */
-    normalizeTarget?: (target: string) => string;
-    /** Targets whose SOURCE LINES are mistakable for each other, with the
-     *  phrases that tell them apart — the product's vocabulary, compared by the
-     *  shell. Omit and no target-correctness check runs.
-     *
-     *  Read negatively: an entry is refused only when the line it cites carries
-     *  a sibling target's label and none of its own, so an unusually-labelled
-     *  document never costs an honest citation. See `./claim-support` for why
-     *  the positive form ("the line must say X") is the wrong shape. */
-    confusableTargets?: readonly ConfusableTargetGroup[];
-    /** Refuse an evidence claim that asserts a figure the artifact reports on a
-     *  DIFFERENT target. ON by default and domain-free — it compares the package
-     *  to itself. Set `false` only for a product whose evidence claims are not
-     *  the artifact's own figures. */
-    verifyArtifactAgreement?: boolean;
-    /** Per-turn provenance closure the ROUTE supplies (profileHash + runId are
-     *  known at dispatch; trusted, never read from model args). */
-    provenance: (ctx: AppToolContext) => WorkProductProvenanceBase;
-    /** Called on the draft→ready commit so the route persists the transcript
-     *  anchor part and the queue projection updates. */
-    onReady?: (record: WorkProductRecord, ctx: AppToolContext) => void | Promise<void>;
-    /** Injectable clock / id generator (tests, deterministic ids). */
-    now?: () => number;
-    generateId?: () => string;
-}
-/** Build the three work-product tools for `customTools` registration on the
- *  MCP server / HTTP handler / runtime executor. */
-declare function buildWorkProductTools(config: WorkProductToolConfig): AppToolDefinition[];
-
-/**
- * Verbatim quote verification — the lineage gate.
- *
- * An evidence `locator.quote` is the reviewer's click target: it must land on
- * text that is actually in the document the entry names. Nothing here is
- * fuzzy. The only latitude is representational — the same characters written
- * differently by a PDF extractor, a text transcription, or a model repeating
- * what it read: Unicode compatibility forms, curly quotes, the several dash
- * codepoints, non-breaking spaces, and run-length whitespace. A quote that
- * still does not occur after that is not a formatting difference; it is text
- * the document does not contain.
- *
- * Deliberately NOT tolerated, because each one re-opens the hole this closes:
- * case (a quote is a quote), token subsets, edit distance, word-overlap
- * scoring, and "the numbers match" heuristics. A fabricated quote and a real
- * one differ by exactly the thing a fuzzy matcher forgives.
- */
-/**
- * Fold a string to the form both sides of a quote comparison are measured in.
- * Composition and presentation only: NFKC, one dash, one apostrophe, one
- * double quote, runs of any whitespace to a single space, trimmed. Case is
- * PRESERVED — lowercasing would let "Box 1" match "box 1", and a citation
- * that cannot reproduce capitalization did not read the document.
- */
-declare function normalizeQuoteText(value: string): string;
-/**
- * Does `quote` occur in `sourceText`? Exact substring first (the common case,
- * and free); the normalized comparison second, for the representational
- * differences above. Nothing else.
- *
- * An empty or whitespace-only quote is NOT a match — it would otherwise be a
- * substring of every document and pass the gate vacuously.
- */
-declare function sourceContainsQuote(sourceText: string, quote: string): boolean;
-/**
- * Slice a citation out of the source text by character offset — the reason
- * this module exists in its stronger form.
- *
- * Verification above is a REJECTION gate: the model retypes a quote and the
- * shell refuses it when the characters do not occur. That gate is correct and
- * it works, but a model that reproduces a line character-for-character only
- * some of the time cannot USE it — every miss is a refusal, and the package
- * ends up with no lineage at all rather than false lineage. A measured 9 of 59
- * on the live tax surface is what "some of the time" meant in practice.
- *
- * A span inverts it. The model names two integers into text it just read; the
- * PLATFORM produces the quote from the bytes it already holds. There is no
- * retyping step to get wrong, so a fabricated quote is not rejected — it is
- * unrepresentable. `sourceContainsQuote(text, sliceSourceSpan(text, span))` is
- * true for every span this function returns, by construction.
- *
- * Offsets index the SAME string the product's document-reading tool pages
- * with an offset, which is the same string its `readSourceText` seam returns.
- * That is the one contract a product must keep; violate it and spans point at
- * the wrong characters (still real characters of that document — never
- * invented text, but the wrong line).
- *
- * Half-open `[start, end)`, matching `String.prototype.slice` and the
- * `offset`/`offset + text.length` window a paged read already reports.
- */
-type SourceSpanFailure = {
-    reason: 'not_integer';
-    field: 'start' | 'end';
-} | {
-    reason: 'negative';
-    field: 'start' | 'end';
-} | {
-    reason: 'inverted';
-} | {
-    reason: 'out_of_range';
-    totalChars: number;
-} | {
-    reason: 'blank';
-};
-type SourceSpanResult = {
-    ok: true;
-    quote: string;
-} | {
-    ok: false;
-    failure: SourceSpanFailure;
-};
-/**
- * Locate the line containing `value` and return it as a span — the citation
- * form for a model that cannot count characters.
- *
- * Measured on production (tax session 135b7cc3, gpt-4.1-mini): given the
- * document text and told exactly which line to cite, the model produced
- * offsets that landed on the WRONG line four times out of four, then missed
- * again on a second attempt after being shown the text its offsets had
- * selected. Character arithmetic is not something this model class does.
- *
- * What it DOES do reliably is read the value: all four `claim` fields in that
- * same run were correct to the cent. So the model names the value it read and
- * the PLATFORM finds it. Both failure modes close at once —
- *
- *  - the quote cannot be invented, because the platform slices it;
- *  - the span cannot be mis-addressed, because the platform computed it from
- *    a needle it PROVED occurs in the text.
- *
- * A needle that is not in the document is refused, which is the same fail-loud
- * posture as a quote that does not occur — and correctly so: the model is
- * asserting the document says something it does not.
- *
- * The cited span is the whole LINE, not the needle: "128,450.00" alone is not
- * a click target a reviewer can judge, whereas the line it sits on says what
- * the number IS. Number-only needles are common and deliberately supported.
- */
-type SourceFindFailure = {
-    reason: 'blank_needle';
-} | {
-    reason: 'not_found';
-} | {
-    reason: 'occurrence_out_of_range';
-    found: number;
-} | {
-    reason: 'not_distinctive';
-    needle: string;
-    found: number;
-};
-type SourceFindResult = {
-    ok: true;
-    span: {
-        start: number;
-        end: number;
-    };
-    quote: string;
-    occurrences: number;
-} | {
-    ok: false;
-    failure: SourceFindFailure;
-};
-declare function findSourceLine(sourceText: string, needle: string, occurrence?: number): SourceFindResult;
-/** Resolve `[start, end)` against `sourceText`. Every rejection is a caller
- *  mistake the model can correct from the paged read it already has, so each
- *  carries the discriminator a tool layer turns into a specific message. */
-declare function sliceSourceSpan(sourceText: string, span: {
-    start: number;
-    end: number;
-}): SourceSpanResult;
-
-/**
- * Framework-neutral work-product review endpoints — the
- * `createInteractionAnswerRoute` factory pattern: web-standard
- * `Request`/`Response`, ONE product-supplied `authorize` seam (session auth,
- * workspace access, reviewer identity, rate limits), everything behind it
- * mechanism. Server-only and subpath-only: never reachable from a client
- * bundle (enforced by the browser-safety test).
- *
- * The verdict endpoint is deliberately NOT a second approval broker: agent
- * asks stay on `/interactions`; this is the REVIEWER's plain authorized
- * verdict on a ready package — one human-in-the-loop channel per direction.
- * A `request_changes` note re-enters chat as the correction turn via the
- * `onVerdict` seam; chat remains the driver surface.
- */
-
-/** Reviewer verdict wire body for the POST endpoint. */
-type WorkProductVerdictBody = {
-    ok: true;
-    id: string;
-    verdict: 'approve';
-    note?: string;
-} | {
-    ok: true;
-    id: string;
-    verdict: 'request_changes';
-    note: string;
-} | {
-    ok: false;
-    error: string;
-};
-/** Validate the verdict POST body: `{ id, verdict, note? }`; a
- *  `request_changes` verdict REQUIRES a non-empty note — the note IS the
- *  correction turn the agent works from. */
-declare function validateWorkProductVerdictBody(body: Record<string, unknown>): WorkProductVerdictBody;
-/** The product seam's verdict for one request: authenticated reviewer +
- *  workspace, or a product-authored short-circuit Response (401/403/429…). */
-type WorkProductRouteAuthorization = {
-    ok: true;
-    workspaceId: string;
-    reviewedBy: string;
-} | {
-    ok: false;
-    response: Response;
-};
-/** Auth seam arguments carrying the request, the endpoint intent, and the parsed verdict body */
-interface WorkProductAuthorizeArgs {
-    request: Request;
-    intent: 'list' | 'detail' | 'verdict';
-    /** The parsed, validated POST body (verdict intent only). */
-    body?: Record<string, unknown>;
-}
-/** Configuration options assembling the review endpoints from the store and product seams */
-interface WorkProductRoutesOptions {
-    store: WorkProductStorePort;
-    /** Authenticate + authorize the caller; the ONLY product access step. */
-    authorize: (args: WorkProductAuthorizeArgs) => Promise<WorkProductRouteAuthorization>;
-    /** Post-verdict product seam: post the `request_changes` note into the
-     *  driving chat thread as the correction turn, notify, etc. Runs after the
-     *  transition commits; a throw is logged, never unwinds the verdict. */
-    onVerdict?: (args: {
-        record: WorkProductRecord;
-        verdict: 'approve' | 'request_changes';
-        note?: string;
-        reviewedBy: string;
-    }) => void | Promise<void>;
-    /** Persist/update the transcript anchor part reflecting the new status, so
-     *  the chat card flips with the verdict. */
-    persistAnchorPart?: (part: WorkProductPersistedPart, record: WorkProductRecord) => void | Promise<void>;
-    /** Future integration point fired on approval (push to a DMS/CRM/export
-     *  pipeline). A stub seam by design — export itself stays the product's
-     *  signed object-store download. */
-    onExport?: (record: WorkProductRecord) => void | Promise<void>;
-    logger?: Pick<Console, 'warn' | 'error'>;
-    now?: () => number;
-}
-/** Assembled review endpoints returning web-standard Responses */
-interface WorkProductRoutes {
-    /** GET — the workspace's records for the queue projection. Optional
-     *  `?status=a,b` filter. */
-    list: (request: Request) => Promise<Response>;
-    /** GET — one record by id (404 when absent or outside the workspace). */
-    detail: (request: Request, id: string) => Promise<Response>;
-    /** POST `{ id, verdict, note? }` — the reviewer verdict: CAS transition +
-     *  history entry + product seams. 409 when the record is no longer ready. */
-    verdict: (request: Request) => Promise<Response>;
-}
-/** Create the work-product review endpoints over the store port and product seams */
-declare function createWorkProductRoutes(options: WorkProductRoutesOptions): WorkProductRoutes;
-
-export { ARTIFACT_AGREEMENT_CHECK, type ArtifactAgreement, CLAIM_SUPPORT_CHECK, type ClaimSupport, type ConfusableTargetGroup, type CreateWorkProductInput, EVIDENCE_COVERAGE_CHECK, EvidenceEntry, ExceptionEntry, type FinalizeWorkProductProvenanceInput, type InMemoryWorkProductStore, MAX_WORK_PRODUCT_BATCH, QUOTE_VERIFICATION_CHECK, QualityCheck, type SourceFindFailure, type SourceFindResult, type SourceSpanFailure, type SourceSpanResult, type SubmitWorkProductInput, TARGET_CORRECTNESS_CHECK, type TargetLabelVerdict, TrustItem, WorkProductArtifact, WorkProductAuditEvent, type WorkProductAuthorizeArgs, type WorkProductOutcome, WorkProductPersistedPart, WorkProductProvenance, type WorkProductProvenanceBase, WorkProductRecord, type WorkProductRouteAuthorization, type WorkProductRoutes, type WorkProductRoutesOptions, type WorkProductService, type WorkProductServiceOptions, WorkProductStatus, WorkProductStorePort, type WorkProductToolConfig, type WorkProductVerdictBody, type WorkProductVerdictInput, artifactAgreementErrorDetail, buildWorkProductTools, canTransitionWorkProduct, canonicalizeValue, claimSupportErrorDetail, claimValues, createInMemoryWorkProductStore, createWorkProductRoutes, createWorkProductService, finalizeWorkProductProvenance, findSourceLine, indexArtifactValues, isWorkProductTerminal, normalizeQuoteText, sliceSourceSpan, sourceContainsQuote, stampProvenance, targetLabelErrorDetail, validateWorkProductVerdictBody, valuesInText, verifyArtifactAgreement, verifyClaimSupport, verifyTargetLabel, workProductTrustInputs };
+ * `./work-product` — the reviewable work-product vertical: artifact +
+ * evidence map (source→field lineage) + exceptions + quality checks +
+ * version history + run provenance, produced by an agent through the
+ * schema-validated tool side channel and signed off by a professional
+ * through the verdict route. The review queue is a pure projection over
+ * this row plus existing sources (`/chat-store` threads, `/interactions`
+ * asks); chat stays the driver surface.
+ */
+export * from './types';
+export * from './service';
+export * from './tools';
+export * from './quote';
+export * from './claim-support';
+export * from './queue';
+export * from './route';
+export * from './provenance';