cogmem 3.6.2

package/dist/entity/EntityGovernanceService.d.ts

@@ -0,0 +1,47 @@
+import Database from 'bun:sqlite';
+import type { GovernanceEvidenceRecord } from '../governance/MemoryGovernanceValidator.js';
+import { EntityStore } from '../store/EntityStore.js';
+export type EntityMergeCandidateStatus = 'pending' | 'approved' | 'rejected' | 'applied' | 'reverted';
+export interface EntityMergeCandidate {
+    candidateId: string;
+    projectId?: string;
+    sourceEntityId: string;
+    targetEntityId: string;
+    alias: string;
+    confidence: number;
+    status: EntityMergeCandidateStatus;
+    reviewReasons: string[];
+    evidenceEventIds: string[];
+    createdAt: number;
+    updatedAt: number;
+    version: number;
+}
+export interface ProposeEntityMergeInput {
+    projectId?: string;
+    sourceEntityId: string;
+    targetEntityId: string;
+    alias: string;
+    confidence: number;
+    evidenceEventIds: string[];
+    now?: number;
+}
+export declare class EntityGovernanceService {
+    private readonly db;
+    private readonly entities;
+    private readonly findEvidence;
+    constructor(db: Database, entities: EntityStore, findEvidence: (eventId: string) => GovernanceEvidenceRecord | undefined);
+    proposeMerge(input: ProposeEntityMergeInput): EntityMergeCandidate;
+    apply(candidateId: string, now?: number): EntityMergeCandidate;
+    revert(candidateId: string, now?: number): EntityMergeCandidate;
+    get(candidateId: string): EntityMergeCandidate | null;
+    list(options?: {
+        projectId?: string;
+        status?: EntityMergeCandidateStatus;
+        limit?: number;
+    }): EntityMergeCandidate[];
+    private requireEntity;
+    private requireCandidate;
+    private updateStatus;
+    private initializeSchema;
+}
+//# sourceMappingURL=EntityGovernanceService.d.ts.map

package/dist/entity/EntityGovernanceService.js

@@ -0,0 +1,215 @@
+import { createHash } from 'node:crypto';
+export class EntityGovernanceService {
+    db;
+    entities;
+    findEvidence;
+    constructor(db, entities, findEvidence) {
+        this.db = db;
+        this.entities = entities;
+        this.findEvidence = findEvidence;
+        this.initializeSchema();
+    }
+    proposeMerge(input) {
+        const now = input.now ?? Date.now();
+        const source = this.requireEntity(input.sourceEntityId);
+        const target = this.requireEntity(input.targetEntityId);
+        const reasons = [];
+        const evidence = input.evidenceEventIds.map((eventId) => this.findEvidence(eventId)).filter(Boolean);
+        if (source.entityId === target.entityId)
+            reasons.push('same_entity');
+        if (source.type !== target.type)
+            reasons.push('entity_type_mismatch');
+        if (projectIdOf(source) && input.projectId && projectIdOf(source) !== input.projectId)
+            reasons.push('project_boundary_violation');
+        if (projectIdOf(target) && input.projectId && projectIdOf(target) !== input.projectId)
+            reasons.push('project_boundary_violation');
+        if (evidence.length !== input.evidenceEventIds.length)
+            reasons.push('unknown_evidence');
+        if (evidence.some((item) => item.projectId && input.projectId && item.projectId !== input.projectId))
+            reasons.push('project_boundary_violation');
+        const hasUserEvidence = evidence.some((item) => item.role === 'user');
+        if (source.type === 'person' && !hasUserEvidence)
+            reasons.push('person_merge_requires_explicit_user_evidence');
+        const fatal = reasons.some((reason) => ['same_entity', 'entity_type_mismatch', 'project_boundary_violation', 'unknown_evidence'].includes(reason));
+        const threshold = source.type === 'person' ? 0.99 : 0.95;
+        const status = fatal
+            ? 'rejected'
+            : input.confidence >= threshold && (source.type !== 'person' || hasUserEvidence)
+                ? 'approved'
+                : input.confidence < 0.6
+                    ? 'rejected'
+                    : 'pending';
+        if (status === 'pending' && reasons.length === 0)
+            reasons.push('confidence_requires_review');
+        if (status === 'rejected' && reasons.length === 0)
+            reasons.push('confidence_below_minimum');
+        const candidateId = candidateIdFor(input);
+        this.db.prepare(`
+      INSERT INTO entity_merge_candidates (
+        candidate_id, project_id, source_entity_id, target_entity_id, alias, confidence,
+        status, review_reasons_json, evidence_event_ids_json, created_at, updated_at, version
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
+      ON CONFLICT(candidate_id) DO UPDATE SET
+        confidence = excluded.confidence,
+        status = excluded.status,
+        review_reasons_json = excluded.review_reasons_json,
+        evidence_event_ids_json = excluded.evidence_event_ids_json,
+        updated_at = excluded.updated_at,
+        version = entity_merge_candidates.version + 1
+    `).run(candidateId, input.projectId || null, source.entityId, target.entityId, input.alias, input.confidence, status, JSON.stringify(reasons), JSON.stringify(input.evidenceEventIds), now, now);
+        return this.get(candidateId);
+    }
+    apply(candidateId, now = Date.now()) {
+        const candidate = this.requireCandidate(candidateId);
+        if (candidate.status === 'applied')
+            return candidate;
+        if (candidate.status !== 'approved')
+            throw new Error(`Entity merge candidate is not approved: ${candidate.status}`);
+        const source = this.requireEntity(candidate.sourceEntityId);
+        const target = this.requireEntity(candidate.targetEntityId);
+        if (!source.canonicalEntityId || !target.canonicalEntityId)
+            throw new Error('Entity merge requires canonical entity ids.');
+        this.db.transaction(() => {
+            this.entities.addAlias(target.entityId, candidate.alias, now);
+            this.entities.redirectInstance({ sourceEntityId: source.entityId, targetCanonicalEntityId: target.canonicalEntityId, updatedAt: now });
+            this.db.prepare(`
+        INSERT INTO entity_resolution_log (
+          log_id, candidate_id, source_entity_id, target_entity_id, previous_canonical_entity_id,
+          previous_status, alias, action, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, 'merge', ?)
+      `).run(`elog:${candidateId}:merge`, candidateId, source.entityId, target.entityId, source.canonicalEntityId, source.status, candidate.alias, now);
+            this.updateStatus(candidateId, 'applied', now);
+        })();
+        return this.requireCandidate(candidateId);
+    }
+    revert(candidateId, now = Date.now()) {
+        const candidate = this.requireCandidate(candidateId);
+        if (candidate.status === 'reverted')
+            return candidate;
+        if (candidate.status !== 'applied')
+            throw new Error(`Entity merge candidate is not applied: ${candidate.status}`);
+        const log = this.db.prepare(`
+      SELECT * FROM entity_resolution_log WHERE candidate_id = ? AND action = 'merge'
+      ORDER BY created_at DESC LIMIT 1
+    `).get(candidateId);
+        if (!log)
+            throw new Error(`Missing entity merge audit log: ${candidateId}`);
+        this.db.transaction(() => {
+            this.entities.restoreInstance({
+                entityId: candidate.sourceEntityId,
+                canonicalEntityId: String(log.previous_canonical_entity_id),
+                status: String(log.previous_status),
+                updatedAt: now,
+            });
+            this.entities.removeAlias(candidate.targetEntityId, String(log.alias), now);
+            this.db.prepare(`
+        INSERT INTO entity_resolution_log (
+          log_id, candidate_id, source_entity_id, target_entity_id, previous_canonical_entity_id,
+          previous_status, alias, action, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, 'revert', ?)
+      `).run(`elog:${candidateId}:revert:${now}`, candidateId, candidate.sourceEntityId, candidate.targetEntityId, String(log.previous_canonical_entity_id), String(log.previous_status), String(log.alias), now);
+            this.updateStatus(candidateId, 'reverted', now);
+        })();
+        return this.requireCandidate(candidateId);
+    }
+    get(candidateId) {
+        const row = this.db.prepare(`SELECT * FROM entity_merge_candidates WHERE candidate_id = ?`).get(candidateId);
+        return row ? mapCandidate(row) : null;
+    }
+    list(options = {}) {
+        const clauses = [];
+        const params = [];
+        if (options.projectId) {
+            clauses.push('project_id = ?');
+            params.push(options.projectId);
+        }
+        if (options.status) {
+            clauses.push('status = ?');
+            params.push(options.status);
+        }
+        const where = clauses.length ? `WHERE ${clauses.join(' AND ')}` : '';
+        params.push(Math.max(1, Math.min(500, options.limit ?? 100)));
+        return this.db.prepare(`SELECT * FROM entity_merge_candidates ${where} ORDER BY updated_at DESC LIMIT ?`).all(...params)
+            .map(mapCandidate);
+    }
+    requireEntity(entityId) {
+        const entity = this.entities.findByEntityId(entityId);
+        if (!entity)
+            throw new Error(`Unknown entity: ${entityId}`);
+        return entity;
+    }
+    requireCandidate(candidateId) {
+        const candidate = this.get(candidateId);
+        if (!candidate)
+            throw new Error(`Unknown entity merge candidate: ${candidateId}`);
+        return candidate;
+    }
+    updateStatus(candidateId, status, now) {
+        this.db.prepare(`
+      UPDATE entity_merge_candidates SET status = ?, updated_at = ?, version = version + 1 WHERE candidate_id = ?
+    `).run(status, now, candidateId);
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS entity_merge_candidates (
+        candidate_id TEXT PRIMARY KEY,
+        project_id TEXT,
+        source_entity_id TEXT NOT NULL,
+        target_entity_id TEXT NOT NULL,
+        alias TEXT NOT NULL,
+        confidence REAL NOT NULL,
+        status TEXT NOT NULL,
+        review_reasons_json TEXT NOT NULL,
+        evidence_event_ids_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL,
+        version INTEGER NOT NULL DEFAULT 1
+      );
+      CREATE INDEX IF NOT EXISTS idx_entity_merge_candidates_project
+        ON entity_merge_candidates(project_id, status, updated_at DESC);
+      CREATE TABLE IF NOT EXISTS entity_resolution_log (
+        log_id TEXT PRIMARY KEY,
+        candidate_id TEXT NOT NULL,
+        source_entity_id TEXT NOT NULL,
+        target_entity_id TEXT NOT NULL,
+        previous_canonical_entity_id TEXT NOT NULL,
+        previous_status TEXT NOT NULL,
+        alias TEXT NOT NULL,
+        action TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      );
+    `);
+    }
+}
+function candidateIdFor(input) {
+    const value = [input.projectId || '', input.sourceEntityId, input.targetEntityId, input.alias.toLowerCase()].join('\0');
+    return `emerge-${createHash('sha256').update(value).digest('hex').slice(0, 24)}`;
+}
+function projectIdOf(entity) {
+    return typeof entity.metadata?.projectId === 'string' ? entity.metadata.projectId : undefined;
+}
+function mapCandidate(row) {
+    return {
+        candidateId: String(row.candidate_id),
+        projectId: row.project_id ? String(row.project_id) : undefined,
+        sourceEntityId: String(row.source_entity_id),
+        targetEntityId: String(row.target_entity_id),
+        alias: String(row.alias),
+        confidence: Number(row.confidence),
+        status: String(row.status),
+        reviewReasons: parseArray(row.review_reasons_json),
+        evidenceEventIds: parseArray(row.evidence_event_ids_json),
+        createdAt: Number(row.created_at),
+        updatedAt: Number(row.updated_at),
+        version: Number(row.version),
+    };
+}
+function parseArray(value) {
+    try {
+        const parsed = JSON.parse(String(value || '[]'));
+        return Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/entity/index.d.ts

@@ -0,0 +1,3 @@
+export { EntityGovernanceService } from './EntityGovernanceService.js';
+export type { EntityMergeCandidate, EntityMergeCandidateStatus, ProposeEntityMergeInput, } from './EntityGovernanceService.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/entity/index.js

@@ -0,0 +1 @@
+export { EntityGovernanceService } from './EntityGovernanceService.js';

package/dist/episode/CogmemBlockStripper.d.ts

@@ -0,0 +1,11 @@
+import type { MemoryEvent } from '../types/index.js';
+export declare class CogmemBlockStripper {
+    private readonly maxBlockChars;
+    constructor(options?: {
+        maxBlockChars?: number;
+    });
+    strip(value: string): string;
+}
+export declare function stripCogmemBlocks(value: string): string;
+export declare function eventTextForMemory(event: Pick<MemoryEvent, 'payload'>): string;
+//# sourceMappingURL=CogmemBlockStripper.d.ts.map

package/dist/episode/CogmemBlockStripper.js

@@ -0,0 +1,58 @@
+const CONTROL_BLOCKS = new Set([
+    'COGMEM_RECALL_CONTEXT', 'COGMEM_MEMORY_ATLAS', 'COGMEM_TURN_BRIDGE', 'COGMEM_SESSION_STATE', 'COGMEM_STRATEGY_CONTEXT',
+]);
+export class CogmemBlockStripper {
+    maxBlockChars;
+    constructor(options = {}) {
+        this.maxBlockChars = Math.max(64, Math.min(options.maxBlockChars ?? 256_000, 1_000_000));
+    }
+    strip(value) {
+        const text = String(value || '');
+        const token = /<\/?([A-Z0-9_]+)\b[^>]*>/giu;
+        const stack = [];
+        let result = '';
+        let cursor = 0;
+        let hiddenChars = 0;
+        for (const match of text.matchAll(token)) {
+            const index = match.index ?? 0;
+            const name = String(match[1] || '').toUpperCase();
+            if (!CONTROL_BLOCKS.has(name))
+                continue;
+            const closing = match[0].startsWith('</');
+            if (stack.length === 0)
+                result += text.slice(cursor, index);
+            else
+                hiddenChars += index - cursor;
+            if (closing) {
+                const position = stack.lastIndexOf(name);
+                if (position >= 0)
+                    stack.splice(position);
+            }
+            else {
+                stack.push(name);
+            }
+            cursor = index + match[0].length;
+            if (hiddenChars > this.maxBlockChars && stack.length) {
+                cursor = text.length;
+                break;
+            }
+        }
+        if (stack.length === 0 && cursor < text.length)
+            result += text.slice(cursor);
+        return result.replace(/\s+/g, ' ').trim();
+    }
+}
+const DEFAULT_STRIPPER = new CogmemBlockStripper();
+export function stripCogmemBlocks(value) {
+    return DEFAULT_STRIPPER.strip(value);
+}
+export function eventTextForMemory(event) {
+    const payload = event.payload;
+    if (!payload || typeof payload !== 'object')
+        return '';
+    for (const field of ['text', 'content', 'output', 'title', 'summary']) {
+        if (typeof payload[field] === 'string')
+            return stripCogmemBlocks(payload[field]);
+    }
+    return '';
+}

package/dist/episode/CorrectionResolver.d.ts

@@ -0,0 +1,30 @@
+export interface CorrectionTarget {
+    beliefId: string;
+    canonicalKey?: string;
+    statement?: string;
+    projectId?: string;
+}
+export interface CorrectionResolution {
+    status: 'resolved' | 'needs_review';
+    target?: CorrectionTarget;
+    candidates: CorrectionTarget[];
+    reason: string;
+}
+export declare class CorrectionResolver {
+    private readonly searchActiveBeliefs;
+    constructor(searchActiveBeliefs: (input: {
+        projectId: string;
+        query: string;
+        topicPath?: string;
+        entities?: string[];
+        limit: number;
+    }) => CorrectionTarget[]);
+    resolve(input: {
+        projectId: string;
+        query: string;
+        claimKey?: string;
+        topicPath?: string;
+        entities?: string[];
+    }): CorrectionResolution;
+}
+//# sourceMappingURL=CorrectionResolver.d.ts.map

package/dist/episode/CorrectionResolver.js

@@ -0,0 +1,17 @@
+export class CorrectionResolver {
+    searchActiveBeliefs;
+    constructor(searchActiveBeliefs) {
+        this.searchActiveBeliefs = searchActiveBeliefs;
+    }
+    resolve(input) {
+        const candidates = this.searchActiveBeliefs({
+            projectId: input.projectId, query: input.claimKey || input.query, topicPath: input.topicPath,
+            entities: input.entities, limit: 5,
+        }).filter((candidate) => !candidate.projectId || candidate.projectId === input.projectId);
+        const exact = input.claimKey ? candidates.filter((candidate) => candidate.canonicalKey === input.claimKey) : [];
+        const selected = exact.length === 1 ? exact[0] : candidates.length === 1 ? candidates[0] : undefined;
+        return selected
+            ? { status: 'resolved', target: selected, candidates, reason: exact.length === 1 ? 'canonical_key_match' : 'single_bounded_semantic_match' }
+            : { status: 'needs_review', candidates, reason: candidates.length ? 'ambiguous_correction_target' : 'orphan_correction' };
+    }
+}

package/dist/episode/EpisodeAssembler.d.ts

@@ -0,0 +1,54 @@
+import type { MemoryEvent } from '../types/index.js';
+import { type TurnClassificationContext, type TurnRelationAdvisoryReviewer } from './TurnRelationClassifier.js';
+import type { EpisodeClosureReceipt, MemoryEpisode } from './EpisodeTypes.js';
+import { EpisodeStore } from './EpisodeStore.js';
+export interface EpisodeAssemblyResult {
+    episode?: MemoryEpisode;
+    assignedEventIds: string[];
+    unassignedEventIds: string[];
+    ignoredEventIds: string[];
+    closureReceipt?: EpisodeClosureReceipt;
+    reopened: boolean;
+}
+export declare class EpisodeAssembler {
+    private readonly store;
+    private readonly resolveEvent?;
+    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);
+    appendTurn(events: MemoryEvent[], input: {
+        projectId: string;
+        sessionId: string;
+        sourceAgent?: string;
+        conversationThreadId?: string;
+        now?: number;
+        batchSeal?: boolean;
+        forceBatchSeal?: boolean;
+    }): EpisodeAssemblyResult;
+    appendTurnAsync(events: MemoryEvent[], input: {
+        projectId: string;
+        sessionId: string;
+        sourceAgent?: string;
+        conversationThreadId?: string;
+        now?: number;
+        batchSeal?: boolean;
+        forceBatchSeal?: boolean;
+    }): Promise<EpisodeAssemblyResult>;
+    private appendTurnClassified;
+    appendEvent(event: MemoryEvent, input: {
+        projectId: string;
+        sessionId: string;
+        sourceAgent?: string;
+        now?: number;
+    }): EpisodeAssemblyResult;
+    appendEventAsync(event: MemoryEvent, input: {
+        projectId: string;
+        sessionId: string;
+        sourceAgent?: string;
+        now?: number;
+    }): Promise<EpisodeAssemblyResult>;
+    private classificationContext;
+    private classifyPrimary;
+}
+//# sourceMappingURL=EpisodeAssembler.d.ts.map

package/dist/episode/EpisodeAssembler.js

@@ -0,0 +1,203 @@
+import { eventTextForMemory } from './CogmemBlockStripper.js';
+import { classifyAssistantRelation, classifyTurnRelation, classifyTurnRelationHybrid } from './TurnRelationClassifier.js';
+export class EpisodeAssembler {
+    store;
+    resolveEvent;
+    softReopenWindowMs;
+    reviewer;
+    resolveTopicContext;
+    constructor(store, resolveEvent, softReopenWindowMs = 30 * 60_000, reviewer, resolveTopicContext) {
+        this.store = store;
+        this.resolveEvent = resolveEvent;
+        this.softReopenWindowMs = softReopenWindowMs;
+        this.reviewer = reviewer;
+        this.resolveTopicContext = resolveTopicContext;
+    }
+    appendTurn(events, input) {
+        return this.appendTurnClassified(events, input);
+    }
+    async appendTurnAsync(events, input) {
+        const ordered = [...events].sort((a, b) => (a.eventOrdinal || 0) - (b.eventOrdinal || 0));
+        if (!ordered.length)
+            return { assignedEventIds: [], unassignedEventIds: [], ignoredEventIds: [], reopened: false };
+        const primary = ordered.find((event) => event.role === 'user') || ordered[0];
+        const threadId = input.conversationThreadId || primary.threadId || input.sessionId;
+        const episode = this.store.findActiveEpisode(input.projectId, input.sessionId, input.sourceAgent, threadId);
+        const decision = primary.role === 'user'
+            ? await classifyTurnRelationHybrid(this.classificationContext(primary, episode, ordered), this.reviewer)
+            : this.classifyPrimary(primary, episode, ordered);
+        return this.appendTurnClassified(ordered, input, decision);
+    }
+    appendTurnClassified(events, input, decisionOverride) {
+        const ordered = [...events].sort((a, b) => (a.eventOrdinal || 0) - (b.eventOrdinal || 0));
+        if (!ordered.length)
+            return { assignedEventIds: [], unassignedEventIds: [], ignoredEventIds: [], reopened: false };
+        const mismatched = ordered.find((event) => event.projectId && event.projectId !== input.projectId);
+        if (mismatched)
+            throw new Error(`episode_project_mismatch:${mismatched.eventId}`);
+        const primary = ordered.find((event) => event.role === 'user') || ordered[0];
+        const conversationThreadId = input.conversationThreadId || primary.threadId || input.sessionId;
+        let episode = this.store.findActiveEpisode(input.projectId, input.sessionId, input.sourceAgent, conversationThreadId);
+        let legacyLinkedEpisodeId;
+        if (episode && !episode.sourceAgent && !episode.conversationThreadId) {
+            const legacyEpisodeId = episode.episodeId;
+            episode = this.store.claimLegacyEpisodeScope(legacyEpisodeId, input.sourceAgent, conversationThreadId);
+            if (!episode)
+                legacyLinkedEpisodeId = legacyEpisodeId;
+        }
+        const decision = decisionOverride ?? this.classifyPrimary(primary, episode, ordered);
+        let reopened = false;
+        let closureReceipt;
+        let linkedEpisodeId = legacyLinkedEpisodeId;
+        const now = input.now ?? Math.max(...ordered.map((event) => event.occurredAt || Date.now()));
+        if (decision.relation === 'noise') {
+            for (const event of ordered) {
+                this.store.markEventDisposition({
+                    eventId: event.eventId, projectId: input.projectId, disposition: 'ignored', reason: 'deterministic_noise', now,
+                });
+            }
+            return { assignedEventIds: [], unassignedEventIds: [], ignoredEventIds: ordered.map((event) => event.eventId), reopened: false };
+        }
+        if (episode?.status === 'open' && ['hard_topic_switch', 'starts_new_topic', 'switches_topic'].includes(decision.relation)) {
+            closureReceipt = this.store.sealEpisode(episode.episodeId, {
+                mode: 'hard', reason: 'explicit_topic_switch', reasonCode: 'topic_switch', now,
+            });
+            episode = undefined;
+        }
+        if (episode?.status === 'open' && decision.relation === 'ambiguous_shift') {
+            linkedEpisodeId = episode.episodeId;
+            closureReceipt = this.store.sealEpisode(episode.episodeId, {
+                mode: 'soft', reason: 'ambiguous_topic_shift', reasonCode: 'topic_switch', requiresReview: true, now,
+            });
+            episode = undefined;
+        }
+        if (episode?.status === 'soft_sealed') {
+            const mayReopen = new Set([
+                'continues_previous', 'clarifies_previous', 'corrects_previous', 'returns_to_old_topic',
+                'answers_assistant_question', 'accepts_assistant_proposal', 'rejects_assistant_proposal', 'confirms_assistant_fact',
+            ]).has(decision.relation)
+                && now - (episode.sealedAt || episode.updatedAt) <= this.softReopenWindowMs;
+            if (mayReopen) {
+                episode = this.store.reopenSoftEpisode(episode.episodeId, now);
+                reopened = true;
+            }
+            else {
+                episode = undefined;
+            }
+        }
+        if (!episode) {
+            episode = this.store.createEpisode({
+                projectId: input.projectId, sessionId: input.sessionId, sourceAgent: input.sourceAgent,
+                conversationThreadId,
+                topicPath: decision.topicPath,
+                episodeType: decision.episodeType, importance: decision.importance,
+                eventId: primary.eventId, globalSeq: primary.globalSeq, occurredAt: primary.occurredAt || now,
+                episodeTags: [decision.episodeType, ...decision.candidateTypes],
+                candidateTypes: decision.candidateTypes,
+                importanceSignals: decision.importanceSignals,
+                importanceReason: decision.rationale,
+                linkedEpisodeId,
+            });
+        }
+        const assignedEventIds = [];
+        for (const event of ordered) {
+            const existing = this.store.getEventLink(event.eventId);
+            if (existing) {
+                assignedEventIds.push(event.eventId);
+                continue;
+            }
+            const relation = event.role === 'assistant' || event.role === 'agent'
+                ? classifyAssistantRelation(eventText(event), 'assistant')
+                : event.role === 'tool'
+                    ? 'tool_result_context'
+                    : decision.relation;
+            this.store.appendEvent({
+                episodeId: episode.episodeId, eventId: event.eventId, relation,
+                confidence: event.eventId === primary.eventId ? decision.confidence : 0.9,
+                globalSeq: event.globalSeq, occurredAt: event.occurredAt || now,
+                episodeType: decision.episodeType, importance: decision.importance,
+                summaryText: summaryLine(event),
+                candidateTypes: decision.candidateTypes,
+                importanceSignals: decision.importanceSignals,
+                importanceReason: decision.rationale,
+            });
+            assignedEventIds.push(event.eventId);
+        }
+        if (input.batchSeal) {
+            const confidence = averageConfidence(this.store.listEventLinks(episode.episodeId));
+            const requiresReview = !input.forceBatchSeal && confidence < 0.6;
+            closureReceipt = this.store.sealEpisode(episode.episodeId, {
+                mode: requiresReview ? 'soft' : 'batch', reason: requiresReview ? 'batch_low_confidence_review' : 'batch_boundary',
+                reasonCode: 'batch_boundary', requiresReview, now,
+            });
+        }
+        else if (decision.relation === 'closes_episode') {
+            closureReceipt = this.store.sealEpisode(episode.episodeId, {
+                mode: 'hard', reason: 'explicit_user_closure', reasonCode: 'explicit_user_closure', now,
+            });
+        }
+        return { episode: this.store.getEpisode(episode.episodeId), assignedEventIds, unassignedEventIds: [], ignoredEventIds: [], closureReceipt, reopened };
+    }
+    appendEvent(event, input) {
+        const active = this.store.findActiveEpisode(input.projectId, input.sessionId, input.sourceAgent, event.threadId || input.sessionId);
+        if (!active && event.role !== 'user') {
+            return { assignedEventIds: [], unassignedEventIds: [event.eventId], ignoredEventIds: [], reopened: false };
+        }
+        return this.appendTurn([event], input);
+    }
+    async appendEventAsync(event, input) {
+        const active = this.store.findActiveEpisode(input.projectId, input.sessionId, input.sourceAgent, event.threadId || input.sessionId);
+        if (!active && event.role !== 'user') {
+            return { assignedEventIds: [], unassignedEventIds: [event.eventId], ignoredEventIds: [], reopened: false };
+        }
+        return this.appendTurnAsync([event], input);
+    }
+    classificationContext(primary, episode, currentEvents = []) {
+        const context = {
+            currentUserText: eventText(primary),
+            activeEpisodeSummary: episode?.semanticSummary?.userPosition || episode?.summary,
+            activeEpisodeTopicPath: episode?.topicPath,
+            currentAssistantText: currentEvents.find((event) => event.role === 'assistant' || event.role === 'agent')
+                ? eventText(currentEvents.find((event) => event.role === 'assistant' || event.role === 'agent'))
+                : undefined,
+        };
+        Object.assign(context, this.resolveTopicContext?.(primary, episode) || {});
+        if (!episode || !this.resolveEvent)
+            return context;
+        const prior = this.store.listEventLinks(episode.episodeId)
+            .map((link) => this.resolveEvent(link.eventId))
+            .filter((event) => Boolean(event));
+        const previousUser = [...prior].reverse().find((event) => event.role === 'user');
+        const previousAssistant = [...prior].reverse().find((event) => event.role === 'assistant' || event.role === 'agent');
+        context.previousUserText = previousUser ? eventText(previousUser) : undefined;
+        context.previousAssistantText = previousAssistant ? eventText(previousAssistant) : undefined;
+        context.recentRelations = this.store.listEventLinks(episode.episodeId).slice(-5).map((link) => link.relation);
+        return context;
+    }
+    classifyPrimary(primary, episode, currentEvents = []) {
+        if (primary.role === 'user')
+            return classifyTurnRelation(this.classificationContext(primary, episode, currentEvents));
+        return {
+            relation: classifyAssistantRelation(eventText(primary), primary.role || 'assistant'),
+            confidence: 0.9,
+            signals: ['non_user_context_only'],
+            needsLlmReview: false,
+            candidateTypes: [],
+            closureCandidate: false,
+            episodeType: 'discussion',
+            importance: 0.3,
+            importanceSignals: ['non_user_context_only'],
+            rationale: 'non_user_event_requires_later_user_evidence',
+        };
+    }
+}
+function eventText(event) {
+    return eventTextForMemory(event);
+}
+function summaryLine(event) {
+    const text = eventText(event).replace(/\s+/g, ' ').trim().slice(0, 240);
+    return `${event.role || event.rawEventType || 'event'}: ${text}`;
+}
+function averageConfidence(links) {
+    return links.length ? links.reduce((total, link) => total + link.confidence, 0) / links.length : 0;
+}

package/dist/episode/EpisodeImportIdentity.d.ts

@@ -0,0 +1,7 @@
+export interface StableImportIdentityInput {
+    role: string;
+    text: string;
+    timestamp?: number;
+}
+export declare function createStableImportIdentityFactory(sourceAgent: string, sourceSessionId: string): (input: StableImportIdentityInput) => string;
+//# sourceMappingURL=EpisodeImportIdentity.d.ts.map