@fgv/ts-agent-memory 5.1.0-36 → 5.1.0-39

package/lib/packlets/ingest/hostStages.d.ts

@@ -0,0 +1,88 @@
+import { Result } from '@fgv/ts-utils';
+import { MemoryId } from '../types';
+import { ICandidateEdge, ICandidateRecord, IEntityResolutionCandidate, IIngestItem, IMemoryClassification, ResolutionVerdict } from './model';
+/**
+ * Stage 2 — the host's classifier. Decides what {@link IIngestItem} maps to
+ * which memory {@link Kind} (and optional tags / confidence). LOCKED as a
+ * separate staged interface (OQ-10): the host plugs its existing classifier
+ * machinery in here rather than surrendering to an opaque ingestor.
+ * @public
+ */
+export interface IMemoryClassifier {
+    /**
+     * Classify one item. A `fail` aborts the item's ingest loudly (fgv never
+     * guesses a kind).
+     */
+    classify(item: IIngestItem): Promise<Result<IMemoryClassification>>;
+}
+/**
+ * Stage 3 — the host's fact extractor. Turns a classified item into zero or more
+ * {@link ICandidateRecord}s. Each candidate's body is validated against the
+ * kind's registered Converter by fgv before it can reach the store (the typed
+ * validation boundary — no unchecked host data is persisted).
+ * @public
+ */
+export interface IFactExtractor {
+    /**
+     * Extract candidate records from a classified item. An empty array is a valid
+     * result (the item yielded nothing memorable).
+     */
+    extract(item: IIngestItem, classification: IMemoryClassification): Promise<Result<ReadonlyArray<ICandidateRecord>>>;
+}
+/**
+ * Stage 4 (optional) — the host's entity resolver (OQ-13, LOCKED OPTIONAL). When
+ * supplied, fgv surfaces near-duplicate {@link IEntityResolutionCandidate}s (from
+ * layer-2 similarity search) and the resolver returns a
+ * {@link ResolutionVerdict}. When ABSENT, stage-4 dedup falls back to
+ * exact-`{ kind, body }`-hash only — the deterministic-identity host path.
+ * @public
+ */
+export interface IEntityResolver {
+    /**
+     * Decide whether `candidate` is new, a duplicate of / supersedes / merges into
+     * one of the surfaced `similar` records. `similar` is non-empty and ordered by
+     * descending score when the resolver is invoked (fgv only calls it when
+     * layer-2 surfaces at least one over-threshold neighbor).
+     */
+    resolve(candidate: ICandidateRecord, similar: ReadonlyArray<IEntityResolutionCandidate>): Promise<Result<ResolutionVerdict>>;
+}
+/**
+ * The context fgv hands the host's relation extractor (stage 5): the source item
+ * plus the candidates fgv is about to write, each paired with its resolved
+ * reference id (the codec `idStem`). The extractor proposes attributed edges over
+ * these ids and existing store records.
+ * @public
+ */
+export interface IRelationContext {
+    /** The item being ingested. */
+    readonly item: IIngestItem;
+    /** The candidates fgv is about to write, each with its resolved reference id. */
+    readonly candidates: ReadonlyArray<IRelationCandidate>;
+}
+/**
+ * A candidate paired with its resolved reference id, handed to the relation
+ * extractor so it can source edges from it.
+ * @public
+ */
+export interface IRelationCandidate {
+    /** The candidate about to be written. */
+    readonly candidate: ICandidateRecord;
+    /** Its resolved reference id (codec `idStem` — the stable entity reference). */
+    readonly id: MemoryId;
+}
+/**
+ * Stage 5 — the host's relation extractor. Proposes attributed edges among the
+ * candidates and existing records. fgv owns the validation, the write-time cycle
+ * guard, and the actual persistence of the edges (the host brings only the
+ * relationship judgment).
+ * @public
+ */
+export interface IRelationExtractor {
+    /**
+     * Propose the edges to attach for this ingest. An empty array is valid (no
+     * relations). Every proposed {@link ICandidateEdge.source | source} must be one
+     * of the context's candidate reference ids.
+     */
+    relate(context: IRelationContext): Promise<Result<ReadonlyArray<ICandidateEdge>>>;
+}
+//# sourceMappingURL=hostStages.d.ts.map

package/lib/packlets/ingest/hostStages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostStages.d.ts","sourceRoot":"","sources":["../../../src/packlets/ingest/hostStages.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,0BAA0B,EAC1B,WAAW,EACX,qBAAqB,EACrB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAEjB;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC,CAAC;CACrE;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,OAAO,CACL,IAAI,EAAE,WAAW,EACjB,cAAc,EAAE,qBAAqB,GACpC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC;CACrD;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;OAKG;IACH,OAAO,CACL,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,aAAa,CAAC,0BAA0B,CAAC,GACjD,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;CACvC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,iFAAiF;IACjF,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,kBAAkB,CAAC,CAAC;CACxD;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,yCAAyC;IACzC,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,gFAAgF;IAChF,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;CACvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;CACnF"}

package/lib/packlets/ingest/hostStages.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Erik Fortune
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=hostStages.js.map

package/lib/packlets/ingest/hostStages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hostStages.js","sourceRoot":"","sources":["../../../src/packlets/ingest/hostStages.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { Result } from '@fgv/ts-utils';\nimport { MemoryId } from '../types';\nimport {\n  ICandidateEdge,\n  ICandidateRecord,\n  IEntityResolutionCandidate,\n  IIngestItem,\n  IMemoryClassification,\n  ResolutionVerdict\n} from './model';\n\n/**\n * Stage 2 — the host's classifier. Decides what {@link IIngestItem} maps to\n * which memory {@link Kind} (and optional tags / confidence). LOCKED as a\n * separate staged interface (OQ-10): the host plugs its existing classifier\n * machinery in here rather than surrendering to an opaque ingestor.\n * @public\n */\nexport interface IMemoryClassifier {\n  /**\n   * Classify one item. A `fail` aborts the item's ingest loudly (fgv never\n   * guesses a kind).\n   */\n  classify(item: IIngestItem): Promise<Result<IMemoryClassification>>;\n}\n\n/**\n * Stage 3 — the host's fact extractor. Turns a classified item into zero or more\n * {@link ICandidateRecord}s. Each candidate's body is validated against the\n * kind's registered Converter by fgv before it can reach the store (the typed\n * validation boundary — no unchecked host data is persisted).\n * @public\n */\nexport interface IFactExtractor {\n  /**\n   * Extract candidate records from a classified item. An empty array is a valid\n   * result (the item yielded nothing memorable).\n   */\n  extract(\n    item: IIngestItem,\n    classification: IMemoryClassification\n  ): Promise<Result<ReadonlyArray<ICandidateRecord>>>;\n}\n\n/**\n * Stage 4 (optional) — the host's entity resolver (OQ-13, LOCKED OPTIONAL). When\n * supplied, fgv surfaces near-duplicate {@link IEntityResolutionCandidate}s (from\n * layer-2 similarity search) and the resolver returns a\n * {@link ResolutionVerdict}. When ABSENT, stage-4 dedup falls back to\n * exact-`{ kind, body }`-hash only — the deterministic-identity host path.\n * @public\n */\nexport interface IEntityResolver {\n  /**\n   * Decide whether `candidate` is new, a duplicate of / supersedes / merges into\n   * one of the surfaced `similar` records. `similar` is non-empty and ordered by\n   * descending score when the resolver is invoked (fgv only calls it when\n   * layer-2 surfaces at least one over-threshold neighbor).\n   */\n  resolve(\n    candidate: ICandidateRecord,\n    similar: ReadonlyArray<IEntityResolutionCandidate>\n  ): Promise<Result<ResolutionVerdict>>;\n}\n\n/**\n * The context fgv hands the host's relation extractor (stage 5): the source item\n * plus the candidates fgv is about to write, each paired with its resolved\n * reference id (the codec `idStem`). The extractor proposes attributed edges over\n * these ids and existing store records.\n * @public\n */\nexport interface IRelationContext {\n  /** The item being ingested. */\n  readonly item: IIngestItem;\n  /** The candidates fgv is about to write, each with its resolved reference id. */\n  readonly candidates: ReadonlyArray<IRelationCandidate>;\n}\n\n/**\n * A candidate paired with its resolved reference id, handed to the relation\n * extractor so it can source edges from it.\n * @public\n */\nexport interface IRelationCandidate {\n  /** The candidate about to be written. */\n  readonly candidate: ICandidateRecord;\n  /** Its resolved reference id (codec `idStem` — the stable entity reference). */\n  readonly id: MemoryId;\n}\n\n/**\n * Stage 5 — the host's relation extractor. Proposes attributed edges among the\n * candidates and existing records. fgv owns the validation, the write-time cycle\n * guard, and the actual persistence of the edges (the host brings only the\n * relationship judgment).\n * @public\n */\nexport interface IRelationExtractor {\n  /**\n   * Propose the edges to attach for this ingest. An empty array is valid (no\n   * relations). Every proposed {@link ICandidateEdge.source | source} must be one\n   * of the context's candidate reference ids.\n   */\n  relate(context: IRelationContext): Promise<Result<ReadonlyArray<ICandidateEdge>>>;\n}\n"]}

package/lib/packlets/ingest/index.d.ts

@@ -0,0 +1,5 @@
+export * from './model';
+export * from './hostStages';
+export * from './cycleGuard';
+export * from './orchestrator';
+//# sourceMappingURL=index.d.ts.map

package/lib/packlets/ingest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/packlets/ingest/index.ts"],"names":[],"mappings":"AAKA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC"}

package/lib/packlets/ingest/index.js

@@ -0,0 +1,25 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Erik Fortune
+ * SPDX-License-Identifier: MIT
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./model"), exports);
+__exportStar(require("./hostStages"), exports);
+__exportStar(require("./cycleGuard"), exports);
+__exportStar(require("./orchestrator"), exports);
+//# sourceMappingURL=index.js.map

package/lib/packlets/ingest/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/packlets/ingest/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;AAEH,0CAAwB;AACxB,+CAA6B;AAC7B,+CAA6B;AAC7B,iDAA+B","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nexport * from './model';\nexport * from './hostStages';\nexport * from './cycleGuard';\nexport * from './orchestrator';\n"]}

package/lib/packlets/ingest/model.d.ts

@@ -0,0 +1,177 @@
+import { IEdge, IMemoryEnvelope, IMemoryRecord, Kind, MemoryId, Tag } from '../types';
+/**
+ * A single unit of raw source material handed to the ingest pipeline. The host
+ * owns the shape of {@link IIngestItem.content | content} — fgv never interprets
+ * it; it flows opaquely into the host's classifier and extractor (stages 2-3).
+ *
+ * Single-item ingest is FIRST-CLASS: the orchestrator's primary entry point
+ * takes one `IIngestItem` (per-turn streaming), and the batch entry point is a
+ * convenience loop over it.
+ * @public
+ */
+export interface IIngestItem {
+    /**
+     * Host-owned identity for this source item. Opaque to fgv; used only in
+     * diagnostics and echoed back on the {@link IIngestItemResult}.
+     */
+    readonly id: string;
+    /**
+     * The opaque source payload the host's classifier / extractor understand
+     * (e.g. a raw turn, a document, a tool-call transcript). Never interpreted by
+     * fgv.
+     */
+    readonly content: unknown;
+    /**
+     * Optional back-link to the memory record this item was derived from (e.g. the
+     * MTM turn an extracted fact came from). When present, fgv stamps it as
+     * {@link IProvenance.derivedFrom | provenance.derivedFrom} on every record
+     * ingested from this item (stage 6) — the cross-kind provenance spine.
+     */
+    readonly sourceId?: MemoryId;
+    /** Optional opaque metadata carried alongside the item; never interpreted by fgv. */
+    readonly metadata?: Record<string, unknown>;
+}
+/**
+ * The host classifier's verdict for an {@link IIngestItem} (stage 2). Guides the
+ * host's own extractor (stage 3) and supplies the default `kind` / `tags` /
+ * `confidence` fgv stamps when the extractor does not override them.
+ *
+ * Extensible: the `[key: string]: unknown` arm lets the host attach an opaque
+ * classification payload without changing this interface.
+ * @public
+ */
+export interface IMemoryClassification {
+    /** The record kind the item classifies as. */
+    readonly kind: Kind;
+    /** Optional tags the classifier assigns. */
+    readonly tags?: ReadonlyArray<Tag>;
+    /** Optional classifier confidence in `[0, 1]`; flows to `provenance.confidence`. */
+    readonly confidence?: number;
+    /** Opaque, host-owned extension payload — never interpreted by fgv. */
+    readonly [key: string]: unknown;
+}
+/**
+ * The store-owned envelope fields fgv derives or stamps: `id` (from the codec),
+ * and the transaction-time metadata (`seq` / `contentHash` / `created` /
+ * `updated`). A {@link ICandidateRecord} supplies everything EXCEPT these.
+ * @public
+ */
+export type StoreStampedEnvelopeField = 'id' | 'seq' | 'contentHash' | 'created' | 'updated';
+/**
+ * A host-extracted candidate record (stage 3 output). The host supplies the
+ * full envelope MINUS the {@link StoreStampedEnvelopeField | store-stamped
+ * fields} (fgv derives `id` from the codec; the store stamps the rest) plus the
+ * typed body. Every candidate body is validated against the kind's registered
+ * Converter before it can reach the store (the typed validation boundary).
+ * @public
+ */
+export interface ICandidateRecord {
+    /** The host-supplied envelope, minus the store-stamped fields. */
+    readonly envelope: Omit<IMemoryEnvelope, StoreStampedEnvelopeField>;
+    /** The per-kind body (a markdown string in v1), validated on ingest. */
+    readonly body: unknown;
+}
+/**
+ * A near-duplicate candidate surfaced to the {@link IEntityResolver} by stage-4
+ * layer-2 similarity search: an existing record whose embedding is within the
+ * similarity threshold of the incoming candidate.
+ * @public
+ */
+export interface IEntityResolutionCandidate {
+    /** The existing record's id. */
+    readonly id: MemoryId;
+    /** The existing record. */
+    readonly record: IMemoryRecord<unknown>;
+    /** The backend similarity score (higher = more similar). */
+    readonly score: number;
+}
+/**
+ * The four dedup verdicts a {@link IEntityResolver} (or fgv's exact-match layer)
+ * returns for a candidate. See the design note §3 for the verdict → write
+ * disposition mapping.
+ * @public
+ */
+export type ResolutionVerdict = {
+    readonly verdict: 'new';
+} | {
+    readonly verdict: 'duplicate-of';
+    readonly target: MemoryId;
+} | {
+    readonly verdict: 'supersede';
+    readonly target: MemoryId;
+} | {
+    readonly verdict: 'merge-into';
+    readonly target: MemoryId;
+};
+/**
+ * How a candidate was ultimately written (or not) after resolution.
+ *
+ * - `written` — persisted as a fresh record (verdict `new`), or as a superseding
+ *   record (verdict `supersede`).
+ * - `deduped` — not written; an existing record satisfied it (verdict
+ *   `duplicate-of`, incl. every layer-1 exact `{ kind, body }` match).
+ * - `merged` — merged into an existing target entity (verdict `merge-into`).
+ * @public
+ */
+export type IngestDisposition = 'written' | 'deduped' | 'merged';
+/**
+ * A stage-5 attributed edge proposal: the {@link ICandidateEdge.edge | edge} to
+ * add, sourced from {@link ICandidateEdge.source | source}. The source MUST be a
+ * candidate being written in this ingest (edges land on the source record's
+ * `envelope.links`); the edge's `target` must resolve to a sibling candidate or
+ * an existing store record.
+ * @public
+ */
+export interface ICandidateEdge {
+    /** The reference id (codec `idStem`) of the candidate the edge originates from. */
+    readonly source: MemoryId;
+    /** The attributed edge (type / target / optional confidence / provenance). */
+    readonly edge: IEdge;
+}
+/**
+ * Per-candidate outcome of an ingest run.
+ * @public
+ */
+export interface IIngestedRecordResult {
+    /** The candidate the outcome is for. */
+    readonly candidate: ICandidateRecord;
+    /** The resolution verdict fgv reached (or the resolver returned). */
+    readonly resolution: ResolutionVerdict;
+    /** What the write ultimately did. */
+    readonly disposition: IngestDisposition;
+    /**
+     * The stored record's id: the newly-written id (`written` / `merged`), or the
+     * existing target's id (`deduped`).
+     */
+    readonly id: MemoryId;
+    /** The persisted record, when a write happened (`written` / `merged`). */
+    readonly record?: IMemoryRecord<unknown>;
+    /** The stage-5 edges attached to this candidate before the write. */
+    readonly edges: ReadonlyArray<ICandidateEdge>;
+    /**
+     * Informational diagnostic, set to `'temporal-versioned'` when the
+     * contradicts→temporal interlock is recognized: a `contradicts` edge was
+     * attached to a candidate of a temporal kind.
+     *
+     * @remarks
+     * A temporal kind ALWAYS writes through the store's versioned put path (that is
+     * the codec's `isVersioned` behavior — the prior version is invalidated and a
+     * new version written on every write, contradicts edge or not). This flag does
+     * NOT cause that routing; it is a diagnostic marker that the contradicts-driven
+     * scenario occurred, so callers can distinguish a contradiction-superseding
+     * version from an ordinary revision.
+     */
+    readonly interlock?: 'temporal-versioned';
+}
+/**
+ * The result of ingesting a single {@link IIngestItem}: the item plus the
+ * per-candidate outcomes (one item can yield zero or many candidate records).
+ * @public
+ */
+export interface IIngestItemResult {
+    /** The item that was ingested. */
+    readonly item: IIngestItem;
+    /** The per-candidate outcomes, in extraction order. */
+    readonly records: ReadonlyArray<IIngestedRecordResult>;
+}
+//# sourceMappingURL=model.d.ts.map

package/lib/packlets/ingest/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/packlets/ingest/model.ts"],"names":[],"mappings":"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"}

package/lib/packlets/ingest/model.js

@@ -0,0 +1,7 @@
+"use strict";
+/*
+ * Copyright (c) 2026 Erik Fortune
+ * SPDX-License-Identifier: MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=model.js.map

package/lib/packlets/ingest/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../../../src/packlets/ingest/model.ts"],"names":[],"mappings":";AAAA;;;GAGG","sourcesContent":["/*\n * Copyright (c) 2026 Erik Fortune\n * SPDX-License-Identifier: MIT\n */\n\nimport { IEdge, IMemoryEnvelope, IMemoryRecord, Kind, MemoryId, Tag } from '../types';\n\n/**\n * A single unit of raw source material handed to the ingest pipeline. The host\n * owns the shape of {@link IIngestItem.content | content} — fgv never interprets\n * it; it flows opaquely into the host's classifier and extractor (stages 2-3).\n *\n * Single-item ingest is FIRST-CLASS: the orchestrator's primary entry point\n * takes one `IIngestItem` (per-turn streaming), and the batch entry point is a\n * convenience loop over it.\n * @public\n */\nexport interface IIngestItem {\n  /**\n   * Host-owned identity for this source item. Opaque to fgv; used only in\n   * diagnostics and echoed back on the {@link IIngestItemResult}.\n   */\n  readonly id: string;\n  /**\n   * The opaque source payload the host's classifier / extractor understand\n   * (e.g. a raw turn, a document, a tool-call transcript). Never interpreted by\n   * fgv.\n   */\n  readonly content: unknown;\n  /**\n   * Optional back-link to the memory record this item was derived from (e.g. the\n   * MTM turn an extracted fact came from). When present, fgv stamps it as\n   * {@link IProvenance.derivedFrom | provenance.derivedFrom} on every record\n   * ingested from this item (stage 6) — the cross-kind provenance spine.\n   */\n  readonly sourceId?: MemoryId;\n  /** Optional opaque metadata carried alongside the item; never interpreted by fgv. */\n  readonly metadata?: Record<string, unknown>;\n}\n\n/**\n * The host classifier's verdict for an {@link IIngestItem} (stage 2). Guides the\n * host's own extractor (stage 3) and supplies the default `kind` / `tags` /\n * `confidence` fgv stamps when the extractor does not override them.\n *\n * Extensible: the `[key: string]: unknown` arm lets the host attach an opaque\n * classification payload without changing this interface.\n * @public\n */\nexport interface IMemoryClassification {\n  /** The record kind the item classifies as. */\n  readonly kind: Kind;\n  /** Optional tags the classifier assigns. */\n  readonly tags?: ReadonlyArray<Tag>;\n  /** Optional classifier confidence in `[0, 1]`; flows to `provenance.confidence`. */\n  readonly confidence?: number;\n  /** Opaque, host-owned extension payload — never interpreted by fgv. */\n  readonly [key: string]: unknown;\n}\n\n/**\n * The store-owned envelope fields fgv derives or stamps: `id` (from the codec),\n * and the transaction-time metadata (`seq` / `contentHash` / `created` /\n * `updated`). A {@link ICandidateRecord} supplies everything EXCEPT these.\n * @public\n */\nexport type StoreStampedEnvelopeField = 'id' | 'seq' | 'contentHash' | 'created' | 'updated';\n\n/**\n * A host-extracted candidate record (stage 3 output). The host supplies the\n * full envelope MINUS the {@link StoreStampedEnvelopeField | store-stamped\n * fields} (fgv derives `id` from the codec; the store stamps the rest) plus the\n * typed body. Every candidate body is validated against the kind's registered\n * Converter before it can reach the store (the typed validation boundary).\n * @public\n */\nexport interface ICandidateRecord {\n  /** The host-supplied envelope, minus the store-stamped fields. */\n  readonly envelope: Omit<IMemoryEnvelope, StoreStampedEnvelopeField>;\n  /** The per-kind body (a markdown string in v1), validated on ingest. */\n  readonly body: unknown;\n}\n\n/**\n * A near-duplicate candidate surfaced to the {@link IEntityResolver} by stage-4\n * layer-2 similarity search: an existing record whose embedding is within the\n * similarity threshold of the incoming candidate.\n * @public\n */\nexport interface IEntityResolutionCandidate {\n  /** The existing record's id. */\n  readonly id: MemoryId;\n  /** The existing record. */\n  readonly record: IMemoryRecord<unknown>;\n  /** The backend similarity score (higher = more similar). */\n  readonly score: number;\n}\n\n/**\n * The four dedup verdicts a {@link IEntityResolver} (or fgv's exact-match layer)\n * returns for a candidate. See the design note §3 for the verdict → write\n * disposition mapping.\n * @public\n */\nexport type ResolutionVerdict =\n  | { readonly verdict: 'new' }\n  | { readonly verdict: 'duplicate-of'; readonly target: MemoryId }\n  | { readonly verdict: 'supersede'; readonly target: MemoryId }\n  | { readonly verdict: 'merge-into'; readonly target: MemoryId };\n\n/**\n * How a candidate was ultimately written (or not) after resolution.\n *\n * - `written` — persisted as a fresh record (verdict `new`), or as a superseding\n *   record (verdict `supersede`).\n * - `deduped` — not written; an existing record satisfied it (verdict\n *   `duplicate-of`, incl. every layer-1 exact `{ kind, body }` match).\n * - `merged` — merged into an existing target entity (verdict `merge-into`).\n * @public\n */\nexport type IngestDisposition = 'written' | 'deduped' | 'merged';\n\n/**\n * A stage-5 attributed edge proposal: the {@link ICandidateEdge.edge | edge} to\n * add, sourced from {@link ICandidateEdge.source | source}. The source MUST be a\n * candidate being written in this ingest (edges land on the source record's\n * `envelope.links`); the edge's `target` must resolve to a sibling candidate or\n * an existing store record.\n * @public\n */\nexport interface ICandidateEdge {\n  /** The reference id (codec `idStem`) of the candidate the edge originates from. */\n  readonly source: MemoryId;\n  /** The attributed edge (type / target / optional confidence / provenance). */\n  readonly edge: IEdge;\n}\n\n/**\n * Per-candidate outcome of an ingest run.\n * @public\n */\nexport interface IIngestedRecordResult {\n  /** The candidate the outcome is for. */\n  readonly candidate: ICandidateRecord;\n  /** The resolution verdict fgv reached (or the resolver returned). */\n  readonly resolution: ResolutionVerdict;\n  /** What the write ultimately did. */\n  readonly disposition: IngestDisposition;\n  /**\n   * The stored record's id: the newly-written id (`written` / `merged`), or the\n   * existing target's id (`deduped`).\n   */\n  readonly id: MemoryId;\n  /** The persisted record, when a write happened (`written` / `merged`). */\n  readonly record?: IMemoryRecord<unknown>;\n  /** The stage-5 edges attached to this candidate before the write. */\n  readonly edges: ReadonlyArray<ICandidateEdge>;\n  /**\n   * Informational diagnostic, set to `'temporal-versioned'` when the\n   * contradicts→temporal interlock is recognized: a `contradicts` edge was\n   * attached to a candidate of a temporal kind.\n   *\n   * @remarks\n   * A temporal kind ALWAYS writes through the store's versioned put path (that is\n   * the codec's `isVersioned` behavior — the prior version is invalidated and a\n   * new version written on every write, contradicts edge or not). This flag does\n   * NOT cause that routing; it is a diagnostic marker that the contradicts-driven\n   * scenario occurred, so callers can distinguish a contradiction-superseding\n   * version from an ordinary revision.\n   */\n  readonly interlock?: 'temporal-versioned';\n}\n\n/**\n * The result of ingesting a single {@link IIngestItem}: the item plus the\n * per-candidate outcomes (one item can yield zero or many candidate records).\n * @public\n */\nexport interface IIngestItemResult {\n  /** The item that was ingested. */\n  readonly item: IIngestItem;\n  /** The per-candidate outcomes, in extraction order. */\n  readonly records: ReadonlyArray<IIngestedRecordResult>;\n}\n"]}

package/lib/packlets/ingest/orchestrator.d.ts

@@ -0,0 +1,206 @@
+import { Logging, Result } from '@fgv/ts-utils';
+import { IIdentityCodec, Kind, LinkType } from '../types';
+import { IBodyConverterRegistry } from '../converters';
+import { IMemoryStore } from '../store';
+import { IVectorIndex, MemoryEmbedder } from '../vector';
+import { IEntityResolver, IFactExtractor, IMemoryClassifier, IRelationExtractor } from './hostStages';
+import { IIngestItem, IIngestItemResult } from './model';
+/**
+ * The provenance source stamped on every record the ingest pipeline writes.
+ * @public
+ */
+export declare const HOST_INGEST_PROVENANCE_SOURCE: string;
+/**
+ * The link type whose presence on a temporal-kind candidate fires the
+ * contradicts→temporal-versioned interlock.
+ * @public
+ */
+export declare const CONTRADICTS_LINK_TYPE: LinkType;
+/**
+ * The default stage-4 layer-2 cosine similarity threshold (design note §2). A
+ * near-duplicate candidate is surfaced to the {@link IEntityResolver} only when
+ * its nearest neighbor scores `>= 0.85`.
+ * @public
+ */
+export declare const DEFAULT_SIMILARITY_THRESHOLD: number;
+/**
+ * The default top-K for stage-4 layer-2 similarity candidate generation.
+ * @public
+ */
+export declare const DEFAULT_SIMILARITY_TOP_K: number;
+/**
+ * How the write-time cycle guard behaves: `'reject'` (default — a cycle-inducing
+ * edge fails the ingest) or `'off'` (no acyclicity constraint, for deployments
+ * whose link graphs are legitimately cyclic — e.g. mutual associative links).
+ * @public
+ */
+export type CycleGuardMode = 'reject' | 'off';
+/**
+ * The fgv-owned six-stage ingest orchestrator. Composes the host's staged
+ * classify / extract / (optional) resolve / relate machinery around fgv's owned
+ * validation boundary, dedup, edge + cycle safety, provenance stamping, and the
+ * contradicts→temporal interlock.
+ * @public
+ */
+export interface IMemoryIngestOrchestrator {
+    /**
+     * Ingest a SINGLE item end-to-end (the first-class per-turn streaming path).
+     */
+    ingestItem(item: IIngestItem): Promise<Result<IIngestItemResult>>;
+    /**
+     * Ingest a batch of items. A convenience loop over {@link
+     * IMemoryIngestOrchestrator.ingestItem | ingestItem} — items are processed in
+     * order and the first failure aborts the batch.
+     */
+    ingestBatch(items: ReadonlyArray<IIngestItem>): Promise<Result<ReadonlyArray<IIngestItemResult>>>;
+}
+/**
+ * Parameters for {@link MemoryIngestOrchestrator.create}.
+ * @public
+ */
+export interface IMemoryIngestOrchestratorCreateParams {
+    /** The store every write bottoms out in (stage 6). */
+    readonly store: IMemoryStore;
+    /** Per-kind body converter registry — the stage-3 typed validation boundary. */
+    readonly registry: IBodyConverterRegistry;
+    /** Per-kind identity codecs (maps a candidate `entityId` to its storage address). */
+    readonly codecs?: ReadonlyMap<Kind, IIdentityCodec>;
+    /** Default identity codec for kinds without an explicit entry. */
+    readonly defaultCodec?: IIdentityCodec;
+    /** Stage 2 — the host's classifier. */
+    readonly classifier: IMemoryClassifier;
+    /** Stage 3 — the host's fact extractor. */
+    readonly extractor: IFactExtractor;
+    /** Stage 5 — the host's relation extractor. */
+    readonly relationExtractor: IRelationExtractor;
+    /**
+     * Stage 4 (optional, OQ-13) — the host's entity resolver. Absent → stage-4
+     * dedup is exact-`{ kind, body }`-hash only (the deterministic-identity path).
+     */
+    readonly entityResolver?: IEntityResolver;
+    /**
+     * Optional vector index for stage-4 layer-2 similarity candidate-gen. Wired
+     * together with {@link IMemoryIngestOrchestratorCreateParams.embed | embed} AND
+     * {@link IMemoryIngestOrchestratorCreateParams.entityResolver | entityResolver};
+     * absent (or either co-requisite absent) → layer-2 is skipped and dedup is
+     * exact-only.
+     */
+    readonly vectorIndex?: IVectorIndex;
+    /** Optional embedder used to embed a candidate for layer-2 similarity search. */
+    readonly embed?: MemoryEmbedder;
+    /**
+     * Stage-4 layer-2 cosine threshold. Defaults to {@link
+     * DEFAULT_SIMILARITY_THRESHOLD} (`0.85`).
+     */
+    readonly similarityThreshold?: number;
+    /**
+     * Stage-4 layer-2 top-K. Defaults to {@link DEFAULT_SIMILARITY_TOP_K} (`5`).
+     */
+    readonly similarityTopK?: number;
+    /** Write-time cycle guard mode. Defaults to `'reject'`. */
+    readonly cycleGuard?: CycleGuardMode;
+    /** Diagnostic logger (defaults to a no-op). */
+    readonly logger?: Logging.ILogger;
+}
+/**
+ * Default {@link IMemoryIngestOrchestrator}.
+ * @public
+ */
+export declare class MemoryIngestOrchestrator implements IMemoryIngestOrchestrator {
+    private readonly _store;
+    private readonly _registry;
+    private readonly _codecs;
+    private readonly _defaultCodec;
+    private readonly _classifier;
+    private readonly _extractor;
+    private readonly _relationExtractor;
+    private readonly _similarity;
+    private readonly _similarityThreshold;
+    private readonly _similarityTopK;
+    private readonly _cycleGuard;
+    private readonly _logger;
+    private readonly _hasher;
+    private constructor();
+    /** Family-convention factory. */
+    static create(params: IMemoryIngestOrchestratorCreateParams): Result<MemoryIngestOrchestrator>;
+    /** {@inheritDoc IMemoryIngestOrchestrator.ingestItem} */
+    ingestItem(item: IIngestItem): Promise<Result<IIngestItemResult>>;
+    /** {@inheritDoc IMemoryIngestOrchestrator.ingestBatch} */
+    ingestBatch(items: ReadonlyArray<IIngestItem>): Promise<Result<ReadonlyArray<IIngestItemResult>>>;
+    /** Stage 2 — classify (host), normalizing a rejected promise into a Failure. */
+    private _classify;
+    /** Stage 3 — extract (host), normalizing a rejected promise into a Failure. */
+    private _extract;
+    /**
+     * Stages 3b-6 over the extracted candidates: validate bodies, resolve/dedup
+     * (stage 4), relate + cycle guard (stage 5), and load-with-provenance (stage 6).
+     */
+    private _processCandidates;
+    /** Stage 3b + 4 for one candidate: validate body, resolve address, resolve verdict. */
+    private _planCandidate;
+    /**
+     * Turn a resolved verdict into a candidate plan. A `new` verdict writes under the
+     * candidate's own address. Every TARGET-bearing verdict
+     * (`duplicate-of` / `supersede` / `merge-into`) is validated uniformly: the
+     * target must be a real store record (fgv owns validation — a non-compliant host
+     * resolver never smuggles a bogus id through) AND its kind must equal the
+     * candidate's kind (a cross-kind target would write to the wrong scope). Only
+     * `merge-into` re-addresses the write to the target's entity.
+     */
+    private _planFromVerdict;
+    /**
+     * Stage 4 — resolve a dedup verdict. Layer 1: an exact `{ kind, body }` match in
+     * the candidate's scope is a `duplicate-of` (design note §1). Layer 2 (only when
+     * a resolver + vector index + embedder are all wired): embed the candidate,
+     * surface over-threshold neighbors, and dispatch to the {@link IEntityResolver}.
+     * Otherwise the verdict is `new` (the exact-only fall-back path).
+     */
+    private _resolveVerdict;
+    /** Layer-2 similarity candidate-gen + resolver dispatch. */
+    private _resolveViaSimilarity;
+    /** Layer-2 continuation once the candidate has a provisional record to embed. */
+    private _resolveViaSimilarityEmbedded;
+    /**
+     * Find an existing record in `scope` whose `{ kind, body }` hash matches the
+     * candidate's (layer-1 exact dedup). Invalidated temporal versions are excluded
+     * — only a live (non-temporal or current) record deduplicates a candidate.
+     */
+    private _findExactMatch;
+    /**
+     * The body of a persisted record, required to be a string (the store persists
+     * only string bodies). Fails loudly rather than blind-casting an `unknown` body
+     * into the exact-dedup hash — a non-string existing body is a store-integrity
+     * fault, surfaced with context, not a silent miscompute.
+     */
+    private static _recordBodyString;
+    /** The stage-4 exact-dedup key over `{ kind, body }` (design note §1). */
+    private _exactKey;
+    /** Stage 5 — relate (host), validate edges, and run the write-time cycle guard. */
+    private _relate;
+    /**
+     * Validate stage-5 edges: each `source` must be a candidate being written; each
+     * `target` must resolve to a sibling candidate or an existing store record.
+     */
+    private _validateEdges;
+    /** Stage 6 — stamp provenance + edges, admit through the store, record the outcome. */
+    private _loadCandidate;
+    /** Build the fully-stamped record to persist (provenance + edges + placeholder txn fields). */
+    private _buildRecord;
+    /** Union two tag lists, de-duplicated, preserving first-occurrence order. */
+    private static _unionTags;
+    /** De-duplicate a link list by canonical edge hash, preserving first-occurrence order. */
+    private _dedupEdges;
+    /** Resolve a `(kind, entityId)` to its storage address via the registered codec. */
+    private _resolveAddress;
+    /** Run a host hook, normalizing a thrown/rejected hook into a Failure (never throws across the seam). */
+    private _capture;
+    /** Index a record snapshot by id (last write wins on an id collision across scopes). */
+    private static _indexById;
+    /** Every existing outbound edge in the snapshot, as cycle-guard edges. */
+    private static _existingEdges;
+    /** A provisional record for embedding a candidate (placeholder txn-time fields). */
+    private static _provisionalRecord;
+    /** Require a candidate body to be a string (the store persists only string bodies). */
+    private static _asStringBody;
+}
+//# sourceMappingURL=orchestrator.d.ts.map

package/lib/packlets/ingest/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../../src/packlets/ingest/orchestrator.ts"],"names":[],"mappings":"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"}