cogmem 3.7.1 → 3.7.3

package/dist/config/CogmemConfig.js

@@ -4,6 +4,7 @@ import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { AesGcmEncryptionProvider } from '../encryption/index.js';
 import { ModelRegistry } from '../models/ModelRegistry.js';
 import { DEFAULT_VECTOR_DIMENSION, addVectorDimensionDiagnostics, parseVectorDimensionValue, } from './VectorDimension.js';
+import { normalizeEpisodeBoundaryConfig } from '../episode/EpisodeBoundaryPolicy.js';
 export function defaultCogmemHome(env = process.env) {
     return join(env.HOME || homedir(), '.cogmem');
 }
@@ -53,6 +54,7 @@ export function loadCogmemConfig(options = {}) {
     const memoryModel = section(root, 'memory_model');
     const reasoningModel = section(root, 'reasoning_model');
     const governance = section(root, 'governance');
+    const episodeBoundary = section(root, 'episode_boundary');
     const integrations = section(root, 'integrations');
     const openclaw = section(integrations, 'openclaw');
     const hermes = section(integrations, 'hermes');
@@ -101,6 +103,25 @@ export function loadCogmemConfig(options = {}) {
     }
     if (Object.keys(redactionPolicy).length > 0)
         optionsOut.redactionPolicy = redactionPolicy;
+    const boundaryInput = {
+        enabled: boundaryBoolean(episodeBoundary.enabled, 'enabled', diagnostics),
+        mode: boundaryString(episodeBoundary.mode, 'mode', diagnostics),
+        maxEvents: boundaryNumber(episodeBoundary.max_events, 'max_events', diagnostics),
+        maxDurationMs: boundaryNumber(episodeBoundary.max_duration_ms, 'max_duration_ms', diagnostics),
+        maxIdleGapMs: boundaryNumber(episodeBoundary.max_idle_gap_ms, 'max_idle_gap_ms', diagnostics),
+        splitOnTrustedLocalDateChange: boundaryBoolean(episodeBoundary.split_on_trusted_local_date_change, 'split_on_trusted_local_date_change', diagnostics),
+        auditDecisions: boundaryBoolean(episodeBoundary.audit_decisions, 'audit_decisions', diagnostics),
+        applyToLive: boundaryBoolean(episodeBoundary.apply_to_live, 'apply_to_live', diagnostics),
+        applyToImports: boundaryBoolean(episodeBoundary.apply_to_imports, 'apply_to_imports', diagnostics),
+        policyVersion: boundaryString(episodeBoundary.policy_version, 'policy_version', diagnostics),
+        timezone: boundaryString(episodeBoundary.timezone, 'timezone', diagnostics),
+    };
+    const configuredBoundary = Object.values(boundaryInput).some((value) => value !== undefined);
+    if (configuredBoundary) {
+        const normalizedBoundary = normalizeEpisodeBoundaryConfig(boundaryInput);
+        optionsOut.episodeBoundary = normalizedBoundary.config;
+        diagnostics.push(...normalizedBoundary.diagnostics);
+    }
     const encryptionEnabled = booleanValue(governance.encryption) === true;
     const encryptionPassphrase = interpolate(stringValue(governance.encryption_passphrase) || stringValue(governance.passphrase) || '', env, diagnostics);
     if (encryptionEnabled) {
@@ -245,3 +266,27 @@ function booleanValue(value) {
 function numberValue(value) {
     return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
 }
+function boundaryBoolean(value, name, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'boolean')
+        return value;
+    diagnostics.push({ severity: 'warning', code: `invalid_episode_boundary_${name}_type`, message: `episode_boundary.${name} must be a boolean.` });
+    return undefined;
+}
+function boundaryNumber(value, name, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    diagnostics.push({ severity: 'warning', code: `invalid_episode_boundary_${name}_type`, message: `episode_boundary.${name} must be a finite number.` });
+    return undefined;
+}
+function boundaryString(value, name, diagnostics) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    diagnostics.push({ severity: 'warning', code: `invalid_episode_boundary_${name}_type`, message: `episode_boundary.${name} must be a string.` });
+    return undefined;
+}

package/dist/core/MemoryGraph.js

@@ -14,15 +14,27 @@ export class MemoryGraph {
     anchorIndex = new Map();
     topicReclassifiedListeners = new Set();
     constructor(dbPath = ':memory:') {
-        try {
-            this.db = new Database(dbPath);
-            this.initializeSchema();
-            this.rebuildIndexes();
-        }
-        catch (error) {
-            logger.error('Failed to initialize MemoryGraph:', error);
-            throw new Error(`MemoryGraph initialization failed: ${error}`);
+        let lastError;
+        for (let attempt = 0; attempt < 6; attempt += 1) {
+            try {
+                this.db = new Database(dbPath);
+                this.initializeSchema();
+                this.rebuildIndexes();
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                try {
+                    this.db?.close();
+                }
+                catch { }
+                if (!isSqliteBusy(error) || attempt === 5)
+                    break;
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50 * (attempt + 1));
+            }
         }
+        logger.error('Failed to initialize MemoryGraph:', lastError);
+        throw new Error(`MemoryGraph initialization failed: ${lastError}`);
     }
     initializeSchema() {
         this.db.exec(`
@@ -858,3 +870,8 @@ export class MemoryGraph {
         }
     }
 }
+function isSqliteBusy(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error?.code;
+    return code === 'SQLITE_BUSY' || code === 'SQLITE_LOCKED' || /database is locked|SQLITE_BUSY|SQLITE_LOCKED/i.test(message);
+}

package/dist/dream/DreamScheduler.d.ts

@@ -1,5 +1,6 @@
 import type { DreamCuratorWorker } from '../engine/DreamCuratorWorker.js';
 import type { EpisodeStore } from '../episode/EpisodeStore.js';
+import type { DeepWriteCandidateStore } from '../store/DeepWriteCandidateStore.js';
 export type DreamTickMode = 'auto' | 'micro' | 'normal' | 'deep';
 export type SelectedDreamMode = 'none' | 'micro' | 'normal' | 'deep';
 export interface DreamTickOptions {
@@ -11,6 +12,9 @@ export interface DreamTickOptions {
     leaseMs?: number;
     maxAttempts?: number;
     maintenanceReason?: 'daily' | 'upgrade_repair';
+    clock?: {
+        now(): number;
+    };
 }
 export interface DreamTickResult {
     runId: string;
@@ -40,7 +44,8 @@ export interface DreamTickResult {
 export declare class DreamScheduler {
     private readonly episodeStore;
     private readonly curator;
-    constructor(episodeStore: EpisodeStore, curator: DreamCuratorWorker);
+    private readonly candidateStore;
+    constructor(episodeStore: EpisodeStore, curator: DreamCuratorWorker, candidateStore: DeepWriteCandidateStore);
     tick(options?: DreamTickOptions): Promise<DreamTickResult>;
     private recordRun;
 }

package/dist/dream/DreamScheduler.js

@@ -2,27 +2,35 @@ import { randomUUID } from 'node:crypto';
 export class DreamScheduler {
     episodeStore;
     curator;
-    constructor(episodeStore, curator) {
+    candidateStore;
+    constructor(episodeStore, curator, candidateStore) {
         this.episodeStore = episodeStore;
         this.curator = curator;
+        this.candidateStore = candidateStore;
     }
     async tick(options = {}) {
-        const startedAt = options.now ?? Date.now();
+        const wallStartedAt = Date.now();
+        const clock = options.clock ?? {
+            now: () => options.now === undefined ? Date.now() : options.now + (Date.now() - wallStartedAt),
+        };
+        const startedAt = options.now ?? clock.now();
         const requestedMode = options.mode ?? 'auto';
         const runId = `episode-dream-run-${randomUUID()}`;
-        const backlogBefore = this.episodeStore.getDreamStatus(options.projectId);
         const graceMs = Math.max(0, options.softSealGraceMs ?? 5 * 60_000);
+        const leaseMs = Math.max(5_000, options.leaseMs ?? 5 * 60_000);
+        this.candidateStore?.abandonStaleStagedRuns(startedAt - leaseMs, startedAt, options.projectId);
         this.episodeStore.finalizeMatureSoftSeals({
             projectId: options.projectId,
             sealedBefore: startedAt - graceMs,
             now: startedAt,
         });
+        const backlogBefore = this.episodeStore.getDreamStatus(options.projectId);
         const maxEpisodes = Math.max(1, Math.min(Math.trunc(options.maxEpisodes ?? modeLimit(requestedMode)), 50));
         const jobs = this.episodeStore.claimDreamJobs({
             projectId: options.projectId,
             limit: maxEpisodes,
             now: startedAt,
-            leaseMs: Math.max(5_000, options.leaseMs ?? 5 * 60_000),
+            leaseMs,
             maxAttempts: Math.max(1, options.maxAttempts ?? 3),
             runId,
         });
@@ -68,16 +76,38 @@ export class DreamScheduler {
                     episodeRelations: links.map((link) => ({ eventId: link.eventId, relation: link.relation })),
                     limit: limits.eventLimit,
                     now: startedAt,
+                    dreamJobLeaseId: job.leaseId,
+                    leaseUntil: job.leaseUntil,
+                    attemptGeneration: job.attemptGeneration,
                 });
                 const ids = run.candidates.map((candidate) => candidate.candidateId);
-                this.episodeStore.completeDreamJob(job.episodeId, job.leaseId, ids, startedAt);
+                try {
+                    const commitCandidates = run.runId
+                        ? () => {
+                            if (this.candidateStore.getDatabase() !== this.episodeStore.getDatabase()) {
+                                throw new Error('dream_stores_must_share_database');
+                            }
+                            this.candidateStore.publishStagedCandidates(run.runId, ids, startedAt);
+                            this.candidateStore.updateRunStatus(run.runId, 'staged', 'succeeded');
+                        }
+                        : undefined;
+                    const completedAt = clock.now();
+                    this.episodeStore.completeDreamJob(job.episodeId, job.leaseId, ids, completedAt, commitCandidates);
+                }
+                catch (completionError) {
+                    const failedAt = clock.now();
+                    if (run.runId)
+                        this.candidateStore.failStagedRun(run.runId, failedAt, 'dream_job_completion_failed');
+                    throw completionError;
+                }
                 episodeIds.push(job.episodeId);
                 candidateIds.push(...ids);
             }
             catch (error) {
                 failures += 1;
                 const message = error instanceof Error ? error.message : String(error);
-                const failure = classifyFailure(message, job.attempts, startedAt);
+                const failureNow = clock.now();
+                const failure = classifyFailure(message, job.attempts, failureNow);
                 this.episodeStore.failDreamJob(job.episodeId, job.leaseId, message, failure);
                 failedEpisodes.push({ episodeId: job.episodeId, error: message, failureCategory: failure.failureCategory, retryAfter: failure.retryAfter });
             }

package/dist/engine/CognitiveGraphCompiler.js

@@ -96,7 +96,7 @@ export class CognitiveGraphCompiler {
             seedNodeIds.push(factNode.nodeId);
             edgeCount += 1;
             if (fact.entityId) {
-                const entity = this.entityStore.findByEntityId(fact.entityId);
+                const entity = this.entityStore.getByEntityId(fact.entityId);
                 if (entity) {
                     const entityNode = this.store.upsertNode({
                         nodeId: `cgnode-${randomUUID()}`,

package/dist/engine/ConsolidationPipeline.js

@@ -263,7 +263,7 @@ export class ConsolidationPipeline {
     }
     buildAsyncEnrichmentEntityBinding(neuron, consolidation) {
         const compiledEntities = consolidation.compiledEntityIds
-            .map((entityId) => this.entityStore.findByEntityId(entityId))
+            .map((entityId) => this.entityStore.getByEntityId(entityId))
             .filter((entity) => Boolean(entity));
         const suspiciousReasons = [];
         if (compiledEntities.length > 0) {
@@ -286,11 +286,11 @@ export class ConsolidationPipeline {
     }
     buildAsyncEnrichmentContext(neuron, consolidation) {
         const recentEntities = Array.from(new Map([
-            ...consolidation.compiledEntityIds.map((entityId) => this.entityStore.findByEntityId(entityId)),
+            ...consolidation.compiledEntityIds.map((entityId) => this.entityStore.getByEntityId(entityId)),
             ...this.entityStore.getEntityTimeline({
                 projectId: neuron.metadata.projectId,
                 limit: 8
-            }).map((item) => this.entityStore.findByEntityId(item.entityId))
+            }).map((item) => this.entityStore.getByEntityId(item.entityId))
         ]
             .filter((entity) => Boolean(entity))
             .map((entity) => [entity.entityId, entity])).values()).slice(0, 6);
@@ -309,7 +309,7 @@ export class ConsolidationPipeline {
     hasSuspiciousUnseenEntityBinding(consolidation) {
         const semanticEntityHints = consolidation.semanticCompilation?.entities.map((entity) => entity.text) || [];
         const compiledEntityNames = consolidation.compiledEntityIds
-            .map((entityId) => this.entityStore.findByEntityId(entityId)?.canonicalName || '')
+            .map((entityId) => this.entityStore.getByEntityId(entityId)?.canonicalName || '')
             .filter(Boolean);
         const sourceText = consolidation.interactionUnit?.semanticText || '';
         const explicitNamedDevice = sourceText.match(/([A-Za-z][A-Za-z0-9._-]*(?:\s+[A-Za-z0-9._-]+){1,3})/);

package/dist/engine/DeepWritePromotionPolicy.d.ts

@@ -30,8 +30,10 @@ export interface DeepWriteEvaluationOptions {
 export declare class DeepWritePromotionPolicy {
     private readonly deps;
     constructor(deps: DeepWritePromotionPolicyDeps);
+    setRelationStore(store: GraphEdgeStoreLike): void;
     promoteRun(runId: string): DeepWritePromotionDecision[];
     promotePending(limit?: number, options?: DeepWritePromotionOptions): DeepWritePromotionDecision[];
+    private atomicEvaluate;
     evaluateAndApply(candidate: DeepWriteCandidateRecord, options?: DeepWriteEvaluationOptions): DeepWritePromotionDecision;
     private promoteOrganizationCandidate;
     private promoteFact;

package/dist/engine/DeepWritePromotionPolicy.js

@@ -134,18 +134,39 @@ export class DeepWritePromotionPolicy {
     constructor(deps) {
         this.deps = deps;
     }
+    setRelationStore(store) {
+        this.deps.relationStore = store;
+    }
     promoteRun(runId) {
         const candidates = this.deps.candidateStore.listCandidatesByRun(runId);
-        return candidates.map((candidate) => this.evaluateAndApply(candidate));
+        return candidates.map((candidate) => this.atomicEvaluate(candidate));
     }
     promotePending(limit = 100, options = {}) {
         const candidates = options.projectId
             ? this.deps.candidateStore.listCandidates({ statuses: ['candidate'], projectId: options.projectId, limit })
             : this.deps.candidateStore.listCandidatesByStatus(['candidate'], { limit });
-        return candidates.map((candidate) => this.evaluateAndApply(candidate));
+        return candidates.map((candidate) => this.atomicEvaluate(candidate));
+    }
+    atomicEvaluate(candidate) {
+        return this.deps.candidateStore.getDatabase().transaction(() => {
+            if (!this.deps.candidateStore.claimCandidate(candidate.candidateId)) {
+                return this.keep(candidate, 'candidate_claim_lost');
+            }
+            const current = this.deps.candidateStore.getCandidate(candidate.candidateId);
+            if (!current || current.status !== 'promoting')
+                return this.keep(candidate, 'candidate_claim_lost');
+            const decision = this.evaluateAndApply(current);
+            if (decision.outcome === 'keep_candidate') {
+                this.deps.candidateStore.updateCandidateStatus(current.candidateId, 'candidate', {
+                    reason: decision.reason,
+                    updatedAt: Date.now(),
+                }, 'promoting');
+            }
+            return decision;
+        })();
     }
     evaluateAndApply(candidate, options = {}) {
-        if (candidate.status !== 'candidate') {
+        if (candidate.status !== 'candidate' && candidate.status !== 'promoting') {
             return this.keep(candidate, `status_${candidate.status}_not_promotable`);
         }
         const content = asRecord(candidate.content);
@@ -508,7 +529,7 @@ export class DeepWritePromotionPolicy {
             type: decision.targetType,
             id: decision.targetId,
             reason: decision.reason,
-        });
+        }, candidate.status);
         return decision;
     }
 }

package/dist/engine/DreamCuratorWorker.d.ts

@@ -26,6 +26,9 @@ export interface DreamCuratorRunOptions {
         eventId: string;
         relation: string;
     }>;
+    dreamJobLeaseId?: string;
+    leaseUntil?: number;
+    attemptGeneration?: number;
 }
 export interface DreamCuratorRunResult {
     runId?: string;

package/dist/engine/DreamCuratorWorker.js

@@ -84,10 +84,22 @@ export class DreamCuratorWorker {
                 content: candidate.content,
                 evidence: candidate.evidence,
             })))),
-            status: 'succeeded',
+            status: options.sourceEpisodeId ? 'staged' : 'succeeded',
             createdAt: now,
+            sourceEpisodeId: options.sourceEpisodeId,
+            dreamJobLeaseId: options.dreamJobLeaseId,
+            leaseUntil: options.leaseUntil,
+            attemptGeneration: options.attemptGeneration,
         });
-        const inserted = this.deps.candidateStore.insertCandidates(candidateInputs.map((candidate) => ({ ...candidate, runId: run.runId, createdAt: now })));
+        const inserted = this.deps.candidateStore.insertCandidates(candidateInputs.map((candidate) => ({
+            ...candidate,
+            status: options.sourceEpisodeId && candidate.status !== 'shadow' ? 'staged' : candidate.status,
+            publishStatus: options.sourceEpisodeId && candidate.status !== 'shadow'
+                ? candidate.status
+                : undefined,
+            runId: run.runId,
+            createdAt: now,
+        })));
         const status = explicitEpisodeRun
             ? before
             : this.deps.dreamLedgerStore.markDreamed(options.projectId, maxGlobalSeq, now);
@@ -100,7 +112,10 @@ export class DreamCuratorWorker {
             candidateCount: inserted.length,
             maxGlobalSeq,
             status,
-            candidates: inserted,
+            candidates: inserted.map((candidate, index) => ({
+                ...candidate,
+                status: candidateInputs[index]?.status ?? candidate.status,
+            })),
         };
     }
     async buildCandidates(events, options, now) {

package/dist/engine/FactCompiler.js

@@ -177,7 +177,7 @@ export class FactCompiler {
             : null;
         if (issueMatches.length > 0) {
             const resolvedDevice = primaryDeviceEntityId
-                ? this.entityStore.findByEntityId(primaryDeviceEntityId)
+                ? this.entityStore.getByEntityId(primaryDeviceEntityId)
                 : this.resolveImplicitEntity(workingText, 'device', projectId);
             for (const issueMatch of issueMatches) {
                 const issueMetadata = this.buildIssueMetadata(issueMatch.issue, issueMatch.issue, sourceText, {
@@ -266,7 +266,7 @@ export class FactCompiler {
             }
         }
         else if (input.semanticCompilation?.issueHints.length && primaryDeviceEntityId) {
-            const resolvedDevice = this.entityStore.findByEntityId(primaryDeviceEntityId);
+            const resolvedDevice = this.entityStore.getByEntityId(primaryDeviceEntityId);
             for (const issueHint of input.semanticCompilation.issueHints.slice(0, 2)) {
                 const issueMetadata = this.buildIssueMetadata(issueHint, issueHint, sourceText);
                 factInputs.push({

package/dist/entity/EntityGovernanceService.js

@@ -133,7 +133,7 @@ export class EntityGovernanceService {
             .map(mapCandidate);
     }
     requireEntity(entityId) {
-        const entity = this.entities.findByEntityId(entityId);
+        const entity = this.entities.getByEntityId(entityId);
         if (!entity)
             throw new Error(`Unknown entity: ${entityId}`);
         return entity;

package/dist/episode/EpisodeActiveScopeGuard.d.ts

@@ -0,0 +1,3 @@
+import type Database from 'bun:sqlite';
+export declare function sealDuplicateOpenEpisodes(db: Database): void;
+//# sourceMappingURL=EpisodeActiveScopeGuard.d.ts.map

package/dist/episode/EpisodeActiveScopeGuard.js

@@ -0,0 +1,46 @@
+export function sealDuplicateOpenEpisodes(db) {
+    const duplicates = db.prepare(`
+    SELECT project_id, session_id, COALESCE(source_agent, '') AS source_agent_key,
+      COALESCE(conversation_thread_id, '') AS thread_key
+    FROM memory_episodes
+    WHERE status = 'open'
+    GROUP BY project_id, session_id, COALESCE(source_agent, ''), COALESCE(conversation_thread_id, '')
+    HAVING COUNT(*) > 1
+  `).all();
+    if (!duplicates.length)
+        return;
+    const selectEpisodes = db.prepare(`
+    SELECT * FROM memory_episodes
+    WHERE status = 'open'
+      AND project_id = ?
+      AND session_id = ?
+      AND COALESCE(source_agent, '') = ?
+      AND COALESCE(conversation_thread_id, '') = ?
+    ORDER BY updated_at DESC, episode_id DESC
+  `);
+    const selectEventIds = db.prepare(`
+    SELECT event_id FROM memory_episode_events WHERE episode_id = ? ORDER BY position
+  `);
+    const sealEpisode = db.prepare(`
+    UPDATE memory_episodes SET status = 'sealed', sealed_at = ?, updated_at = MAX(updated_at, ?)
+    WHERE episode_id = ?
+  `);
+    const insertReceipt = db.prepare(`
+    INSERT OR IGNORE INTO episode_closure_receipts (
+      receipt_id, episode_id, project_id, closure_mode, closure_reason, source_event_ids_json,
+      start_seq, end_seq, topic_path, episode_type, importance, dream_recommended, dream_mode,
+      created_at, closure_reason_code, closure_reason_detail, requires_review,
+      ignored_nearby_event_ids_json, unassigned_nearby_event_ids_json
+    ) VALUES (?, ?, ?, 'manual', 'migration_duplicate_open_scope', ?, ?, ?, ?, ?, ?, 0, 'normal', ?,
+      'repair', ?, 1, '[]', '[]')
+  `);
+    for (const scope of duplicates) {
+        const rows = selectEpisodes.all(scope.project_id, scope.session_id, scope.source_agent_key, scope.thread_key);
+        for (const episode of rows.slice(1)) {
+            const eventIds = selectEventIds.all(episode.episode_id).map((row) => row.event_id);
+            const now = episode.updated_at;
+            sealEpisode.run(now, now, episode.episode_id);
+            insertReceipt.run(`migration-0029-${episode.episode_id}`, episode.episode_id, episode.project_id, JSON.stringify(eventIds), episode.start_seq ?? null, episode.end_seq ?? null, episode.topic_path ?? null, episode.episode_type, episode.importance, now, JSON.stringify({ reason: 'migration_duplicate_open_scope', keptOpenEpisodeId: rows[0].episode_id, duplicateScope: scope }));
+        }
+    }
+}

package/dist/episode/EpisodeAssembler.d.ts

@@ -1,7 +1,8 @@
 import type { MemoryEvent } from '../types/index.js';
-import { type TurnClassificationContext, type TurnRelationAdvisoryReviewer } from './TurnRelationClassifier.js';
+import { type TurnClassificationContext, type TurnRelationAdvisoryReviewer, type TurnRelationReviewStatus } from './TurnRelationClassifier.js';
 import type { EpisodeClosureReceipt, MemoryEpisode } from './EpisodeTypes.js';
 import { EpisodeStore } from './EpisodeStore.js';
+import { EpisodeBoundaryPolicy } from './EpisodeBoundaryPolicy.js';
 export interface EpisodeAssemblyResult {
     episode?: MemoryEpisode;
     assignedEventIds: string[];
@@ -9,6 +10,17 @@ export interface EpisodeAssemblyResult {
     ignoredEventIds: string[];
     closureReceipt?: EpisodeClosureReceipt;
     reopened: boolean;
+    boundaryTriggered?: boolean;
+    boundaryDetected?: boolean;
+    boundaryApplied?: boolean;
+    boundaryMode?: string;
+    boundaryDecisionId?: string;
+    boundaryGuardCodes?: string[];
+    boundaryAuditRecorded?: boolean;
+    boundaryAuditStatus?: 'disabled' | 'inserted' | 'duplicate' | 'failed' | 'not_applicable';
+    previousEpisodeId?: string;
+    reviewerRawResultStatus?: TurnRelationReviewStatus;
+    warnings?: string[];
 }
 export declare class EpisodeAssembler {
     private readonly store;
@@ -16,7 +28,8 @@ export declare class EpisodeAssembler {
     private readonly softReopenWindowMs;
     private readonly reviewer?;
     private readonly resolveTopicContext?;
-    constructor(store: EpisodeStore, resolveEvent?: ((eventId: string) => MemoryEvent | null | undefined) | undefined, softReopenWindowMs?: number, reviewer?: TurnRelationAdvisoryReviewer | undefined, resolveTopicContext?: ((primary: MemoryEvent, episode?: MemoryEpisode) => Partial<TurnClassificationContext>) | undefined);
+    private readonly boundaryPolicy;
+    constructor(store: EpisodeStore, resolveEvent?: ((eventId: string) => MemoryEvent | null | undefined) | undefined, softReopenWindowMs?: number, reviewer?: TurnRelationAdvisoryReviewer | undefined, resolveTopicContext?: ((primary: MemoryEvent, episode?: MemoryEpisode) => Partial<TurnClassificationContext>) | undefined, boundaryPolicy?: EpisodeBoundaryPolicy);
     appendTurn(events: MemoryEvent[], input: {
         projectId: string;
         sessionId: string;
@@ -25,6 +38,7 @@ export declare class EpisodeAssembler {
         now?: number;
         batchSeal?: boolean;
         forceBatchSeal?: boolean;
+        allowNonUserEpisodeStart?: boolean;
     }): EpisodeAssemblyResult;
     appendTurnAsync(events: MemoryEvent[], input: {
         projectId: string;
@@ -34,6 +48,7 @@ export declare class EpisodeAssembler {
         now?: number;
         batchSeal?: boolean;
         forceBatchSeal?: boolean;
+        allowNonUserEpisodeStart?: boolean;
     }): Promise<EpisodeAssemblyResult>;
     private appendTurnClassified;
     appendEvent(event: MemoryEvent, input: {
@@ -50,5 +65,8 @@ export declare class EpisodeAssembler {
     }): Promise<EpisodeAssemblyResult>;
     private classificationContext;
     private classifyPrimary;
+    private appendOrderedEvents;
+    private evaluateBoundary;
+    private recordBoundaryDecisionSafe;
 }
 //# sourceMappingURL=EpisodeAssembler.d.ts.map