@tangle-network/agent-app 0.43.67 → 0.43.68

package/dist/queue-C24V13h9.d.ts

@@ -0,0 +1,68 @@
+import { i as WorkProductRecord, j as WorkProductRef, h as WorkProductProvenance } from './types-CEchbvgz.js';
+
+/**
+ * The review queue is a PROJECTION, not a store — a client-safe pure fold of
+ * existing sources into queue items (the `/missions` events.ts pattern: pure
+ * data, re-validation at JSON boundaries). The only genuinely-new durable
+ * state behind it is the {@link WorkProductRecord} row and its status
+ * machine; everything else reads what already exists:
+ *
+ *  - intake: a chat thread for the engagement scope with NO record yet
+ *  - missing_info: the open record's thread has a PENDING `/interactions` ask
+ *  - working: record status `draft` (the live token tail stays on the chat
+ *    surface's existing running-turns endpoint — the projection tracks no
+ *    live runs, per the reuse-the-primitive invariant)
+ *  - ready_for_review / changes_requested / approved / blocked: read directly
+ *    off `WorkProductRecord.status` (blocked surfaces its unresolved count)
+ */
+
+type ReviewQueueState = 'intake' | 'missing_info' | 'working' | 'ready_for_review' | 'changes_requested' | 'approved' | 'blocked';
+/** One row of the review queue projection for an engagement scope */
+interface ReviewQueueItem {
+    scopeKey: string;
+    state: ReviewQueueState;
+    threadId: string | null;
+    workProduct?: WorkProductRef & {
+        title: string;
+        kind: string;
+    };
+    /** The pending `/interactions` ask parking this scope, when any. */
+    pendingAsk?: {
+        interactionId: string;
+        title: string;
+    };
+    blockingExceptions: number;
+    failedChecks: number;
+    provenance?: Pick<WorkProductProvenance, 'profileHash' | 'servingModels'>;
+    updatedAt: number;
+}
+/** An engagement-scoped chat thread — the intake candidate source. Products
+ *  that scope threads already carry a scopeKey-style column. */
+interface ReviewQueueThread {
+    scopeKey: string;
+    threadId: string;
+    updatedAt: number;
+}
+/** A pending `/interactions` ask on a thread (from the existing list
+ *  endpoint) — the missing_info source. */
+interface ReviewQueuePendingAsk {
+    threadId: string;
+    interactionId: string;
+    title: string;
+}
+/** Existing-source inputs the projection folds — no new stores */
+interface ReviewQueueInputs {
+    workProducts: readonly WorkProductRecord[];
+    /** Engagement threads with no work product yet → intake items. */
+    threads?: readonly ReviewQueueThread[];
+    /** Pending asks by thread → missing_info override on open records. */
+    pendingAsks?: readonly ReviewQueuePendingAsk[];
+}
+/** Fold the existing sources into queue items, newest first. */
+declare function projectReviewQueue(inputs: ReviewQueueInputs): ReviewQueueItem[];
+/** Re-validate one JSON-boundary row into a queue item; null for junk. The
+ *  client-side twin of the server projection, for payloads that cross a
+ *  fetch boundary. */
+declare function parseReviewQueueItem(raw: unknown): ReviewQueueItem | null;
+
+export { type ReviewQueueInputs as R, type ReviewQueueItem as a, type ReviewQueuePendingAsk as b, type ReviewQueueState as c, type ReviewQueueThread as d, projectReviewQueue as e, parseReviewQueueItem as p };

package/dist/runtime/index.js

@@ -8,7 +8,7 @@ import {
   runToolLoop,
   streamToolLoop,
   toLoopEvents
-} from "../chunk-JWBZ74TW.js";
+} from "../chunk-7ESQUSAC.js";
 import {
   DEFAULT_TANGLE_BILLING_ENFORCEMENT_ENV_VAR,
   DEFAULT_TANGLE_ROUTER_BASE_URL,
@@ -24,7 +24,8 @@ import {
   tangleExecutionKeyHttpError,
   trimOrNull
 } from "../chunk-JML7WKWU.js";
-import "../chunk-7CTIUCQ4.js";
+import "../chunk-UOAYS72M.js";
+import "../chunk-YEFFHORB.js";
 import {
   __resetCatalogCache,
   buildCatalog,

package/dist/sandbox/index.js

@@ -60,11 +60,12 @@ import {
   writeProfileFilesToBox
 } from "../chunk-3ALFBTIW.js";
 import "../chunk-CQZSAR77.js";
-import "../chunk-YKBDH2UY.js";
+import "../chunk-WL7XHLDK.js";
 import "../chunk-3EJ6SFJI.js";
 import "../chunk-S5SRJJQG.js";
 import "../chunk-JML7WKWU.js";
-import "../chunk-7CTIUCQ4.js";
+import "../chunk-UOAYS72M.js";
+import "../chunk-YEFFHORB.js";
 export {
   DEFAULT_SANDBOX_RESOURCES,
   ENV_TOTAL_MAX_BYTES,

package/dist/teams/index.js

@@ -1,3 +1,8 @@
+import {
+  generateInviteToken,
+  isInviteTokenShape,
+  validateInviteToken
+} from "../chunk-DJ4VJIH5.js";
 import {
   INVITATION_EXPIRY_DAYS,
   generateInvitationToken,
@@ -7,11 +12,6 @@ import {
   parseInvitationPermission,
   renderInvitationEmail
 } from "../chunk-2DRYTJHI.js";
-import {
-  generateInviteToken,
-  isInviteTokenShape,
-  validateInviteToken
-} from "../chunk-DJ4VJIH5.js";
 import {
   ASSIGNABLE_WORKSPACE_ROLES,
   ORGANIZATION_ROLES,

package/dist/teams/invitations-api.js

@@ -1,3 +1,7 @@
+import {
+  SeatLimitError
+} from "../chunk-MEUNTJL5.js";
+import "../chunk-DJ4VJIH5.js";
 import {
   generateInvitationToken,
   getInvitationExpiresAt,
@@ -5,10 +9,6 @@ import {
   normalizeInvitationEmail,
   parseInvitationPermission
 } from "../chunk-2DRYTJHI.js";
-import {
-  SeatLimitError
-} from "../chunk-MEUNTJL5.js";
-import "../chunk-DJ4VJIH5.js";
 import {
   hasWorkspaceRole
 } from "../chunk-6XIAPIW6.js";

package/dist/teams-react/index.js

@@ -1,12 +1,12 @@
+import {
+  InviteAcceptPage
+} from "../chunk-VCPZ3HTN.js";
 import {
   MembersPanel
 } from "../chunk-S564OFTL.js";
 import {
   InvitationsPanel
 } from "../chunk-5SXS3YAB.js";
-import {
-  InviteAcceptPage
-} from "../chunk-VCPZ3HTN.js";
 import "../chunk-6XIAPIW6.js";
 export {
   InvitationsPanel,

package/dist/tools/index.js

@@ -6,7 +6,7 @@ import {
   restrictTaxonomy,
   verifyCapabilityToken,
   verifyExpiringCapabilityToken
-} from "../chunk-YKBDH2UY.js";
+} from "../chunk-WL7XHLDK.js";
 import {
   DEFAULT_APP_TOOL_PATHS,
   DEFAULT_HEADER_NAMES,
@@ -19,18 +19,20 @@ import {
   readToolArgs
 } from "../chunk-3EJ6SFJI.js";
 import "../chunk-S5SRJJQG.js";
+import {
+  createAppToolRuntimeExecutor,
+  dispatchAppTool,
+  outcomeStatus
+} from "../chunk-UOAYS72M.js";
 import {
   APP_TOOL_NAMES,
   ToolInputError,
   buildAppToolOpenAITools,
-  createAppToolRuntimeExecutor,
   customToolToOpenAI,
   defineAppTool,
-  dispatchAppTool,
   findCustomTool,
-  isAppToolName,
-  outcomeStatus
-} from "../chunk-7CTIUCQ4.js";
+  isAppToolName
+} from "../chunk-YEFFHORB.js";
 export {
   APP_TOOL_NAMES,
   DEFAULT_APP_TOOL_PATHS,

package/dist/trust-gate-Dcm5xSva.d.ts

@@ -0,0 +1,83 @@
+import { JudgeVerdict } from '@tangle-network/agent-eval';
+
+/**
+ * Trust gate — decides whether an ensemble's scores are allowed to be BELIEVED,
+ * one level up from {@link aggregateJudgeVerdicts} (which only reduces ONE
+ * artifact's raters to a composite). A composite is a number; this is the check
+ * that the number means anything. It is the code "Enforced by" for the
+ * measurement-validation skill's after-gate ("is this result allowed to be
+ * believed").
+ *
+ * Three checks, each fail-loud and named in `trustReasons`:
+ *   (1) inter-rater reliability over the corpus ≥ `irrFloor` — raters that
+ *       disagree no better than chance carry no signal to optimize against.
+ *   (2) per-item rater spread ≤ `spreadCeiling` — for EACH item, raters must
+ *       converge on THAT item.
+ *   (3) surviving raters per item ≥ `minSurvivors` — a mean over one or two
+ *       raters is an anecdote, not an ensemble.
+ *
+ * CRITICAL metric semantics — per-item spread is rater disagreement about the
+ * SAME item: `max(score) − min(score)` across the raters that scored THAT item
+ * (max over its dimensions), never pooled across different items or across the
+ * baseline/candidate sides. Pooling reads a genuine quality gap BETWEEN items as
+ * "the raters split" and so trips the gate exactly when the finding is largest —
+ * the failure mode the after-gate exists to prevent. The corpus IRR (check 1)
+ * leans on the substrate's `interRaterReliability`, whose expected-disagreement
+ * denominator already pools across items, so genuine item-to-item variation
+ * RAISES reliability rather than lowering it.
+ */
+
+/** One item's raters: the per-judge verdicts {@link aggregateJudgeVerdicts}
+ *  reduces, tagged with the item they scored so spread stays within-item. */
+interface TrustItem<D extends string = string> {
+    /** Stable item identifier — surfaces in `perItemSpread` and `trustReasons`. */
+    itemId: string;
+    /** The raters' verdicts for THIS item (one per judge call). A failed judge
+     *  (`perDimension: null`) is dropped before spread/IRR, never folded as 0. */
+    verdicts: readonly JudgeVerdict<D>[];
+}
+/** Thresholds for {@link trustVerdicts}. All overridable; defaults are the
+ *  conservative after-gate bar. */
+interface TrustThresholds {
+    /** Minimum corpus inter-rater reliability (Krippendorff-style α). Below this
+     *  the raters agree no better than chance. Default 0.2. */
+    irrFloor?: number;
+    /** Maximum per-item rater spread (`max − min` over a single item's surviving
+     *  raters, across its dimensions). Above this the raters split ON THAT ITEM.
+     *  Default 0.5. */
+    spreadCeiling?: number;
+    /** Minimum surviving (non-failed) raters required per item. Default 3. */
+    minSurvivors?: number;
+}
+/** Result of the trust gate. `trustworthy` iff every check passed; `trustReasons`
+ *  is empty iff `trustworthy`. */
+interface TrustVerdict {
+    /** True iff IRR ≥ floor AND every item's spread ≤ ceiling AND every item has
+     *  ≥ `minSurvivors` surviving raters. */
+    trustworthy: boolean;
+    /** One entry per FAILED check, each naming its number + the offending value.
+     *  Empty iff `trustworthy`. */
+    trustReasons: string[];
+    /** Corpus inter-rater reliability actually measured (the check-1 value). */
+    interRaterReliability: number;
+    /** Per-item spread (`max − min` over surviving raters, max over dimensions),
+     *  keyed by `itemId`. The check-2 input, surfaced for drill-down. */
+    perItemSpread: Record<string, number>;
+}
+/**
+ * Decide whether an ensemble's per-item verdicts are trustworthy enough to
+ * believe a lift computed from them. Pure: no LLM, no I/O, no clock, no random —
+ * the same `items` + `thresholds` always yield the same verdict.
+ *
+ * Sibling to {@link aggregateJudgeVerdicts}: that reduces ONE item's raters to a
+ * composite; this audits the raters ACROSS items and reports whether the
+ * composites are believable. Run it on the corpus of held-out items before
+ * reporting any lift over their scores.
+ *
+ * @throws if `items` is empty — an empty corpus has no measurable trust, and a
+ *   silent `trustworthy: true` over zero evidence is the exact lie the gate
+ *   exists to refuse.
+ */
+declare function trustVerdicts<D extends string>(items: readonly TrustItem<D>[], thresholds?: TrustThresholds): TrustVerdict;
+
+export { type TrustItem as T, type TrustThresholds as a, type TrustVerdict as b, trustVerdicts as t };

package/dist/types-CEchbvgz.d.ts

@@ -0,0 +1,268 @@
+/**
+ * The reviewable work-product contract — the one durable object every Tangle
+ * agent product converges on: an artifact plus its evidence map (source→field
+ * lineage), exceptions, quality checks, version history, and run provenance,
+ * produced by an agent and signed off by a professional.
+ *
+ * Import-free and client-safe by construction: the queue projection and the
+ * React surfaces re-validate these shapes at JSON boundaries, so every type
+ * and codec here must load in a browser bundle. Every domain word — artifact
+ * `kind`, evidence `target`, exception `kind`, check `name`, `scopeKey`
+ * format — is a STRING PARAMETER validated against product-supplied
+ * vocabularies in the tool layer; nothing domain-specific is baked here.
+ */
+/** Stable pointer at one version of one work product. */
+interface WorkProductRef {
+    id: string;
+    version: number;
+}
+type WorkProductStatus = 'draft' | 'blocked' | 'ready' | 'changes_requested' | 'approved' | 'superseded';
+/** Runtime guard for re-validating a status read off a JSON boundary. */
+declare function isWorkProductStatus(value: unknown): value is WorkProductStatus;
+/** Define the reviewable artifact body with its kind, sources, and structured field map */
+interface WorkProductArtifact {
+    /** PARAMETER: 'return_package' | 'redline' | 'outreach_campaign' — validated
+     *  against the product's `artifactKinds` vocabulary at submit. */
+    kind: string;
+    title: string;
+    /** Vault/object-store ref for the rendered document (large bodies). */
+    path?: string;
+    /** Inline body when small (markdown/JSON). */
+    content?: string;
+    mediaType?: string;
+    /** Diff-first products (legal): the source document the artifact redlines. */
+    baseline?: {
+        path?: string;
+        content?: string;
+    };
+    /** The structured field map lineage targets anchor to (tax: form-line ids). */
+    fields?: Record<string, unknown>;
+}
+/** Point into a source document: page, free-form range, verbatim quote */
+interface EvidenceLocator {
+    page?: number;
+    /** 'L120-L134' | 'B7' | '¶4' — free-form, non-empty when present. */
+    range?: string;
+    /** Verbatim supporting quote from the source. */
+    quote?: string;
+}
+/** One lineage row: a source document location supporting one artifact claim */
+interface EvidenceEntry {
+    /** Agent-supplied stable id — the same id re-emitted is an upsert/replace. */
+    id: string;
+    /** Vault path / attachment id / object-store key of the SOURCE document. */
+    sourceRef: string;
+    locator: EvidenceLocator;
+    /** Artifact field/claim the evidence supports: '1040.line_9' |
+     *  'clause:indemnification' | 'icp.employee_count' — product vocabulary. */
+    target: string;
+    /** The value/assertion at the target. */
+    claim: string;
+    /** 0..1; absent = unstated (never defaulted). */
+    confidence?: number;
+}
+type ExceptionSeverity = 'blocking' | 'material' | 'advisory';
+/** One flagged problem with the work product, resolvable by agent or reviewer */
+interface ExceptionEntry {
+    id: string;
+    severity: ExceptionSeverity;
+    /** PARAMETER: 'missing_document' | 'inconsistent_source' | … — validated
+     *  against the product's `exceptionKinds` vocabulary. */
+    kind: string;
+    message: string;
+    /** Affected artifact targets. */
+    targets?: string[];
+    resolved: boolean;
+    resolvedBy?: 'agent' | 'reviewer';
+    resolutionNote?: string;
+}
+/** Unresolved blocking exceptions are what park a work product in `blocked`. */
+declare function unresolvedBlockingExceptions(exceptions: readonly ExceptionEntry[]): ExceptionEntry[];
+/** One named quality verdict on the work product, tagged with who computed it */
+interface QualityCheck {
+    id: string;
+    /** Product vocabulary: 'totals_reconcile', 'evidence_coverage', … */
+    name: string;
+    passed: boolean;
+    detail?: string;
+    /** agent self-report | shell-computed | eval-ensemble verdict. */
+    source: 'agent' | 'platform' | 'judge';
+}
+/** The audit triple binding a work product to the exact configuration and run
+ *  that produced it. `profileHash` is agent-eval's `agentProfileHash()` of the
+ *  EXACT shipped profile — the same hash that keys scorecard cells, so a
+ *  reviewer can see the measured backtest history of the configuration that
+ *  produced the document. */
+interface WorkProductProvenance {
+    profileHash: string;
+    /** Chat turnId or mission-step run id. */
+    runId: string;
+    /** Back-filled from the usage receipt / serving-model header at turn
+     *  completion — only the completed turn knows what actually served. */
+    servingModels: string[];
+    sessionId?: string;
+    missionRef?: {
+        missionId: string;
+        stepId: string;
+    };
+    costUsd?: number;
+    producedAt: number;
+}
+/** The product-resolved backtest summary for one profile hash (from its own
+ *  eval artifacts via agent-eval's `loadScorecard`) — the shell defines only
+ *  this TYPE and the `ProvenanceStamp` slot that renders it. */
+interface ProfileBacktestSummary {
+    profileHash: string;
+    /** Backtest cases behind the composite. */
+    cases: number;
+    composite: number;
+    /** The eval-campaign trust gate's verdict on whether the composite is
+     *  allowed to be believed; 'fail' renders as "quality: unverified". */
+    trust: 'pass' | 'fail';
+    trustReasons: string[];
+}
+/** Frozen milestone row for one version of the work product */
+interface WorkProductVersionEntry {
+    version: number;
+    status: WorkProductStatus;
+    provenance: WorkProductProvenance;
+    /** Frozen snapshot ref of this version's body (object-store key) — the
+     *  DiffView input for vN-1 vs vN. */
+    artifactPath?: string;
+    reviewedBy?: string;
+    reviewNote?: string;
+    at: number;
+}
+/** Define the durable work product row accumulating artifact, lineage, exceptions, checks, and history */
+interface WorkProductRecord {
+    /** Minted server-side; the model NEVER supplies ids — it addresses work by
+     *  `scopeKey`. */
+    id: string;
+    workspaceId: string;
+    /** The chat thread that drives it (chat stays first). */
+    threadId: string | null;
+    /** Product engagement key: 'return:acme:2025' | 'contract:acme-msa' |
+     *  'campaign:cpa-pilots'. */
+    scopeKey: string;
+    status: WorkProductStatus;
+    version: number;
+    /** `null` while the draft accumulates (evidence streams in before the
+     *  artifact arrives); non-null from the submit transition onward. Typed
+     *  honestly rather than forcing a placeholder artifact on every draft. */
+    artifact: WorkProductArtifact | null;
+    evidence: EvidenceEntry[];
+    exceptions: ExceptionEntry[];
+    checks: QualityCheck[];
+    provenance: WorkProductProvenance;
+    history: WorkProductVersionEntry[];
+    createdAt: number;
+    updatedAt: number;
+}
+/** Fields a guarded write compares against the values the caller read. An
+ *  absent field is unguarded. A SQL implementation compares like-for-like
+ *  scalar columns; the in-memory store does the same. */
+interface WorkProductUpdateGuard {
+    status?: WorkProductStatus;
+    version?: number;
+}
+/** Fields a guarded write sets when the guard holds. */
+interface WorkProductPatch {
+    status?: WorkProductStatus;
+    version?: number;
+    artifact?: WorkProductArtifact;
+    evidence?: EvidenceEntry[];
+    exceptions?: ExceptionEntry[];
+    checks?: QualityCheck[];
+    provenance?: WorkProductProvenance;
+    history?: WorkProductVersionEntry[];
+    updatedAt?: number;
+}
+/** One audit-trail row, appended after every committed state change. */
+interface WorkProductAuditEvent {
+    workProductId: string;
+    workspaceId: string;
+    /** Machine-readable transition name ('wp.created' | 'wp.evidence' |
+     *  'wp.ready' | 'wp.verdict' | …). */
+    step: string;
+    message: string;
+    metadata: Record<string, unknown>;
+    at: number;
+}
+/**
+ * Persistence seam — the product implements this over its own tables. The
+ * invariant the implementation MUST keep: `update` applies `patch` ONLY when
+ * every guard field still equals the stored value, and returns `null` when
+ * the guard misses — a typed conflict, never a clobber.
+ */
+interface WorkProductStorePort {
+    load(id: string): Promise<WorkProductRecord | null>;
+    /** The scope's single OPEN accumulator row — status `draft` or `blocked` —
+     *  or null when the scope has only reviewed/terminal rows (or none). The
+     *  `changes_requested` row is found via {@link listByWorkspace}; reopening
+     *  it is the service's job. */
+    findDraft(workspaceId: string, scopeKey: string): Promise<WorkProductRecord | null>;
+    listByWorkspace(workspaceId: string, opts?: {
+        status?: WorkProductStatus[];
+    }): Promise<WorkProductRecord[]>;
+    /** `extras` are opaque product-column values written in the SAME statement
+     *  as the record (single-write creation), or ignored when the table has no
+     *  extra columns. */
+    insert(record: WorkProductRecord, extras?: Record<string, unknown>): Promise<WorkProductRecord>;
+    /** CAS: apply `patch` ONLY when guard fields equal stored values; null on a
+     *  miss — typed conflict, never a clobber. */
+    update(id: string, guard: WorkProductUpdateGuard, patch: WorkProductPatch): Promise<WorkProductRecord | null>;
+    appendEvent(event: WorkProductAuditEvent): Promise<void>;
+}
+/** Validation result whose failure names the exact field, so a tool layer can
+ *  hand the model a correctable error it can act on. */
+type WorkProductParseResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    field: string;
+    error: string;
+};
+/** Validate one raw evidence entry field-by-field. `path` prefixes the failure
+ *  field name (e.g. `entries[3]`) so batched calls name the exact offender. */
+declare function parseEvidenceInput(raw: unknown, path?: string): WorkProductParseResult<EvidenceEntry>;
+/** Validate one raw exception entry field-by-field. Kind MEMBERSHIP in the
+ *  product vocabulary is the tool layer's check (it owns the config). */
+declare function parseExceptionInput(raw: unknown, path?: string): WorkProductParseResult<ExceptionEntry>;
+/** Validate a raw artifact. Kind MEMBERSHIP in `artifactKinds` is the tool
+ *  layer's check. An artifact must carry a body: at least one of `path`,
+ *  `content`, or `fields`. */
+declare function parseArtifactInput(raw: unknown, path?: string): WorkProductParseResult<WorkProductArtifact>;
+/** Agent self-reported check input for `submit_work_product` (persisted with
+ *  `source: 'agent'`; `platform`/`judge` sources are never model-suppliable). */
+interface AgentCheckInput {
+    id: string;
+    name: string;
+    passed: boolean;
+    detail?: string;
+}
+/** Validate one agent self-check ensuring identifiers, verdict flag, and optional detail are well formed */
+declare function parseAgentCheckInput(raw: unknown, path?: string): WorkProductParseResult<AgentCheckInput>;
+/**
+ * The persisted `type:'work_product'` transcript anchor — the chat card that
+ * keeps chat the driver surface for review. The PLATFORM writes it on the
+ * ready transition (and updates it on a verdict); no prompt ever teaches an
+ * agent to author one. `/chat-store` aliases this as `ChatWorkProductPart` in
+ * its stored-part union, exactly like the `interaction`/`plan` members.
+ */
+interface WorkProductPersistedPart {
+    type: 'work_product';
+    ref: WorkProductRef;
+    kind: string;
+    title: string;
+    status: WorkProductStatus;
+}
+/** Project the transcript anchor part from a record. Requires the submitted
+ *  artifact (the anchor is written on the ready transition, after which
+ *  `artifact` is always non-null); falls back to the scopeKey label for
+ *  defensive callers on an accumulating draft. */
+declare function workProductToPersistedPart(record: WorkProductRecord): WorkProductPersistedPart;
+/** Re-validate a stored/wire part into the typed anchor; null for junk. */
+declare function persistedPartToWorkProduct(part: Record<string, unknown>): WorkProductPersistedPart | null;
+
+export { type AgentCheckInput as A, type EvidenceEntry as E, type ProfileBacktestSummary as P, type QualityCheck as Q, type WorkProductArtifact as W, type EvidenceLocator as a, type ExceptionEntry as b, type ExceptionSeverity as c, type WorkProductAuditEvent as d, type WorkProductParseResult as e, type WorkProductPatch as f, type WorkProductPersistedPart as g, type WorkProductProvenance as h, type WorkProductRecord as i, type WorkProductRef as j, type WorkProductStatus as k, type WorkProductStorePort as l, type WorkProductUpdateGuard as m, type WorkProductVersionEntry as n, isWorkProductStatus as o, parseAgentCheckInput as p, parseArtifactInput as q, parseEvidenceInput as r, parseExceptionInput as s, persistedPartToWorkProduct as t, unresolvedBlockingExceptions as u, workProductToPersistedPart as w };