@remnic/core 9.69.56 → 9.69.58

package/dist/orchestration/dependency-propagation-delivery.d.ts

@@ -0,0 +1,129 @@
+import type { ExtractionEngine } from "../extraction.js";
+import type { PluginConfig } from "../types.js";
+import { type DependencyPropagationStorage, type PropagationEvent } from "./dependency-propagation.js";
+export type DependencyPropagationJobStatus = "prepared" | "ready" | "leased" | "retryable" | "completed" | "dead_letter" | "canceled";
+export interface DependencyPropagationJob {
+    jobId: string;
+    namespace: string;
+    sourceId: string;
+    event: PropagationEvent;
+    status: DependencyPropagationJobStatus;
+    attempts: number;
+    createdAt: number;
+    updatedAt: number;
+    reservations?: number;
+    revision: number;
+    reservationIds?: string[];
+    nextAttemptAt?: number;
+    leaseOwner?: string;
+    leaseExpiresAt?: number;
+    lastError?: string;
+    preparedReplacementFingerprint?: string;
+}
+export interface DependencyPropagationPreparationToken {
+    jobId: string;
+    revision: number;
+    ownsPreparedJob: boolean;
+    reservationId: string;
+}
+export interface DependencyPropagationDeliveryPort {
+    prepare(event: PropagationEvent): Promise<DependencyPropagationPreparationToken | null>;
+    afterMutation(token: DependencyPropagationPreparationToken | null, event: PropagationEvent): Promise<void>;
+    cancel(token: DependencyPropagationPreparationToken | null): Promise<void>;
+    deferPrepared(token: DependencyPropagationPreparationToken | null): Promise<void>;
+}
+/**
+ * Index reconciliation for a replayed primary mutation (recovery). Implemented
+ * by the host and injected via {@link DependencyPropagationDeliveryOptions} so
+ * the core delivery never statically imports optional index backends (rule 57).
+ *
+ * A normal consolidation pass reindexes the survivor and deindexes the
+ * superseded source inline after a MERGE/INVALIDATE. Recovery that replays the
+ * same primary mutation must perform the equivalent reconciliation BEFORE the
+ * job becomes ready; this port is the seam. A rejection keeps the job
+ * retryable rather than marking it ready (see recoverPrimaryMutation).
+ */
+export interface DependencyPropagationReplayReconciliationPort {
+    /** Deindex superseded memories — removes their stale index visibility. */
+    deindex(event: PropagationEvent, memoryIds: readonly string[]): Promise<void>;
+    /** Reindex the survivor — refreshes its index visibility. */
+    reindex(event: PropagationEvent, survivorId: string): Promise<void>;
+}
+export interface DependencyPropagationDeliveryOptions {
+    queueRoot: string;
+    config: PluginConfig;
+    extraction: ExtractionEngine;
+    getStorage: (namespace: string) => Promise<DependencyPropagationStorage>;
+    workerId?: string;
+    clock?: () => number;
+    retryDelayMs?: number;
+    leaseMs?: number;
+    maxAttempts?: number;
+    autoStart?: boolean;
+    schedule?: (run: () => Promise<void>, delayMs: number) => void;
+    readQueueFile?: (filePath: string) => Promise<string>;
+    writeQueueFile?: (filePath: string, content: string) => Promise<void>;
+    /**
+     * Index reconciliation invoked after a recovered primary-mutation replay,
+     * before the job becomes ready. Host-injected so the core never imports an
+     * index backend; absent it, recovery skips index reconciliation (back-compat).
+     * A rejection keeps the recovered job retryable rather than marking it ready.
+     */
+    replayReconciliation?: DependencyPropagationReplayReconciliationPort;
+}
+export declare class DependencyPropagationDelivery {
+    private readonly queueRoot;
+    private readonly getStorage;
+    private readonly config;
+    private readonly extraction;
+    private readonly workerId;
+    private readonly clock;
+    private readonly retryDelayMs;
+    private readonly leaseMs;
+    private readonly maxAttempts;
+    private readonly autoStart;
+    private readonly schedule;
+    private readonly readQueueFile;
+    private readonly writeQueueFile;
+    private readonly replayReconciliation?;
+    private backgroundScheduled;
+    private recoveryScheduled;
+    private backgroundRun;
+    private readonly activeRuns;
+    private stopped;
+    constructor(options: DependencyPropagationDeliveryOptions);
+    prepare(event: PropagationEvent): Promise<DependencyPropagationPreparationToken | null>;
+    afterMutation(token: DependencyPropagationPreparationToken | null, event: PropagationEvent): Promise<void>;
+    cancel(token: DependencyPropagationPreparationToken | null): Promise<void>;
+    deferPrepared(token: DependencyPropagationPreparationToken | null): Promise<void>;
+    private trackRun;
+    recover(): Promise<void>;
+    private recoverInternal;
+    private claimPrepared;
+    private claimExpiredRecoveryLease;
+    private recoverPrimaryMutation;
+    runUntilIdle(): Promise<number>;
+    private runUntilIdleInternal;
+    private scheduleBackgroundRun;
+    private scheduleBackgroundRecovery;
+    private scheduleNextPendingRun;
+    listJobs(): Promise<DependencyPropagationJob[]>;
+    shutdown(): Promise<void>;
+    private stateDir;
+    private jobPath;
+    private writeQueueJob;
+    private readEntries;
+    private clearCommittedInvalidationProof;
+    private retainPreparedJob;
+    private transitionUnlocked;
+    private finalizeTerminalJob;
+    private pruneTerminalStatusUnlocked;
+    private removeAllQueueFilesForJobUnlocked;
+    private claimNext;
+    private processClaimed;
+    private withCurrentLease;
+    private renewLease;
+    private finishAttempt;
+    private propagateDirect;
+}
+//# sourceMappingURL=dependency-propagation-delivery.d.ts.map

package/dist/orchestration/dependency-propagation-delivery.d.ts.map

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

package/dist/orchestration/dependency-propagation-queue-state.d.ts

@@ -0,0 +1,15 @@
+import type { MemoryFile } from "../types.js";
+import type { PropagationEvent } from "./dependency-propagation.js";
+import type { DependencyPropagationJob, DependencyPropagationJobStatus } from "./dependency-propagation-delivery.js";
+export declare const JOB_STATES: readonly DependencyPropagationJobStatus[];
+export declare function isFiniteNumber(value: unknown): value is number;
+export declare function isPropagationEvent(value: unknown): value is PropagationEvent;
+export declare function validateJob(value: unknown, expectedState?: DependencyPropagationJobStatus): DependencyPropagationJob | null;
+export declare function canonicalize(value: unknown): unknown;
+export declare function compareByteStable(left: string, right: string): number;
+export declare function canonicalEvent(event: PropagationEvent): PropagationEvent;
+export declare function stableLinks(links: unknown): unknown;
+export declare function matchesPreparedSource(current: MemoryFile, prepared: Pick<MemoryFile, "content" | "frontmatter">): boolean;
+export declare function eventJobId(event: PropagationEvent): string;
+export declare function isNotFound(error: unknown): boolean;
+//# sourceMappingURL=dependency-propagation-queue-state.d.ts.map

package/dist/orchestration/dependency-propagation-queue-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-propagation-queue-state.d.ts","sourceRoot":"","sources":["../../src/orchestration/dependency-propagation-queue-state.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,KAAK,EACV,wBAAwB,EACxB,8BAA8B,EAC/B,MAAM,sCAAsC,CAAC;AAE9C,eAAO,MAAM,UAAU,EAAE,SAAS,8BAA8B,EAQ/D,CAAC;AASF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE9D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAkC5E;AAED,wBAAgB,WAAW,CACzB,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,8BAA8B,GAC7C,wBAAwB,GAAG,IAAI,CAuFjC;AACD,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAWpD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,CAExE;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAOnD;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,UAAU,EACnB,QAAQ,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,GAAG,aAAa,CAAC,GACpD,OAAO,CAWT;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAW1D;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAElD"}

package/dist/orchestration/dependency-propagation-recovery-replay.d.ts

@@ -0,0 +1,49 @@
+import type { MemoryFile } from "../types.js";
+import { type DependencyPropagationStorage, type PropagationEvent } from "./dependency-propagation.js";
+/**
+ * Storage capabilities the recovery replay needs beyond the base
+ * {@link DependencyPropagationStorage}: cold/archived memory reads, committed
+ * invalidation bookkeeping, and the supersede/invalidate primitives.
+ */
+export type DependencyPropagationRecoveryStorage = DependencyPropagationStorage & {
+    readAllColdMemories?: () => Promise<MemoryFile[]>;
+    readArchivedMemories?: () => Promise<MemoryFile[]>;
+    hasCommittedInvalidation?: (memory: Pick<MemoryFile, "content" | "frontmatter">) => Promise<boolean>;
+    clearCommittedInvalidation?: (memory: Pick<MemoryFile, "content" | "frontmatter">) => Promise<void>;
+    invalidateMemory?: (id: string, snapshot?: Pick<MemoryFile, "content" | "frontmatter"> & Partial<Pick<MemoryFile, "path">>, options?: {
+        recordCommitProof?: boolean;
+    }) => Promise<boolean>;
+    updateMemoryIfUnchanged?: (expected: MemoryFile, content: string, options?: {
+        supersedes?: string;
+        lineage?: string[];
+        actor?: string;
+        sourceConnector?: string;
+    }) => Promise<string | false>;
+};
+/**
+ * Content fingerprint captured at preparation time. Access-count /
+ * last-accessed bookkeeping is excluded so a replay can prove the survivor has
+ * not drifted.
+ */
+export declare function memoryFingerprint(memory: Pick<MemoryFile, "content" | "frontmatter">): string;
+/**
+ * Resolve a memory by id across hot, cold, and archived stores. Returns `null`
+ * when no source record survives anywhere — recovery then cannot replay.
+ */
+export declare function findRecoverySource(storage: DependencyPropagationRecoveryStorage, sourceId: string): Promise<MemoryFile | null>;
+/**
+ * Refresh a propagation event's replacement content from the current store for
+ * replay. Returns the event unchanged when it has no replacement; returns
+ * `null` when a replacement was expected but is no longer resolvable.
+ */
+export declare function readCurrentReplacementEvent(storage: DependencyPropagationStorage, event: PropagationEvent): Promise<PropagationEvent | null>;
+/**
+ * Replay the primary mutation a durable job represents against the current
+ * store, by cause: temporal supersession, contradiction supersede,
+ * consolidation invalidate, or consolidation merge. Idempotent — returns
+ * `true` when the mutation is already applied or is applied now, `false` when
+ * the source/replacement no longer matches the prepared snapshot (so the caller
+ * keeps the job retryable instead of marking it complete).
+ */
+export declare function replayPrimaryMutation(sourceStorage: DependencyPropagationStorage, event: PropagationEvent, preparedReplacementFingerprint?: string): Promise<boolean>;
+//# sourceMappingURL=dependency-propagation-recovery-replay.d.ts.map

package/dist/orchestration/dependency-propagation-recovery-replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-propagation-recovery-replay.d.ts","sourceRoot":"","sources":["../../src/orchestration/dependency-propagation-recovery-replay.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK9C,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,gBAAgB,EACtB,MAAM,6BAA6B,CAAC;AAGrC;;;;GAIG;AACH,MAAM,MAAM,oCAAoC,GAAG,4BAA4B,GAAG;IAChF,mBAAmB,CAAC,EAAE,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAClD,oBAAoB,CAAC,EAAE,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IACnD,wBAAwB,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,GAAG,aAAa,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACrG,0BAA0B,CAAC,EAAE,CAC3B,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,GAAG,aAAa,CAAC,KAChD,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,gBAAgB,CAAC,EAAE,CACjB,EAAE,EAAE,MAAM,EACV,QAAQ,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,GAAG,aAAa,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,EAC1F,OAAO,CAAC,EAAE;QAAE,iBAAiB,CAAC,EAAE,OAAO,CAAA;KAAE,KACtC,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,uBAAuB,CAAC,EAAE,CACxB,QAAQ,EAAE,UAAU,EACpB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE;QACR,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,KACE,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC;CAC9B,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,GAAG,aAAa,CAAC,GAAG,MAAM,CAK7F;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,oCAAoC,EAC7C,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAc5B;AAED;;;;GAIG;AACH,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,4BAA4B,EACrC,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAWlC;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACzC,aAAa,EAAE,4BAA4B,EAC3C,KAAK,EAAE,gBAAgB,EACvB,8BAA8B,CAAC,EAAE,MAAM,GACtC,OAAO,CAAC,OAAO,CAAC,CAkHlB"}

package/dist/orchestration/dependency-propagation-replay-reconciliation.d.ts

@@ -0,0 +1,25 @@
+import type { StorageManager } from "../storage.js";
+import type { PluginConfig } from "../types.js";
+import type { DependencyPropagationReplayReconciliationPort } from "./dependency-propagation-delivery.js";
+/**
+ * Narrow host port: the index primitives a recovery replay needs. The host
+ * (orchestrator) supplies them; this module owns the cause-gating and
+ * deindex/reindex ordering and imports no index backend of its own.
+ */
+export interface DependencyPropagationReplayHost {
+    /** Resolve the storage owning a propagation event's namespace scope. */
+    getStorage(namespace: string): Promise<StorageManager>;
+    /** Reindex/refresh a still-active survivor's index visibility. */
+    indexPersistedMemory(storage: StorageManager, memoryId: string): Promise<void>;
+    /** Remove a superseded memory's stale embedding index entry. */
+    removeFromIndex(memoryId: string): Promise<void>;
+    /** Host config; read for the query-aware-indexing gate. */
+    readonly config: PluginConfig;
+}
+/**
+ * Build the replay-reconciliation port bound to a host's index primitives. The
+ * returned port is handed to {@link DependencyPropagationDelivery} as
+ * `replayReconciliation`; it is inert until the delivery replays a job.
+ */
+export declare function createDependencyPropagationReplayReconciliation(host: DependencyPropagationReplayHost): DependencyPropagationReplayReconciliationPort;
+//# sourceMappingURL=dependency-propagation-replay-reconciliation.d.ts.map

package/dist/orchestration/dependency-propagation-replay-reconciliation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-propagation-replay-reconciliation.d.ts","sourceRoot":"","sources":["../../src/orchestration/dependency-propagation-replay-reconciliation.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAE,6CAA6C,EAAE,MAAM,sCAAsC,CAAC;AAE1G;;;;GAIG;AACH,MAAM,WAAW,+BAA+B;IAC9C,wEAAwE;IACxE,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IACvD,kEAAkE;IAClE,oBAAoB,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/E,gEAAgE;IAChE,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;CAC/B;AAED;;;;GAIG;AACH,wBAAgB,+CAA+C,CAC7D,IAAI,EAAE,+BAA+B,GACpC,6CAA6C,CA2B/C"}

package/dist/orchestration/dependency-propagation.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Bounded, one-hop invalidation propagation for linked memories.
+ *
+ * Propagation hooks stay at orchestration call sites. They never live inside
+ * StorageManager, so propagation supersessions cannot recurse.
+ */
+import type { ExtractionEngine } from "../extraction.js";
+import type { MemoryFile, MemoryFrontmatter, MemoryLinkType, PluginConfig } from "../types.js";
+export declare function isDependencyPropagationEnabled(config: Pick<PluginConfig, "dependencyPropagation">): boolean;
+export interface PropagationEvent {
+    /** Snapshot captured before the primary supersession or deletion. */
+    oldMemory: {
+        content: string;
+        frontmatter: MemoryFrontmatter;
+        path?: string;
+    };
+    replacementId: string | null;
+    replacementContent: string | null;
+    cause: "contradiction" | "temporal_supersession" | "consolidation_invalidate" | "consolidation_merge";
+    namespaceScope: string;
+    temporalMutation?: {
+        supersededAt: string;
+        invalidAt?: string;
+        matchedKeys: string[];
+    };
+}
+export interface PropagationResult {
+    dependentsFound: number;
+    invalidated: number;
+    stillValid: number;
+    uncertain: number;
+    skipped: "disabled" | "no_dependents" | "llm_error" | "timeout" | null;
+    route: "fast-completion" | null;
+    durationMs: number;
+}
+export type DependencyPropagationWriteFence = <T>(write: () => Promise<T>) => Promise<T | undefined>;
+export interface DependencyPropagationStorage {
+    readAllMemories(): Promise<MemoryFile[]>;
+    getMemoryById(id: string): Promise<MemoryFile | null>;
+    supersedeMemory(id: string, replacementId: string, reason: string, metadata?: Pick<MemoryFrontmatter, "supersessionCause" | "invalidatedBy">, options?: {
+        requireActive?: boolean;
+        acceptExactReplay?: boolean;
+        expectedSnapshot?: Pick<MemoryFile, "content" | "frontmatter"> & Partial<Pick<MemoryFile, "path">>;
+    }): Promise<boolean>;
+}
+/**
+ * Discover exactly one-hop dependents from a memory snapshot.
+ *
+ * A supports edge on the dying memory points forward to its dependent.
+ * follows and configured references edges point back to the dying memory.
+ */
+export declare function findDependents(memories: MemoryFile[], oldMemory: Pick<PropagationEvent["oldMemory"], "frontmatter">, linkTypes?: readonly MemoryLinkType[]): MemoryFile[];
+/**
+ * Revalidate one-hop dependents after a successful primary operation.
+ * The caller's storage is already namespace-scoped; this function never
+ * constructs another storage or scans a different namespace.
+ */
+export declare function propagateInvalidation(deps: {
+    storage: DependencyPropagationStorage;
+    extraction: ExtractionEngine;
+    config: PluginConfig;
+    writeFence?: DependencyPropagationWriteFence;
+}, event: PropagationEvent): Promise<PropagationResult>;
+//# sourceMappingURL=dependency-propagation.d.ts.map

package/dist/orchestration/dependency-propagation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-propagation.d.ts","sourceRoot":"","sources":["../../src/orchestration/dependency-propagation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,KAAK,EAEV,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,YAAY,EACb,MAAM,aAAa,CAAC;AAErB,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,uBAAuB,CAAC,GAAG,OAAO,CAG3G;AAED,MAAM,WAAW,gBAAgB;IAC/B,qEAAqE;IACrE,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,iBAAiB,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9E,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,kBAAkB,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,KAAK,EACD,eAAe,GACf,uBAAuB,GACvB,0BAA0B,GAC1B,qBAAqB,CAAC;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,MAAM,EAAE,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,iBAAiB;IAChC,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,UAAU,GAAG,eAAe,GAAG,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC;IACvE,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,EAC9C,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KACpB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;AAE5B,MAAM,WAAW,4BAA4B;IAC3C,eAAe,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IACzC,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;IACtD,eAAe,CACb,EAAE,EAAE,MAAM,EACV,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,mBAAmB,GAAG,eAAe,CAAC,EACzE,OAAO,CAAC,EAAE;QACR,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,gBAAgB,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,GAAG,aAAa,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC;KACpG,GACA,OAAO,CAAC,OAAO,CAAC,CAAC;CACrB;AAcD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,UAAU,EAAE,EACtB,SAAS,EAAE,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,EAAE,aAAa,CAAC,EAC7D,SAAS,GAAE,SAAS,cAAc,EAA4B,GAC7D,UAAU,EAAE,CAoCd;AAwCD;;;;GAIG;AACH,wBAAsB,qBAAqB,CACzC,IAAI,EAAE;IACJ,OAAO,EAAE,4BAA4B,CAAC;IACtC,UAAU,EAAE,gBAAgB,CAAC;IAC7B,MAAM,EAAE,YAAY,CAAC;IACrB,UAAU,CAAC,EAAE,+BAA+B,CAAC;CAC9C,EACD,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,iBAAiB,CAAC,CAyJ5B"}

package/dist/orchestration/dependency-revalidation.d.ts

@@ -0,0 +1,45 @@
+/**
+ * LLM revalidation of dependent memories after a support link breaks.
+ *
+ * Extracted from ExtractionEngine to keep extraction.ts under its ratchet
+ * ceiling. The ExtractionEngine.revalidateDependents method delegates here.
+ */
+export interface RevalidationVerdict {
+    memoryId: string;
+    verdict: "still_valid" | "invalidated" | "uncertain";
+    reason?: string;
+}
+export type RevalidationFastChatCompletion = (messages: Array<{
+    role: "system" | "user" | "assistant";
+    content: string;
+}>, options: {
+    temperature?: number;
+    maxTokens?: number;
+    timeoutMs?: number;
+    operation?: string;
+    priority?: "background" | "recall-critical";
+    signal?: AbortSignal;
+}) => Promise<{
+    content: string;
+} | null>;
+export interface RevalidationDeps {
+    fastChatCompletion: RevalidationFastChatCompletion;
+    parseJsonObject: (raw: string | null) => unknown;
+}
+export declare function revalidateDependentsViaLlm(deps: RevalidationDeps, superseded: {
+    id: string;
+    content: string;
+}, replacement: {
+    id: string;
+    content: string;
+} | null, dependents: Array<{
+    id: string;
+    category: string;
+    content: string;
+}>, options?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}): Promise<{
+    verdicts: RevalidationVerdict[];
+}>;
+//# sourceMappingURL=dependency-revalidation.d.ts.map

package/dist/orchestration/dependency-revalidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-revalidation.d.ts","sourceRoot":"","sources":["../../src/orchestration/dependency-revalidation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,aAAa,GAAG,aAAa,GAAG,WAAW,CAAC;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,8BAA8B,GAAG,CAC3C,QAAQ,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,EAC3E,OAAO,EAAE;IACP,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,YAAY,GAAG,iBAAiB,CAAC;IAC5C,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB,KACE,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAAC;AAEzC,MAAM,WAAW,gBAAgB;IAC/B,kBAAkB,EAAE,8BAA8B,CAAC;IACnD,eAAe,EAAE,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC;CAClD;AAgED,wBAAsB,0BAA0B,CAC9C,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,EAC3C,WAAW,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,EACnD,UAAU,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,EACpE,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACzD,OAAO,CAAC;IAAE,QAAQ,EAAE,mBAAmB,EAAE,CAAA;CAAE,CAAC,CAuB9C"}

package/dist/orchestration/entity-synthesis-coordinator.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Entity synthesis coordinator — extracted from the orchestrator (issue #1526).
+ *
+ * Owns the entity-synthesis lifecycle: processing the queued entities whose
+ * evidence has changed since their last synthesis, gathering timeline +
+ * structured-section evidence, deduplicating it, batch-feeding it through the
+ * fast-tier LLM to produce a compact "current truth" synthesis, and persisting
+ * the result with drift/bookkeeping metadata.
+ *
+ * Moved here (behavior-preserving):
+ *   - module-level helpers `dedupeEntitySynthesisEvidenceEntries`,
+ *     `flattenStructuredSectionEvidence`, `fingerprintEntitySynthesisEvidence`
+ *   - the queue-processing method, now owned by this coordinator as
+ *     `processQueue` (originally the orchestrator's `processEntitySynthesisQueue`)
+ *
+ * The orchestrator constructs one instance and exposes it as
+ * `orchestrator.entitySynthesisCoordinator`; call sites invoke `processQueue`
+ * directly (issue #1800 removed the orchestrator's forwarding delegate once
+ * every caller migrated). Storage is resolved per-call via the injected
+ * accessor so namespace-scoped and default-namespace calls share one
+ * coordinator.
+ */
+import type { StorageManager } from "../index.js";
+import type { EntityTimelineEntry, PluginConfig } from "../types.js";
+/**
+ * Deduplicate synthesis-evidence entries by normalized text, keeping the
+ * newest and oldest timestamp per unique fact when they differ.
+ */
+export declare function dedupeEntitySynthesisEvidenceEntries(entries: EntityTimelineEntry[]): EntityTimelineEntry[];
+/** Dependencies injected by the orchestrator. */
+export interface EntitySynthesisCoordinatorDeps {
+    config: PluginConfig;
+    /** Resolve the storage manager for a namespace (or the default). */
+    getStorage: (namespace?: string) => Promise<StorageManager>;
+    /** Fast-tier LLM completion (same signature as Orchestrator.fastChatCompletion). */
+    fastChatCompletion: (messages: Array<{
+        role: string;
+        content: string;
+    }>, options: {
+        temperature?: number;
+        maxTokens?: number;
+        timeoutMs?: number;
+        operation?: string;
+        priority?: "background" | "recall-critical";
+    }) => Promise<{
+        content: string;
+    } | null>;
+}
+/**
+ * Coordinates entity synthesis refresh for queued entities. Owns the
+ * evidence-gathering, dedup, batched-LLM-synthesis, and persistence logic
+ * that previously lived inline in the orchestrator.
+ */
+export declare class EntitySynthesisCoordinator {
+    private readonly deps;
+    constructor(deps: EntitySynthesisCoordinatorDeps);
+    /**
+     * Process up to `maxEntities` entities from the synthesis queue for the
+     * given namespace. Returns the number of entities whose synthesis was
+     * successfully refreshed.
+     */
+    processQueue(namespace?: string, maxEntities?: number): Promise<number>;
+}
+//# sourceMappingURL=entity-synthesis-coordinator.d.ts.map

package/dist/orchestration/entity-synthesis-coordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-synthesis-coordinator.d.ts","sourceRoot":"","sources":["../../src/orchestration/entity-synthesis-coordinator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMlD,OAAO,KAAK,EAEV,mBAAmB,EACnB,YAAY,EACb,MAAM,aAAa,CAAC;AAQrB;;;GAGG;AACH,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,mBAAmB,EAAE,GAC7B,mBAAmB,EAAE,CA6CvB;AA2CD,iDAAiD;AACjD,MAAM,WAAW,8BAA8B;IAC7C,MAAM,EAAE,YAAY,CAAC;IACrB,oEAAoE;IACpE,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAC5D,oFAAoF;IACpF,kBAAkB,EAAE,CAClB,QAAQ,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,EAClD,OAAO,EAAE;QACP,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,YAAY,GAAG,iBAAiB,CAAC;KAC7C,KACE,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;CAC1C;AAED;;;;GAIG;AACH,qBAAa,0BAA0B;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,8BAA8B;IAEjE;;;;OAIG;IACG,YAAY,CAChB,SAAS,CAAC,EAAE,MAAM,EAClB,WAAW,GAAE,MAAU,GACtB,OAAO,CAAC,MAAM,CAAC;CAmJnB"}

package/dist/orchestration/episodic-context-section.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Episodic-context recall section (issue #2331, harmonic-memory P3).
+ *
+ * Extracted sibling of `recallInternal`'s final assembly phase: resolves the
+ * structured `sources` provenance of the top recalled facts to LCM archive
+ * turn ranges, groups overlapping ranges into episodes, and appends the raw
+ * turns as a `## Source Episodes` section — pure lookup + formatting, no LLM
+ * calls, read-only archive access, inside the enrichment deadline.
+ *
+ * Opt-in: the registry entry is gated on `episodicContextEnabled === true`
+ * (default off), so flag-off returns before touching the archive and recall
+ * output stays byte-identical.
+ */
+import { type RecallSectionMetric } from "../recall-qos.js";
+import type { RecallSectionBuckets } from "./recall-section-coordinator.js";
+import type { RecallInternalDeps } from "./recall-internal-deps.js";
+import type { ScopePlan } from "../scopes/scope-plan.js";
+export declare function appendEpisodicContextSection(deps: RecallInternalDeps, options: {
+    sectionBuckets: RecallSectionBuckets;
+    recalledMemoryPaths: string[];
+    recalledMemoryNamespaces: Array<string | undefined>;
+    scopePlan: ScopePlan;
+    namespacesEnabled: boolean;
+    enrichmentSectionDeadlineMs: number;
+    recallOuterTimeoutMs: number;
+    recallStart: number;
+    abortSignal?: AbortSignal;
+    recordMetric: (metric: RecallSectionMetric) => void;
+}): Promise<void>;
+//# sourceMappingURL=episodic-context-section.d.ts.map

package/dist/orchestration/episodic-context-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"episodic-context-section.d.ts","sourceRoot":"","sources":["../../src/orchestration/episodic-context-section.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,OAAO,EACL,KAAK,mBAAmB,EAGzB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAOzD,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE;IACP,cAAc,EAAE,oBAAoB,CAAC;IACrC,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,wBAAwB,EAAE,KAAK,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACpD,SAAS,EAAE,SAAS,CAAC;IACrB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,2BAA2B,EAAE,MAAM,CAAC;IACpC,oBAAoB,EAAE,MAAM,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,YAAY,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,CAAC;CACrD,GACA,OAAO,CAAC,IAAI,CAAC,CA+Mf"}

package/dist/orchestration/extraction-anchor-snapshot.d.ts

@@ -0,0 +1,20 @@
+import type { StorageManager } from "../index.js";
+import type { MemoryCategory, MemoryFile } from "../types.js";
+type AnchorSnapshotOptions = {
+    enabled?: boolean;
+    candidateLimit?: number;
+    onRefreshError?: (error: unknown) => void;
+};
+/** Maintains one hot+cold anchor snapshot per storage during a persistence pass. */
+export declare class ExtractionAnchorSnapshot {
+    private readonly options;
+    private readonly snapshots;
+    private readonly refreshFailed;
+    private failOpenRead;
+    constructor(options?: AnchorSnapshotOptions);
+    get(storage: StorageManager, entityRef: unknown): Promise<MemoryFile[] | undefined>;
+    replace(storage: StorageManager, memoryId: string, category: MemoryCategory, pathById: Map<string, string>): Promise<void>;
+    remove(storage: StorageManager, memoryId: string): Promise<void>;
+}
+export {};
+//# sourceMappingURL=extraction-anchor-snapshot.d.ts.map

package/dist/orchestration/extraction-anchor-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-anchor-snapshot.d.ts","sourceRoot":"","sources":["../../src/orchestration/extraction-anchor-snapshot.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9D,KAAK,qBAAqB,GAAG;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CAC3C,CAAC;AAEF,oFAAoF;AACpF,qBAAa,wBAAwB;IAcvB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAbpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwD;IAClF,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAiC;IAC/D,OAAO,CAAC,YAAY;gBAWS,OAAO,GAAE,qBAA0B;IAEhE,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,EAAE,GAAG,SAAS,CAAC;IAsB7E,OAAO,CACX,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,cAAc,EACxB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC5B,OAAO,CAAC,IAAI,CAAC;IAuBV,MAAM,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAOvE"}

package/dist/orchestration/extraction-envelope.d.ts

@@ -0,0 +1,40 @@
+import { type MemoryWriteInput, type SealedMemoryEnvelope, type WriteContext } from "../write-envelope.js";
+/**
+ * Envelope helpers for the extraction persistence pipeline (issue #1989 PR2).
+ *
+ * Extraction input is MACHINE-GENERATED: one malformed LLM field must never
+ * abort a whole persistence batch that legacy `writeMemory` would have
+ * accepted. Every extraction-side compose therefore runs in salvage mode,
+ * and every drop is warn-logged (rule 34 — visible, never silent).
+ */
+/**
+ * Compose an extraction-side envelope in salvage mode and warn-log any
+ * salvage notes. The single compose wrapper for all extraction-persist
+ * write sites, so note logging cannot be forgotten at a new site.
+ */
+export declare function composeSalvagedExtractionEnvelope(input: MemoryWriteInput, ctx: WriteContext): SealedMemoryEnvelope;
+/**
+ * System marker tags ("shared-promotion", "<target>-promotion", "chunked")
+ * must survive the tag cap — the CLI and stats identify chunked parents and
+ * promotions through them (#2014/#2017 review round). Normalize the source
+ * tags first (same trim/dedupe salvage would apply), reserve one slot for
+ * the marker, and warn when source tags are dropped to make room.
+ */
+export declare function withReservedMarkerTag(sourceTags: string[], marker: string): string[];
+/**
+ * Pure salvage-compose probe: reproduce the SURVIVING entityRef and raw
+ * attribute pairs a salvage write of these fields would persist
+ * (deterministic, side-effect-free). Returns null when strict envelope
+ * preconditions reject (such input never reached a salvage write either) —
+ * callers fail open to their raw fields.
+ */
+export declare function probeSalvageSurvivingFields(input: {
+    content: string;
+    category: MemoryWriteInput["category"];
+    structuredAttributes?: Record<string, string>;
+    entityRef?: string;
+}): {
+    entityRef?: string;
+    structuredAttributes?: Record<string, string>;
+} | null;
+//# sourceMappingURL=extraction-envelope.d.ts.map

package/dist/orchestration/extraction-envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-envelope.d.ts","sourceRoot":"","sources":["../../src/orchestration/extraction-envelope.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,YAAY,EAClB,MAAM,sBAAsB,CAAC;AAI9B;;;;;;;GAOG;AAEH;;;;GAIG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,gBAAgB,EACvB,GAAG,EAAE,YAAY,GAChB,oBAAoB,CAMtB;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBpF;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACvC,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,IAAI,CAoB/E"}

package/dist/orchestration/extraction-injection-gate.d.ts

@@ -0,0 +1,51 @@
+import type { EntityStructuredSection } from "../types.js";
+export interface InjectionScreenCandidate {
+    content: string;
+    category?: string;
+    structuredAttributes?: Record<string, unknown>;
+    procedureSteps?: unknown;
+}
+export interface InjectionScreenGateResult {
+    status?: "pending_review";
+    tags: string[];
+}
+/** Serialize the body fields that the persistence path will store. */
+export declare function serializeInjectionScreenCandidate(candidate: InjectionScreenCandidate): string;
+/** Screen one candidate and assemble the persistence effects. */
+export declare function evaluateInjectionScreen(candidate: InjectionScreenCandidate | string, enabled: boolean): InjectionScreenGateResult;
+/**
+ * Withhold injection-flagged strings from an entity-index write (#1955
+ * review): entity facts/sections have no review status, so a flagged field is
+ * excluded from the recallable index and surfaced via the returned rules for
+ * the caller to log. Screen off → strings pass through unfiltered.
+ */
+export declare function withholdScreenedStrings(values: readonly unknown[], enabled: boolean): {
+    kept: string[];
+    withheldRules: string[];
+};
+export interface ScreenedEntityWrite {
+    name: string;
+    type: string;
+    source: string;
+    facts: string[];
+    structuredSections?: EntityStructuredSection[];
+    withheldRules: string[];
+    /** True when the entity NAME itself was flagged — callers must not index it. */
+    withheld: boolean;
+}
+/**
+ * Validate and screen one extracted entity before it enters the entity index
+ * (#1955 review): flagged facts/section facts are withheld and reported via
+ * `withheldRules` (entities carry no review status; routing is #2397).
+ * Returns null for entities without a usable name/type.
+ */
+export declare function screenEntityForIndex(entity: unknown, enabled: boolean): ScreenedEntityWrite | null;
+/**
+ * Screen a batch of persist-bound strings and preformat the withheld warning
+ * (#1955): keeps persist call sites within their file-size ratchet.
+ */
+export declare function screenPersistStrings(values: readonly string[], enabled: boolean): {
+    kept: string[];
+    warning?: string;
+};
+//# sourceMappingURL=extraction-injection-gate.d.ts.map

package/dist/orchestration/extraction-injection-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-injection-gate.d.ts","sourceRoot":"","sources":["../../src/orchestration/extraction-injection-gate.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAE3D,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/C,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,sEAAsE;AACtE,wBAAgB,iCAAiC,CAAC,SAAS,EAAE,wBAAwB,GAAG,MAAM,CAkB7F;AAED,iEAAiE;AACjE,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,wBAAwB,GAAG,MAAM,EAC5C,OAAO,EAAE,OAAO,GACf,yBAAyB,CAW3B;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,OAAO,EAAE,EAC1B,OAAO,EAAE,OAAO,GACf;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAE,CAiB7C;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,kBAAkB,CAAC,EAAE,uBAAuB,EAAE,CAAC;IAC/C,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,gFAAgF;IAChF,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CA+ClG;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,OAAO,EAAE,OAAO,GACf;IAAE,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAQtC"}

package/dist/orchestration/extraction-origin-context.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Derive issue #1955 origin metadata at the extraction boundary.
+ */
+import { type OriginClass } from "../security/origin-authority.js";
+import type { BufferTurn } from "../types.js";
+export interface ExtractionSourceContext {
+    sessionKey?: string;
+    principal?: string;
+    validAt?: string;
+    sourceConnector?: string;
+    turnRole?: "user" | "assistant" | "tool" | string;
+    importAdapter?: string;
+    originConflict?: boolean;
+}
+/** Derive one origin context from the turns that supplied an extraction. */
+export declare function deriveExtractionOriginContext(targetTurns: readonly BufferTurn[], fallbackConnector?: string): Pick<ExtractionSourceContext, "turnRole" | "importAdapter" | "sourceConnector" | "originConflict">;
+/** Classify the persisted origin without reading config flags. */
+export declare function classifyExtractionOrigin(sourceContext?: ExtractionSourceContext): OriginClass;
+//# sourceMappingURL=extraction-origin-context.d.ts.map

package/dist/orchestration/extraction-origin-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extraction-origin-context.d.ts","sourceRoot":"","sources":["../../src/orchestration/extraction-origin-context.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,iCAAiC,CAAC;AACnF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,WAAW,uBAAuB;IACtC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,MAAM,CAAC;IAClD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,4EAA4E;AAC5E,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,SAAS,UAAU,EAAE,EAClC,iBAAiB,CAAC,EAAE,MAAM,GACzB,IAAI,CAAC,uBAAuB,EAAE,UAAU,GAAG,eAAe,GAAG,iBAAiB,GAAG,gBAAgB,CAAC,CA0DpG;AAED,kEAAkE;AAClE,wBAAgB,wBAAwB,CAAC,aAAa,CAAC,EAAE,uBAAuB,GAAG,WAAW,CAO7F"}