@agenr/skeln-plugin 3.3.0 → 2026.6.2

package/dist/lifecycle-checkpoint-IAC5FCQU.js

@@ -0,0 +1,154 @@
+import {
+  normalizeOptionalString
+} from "./chunk-OJSIZDZD.js";
+
+// src/app/working-memory/lifecycle-checkpoint.ts
+async function attachWorkingCheckpointRefresh(event, result, workingMemory) {
+  const refreshRequest = resolveWorkingCheckpointRefreshRequest(event, result);
+  if (!refreshRequest) {
+    return result;
+  }
+  const workingCheckpointRefresh = workingMemory ? await mergeWorkingCheckpoint(refreshRequest, workingMemory) : skippedRefreshWithoutWorkingMemory(refreshRequest.attachLabel);
+  return {
+    ...result,
+    workingCheckpointRefresh
+  };
+}
+async function mergeWorkingCheckpoint(request, workingMemory) {
+  const scope = resolveWorkingRefreshScope(request.event);
+  if (!scope) {
+    return {
+      ok: false,
+      reason: "missing_scope",
+      message: `${request.lifecycleLabel} requires working-scope facts.`
+    };
+  }
+  const result = await workingMemory.run({
+    action: "update",
+    scope,
+    operation: {
+      type: "merge_checkpoint",
+      checkpoint: {
+        summary: request.summary,
+        recordedAt: request.event.observedAt
+      }
+    },
+    updateReason: request.updateReason,
+    actor: "runtime",
+    source: "lifecycle_hook"
+  });
+  if (!result.ok) {
+    return mapWorkingMemoryRefreshFailure(result.code, result.message, request.lifecycleLabel);
+  }
+  if (result.action !== "update") {
+    return {
+      ok: false,
+      reason: "working_memory_unavailable",
+      message: `Expected working-memory update result, received ${result.action}.`
+    };
+  }
+  return {
+    ok: true,
+    action: "working_checkpoint_refreshed",
+    workingSetId: result.workingSet.id,
+    revision: result.workingSet.revision
+  };
+}
+function resolveWorkingCheckpointRefreshRequest(event, result) {
+  const compactionEvent = resolveCompactionCheckpointRefreshEvent(event, result);
+  if (compactionEvent) {
+    const summary = normalizeOptionalString(compactionEvent.artifact.summary);
+    if (!summary) {
+      return void 0;
+    }
+    const sourceId = normalizeOptionalString(compactionEvent.artifact.sourceId) ?? "unknown";
+    return {
+      event: compactionEvent,
+      summary,
+      updateReason: `Refreshed working checkpoint from session compaction ${sourceId}.`,
+      lifecycleLabel: "compaction checkpoint refresh",
+      attachLabel: "Compaction checkpoint refresh"
+    };
+  }
+  const shutdownEvent = resolveShutdownCheckpointRefreshEvent(event, result);
+  if (!shutdownEvent) {
+    return void 0;
+  }
+  const reason = normalizeShutdownReason(shutdownEvent.shutdownReason);
+  return {
+    event: shutdownEvent,
+    summary: `Session shutdown (${reason}) recorded. Resume from the latest working-set snapshot; no implicit close was performed.`,
+    updateReason: `Recorded working checkpoint from session shutdown (${reason}).`,
+    lifecycleLabel: "shutdown checkpoint refresh",
+    attachLabel: "Shutdown checkpoint refresh"
+  };
+}
+function resolveCompactionCheckpointRefreshEvent(event, result) {
+  if (event.type !== "session_compact" || result.artifact?.kind !== "compaction_checkpoint") {
+    return void 0;
+  }
+  const artifact = event.artifact;
+  if (!isCompactionCheckpointArtifact(artifact)) {
+    return void 0;
+  }
+  return {
+    ...event,
+    type: "session_compact",
+    artifact
+  };
+}
+function resolveShutdownCheckpointRefreshEvent(event, result) {
+  if (event.type !== "session_shutdown" || result.accepted !== true) {
+    return void 0;
+  }
+  return {
+    ...event,
+    type: "session_shutdown"
+  };
+}
+function isCompactionCheckpointArtifact(artifact) {
+  return artifact?.kind === "compaction_checkpoint";
+}
+function resolveWorkingRefreshScope(event) {
+  if (event.workingScope && Object.keys(event.workingScope).length > 0) {
+    return event.workingScope;
+  }
+  return void 0;
+}
+function mapWorkingMemoryRefreshFailure(code, message, lifecycleLabel) {
+  if (code === "feature_disabled") {
+    return {
+      ok: false,
+      reason: "not_applicable",
+      message: `Working memory is disabled; ${lifecycleLabel} was skipped.`
+    };
+  }
+  if (code === "missing_active_set") {
+    return {
+      ok: false,
+      reason: "no_active_working_set",
+      code,
+      message
+    };
+  }
+  return {
+    ok: false,
+    reason: "working_memory_unavailable",
+    code,
+    message
+  };
+}
+function normalizeShutdownReason(shutdownReason) {
+  const trimmed = shutdownReason?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : "unknown";
+}
+function skippedRefreshWithoutWorkingMemory(label) {
+  return {
+    ok: false,
+    reason: "not_applicable",
+    message: `${label} requires a working-memory service, but none was wired into the runtime.`
+  };
+}
+export {
+  attachWorkingCheckpointRefresh
+};

package/dist/{claim-slot-policy-CQ-h0GaV.d.ts → ports-C4QkwDBS.d.ts}

@@ -2,18 +2,22 @@
  * Core domain types for agenr.
  * These types have zero infrastructure dependencies.
  */
-/** Ordered list of supported durable knowledge entry categories. */
-declare const ENTRY_TYPES: readonly ["fact", "decision", "preference", "lesson", "relationship", "milestone"];
+/** Ordered list of supported durable memory kinds. */
+declare const DURABLE_KINDS: readonly ["fact", "decision", "preference", "lesson", "relationship", "milestone", "directive"];
 /**
- * Union of all supported knowledge entry categories.
+ * Union of all supported durable memory kinds.
  */
-type EntryType = (typeof ENTRY_TYPES)[number];
+type DurableKind = (typeof DURABLE_KINDS)[number];
+/** Ordered list of supported behavioral directive polarities. */
+declare const DIRECTIVE_POLARITIES: readonly ["abstain", "proactive"];
+/** Ordered list of non-topic behavioral directive triggers. */
+declare const DIRECTIVE_BASE_TRIGGERS: readonly ["session_start", "always"];
 /** Ordered list of supported recall durability levels. */
 declare const EXPIRY_LEVELS: readonly ["core", "permanent", "temporary"];
 /** Ordered list of supported claim-key lifecycle statuses. */
 declare const CLAIM_KEY_STATUSES: readonly ["trusted", "tentative", "unresolved"];
 /** Ordered list of supported claim-key provenance sources. */
-declare const CLAIM_KEY_SOURCES: readonly ["manual", "model", "json_retry", "deterministic_repair", "surgeon_metadata_rewrite", "surgeon_family_reuse", "surgeon_compaction"];
+declare const CLAIM_KEY_SOURCES: readonly ["manual", "model", "json_retry", "deterministic_repair", "dreaming_extract", "dreaming_reconcile", "dreaming_temporalize", "dreaming_project"];
 /** Ordered list of supported claim-support provenance modes. */
 declare const CLAIM_SUPPORT_MODES: readonly ["explicit", "normalized", "inferred"];
 
@@ -33,6 +37,14 @@ type ClaimKeySource = (typeof CLAIM_KEY_SOURCES)[number];
  * Union of all supported claim-support provenance modes.
  */
 type ClaimSupportMode = (typeof CLAIM_SUPPORT_MODES)[number];
+/**
+ * Union of supported directive polarity values.
+ */
+type DirectivePolarity = (typeof DIRECTIVE_POLARITIES)[number];
+/**
+ * Supported directive trigger shape.
+ */
+type DirectiveTrigger = (typeof DIRECTIVE_BASE_TRIGGERS)[number] | `topic:${string}`;
 /** Ordered list of supported episode sources. */
 declare const EPISODE_SOURCES: readonly ["openclaw", "skeln", "codex", "cli", "synthesis"];
 /** Ordered list of supported episode activity levels. */
@@ -40,7 +52,7 @@ declare const EPISODE_ACTIVITY_LEVELS: readonly ["substantial", "minimal", "none
 /** Ordered list of supported procedure step kinds. */
 declare const PROCEDURE_STEP_KINDS: readonly ["run_command", "read_reference", "inspect_state", "edit_file", "ask_user", "invoke_tool", "verify"];
 /** Ordered list of supported procedure provenance source kinds. */
-declare const PROCEDURE_SOURCE_KINDS: readonly ["skill", "doc", "entry", "episode", "repo_file", "manual"];
+declare const PROCEDURE_SOURCE_KINDS: readonly ["skill", "doc", "durable", "episode", "repo_file", "manual"];
 
 /**
  * Union of all supported episode sources.
@@ -75,9 +87,9 @@ interface ClaimKeyLifecycleMetadata {
 /**
  * Canonical stored knowledge record.
  */
-interface Entry extends ClaimKeyLifecycleMetadata {
+interface Durable extends ClaimKeyLifecycleMetadata {
     id: string;
-    type: EntryType;
+    type: DurableKind;
     subject: string;
     content: string;
     importance: number;
@@ -94,15 +106,13 @@ interface Entry extends ClaimKeyLifecycleMetadata {
     superseded_by?: string;
     valid_from?: string;
     valid_to?: string;
+    directive_polarity?: DirectivePolarity;
+    directive_trigger?: DirectiveTrigger;
     claim_key?: string;
     supersession_kind?: string;
     supersession_reason?: string;
-    cluster_id?: string;
     user_id?: string;
     project?: string;
-    retired: boolean;
-    retired_at?: string;
-    retired_reason?: string;
     created_at: string;
     updated_at: string;
 }
@@ -114,21 +124,22 @@ interface Entry extends ClaimKeyLifecycleMetadata {
  * lifecycle payload for the target claim key. Partial lifecycle patches are
  * rejected at the persistence boundary.
  */
-interface EntryUpdateInput {
-    importance?: Entry["importance"];
-    expiry?: Entry["expiry"];
-    claim_key?: Entry["claim_key"];
-    claim_key_raw?: Entry["claim_key_raw"];
-    claim_key_status?: Entry["claim_key_status"];
-    claim_key_source?: Entry["claim_key_source"];
-    claim_key_confidence?: Entry["claim_key_confidence"];
-    claim_key_rationale?: Entry["claim_key_rationale"];
-    claim_support_source_kind?: Entry["claim_support_source_kind"];
-    claim_support_locator?: Entry["claim_support_locator"];
-    claim_support_observed_at?: Entry["claim_support_observed_at"];
-    claim_support_mode?: Entry["claim_support_mode"];
-    valid_from?: Entry["valid_from"];
-    valid_to?: Entry["valid_to"];
+interface DurableUpdateInput {
+    importance?: Durable["importance"];
+    expiry?: Durable["expiry"];
+    claim_key?: Durable["claim_key"];
+    claim_key_raw?: Durable["claim_key_raw"];
+    claim_key_status?: Durable["claim_key_status"];
+    claim_key_source?: Durable["claim_key_source"];
+    claim_key_confidence?: Durable["claim_key_confidence"];
+    claim_key_rationale?: Durable["claim_key_rationale"];
+    claim_support_source_kind?: Durable["claim_support_source_kind"];
+    claim_support_locator?: Durable["claim_support_locator"];
+    claim_support_observed_at?: Durable["claim_support_observed_at"];
+    claim_support_mode?: Durable["claim_support_mode"];
+    valid_from?: Durable["valid_from"];
+    valid_to?: Durable["valid_to"];
+    project?: Durable["project"];
 }
 /**
  * Canonical stored episodic-memory record.
@@ -153,9 +164,10 @@ interface Episode {
     genVersion?: string;
     messageCount?: number;
     embedding?: number[];
-    retired: boolean;
-    retiredAt?: string;
-    retiredReason?: string;
+    validFrom?: string;
+    validTo?: string;
+    supersessionKind?: string;
+    supersessionReason?: string;
     supersededBy?: string;
     createdAt: string;
     updatedAt: string;
@@ -319,9 +331,10 @@ interface ProcedureLifecycleMetadata {
     recall_text: string;
     revision_hash: string;
     source_hash: string;
-    retired: boolean;
-    retired_at?: string;
-    retired_reason?: string;
+    valid_from?: string;
+    valid_to?: string;
+    supersession_kind?: string;
+    supersession_reason?: string;
     superseded_by?: string;
     created_at: string;
     updated_at: string;
@@ -334,6 +347,54 @@ interface Procedure extends ProcedureDefinition, ProcedureLifecycleMetadata {
     source_file?: string;
     embedding?: number[];
 }
+/**
+ * Normalized transcript message emitted by transcript adapters.
+ */
+interface TranscriptMessage {
+    index: number;
+    role: "user" | "assistant";
+    text: string;
+    timestamp?: string;
+}
+/**
+ * Session-level metadata derived while parsing a transcript file.
+ */
+interface SessionTranscriptMetadata {
+    sessionId?: string;
+    startedAt?: string;
+    endedAt?: string;
+    messageCount: number;
+    transcriptHash: string;
+}
+/**
+ * Parsed transcript metadata exposed to transcript consumers.
+ */
+interface ParsedTranscriptMetadata extends SessionTranscriptMetadata {
+    sessionLabel?: string;
+    modelsUsed?: string[];
+    /** Best-effort surface reconstructed from transcript content. */
+    reconstructedSurface?: string | null;
+    /** Provenance for the reconstructed surface value. */
+    surfaceReconstructionSource?: "reconstructed" | "none";
+    /** Stable source identity derived by the transcript adapter when available. */
+    sourceIdentity?: string;
+    /** Adapter-specific kind describing the stable source identity. */
+    sourceIdentityKind?: string;
+    /** Best-effort working-directory or workspace path for the session. */
+    workingDirectory?: string;
+    /** Explicit user identifier carried by the transcript source when available. */
+    userId?: string;
+    /** Explicit project identifier carried by the transcript source when available. */
+    project?: string;
+}
+/**
+ * Parsed transcript with normalized messages and source metadata.
+ */
+interface ParsedTranscript {
+    messages: TranscriptMessage[];
+    metadata: ParsedTranscriptMetadata;
+    warnings: string[];
+}
 
 /**
  * Aggregate active corpus counts for one entity prefix.
@@ -344,12 +405,11 @@ interface ClaimKeyEntityPrefixStats {
     trustedEntryCount: number;
     tentativeEntryCount: number;
     unresolvedEntryCount: number;
-    legacyEntryCount: number;
     deterministicRepairEntryCount: number;
     manualEntryCount: number;
     modelEntryCount: number;
     jsonRetryEntryCount: number;
-    surgeonFamilyReuseEntryCount: number;
+    dreamingFamilyReuseDurableCount: number;
 }
 
 /**
@@ -421,7 +481,7 @@ interface RecallInput {
     limit?: number;
     threshold?: number;
     budget?: number;
-    types?: EntryType[];
+    types?: DurableKind[];
     tags?: string[];
     since?: string;
     until?: string;
@@ -443,7 +503,7 @@ interface RecallInput {
  * in the composite score directly now that RRF owns the fused signal.
  */
 interface RecallOutput {
-    entry: Entry;
+    entry: Durable;
     score: number;
     scores: {
         /** Fused reciprocal rank fusion score used as the composite relevance signal. */
@@ -473,12 +533,12 @@ interface RecallOutput {
 /**
  * Minimal entry fields needed during recall scoring before final hydration.
  */
-type RecallCandidateEntry = Pick<Entry, "id" | "subject" | "content" | "importance" | "expiry" | "created_at" | "embedding" | "superseded_by" | "claim_key" | "claim_key_status" | "claim_support_observed_at" | "valid_from" | "valid_to" | "retired">;
+type RecallCandidateDurable = Pick<Durable, "id" | "subject" | "content" | "importance" | "expiry" | "created_at" | "embedding" | "superseded_by" | "claim_key" | "claim_key_status" | "claim_support_observed_at" | "valid_from" | "valid_to">;
 /**
  * A candidate returned from vector search with ranking-time entry data.
  */
 interface VectorCandidate {
-    entry: RecallCandidateEntry;
+    entry: RecallCandidateDurable;
     vectorSim: number;
 }
 /**
@@ -490,18 +550,43 @@ interface VectorCandidate {
  * final composite score.
  */
 interface FtsCandidate {
-    entry: RecallCandidateEntry;
+    entry: RecallCandidateDurable;
     rank: number;
     tier: "exact" | "all_tokens" | "any_tokens";
 }
+/**
+ * Candidate shape after the vector and FTS admission paths are merged into one
+ * entry-id keyed pool. Vector similarity is preserved when a candidate appeared
+ * in the vector channel.
+ */
+interface RecallMergedCandidate {
+    entry: RecallCandidateDurable;
+    vectorSim?: number;
+}
+/**
+ * Merged recall candidate pool plus the per-channel ordered rank lists that
+ * reciprocal rank fusion consumes. This is the single shape produced by the
+ * merge stage and consumed by valid-time filtering and scoring.
+ */
+interface RecallMergeOutcome {
+    merged: Map<string, RecallMergedCandidate>;
+    vectorRanks: string[];
+    ftsRanks: string[];
+}
 /**
  * Filters that the core recall pipeline can push down into adapter queries.
  */
-interface EntryFilters {
-    types?: EntryType[];
+interface DurableFilters {
+    types?: DurableKind[];
     tags?: string[];
     since?: Date;
     until?: Date;
+    /**
+     * When set, adapter queries exclude durables whose valid-time window does not
+     * contain this instant. Core recall still applies the same filter after merge
+     * as defense in depth for non-SQL retrieval paths.
+     */
+    validAsOf?: Date;
 }
 
 /**
@@ -533,7 +618,7 @@ interface EntryFilters {
  * - `session_family` reaches across episodes originating in the same
  *   session identity (same `source` plus `sourceId`).
  * - `topic_family` reaches across rows sharing a strong subject prefix and
- *   is the weakest, retired-only fallback for entries.
+ *   is the weakest, historical-only fallback for entries.
  */
 type NeighborhoodFamily = "supersession_chain" | "claim_key_sibling" | "procedure_revision" | "session_family" | "topic_family";
 /**
@@ -541,18 +626,18 @@ type NeighborhoodFamily = "supersession_chain" | "claim_key_sibling" | "procedur
  *
  * This is the generalized successor of the phase 1 `fetchPredecessors`
  * lookup. The adapter should honor the requested `families` exactly and
- * respect `includeRetired` as a hard gate so the default entry profile
- * never pulls retired rows into the candidate pool.
+ * respect `includeHistorical` as a hard gate so the default entry profile
+ * never pulls historical rows into the candidate pool.
  */
-interface EntryNeighborhoodRequest {
+interface DurableNeighborhoodRequest {
     /** Seed entry IDs to expand around. */
     seedIds: string[];
     /** Maximum total rows the adapter may return. */
     budget: number;
     /** Families the adapter should traverse. */
     families: readonly NeighborhoodFamily[];
-    /** When true, retired rows are eligible; when false, only active rows. */
-    includeRetired?: boolean;
+    /** When true, historical rows are eligible; when false, only active rows. */
+    includeHistorical?: boolean;
 }
 /** Default total-rows budget for one neighborhood expansion call. */
 declare const DEFAULT_NEIGHBORHOOD_BUDGET = 24;
@@ -636,7 +721,7 @@ declare function seededRerank<TCandidate extends SeededRerankCandidate>(candidat
  * @param seed - Strong-seed entry the candidate is being compared to.
  * @returns True when the two entries share lineage, false otherwise.
  */
-declare function sharesEntryLineage(candidate: RecallCandidateEntry, seed: RecallCandidateEntry): boolean;
+declare function sharesEntryLineage(candidate: RecallCandidateDurable, seed: RecallCandidateDurable): boolean;
 /**
  * Decide whether two episodes belong to the same session family.
  *
@@ -665,25 +750,25 @@ declare function sharesProcedureLineage(candidate: Procedure, seed: Procedure):
  */
 interface DatabasePort {
     /** Insert a new entry with its embedding. */
-    insertEntry(entry: Entry, embedding: number[], contentHash: string): Promise<string>;
+    insertDurable(entry: Durable, embedding: number[], contentHash: string): Promise<string>;
     /** Drop expensive indexes and triggers before a bulk write phase begins. */
     prepareForBulkWrites(): Promise<void>;
     /** Rebuild expensive indexes and triggers after a bulk write phase ends. */
     finalizeBulkWrites(): Promise<void>;
     /** Get entries by IDs. */
-    getEntries(ids: string[]): Promise<Entry[]>;
+    getDurables(ids: string[]): Promise<Durable[]>;
     /** Get a single entry by ID. */
-    getEntry(id: string): Promise<Entry | null>;
+    getDurable(id: string): Promise<Durable | null>;
     /** Check if content hashes already exist. Returns the set of existing hashes. */
     findExistingHashes(hashes: string[]): Promise<Set<string>>;
     /** Check if normalized content hashes already exist. Returns the set of existing hashes. */
     findExistingNormHashes(hashes: string[]): Promise<Set<string>>;
-    /** Mark an entry as retired. */
-    retireEntry(id: string, reason?: string): Promise<boolean>;
+    /** Close one entry's valid-time window so it becomes stale for current recall. */
+    closeDurableValidity(id: string, reason?: string): Promise<boolean>;
     /** Supersede an active entry, linking it to the new entry that replaces it. */
-    supersedeEntry(oldId: string, newId: string, kind?: string, reason?: string): Promise<boolean>;
+    supersedeDurable(oldId: string, newId: string, kind?: string, reason?: string): Promise<boolean>;
     /** Find active entries with the given claim key. */
-    findActiveEntriesByClaimKey(claimKey: string): Promise<Entry[]>;
+    findActiveDurablesByClaimKey(claimKey: string): Promise<Durable[]>;
     /** Get distinct entity prefixes from existing claim keys. */
     getDistinctClaimKeyPrefixes(): Promise<string[]>;
     /** Get bounded full claim-key examples ordered for extraction hinting. */
@@ -691,7 +776,7 @@ interface DatabasePort {
     /** Get active per-prefix claim-key counts for conservative alias-family handling. */
     getClaimKeyEntityPrefixStats?(): Promise<ClaimKeyEntityPrefixStats[]>;
     /** Update entry fields (importance, expiry, and temporal metadata). */
-    updateEntry(id: string, fields: EntryUpdateInput): Promise<boolean>;
+    updateDurable(id: string, fields: DurableUpdateInput): Promise<boolean>;
     /** Check if a file has been ingested (by path + hash). */
     getIngestLogEntry(filePath: string): Promise<{
         fileHash: string;
@@ -714,7 +799,7 @@ interface EpisodeDatabasePort {
     getEpisodeByTranscriptHash(source: EpisodeSource, transcriptHash: string): Promise<Episode | null>;
     /** Insert or update an episode using `summaryHash` change detection. */
     upsertEpisode(input: EpisodeInput): Promise<EpisodeUpsertResult>;
-    /** List non-retired episodes whose time range overlaps the requested window. */
+    /** List active episodes whose time range overlaps the requested window. */
     listEpisodesByTimeWindow(window: TemporalWindow, limit?: number): Promise<Episode[]>;
     /** Find episodes by vector similarity to a query embedding. */
     episodeVectorSearch(params: {
@@ -724,7 +809,7 @@ interface EpisodeDatabasePort {
         episode: Episode;
         vectorSim: number;
     }>>;
-    /** List non-retired episodes that still need embeddings. */
+    /** List active episodes that still need embeddings. */
     listEpisodesWithoutEmbeddings(limit?: number): Promise<Episode[]>;
     /** Update only the embedding payload for an existing episode row. */
     updateEpisodeEmbedding(id: string, embedding: number[]): Promise<void>;
@@ -761,10 +846,18 @@ interface ProcedureDatabasePort {
     listProceduresWithoutEmbeddings(limit?: number): Promise<Procedure[]>;
     /** Update only the embedding payload for an existing procedure row. */
     updateProcedureEmbedding(id: string, embedding: number[]): Promise<void>;
-    /** Mark one active procedure revision as retired. */
-    retireProcedure(id: string, reason?: string): Promise<boolean>;
+    /** Close one active procedure revision's valid-time window. */
+    closeProcedureValidity(id: string, reason?: string): Promise<boolean>;
     /** Supersede one active procedure revision with a new revision. */
     supersedeProcedure(oldId: string, newId: string, reason?: string): Promise<boolean>;
+    /**
+     * Replace one active procedure revision with a new revision atomically.
+     *
+     * Owns the active-key unique-index and `superseded_by` foreign-key ordering so
+     * callers do not reimplement the close-insert-link sequence. Must run inside a
+     * write transaction.
+     */
+    replaceProcedureRevision(existingId: string, replacement: Procedure, reason?: string): Promise<Procedure>;
 }
 /**
  * Embedding provider contract used by core ranking and storage flows.
@@ -783,26 +876,26 @@ interface RecallPorts {
     vectorSearch(params: {
         embedding: number[];
         limit: number;
-        filters?: EntryFilters;
+        filters?: DurableFilters;
     }): Promise<VectorCandidate[]>;
     /** Search FTS candidates with adapter-level filtering applied. */
     ftsSearch(params: {
         text: string;
         limit: number;
-        filters?: EntryFilters;
+        filters?: DurableFilters;
     }): Promise<FtsCandidate[]>;
     /**
      * Expand a typed neighborhood of entries around the provided seed IDs.
      *
-     * The adapter honors `families` exactly and treats `includeRetired` as a
+     * The adapter honors `families` exactly and treats `includeHistorical` as a
      * hard gate. This is the generalized successor of the phase 1
      * `fetchPredecessors` lookup and is used by every entry ranking profile.
-     * The default profile passes `includeRetired: false`; historical-state
-     * passes `includeRetired: true` with a wider family set.
+     * The default profile passes `includeHistorical: false`; historical-state
+     * passes `includeHistorical: true` with a wider family set.
      */
-    expandNeighborhood?(request: EntryNeighborhoodRequest): Promise<RecallCandidateEntry[]>;
+    expandNeighborhood?(request: DurableNeighborhoodRequest): Promise<RecallCandidateDurable[]>;
     /** Hydrate fully populated entries for the final ranked result set. */
-    hydrateEntries(ids: string[]): Promise<Entry[]>;
+    hydrateEntries(ids: string[]): Promise<Durable[]>;
     /** Persist recall events for the returned entry set. */
     recordRecallEvents(params: {
         entryIds: string[];
@@ -864,17 +957,14 @@ interface CrossEncoderPort {
      */
     rank(query: string, passages: readonly CrossEncoderPassage[]): Promise<CrossEncoderScore[]>;
 }
-
-/**
- * Runtime slot-policy classes used by claim-centric read surfaces.
- */
-type ClaimSlotPolicy = "exclusive" | "multivalued";
 /**
- * Data-driven slot-policy overrides keyed by canonical claim-key attribute head.
+ * Transcript source contract for parsing external session files into core types.
  */
-interface ClaimSlotPolicyConfig {
-    /** Optional attribute-head policy overrides such as `integration -> exclusive`. */
-    attributeHeads?: Readonly<Record<string, ClaimSlotPolicy>>;
+interface TranscriptPort {
+    /** Parse a raw session file into a structured transcript. */
+    parseFile(filePath: string, options?: {
+        verbose?: boolean;
+    }): Promise<ParsedTranscript>;
 }
 
-export { type ClaimSlotPolicyConfig as C, DEFAULT_NEIGHBORHOOD_BUDGET as D, type EntryType as E, type FtsCandidate as F, type LlmPort as L, type NeighborhoodFamily as N, type ProcedureDatabasePort as P, type RecallInput as R, type SeededRerankCandidate as S, type VectorCandidate as V, type CrossEncoderPort as a, type Expiry as b, type RecallPorts as c, type RecallOutput as d, DEFAULT_SEEDED_RERANK_WEIGHT as e, DEFAULT_STRONG_SEED_SCORE_GAP as f, DEFAULT_STRONG_SEED_TOP_N as g, type EntityAttributeKind as h, type EntityAttributeQueryShape as i, type EntryFilters as j, type EntryNeighborhoodRequest as k, type RecallCandidateEntry as l, type RecallRankingProfile as m, type SeededRerankOptions as n, selectStrongSeeds as o, sharesEntryLineage as p, sharesEpisodeLineage as q, sharesProcedureLineage as r, seededRerank as s, type Entry as t, type ClaimSlotPolicy as u, type DatabasePort as v, type EpisodeDatabasePort as w, type EmbeddingPort as x };
+export { type CrossEncoderPort as C, type DurableKind as D, type Expiry as E, type FtsCandidate as F, type LlmPort as L, type NeighborhoodFamily as N, type ParsedTranscript as P, type RecallInput as R, type SeededRerankCandidate as S, type TranscriptPort as T, type VectorCandidate as V, type Durable as a, type RecallPorts as b, type RecallOutput as c, DEFAULT_NEIGHBORHOOD_BUDGET as d, DEFAULT_SEEDED_RERANK_WEIGHT as e, DEFAULT_STRONG_SEED_SCORE_GAP as f, DEFAULT_STRONG_SEED_TOP_N as g, type DurableFilters as h, type DurableNeighborhoodRequest as i, type EntityAttributeKind as j, type EntityAttributeQueryShape as k, type RecallCandidateDurable as l, type RecallMergeOutcome as m, type RecallMergedCandidate as n, type RecallRankingProfile as o, type SeededRerankOptions as p, selectStrongSeeds as q, sharesEntryLineage as r, seededRerank as s, sharesEpisodeLineage as t, sharesProcedureLineage as u, type ProcedureDatabasePort as v, type DurableUpdateInput as w, type DatabasePort as x, type EpisodeDatabasePort as y, type EmbeddingPort as z };

package/dist/scan-6JKPOQHD.js

@@ -0,0 +1,6 @@
+import {
+  runDreamScan
+} from "./chunk-GKZQ5AG5.js";
+export {
+  runDreamScan
+};

package/dist/service-EKFACEN6.js

@@ -0,0 +1,15 @@
+import {
+  backupDatabaseFile,
+  runDream,
+  runDreamWithHeldLock
+} from "./chunk-5AYIXQRF.js";
+import "./chunk-GF3PX3VM.js";
+import "./chunk-SOQW7356.js";
+import "./chunk-VTHBPXDQ.js";
+import "./chunk-VBPYU7GO.js";
+import "./chunk-GKZQ5AG5.js";
+export {
+  backupDatabaseFile,
+  runDream,
+  runDreamWithHeldLock
+};