claude-memory-layer 1.0.0

package/dist/core/index.js

@@ -0,0 +1,4408 @@
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// src/core/types.ts
+import { z } from "zod";
+var EventTypeSchema = z.enum([
+  "user_prompt",
+  "agent_response",
+  "session_summary",
+  "tool_observation"
+]);
+var MemoryEventSchema = z.object({
+  id: z.string().uuid(),
+  eventType: EventTypeSchema,
+  sessionId: z.string(),
+  timestamp: z.date(),
+  content: z.string(),
+  canonicalKey: z.string(),
+  dedupeKey: z.string(),
+  metadata: z.record(z.unknown()).optional()
+});
+var MemoryEventInputSchema = MemoryEventSchema.omit({
+  id: true,
+  dedupeKey: true,
+  canonicalKey: true
+});
+var SessionSchema = z.object({
+  id: z.string(),
+  startedAt: z.date(),
+  endedAt: z.date().optional(),
+  projectPath: z.string().optional(),
+  summary: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+var InsightTypeSchema = z.enum([
+  "preference",
+  "pattern",
+  "expertise"
+]);
+var InsightSchema = z.object({
+  id: z.string().uuid(),
+  insightType: InsightTypeSchema,
+  content: z.string(),
+  canonicalKey: z.string(),
+  confidence: z.number().min(0).max(1),
+  sourceEvents: z.array(z.string().uuid()),
+  createdAt: z.date(),
+  lastUpdated: z.date()
+});
+var MemoryMatchSchema = z.object({
+  event: MemoryEventSchema,
+  score: z.number().min(0).max(1),
+  relevanceReason: z.string().optional()
+});
+var MatchConfidenceSchema = z.enum(["high", "suggested", "none"]);
+var MatchResultSchema = z.object({
+  match: MemoryMatchSchema.nullable(),
+  confidence: MatchConfidenceSchema,
+  gap: z.number().optional(),
+  alternatives: z.array(MemoryMatchSchema).optional()
+});
+var MATCH_THRESHOLDS = {
+  minCombinedScore: 0.92,
+  minGap: 0.03,
+  suggestionThreshold: 0.75
+};
+var MemoryLevelSchema = z.enum(["L0", "L1", "L2", "L3", "L4"]);
+var GraduationResultSchema = z.object({
+  eventId: z.string().uuid(),
+  fromLevel: MemoryLevelSchema,
+  toLevel: MemoryLevelSchema,
+  success: z.boolean(),
+  reason: z.string().optional()
+});
+var EvidenceSpanSchema = z.object({
+  start: z.number().int().nonnegative(),
+  end: z.number().int().positive(),
+  confidence: z.number().min(0).max(1),
+  matchType: z.enum(["exact", "fuzzy", "none"]),
+  originalQuote: z.string(),
+  alignedText: z.string()
+});
+var ConfigSchema = z.object({
+  storage: z.object({
+    path: z.string().default("~/.claude-code/memory"),
+    maxSizeMB: z.number().default(500)
+  }).default({}),
+  embedding: z.object({
+    provider: z.enum(["local", "openai"]).default("local"),
+    model: z.string().default("Xenova/all-MiniLM-L6-v2"),
+    openaiModel: z.string().default("text-embedding-3-small"),
+    batchSize: z.number().default(32)
+  }).default({}),
+  retrieval: z.object({
+    topK: z.number().default(5),
+    minScore: z.number().default(0.7),
+    maxTokens: z.number().default(2e3)
+  }).default({}),
+  matching: z.object({
+    minCombinedScore: z.number().default(0.92),
+    minGap: z.number().default(0.03),
+    suggestionThreshold: z.number().default(0.75),
+    weights: z.object({
+      semanticSimilarity: z.number().default(0.4),
+      ftsScore: z.number().default(0.25),
+      recencyBonus: z.number().default(0.2),
+      statusWeight: z.number().default(0.15)
+    }).default({})
+  }).default({}),
+  privacy: z.object({
+    excludePatterns: z.array(z.string()).default(["password", "secret", "api_key", "token", "bearer"]),
+    anonymize: z.boolean().default(false),
+    privateTags: z.object({
+      enabled: z.boolean().default(true),
+      marker: z.enum(["[PRIVATE]", "[REDACTED]", ""]).default("[PRIVATE]"),
+      preserveLineCount: z.boolean().default(false),
+      supportedFormats: z.array(z.enum(["xml", "bracket", "comment"])).default(["xml"])
+    }).default({})
+  }).default({}),
+  toolObservation: z.object({
+    enabled: z.boolean().default(true),
+    excludedTools: z.array(z.string()).default(["TodoWrite", "TodoRead"]),
+    maxOutputLength: z.number().default(1e4),
+    maxOutputLines: z.number().default(100),
+    storeOnlyOnSuccess: z.boolean().default(false)
+  }).default({}),
+  features: z.object({
+    autoSave: z.boolean().default(true),
+    sessionSummary: z.boolean().default(true),
+    insightExtraction: z.boolean().default(true),
+    crossProjectLearning: z.boolean().default(false),
+    singleWriterMode: z.boolean().default(true)
+  }).default({}),
+  mode: z.enum(["session", "endless"]).default("session"),
+  endless: z.object({
+    enabled: z.boolean().default(false),
+    workingSet: z.object({
+      maxEvents: z.number().default(100),
+      timeWindowHours: z.number().default(24),
+      minRelevanceScore: z.number().default(0.5)
+    }).default({}),
+    consolidation: z.object({
+      triggerIntervalMs: z.number().default(36e5),
+      triggerEventCount: z.number().default(100),
+      triggerIdleMs: z.number().default(18e5),
+      useLLMSummarization: z.boolean().default(false)
+    }).default({}),
+    continuity: z.object({
+      minScoreForSeamless: z.number().default(0.7),
+      topicDecayHours: z.number().default(48)
+    }).default({})
+  }).optional()
+});
+var ToolMetadataSchema = z.object({
+  filePath: z.string().optional(),
+  fileType: z.string().optional(),
+  lineCount: z.number().optional(),
+  command: z.string().optional(),
+  exitCode: z.number().optional(),
+  pattern: z.string().optional(),
+  matchCount: z.number().optional(),
+  url: z.string().optional(),
+  statusCode: z.number().optional()
+});
+var ToolObservationPayloadSchema = z.object({
+  toolName: z.string(),
+  toolInput: z.record(z.unknown()),
+  toolOutput: z.string(),
+  durationMs: z.number(),
+  success: z.boolean(),
+  errorMessage: z.string().optional(),
+  metadata: ToolMetadataSchema.optional()
+});
+var EntityTypeSchema = z.enum(["task", "condition", "artifact"]);
+var TaskStatusSchema = z.enum([
+  "pending",
+  "in_progress",
+  "blocked",
+  "done",
+  "cancelled"
+]);
+var TaskPrioritySchema = z.enum(["low", "medium", "high", "critical"]);
+var EntityStageSchema = z.enum([
+  "raw",
+  "working",
+  "candidate",
+  "verified",
+  "certified"
+]);
+var EntityStatusSchema = z.enum([
+  "active",
+  "contested",
+  "deprecated",
+  "superseded"
+]);
+var EntitySchema = z.object({
+  entityId: z.string(),
+  entityType: EntityTypeSchema,
+  canonicalKey: z.string(),
+  title: z.string(),
+  stage: EntityStageSchema,
+  status: EntityStatusSchema,
+  currentJson: z.record(z.unknown()),
+  titleNorm: z.string().optional(),
+  searchText: z.string().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var TaskCurrentJsonSchema = z.object({
+  status: TaskStatusSchema,
+  priority: TaskPrioritySchema.optional(),
+  blockers: z.array(z.string()).optional(),
+  blockerSuggestions: z.array(z.string()).optional(),
+  description: z.string().optional(),
+  project: z.string().optional()
+});
+var EntityAliasSchema = z.object({
+  entityType: EntityTypeSchema,
+  canonicalKey: z.string(),
+  entityId: z.string(),
+  isPrimary: z.boolean()
+});
+var NodeTypeSchema = z.enum(["entry", "entity", "event"]);
+var RelationTypeSchema = z.enum([
+  "evidence_of",
+  "blocked_by",
+  "blocked_by_suggested",
+  "resolves_to",
+  "derived_from",
+  "supersedes",
+  "source_of"
+]);
+var EdgeSchema = z.object({
+  edgeId: z.string(),
+  srcType: NodeTypeSchema,
+  srcId: z.string(),
+  relType: RelationTypeSchema,
+  dstType: NodeTypeSchema,
+  dstId: z.string(),
+  metaJson: z.record(z.unknown()).optional(),
+  createdAt: z.date()
+});
+var TaskEventTypeSchema = z.enum([
+  "task_created",
+  "task_status_changed",
+  "task_priority_changed",
+  "task_blockers_set",
+  "task_transition_rejected",
+  "condition_declared",
+  "artifact_declared",
+  "condition_resolved_to"
+]);
+var BlockerModeSchema = z.enum(["replace", "suggest"]);
+var BlockerKindSchema = z.enum(["task", "condition", "artifact"]);
+var BlockerRefSchema = z.object({
+  kind: BlockerKindSchema,
+  entityId: z.string(),
+  rawText: z.string().optional(),
+  confidence: z.number().min(0).max(1).optional(),
+  candidates: z.array(z.string()).optional()
+});
+var TaskCreatedPayloadSchema = z.object({
+  taskId: z.string(),
+  title: z.string(),
+  canonicalKey: z.string(),
+  initialStatus: TaskStatusSchema,
+  priority: TaskPrioritySchema.optional(),
+  description: z.string().optional(),
+  project: z.string().optional()
+});
+var TaskStatusChangedPayloadSchema = z.object({
+  taskId: z.string(),
+  fromStatus: TaskStatusSchema,
+  toStatus: TaskStatusSchema,
+  reason: z.string().optional()
+});
+var TaskBlockersSetPayloadSchema = z.object({
+  taskId: z.string(),
+  mode: BlockerModeSchema,
+  blockers: z.array(BlockerRefSchema),
+  sourceEntryId: z.string().optional()
+});
+var EntryTypeSchema = z.enum([
+  "fact",
+  "decision",
+  "insight",
+  "task_note",
+  "reference",
+  "preference",
+  "pattern"
+]);
+var EntrySchema = z.object({
+  entryId: z.string(),
+  createdTs: z.date(),
+  entryType: EntryTypeSchema,
+  title: z.string(),
+  contentJson: z.record(z.unknown()),
+  stage: EntityStageSchema,
+  status: EntityStatusSchema,
+  supersededBy: z.string().optional(),
+  buildId: z.string().optional(),
+  evidenceJson: z.record(z.unknown()).optional(),
+  canonicalKey: z.string()
+});
+var ExtractedEvidenceSchema = z.object({
+  messageIndex: z.number().int().nonnegative(),
+  quote: z.string()
+});
+var AlignedEvidenceSchema = z.object({
+  messageIndex: z.number().int().nonnegative(),
+  quote: z.string(),
+  spanStart: z.number().int().nonnegative(),
+  spanEnd: z.number().int().positive(),
+  quoteHash: z.string(),
+  confidence: z.number().min(0).max(1),
+  matchMethod: z.enum(["exact", "normalized", "fuzzy"])
+});
+var FailedEvidenceSchema = z.object({
+  messageIndex: z.number().int().nonnegative(),
+  quote: z.string(),
+  failureReason: z.enum(["not_found", "below_threshold", "ambiguous", "empty_quote", "invalid_index"])
+});
+var EvidenceAlignResultSchema = z.discriminatedUnion("aligned", [
+  z.object({ aligned: z.literal(true), evidence: AlignedEvidenceSchema }),
+  z.object({ aligned: z.literal(false), evidence: FailedEvidenceSchema })
+]);
+var OutboxStatusSchema = z.enum(["pending", "processing", "done", "failed"]);
+var OutboxItemKindSchema = z.enum(["entry", "task_title", "event"]);
+var OutboxJobSchema = z.object({
+  jobId: z.string(),
+  itemKind: OutboxItemKindSchema,
+  itemId: z.string(),
+  embeddingVersion: z.string(),
+  status: OutboxStatusSchema,
+  retryCount: z.number().int().nonnegative(),
+  error: z.string().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+var VALID_OUTBOX_TRANSITIONS = [
+  { from: "pending", to: "processing" },
+  { from: "processing", to: "done" },
+  { from: "processing", to: "failed" },
+  { from: "failed", to: "pending" }
+];
+var BuildRunSchema = z.object({
+  buildId: z.string(),
+  startedAt: z.date(),
+  finishedAt: z.date().optional(),
+  extractorModel: z.string(),
+  extractorPromptHash: z.string(),
+  embedderModel: z.string(),
+  embeddingVersion: z.string(),
+  idrisVersion: z.string(),
+  schemaVersion: z.string(),
+  status: z.enum(["running", "success", "failed"]),
+  error: z.string().optional()
+});
+var PipelineMetricSchema = z.object({
+  id: z.string(),
+  ts: z.date(),
+  stage: z.string(),
+  latencyMs: z.number(),
+  success: z.boolean(),
+  error: z.string().optional(),
+  sessionId: z.string().optional()
+});
+var SearchIndexItemSchema = z.object({
+  id: z.string(),
+  summary: z.string().max(100),
+  score: z.number(),
+  type: z.enum(["user_prompt", "agent_response", "session_summary", "tool_observation"]),
+  timestamp: z.date(),
+  sessionId: z.string()
+});
+var TimelineItemSchema = z.object({
+  id: z.string(),
+  timestamp: z.date(),
+  type: z.enum(["user_prompt", "agent_response", "session_summary", "tool_observation"]),
+  preview: z.string().max(200),
+  isTarget: z.boolean()
+});
+var FullDetailSchema = z.object({
+  id: z.string(),
+  content: z.string(),
+  type: z.enum(["user_prompt", "agent_response", "session_summary", "tool_observation"]),
+  timestamp: z.date(),
+  sessionId: z.string(),
+  citationId: z.string().optional(),
+  metadata: z.object({
+    tokenCount: z.number(),
+    hasCode: z.boolean(),
+    files: z.array(z.string()).optional(),
+    tools: z.array(z.string()).optional()
+  })
+});
+var ProgressiveSearchResultSchema = z.object({
+  index: z.array(SearchIndexItemSchema),
+  timeline: z.array(TimelineItemSchema).optional(),
+  details: z.array(FullDetailSchema).optional(),
+  meta: z.object({
+    totalMatches: z.number(),
+    expandedCount: z.number(),
+    estimatedTokens: z.number(),
+    expansionReason: z.string().optional()
+  })
+});
+var ProgressiveDisclosureConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  layer1: z.object({
+    topK: z.number().default(10),
+    minScore: z.number().default(0.7)
+  }).default({}),
+  autoExpand: z.object({
+    enabled: z.boolean().default(true),
+    highConfidenceThreshold: z.number().default(0.92),
+    scoreGapThreshold: z.number().default(0.1),
+    maxAutoExpandCount: z.number().default(3)
+  }).default({}),
+  tokenBudget: z.object({
+    maxTotalTokens: z.number().default(2e3),
+    layer1PerItem: z.number().default(50),
+    layer2PerItem: z.number().default(40),
+    layer3PerItem: z.number().default(500)
+  }).default({})
+});
+var CitationSchema = z.object({
+  citationId: z.string().length(6),
+  eventId: z.string(),
+  createdAt: z.date()
+});
+var CitationUsageSchema = z.object({
+  usageId: z.string(),
+  citationId: z.string(),
+  sessionId: z.string(),
+  usedAt: z.date(),
+  context: z.string().optional()
+});
+var MemoryModeSchema = z.enum(["session", "endless"]);
+var EndlessModeConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  workingSet: z.object({
+    maxEvents: z.number().default(100),
+    timeWindowHours: z.number().default(24),
+    minRelevanceScore: z.number().default(0.5)
+  }).default({}),
+  consolidation: z.object({
+    triggerIntervalMs: z.number().default(36e5),
+    // 1 hour
+    triggerEventCount: z.number().default(100),
+    triggerIdleMs: z.number().default(18e5),
+    // 30 minutes
+    useLLMSummarization: z.boolean().default(false)
+  }).default({}),
+  continuity: z.object({
+    minScoreForSeamless: z.number().default(0.7),
+    topicDecayHours: z.number().default(48)
+  }).default({})
+});
+var WorkingSetItemSchema = z.object({
+  id: z.string(),
+  eventId: z.string(),
+  addedAt: z.date(),
+  relevanceScore: z.number(),
+  topics: z.array(z.string()).optional(),
+  expiresAt: z.date()
+});
+var ConsolidatedMemorySchema = z.object({
+  memoryId: z.string(),
+  summary: z.string(),
+  topics: z.array(z.string()),
+  sourceEvents: z.array(z.string()),
+  confidence: z.number(),
+  createdAt: z.date(),
+  accessedAt: z.date().optional(),
+  accessCount: z.number().default(0)
+});
+var TransitionTypeSchema = z.enum(["seamless", "topic_shift", "break"]);
+var ContinuityLogSchema = z.object({
+  logId: z.string(),
+  fromContextId: z.string().optional(),
+  toContextId: z.string().optional(),
+  continuityScore: z.number(),
+  transitionType: TransitionTypeSchema,
+  createdAt: z.date()
+});
+
+// src/core/canonical-key.ts
+import { createHash } from "crypto";
+var MAX_KEY_LENGTH = 200;
+function makeCanonicalKey(title, context) {
+  let normalized = title.normalize("NFKC");
+  normalized = normalized.toLowerCase();
+  normalized = normalized.replace(/[^\p{L}\p{N}\s]/gu, "");
+  normalized = normalized.replace(/\s+/g, " ").trim();
+  let key = normalized;
+  if (context?.project) {
+    key = `${context.project}::${key}`;
+  }
+  if (key.length > MAX_KEY_LENGTH) {
+    const hashSuffix = createHash("md5").update(key).digest("hex").slice(0, 8);
+    key = key.slice(0, MAX_KEY_LENGTH - 9) + "_" + hashSuffix;
+  }
+  return key;
+}
+function isSameCanonicalKey(a, b) {
+  return makeCanonicalKey(a) === makeCanonicalKey(b);
+}
+function makeDedupeKey(content, sessionId) {
+  const contentHash = createHash("sha256").update(content).digest("hex");
+  return `${sessionId}:${contentHash}`;
+}
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+function normalizeForKey(text) {
+  return text.normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, "").replace(/\s+/g, "_").trim();
+}
+function makeEntityCanonicalKey(entityType, identifier, context) {
+  const project = context?.project ?? "default";
+  switch (entityType) {
+    case "task":
+      return `task:${project}:${normalizeForKey(identifier)}`;
+    case "condition":
+      return `cond:${project}:${normalizeForKey(identifier)}`;
+    case "artifact":
+      return makeArtifactKey(identifier);
+  }
+}
+function makeArtifactKey(identifier) {
+  if (/^https?:\/\//.test(identifier)) {
+    const hash2 = createHash("sha1").update(identifier).digest("hex").slice(0, 12);
+    return `art:url:${hash2}`;
+  }
+  const jiraMatch = identifier.match(/^([A-Z]+-\d+)$/);
+  if (jiraMatch) {
+    return `art:jira:${jiraMatch[1].toLowerCase()}`;
+  }
+  const ghMatch = identifier.match(/^([^\/]+\/[^#]+)#(\d+)$/);
+  if (ghMatch) {
+    return `art:gh_issue:${ghMatch[1]}:${ghMatch[2]}`;
+  }
+  const hash = createHash("sha1").update(identifier).digest("hex").slice(0, 12);
+  return `art:generic:${hash}`;
+}
+function makeTaskEventDedupeKey(eventType, taskId, sessionId, additionalContext) {
+  const parts = [eventType, taskId, sessionId];
+  if (additionalContext) {
+    parts.push(additionalContext);
+  }
+  const combined = parts.join(":");
+  return createHash("sha256").update(combined).digest("hex");
+}
+function parseEntityCanonicalKey(canonicalKey) {
+  const taskMatch = canonicalKey.match(/^task:([^:]+):(.+)$/);
+  if (taskMatch) {
+    return { entityType: "task", project: taskMatch[1], identifier: taskMatch[2] };
+  }
+  const condMatch = canonicalKey.match(/^cond:([^:]+):(.+)$/);
+  if (condMatch) {
+    return { entityType: "condition", project: condMatch[1], identifier: condMatch[2] };
+  }
+  const artMatch = canonicalKey.match(/^art:([^:]+):(.+)$/);
+  if (artMatch) {
+    return { entityType: "artifact", identifier: artMatch[2] };
+  }
+  return null;
+}
+
+// src/core/event-store.ts
+import { Database } from "duckdb";
+import { randomUUID } from "crypto";
+var EventStore = class {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+    this.db = new Database(dbPath);
+  }
+  db;
+  initialized = false;
+  /**
+   * Initialize database schema
+   */
+  async initialize() {
+    if (this.initialized)
+      return;
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS events (
+        id VARCHAR PRIMARY KEY,
+        event_type VARCHAR NOT NULL,
+        session_id VARCHAR NOT NULL,
+        timestamp TIMESTAMP NOT NULL,
+        content TEXT NOT NULL,
+        canonical_key VARCHAR NOT NULL,
+        dedupe_key VARCHAR UNIQUE,
+        metadata JSON
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS event_dedup (
+        dedupe_key VARCHAR PRIMARY KEY,
+        event_id VARCHAR NOT NULL,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        id VARCHAR PRIMARY KEY,
+        started_at TIMESTAMP NOT NULL,
+        ended_at TIMESTAMP,
+        project_path VARCHAR,
+        summary TEXT,
+        tags JSON
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS insights (
+        id VARCHAR PRIMARY KEY,
+        insight_type VARCHAR NOT NULL,
+        content TEXT NOT NULL,
+        canonical_key VARCHAR NOT NULL,
+        confidence FLOAT,
+        source_events JSON,
+        created_at TIMESTAMP,
+        last_updated TIMESTAMP
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS embedding_outbox (
+        id VARCHAR PRIMARY KEY,
+        event_id VARCHAR NOT NULL,
+        content TEXT NOT NULL,
+        status VARCHAR DEFAULT 'pending',
+        retry_count INT DEFAULT 0,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        processed_at TIMESTAMP,
+        error_message TEXT
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS projection_offsets (
+        projection_name VARCHAR PRIMARY KEY,
+        last_event_id VARCHAR,
+        last_timestamp TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS memory_levels (
+        event_id VARCHAR PRIMARY KEY,
+        level VARCHAR NOT NULL DEFAULT 'L0',
+        promoted_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS entries (
+        entry_id VARCHAR PRIMARY KEY,
+        created_ts TIMESTAMP NOT NULL,
+        entry_type VARCHAR NOT NULL,
+        title VARCHAR NOT NULL,
+        content_json JSON NOT NULL,
+        stage VARCHAR NOT NULL DEFAULT 'raw',
+        status VARCHAR DEFAULT 'active',
+        superseded_by VARCHAR,
+        build_id VARCHAR,
+        evidence_json JSON,
+        canonical_key VARCHAR,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS entities (
+        entity_id VARCHAR PRIMARY KEY,
+        entity_type VARCHAR NOT NULL,
+        canonical_key VARCHAR NOT NULL,
+        title VARCHAR NOT NULL,
+        stage VARCHAR NOT NULL DEFAULT 'raw',
+        status VARCHAR NOT NULL DEFAULT 'active',
+        current_json JSON NOT NULL,
+        title_norm VARCHAR,
+        search_text VARCHAR,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS entity_aliases (
+        entity_type VARCHAR NOT NULL,
+        canonical_key VARCHAR NOT NULL,
+        entity_id VARCHAR NOT NULL,
+        is_primary BOOLEAN DEFAULT FALSE,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        PRIMARY KEY(entity_type, canonical_key)
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS edges (
+        edge_id VARCHAR PRIMARY KEY,
+        src_type VARCHAR NOT NULL,
+        src_id VARCHAR NOT NULL,
+        rel_type VARCHAR NOT NULL,
+        dst_type VARCHAR NOT NULL,
+        dst_id VARCHAR NOT NULL,
+        meta_json JSON,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS vector_outbox (
+        job_id VARCHAR PRIMARY KEY,
+        item_kind VARCHAR NOT NULL,
+        item_id VARCHAR NOT NULL,
+        embedding_version VARCHAR NOT NULL,
+        status VARCHAR NOT NULL DEFAULT 'pending',
+        retry_count INT DEFAULT 0,
+        error VARCHAR,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        UNIQUE(item_kind, item_id, embedding_version)
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS build_runs (
+        build_id VARCHAR PRIMARY KEY,
+        started_at TIMESTAMP NOT NULL,
+        finished_at TIMESTAMP,
+        extractor_model VARCHAR NOT NULL,
+        extractor_prompt_hash VARCHAR NOT NULL,
+        embedder_model VARCHAR NOT NULL,
+        embedding_version VARCHAR NOT NULL,
+        idris_version VARCHAR NOT NULL,
+        schema_version VARCHAR NOT NULL,
+        status VARCHAR NOT NULL DEFAULT 'running',
+        error VARCHAR
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS pipeline_metrics (
+        id VARCHAR PRIMARY KEY,
+        ts TIMESTAMP NOT NULL,
+        stage VARCHAR NOT NULL,
+        latency_ms DOUBLE NOT NULL,
+        success BOOLEAN NOT NULL,
+        error VARCHAR,
+        session_id VARCHAR
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS working_set (
+        id VARCHAR PRIMARY KEY,
+        event_id VARCHAR NOT NULL,
+        added_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        relevance_score FLOAT DEFAULT 1.0,
+        topics JSON,
+        expires_at TIMESTAMP
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS consolidated_memories (
+        memory_id VARCHAR PRIMARY KEY,
+        summary TEXT NOT NULL,
+        topics JSON,
+        source_events JSON,
+        confidence FLOAT DEFAULT 0.5,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        accessed_at TIMESTAMP,
+        access_count INTEGER DEFAULT 0
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS continuity_log (
+        log_id VARCHAR PRIMARY KEY,
+        from_context_id VARCHAR,
+        to_context_id VARCHAR,
+        continuity_score FLOAT,
+        transition_type VARCHAR,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.db.run(`
+      CREATE TABLE IF NOT EXISTS endless_config (
+        key VARCHAR PRIMARY KEY,
+        value JSON,
+        updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(entry_type)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_entries_stage ON entries(stage)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_entries_canonical ON entries(canonical_key)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_entities_type_key ON entities(entity_type, canonical_key)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_entities_status ON entities(status)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_edges_src ON edges(src_id, rel_type)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_edges_dst ON edges(dst_id, rel_type)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_edges_rel ON edges(rel_type)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_outbox_status ON vector_outbox(status)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_working_set_expires ON working_set(expires_at)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_working_set_relevance ON working_set(relevance_score DESC)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_consolidated_confidence ON consolidated_memories(confidence DESC)`);
+    await this.db.run(`CREATE INDEX IF NOT EXISTS idx_continuity_created ON continuity_log(created_at)`);
+    this.initialized = true;
+  }
+  /**
+   * Append event to store (AXIOMMIND Principle 2: Append-only)
+   * Returns existing event ID if duplicate (Principle 3: Idempotency)
+   */
+  async append(input) {
+    await this.initialize();
+    const canonicalKey = makeCanonicalKey(input.content);
+    const dedupeKey = makeDedupeKey(input.content, input.sessionId);
+    const existing = await this.db.all(
+      `SELECT event_id FROM event_dedup WHERE dedupe_key = ?`,
+      [dedupeKey]
+    );
+    if (existing.length > 0) {
+      return {
+        success: true,
+        eventId: existing[0].event_id,
+        isDuplicate: true
+      };
+    }
+    const id = randomUUID();
+    const timestamp = input.timestamp.toISOString();
+    try {
+      await this.db.run(
+        `INSERT INTO events (id, event_type, session_id, timestamp, content, canonical_key, dedupe_key, metadata)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          id,
+          input.eventType,
+          input.sessionId,
+          timestamp,
+          input.content,
+          canonicalKey,
+          dedupeKey,
+          JSON.stringify(input.metadata || {})
+        ]
+      );
+      await this.db.run(
+        `INSERT INTO event_dedup (dedupe_key, event_id) VALUES (?, ?)`,
+        [dedupeKey, id]
+      );
+      await this.db.run(
+        `INSERT INTO memory_levels (event_id, level) VALUES (?, 'L0')`,
+        [id]
+      );
+      return { success: true, eventId: id, isDuplicate: false };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get events by session ID
+   */
+  async getSessionEvents(sessionId) {
+    await this.initialize();
+    const rows = await this.db.all(
+      `SELECT * FROM events WHERE session_id = ? ORDER BY timestamp ASC`,
+      [sessionId]
+    );
+    return rows.map(this.rowToEvent);
+  }
+  /**
+   * Get recent events
+   */
+  async getRecentEvents(limit = 100) {
+    await this.initialize();
+    const rows = await this.db.all(
+      `SELECT * FROM events ORDER BY timestamp DESC LIMIT ?`,
+      [limit]
+    );
+    return rows.map(this.rowToEvent);
+  }
+  /**
+   * Get event by ID
+   */
+  async getEvent(id) {
+    await this.initialize();
+    const rows = await this.db.all(
+      `SELECT * FROM events WHERE id = ?`,
+      [id]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToEvent(rows[0]);
+  }
+  /**
+   * Create or update session
+   */
+  async upsertSession(session) {
+    await this.initialize();
+    const existing = await this.db.all(
+      `SELECT id FROM sessions WHERE id = ?`,
+      [session.id]
+    );
+    if (existing.length === 0) {
+      await this.db.run(
+        `INSERT INTO sessions (id, started_at, project_path, tags)
+         VALUES (?, ?, ?, ?)`,
+        [
+          session.id,
+          (session.startedAt || /* @__PURE__ */ new Date()).toISOString(),
+          session.projectPath || null,
+          JSON.stringify(session.tags || [])
+        ]
+      );
+    } else {
+      const updates = [];
+      const values = [];
+      if (session.endedAt) {
+        updates.push("ended_at = ?");
+        values.push(session.endedAt.toISOString());
+      }
+      if (session.summary) {
+        updates.push("summary = ?");
+        values.push(session.summary);
+      }
+      if (session.tags) {
+        updates.push("tags = ?");
+        values.push(JSON.stringify(session.tags));
+      }
+      if (updates.length > 0) {
+        values.push(session.id);
+        await this.db.run(
+          `UPDATE sessions SET ${updates.join(", ")} WHERE id = ?`,
+          values
+        );
+      }
+    }
+  }
+  /**
+   * Get session by ID
+   */
+  async getSession(id) {
+    await this.initialize();
+    const rows = await this.db.all(
+      `SELECT * FROM sessions WHERE id = ?`,
+      [id]
+    );
+    if (rows.length === 0)
+      return null;
+    const row = rows[0];
+    return {
+      id: row.id,
+      startedAt: new Date(row.started_at),
+      endedAt: row.ended_at ? new Date(row.ended_at) : void 0,
+      projectPath: row.project_path,
+      summary: row.summary,
+      tags: row.tags ? JSON.parse(row.tags) : void 0
+    };
+  }
+  /**
+   * Add to embedding outbox (Single-Writer Pattern)
+   */
+  async enqueueForEmbedding(eventId, content) {
+    await this.initialize();
+    const id = randomUUID();
+    await this.db.run(
+      `INSERT INTO embedding_outbox (id, event_id, content, status, retry_count)
+       VALUES (?, ?, ?, 'pending', 0)`,
+      [id, eventId, content]
+    );
+    return id;
+  }
+  /**
+   * Get pending outbox items
+   */
+  async getPendingOutboxItems(limit = 32) {
+    await this.initialize();
+    const rows = await this.db.all(
+      `UPDATE embedding_outbox
+       SET status = 'processing'
+       WHERE id IN (
+         SELECT id FROM embedding_outbox
+         WHERE status = 'pending'
+         ORDER BY created_at
+         LIMIT ?
+       )
+       RETURNING *`,
+      [limit]
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      eventId: row.event_id,
+      content: row.content,
+      status: row.status,
+      retryCount: row.retry_count,
+      createdAt: new Date(row.created_at),
+      errorMessage: row.error_message
+    }));
+  }
+  /**
+   * Mark outbox items as done
+   */
+  async completeOutboxItems(ids) {
+    if (ids.length === 0)
+      return;
+    const placeholders = ids.map(() => "?").join(",");
+    await this.db.run(
+      `DELETE FROM embedding_outbox WHERE id IN (${placeholders})`,
+      ids
+    );
+  }
+  /**
+   * Mark outbox items as failed
+   */
+  async failOutboxItems(ids, error) {
+    if (ids.length === 0)
+      return;
+    const placeholders = ids.map(() => "?").join(",");
+    await this.db.run(
+      `UPDATE embedding_outbox
+       SET status = CASE WHEN retry_count >= 3 THEN 'failed' ELSE 'pending' END,
+           retry_count = retry_count + 1,
+           error_message = ?
+       WHERE id IN (${placeholders})`,
+      [error, ...ids]
+    );
+  }
+  /**
+   * Update memory level
+   */
+  async updateMemoryLevel(eventId, level) {
+    await this.initialize();
+    await this.db.run(
+      `UPDATE memory_levels SET level = ?, promoted_at = CURRENT_TIMESTAMP WHERE event_id = ?`,
+      [level, eventId]
+    );
+  }
+  /**
+   * Get memory level statistics
+   */
+  async getLevelStats() {
+    await this.initialize();
+    const rows = await this.db.all(
+      `SELECT level, COUNT(*) as count FROM memory_levels GROUP BY level`
+    );
+    return rows;
+  }
+  // ============================================================
+  // Endless Mode Helper Methods
+  // ============================================================
+  /**
+   * Get database instance for Endless Mode stores
+   */
+  getDatabase() {
+    return this.db;
+  }
+  /**
+   * Get config value for endless mode
+   */
+  async getEndlessConfig(key) {
+    await this.initialize();
+    const rows = await this.db.all(
+      `SELECT value FROM endless_config WHERE key = ?`,
+      [key]
+    );
+    if (rows.length === 0)
+      return null;
+    return JSON.parse(rows[0].value);
+  }
+  /**
+   * Set config value for endless mode
+   */
+  async setEndlessConfig(key, value) {
+    await this.initialize();
+    await this.db.run(
+      `INSERT OR REPLACE INTO endless_config (key, value, updated_at)
+       VALUES (?, ?, CURRENT_TIMESTAMP)`,
+      [key, JSON.stringify(value)]
+    );
+  }
+  /**
+   * Get all sessions
+   */
+  async getAllSessions() {
+    await this.initialize();
+    const rows = await this.db.all(
+      `SELECT * FROM sessions ORDER BY started_at DESC`
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      startedAt: new Date(row.started_at),
+      endedAt: row.ended_at ? new Date(row.ended_at) : void 0,
+      projectPath: row.project_path,
+      summary: row.summary,
+      tags: row.tags ? JSON.parse(row.tags) : void 0
+    }));
+  }
+  /**
+   * Close database connection
+   */
+  async close() {
+    await this.db.close();
+  }
+  /**
+   * Convert database row to MemoryEvent
+   */
+  rowToEvent(row) {
+    return {
+      id: row.id,
+      eventType: row.event_type,
+      sessionId: row.session_id,
+      timestamp: new Date(row.timestamp),
+      content: row.content,
+      canonicalKey: row.canonical_key,
+      dedupeKey: row.dedupe_key,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+    };
+  }
+};
+
+// src/core/entity-repo.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var EntityRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Create a new entity
+   */
+  async create(input) {
+    const entityId = randomUUID2();
+    const canonicalKey = makeEntityCanonicalKey(input.entityType, input.title, {
+      project: input.project
+    });
+    const titleNorm = input.title.toLowerCase().trim();
+    const searchText = `${input.title} ${JSON.stringify(input.currentJson)}`;
+    const now = /* @__PURE__ */ new Date();
+    await this.db.run(
+      `INSERT INTO entities (
+        entity_id, entity_type, canonical_key, title, stage, status,
+        current_json, title_norm, search_text, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        entityId,
+        input.entityType,
+        canonicalKey,
+        input.title,
+        input.stage ?? "raw",
+        input.status ?? "active",
+        JSON.stringify(input.currentJson),
+        titleNorm,
+        searchText,
+        now.toISOString(),
+        now.toISOString()
+      ]
+    );
+    await this.db.run(
+      `INSERT INTO entity_aliases (entity_type, canonical_key, entity_id, is_primary)
+       VALUES (?, ?, ?, TRUE)
+       ON CONFLICT (entity_type, canonical_key) DO NOTHING`,
+      [input.entityType, canonicalKey, entityId]
+    );
+    return {
+      entityId,
+      entityType: input.entityType,
+      canonicalKey,
+      title: input.title,
+      stage: input.stage ?? "raw",
+      status: input.status ?? "active",
+      currentJson: input.currentJson,
+      titleNorm,
+      searchText,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  /**
+   * Find entity by ID
+   */
+  async findById(entityId) {
+    const rows = await this.db.all(
+      `SELECT * FROM entities WHERE entity_id = ?`,
+      [entityId]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToEntity(rows[0]);
+  }
+  /**
+   * Find entity by canonical key
+   */
+  async findByCanonicalKey(entityType, canonicalKey) {
+    const rows = await this.db.all(
+      `SELECT * FROM entities
+       WHERE entity_type = ? AND canonical_key = ?`,
+      [entityType, canonicalKey]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToEntity(rows[0]);
+  }
+  /**
+   * Find or create entity by title (idempotent)
+   */
+  async findOrCreate(input) {
+    const canonicalKey = makeEntityCanonicalKey(input.entityType, input.title, {
+      project: input.project
+    });
+    const existing = await this.findByCanonicalKey(input.entityType, canonicalKey);
+    if (existing) {
+      return { entity: existing, created: false };
+    }
+    const entity = await this.create(input);
+    return { entity, created: true };
+  }
+  /**
+   * Update entity
+   */
+  async update(entityId, input) {
+    const existing = await this.findById(entityId);
+    if (!existing)
+      return null;
+    const updates = [];
+    const values = [];
+    if (input.currentJson !== void 0) {
+      updates.push("current_json = ?");
+      values.push(JSON.stringify(input.currentJson));
+    }
+    if (input.stage !== void 0) {
+      updates.push("stage = ?");
+      values.push(input.stage);
+    }
+    if (input.status !== void 0) {
+      updates.push("status = ?");
+      values.push(input.status);
+    }
+    if (input.searchText !== void 0) {
+      updates.push("search_text = ?");
+      values.push(input.searchText);
+    }
+    updates.push("updated_at = ?");
+    values.push((/* @__PURE__ */ new Date()).toISOString());
+    values.push(entityId);
+    await this.db.run(
+      `UPDATE entities SET ${updates.join(", ")} WHERE entity_id = ?`,
+      values
+    );
+    return this.findById(entityId);
+  }
+  /**
+   * List entities by type
+   */
+  async listByType(entityType, options) {
+    let query = `SELECT * FROM entities WHERE entity_type = ?`;
+    const params = [entityType];
+    if (options?.status) {
+      query += ` AND status = ?`;
+      params.push(options.status);
+    }
+    query += ` ORDER BY updated_at DESC`;
+    if (options?.limit) {
+      query += ` LIMIT ?`;
+      params.push(options.limit);
+    }
+    if (options?.offset) {
+      query += ` OFFSET ?`;
+      params.push(options.offset);
+    }
+    const rows = await this.db.all(query, params);
+    return rows.map((row) => this.rowToEntity(row));
+  }
+  /**
+   * Search entities by text
+   */
+  async search(query, options) {
+    const searchPattern = `%${query.toLowerCase()}%`;
+    let sql = `SELECT * FROM entities WHERE (title_norm LIKE ? OR search_text LIKE ?)`;
+    const params = [searchPattern, searchPattern];
+    if (options?.entityType) {
+      sql += ` AND entity_type = ?`;
+      params.push(options.entityType);
+    }
+    sql += ` AND status = 'active' ORDER BY updated_at DESC`;
+    if (options?.limit) {
+      sql += ` LIMIT ?`;
+      params.push(options.limit);
+    }
+    const rows = await this.db.all(sql, params);
+    return rows.map((row) => this.rowToEntity(row));
+  }
+  /**
+   * Get tasks by status
+   */
+  async getTasksByStatus(status) {
+    const rows = await this.db.all(
+      `SELECT * FROM entities
+       WHERE entity_type = 'task'
+       AND json_extract(current_json, '$.status') = ?
+       AND status = 'active'
+       ORDER BY updated_at DESC`,
+      [status]
+    );
+    return rows.map((row) => this.rowToEntity(row));
+  }
+  /**
+   * Get blocked tasks with their blockers
+   */
+  async getBlockedTasksWithBlockers() {
+    const tasks = await this.getTasksByStatus("blocked");
+    const results = [];
+    for (const task of tasks) {
+      const blockerEdges = await this.db.all(
+        `SELECT e.dst_id, ent.entity_type, ent.title
+         FROM edges e
+         JOIN entities ent ON ent.entity_id = e.dst_id
+         WHERE e.src_id = ? AND e.rel_type = 'blocked_by'`,
+        [task.entityId]
+      );
+      results.push({
+        task,
+        blockers: blockerEdges.map((row) => ({
+          entityId: row.dst_id,
+          entityType: row.entity_type,
+          title: row.title
+        }))
+      });
+    }
+    return results;
+  }
+  /**
+   * Add alias for entity
+   */
+  async addAlias(entityType, canonicalKey, entityId) {
+    await this.db.run(
+      `INSERT INTO entity_aliases (entity_type, canonical_key, entity_id, is_primary)
+       VALUES (?, ?, ?, FALSE)
+       ON CONFLICT (entity_type, canonical_key) DO NOTHING`,
+      [entityType, canonicalKey, entityId]
+    );
+  }
+  /**
+   * Find entity by alias
+   */
+  async findByAlias(entityType, canonicalKey) {
+    const rows = await this.db.all(
+      `SELECT e.* FROM entities e
+       JOIN entity_aliases a ON e.entity_id = a.entity_id
+       WHERE a.entity_type = ? AND a.canonical_key = ?`,
+      [entityType, canonicalKey]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToEntity(rows[0]);
+  }
+  /**
+   * Convert database row to Entity
+   */
+  rowToEntity(row) {
+    return {
+      entityId: row.entity_id,
+      entityType: row.entity_type,
+      canonicalKey: row.canonical_key,
+      title: row.title,
+      stage: row.stage,
+      status: row.status,
+      currentJson: typeof row.current_json === "string" ? JSON.parse(row.current_json) : row.current_json,
+      titleNorm: row.title_norm,
+      searchText: row.search_text,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
+};
+
+// src/core/edge-repo.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var EdgeRepo = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Create a new edge (idempotent - ignores duplicates)
+   */
+  async create(input) {
+    const edgeId = randomUUID3();
+    const now = /* @__PURE__ */ new Date();
+    await this.db.run(
+      `INSERT INTO edges (edge_id, src_type, src_id, rel_type, dst_type, dst_id, meta_json, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT DO NOTHING`,
+      [
+        edgeId,
+        input.srcType,
+        input.srcId,
+        input.relType,
+        input.dstType,
+        input.dstId,
+        JSON.stringify(input.metaJson ?? {}),
+        now.toISOString()
+      ]
+    );
+    return {
+      edgeId,
+      srcType: input.srcType,
+      srcId: input.srcId,
+      relType: input.relType,
+      dstType: input.dstType,
+      dstId: input.dstId,
+      metaJson: input.metaJson,
+      createdAt: now
+    };
+  }
+  /**
+   * Create or update edge
+   */
+  async upsert(input) {
+    const existing = await this.findByEndpoints(
+      input.srcType,
+      input.srcId,
+      input.relType,
+      input.dstType,
+      input.dstId
+    );
+    if (existing) {
+      await this.db.run(
+        `UPDATE edges SET meta_json = ? WHERE edge_id = ?`,
+        [JSON.stringify(input.metaJson ?? {}), existing.edgeId]
+      );
+      return { ...existing, metaJson: input.metaJson };
+    }
+    return this.create(input);
+  }
+  /**
+   * Find edge by endpoints
+   */
+  async findByEndpoints(srcType, srcId, relType, dstType, dstId) {
+    const rows = await this.db.all(
+      `SELECT * FROM edges
+       WHERE src_type = ? AND src_id = ? AND rel_type = ?
+       AND dst_type = ? AND dst_id = ?`,
+      [srcType, srcId, relType, dstType, dstId]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToEdge(rows[0]);
+  }
+  /**
+   * Find edges by source
+   */
+  async findBySrc(srcId, relType) {
+    let query = `SELECT * FROM edges WHERE src_id = ?`;
+    const params = [srcId];
+    if (relType) {
+      query += ` AND rel_type = ?`;
+      params.push(relType);
+    }
+    query += ` ORDER BY created_at DESC`;
+    const rows = await this.db.all(query, params);
+    return rows.map((row) => this.rowToEdge(row));
+  }
+  /**
+   * Find edges by destination
+   */
+  async findByDst(dstId, relType) {
+    let query = `SELECT * FROM edges WHERE dst_id = ?`;
+    const params = [dstId];
+    if (relType) {
+      query += ` AND rel_type = ?`;
+      params.push(relType);
+    }
+    query += ` ORDER BY created_at DESC`;
+    const rows = await this.db.all(query, params);
+    return rows.map((row) => this.rowToEdge(row));
+  }
+  /**
+   * Find all edges for a node (both directions)
+   */
+  async findByNode(nodeId) {
+    const outgoing = await this.findBySrc(nodeId);
+    const incoming = await this.findByDst(nodeId);
+    return { outgoing, incoming };
+  }
+  /**
+   * Delete edge by ID
+   */
+  async delete(edgeId) {
+    const result = await this.db.run(
+      `DELETE FROM edges WHERE edge_id = ?`,
+      [edgeId]
+    );
+    return true;
+  }
+  /**
+   * Delete edges by source and relation type
+   */
+  async deleteBySrcAndRel(srcId, relType) {
+    await this.db.run(
+      `DELETE FROM edges WHERE src_id = ? AND rel_type = ?`,
+      [srcId, relType]
+    );
+    return 0;
+  }
+  /**
+   * Delete edges by destination and relation type
+   */
+  async deleteByDstAndRel(dstId, relType) {
+    await this.db.run(
+      `DELETE FROM edges WHERE dst_id = ? AND rel_type = ?`,
+      [dstId, relType]
+    );
+    return 0;
+  }
+  /**
+   * Replace edges for a source and relation type
+   * Used for mode=replace in task_blockers_set
+   */
+  async replaceEdges(srcId, relType, newEdges) {
+    await this.deleteBySrcAndRel(srcId, relType);
+    const created = [];
+    for (const edge of newEdges) {
+      const newEdge = await this.create({
+        srcType: edge.srcType,
+        srcId,
+        relType,
+        dstType: edge.dstType,
+        dstId: edge.dstId,
+        metaJson: edge.metaJson
+      });
+      created.push(newEdge);
+    }
+    return created;
+  }
+  /**
+   * Get effective blockers (resolving condition → task)
+   * Returns resolved blocker if condition has resolves_to edge
+   */
+  async getEffectiveBlockers(taskId) {
+    const blockerEdges = await this.findBySrc(taskId, "blocked_by");
+    const results = [];
+    for (const edge of blockerEdges) {
+      const resolvesTo = await this.db.all(
+        `SELECT dst_id FROM edges
+         WHERE src_id = ? AND rel_type = 'resolves_to'
+         LIMIT 1`,
+        [edge.dstId]
+      );
+      if (resolvesTo.length > 0) {
+        results.push({
+          originalId: edge.dstId,
+          effectiveId: resolvesTo[0].dst_id,
+          isResolved: true
+        });
+      } else {
+        results.push({
+          originalId: edge.dstId,
+          effectiveId: edge.dstId,
+          isResolved: false
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Find 2-hop related entries (Entry → Entity → Entry)
+   */
+  async findRelatedEntries(entryId) {
+    const rows = await this.db.all(
+      `WITH first_hop AS (
+         SELECT e1.dst_id AS entity_id
+         FROM edges e1
+         WHERE e1.src_type = 'entry'
+           AND e1.rel_type = 'evidence_of'
+           AND e1.src_id = ?
+       )
+       SELECT
+         e2.src_id AS entry_id,
+         f.entity_id AS via_entity_id,
+         'evidence_of\u2192evidence_of' AS relation_path
+       FROM first_hop f
+       JOIN edges e2 ON e2.dst_id = f.entity_id
+                    AND e2.rel_type = 'evidence_of'
+                    AND e2.src_type = 'entry'
+       WHERE e2.src_id != ?`,
+      [entryId, entryId]
+    );
+    return rows.map((row) => ({
+      entryId: row.entry_id,
+      viaEntityId: row.via_entity_id,
+      relationPath: row.relation_path
+    }));
+  }
+  /**
+   * Count edges by relation type
+   */
+  async countByRelType() {
+    const rows = await this.db.all(
+      `SELECT rel_type, COUNT(*) as count FROM edges GROUP BY rel_type`
+    );
+    return rows.map((row) => ({
+      relType: row.rel_type,
+      count: Number(row.count)
+    }));
+  }
+  /**
+   * Convert database row to Edge
+   */
+  rowToEdge(row) {
+    return {
+      edgeId: row.edge_id,
+      srcType: row.src_type,
+      srcId: row.src_id,
+      relType: row.rel_type,
+      dstType: row.dst_type,
+      dstId: row.dst_id,
+      metaJson: typeof row.meta_json === "string" ? JSON.parse(row.meta_json) : row.meta_json,
+      createdAt: new Date(row.created_at)
+    };
+  }
+};
+
+// src/core/vector-store.ts
+import * as lancedb from "@lancedb/lancedb";
+var VectorStore = class {
+  constructor(dbPath) {
+    this.dbPath = dbPath;
+  }
+  db = null;
+  table = null;
+  tableName = "conversations";
+  /**
+   * Initialize LanceDB connection
+   */
+  async initialize() {
+    if (this.db)
+      return;
+    this.db = await lancedb.connect(this.dbPath);
+    try {
+      const tables = await this.db.tableNames();
+      if (tables.includes(this.tableName)) {
+        this.table = await this.db.openTable(this.tableName);
+      }
+    } catch {
+      this.table = null;
+    }
+  }
+  /**
+   * Add or update vector record
+   */
+  async upsert(record) {
+    await this.initialize();
+    if (!this.db) {
+      throw new Error("Database not initialized");
+    }
+    const data = {
+      id: record.id,
+      eventId: record.eventId,
+      sessionId: record.sessionId,
+      eventType: record.eventType,
+      content: record.content,
+      vector: record.vector,
+      timestamp: record.timestamp,
+      metadata: JSON.stringify(record.metadata || {})
+    };
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, [data]);
+    } else {
+      await this.table.add([data]);
+    }
+  }
+  /**
+   * Add multiple vector records in batch
+   */
+  async upsertBatch(records) {
+    if (records.length === 0)
+      return;
+    await this.initialize();
+    if (!this.db) {
+      throw new Error("Database not initialized");
+    }
+    const data = records.map((record) => ({
+      id: record.id,
+      eventId: record.eventId,
+      sessionId: record.sessionId,
+      eventType: record.eventType,
+      content: record.content,
+      vector: record.vector,
+      timestamp: record.timestamp,
+      metadata: JSON.stringify(record.metadata || {})
+    }));
+    if (!this.table) {
+      this.table = await this.db.createTable(this.tableName, data);
+    } else {
+      await this.table.add(data);
+    }
+  }
+  /**
+   * Search for similar vectors
+   */
+  async search(queryVector, options = {}) {
+    await this.initialize();
+    if (!this.table) {
+      return [];
+    }
+    const { limit = 5, minScore = 0.7, sessionId } = options;
+    let query = this.table.search(queryVector).limit(limit * 2);
+    if (sessionId) {
+      query = query.where(`sessionId = '${sessionId}'`);
+    }
+    const results = await query.toArray();
+    return results.filter((r) => {
+      const score = 1 - (r._distance || 0);
+      return score >= minScore;
+    }).slice(0, limit).map((r) => ({
+      id: r.id,
+      eventId: r.eventId,
+      content: r.content,
+      score: 1 - (r._distance || 0),
+      sessionId: r.sessionId,
+      eventType: r.eventType,
+      timestamp: r.timestamp
+    }));
+  }
+  /**
+   * Delete vector by event ID
+   */
+  async delete(eventId) {
+    if (!this.table)
+      return;
+    await this.table.delete(`eventId = '${eventId}'`);
+  }
+  /**
+   * Get total count of vectors
+   */
+  async count() {
+    if (!this.table)
+      return 0;
+    const result = await this.table.countRows();
+    return result;
+  }
+  /**
+   * Check if vector exists for event
+   */
+  async exists(eventId) {
+    if (!this.table)
+      return false;
+    const results = await this.table.search([]).where(`eventId = '${eventId}'`).limit(1).toArray();
+    return results.length > 0;
+  }
+};
+
+// src/core/embedder.ts
+import { pipeline } from "@xenova/transformers";
+var Embedder = class {
+  pipeline = null;
+  modelName;
+  initialized = false;
+  constructor(modelName = "Xenova/all-MiniLM-L6-v2") {
+    this.modelName = modelName;
+  }
+  /**
+   * Initialize the embedding pipeline
+   */
+  async initialize() {
+    if (this.initialized)
+      return;
+    this.pipeline = await pipeline("feature-extraction", this.modelName);
+    this.initialized = true;
+  }
+  /**
+   * Generate embedding for a single text
+   */
+  async embed(text) {
+    await this.initialize();
+    if (!this.pipeline) {
+      throw new Error("Embedding pipeline not initialized");
+    }
+    const output = await this.pipeline(text, {
+      pooling: "mean",
+      normalize: true
+    });
+    const vector = Array.from(output.data);
+    return {
+      vector,
+      model: this.modelName,
+      dimensions: vector.length
+    };
+  }
+  /**
+   * Generate embeddings for multiple texts in batch
+   */
+  async embedBatch(texts) {
+    await this.initialize();
+    if (!this.pipeline) {
+      throw new Error("Embedding pipeline not initialized");
+    }
+    const results = [];
+    const batchSize = 32;
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize);
+      for (const text of batch) {
+        const output = await this.pipeline(text, {
+          pooling: "mean",
+          normalize: true
+        });
+        const vector = Array.from(output.data);
+        results.push({
+          vector,
+          model: this.modelName,
+          dimensions: vector.length
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Get embedding dimensions for the current model
+   */
+  async getDimensions() {
+    const result = await this.embed("test");
+    return result.dimensions;
+  }
+  /**
+   * Check if embedder is ready
+   */
+  isReady() {
+    return this.initialized && this.pipeline !== null;
+  }
+  /**
+   * Get model name
+   */
+  getModelName() {
+    return this.modelName;
+  }
+};
+var defaultEmbedder = null;
+function getDefaultEmbedder() {
+  if (!defaultEmbedder) {
+    defaultEmbedder = new Embedder();
+  }
+  return defaultEmbedder;
+}
+
+// src/core/vector-outbox.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var DEFAULT_CONFIG = {
+  embeddingVersion: "v1",
+  maxRetries: 3,
+  stuckThresholdMs: 5 * 60 * 1e3,
+  // 5 minutes
+  cleanupDays: 7
+};
+var VectorOutbox = class {
+  constructor(db, config) {
+    this.db = db;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  config;
+  /**
+   * Enqueue item for vectorization (idempotent)
+   */
+  async enqueue(itemKind, itemId, embeddingVersion) {
+    const version = embeddingVersion ?? this.config.embeddingVersion;
+    const jobId = randomUUID4();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await this.db.run(
+      `INSERT INTO vector_outbox (
+        job_id, item_kind, item_id, embedding_version, status, retry_count, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, 'pending', 0, ?, ?)
+      ON CONFLICT (item_kind, item_id, embedding_version) DO NOTHING`,
+      [jobId, itemKind, itemId, version, now, now]
+    );
+    return jobId;
+  }
+  /**
+   * Claim pending jobs for processing
+   */
+  async claimJobs(limit = 32) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const rows = await this.db.all(
+      `UPDATE vector_outbox
+       SET status = 'processing', updated_at = ?
+       WHERE job_id IN (
+         SELECT job_id FROM vector_outbox
+         WHERE status = 'pending'
+         ORDER BY created_at ASC
+         LIMIT ?
+       )
+       RETURNING *`,
+      [now, limit]
+    );
+    return rows.map((row) => this.rowToJob(row));
+  }
+  /**
+   * Mark job as done
+   */
+  async markDone(jobId) {
+    await this.db.run(
+      `UPDATE vector_outbox
+       SET status = 'done', updated_at = ?
+       WHERE job_id = ?`,
+      [(/* @__PURE__ */ new Date()).toISOString(), jobId]
+    );
+  }
+  /**
+   * Mark job as failed
+   */
+  async markFailed(jobId, error) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const rows = await this.db.all(
+      `SELECT retry_count FROM vector_outbox WHERE job_id = ?`,
+      [jobId]
+    );
+    if (rows.length === 0)
+      return;
+    const retryCount = rows[0].retry_count;
+    const newStatus = retryCount >= this.config.maxRetries - 1 ? "failed" : "pending";
+    await this.db.run(
+      `UPDATE vector_outbox
+       SET status = ?, error = ?, retry_count = retry_count + 1, updated_at = ?
+       WHERE job_id = ?`,
+      [newStatus, error, now, jobId]
+    );
+  }
+  /**
+   * Get job by ID
+   */
+  async getJob(jobId) {
+    const rows = await this.db.all(
+      `SELECT * FROM vector_outbox WHERE job_id = ?`,
+      [jobId]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToJob(rows[0]);
+  }
+  /**
+   * Get jobs by status
+   */
+  async getJobsByStatus(status, limit = 100) {
+    const rows = await this.db.all(
+      `SELECT * FROM vector_outbox
+       WHERE status = ?
+       ORDER BY created_at ASC
+       LIMIT ?`,
+      [status, limit]
+    );
+    return rows.map((row) => this.rowToJob(row));
+  }
+  /**
+   * Reconcile: recover stuck and retry failed jobs
+   */
+  async reconcile() {
+    const now = /* @__PURE__ */ new Date();
+    const stuckThreshold = new Date(now.getTime() - this.config.stuckThresholdMs);
+    const recoveredResult = await this.db.run(
+      `UPDATE vector_outbox
+       SET status = 'pending', updated_at = ?
+       WHERE status = 'processing'
+       AND updated_at < ?`,
+      [now.toISOString(), stuckThreshold.toISOString()]
+    );
+    const retriedResult = await this.db.run(
+      `UPDATE vector_outbox
+       SET status = 'pending', updated_at = ?
+       WHERE status = 'failed'
+       AND retry_count < ?`,
+      [now.toISOString(), this.config.maxRetries]
+    );
+    const recoveredRows = await this.db.all(
+      `SELECT COUNT(*) as count FROM vector_outbox
+       WHERE status = 'pending' AND updated_at = ?`,
+      [now.toISOString()]
+    );
+    return {
+      recovered: 0,
+      // Approximate
+      retried: 0
+      // Approximate
+    };
+  }
+  /**
+   * Cleanup old done jobs
+   */
+  async cleanup() {
+    const threshold = /* @__PURE__ */ new Date();
+    threshold.setDate(threshold.getDate() - this.config.cleanupDays);
+    await this.db.run(
+      `DELETE FROM vector_outbox
+       WHERE status = 'done'
+       AND updated_at < ?`,
+      [threshold.toISOString()]
+    );
+    return 0;
+  }
+  /**
+   * Get metrics
+   */
+  async getMetrics() {
+    const statusCounts = await this.db.all(
+      `SELECT status, COUNT(*) as count
+       FROM vector_outbox
+       GROUP BY status`
+    );
+    const oldestPending = await this.db.all(
+      `SELECT created_at FROM vector_outbox
+       WHERE status = 'pending'
+       ORDER BY created_at ASC
+       LIMIT 1`
+    );
+    const metrics = {
+      pendingCount: 0,
+      processingCount: 0,
+      doneCount: 0,
+      failedCount: 0,
+      oldestPendingAge: null
+    };
+    for (const row of statusCounts) {
+      switch (row.status) {
+        case "pending":
+          metrics.pendingCount = Number(row.count);
+          break;
+        case "processing":
+          metrics.processingCount = Number(row.count);
+          break;
+        case "done":
+          metrics.doneCount = Number(row.count);
+          break;
+        case "failed":
+          metrics.failedCount = Number(row.count);
+          break;
+      }
+    }
+    if (oldestPending.length > 0) {
+      const oldestDate = new Date(oldestPending[0].created_at);
+      metrics.oldestPendingAge = Date.now() - oldestDate.getTime();
+    }
+    return metrics;
+  }
+  /**
+   * Validate state transition
+   */
+  isValidTransition(from, to) {
+    const validTransitions = [
+      { from: "pending", to: "processing" },
+      { from: "processing", to: "done" },
+      { from: "processing", to: "failed" },
+      { from: "failed", to: "pending" }
+    ];
+    return validTransitions.some((t) => t.from === from && t.to === to);
+  }
+  /**
+   * Convert database row to OutboxJob
+   */
+  rowToJob(row) {
+    return {
+      jobId: row.job_id,
+      itemKind: row.item_kind,
+      itemId: row.item_id,
+      embeddingVersion: row.embedding_version,
+      status: row.status,
+      retryCount: row.retry_count,
+      error: row.error,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
+};
+
+// src/core/vector-worker.ts
+var DEFAULT_CONFIG2 = {
+  batchSize: 32,
+  pollIntervalMs: 1e3,
+  maxRetries: 3
+};
+var VectorWorker = class {
+  eventStore;
+  vectorStore;
+  embedder;
+  config;
+  running = false;
+  pollTimeout = null;
+  constructor(eventStore, vectorStore, embedder, config = {}) {
+    this.eventStore = eventStore;
+    this.vectorStore = vectorStore;
+    this.embedder = embedder;
+    this.config = { ...DEFAULT_CONFIG2, ...config };
+  }
+  /**
+   * Start the worker polling loop
+   */
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.poll();
+  }
+  /**
+   * Stop the worker
+   */
+  stop() {
+    this.running = false;
+    if (this.pollTimeout) {
+      clearTimeout(this.pollTimeout);
+      this.pollTimeout = null;
+    }
+  }
+  /**
+   * Process a single batch of outbox items
+   */
+  async processBatch() {
+    const items = await this.eventStore.getPendingOutboxItems(this.config.batchSize);
+    if (items.length === 0) {
+      return 0;
+    }
+    const successful = [];
+    const failed = [];
+    try {
+      const embeddings = await this.embedder.embedBatch(items.map((i) => i.content));
+      const records = [];
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const embedding = embeddings[i];
+        const event = await this.eventStore.getEvent(item.eventId);
+        if (!event) {
+          failed.push(item.id);
+          continue;
+        }
+        records.push({
+          id: `vec_${item.id}`,
+          eventId: item.eventId,
+          sessionId: event.sessionId,
+          eventType: event.eventType,
+          content: item.content,
+          vector: embedding.vector,
+          timestamp: event.timestamp.toISOString(),
+          metadata: event.metadata
+        });
+        successful.push(item.id);
+      }
+      if (records.length > 0) {
+        await this.vectorStore.upsertBatch(records);
+      }
+      if (successful.length > 0) {
+        await this.eventStore.completeOutboxItems(successful);
+      }
+      if (failed.length > 0) {
+        await this.eventStore.failOutboxItems(failed, "Event not found");
+      }
+      return successful.length;
+    } catch (error) {
+      const allIds = items.map((i) => i.id);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      await this.eventStore.failOutboxItems(allIds, errorMessage);
+      throw error;
+    }
+  }
+  /**
+   * Poll for new items
+   */
+  async poll() {
+    if (!this.running)
+      return;
+    try {
+      await this.processBatch();
+    } catch (error) {
+      console.error("Vector worker error:", error);
+    }
+    this.pollTimeout = setTimeout(() => this.poll(), this.config.pollIntervalMs);
+  }
+  /**
+   * Process all pending items (blocking)
+   */
+  async processAll() {
+    let totalProcessed = 0;
+    let processed;
+    do {
+      processed = await this.processBatch();
+      totalProcessed += processed;
+    } while (processed > 0);
+    return totalProcessed;
+  }
+  /**
+   * Check if worker is running
+   */
+  isRunning() {
+    return this.running;
+  }
+};
+function createVectorWorker(eventStore, vectorStore, embedder, config) {
+  const worker = new VectorWorker(eventStore, vectorStore, embedder, config);
+  return worker;
+}
+var DEFAULT_CONFIG_V2 = {
+  batchSize: 32,
+  pollIntervalMs: 1e3,
+  maxRetries: 3,
+  embeddingVersion: "v1"
+};
+var DefaultContentProvider = class {
+  constructor(db) {
+    this.db = db;
+  }
+  async getContent(itemKind, itemId) {
+    switch (itemKind) {
+      case "entry":
+        return this.getEntryContent(itemId);
+      case "task_title":
+        return this.getTaskTitleContent(itemId);
+      case "event":
+        return this.getEventContent(itemId);
+      default:
+        return null;
+    }
+  }
+  async getEntryContent(entryId) {
+    const rows = await this.db.all(
+      `SELECT title, content_json, entry_type FROM entries WHERE entry_id = ?`,
+      [entryId]
+    );
+    if (rows.length === 0)
+      return null;
+    const row = rows[0];
+    const contentJson = typeof row.content_json === "string" ? JSON.parse(row.content_json) : row.content_json;
+    return {
+      content: `${row.title}
+${JSON.stringify(contentJson)}`,
+      metadata: {
+        itemKind: "entry",
+        entryType: row.entry_type
+      }
+    };
+  }
+  async getTaskTitleContent(taskId) {
+    const rows = await this.db.all(
+      `SELECT title, search_text, current_json FROM entities
+       WHERE entity_id = ? AND entity_type = 'task'`,
+      [taskId]
+    );
+    if (rows.length === 0)
+      return null;
+    const row = rows[0];
+    return {
+      content: row.search_text || row.title,
+      metadata: {
+        itemKind: "task_title",
+        entityType: "task"
+      }
+    };
+  }
+  async getEventContent(eventId) {
+    const rows = await this.db.all(
+      `SELECT content, event_type, session_id FROM events WHERE id = ?`,
+      [eventId]
+    );
+    if (rows.length === 0)
+      return null;
+    const row = rows[0];
+    return {
+      content: row.content,
+      metadata: {
+        itemKind: "event",
+        eventType: row.event_type,
+        sessionId: row.session_id
+      }
+    };
+  }
+};
+var VectorWorkerV2 = class {
+  outbox;
+  vectorStore;
+  embedder;
+  contentProvider;
+  config;
+  running = false;
+  pollTimeout = null;
+  constructor(db, vectorStore, embedder, config = {}, contentProvider) {
+    this.outbox = new VectorOutbox(db, {
+      embeddingVersion: config.embeddingVersion ?? DEFAULT_CONFIG_V2.embeddingVersion,
+      maxRetries: config.maxRetries ?? DEFAULT_CONFIG_V2.maxRetries
+    });
+    this.vectorStore = vectorStore;
+    this.embedder = embedder;
+    this.config = { ...DEFAULT_CONFIG_V2, ...config };
+    this.contentProvider = contentProvider ?? new DefaultContentProvider(db);
+  }
+  /**
+   * Start the worker polling loop
+   */
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.poll();
+  }
+  /**
+   * Stop the worker
+   */
+  stop() {
+    this.running = false;
+    if (this.pollTimeout) {
+      clearTimeout(this.pollTimeout);
+      this.pollTimeout = null;
+    }
+  }
+  /**
+   * Process a single batch of outbox jobs
+   */
+  async processBatch() {
+    const jobs = await this.outbox.claimJobs(this.config.batchSize);
+    if (jobs.length === 0) {
+      return 0;
+    }
+    let successCount = 0;
+    for (const job of jobs) {
+      try {
+        await this.processJob(job);
+        await this.outbox.markDone(job.jobId);
+        successCount++;
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        await this.outbox.markFailed(job.jobId, errorMessage);
+      }
+    }
+    return successCount;
+  }
+  /**
+   * Process a single job
+   */
+  async processJob(job) {
+    const contentData = await this.contentProvider.getContent(job.itemKind, job.itemId);
+    if (!contentData) {
+      return;
+    }
+    const embedding = await this.embedder.embed(contentData.content);
+    const record = {
+      id: `${job.itemKind}_${job.itemId}_${job.embeddingVersion}`,
+      eventId: job.itemKind === "event" ? job.itemId : "",
+      sessionId: contentData.metadata.sessionId ?? "",
+      eventType: contentData.metadata.eventType ?? job.itemKind,
+      content: contentData.content,
+      vector: embedding.vector,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata: {
+        ...contentData.metadata,
+        embeddingVersion: job.embeddingVersion
+      }
+    };
+    await this.vectorStore.upsertBatch([record]);
+  }
+  /**
+   * Poll for new jobs
+   */
+  async poll() {
+    if (!this.running)
+      return;
+    try {
+      await this.processBatch();
+    } catch (error) {
+      console.error("Vector worker V2 error:", error);
+    }
+    this.pollTimeout = setTimeout(() => this.poll(), this.config.pollIntervalMs);
+  }
+  /**
+   * Process all pending jobs (blocking)
+   */
+  async processAll() {
+    let totalProcessed = 0;
+    let processed;
+    do {
+      processed = await this.processBatch();
+      totalProcessed += processed;
+    } while (processed > 0);
+    return totalProcessed;
+  }
+  /**
+   * Run reconciliation
+   */
+  async reconcile() {
+    return this.outbox.reconcile();
+  }
+  /**
+   * Get metrics
+   */
+  async getMetrics() {
+    return this.outbox.getMetrics();
+  }
+  /**
+   * Check if worker is running
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get the outbox instance for direct access
+   */
+  getOutbox() {
+    return this.outbox;
+  }
+};
+function createVectorWorkerV2(db, vectorStore, embedder, config) {
+  return new VectorWorkerV2(db, vectorStore, embedder, config);
+}
+
+// src/core/matcher.ts
+var DEFAULT_CONFIG3 = {
+  weights: {
+    semanticSimilarity: 0.4,
+    ftsScore: 0.25,
+    recencyBonus: 0.2,
+    statusWeight: 0.15
+  },
+  minCombinedScore: 0.92,
+  minGap: 0.03,
+  suggestionThreshold: 0.75
+};
+var Matcher = class {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG3,
+      ...config,
+      weights: { ...DEFAULT_CONFIG3.weights, ...config.weights }
+    };
+  }
+  /**
+   * Calculate combined score using AXIOMMIND weighted formula
+   */
+  calculateCombinedScore(semanticScore, ftsScore = 0, recencyDays = 0, isActive = true) {
+    const { weights } = this.config;
+    const recencyBonus = Math.max(0, 1 - recencyDays / 30);
+    const statusMultiplier = isActive ? 1 : 0.7;
+    const combinedScore = weights.semanticSimilarity * semanticScore + weights.ftsScore * ftsScore + weights.recencyBonus * recencyBonus + weights.statusWeight * statusMultiplier;
+    return Math.min(1, combinedScore);
+  }
+  /**
+   * Classify match confidence based on AXIOMMIND thresholds
+   */
+  classifyConfidence(topScore, secondScore) {
+    const { minCombinedScore, minGap, suggestionThreshold } = this.config;
+    const gap = secondScore !== null ? topScore - secondScore : Infinity;
+    if (topScore >= minCombinedScore && gap >= minGap) {
+      return "high";
+    }
+    if (topScore >= suggestionThreshold) {
+      return "suggested";
+    }
+    return "none";
+  }
+  /**
+   * Match search results to find best memory
+   */
+  matchSearchResults(results, getEventAge) {
+    if (results.length === 0) {
+      return {
+        match: null,
+        confidence: "none"
+      };
+    }
+    const scoredResults = results.map((result) => {
+      const ageDays = getEventAge(result.eventId);
+      const combinedScore = this.calculateCombinedScore(
+        result.score,
+        0,
+        // FTS score - would need to be passed in
+        ageDays,
+        true
+        // Assume active
+      );
+      return {
+        result,
+        combinedScore
+      };
+    });
+    scoredResults.sort((a, b) => b.combinedScore - a.combinedScore);
+    const topResult = scoredResults[0];
+    const secondScore = scoredResults.length > 1 ? scoredResults[1].combinedScore : null;
+    const confidence = this.classifyConfidence(topResult.combinedScore, secondScore);
+    const match = {
+      event: {
+        id: topResult.result.eventId,
+        eventType: topResult.result.eventType,
+        sessionId: topResult.result.sessionId,
+        timestamp: new Date(topResult.result.timestamp),
+        content: topResult.result.content,
+        canonicalKey: "",
+        // Would need to be fetched
+        dedupeKey: ""
+        // Would need to be fetched
+      },
+      score: topResult.combinedScore
+    };
+    const gap = secondScore !== null ? topResult.combinedScore - secondScore : void 0;
+    const alternatives = confidence === "suggested" ? scoredResults.slice(1, 4).map((sr) => ({
+      event: {
+        id: sr.result.eventId,
+        eventType: sr.result.eventType,
+        sessionId: sr.result.sessionId,
+        timestamp: new Date(sr.result.timestamp),
+        content: sr.result.content,
+        canonicalKey: "",
+        dedupeKey: ""
+      },
+      score: sr.combinedScore
+    })) : void 0;
+    return {
+      match: confidence !== "none" ? match : null,
+      confidence,
+      gap,
+      alternatives
+    };
+  }
+  /**
+   * Calculate days between two dates
+   */
+  static calculateAgeDays(timestamp) {
+    const now = /* @__PURE__ */ new Date();
+    const diffMs = now.getTime() - timestamp.getTime();
+    return diffMs / (1e3 * 60 * 60 * 24);
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+var defaultMatcher = null;
+function getDefaultMatcher() {
+  if (!defaultMatcher) {
+    defaultMatcher = new Matcher();
+  }
+  return defaultMatcher;
+}
+
+// src/core/evidence-aligner.ts
+import { createHash as createHash2 } from "crypto";
+var DEFAULT_OPTIONS = {
+  minMatchLength: 10,
+  fuzzyThreshold: 0.8,
+  maxMissingClaims: 2
+};
+var DEFAULT_OPTIONS_V2 = {
+  minMatchLength: 5,
+  exactMatchBonus: 1,
+  normalizedThreshold: 0.95,
+  fuzzyThreshold: 0.85,
+  maxMissingRatio: 0.2
+};
+var EvidenceAligner = class {
+  options;
+  constructor(options = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  /**
+   * Align claims against source content
+   * Returns evidence spans showing where claims are supported
+   */
+  align(claims, sourceContent) {
+    const spans = [];
+    const missingClaims = [];
+    const normalizedSource = this.normalize(sourceContent);
+    for (const claim of claims) {
+      const normalizedClaim = this.normalize(claim);
+      if (normalizedClaim.length < this.options.minMatchLength) {
+        continue;
+      }
+      const exactSpan = this.findExactMatch(normalizedClaim, normalizedSource, sourceContent);
+      if (exactSpan) {
+        spans.push(exactSpan);
+        continue;
+      }
+      const fuzzySpan = this.findFuzzyMatch(normalizedClaim, normalizedSource, sourceContent);
+      if (fuzzySpan && fuzzySpan.confidence >= this.options.fuzzyThreshold) {
+        spans.push(fuzzySpan);
+        continue;
+      }
+      missingClaims.push(claim);
+    }
+    const totalClaims = claims.length;
+    const alignedClaims = spans.length;
+    const confidence = totalClaims > 0 ? alignedClaims / totalClaims : 1;
+    const isAligned = missingClaims.length <= this.options.maxMissingClaims;
+    return {
+      isAligned,
+      confidence,
+      spans,
+      missingClaims
+    };
+  }
+  /**
+   * Find exact substring match
+   */
+  findExactMatch(normalizedClaim, normalizedSource, originalSource) {
+    const index = normalizedSource.indexOf(normalizedClaim);
+    if (index === -1) {
+      return null;
+    }
+    return {
+      start: index,
+      end: index + normalizedClaim.length,
+      confidence: 1,
+      matchType: "exact",
+      originalQuote: originalSource.slice(index, index + normalizedClaim.length),
+      alignedText: normalizedClaim
+    };
+  }
+  /**
+   * Find fuzzy match using sliding window
+   */
+  findFuzzyMatch(normalizedClaim, normalizedSource, originalSource) {
+    const windowSize = normalizedClaim.length;
+    let bestMatch = null;
+    for (let i = 0; i <= normalizedSource.length - windowSize; i++) {
+      const window = normalizedSource.slice(i, i + windowSize);
+      const similarity = this.calculateSimilarity(normalizedClaim, window);
+      if (!bestMatch || similarity > bestMatch.similarity) {
+        bestMatch = { index: i, similarity };
+      }
+    }
+    if (!bestMatch || bestMatch.similarity < this.options.fuzzyThreshold) {
+      return null;
+    }
+    return {
+      start: bestMatch.index,
+      end: bestMatch.index + windowSize,
+      confidence: bestMatch.similarity,
+      matchType: "fuzzy",
+      originalQuote: originalSource.slice(bestMatch.index, bestMatch.index + windowSize),
+      alignedText: normalizedClaim
+    };
+  }
+  /**
+   * Calculate similarity between two strings using Jaccard coefficient
+   */
+  calculateSimilarity(a, b) {
+    const setA = new Set(this.tokenize(a));
+    const setB = new Set(this.tokenize(b));
+    const intersection = new Set([...setA].filter((x) => setB.has(x)));
+    const union = /* @__PURE__ */ new Set([...setA, ...setB]);
+    return intersection.size / union.size;
+  }
+  /**
+   * Tokenize text into words
+   */
+  tokenize(text) {
+    return text.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+  }
+  /**
+   * Normalize text for comparison
+   */
+  normalize(text) {
+    return text.normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, "").replace(/\s+/g, " ").trim();
+  }
+  /**
+   * Extract claims from a response text
+   * Splits on sentence boundaries and filters short sentences
+   */
+  extractClaims(text) {
+    const sentences = text.split(/[.!?]+/).map((s) => s.trim()).filter((s) => s.length > 0);
+    return sentences.filter((s) => {
+      return s.length >= this.options.minMatchLength && !s.endsWith("?");
+    });
+  }
+  /**
+   * Verify that a response is grounded in the provided context
+   */
+  verifyGrounding(response, context) {
+    const claims = this.extractClaims(response);
+    const combinedContext = context.join(" ");
+    return this.align(claims, combinedContext);
+  }
+  // ============================================================
+  // V2 Methods: Quote-only alignment
+  // ============================================================
+  optionsV2 = DEFAULT_OPTIONS_V2;
+  /**
+   * Configure V2 options
+   */
+  configureV2(options) {
+    this.optionsV2 = { ...DEFAULT_OPTIONS_V2, ...options };
+  }
+  /**
+   * Align V2: Process extracted evidence with messageIndex and quote
+   * @param sessionMessages - Array of session messages (original text)
+   * @param evidence - Array of extracted evidence (messageIndex + quote)
+   */
+  alignV2(sessionMessages, evidence) {
+    const results = [];
+    let alignedCount = 0;
+    let totalConfidence = 0;
+    for (const ev of evidence) {
+      const result = this.alignSingleEvidence(sessionMessages, ev);
+      results.push(result);
+      if (result.aligned) {
+        alignedCount++;
+        totalConfidence += result.evidence.confidence;
+      }
+    }
+    const failedCount = evidence.length - alignedCount;
+    const maxMissing = Math.floor(evidence.length * this.optionsV2.maxMissingRatio);
+    const evidenceAligned = failedCount <= maxMissing;
+    const overallConfidence = evidence.length > 0 ? totalConfidence / evidence.length : 1;
+    return {
+      evidenceAligned,
+      alignedCount,
+      failedCount,
+      results,
+      overallConfidence
+    };
+  }
+  /**
+   * Align a single evidence item
+   */
+  alignSingleEvidence(sessionMessages, evidence) {
+    const { messageIndex, quote } = evidence;
+    if (messageIndex < 0 || messageIndex >= sessionMessages.length) {
+      return {
+        aligned: false,
+        evidence: {
+          messageIndex,
+          quote,
+          failureReason: "invalid_index"
+        }
+      };
+    }
+    if (!quote || quote.trim().length === 0) {
+      return {
+        aligned: false,
+        evidence: {
+          messageIndex,
+          quote,
+          failureReason: "empty_quote"
+        }
+      };
+    }
+    const sourceMessage = sessionMessages[messageIndex];
+    const exactResult = this.tryExactMatchV2(quote, sourceMessage, messageIndex);
+    if (exactResult) {
+      return exactResult;
+    }
+    const normalizedResult = this.tryNormalizedMatchV2(quote, sourceMessage, messageIndex);
+    if (normalizedResult) {
+      return normalizedResult;
+    }
+    const fuzzyResult = this.tryFuzzyMatchV2(quote, sourceMessage, messageIndex);
+    if (fuzzyResult) {
+      return fuzzyResult;
+    }
+    return {
+      aligned: false,
+      evidence: {
+        messageIndex,
+        quote,
+        failureReason: "not_found"
+      }
+    };
+  }
+  /**
+   * Try exact substring match
+   */
+  tryExactMatchV2(quote, source, messageIndex) {
+    const index = source.indexOf(quote);
+    if (index === -1) {
+      return null;
+    }
+    return {
+      aligned: true,
+      evidence: {
+        messageIndex,
+        quote,
+        spanStart: index,
+        spanEnd: index + quote.length,
+        quoteHash: this.hashQuote(quote),
+        confidence: 1,
+        matchMethod: "exact"
+      }
+    };
+  }
+  /**
+   * Try normalized match (whitespace collapsed)
+   */
+  tryNormalizedMatchV2(quote, source, messageIndex) {
+    const normalizedQuote = this.normalizeWhitespace(quote);
+    const normalizedSource = this.normalizeWhitespace(source);
+    const normalizedIndex = normalizedSource.indexOf(normalizedQuote);
+    if (normalizedIndex === -1) {
+      return null;
+    }
+    const originalSpan = this.mapToOriginalPositions(
+      source,
+      normalizedSource,
+      normalizedIndex,
+      normalizedIndex + normalizedQuote.length
+    );
+    if (!originalSpan) {
+      return null;
+    }
+    return {
+      aligned: true,
+      evidence: {
+        messageIndex,
+        quote,
+        spanStart: originalSpan.start,
+        spanEnd: originalSpan.end,
+        quoteHash: this.hashQuote(quote),
+        confidence: 0.95,
+        matchMethod: "normalized"
+      }
+    };
+  }
+  /**
+   * Try fuzzy match using sliding window
+   */
+  tryFuzzyMatchV2(quote, source, messageIndex) {
+    const normalizedQuote = this.normalize(quote);
+    const normalizedSource = this.normalize(source);
+    if (normalizedQuote.length < this.optionsV2.minMatchLength) {
+      return null;
+    }
+    const windowSizes = [
+      normalizedQuote.length,
+      Math.floor(normalizedQuote.length * 1.1),
+      Math.floor(normalizedQuote.length * 1.2)
+    ];
+    let bestMatch = null;
+    for (const windowSize of windowSizes) {
+      for (let i = 0; i <= normalizedSource.length - windowSize; i++) {
+        const window = normalizedSource.slice(i, i + windowSize);
+        const similarity = this.calculateLevenshteinSimilarity(normalizedQuote, window);
+        if (similarity >= this.optionsV2.fuzzyThreshold) {
+          if (!bestMatch || similarity > bestMatch.similarity) {
+            bestMatch = { index: i, windowSize, similarity };
+          }
+        }
+      }
+    }
+    if (!bestMatch) {
+      return null;
+    }
+    const originalSpan = this.mapToOriginalPositions(
+      source,
+      normalizedSource,
+      bestMatch.index,
+      bestMatch.index + bestMatch.windowSize
+    );
+    if (!originalSpan) {
+      return null;
+    }
+    return {
+      aligned: true,
+      evidence: {
+        messageIndex,
+        quote,
+        spanStart: originalSpan.start,
+        spanEnd: originalSpan.end,
+        quoteHash: this.hashQuote(quote),
+        confidence: bestMatch.similarity,
+        matchMethod: "fuzzy"
+      }
+    };
+  }
+  /**
+   * Normalize whitespace only (preserve other characters)
+   */
+  normalizeWhitespace(text) {
+    return text.replace(/[\t\r]/g, " ").replace(/\n+/g, " ").replace(/ +/g, " ").trim();
+  }
+  /**
+   * Map normalized positions back to original
+   */
+  mapToOriginalPositions(original, normalized, normalizedStart, normalizedEnd) {
+    const normalizedToOriginal = /* @__PURE__ */ new Map();
+    let normalizedPos = 0;
+    for (let origPos = 0; origPos < original.length; origPos++) {
+      const char = original[origPos];
+      if (/\s/.test(char)) {
+        if (normalizedPos < normalized.length && /\s/.test(normalized[normalizedPos])) {
+          normalizedToOriginal.set(normalizedPos, origPos);
+          normalizedPos++;
+          while (origPos + 1 < original.length && /\s/.test(original[origPos + 1])) {
+            origPos++;
+          }
+        }
+      } else {
+        normalizedToOriginal.set(normalizedPos, origPos);
+        normalizedPos++;
+      }
+    }
+    const startOrig = normalizedToOriginal.get(normalizedStart);
+    let endOrig = normalizedToOriginal.get(normalizedEnd - 1);
+    if (startOrig === void 0) {
+      return null;
+    }
+    if (endOrig === void 0) {
+      endOrig = original.length - 1;
+    }
+    return {
+      start: startOrig,
+      end: endOrig + 1
+    };
+  }
+  /**
+   * Calculate Levenshtein distance similarity
+   */
+  calculateLevenshteinSimilarity(a, b) {
+    const m = a.length;
+    const n = b.length;
+    if (m === 0)
+      return n === 0 ? 1 : 0;
+    if (n === 0)
+      return 0;
+    const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+      dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+      dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+        dp[i][j] = Math.min(
+          dp[i - 1][j] + 1,
+          // deletion
+          dp[i][j - 1] + 1,
+          // insertion
+          dp[i - 1][j - 1] + cost
+          // substitution
+        );
+      }
+    }
+    const distance = dp[m][n];
+    const maxLen = Math.max(m, n);
+    return 1 - distance / maxLen;
+  }
+  /**
+   * Hash quote for deduplication
+   */
+  hashQuote(quote) {
+    return createHash2("sha256").update(quote).digest("hex").slice(0, 16);
+  }
+  /**
+   * Convert V2 result to V1 format for backwards compatibility
+   */
+  convertToV1Result(v2Result) {
+    const spans = [];
+    const missingClaims = [];
+    for (const result of v2Result.results) {
+      if (result.aligned) {
+        const ev = result.evidence;
+        spans.push({
+          start: ev.spanStart,
+          end: ev.spanEnd,
+          confidence: ev.confidence,
+          matchType: ev.matchMethod === "exact" ? "exact" : "fuzzy",
+          originalQuote: ev.quote,
+          alignedText: ev.quote
+        });
+      } else {
+        const ev = result.evidence;
+        missingClaims.push(ev.quote);
+      }
+    }
+    return {
+      isAligned: v2Result.evidenceAligned,
+      confidence: v2Result.overallConfidence,
+      spans,
+      missingClaims
+    };
+  }
+};
+var defaultAligner = null;
+function getDefaultAligner() {
+  if (!defaultAligner) {
+    defaultAligner = new EvidenceAligner();
+  }
+  return defaultAligner;
+}
+
+// src/core/retriever.ts
+var DEFAULT_OPTIONS2 = {
+  topK: 5,
+  minScore: 0.7,
+  maxTokens: 2e3,
+  includeSessionContext: true
+};
+var Retriever = class {
+  eventStore;
+  vectorStore;
+  embedder;
+  matcher;
+  constructor(eventStore, vectorStore, embedder, matcher) {
+    this.eventStore = eventStore;
+    this.vectorStore = vectorStore;
+    this.embedder = embedder;
+    this.matcher = matcher;
+  }
+  /**
+   * Retrieve relevant memories for a query
+   */
+  async retrieve(query, options = {}) {
+    const opts = { ...DEFAULT_OPTIONS2, ...options };
+    const queryEmbedding = await this.embedder.embed(query);
+    const searchResults = await this.vectorStore.search(queryEmbedding.vector, {
+      limit: opts.topK * 2,
+      // Get extra for filtering
+      minScore: opts.minScore,
+      sessionId: opts.sessionId
+    });
+    const matchResult = this.matcher.matchSearchResults(
+      searchResults,
+      (eventId) => this.getEventAgeDays(eventId)
+    );
+    const memories = await this.enrichResults(searchResults.slice(0, opts.topK), opts);
+    const context = this.buildContext(memories, opts.maxTokens);
+    return {
+      memories,
+      matchResult,
+      totalTokens: this.estimateTokens(context),
+      context
+    };
+  }
+  /**
+   * Retrieve memories from a specific session
+   */
+  async retrieveFromSession(sessionId) {
+    return this.eventStore.getSessionEvents(sessionId);
+  }
+  /**
+   * Get recent memories across all sessions
+   */
+  async retrieveRecent(limit = 100) {
+    return this.eventStore.getRecentEvents(limit);
+  }
+  /**
+   * Enrich search results with full event data
+   */
+  async enrichResults(results, options) {
+    const memories = [];
+    for (const result of results) {
+      const event = await this.eventStore.getEvent(result.eventId);
+      if (!event)
+        continue;
+      let sessionContext;
+      if (options.includeSessionContext) {
+        sessionContext = await this.getSessionContext(event.sessionId, event.id);
+      }
+      memories.push({
+        event,
+        score: result.score,
+        sessionContext
+      });
+    }
+    return memories;
+  }
+  /**
+   * Get surrounding context from the same session
+   */
+  async getSessionContext(sessionId, eventId) {
+    const sessionEvents = await this.eventStore.getSessionEvents(sessionId);
+    const eventIndex = sessionEvents.findIndex((e) => e.id === eventId);
+    if (eventIndex === -1)
+      return void 0;
+    const start = Math.max(0, eventIndex - 1);
+    const end = Math.min(sessionEvents.length, eventIndex + 2);
+    const contextEvents = sessionEvents.slice(start, end);
+    if (contextEvents.length <= 1)
+      return void 0;
+    return contextEvents.filter((e) => e.id !== eventId).map((e) => `[${e.eventType}]: ${e.content.slice(0, 200)}...`).join("\n");
+  }
+  /**
+   * Build context string from memories (respecting token limit)
+   */
+  buildContext(memories, maxTokens) {
+    const parts = [];
+    let currentTokens = 0;
+    for (const memory of memories) {
+      const memoryText = this.formatMemory(memory);
+      const memoryTokens = this.estimateTokens(memoryText);
+      if (currentTokens + memoryTokens > maxTokens) {
+        break;
+      }
+      parts.push(memoryText);
+      currentTokens += memoryTokens;
+    }
+    if (parts.length === 0) {
+      return "";
+    }
+    return `## Relevant Memories
+
+${parts.join("\n\n---\n\n")}`;
+  }
+  /**
+   * Format a single memory for context
+   */
+  formatMemory(memory) {
+    const { event, score, sessionContext } = memory;
+    const date = event.timestamp.toISOString().split("T")[0];
+    let text = `**${event.eventType}** (${date}, score: ${score.toFixed(2)})
+${event.content}`;
+    if (sessionContext) {
+      text += `
+
+_Context:_ ${sessionContext}`;
+    }
+    return text;
+  }
+  /**
+   * Estimate token count (rough approximation)
+   */
+  estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Get event age in days (for recency scoring)
+   */
+  getEventAgeDays(eventId) {
+    return 0;
+  }
+};
+function createRetriever(eventStore, vectorStore, embedder, matcher) {
+  return new Retriever(eventStore, vectorStore, embedder, matcher);
+}
+
+// src/core/graduation.ts
+var DEFAULT_CRITERIA = {
+  L0toL1: {
+    minAccessCount: 1,
+    minConfidence: 0.5,
+    minCrossSessionRefs: 0,
+    maxAgeDays: 30
+  },
+  L1toL2: {
+    minAccessCount: 3,
+    minConfidence: 0.7,
+    minCrossSessionRefs: 1,
+    maxAgeDays: 60
+  },
+  L2toL3: {
+    minAccessCount: 5,
+    minConfidence: 0.85,
+    minCrossSessionRefs: 2,
+    maxAgeDays: 90
+  },
+  L3toL4: {
+    minAccessCount: 10,
+    minConfidence: 0.92,
+    minCrossSessionRefs: 3,
+    maxAgeDays: 180
+  }
+};
+var GraduationPipeline = class {
+  eventStore;
+  criteria;
+  metrics = /* @__PURE__ */ new Map();
+  constructor(eventStore, criteria = {}) {
+    this.eventStore = eventStore;
+    this.criteria = {
+      L0toL1: { ...DEFAULT_CRITERIA.L0toL1, ...criteria.L0toL1 },
+      L1toL2: { ...DEFAULT_CRITERIA.L1toL2, ...criteria.L1toL2 },
+      L2toL3: { ...DEFAULT_CRITERIA.L2toL3, ...criteria.L2toL3 },
+      L3toL4: { ...DEFAULT_CRITERIA.L3toL4, ...criteria.L3toL4 }
+    };
+  }
+  /**
+   * Record an access to an event (used for graduation scoring)
+   */
+  recordAccess(eventId, fromSessionId, confidence = 1) {
+    const existing = this.metrics.get(eventId);
+    if (existing) {
+      existing.accessCount++;
+      existing.lastAccessed = /* @__PURE__ */ new Date();
+      existing.confidence = Math.max(existing.confidence, confidence);
+    } else {
+      this.metrics.set(eventId, {
+        eventId,
+        accessCount: 1,
+        lastAccessed: /* @__PURE__ */ new Date(),
+        crossSessionRefs: 0,
+        confidence
+      });
+    }
+  }
+  /**
+   * Evaluate if an event should graduate to the next level
+   */
+  async evaluateGraduation(eventId, currentLevel) {
+    const metrics = this.metrics.get(eventId);
+    if (!metrics) {
+      return {
+        eventId,
+        fromLevel: currentLevel,
+        toLevel: currentLevel,
+        success: false,
+        reason: "No metrics available for event"
+      };
+    }
+    const nextLevel = this.getNextLevel(currentLevel);
+    if (!nextLevel) {
+      return {
+        eventId,
+        fromLevel: currentLevel,
+        toLevel: currentLevel,
+        success: false,
+        reason: "Already at maximum level"
+      };
+    }
+    const criteria = this.getCriteria(currentLevel, nextLevel);
+    const evaluation = this.checkCriteria(metrics, criteria);
+    if (evaluation.passed) {
+      await this.eventStore.updateMemoryLevel(eventId, nextLevel);
+      return {
+        eventId,
+        fromLevel: currentLevel,
+        toLevel: nextLevel,
+        success: true
+      };
+    }
+    return {
+      eventId,
+      fromLevel: currentLevel,
+      toLevel: currentLevel,
+      success: false,
+      reason: evaluation.reason
+    };
+  }
+  /**
+   * Run graduation evaluation for all events at a given level
+   */
+  async graduateBatch(level) {
+    const results = [];
+    for (const [eventId, metrics] of this.metrics) {
+      const result = await this.evaluateGraduation(eventId, level);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Extract insights from graduated events (L1+)
+   */
+  extractInsights(events) {
+    const insights = [];
+    const patterns = this.detectPatterns(events);
+    for (const pattern of patterns) {
+      insights.push({
+        id: crypto.randomUUID(),
+        insightType: "pattern",
+        content: pattern.description,
+        canonicalKey: pattern.key,
+        confidence: pattern.confidence,
+        sourceEvents: pattern.eventIds,
+        createdAt: /* @__PURE__ */ new Date(),
+        lastUpdated: /* @__PURE__ */ new Date()
+      });
+    }
+    const preferences = this.detectPreferences(events);
+    for (const pref of preferences) {
+      insights.push({
+        id: crypto.randomUUID(),
+        insightType: "preference",
+        content: pref.description,
+        canonicalKey: pref.key,
+        confidence: pref.confidence,
+        sourceEvents: pref.eventIds,
+        createdAt: /* @__PURE__ */ new Date(),
+        lastUpdated: /* @__PURE__ */ new Date()
+      });
+    }
+    return insights;
+  }
+  /**
+   * Get the next level in the graduation pipeline
+   */
+  getNextLevel(current) {
+    const levels = ["L0", "L1", "L2", "L3", "L4"];
+    const currentIndex = levels.indexOf(current);
+    if (currentIndex === -1 || currentIndex >= levels.length - 1) {
+      return null;
+    }
+    return levels[currentIndex + 1];
+  }
+  /**
+   * Get criteria for level transition
+   */
+  getCriteria(from, to) {
+    const key = `${from}to${to}`;
+    return this.criteria[key] || DEFAULT_CRITERIA.L0toL1;
+  }
+  /**
+   * Check if metrics meet criteria
+   */
+  checkCriteria(metrics, criteria) {
+    if (metrics.accessCount < criteria.minAccessCount) {
+      return {
+        passed: false,
+        reason: `Access count ${metrics.accessCount} < ${criteria.minAccessCount}`
+      };
+    }
+    if (metrics.confidence < criteria.minConfidence) {
+      return {
+        passed: false,
+        reason: `Confidence ${metrics.confidence} < ${criteria.minConfidence}`
+      };
+    }
+    if (metrics.crossSessionRefs < criteria.minCrossSessionRefs) {
+      return {
+        passed: false,
+        reason: `Cross-session refs ${metrics.crossSessionRefs} < ${criteria.minCrossSessionRefs}`
+      };
+    }
+    const ageDays = (Date.now() - metrics.lastAccessed.getTime()) / (1e3 * 60 * 60 * 24);
+    if (ageDays > criteria.maxAgeDays) {
+      return {
+        passed: false,
+        reason: `Event too old: ${ageDays.toFixed(1)} days > ${criteria.maxAgeDays}`
+      };
+    }
+    return { passed: true };
+  }
+  /**
+   * Detect patterns in events
+   */
+  detectPatterns(events) {
+    const keyGroups = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      const existing = keyGroups.get(event.canonicalKey) || [];
+      existing.push(event);
+      keyGroups.set(event.canonicalKey, existing);
+    }
+    const patterns = [];
+    for (const [key, groupEvents] of keyGroups) {
+      if (groupEvents.length >= 2) {
+        patterns.push({
+          key,
+          description: `Repeated topic: ${key.slice(0, 50)}`,
+          confidence: Math.min(1, groupEvents.length / 5),
+          eventIds: groupEvents.map((e) => e.id)
+        });
+      }
+    }
+    return patterns;
+  }
+  /**
+   * Detect user preferences from events
+   */
+  detectPreferences(events) {
+    const preferenceKeywords = ["prefer", "like", "want", "always", "never", "favorite"];
+    const preferences = [];
+    for (const event of events) {
+      if (event.eventType !== "user_prompt")
+        continue;
+      const lowerContent = event.content.toLowerCase();
+      for (const keyword of preferenceKeywords) {
+        if (lowerContent.includes(keyword)) {
+          preferences.push({
+            key: `preference_${keyword}_${event.id.slice(0, 8)}`,
+            description: `User preference: ${event.content.slice(0, 100)}`,
+            confidence: 0.7,
+            eventIds: [event.id]
+          });
+          break;
+        }
+      }
+    }
+    return preferences;
+  }
+  /**
+   * Get graduation statistics
+   */
+  async getStats() {
+    return this.eventStore.getLevelStats();
+  }
+};
+function createGraduationPipeline(eventStore) {
+  return new GraduationPipeline(eventStore);
+}
+
+// src/core/task/task-matcher.ts
+var DEFAULT_CONFIG4 = {
+  minCombinedScore: MATCH_THRESHOLDS.minCombinedScore,
+  minGap: MATCH_THRESHOLDS.minGap,
+  suggestionThreshold: MATCH_THRESHOLDS.suggestionThreshold,
+  maxCandidates: 5
+};
+var TaskMatcher = class {
+  constructor(db, config) {
+    this.db = db;
+    this.config = { ...DEFAULT_CONFIG4, ...config };
+  }
+  config;
+  /**
+   * Find task by exact canonical key match
+   */
+  async findExact(title, project) {
+    const canonicalKey = makeEntityCanonicalKey("task", title, { project });
+    const rows = await this.db.all(
+      `SELECT * FROM entities
+       WHERE entity_type = 'task' AND canonical_key = ?
+       AND status = 'active'`,
+      [canonicalKey]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToEntity(rows[0]);
+  }
+  /**
+   * Find task by alias
+   */
+  async findByAlias(title, project) {
+    const canonicalKey = makeEntityCanonicalKey("task", title, { project });
+    const rows = await this.db.all(
+      `SELECT e.* FROM entities e
+       JOIN entity_aliases a ON e.entity_id = a.entity_id
+       WHERE a.entity_type = 'task' AND a.canonical_key = ?
+       AND e.status = 'active'`,
+      [canonicalKey]
+    );
+    if (rows.length === 0)
+      return null;
+    return this.rowToEntity(rows[0]);
+  }
+  /**
+   * Search tasks by text (FTS-like)
+   */
+  async searchByText(query, project) {
+    const searchPattern = `%${query.toLowerCase()}%`;
+    let sql = `
+      SELECT *,
+        CASE
+          WHEN title_norm = ? THEN 1.0
+          WHEN title_norm LIKE ? THEN 0.9
+          ELSE 0.7
+        END as match_score
+      FROM entities
+      WHERE entity_type = 'task'
+        AND status = 'active'
+        AND (title_norm LIKE ? OR search_text LIKE ?)
+    `;
+    const normalizedQuery = query.toLowerCase().trim();
+    const params = [normalizedQuery, `%${normalizedQuery}%`, searchPattern, searchPattern];
+    if (project) {
+      sql += ` AND json_extract(current_json, '$.project') = ?`;
+      params.push(project);
+    }
+    sql += ` ORDER BY match_score DESC, updated_at DESC LIMIT ?`;
+    params.push(this.config.maxCandidates);
+    const rows = await this.db.all(sql, params);
+    return rows.map((row) => ({
+      entity: this.rowToEntity(row),
+      score: row.match_score
+    }));
+  }
+  /**
+   * Match task with confidence classification
+   * Returns high confidence only if score ≥ 0.92 AND gap ≥ 0.03
+   */
+  async match(title, project) {
+    const exactMatch = await this.findExact(title, project);
+    if (exactMatch) {
+      return {
+        match: exactMatch,
+        confidence: "high",
+        score: 1
+      };
+    }
+    const aliasMatch = await this.findByAlias(title, project);
+    if (aliasMatch) {
+      return {
+        match: aliasMatch,
+        confidence: "high",
+        score: 0.98
+      };
+    }
+    const searchResults = await this.searchByText(title, project);
+    if (searchResults.length === 0) {
+      return {
+        match: null,
+        confidence: "none",
+        score: 0
+      };
+    }
+    const topResult = searchResults[0];
+    const secondScore = searchResults.length > 1 ? searchResults[1].score : null;
+    const gap = secondScore !== null ? topResult.score - secondScore : Infinity;
+    const confidence = this.classifyConfidence(topResult.score, gap);
+    if (confidence === "high") {
+      return {
+        match: topResult.entity,
+        confidence: "high",
+        score: topResult.score,
+        gap
+      };
+    }
+    if (confidence === "suggested") {
+      return {
+        match: null,
+        confidence: "suggested",
+        score: topResult.score,
+        gap,
+        candidates: searchResults.slice(0, this.config.maxCandidates).map((r) => r.entity)
+      };
+    }
+    return {
+      match: null,
+      confidence: "none",
+      score: topResult.score
+    };
+  }
+  /**
+   * Classify confidence based on AXIOMMIND thresholds
+   */
+  classifyConfidence(score, gap) {
+    const { minCombinedScore, minGap, suggestionThreshold } = this.config;
+    if (score >= minCombinedScore && gap >= minGap) {
+      return "high";
+    }
+    if (score >= suggestionThreshold) {
+      return "suggested";
+    }
+    return "none";
+  }
+  /**
+   * Get suggestion candidates (for condition fallback)
+   */
+  async getSuggestionCandidates(title, project) {
+    const searchResults = await this.searchByText(title, project);
+    return searchResults.filter((r) => r.score >= this.config.suggestionThreshold).slice(0, this.config.maxCandidates).map((r) => r.entity);
+  }
+  /**
+   * Convert database row to Entity
+   */
+  rowToEntity(row) {
+    return {
+      entityId: row.entity_id,
+      entityType: row.entity_type,
+      canonicalKey: row.canonical_key,
+      title: row.title,
+      stage: row.stage,
+      status: row.status,
+      currentJson: typeof row.current_json === "string" ? JSON.parse(row.current_json) : row.current_json,
+      titleNorm: row.title_norm,
+      searchText: row.search_text,
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at)
+    };
+  }
+};
+
+// src/core/task/blocker-resolver.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var URL_PATTERN = /^https?:\/\/.+/;
+var JIRA_PATTERN = /^[A-Z]+-\d+$/;
+var GITHUB_ISSUE_PATTERN = /^[^\/]+\/[^#]+#\d+$/;
+var TASK_ID_PATTERN = /^task:[^:]+:[^:]+$/;
+var BlockerResolver = class {
+  constructor(db, config = {}) {
+    this.db = db;
+    this.config = config;
+    this.taskMatcher = new TaskMatcher(db);
+  }
+  taskMatcher;
+  /**
+   * Resolve a single blocker text to entity reference
+   * Rules:
+   * 1. Strong ID/URL/key pattern → artifact
+   * 2. Explicit task_id → task
+   * 3. Task title match (strict only) → task
+   * 4. Fallback → condition (no stub task creation)
+   */
+  async resolveBlocker(text, sourceEntryId) {
+    const trimmedText = text.trim();
+    const artifactRef = await this.tryResolveAsArtifact(trimmedText);
+    if (artifactRef) {
+      return artifactRef;
+    }
+    if (TASK_ID_PATTERN.test(trimmedText)) {
+      const taskRef = await this.tryResolveAsTaskId(trimmedText);
+      if (taskRef) {
+        return taskRef;
+      }
+    }
+    const taskMatch = await this.taskMatcher.match(trimmedText, this.config.project);
+    if (taskMatch.confidence === "high" && taskMatch.match) {
+      return {
+        kind: "task",
+        entityId: taskMatch.match.entityId,
+        rawText: trimmedText,
+        confidence: taskMatch.score
+      };
+    }
+    const conditionRef = await this.createConditionBlocker(
+      trimmedText,
+      taskMatch.candidates
+    );
+    return conditionRef;
+  }
+  /**
+   * Resolve multiple blocker texts
+   */
+  async resolveBlockers(texts, sourceEntryId) {
+    const results = [];
+    for (const text of texts) {
+      const ref = await this.resolveBlocker(text, sourceEntryId);
+      results.push(ref);
+    }
+    return results;
+  }
+  /**
+   * Try to resolve as artifact (URL, JIRA, GitHub)
+   */
+  async tryResolveAsArtifact(text) {
+    if (!URL_PATTERN.test(text) && !JIRA_PATTERN.test(text) && !GITHUB_ISSUE_PATTERN.test(text)) {
+      return null;
+    }
+    const canonicalKey = makeArtifactKey(text);
+    const existing = await this.db.all(
+      `SELECT entity_id FROM entities
+       WHERE entity_type = 'artifact' AND canonical_key = ?`,
+      [canonicalKey]
+    );
+    let entityId;
+    if (existing.length > 0) {
+      entityId = existing[0].entity_id;
+    } else {
+      entityId = await this.declareArtifact(text, canonicalKey);
+    }
+    return {
+      kind: "artifact",
+      entityId,
+      rawText: text,
+      confidence: 1
+    };
+  }
+  /**
+   * Try to resolve as explicit task ID
+   */
+  async tryResolveAsTaskId(taskId) {
+    const rows = await this.db.all(
+      `SELECT entity_id FROM entities
+       WHERE entity_type = 'task' AND canonical_key = ?
+       AND status = 'active'`,
+      [taskId]
+    );
+    if (rows.length === 0) {
+      return null;
+    }
+    return {
+      kind: "task",
+      entityId: rows[0].entity_id,
+      rawText: taskId,
+      confidence: 1
+    };
+  }
+  /**
+   * Create condition blocker (get-or-create)
+   */
+  async createConditionBlocker(text, candidates) {
+    const canonicalKey = makeEntityCanonicalKey("condition", text, {
+      project: this.config.project
+    });
+    const existing = await this.db.all(
+      `SELECT entity_id FROM entities
+       WHERE entity_type = 'condition' AND canonical_key = ?`,
+      [canonicalKey]
+    );
+    let entityId;
+    if (existing.length > 0) {
+      entityId = existing[0].entity_id;
+    } else {
+      entityId = await this.declareCondition(text, canonicalKey, candidates);
+    }
+    return {
+      kind: "condition",
+      entityId,
+      rawText: text,
+      confidence: 0.5,
+      candidates: candidates?.map((c) => c.entityId)
+    };
+  }
+  /**
+   * Declare a new condition entity
+   */
+  async declareCondition(text, canonicalKey, candidates) {
+    const entityId = randomUUID5();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const currentJson = {
+      text,
+      resolved: false,
+      candidates: candidates?.map((c) => ({
+        entityId: c.entityId,
+        title: c.title
+      }))
+    };
+    await this.db.run(
+      `INSERT INTO entities (
+        entity_id, entity_type, canonical_key, title, stage, status,
+        current_json, title_norm, search_text, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        entityId,
+        "condition",
+        canonicalKey,
+        text,
+        "raw",
+        "active",
+        JSON.stringify(currentJson),
+        text.toLowerCase().trim(),
+        text,
+        now,
+        now
+      ]
+    );
+    await this.db.run(
+      `INSERT INTO entity_aliases (entity_type, canonical_key, entity_id, is_primary)
+       VALUES (?, ?, ?, TRUE)
+       ON CONFLICT (entity_type, canonical_key) DO NOTHING`,
+      ["condition", canonicalKey, entityId]
+    );
+    return entityId;
+  }
+  /**
+   * Declare a new artifact entity
+   */
+  async declareArtifact(identifier, canonicalKey) {
+    const entityId = randomUUID5();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let artifactType = "generic";
+    if (URL_PATTERN.test(identifier)) {
+      artifactType = "url";
+    } else if (JIRA_PATTERN.test(identifier)) {
+      artifactType = "jira";
+    } else if (GITHUB_ISSUE_PATTERN.test(identifier)) {
+      artifactType = "github_issue";
+    }
+    const currentJson = {
+      identifier,
+      artifactType
+    };
+    await this.db.run(
+      `INSERT INTO entities (
+        entity_id, entity_type, canonical_key, title, stage, status,
+        current_json, title_norm, search_text, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        entityId,
+        "artifact",
+        canonicalKey,
+        identifier,
+        "raw",
+        "active",
+        JSON.stringify(currentJson),
+        identifier.toLowerCase(),
+        identifier,
+        now,
+        now
+      ]
+    );
+    await this.db.run(
+      `INSERT INTO entity_aliases (entity_type, canonical_key, entity_id, is_primary)
+       VALUES (?, ?, ?, TRUE)
+       ON CONFLICT (entity_type, canonical_key) DO NOTHING`,
+      ["artifact", canonicalKey, entityId]
+    );
+    return entityId;
+  }
+  /**
+   * Create unknown placeholder condition
+   * Used when task is blocked but no blocker text provided
+   */
+  async createUnknownPlaceholder(taskTitle) {
+    const text = `Unknown blocker for: ${taskTitle}`;
+    const ref = await this.createConditionBlocker(text);
+    await this.db.run(
+      `UPDATE entities
+       SET current_json = json_set(current_json, '$.auto_placeholder', true)
+       WHERE entity_id = ?`,
+      [ref.entityId]
+    );
+    return {
+      ...ref,
+      confidence: 0
+    };
+  }
+};
+
+// src/core/task/task-resolver.ts
+import { randomUUID as randomUUID6 } from "crypto";
+var VALID_TRANSITIONS = {
+  pending: ["in_progress", "cancelled"],
+  in_progress: ["blocked", "done", "cancelled"],
+  blocked: ["in_progress", "done", "cancelled"],
+  done: [],
+  // Terminal state
+  cancelled: []
+  // Terminal state
+};
+var TaskResolver = class {
+  constructor(db, config) {
+    this.db = db;
+    this.config = config;
+    this.taskMatcher = new TaskMatcher(db);
+    this.blockerResolver = new BlockerResolver(db, { project: config.project });
+  }
+  taskMatcher;
+  blockerResolver;
+  /**
+   * Process extracted task entry
+   * 1. Find or create task entity
+   * 2. Emit status/priority change events if needed
+   * 3. Process blockers
+   */
+  async processTask(extracted, sourceEntryId) {
+    const events = [];
+    const { task, isNew, eventId: createEventId } = await this.findOrCreateTask(extracted);
+    if (isNew && createEventId) {
+      events.push(createEventId);
+    }
+    if (extracted.status) {
+      const statusEvent = await this.handleStatusChange(task, extracted.status);
+      if (statusEvent) {
+        events.push(statusEvent);
+      }
+    }
+    if (extracted.priority) {
+      const priorityEvent = await this.handlePriorityChange(task, extracted.priority);
+      if (priorityEvent) {
+        events.push(priorityEvent);
+      }
+    }
+    if (extracted.blockedBy && extracted.blockedBy.length > 0) {
+      const blockerEvent = await this.handleBlockers(
+        task,
+        extracted.blockedBy,
+        sourceEntryId
+      );
+      if (blockerEvent) {
+        events.push(blockerEvent);
+      }
+    } else if (extracted.status === "blocked") {
+      const blockerEvent = await this.handleUnknownBlocker(task);
+      if (blockerEvent) {
+        events.push(blockerEvent);
+      }
+    }
+    return {
+      taskId: task.entityId,
+      isNew,
+      events
+    };
+  }
+  /**
+   * Find existing task or create new one
+   */
+  async findOrCreateTask(extracted) {
+    const matchResult = await this.taskMatcher.match(extracted.title, extracted.project);
+    if (matchResult.confidence === "high" && matchResult.match) {
+      return {
+        task: matchResult.match,
+        isNew: false
+      };
+    }
+    const taskId = randomUUID6();
+    const canonicalKey = makeEntityCanonicalKey("task", extracted.title, {
+      project: extracted.project
+    });
+    let initialStatus = extracted.status ?? "pending";
+    if (initialStatus === "done") {
+      initialStatus = "in_progress";
+    }
+    const now = /* @__PURE__ */ new Date();
+    const currentJson = {
+      status: initialStatus,
+      priority: extracted.priority ?? "medium",
+      description: extracted.description,
+      project: extracted.project ?? this.config.project
+    };
+    await this.db.run(
+      `INSERT INTO entities (
+        entity_id, entity_type, canonical_key, title, stage, status,
+        current_json, title_norm, search_text, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        taskId,
+        "task",
+        canonicalKey,
+        extracted.title,
+        "raw",
+        "active",
+        JSON.stringify(currentJson),
+        extracted.title.toLowerCase().trim(),
+        `${extracted.title} ${extracted.description ?? ""}`,
+        now.toISOString(),
+        now.toISOString()
+      ]
+    );
+    await this.db.run(
+      `INSERT INTO entity_aliases (entity_type, canonical_key, entity_id, is_primary)
+       VALUES (?, ?, ?, TRUE)
+       ON CONFLICT (entity_type, canonical_key) DO NOTHING`,
+      ["task", canonicalKey, taskId]
+    );
+    const eventId = await this.emitTaskEvent("task_created", {
+      taskId,
+      title: extracted.title,
+      canonicalKey,
+      initialStatus,
+      priority: extracted.priority ?? "medium",
+      description: extracted.description,
+      project: extracted.project ?? this.config.project
+    });
+    const task = {
+      entityId: taskId,
+      entityType: "task",
+      canonicalKey,
+      title: extracted.title,
+      stage: "raw",
+      status: "active",
+      currentJson,
+      titleNorm: extracted.title.toLowerCase().trim(),
+      searchText: `${extracted.title} ${extracted.description ?? ""}`,
+      createdAt: now,
+      updatedAt: now
+    };
+    return { task, isNew: true, eventId };
+  }
+  /**
+   * Handle task status change
+   */
+  async handleStatusChange(task, newStatus) {
+    const currentJson = task.currentJson;
+    const currentStatus = currentJson.status;
+    if (currentStatus === newStatus) {
+      return null;
+    }
+    const validNextStates = VALID_TRANSITIONS[currentStatus] ?? [];
+    if (!validNextStates.includes(newStatus)) {
+      return this.emitTaskEvent("task_transition_rejected", {
+        taskId: task.entityId,
+        fromStatus: currentStatus,
+        toStatus: newStatus,
+        reason: `Invalid transition from ${currentStatus} to ${newStatus}`
+      });
+    }
+    const eventId = await this.emitTaskEvent("task_status_changed", {
+      taskId: task.entityId,
+      fromStatus: currentStatus,
+      toStatus: newStatus
+    });
+    await this.db.run(
+      `UPDATE entities
+       SET current_json = json_set(current_json, '$.status', ?),
+           updated_at = ?
+       WHERE entity_id = ?`,
+      [newStatus, (/* @__PURE__ */ new Date()).toISOString(), task.entityId]
+    );
+    return eventId;
+  }
+  /**
+   * Handle task priority change
+   */
+  async handlePriorityChange(task, newPriority) {
+    const currentJson = task.currentJson;
+    const currentPriority = currentJson.priority ?? "medium";
+    if (currentPriority === newPriority) {
+      return null;
+    }
+    const eventId = await this.emitTaskEvent("task_priority_changed", {
+      taskId: task.entityId,
+      fromPriority: currentPriority,
+      toPriority: newPriority
+    });
+    await this.db.run(
+      `UPDATE entities
+       SET current_json = json_set(current_json, '$.priority', ?),
+           updated_at = ?
+       WHERE entity_id = ?`,
+      [newPriority, (/* @__PURE__ */ new Date()).toISOString(), task.entityId]
+    );
+    return eventId;
+  }
+  /**
+   * Handle blockers
+   */
+  async handleBlockers(task, blockedByTexts, sourceEntryId) {
+    const blockerRefs = await this.blockerResolver.resolveBlockers(blockedByTexts);
+    const mode = this.config.evidenceAligned ? "replace" : "suggest";
+    const eventId = await this.emitTaskEvent("task_blockers_set", {
+      taskId: task.entityId,
+      mode,
+      blockers: blockerRefs,
+      sourceEntryId
+    });
+    return eventId;
+  }
+  /**
+   * Handle unknown blocker (status=blocked but no blockedBy)
+   */
+  async handleUnknownBlocker(task) {
+    const placeholderRef = await this.blockerResolver.createUnknownPlaceholder(task.title);
+    const eventId = await this.emitTaskEvent("task_blockers_set", {
+      taskId: task.entityId,
+      mode: "suggest",
+      blockers: [placeholderRef]
+    });
+    return eventId;
+  }
+  /**
+   * Emit task event to events table
+   */
+  async emitTaskEvent(eventType, payload) {
+    const eventId = randomUUID6();
+    const now = /* @__PURE__ */ new Date();
+    const dedupeKey = makeTaskEventDedupeKey(
+      eventType,
+      payload.taskId,
+      this.config.sessionId,
+      JSON.stringify(payload)
+    );
+    const existing = await this.db.all(
+      `SELECT event_id FROM event_dedup WHERE dedupe_key = ?`,
+      [dedupeKey]
+    );
+    if (existing.length > 0) {
+      return existing[0].event_id;
+    }
+    await this.db.run(
+      `INSERT INTO events (
+        id, event_type, session_id, timestamp, content,
+        canonical_key, dedupe_key, metadata
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        eventId,
+        eventType,
+        this.config.sessionId,
+        now.toISOString(),
+        JSON.stringify(payload),
+        `task_event:${eventType}:${payload.taskId}`,
+        dedupeKey,
+        JSON.stringify({ source: "task_resolver" })
+      ]
+    );
+    await this.db.run(
+      `INSERT INTO event_dedup (dedupe_key, event_id)
+       VALUES (?, ?)
+       ON CONFLICT DO NOTHING`,
+      [dedupeKey, eventId]
+    );
+    return eventId;
+  }
+  /**
+   * Resolve condition to task (when condition is identified as existing task)
+   */
+  async resolveConditionToTask(conditionId, taskId) {
+    const eventId = await this.emitTaskEvent("condition_resolved_to", {
+      conditionId,
+      resolvedTo: {
+        kind: "task",
+        entityId: taskId
+      }
+    });
+    await this.db.run(
+      `INSERT INTO edges (edge_id, src_type, src_id, rel_type, dst_type, dst_id, meta_json)
+       VALUES (?, 'entity', ?, 'resolves_to', 'entity', ?, ?)
+       ON CONFLICT DO NOTHING`,
+      [randomUUID6(), conditionId, taskId, JSON.stringify({ resolved_at: (/* @__PURE__ */ new Date()).toISOString() })]
+    );
+    return eventId;
+  }
+};
+
+// src/core/task/task-projector.ts
+import { randomUUID as randomUUID7 } from "crypto";
+var PROJECTOR_NAME = "task_projector";
+var TASK_EVENT_TYPES = [
+  "task_created",
+  "task_status_changed",
+  "task_priority_changed",
+  "task_blockers_set",
+  "task_transition_rejected",
+  "condition_resolved_to"
+];
+var TaskProjector = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Get current projection offset
+   */
+  async getOffset() {
+    const rows = await this.db.all(
+      `SELECT last_event_id, last_timestamp
+       FROM projection_offsets
+       WHERE projection_name = ?`,
+      [PROJECTOR_NAME]
+    );
+    if (rows.length === 0) {
+      return { lastEventId: null, lastTimestamp: null };
+    }
+    return {
+      lastEventId: rows[0].last_event_id,
+      lastTimestamp: rows[0].last_timestamp ? new Date(rows[0].last_timestamp) : null
+    };
+  }
+  /**
+   * Update projection offset
+   */
+  async updateOffset(eventId, timestamp) {
+    await this.db.run(
+      `INSERT INTO projection_offsets (projection_name, last_event_id, last_timestamp, updated_at)
+       VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT (projection_name) DO UPDATE SET
+         last_event_id = excluded.last_event_id,
+         last_timestamp = excluded.last_timestamp,
+         updated_at = CURRENT_TIMESTAMP`,
+      [PROJECTOR_NAME, eventId, timestamp.toISOString()]
+    );
+  }
+  /**
+   * Fetch events since last offset
+   */
+  async fetchEventsSince(offset, limit = 100) {
+    let query = `
+      SELECT id, event_type, session_id, timestamp, content
+      FROM events
+      WHERE event_type IN (${TASK_EVENT_TYPES.map(() => "?").join(", ")})
+    `;
+    const params = [...TASK_EVENT_TYPES];
+    if (offset.lastTimestamp && offset.lastEventId) {
+      query += ` AND (timestamp > ? OR (timestamp = ? AND id > ?))`;
+      params.push(
+        offset.lastTimestamp.toISOString(),
+        offset.lastTimestamp.toISOString(),
+        offset.lastEventId
+      );
+    }
+    query += ` ORDER BY timestamp ASC, id ASC LIMIT ?`;
+    params.push(limit);
+    const rows = await this.db.all(query, params);
+    return rows.map((row) => ({
+      id: row.id,
+      eventType: row.event_type,
+      sessionId: row.session_id,
+      timestamp: new Date(row.timestamp),
+      content: typeof row.content === "string" ? JSON.parse(row.content) : row.content
+    }));
+  }
+  /**
+   * Process a batch of events
+   */
+  async processBatch(batchSize = 100) {
+    const offset = await this.getOffset();
+    const events = await this.fetchEventsSince(offset, batchSize);
+    if (events.length === 0) {
+      return 0;
+    }
+    for (const event of events) {
+      await this.processEvent(event);
+      await this.updateOffset(event.id, event.timestamp);
+    }
+    return events.length;
+  }
+  /**
+   * Process all pending events
+   */
+  async processAll() {
+    let totalProcessed = 0;
+    let processed;
+    do {
+      processed = await this.processBatch();
+      totalProcessed += processed;
+    } while (processed > 0);
+    return totalProcessed;
+  }
+  /**
+   * Process a single event
+   */
+  async processEvent(event) {
+    switch (event.eventType) {
+      case "task_created":
+        await this.enqueueForVectorization(event.content.taskId, "task_title");
+        break;
+      case "task_status_changed":
+        await this.handleStatusChanged(event);
+        break;
+      case "task_priority_changed":
+        break;
+      case "task_blockers_set":
+        await this.handleBlockersSet(event);
+        break;
+      case "condition_resolved_to":
+        await this.handleConditionResolved(event);
+        break;
+      case "task_transition_rejected":
+        break;
+    }
+  }
+  /**
+   * Handle task_status_changed event
+   */
+  async handleStatusChanged(event) {
+    const { taskId, toStatus } = event.content;
+    if (toStatus === "done") {
+      await this.db.run(
+        `DELETE FROM edges
+         WHERE src_id = ? AND rel_type IN ('blocked_by', 'blocked_by_suggested')`,
+        [taskId]
+      );
+      await this.db.run(
+        `UPDATE entities
+         SET current_json = json_remove(json_remove(current_json, '$.blockers'), '$.blockerSuggestions'),
+             updated_at = CURRENT_TIMESTAMP
+         WHERE entity_id = ?`,
+        [taskId]
+      );
+    }
+  }
+  /**
+   * Handle task_blockers_set event
+   */
+  async handleBlockersSet(event) {
+    const { taskId, mode, blockers } = event.content;
+    if (mode === "replace") {
+      await this.db.run(
+        `DELETE FROM edges WHERE src_id = ? AND rel_type = 'blocked_by'`,
+        [taskId]
+      );
+      for (const blocker of blockers) {
+        await this.createBlockerEdge(taskId, blocker, "blocked_by");
+      }
+      const blockerIds = blockers.map((b) => b.entityId);
+      await this.db.run(
+        `UPDATE entities
+         SET current_json = json_set(current_json, '$.blockers', ?),
+             updated_at = CURRENT_TIMESTAMP
+         WHERE entity_id = ?`,
+        [JSON.stringify(blockerIds), taskId]
+      );
+    } else {
+      await this.db.run(
+        `DELETE FROM edges WHERE src_id = ? AND rel_type = 'blocked_by_suggested'`,
+        [taskId]
+      );
+      for (const blocker of blockers) {
+        await this.createBlockerEdge(taskId, blocker, "blocked_by_suggested");
+      }
+      const suggestionIds = blockers.map((b) => b.entityId);
+      await this.db.run(
+        `UPDATE entities
+         SET current_json = json_set(current_json, '$.blockerSuggestions', ?),
+             updated_at = CURRENT_TIMESTAMP
+         WHERE entity_id = ?`,
+        [JSON.stringify(suggestionIds), taskId]
+      );
+    }
+  }
+  /**
+   * Create blocker edge
+   */
+  async createBlockerEdge(taskId, blocker, relType) {
+    const edgeId = randomUUID7();
+    await this.db.run(
+      `INSERT INTO edges (edge_id, src_type, src_id, rel_type, dst_type, dst_id, meta_json, created_at)
+       VALUES (?, 'entity', ?, ?, 'entity', ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT DO NOTHING`,
+      [
+        edgeId,
+        taskId,
+        relType,
+        blocker.entityId,
+        JSON.stringify({
+          kind: blocker.kind,
+          rawText: blocker.rawText,
+          confidence: blocker.confidence,
+          candidates: blocker.candidates
+        })
+      ]
+    );
+  }
+  /**
+   * Handle condition_resolved_to event
+   */
+  async handleConditionResolved(event) {
+    const { conditionId, resolvedTo } = event.content;
+    await this.db.run(
+      `UPDATE entities
+       SET current_json = json_set(json_set(current_json, '$.resolved', true), '$.resolvedTo', ?),
+           updated_at = CURRENT_TIMESTAMP
+       WHERE entity_id = ?`,
+      [JSON.stringify(resolvedTo), conditionId]
+    );
+  }
+  /**
+   * Enqueue entity for vectorization
+   */
+  async enqueueForVectorization(itemId, itemKind) {
+    const jobId = randomUUID7();
+    const embeddingVersion = "v1";
+    await this.db.run(
+      `INSERT INTO vector_outbox (job_id, item_kind, item_id, embedding_version, status, retry_count)
+       VALUES (?, ?, ?, ?, 'pending', 0)
+       ON CONFLICT (item_kind, item_id, embedding_version) DO NOTHING`,
+      [jobId, itemKind, itemId, embeddingVersion]
+    );
+  }
+  /**
+   * Rebuild all projections from scratch
+   * WARNING: This clears all edges and rebuilds from events
+   */
+  async rebuild() {
+    await this.db.run(
+      `DELETE FROM edges WHERE rel_type IN ('blocked_by', 'blocked_by_suggested', 'resolves_to')`
+    );
+    await this.db.run(
+      `DELETE FROM projection_offsets WHERE projection_name = ?`,
+      [PROJECTOR_NAME]
+    );
+    return this.processAll();
+  }
+};
+export {
+  AlignedEvidenceSchema,
+  BlockerKindSchema,
+  BlockerModeSchema,
+  BlockerRefSchema,
+  BlockerResolver,
+  BuildRunSchema,
+  CitationSchema,
+  CitationUsageSchema,
+  ConfigSchema,
+  ConsolidatedMemorySchema,
+  ContinuityLogSchema,
+  DefaultContentProvider,
+  EdgeRepo,
+  EdgeSchema,
+  Embedder,
+  EndlessModeConfigSchema,
+  EntityAliasSchema,
+  EntityRepo,
+  EntitySchema,
+  EntityStageSchema,
+  EntityStatusSchema,
+  EntityTypeSchema,
+  EntrySchema,
+  EntryTypeSchema,
+  EventStore,
+  EventTypeSchema,
+  EvidenceAlignResultSchema,
+  EvidenceAligner,
+  EvidenceSpanSchema,
+  ExtractedEvidenceSchema,
+  FailedEvidenceSchema,
+  FullDetailSchema,
+  GraduationPipeline,
+  GraduationResultSchema,
+  InsightSchema,
+  InsightTypeSchema,
+  MATCH_THRESHOLDS,
+  MatchConfidenceSchema,
+  MatchResultSchema,
+  Matcher,
+  MemoryEventInputSchema,
+  MemoryEventSchema,
+  MemoryLevelSchema,
+  MemoryMatchSchema,
+  MemoryModeSchema,
+  NodeTypeSchema,
+  OutboxItemKindSchema,
+  OutboxJobSchema,
+  OutboxStatusSchema,
+  PipelineMetricSchema,
+  ProgressiveDisclosureConfigSchema,
+  ProgressiveSearchResultSchema,
+  RelationTypeSchema,
+  Retriever,
+  SearchIndexItemSchema,
+  SessionSchema,
+  TaskBlockersSetPayloadSchema,
+  TaskCreatedPayloadSchema,
+  TaskCurrentJsonSchema,
+  TaskEventTypeSchema,
+  TaskMatcher,
+  TaskPrioritySchema,
+  TaskProjector,
+  TaskResolver,
+  TaskStatusChangedPayloadSchema,
+  TaskStatusSchema,
+  TimelineItemSchema,
+  ToolMetadataSchema,
+  ToolObservationPayloadSchema,
+  TransitionTypeSchema,
+  VALID_OUTBOX_TRANSITIONS,
+  VectorOutbox,
+  VectorStore,
+  VectorWorker,
+  VectorWorkerV2,
+  WorkingSetItemSchema,
+  createGraduationPipeline,
+  createRetriever,
+  createVectorWorker,
+  createVectorWorkerV2,
+  getDefaultAligner,
+  getDefaultEmbedder,
+  getDefaultMatcher,
+  hashContent,
+  isSameCanonicalKey,
+  makeArtifactKey,
+  makeCanonicalKey,
+  makeDedupeKey,
+  makeEntityCanonicalKey,
+  makeTaskEventDedupeKey,
+  parseEntityCanonicalKey
+};
+//# sourceMappingURL=index.js.map