@aventurevc/api-schemas 0.8.174 → 0.8.176

package/dist/harness/run.js

@@ -8,14 +8,14 @@ import { HarnessRunLaneSchema } from "./run-lane.js";
 import { HarnessRunStatusSchema } from "./run-status.js";
 import { HarnessRunTypeSchema } from "./run-type.js";
 /**
- * One harness enrichment run
+ * One research run on a company, Product, Service, or person
  *
  * @openapiSchema HarnessRun
- * @endpoint GET /v1/harness/runs/{runId}
+ * @endpoint GET /v1/research-runs/{runId}
  * @endpoint POST /v1/enrichments
  * @endpoint POST /v1/entities/{entityId}/enrichments
- * @endpoint POST /v1/harness/runs
  * @endpoint POST /v1/people/{personId}/enrichments
+ * @endpoint POST /v1/research-runs
  * @usedBySchema EnrichmentSchema
  * @usedBySchema HarnessRunDetailSchema
  * @contractShape harness.run
@@ -30,11 +30,11 @@ export const HarnessRunSchema = z.object({
     chassisRouted: z.boolean(),
     /** Creation timestamp */
     createdAt: z.iso.datetime({ offset: true }),
-    /** Canonical slug of the entity the run produced */
+    /** Slug of the profile the run produced */
     entitySlug: z.string().nullish(),
     /** API environment */
     environment: HarnessRunEnvironmentSchema,
-    /** Terminal failure reason, when failed */
+    /** Why the run failed; null unless failed */
     error: z.string().nullish(),
     /** Typed terminal-failure class from the harness retry classifier (e.g. runtime_cap, escalated, provider_capacity, context_overflow); null unless failed */
     failureClass: z.string().nullish(),
@@ -58,7 +58,7 @@ export const HarnessRunSchema = z.object({
     maxScoutConcurrent: z.int(),
     /** Enrichment breadth selected for this run */
     mode: EnrichmentModeSchema,
-    /** Orchestrator model id */
+    /** Model the run uses */
     model: z.string(),
     /** Earliest re-claim time when waiting on retry backoff */
     nextAttemptAt: z.iso.datetime({ offset: true }).nullish(),
@@ -70,15 +70,15 @@ export const HarnessRunSchema = z.object({
     status: HarnessRunStatusSchema,
     /** Read-only research, cohort, and completion sub-agent model id */
     subagentModel: z.string(),
-    /** Selected task preset keys filed with the run */
+    /** Research presets filed with the run */
     taskPresetKey: z.array(z.string()).nullish(),
-    /** Run kind derived from task-key presence: ENRICHMENT for a client-submitted comprehensive or preset-scoped run, TASK for a platform-scheduled micro-task execution */
+    /** Run kind: ENRICHMENT for a research request a caller filed, TASK for a narrower run aVenture scheduled */
     type: HarnessRunTypeSchema,
     /** Last update timestamp */
     updatedAt: z.iso.datetime({ offset: true }),
-    /** Company URL under enrichment */
+    /** URL of the company, Product, Service, or person under research */
     url: z.string(),
-    /** Optional steering prompt filed with the run */
+    /** Optional instructions filed with the run */
     userPrompt: z.string().nullish(),
 });
 //# sourceMappingURL=run.js.map

package/dist/help/resolution.js

@@ -20,7 +20,7 @@ export const HelpResolutionSchema = z.object({
     operationId: z.string().nullish(),
     /** Which of the mutually exclusive resolve outcomes was reached. */
     outcome: HelpResolutionOutcomeSchema,
-    /** Probability the decision model gave its chosen option (an operation, a task, several, or none). A task or operation chosen with low probability escalates to CLARIFY, leading the candidates or naming the task. */
+    /** Confidence, 0 to 1, in the chosen option (an operation, a catalog task, several, or none). A low-confidence choice becomes CLARIFY, listing the candidates. */
     probability: z.number().nullish(),
     /** The chosen catalog task for TASK_PLAN, or the task leading a CLARIFY. */
     taskKey: z.string().nullish(),

package/dist/http/problem-detail.d.ts

@@ -98,6 +98,7 @@ declare const ProblemDetailSchemaDefinition: z.ZodObject<{
     }, z.core.$strip>>>;
     detail: z.ZodOptional<z.ZodString>;
     details: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodType<{
+        conflictType?: string | undefined;
         existingJoin: {
             owner: {
                 entityId?: string | null | undefined;
@@ -115,6 +116,7 @@ declare const ProblemDetailSchemaDefinition: z.ZodObject<{
         url: string;
         urlType: string;
     }, import("../url/duplicate-conflict.ts").UrlDuplicateConflictSchemaInput, z.core.$ZodTypeInternals<{
+        conflictType?: string | undefined;
         existingJoin: {
             owner: {
                 entityId?: string | null | undefined;
@@ -134,6 +136,7 @@ declare const ProblemDetailSchemaDefinition: z.ZodObject<{
     }, import("../url/duplicate-conflict.ts").UrlDuplicateConflictSchemaInput>>, z.ZodType<{
         candidateEntityId: string[];
         candidatePersonId: string[];
+        conflictType?: string | undefined;
         hint: string;
         normalizedUrl?: string | null | undefined;
         url: string;
@@ -141,6 +144,7 @@ declare const ProblemDetailSchemaDefinition: z.ZodObject<{
     }, import("../strict/url-lookup-conflict.ts").StrictUrlLookupConflictSchemaInput, z.core.$ZodTypeInternals<{
         candidateEntityId: string[];
         candidatePersonId: string[];
+        conflictType?: string | undefined;
         hint: string;
         normalizedUrl?: string | null | undefined;
         url: string;
@@ -157,6 +161,7 @@ declare const ProblemDetailSchemaDefinition: z.ZodObject<{
             slug?: string | null | undefined;
             typeRecord?: "Business Line" | "Company" | "Fund" | "Government" | "Investment Firm" | "Nonprofit" | "Organization" | "Product" | "Service" | null | undefined;
         }[] | null | undefined;
+        conflictType?: string | undefined;
         newsCandidate?: {
             externalId?: string | null | undefined;
             id: number;
@@ -178,6 +183,7 @@ declare const ProblemDetailSchemaDefinition: z.ZodObject<{
             slug?: string | null | undefined;
             typeRecord?: "Business Line" | "Company" | "Fund" | "Government" | "Investment Firm" | "Nonprofit" | "Organization" | "Product" | "Service" | null | undefined;
         }[] | null | undefined;
+        conflictType?: string | undefined;
         newsCandidate?: {
             externalId?: string | null | undefined;
             id: number;
@@ -189,20 +195,24 @@ declare const ProblemDetailSchemaDefinition: z.ZodObject<{
         threshold: number;
     }, import("../duplicate/create-review.ts").DuplicateCreateReviewSchemaInput>>, z.ZodType<{
         availableOverrides: ("ATTACH_INACTIVE" | "REACTIVATE")[];
+        conflictType?: string | undefined;
         slug: string;
         tagId: number;
     }, import("../classification/inactive-tag-details.ts").ClassificationInactiveTagDetailsSchemaInput, z.core.$ZodTypeInternals<{
         availableOverrides: ("ATTACH_INACTIVE" | "REACTIVATE")[];
+        conflictType?: string | undefined;
         slug: string;
         tagId: number;
     }, import("../classification/inactive-tag-details.ts").ClassificationInactiveTagDetailsSchemaInput>>, z.ZodType<{
         conflictingArticleId: number;
         conflictingArticleSlug: string;
         conflictingArticleTitle: string;
+        conflictType?: string | undefined;
     }, import("../news/source-url-conflict.ts").NewsSourceUrlConflictSchemaInput, z.core.$ZodTypeInternals<{
         conflictingArticleId: number;
         conflictingArticleSlug: string;
         conflictingArticleTitle: string;
+        conflictType?: string | undefined;
     }, import("../news/source-url-conflict.ts").NewsSourceUrlConflictSchemaInput>>]>>>;
     error: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>;
     existingRecordId: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/http/problem-detail.js

@@ -12,7 +12,7 @@ const ProblemDetailSchemaDefinition = z.object({
         .enum(["COMPANY", "PERSON", "ENTITY_VIEW", "ENTITY_BRAND", "PERSON_VIEW", "WEB_SEARCH"])
         .nullish(),
     circuitBreaker: z.string().nullish(),
-    /** Machine-readable secondary code on ProblemDetail.code. Agents should branch on this value when the HTTP status alone does not identify the recovery path. Code groups include auth/session, rate limiting, job infrastructure, RBAC, external providers, image processing, R2 storage, search, and inference. Many codes indicate infra/admin-only conditions where the correct agent action is to surface the error and stop, not retry. */
+    /** Machine-readable secondary code on ProblemDetail.code. Agents should branch on this value when the HTTP status alone does not identify the recovery path. Code groups include auth/session, rate limiting, job infrastructure, RBAC, external providers, image processing, R2 storage, search, and inference. Many codes describe server-side conditions a caller cannot fix: surface the error and stop rather than retry. */
     code: z
         .union([
         z.enum([
@@ -162,7 +162,7 @@ const ProblemDetailSchemaDefinition = z.object({
         .nullish(),
     conflictingRecord: CurrentSlugOwnerSchema.nullish(),
     detail: z.string().optional(),
-    /** Structured conflict details. Create duplicate reviews and deterministic lookup ambiguity return DuplicateCreateReview; the returned candidates are the decision surface for update, create-with-override, or block. score/threshold rank review priority and are not proof that the requested record is absent. */
+    /** Structured conflict details. A possible duplicate or an ambiguous lookup returns its candidate records; score and threshold rank the candidates and do not prove that the requested record is absent. */
     details: DomainConflictDetailsSchema.nullish(),
     error: z.record(z.string(), z.string()).nullish(),
     /** On a duplicate 409, the id of the stored record the request collided with; read or update that record instead of creating it again. Absent when the conflict names no single stored record. */
@@ -170,7 +170,7 @@ const ProblemDetailSchemaDefinition = z.object({
     existingRedirect: RedirectSlugPathSchema.nullish(),
     feId: z.string().nullish(),
     field: z.string().nullish(),
-    /** Harness run ids a batch enrichment filed or reused for its other records before answering this refusal; absent for every other problem. */
+    /** Research request ids a batch filed or reused for its other records before returning this error; absent for every other error. */
     filedRunId: z.array(z.uuid()).nullish(),
     hammingDistance: z.number().int().nullish(),
     hint: z.string().nullish(),
@@ -180,20 +180,35 @@ const ProblemDetailSchemaDefinition = z.object({
     /** Which meter refused the request; names what limit/used/remaining count. */
     limitType: z
         .enum([
+        /** Too many form submissions from this client; retry after retryAfterSeconds. */
         "FORM",
+        /** The service-wide request rate is exhausted; retry after retryAfterSeconds. */
         "GLOBAL",
+        /** Too many requests from this client's network; retry after retryAfterSeconds. */
         "SUBNET",
+        /** Too many requests from this client's address; retry after retryAfterSeconds. */
         "IP",
+        /** A request-rate limit refused the request; retry after retryAfterSeconds. */
         "UNKNOWN",
+        /** The service is handling too many requests at once; retry after a short backoff. */
         "RESILIENCE4J",
+        /** Too many live web searches; retry after retryAfterSeconds. */
         "WEB_SEARCH",
+        /** Too many help questions; retry after retryAfterSeconds. */
         "AGENT_HELP",
+        /** Too many natural-language searches; retry after retryAfterSeconds. */
         "NATURAL_SEARCH",
+        /** The plan's monthly research allowance is used up. It refills at resetAt, often weeks away: stop rather than retry. */
         "BILLING_ALLOWANCE",
+        /** The additional-usage spend cap or prepaid credit is used up, counted in cents: stop rather than retry until the cap is raised or credit is added. */
         "BILLING_ADDITIONAL_USAGE",
+        /** Too many command-line sign-in requests; retry after retryAfterSeconds. */
         "CLERK_PUBLIC_ADMISSION",
+        /** Too many sign-in page load reports; retry after retryAfterSeconds. */
         "CLERK_SCRIPT_LOAD",
+        /** Not currently sent. If seen, retry after retryAfterSeconds. */
         "ORIGIN_DETAIL",
+        /** A model service this request depends on is at capacity; retry after retryAfterSeconds. */
         "INFERENCE_PROVIDER",
     ])
         .nullish(),

package/dist/identification/candidate.js

@@ -17,21 +17,21 @@ import { SearchDuplicateCandidateScoreSchema } from "../search/duplicate-candida
  * @contractRole canonical
  */
 export const IdentificationCandidateSchema = z.object({
-    /** When the record was created. A hidden record created moments before the lookup is a freshly filed shell, not established coverage. */
+    /** When the record was created. A record created moments before the lookup is newly added and not yet researched. */
     createdAt: z.iso.datetime({ offset: true }).nullish(),
-    /** Percentage, 0 to 100, of the entity's required completion-floor slots that pass, as last computed by the background coverage sweep; GET /v1/entities/{entityId}/coverage returns the live per-slot detail. Absent for people, who have no completion floor, and for entities not yet computed. */
+    /** Percentage, 0 to 100, of this company's core profile facts that aVenture holds, as last computed. It measures how complete the record is, not how likely it is the subject. Absent for people and for companies not yet computed. */
     dataCompletionCoverage: z.int().min(0).max(100).nullish(),
     /** Whether this record's stored website agrees with a url the subject supplied; see IdentificationDomainAgreement. */
     domainAgreement: z.enum(["MATCH", "CONFLICT", "UNKNOWN"]).nullish(),
     /** How this record was checked as the picked record stored again; absent when it was not checked. */
     duplicateBasis: z.enum(["STUB", "SHARED_FACT", "JUDGED"]).nullish(),
-    /** Decision-model probability, 0 to 1, that this record is the picked record stored again; present only when duplicateBasis is JUDGED. */
+    /** Probability, 0 to 1, that this record is the picked record stored again; present only when duplicateBasis is JUDGED. */
     duplicateProbability: z.number().nullish(),
     /** The year the entity was founded, when stored; absent for people and records without one. */
     foundedYear: z.int().nullish(),
     /** Entity identity (entityId) or person identity (personId). record.typeRecord distinguishes a company, product, or service; read it with GET /v1/entities/{entityId} or GET /v1/people/{personId}. */
     owner: EntityPersonOwnerSchema,
-    /** Decision-model probability, 0 to 1, that this record is the subject; absent when the answer came from URL proof or the model did not judge this record. */
+    /** Confidence, 0 to 1, that this record is the subject: the one confidence to act on. Absent when an exact id, URL, slug, or registry-id match settled the answer, which needs no confidence, or when this record was not compared. */
     probability: z.number().nullish(),
     /** The record with its duplicate-check score and reasons; score 0 with no reason means only vector similarity proposed it. */
     record: SearchDuplicateCandidateScoreSchema,

package/dist/identification/identification.d.ts

@@ -194,14 +194,12 @@ export declare const IdentificationSchema: z.ZodObject<{
         updatedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
         website: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>>>;
-    matchConfidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    matchEvidenceProbability: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     officialUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    stage: z.ZodEnum<{
+    stage: z.ZodOptional<z.ZodEnum<{
         DETERMINISTIC: "DETERMINISTIC";
         JUDGMENT: "JUDGMENT";
         WEB_EVIDENCE: "WEB_EVIDENCE";
-    }>;
+    }>>;
     status: z.ZodEnum<{
         MATCHED: "MATCHED";
         NEEDS_REVIEW: "NEEDS_REVIEW";

package/dist/identification/identification.js

@@ -19,26 +19,22 @@ import { IdentificationCandidateSchema } from "./candidate.js";
 export const IdentificationSchema = z.object({
     /** Records considered, most probable first. */
     candidate: z.array(IdentificationCandidateSchema),
-    /** With fileOnMiss=true, the hidden record this NO_MATCH filed (or already held its own site): it is now stored, so do not create it. Absent otherwise. */
+    /** With fileOnMiss=true, the new record this NO_MATCH created, or the existing one that already held its website. Absent otherwise. */
     created: IdentificationCandidateSchema.nullish(),
     /** One sentence naming what settled the answer or what the user must decide. */
     detail: z.string(),
-    /** Other stored records judged to be this same subject stored again: likely duplicate records to merge into match. Empty when none were found. */
+    /** Other records that appear to describe the same subject as match. Empty when none were found. */
     duplicate: z.array(IdentificationCandidateSchema),
-    /** The background run filed to research created; absent without created, and when the record is already public. */
+    /** Research request filed for the created record; absent without created, and when the record is already public. */
     enrichmentRunId: z.uuid().nullish(),
-    /** true when a language model, asked twice, settled a match the decision model left in review; no enrichment or repair is scheduled for it, so confirm the record before writing to it. Absent otherwise. */
+    /** true when the match was settled on a second, slower review; confirm it before relying on it. Absent otherwise. */
     languageModelSettled: z.boolean().nullish(),
     /** The matched record when status is MATCHED. */
     match: IdentificationCandidateSchema.nullish(),
-    /** Decision-model confidence, 0 to 1, in its pick: the candidate it named as the subject, or, when it picked none, that no candidate is. Present whenever a judgment ran, including a none pick; absent when no judgment ran. The kind-agnostic lookup reports the side whose answer it returns. */
-    matchConfidence: z.number().nullish(),
-    /** Decision-model probability, 0 to 1, that the evidence can tell the subject apart from namesakes. Absent when no judgment ran. The kind-agnostic lookup reports the side whose answer it returns. */
-    matchEvidenceProbability: z.number().nullish(),
-    /** The subject's own website or profile page found in web search. Use it as the website when creating the record only if it is the subject's own domain, not a LinkedIn, Crunchbase, or other profile page. */
+    /** The subject's own website or profile page found in web search; it may be a profile page on another site rather than the subject's own domain. */
     officialUrl: z.string().nullish(),
-    /** The ladder step that settled the answer. */
-    stage: z.enum(["DETERMINISTIC", "JUDGMENT", "WEB_EVIDENCE"]),
+    /** How the answer was settled; informational, so act on status instead. */
+    stage: z.enum(["DETERMINISTIC", "JUDGMENT", "WEB_EVIDENCE"]).optional(),
     /** Use the scoped match, record scoped absence, or refine an ambiguous identity with evidence. */
     status: z.enum(["MATCHED", "NO_MATCH", "NEEDS_REVIEW"]),
 });

package/dist/identification/subject.js

@@ -18,7 +18,7 @@ import { EntityTypeSchema } from "../entity/type.js";
 export const IdentificationSubjectSchema = z.object({
     /** Specific facts in plain words: product, industry, employer and title, or founder names. Generic words like startup add nothing. */
     context: z.string().max(2000).nullish(),
-    /** Kind of record to identify when you know it; the lookup then runs only that kind's ladder. typeRecord or providerId implies ENTITY. */
+    /** Kind of record to identify when you know it; only that kind is looked up. typeRecord or providerId implies ENTITY. */
     kind: z.enum(["ENTITY", "PERSON"]).nullish(),
     /** City, region, or country, such as Austin, TX. Tells namesakes apart; not proof on its own. */
     location: z.string().max(2000).nullish(),

package/dist/lookup/job-mention.d.ts

@@ -1143,14 +1143,12 @@ declare const LookupJobMentionSchemaDefinition: z.ZodObject<{
             updatedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
             website: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         }, z.core.$strip>>>;
-        matchConfidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        matchEvidenceProbability: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         officialUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        stage: z.ZodEnum<{
+        stage: z.ZodOptional<z.ZodEnum<{
             DETERMINISTIC: "DETERMINISTIC";
             JUDGMENT: "JUDGMENT";
             WEB_EVIDENCE: "WEB_EVIDENCE";
-        }>;
+        }>>;
         status: z.ZodEnum<{
             MATCHED: "MATCHED";
             NEEDS_REVIEW: "NEEDS_REVIEW";
@@ -1250,7 +1248,7 @@ type LookupJobMentionDefinition = z.infer<typeof LookupJobMentionSchemaDefinitio
 export interface LookupJobMentionSchemaInput extends z.input<typeof LookupJobMentionSchemaDefinition> {
 }
 /**
- * One company or person a source names, which stored record it is, and, from a standard article job or streaming lookup, the hidden shell record filed when it is new. Bulk lookup only identifies names and files no shells.
+ * One company or person a source names, which stored record it is, and, from a standard article job or streaming lookup, the new unpublished record created when it is new. Bulk lookup only identifies names and creates no records.
  *
  * @openapiSchema LookupJobMention
  * @endpoint GET /v1/lookup-jobs/{jobId}

package/dist/lookup/job-mention.js

@@ -5,9 +5,9 @@ import { EntityPersonOwnerSchema } from "../entity/person-owner.js";
 import { IdentificationSchema } from "../identification/identification.js";
 import { PersonSchema } from "../person/person.js";
 const LookupJobMentionSchemaDefinition = z.object({
-    /** The background harness run filed to graduate or merge shell; absent when none was filed, such as when the shell is already public. */
+    /** Research request filed for this mention, if any. */
     enrichmentRunId: z.uuid().nullish(),
-    /** POST /v1/lookup-mentions only: the candidate companies as search results show them, the match first, then by decision-model probability and duplicate-check score. */
+    /** POST /v1/lookup-mentions only: the candidate companies as search results show them, the match first, then by match probability and duplicate-check score. */
     entity: z.array(EntityListSchema),
     /** One sentence on why this name could not be identified; absent otherwise. */
     failureReason: z.string().nullish(),
@@ -19,13 +19,13 @@ const LookupJobMentionSchemaDefinition = z.object({
     name: z.string(),
     /** POST /v1/lookup-mentions only: the candidate people as search results show them, ranked like entity. */
     person: z.array(PersonSchema),
-    /** The hidden record filed for a NO_MATCH name when web search finds its own site and the live page names it, or the stored hidden record already holding that site. An article job also requires its article as an independent source. A background enrichment run graduates or merges it (enrichmentRunId). Absent for bulk lookups. */
+    /** New unpublished record aVenture created for a NO_MATCH name that the article and another live page both name. enrichmentRunId names the research already filed for it; to file research yourself, send its entityId to POST /v1/entities/{entityId}/enrichments or its personId to POST /v1/people/{personId}/enrichments. */
     shell: EntityPersonOwnerSchema.nullish(),
-    /** One sentence on why no shell was filed for a NO_MATCH name; absent otherwise. */
+    /** Why no new record was created for this NO_MATCH name. */
     shellDetail: z.string().nullish(),
 });
 /**
- * One company or person a source names, which stored record it is, and, from a standard article job or streaming lookup, the hidden shell record filed when it is new. Bulk lookup only identifies names and files no shells.
+ * One company or person a source names, which stored record it is, and, from a standard article job or streaming lookup, the new unpublished record created when it is new. Bulk lookup only identifies names and creates no records.
  *
  * @openapiSchema LookupJobMention
  * @endpoint GET /v1/lookup-jobs/{jobId}

package/dist/lookup/job-mutation.js

@@ -3,11 +3,11 @@ import { z } from "zod/v4";
 import { IdentificationSubjectSchema } from "../identification/subject.js";
 import { LookupMentionSchema } from "./mention.js";
 const LookupJobMutationSchemaDefinition = z.object({
-    /** Companies and people the caller already read, identified without sending the page or screenshot. Send them alone, without an article or file. On lookup jobs, maxNames is required and no shell records or enrichment are scheduled. */
+    /** Companies and people the caller already read, identified without sending the page or screenshot. Send them alone, without an article or file. On lookup jobs, maxNames is required and no records are created and no research is requested. */
     mention: z.array(LookupMentionSchema).optional(),
     /** POST /v1/lookup-mentions only: true answers each name with only its name, mentionType, failureReason, and identification status, stage, match, officialUrl, and detail: no entity or person rows and empty candidate and duplicate lists. Defaults to false, the full answer. */
     omitRecords: z.boolean().optional(),
-    /** Id of a recorded source document whose text is the article, such as an email recorded with POST /v1/research/source-documents; send it alone. Only POST /v1/lookup-mentions reads it, for the admin key or RBAC EDIT_CACHE. */
+    /** Id of a stored source document whose text is the article; send it alone. Only POST /v1/lookup-mentions reads it, and only for accounts with editing rights. */
     sourceDocumentId: z.uuid().nullish(),
     /** aVenture news id of the article; an id that names no stored article is an error. */
     sourceNewsId: z.int().nullish(),

package/dist/lookup/job.d.ts

@@ -182,14 +182,12 @@ declare const LookupJobSchemaDefinition: z.ZodObject<{
             updatedAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
             website: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         }, z.core.$strip>>>;
-        matchConfidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        matchEvidenceProbability: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         officialUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        stage: z.ZodEnum<{
+        stage: z.ZodOptional<z.ZodEnum<{
             DETERMINISTIC: "DETERMINISTIC";
             JUDGMENT: "JUDGMENT";
             WEB_EVIDENCE: "WEB_EVIDENCE";
-        }>;
+        }>>;
         status: z.ZodEnum<{
             MATCHED: "MATCHED";
             NEEDS_REVIEW: "NEEDS_REVIEW";
@@ -791,10 +789,8 @@ declare const LookupJobSchemaDefinition: z.ZodObject<{
                 updatedAt?: string | null | undefined;
                 website?: string | null | undefined;
             } | null | undefined;
-            matchConfidence?: number | null | undefined;
-            matchEvidenceProbability?: number | null | undefined;
             officialUrl?: string | null | undefined;
-            stage: "DETERMINISTIC" | "JUDGMENT" | "WEB_EVIDENCE";
+            stage?: "DETERMINISTIC" | "JUDGMENT" | "WEB_EVIDENCE" | undefined;
             status: "MATCHED" | "NEEDS_REVIEW" | "NO_MATCH";
         } | null | undefined;
         mentionType: "COMPANY" | "PERSON" | "PRODUCT_SERVICE";
@@ -1435,10 +1431,8 @@ declare const LookupJobSchemaDefinition: z.ZodObject<{
                 updatedAt?: string | null | undefined;
                 website?: string | null | undefined;
             } | null | undefined;
-            matchConfidence?: number | null | undefined;
-            matchEvidenceProbability?: number | null | undefined;
             officialUrl?: string | null | undefined;
-            stage: "DETERMINISTIC" | "JUDGMENT" | "WEB_EVIDENCE";
+            stage?: "DETERMINISTIC" | "JUDGMENT" | "WEB_EVIDENCE" | undefined;
             status: "MATCHED" | "NEEDS_REVIEW" | "NO_MATCH";
         } | null | undefined;
         mentionType: "COMPANY" | "PERSON" | "PRODUCT_SERVICE";

package/dist/lookup/mention.js

@@ -7,7 +7,7 @@ const LookupMentionSchemaDefinition = z.object({
     providerName: z.string().nullish(),
     /** Ignored: the lookup searches by name. Still accepted so callers that send it keep working; omit it. */
     searchQuery: z.string().optional(),
-    /** Whether the source names a company, a Product or Service (PRODUCT_SERVICE), or a person. A Product or Service resolves like a company first, then among Product and Service records when that finds no match, and never files a shell. */
+    /** Whether the source names a company, a Product or Service (PRODUCT_SERVICE), or a person. A Product or Service resolves like a company first, then among Product and Service records when that finds no match, and never creates a new record. */
     type: z.enum(["COMPANY", "PERSON", "PRODUCT_SERVICE"]),
 });
 /**

package/dist/media/upload.js

@@ -7,7 +7,7 @@ const MediaUploadSchemaDefinition = z.object({
     accuracy: LogoAccuracySchema.nullish(),
     /** Resolved API CDN URL */
     cdnUrl: z.string(),
-    /** Earliest recorded write timestamp for this media asset slot from res_provenance_event (when this entity/person/news first received any image in this slot). */
+    /** Earliest time this company, person, or news item received an image in this slot. */
     firstUploadedAt: z.iso.datetime({ offset: true }).nullish(),
     /** Target media domain */
     mediaType: MediaObjectTypeSchema,

package/dist/mention/lookup.d.ts

@@ -592,10 +592,8 @@ declare const MentionLookupSchemaDefinition: z.ZodObject<{
                 updatedAt?: string | null | undefined;
                 website?: string | null | undefined;
             } | null | undefined;
-            matchConfidence?: number | null | undefined;
-            matchEvidenceProbability?: number | null | undefined;
             officialUrl?: string | null | undefined;
-            stage: "DETERMINISTIC" | "JUDGMENT" | "WEB_EVIDENCE";
+            stage?: "DETERMINISTIC" | "JUDGMENT" | "WEB_EVIDENCE" | undefined;
             status: "MATCHED" | "NEEDS_REVIEW" | "NO_MATCH";
         } | null | undefined;
         mentionType: "COMPANY" | "PERSON" | "PRODUCT_SERVICE";
@@ -1236,10 +1234,8 @@ declare const MentionLookupSchemaDefinition: z.ZodObject<{
                 updatedAt?: string | null | undefined;
                 website?: string | null | undefined;
             } | null | undefined;
-            matchConfidence?: number | null | undefined;
-            matchEvidenceProbability?: number | null | undefined;
             officialUrl?: string | null | undefined;
-            stage: "DETERMINISTIC" | "JUDGMENT" | "WEB_EVIDENCE";
+            stage?: "DETERMINISTIC" | "JUDGMENT" | "WEB_EVIDENCE" | undefined;
             status: "MATCHED" | "NEEDS_REVIEW" | "NO_MATCH";
         } | null | undefined;
         mentionType: "COMPANY" | "PERSON" | "PRODUCT_SERVICE";

package/dist/natural/search-result.js

@@ -25,7 +25,7 @@ const NaturalSearchResultSchemaDefinition = z.object({
     pendingWebQuery: z.array(z.string()),
     /** Entity list page returned by the canonical entity list engine. */
     result: PageResultEntityListSchema,
-    /** Id of this search's stored record; send it with createSearchInteraction to record which results the user selected or opened. Null when the search was not recorded. */
+    /** Id of this search's stored record. Null when the search was not recorded. */
     searchRequestId: z.uuid().nullish(),
     /** Entities the question is about, one per resolved subject name, in query order; empty when the question names none or none resolves. */
     subject: z.array(EntityListSchema),

package/dist/natural/search.js

@@ -4,17 +4,17 @@ import { ReasoningEffortSchema } from "../reasoning/effort.js";
 import { SearchCacheModeSchema } from "../search/cache-mode.js";
 import { SearchModeSchema } from "../search/mode.js";
 const NaturalSearchSchemaDefinition = z.object({
-    /** Optional chat model for the synthesis answer; null uses the catalog's search answer model. The same allowlist as `model` applies. The answer writes the page heading, title, and description, so this compares answer models without changing the catalog. */
+    /** Optional supported model for the written answer, which also supplies the page heading, title, and description. Omit it to use the default; an unsupported model answers 422. */
     answerModel: z.string().nullish(),
-    /** Search-stage cache policy. use reuses cached search work; bypass computes fresh without retaining outputs; refresh computes fresh and replaces normal entries. Record and immutable query-vector caches retain their own policy. Callers without private-data access always run use. */
+    /** Cache policy. use reuses earlier search work; bypass and refresh compute fresh results and are honored only for accounts with private-data access. */
     cacheMode: SearchCacheModeSchema.default("use").optional(),
     /** Search strategy to run. Defaults to `auto`: the fast name layer runs first (a single-token query as keyword search, a multiword query as an exact normalized name) and the language-model planner runs only on a miss, so name lookups never pay for planning. Any other value forces exactly that strategy: `exact` and `keyword` skip planner model resolution and its rate limit. Entity and person natural-search take every value but `hybrid`; news and federated search accept only `auto` and `keyword`; content search accepts `auto`, `keyword`, `semantic`, and `hybrid` (`semantic` and `hybrid` only for one entity's or person's content). */
     mode: SearchModeSchema.default("auto").optional(),
-    /** Optional chat model for planning; null uses the configured natural-search default. A caller without admin authority may only choose an allowlisted model; admin callers are unrestricted. */
+    /** Optional supported model for planning the search. Omit it to use the default; an unsupported model answers 422. */
     model: z.string().nullish(),
     /** Plain-English search request. */
     query: z.string().min(1),
-    /** Optional reasoning effort for every model call this search makes: the query planner and the synthesis answer. Each call sends the nearest level its model supports, the lower one on a tie. Callers without private-data access are capped at `medium`: an explicit value above it is lowered, and when it is null the resolved effort — the per-model default, the tier default, or, absent an app default, the gateway's own — is still bounded at `medium`. */
+    /** Optional reasoning effort for every model call this search makes: the query planner and the synthesis answer. Each call sends the nearest level its model supports, the lower one on a tie. Accounts without private-data access are capped at `medium`; higher values are lowered. */
     reasoningEffort: ReasoningEffortSchema.nullish(),
     /** Search catalog revision this search reads its qualifier prompts and startup vocabulary from, to compare catalog edits; null reads the current revision. Callers without private-data access always read the current revision. An unknown revision returns 404. */
     searchCatalogRevision: z.int().nullish(),

package/dist/news/resolved-entity-link.js

@@ -7,6 +7,7 @@ const NewsResolvedEntityLinkSchemaDefinition = z.object({
     /** Canonical entity UUID */
     entityId: z.uuid(),
     href: z.string().nullish(),
+    /** True when href links to this entity's aVenture page; false when the entity has no page to link to. */
     internal: z.boolean(),
     matchStatus: NewsMatchStatusSchema.nullish(),
     mention: z.string().nullish(),

package/dist/news/source-url-conflict.d.ts

@@ -3,6 +3,13 @@ declare const NewsSourceUrlConflictSchemaDefinition: z.ZodObject<{
     conflictingArticleId: z.ZodInt;
     conflictingArticleSlug: z.ZodString;
     conflictingArticleTitle: z.ZodString;
+    conflictType: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        CLASSIFICATION_INACTIVE_TAG: "CLASSIFICATION_INACTIVE_TAG";
+        DUPLICATE_CREATE_REVIEW: "DUPLICATE_CREATE_REVIEW";
+        NEWS_SOURCE_URL: "NEWS_SOURCE_URL";
+        STRICT_URL_LOOKUP: "STRICT_URL_LOOKUP";
+        URL_DUPLICATE: "URL_DUPLICATE";
+    }>, z.ZodString]>>;
 }, z.core.$strip>;
 type NewsSourceUrlConflictDefinition = z.infer<typeof NewsSourceUrlConflictSchemaDefinition>;
 export interface NewsSourceUrlConflictSchemaInput extends z.input<typeof NewsSourceUrlConflictSchemaDefinition> {

package/dist/news/source-url-conflict.js

@@ -1,5 +1,6 @@
 // LLM AGENTS MAY NOT EDIT THIS FILE UNDER ANY CIRCUMSTANCES. DO NOT EDIT - generated from Kotlin data classes via OpenAPI. Edit the backend owner and run: make docs-openapi && make docs-zod
 import { z } from "zod/v4";
+import { DomainConflictTypeSchema } from "../domain/conflict-type.js";
 const NewsSourceUrlConflictSchemaDefinition = z.object({
     /** Existing article id (NewsId.value) that already owns this publication + URL pair. */
     conflictingArticleId: z.int(),
@@ -7,6 +8,8 @@ const NewsSourceUrlConflictSchemaDefinition = z.object({
     conflictingArticleSlug: z.string(),
     /** Existing article title for human-readable diagnostics. */
     conflictingArticleTitle: z.string(),
+    /** Conflict kind that identifies this details shape. */
+    conflictType: DomainConflictTypeSchema.optional(),
 });
 /**
  * Typed extension on ProblemDetail.details for HTTP 409 when a news mutation's publication + newsUrlOriginal pair already belongs to another article. The returned fields identify the existing article so the caller can read/update it instead of creating a duplicate.

package/dist/openapi-component-manifest.js

@@ -215,14 +215,6 @@ export const OPENAPI_COMPONENT_MANIFEST = Object.freeze({
         modulePath: "cursor/slice-shared-search-list",
         schemaName: "CursorSliceSharedSearchListSchema",
     },
-    DatasourceDataSourceType: {
-        modulePath: "datasource/data-source-type",
-        schemaName: "DatasourceDataSourceTypeSchema",
-    },
-    DatasourceProvenanceActorType: {
-        modulePath: "datasource/provenance-actor-type",
-        schemaName: "DatasourceProvenanceActorTypeSchema",
-    },
     DatasourceSourceMetadata: {
         modulePath: "datasource/source-metadata",
         schemaName: "DatasourceSourceMetadataSchema",
@@ -233,6 +225,10 @@ export const OPENAPI_COMPONENT_MANIFEST = Object.freeze({
         modulePath: "domain/conflict-details",
         schemaName: "DomainConflictDetailsSchema",
     },
+    DomainConflictType: {
+        modulePath: "domain/conflict-type",
+        schemaName: "DomainConflictTypeSchema",
+    },
     DuplicateCreateReview: {
         modulePath: "duplicate/create-review",
         schemaName: "DuplicateCreateReviewSchema",
@@ -982,7 +978,6 @@ export const OPENAPI_COMPONENT_MANIFEST = Object.freeze({
         modulePath: "strict/url-lookup-conflict",
         schemaName: "StrictUrlLookupConflictSchema",
     },
-    SuppressionReason: { modulePath: "suppression/reason", schemaName: "SuppressionReasonSchema" },
     SystemBuild: { modulePath: "system/system-build", schemaName: "SystemBuildSchema" },
     SystemBuildDetail: {
         modulePath: "system/system-build-detail",

package/dist/person/lookup-batch-param.d.ts

@@ -10,7 +10,6 @@ export declare const PERSON_LOOKUP_BATCH_ENDPOINT: "/v1/people/lookup-batch";
  * @contractRole canonical
  */
 export declare const PersonLookupBatchParamSchema: z.ZodObject<{
-    includePrivate: z.ZodOptional<z.ZodBoolean>;
     page: z.ZodOptional<z.ZodInt>;
     size: z.ZodOptional<z.ZodInt>;
 }, z.core.$strip>;

package/dist/person/lookup-batch-param.js

@@ -11,8 +11,6 @@ export const PERSON_LOOKUP_BATCH_ENDPOINT = "/v1/people/lookup-batch";
  * @contractRole canonical
  */
 export const PersonLookupBatchParamSchema = z.object({
-    /** Includes private fields when the caller has private-visibility authority. Omit to use the caller's default visibility. */
-    includePrivate: z.boolean().optional(),
     /** Zero-based page index (0..N); omit page and size for the full batch. */
     page: z.int().optional(),
     /** The size of the page to be returned; omit page and size for the full batch. */

package/dist/person/lookup-exact-param.d.ts

@@ -12,7 +12,6 @@ export declare const PERSON_LOOKUP_EXACT_ENDPOINT: "/v1/people/lookup-exact";
 export declare const PersonLookupExactParamSchema: z.ZodObject<{
     includeAddress: z.ZodOptional<z.ZodBoolean>;
     includeAssociation: z.ZodOptional<z.ZodBoolean>;
-    includePrivate: z.ZodOptional<z.ZodBoolean>;
     includeUrl: z.ZodOptional<z.ZodBoolean>;
     location: z.ZodOptional<z.ZodString>;
     maxAssociations: z.ZodOptional<z.ZodInt>;