@snapback/cli 1.1.12 → 1.1.14

package/dist/chunk-QLCHTUT5.js

@@ -0,0 +1,1067 @@
+#!/usr/bin/env node
+import { generateId } from './chunk-6MR2TINI.js';
+import { __name, __require } from './chunk-BW7RALUZ.js';
+import * as fs2 from 'fs';
+import * as path3 from 'path';
+import { writeFile } from 'atomically';
+import * as crypto from 'crypto';
+import * as zlib from 'zlib';
+
+var __defProp = Object.defineProperty;
+var __name2 = /* @__PURE__ */ __name((target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+}), "__name");
+var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: /* @__PURE__ */ __name((a, b) => (typeof __require !== "undefined" ? __require : a)[b], "get")
+}) : x)(function(x) {
+  if (typeof __require !== "undefined") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var ConfigStore = class {
+  static {
+    __name(this, "ConfigStore");
+  }
+  static {
+    __name2(this, "ConfigStore");
+  }
+  config;
+  cache = {};
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+  * Get the root directory for intelligence data
+  */
+  get rootDir() {
+    return this.config.rootDir;
+  }
+  /**
+  * Resolve a path relative to rootDir
+  */
+  resolvePath(relativePath) {
+    return path3.join(this.config.rootDir, relativePath);
+  }
+  /**
+  * Load architecture documentation
+  */
+  loadArchitecture() {
+    if (this.cache.architecture) {
+      return this.cache.architecture;
+    }
+    const archPath = this.resolvePath("ARCHITECTURE.md");
+    if (fs2.existsSync(archPath)) {
+      this.cache.architecture = fs2.readFileSync(archPath, "utf-8");
+    } else {
+      this.cache.architecture = "";
+    }
+    return this.cache.architecture;
+  }
+  /**
+  * Load constraints/rules
+  */
+  loadConstraints() {
+    if (this.cache.constraints) {
+      return this.cache.constraints;
+    }
+    const constraintsPath = this.resolvePath(this.config.constraintsFile);
+    if (fs2.existsSync(constraintsPath)) {
+      this.cache.constraints = fs2.readFileSync(constraintsPath, "utf-8");
+    } else {
+      this.cache.constraints = "";
+    }
+    return this.cache.constraints;
+  }
+  /**
+  * Load codebase patterns
+  */
+  loadPatterns() {
+    if (this.cache.patterns) {
+      return this.cache.patterns;
+    }
+    const patternsPath = this.resolvePath(path3.join(this.config.patternsDir, "codebase-patterns.md"));
+    if (fs2.existsSync(patternsPath)) {
+      this.cache.patterns = fs2.readFileSync(patternsPath, "utf-8");
+    } else {
+      this.cache.patterns = "";
+    }
+    return this.cache.patterns;
+  }
+  /**
+  * Load any context file by name
+  */
+  loadContextFile(filename) {
+    const filePath = this.resolvePath(filename);
+    if (fs2.existsSync(filePath)) {
+      return fs2.readFileSync(filePath, "utf-8");
+    }
+    return "";
+  }
+  /**
+  * Get static context suitable for prompt caching
+  *
+  * Content changes rarely - cache for 5+ minutes.
+  * Marked with cache_control for Anthropic prompt caching.
+  *
+  * @see https://docs.anthropic.com/claude/docs/prompt-caching
+  */
+  getStaticContext() {
+    return {
+      architecture: this.loadArchitecture(),
+      constraints: this.loadConstraints(),
+      patterns: this.loadPatterns(),
+      timestamp: /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString(),
+      _cache_control: {
+        type: "ephemeral"
+      }
+    };
+  }
+  /**
+  * Clear the cache (for testing or after file changes)
+  */
+  clearCache() {
+    this.cache = {};
+  }
+  /**
+  * Check if a context file exists
+  */
+  contextFileExists(filename) {
+    return fs2.existsSync(this.resolvePath(filename));
+  }
+  /**
+  * List all context files that exist
+  */
+  listAvailableContextFiles() {
+    return this.config.contextFiles.filter((f) => this.contextFileExists(f));
+  }
+};
+function loadJsonl(filepath) {
+  if (!fs2.existsSync(filepath)) {
+    return [];
+  }
+  try {
+    return fs2.readFileSync(filepath, "utf-8").split(/\r?\n/).filter((line) => line.trim()).map((line) => JSON.parse(line));
+  } catch (e) {
+    console.error(`[JsonlStore] Error loading ${filepath}:`, e);
+    return [];
+  }
+}
+__name(loadJsonl, "loadJsonl");
+__name2(loadJsonl, "loadJsonl");
+function appendJsonl(filepath, data) {
+  const dir = path3.dirname(filepath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, {
+      recursive: true
+    });
+  }
+  fs2.appendFileSync(filepath, `${JSON.stringify(data)}
+`);
+}
+__name(appendJsonl, "appendJsonl");
+__name2(appendJsonl, "appendJsonl");
+async function appendJsonlAsync(filepath, data) {
+  const dir = path3.dirname(filepath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, {
+      recursive: true
+    });
+  }
+  try {
+    const existing = fs2.existsSync(filepath) ? fs2.readFileSync(filepath, "utf-8") : "";
+    await writeFile(filepath, `${existing + JSON.stringify(data)}
+`);
+  } catch {
+    fs2.appendFileSync(filepath, `${JSON.stringify(data)}
+`);
+  }
+}
+__name(appendJsonlAsync, "appendJsonlAsync");
+__name2(appendJsonlAsync, "appendJsonlAsync");
+async function writeJsonl(filepath, records) {
+  const dir = path3.dirname(filepath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, {
+      recursive: true
+    });
+  }
+  const content = `${records.map((r) => JSON.stringify(r)).join("\n")}
+`;
+  try {
+    await writeFile(filepath, content);
+  } catch {
+    fs2.writeFileSync(filepath, content);
+  }
+}
+__name(writeJsonl, "writeJsonl");
+__name2(writeJsonl, "writeJsonl");
+function findInJsonl(filepath, predicate) {
+  const records = loadJsonl(filepath);
+  return records.find(predicate);
+}
+__name(findInJsonl, "findInJsonl");
+__name2(findInJsonl, "findInJsonl");
+async function updateInJsonl(filepath, predicate, updater) {
+  const records = loadJsonl(filepath);
+  let updated = false;
+  const newRecords = records.map((record) => {
+    if (predicate(record)) {
+      updated = true;
+      return updater(record);
+    }
+    return record;
+  });
+  if (updated) {
+    await writeJsonl(filepath, newRecords);
+  }
+  return updated;
+}
+__name(updateInJsonl, "updateInJsonl");
+__name2(updateInJsonl, "updateInJsonl");
+function countInJsonl(filepath, predicate) {
+  const records = loadJsonl(filepath);
+  if (!predicate) {
+    return records.length;
+  }
+  return records.filter(predicate).length;
+}
+__name(countInJsonl, "countInJsonl");
+__name2(countInJsonl, "countInJsonl");
+function generateId2(prefix = "ID") {
+  return generateId(prefix);
+}
+__name(generateId2, "generateId");
+__name2(generateId2, "generateId");
+var DEFAULT_INTENT_CONFIG = {
+  maxResults: 10,
+  minScore: 0.3,
+  intentWeight: 0.4,
+  componentWeight: 0.3,
+  fileAffinityWeight: 0.2,
+  keywordWeight: 0.1,
+  includeRelated: true
+};
+function inferComponentType(filePath) {
+  const normalized = filePath.toLowerCase();
+  const filename = normalized.split("/").pop() ?? "";
+  if (normalized.includes("test") || normalized.endsWith(".test.ts") || normalized.endsWith(".spec.ts")) {
+    return "test";
+  }
+  if (normalized.includes("hooks/") || filename.startsWith("use-")) {
+    return "hook";
+  }
+  if (normalized.includes("components/") || normalized.endsWith(".tsx") || normalized.endsWith(".jsx")) {
+    return "component";
+  }
+  if (normalized.includes("api/") || normalized.includes("routes/") || normalized.includes("endpoints/")) {
+    return "api";
+  }
+  if (normalized.includes("migrations/") || normalized.includes("drizzle/")) {
+    return "migration";
+  }
+  if (normalized.includes("utils/") || normalized.includes("lib/")) {
+    return "util";
+  }
+  if (normalized.includes("types/") || normalized.endsWith(".d.ts")) {
+    return "type";
+  }
+  if (normalized.includes("config") || normalized.endsWith(".config.ts") || normalized.endsWith(".config.js")) {
+    return "config";
+  }
+  if (normalized.includes("tools/") || normalized.includes("mcp/")) {
+    return "tool";
+  }
+  return void 0;
+}
+__name(inferComponentType, "inferComponentType");
+__name2(inferComponentType, "inferComponentType");
+function generateFileAffinityPatterns(filePaths) {
+  const patterns = /* @__PURE__ */ new Set();
+  for (const filePath of filePaths) {
+    const parts = filePath.split("/");
+    if (parts.length > 1) {
+      patterns.add(`${parts[0]}/**`);
+      if (parts.length > 2) {
+        patterns.add(`${parts.slice(0, 2).join("/")}/**`);
+      }
+    }
+    const ext = filePath.split(".").pop();
+    if (ext) {
+      patterns.add(`**/*.${ext}`);
+    }
+    const filename = parts[parts.length - 1];
+    if (filename?.startsWith("use-")) {
+      patterns.add("**/use-*.ts");
+      patterns.add("**/use-*.tsx");
+    }
+  }
+  return Array.from(patterns);
+}
+__name(generateFileAffinityPatterns, "generateFileAffinityPatterns");
+__name2(generateFileAffinityPatterns, "generateFileAffinityPatterns");
+function matchGlob(pattern, text) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<<GLOBSTAR>>>").replace(/\*/g, "[^/]*").replace(/<<<GLOBSTAR>>>/g, ".*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`, "i");
+  return regex.test(text);
+}
+__name(matchGlob, "matchGlob");
+__name2(matchGlob, "matchGlob");
+var MAGIC_BYTES = Buffer.from("SNAPBACK", "utf8");
+var HEADER_SIZE = 16;
+var CURRENT_VERSION = 1;
+var FLAG_ENCRYPTED = 1;
+function createEmptyState() {
+  return {
+    schemaVersion: 1,
+    lastModified: /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString(),
+    learnings: [],
+    violations: [],
+    patterns: [],
+    sessions: [],
+    pendingSync: [],
+    syncVersion: 0,
+    syncStatus: "pending"
+  };
+}
+__name(createEmptyState, "createEmptyState");
+__name2(createEmptyState, "createEmptyState");
+var StateStore = class {
+  static {
+    __name(this, "StateStore");
+  }
+  static {
+    __name2(this, "StateStore");
+  }
+  statePath;
+  encrypt;
+  encryptionKey;
+  state;
+  dirty = false;
+  constructor(options) {
+    this.statePath = path3.join(options.snapbackDir, "state.bin");
+    this.encrypt = options.encrypt ?? false;
+    this.encryptionKey = options.encryptionKey;
+    if (this.encrypt && (!this.encryptionKey || this.encryptionKey.length !== 32)) {
+      throw new Error("Encryption requires a 32-byte key");
+    }
+    this.state = createEmptyState();
+  }
+  /**
+  * Load state from disk
+  */
+  async load() {
+    if (!fs2.existsSync(this.statePath)) {
+      this.state = createEmptyState();
+      return this.state;
+    }
+    try {
+      const raw = await fs2.promises.readFile(this.statePath);
+      this.state = this.deserialize(raw);
+      return this.state;
+    } catch (error) {
+      console.error("[StateStore] Failed to load state, starting fresh:", error);
+      this.state = createEmptyState();
+      return this.state;
+    }
+  }
+  /**
+  * Save state to disk
+  */
+  async save() {
+    this.state.lastModified = /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString();
+    const serialized = this.serialize(this.state);
+    const dir = path3.dirname(this.statePath);
+    if (!fs2.existsSync(dir)) {
+      await fs2.promises.mkdir(dir, {
+        recursive: true
+      });
+    }
+    const tempPath = `${this.statePath}.tmp`;
+    await fs2.promises.writeFile(tempPath, serialized);
+    await fs2.promises.rename(tempPath, this.statePath);
+    this.dirty = false;
+  }
+  /**
+  * Get current state (readonly)
+  */
+  getState() {
+    return this.state;
+  }
+  /**
+  * Check if state has unsaved changes
+  */
+  isDirty() {
+    return this.dirty;
+  }
+  // ============================================================================
+  // LEARNINGS
+  // ============================================================================
+  getLearnings(tier) {
+    if (!tier) {
+      return [
+        ...this.state.learnings
+      ];
+    }
+    return this.state.learnings.filter((l) => l.tier === tier);
+  }
+  addLearning(learning) {
+    const newLearning = {
+      ...learning,
+      id: crypto.randomUUID(),
+      createdAt: /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString(),
+      accessCount: 0,
+      appliedCount: 0,
+      relevanceScore: 1
+    };
+    this.state.learnings.push(newLearning);
+    this.dirty = true;
+    return newLearning;
+  }
+  updateLearning(id, updates) {
+    const index = this.state.learnings.findIndex((l) => l.id === id);
+    if (index === -1) {
+      return false;
+    }
+    this.state.learnings[index] = {
+      ...this.state.learnings[index],
+      ...updates
+    };
+    this.dirty = true;
+    return true;
+  }
+  /**
+  * Archive a learning (Phase 2.6b: set archived flag, preserve data)
+  */
+  archiveLearning(learningId) {
+    const learning = this.state.learnings.find((l) => l.id === learningId);
+    if (!learning) {
+      return false;
+    }
+    learning.archived = true;
+    learning.archivedAt = /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString();
+    this.dirty = true;
+    return true;
+  }
+  /**
+  * Delete a learning permanently (Phase 2.6b: remove from state)
+  */
+  deleteLearning(learningId) {
+    const index = this.state.learnings.findIndex((l) => l.id === learningId);
+    if (index === -1) {
+      return false;
+    }
+    this.state.learnings.splice(index, 1);
+    this.dirty = true;
+    return true;
+  }
+  /**
+  * Get archived learnings (Phase 2.6b)
+  */
+  getArchivedLearnings() {
+    return this.state.learnings.filter((l) => l.archived === true);
+  }
+  // ============================================================================
+  // INTENT-AWARE RETRIEVAL (Phase 2.6c)
+  // ============================================================================
+  /**
+  * Retrieve learnings using task-intent graph indexing
+  * Based on Cursor RAG + A-MEM research patterns
+  *
+  * @param context - Task context with intent, files, and keywords
+  * @param config - Optional retrieval configuration
+  * @returns Scored learnings ranked by relevance
+  */
+  retrieveByIntent(context, config = {}) {
+    const fullConfig = {
+      ...DEFAULT_INTENT_CONFIG,
+      ...config
+    };
+    const componentType = context.componentType ?? this.inferDominantComponentType(context.files);
+    const scored = [];
+    for (const learning of this.state.learnings) {
+      if (learning.archived) {
+        continue;
+      }
+      const score = this.scoreLearning(learning, context, componentType, fullConfig);
+      if (score.totalScore >= fullConfig.minScore) {
+        scored.push({
+          learningId: learning.id,
+          score: score.totalScore,
+          matchReasons: score.reasons
+        });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    if (fullConfig.includeRelated) {
+      this.expandWithRelated(scored, fullConfig.maxResults);
+    }
+    return scored.slice(0, fullConfig.maxResults);
+  }
+  /**
+  * Enrich a learning with intent metadata
+  * Called when creating/updating learnings with file context
+  */
+  enrichWithIntentMetadata(learningId, context) {
+    const learning = this.state.learnings.find((l) => l.id === learningId);
+    if (!learning) {
+      return false;
+    }
+    const existingMeta = learning.intentMetadata;
+    const componentTypes = context.files.map((f) => inferComponentType(f)).filter(Boolean);
+    const fileAffinities = generateFileAffinityPatterns(context.files);
+    learning.intentMetadata = {
+      intents: existingMeta ? Array.from(/* @__PURE__ */ new Set([
+        ...existingMeta.intents,
+        context.intent
+      ])) : [
+        context.intent
+      ],
+      componentTypes: existingMeta ? Array.from(/* @__PURE__ */ new Set([
+        ...existingMeta.componentTypes,
+        ...componentTypes
+      ])) : componentTypes,
+      fileAffinities: existingMeta ? Array.from(/* @__PURE__ */ new Set([
+        ...existingMeta.fileAffinities,
+        ...fileAffinities
+      ])) : fileAffinities,
+      relatedLearnings: existingMeta?.relatedLearnings ?? [],
+      intentSuccessCount: {
+        ...existingMeta?.intentSuccessCount ?? {},
+        [context.intent]: (existingMeta?.intentSuccessCount?.[context.intent] ?? 0) + 1
+      }
+    };
+    this.dirty = true;
+    return true;
+  }
+  /**
+  * Link two learnings together (Zettelkasten-style)
+  */
+  linkLearnings(learningId1, learningId2) {
+    const learning1 = this.state.learnings.find((l) => l.id === learningId1);
+    const learning2 = this.state.learnings.find((l) => l.id === learningId2);
+    if (!learning1 || !learning2) {
+      return false;
+    }
+    if (!learning1.intentMetadata) {
+      learning1.intentMetadata = {
+        intents: [],
+        componentTypes: [],
+        fileAffinities: [],
+        relatedLearnings: [],
+        intentSuccessCount: {}
+      };
+    }
+    if (!learning2.intentMetadata) {
+      learning2.intentMetadata = {
+        intents: [],
+        componentTypes: [],
+        fileAffinities: [],
+        relatedLearnings: [],
+        intentSuccessCount: {}
+      };
+    }
+    if (!learning1.intentMetadata.relatedLearnings.includes(learningId2)) {
+      learning1.intentMetadata.relatedLearnings.push(learningId2);
+    }
+    if (!learning2.intentMetadata.relatedLearnings.includes(learningId1)) {
+      learning2.intentMetadata.relatedLearnings.push(learningId1);
+    }
+    this.dirty = true;
+    return true;
+  }
+  /**
+  * Private: Score a learning against task context
+  */
+  scoreLearning(learning, context, componentType, config) {
+    const meta = learning.intentMetadata;
+    const reasons = {
+      intentMatch: false,
+      componentMatch: false,
+      fileAffinityMatch: false,
+      keywordMatch: false,
+      relationshipMatch: false
+    };
+    let totalScore = 0;
+    if (meta?.intents.includes(context.intent)) {
+      reasons.intentMatch = true;
+      totalScore += config.intentWeight;
+    }
+    if (componentType && meta?.componentTypes.includes(componentType)) {
+      reasons.componentMatch = true;
+      totalScore += config.componentWeight;
+    }
+    if (meta?.fileAffinities.length) {
+      const matchCount = context.files.filter((file) => meta.fileAffinities.some((pattern) => matchGlob(pattern, file))).length;
+      if (matchCount > 0) {
+        reasons.fileAffinityMatch = true;
+        totalScore += config.fileAffinityWeight * (matchCount / context.files.length);
+      }
+    }
+    if (context.keywords?.length && learning.keywords?.length) {
+      const matchCount = context.keywords.filter((kw) => learning.keywords?.includes(kw)).length;
+      if (matchCount > 0) {
+        reasons.keywordMatch = true;
+        totalScore += config.keywordWeight * (matchCount / context.keywords.length);
+      }
+    }
+    return {
+      totalScore,
+      reasons
+    };
+  }
+  /**
+  * Private: Infer dominant component type from file list
+  */
+  inferDominantComponentType(files) {
+    const types = files.map((f) => inferComponentType(f)).filter((t) => t !== void 0);
+    if (types.length === 0) {
+      return void 0;
+    }
+    const counts = /* @__PURE__ */ new Map();
+    for (const type of types) {
+      counts.set(type, (counts.get(type) ?? 0) + 1);
+    }
+    return Array.from(counts.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
+  }
+  /**
+  * Private: Expand results with related learnings via graph traversal
+  */
+  expandWithRelated(scored, _maxResults) {
+    const visited = new Set(scored.map((s) => s.learningId));
+    const toAdd = [];
+    for (const item of scored) {
+      const learning = this.state.learnings.find((l) => l.id === item.learningId);
+      if (!learning?.intentMetadata?.relatedLearnings.length) {
+        continue;
+      }
+      for (const relatedId of learning.intentMetadata.relatedLearnings) {
+        if (visited.has(relatedId)) {
+          continue;
+        }
+        visited.add(relatedId);
+        toAdd.push({
+          learningId: relatedId,
+          score: item.score * 0.7,
+          matchReasons: {
+            intentMatch: false,
+            componentMatch: false,
+            fileAffinityMatch: false,
+            keywordMatch: false,
+            relationshipMatch: true
+          }
+        });
+      }
+    }
+    scored.push(...toAdd);
+    scored.sort((a, b) => b.score - a.score);
+  }
+  // ============================================================================
+  // VIOLATIONS
+  // ============================================================================
+  getViolations() {
+    return [
+      ...this.state.violations
+    ];
+  }
+  recordViolation(violation) {
+    const existing = this.state.violations.find((v) => v.type === violation.type && v.file === violation.file);
+    if (existing) {
+      existing.count++;
+      existing.lastSeen = /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString();
+      this.dirty = true;
+      return existing;
+    }
+    const newViolation = {
+      ...violation,
+      id: crypto.randomUUID(),
+      count: 1,
+      firstSeen: /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString(),
+      lastSeen: /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.state.violations.push(newViolation);
+    this.dirty = true;
+    return newViolation;
+  }
+  /**
+  * Remove a violation by ID
+  *
+  * @param violationId - Violation ID to remove
+  * @returns true if violation was removed, false if not found
+  */
+  removeViolation(violationId) {
+    const index = this.state.violations.findIndex((v) => v.id === violationId);
+    if (index === -1) {
+      return false;
+    }
+    this.state.violations.splice(index, 1);
+    this.dirty = true;
+    return true;
+  }
+  // ============================================================================
+  // PATTERNS
+  // ============================================================================
+  getPatterns() {
+    return [
+      ...this.state.patterns
+    ];
+  }
+  addPattern(pattern) {
+    const newPattern = {
+      ...pattern,
+      id: crypto.randomUUID(),
+      createdAt: /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString(),
+      usageCount: 0
+    };
+    this.state.patterns.push(newPattern);
+    this.dirty = true;
+    return newPattern;
+  }
+  // ============================================================================
+  // SESSIONS
+  // ============================================================================
+  getSessions() {
+    return [
+      ...this.state.sessions
+    ];
+  }
+  saveSession(session) {
+    const existing = session.id ? this.state.sessions.find((s) => s.id === session.id) : void 0;
+    if (existing) {
+      Object.assign(existing, session, {
+        lastCheckpoint: /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.dirty = true;
+      return existing;
+    }
+    const newSession = {
+      id: session.id || crypto.randomUUID(),
+      taskDescription: session.taskDescription,
+      startedAt: session.startedAt,
+      snapshotId: session.snapshotId,
+      context: session.context,
+      appliedLearnings: session.appliedLearnings || [],
+      lastCheckpoint: /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.state.sessions.push(newSession);
+    this.dirty = true;
+    return newSession;
+  }
+  /**
+  * Update applied learnings for a session (Phase 2.6a)
+  * Atomic operation for repetition avoidance
+  */
+  updateSessionLearnings(sessionId, learningIds) {
+    const session = this.state.sessions.find((s) => s.id === sessionId);
+    if (!session) {
+      return false;
+    }
+    const existing = new Set(session.appliedLearnings || []);
+    for (const id of learningIds) {
+      existing.add(id);
+    }
+    session.appliedLearnings = Array.from(existing);
+    session.lastCheckpoint = /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString();
+    this.dirty = true;
+    return true;
+  }
+  // ============================================================================
+  // PROJECT CONTEXT
+  // ============================================================================
+  getProjectContext() {
+    return this.state.projectContext;
+  }
+  setProjectContext(context) {
+    this.state.projectContext = context;
+    this.dirty = true;
+  }
+  // ============================================================================
+  // SYNC QUEUE
+  // ============================================================================
+  /**
+  * Get pending sync items
+  */
+  getPendingSync() {
+    return [
+      ...this.state.pendingSync || []
+    ];
+  }
+  /**
+  * Queue an item for cloud sync
+  */
+  queueForSync(item) {
+    const existing = this.state.pendingSync?.find((p) => p.patternKey === item.patternKey);
+    if (existing) {
+      return existing;
+    }
+    const newItem = {
+      ...item,
+      id: crypto.randomUUID(),
+      queuedAt: /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString(),
+      retryCount: 0
+    };
+    if (!this.state.pendingSync) {
+      this.state.pendingSync = [];
+    }
+    this.state.pendingSync.push(newItem);
+    this.dirty = true;
+    return newItem;
+  }
+  /**
+  * Remove synced items from queue
+  */
+  removeSyncedItems(ids) {
+    if (!this.state.pendingSync) {
+      return;
+    }
+    const idSet = new Set(ids);
+    this.state.pendingSync = this.state.pendingSync.filter((p) => !idSet.has(p.id));
+    this.dirty = true;
+  }
+  /**
+  * Increment retry count for failed items
+  */
+  incrementRetryCount(ids) {
+    if (!this.state.pendingSync) {
+      return;
+    }
+    const idSet = new Set(ids);
+    for (const item of this.state.pendingSync) {
+      if (idSet.has(item.id)) {
+        item.retryCount++;
+      }
+    }
+    this.dirty = true;
+  }
+  // ============================================================================
+  // SYNC METADATA (Phase 1: Intelligence New Platform)
+  // ============================================================================
+  /**
+  * Get current sync status
+  */
+  getSyncStatus() {
+    return this.state.syncStatus;
+  }
+  /**
+  * Set sync status
+  */
+  setSyncStatus(status) {
+    this.state.syncStatus = status;
+    this.dirty = true;
+  }
+  /**
+  * Get current sync version (for CRDT conflict resolution)
+  */
+  getSyncVersion() {
+    return this.state.syncVersion;
+  }
+  /**
+  * Increment sync version and return new value
+  */
+  incrementSyncVersion() {
+    this.state.syncVersion++;
+    this.dirty = true;
+    return this.state.syncVersion;
+  }
+  /**
+  * Mark state as successfully synced with timestamp
+  * Clears any previous sync error
+  */
+  markSynced() {
+    this.state.syncStatus = "synced";
+    this.state.lastSynced = /* @__PURE__ */ (/* @__PURE__ */ new Date()).toISOString();
+    this.state.lastSyncError = void 0;
+    this.dirty = true;
+  }
+  /**
+  * Get last synced timestamp
+  */
+  getLastSynced() {
+    return this.state.lastSynced;
+  }
+  /**
+  * Set sync error status with optional message
+  */
+  setSyncError(message) {
+    this.state.syncStatus = "error";
+    this.state.lastSyncError = message;
+    this.dirty = true;
+  }
+  // ============================================================================
+  // SERIALIZATION
+  // ============================================================================
+  serialize(state) {
+    const json = JSON.stringify(state);
+    const jsonBuffer = Buffer.from(json, "utf8");
+    const compressed = zlib.gzipSync(jsonBuffer, {
+      level: 9
+    });
+    let payload = compressed;
+    let flags = 0;
+    if (this.encrypt && this.encryptionKey) {
+      payload = this.encryptPayload(compressed);
+      flags |= FLAG_ENCRYPTED;
+    }
+    const header = Buffer.alloc(HEADER_SIZE);
+    MAGIC_BYTES.copy(header, 0);
+    header.writeUInt8(CURRENT_VERSION, 8);
+    header.writeUInt8(flags, 9);
+    return Buffer.concat([
+      header,
+      payload
+    ]);
+  }
+  deserialize(raw) {
+    if (raw.length < HEADER_SIZE) {
+      throw new Error("Invalid state file: too small");
+    }
+    const magic = raw.subarray(0, 8);
+    if (!magic.equals(MAGIC_BYTES)) {
+      throw new Error("Invalid state file: bad magic bytes");
+    }
+    const version = raw.readUInt8(8);
+    const flags = raw.readUInt8(9);
+    if (version > CURRENT_VERSION) {
+      throw new Error(`State file version ${version} is newer than supported ${CURRENT_VERSION}`);
+    }
+    let payload = raw.subarray(HEADER_SIZE);
+    if (flags & FLAG_ENCRYPTED) {
+      if (!this.encryptionKey) {
+        throw new Error("State file is encrypted but no key provided");
+      }
+      payload = this.decryptPayload(payload);
+    }
+    const decompressed = zlib.gunzipSync(payload);
+    const json = decompressed.toString("utf8");
+    return JSON.parse(json);
+  }
+  encryptPayload(data) {
+    if (!this.encryptionKey) {
+      throw new Error("No encryption key");
+    }
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv("aes-256-gcm", this.encryptionKey, iv);
+    const encrypted = Buffer.concat([
+      cipher.update(data),
+      cipher.final()
+    ]);
+    const authTag = cipher.getAuthTag();
+    return Buffer.concat([
+      iv,
+      authTag,
+      encrypted
+    ]);
+  }
+  decryptPayload(data) {
+    if (!this.encryptionKey) {
+      throw new Error("No encryption key");
+    }
+    if (data.length < 28) {
+      throw new Error("Encrypted payload too small");
+    }
+    const iv = data.subarray(0, 12);
+    const authTag = data.subarray(12, 28);
+    const encrypted = data.subarray(28);
+    const decipher = crypto.createDecipheriv("aes-256-gcm", this.encryptionKey, iv);
+    decipher.setAuthTag(authTag);
+    return Buffer.concat([
+      decipher.update(encrypted),
+      decipher.final()
+    ]);
+  }
+  // ============================================================================
+  // MIGRATION
+  // ============================================================================
+  /**
+  * Migrate from legacy JSONL files to binary state
+  */
+  async migrateFromJsonl(learningsDir, patternsDir) {
+    const errors = [];
+    let migrated = 0;
+    const learningFiles = [
+      "hot.jsonl",
+      "warm.jsonl",
+      "cold.jsonl",
+      "user-learnings.jsonl",
+      "learnings.jsonl"
+    ];
+    for (const file of learningFiles) {
+      const filePath = path3.join(learningsDir, file);
+      if (fs2.existsSync(filePath)) {
+        try {
+          const content = fs2.readFileSync(filePath, "utf8");
+          const lines = content.split("\n").filter((l) => l.trim());
+          for (const line of lines) {
+            try {
+              const legacy = JSON.parse(line);
+              const tier = file.startsWith("hot") ? "hot" : file.startsWith("cold") ? "cold" : "warm";
+              this.addLearning({
+                type: legacy.type || "pattern",
+                trigger: legacy.trigger || "",
+                action: legacy.action || "",
+                keywords: legacy.keywords,
+                source: legacy.source,
+                tier: legacy.tier || tier,
+                domain: legacy.domain
+              });
+              migrated++;
+            } catch {
+              errors.push(`Failed to parse learning: ${line.substring(0, 50)}...`);
+            }
+          }
+        } catch (e) {
+          errors.push(`Failed to read ${file}: ${e}`);
+        }
+      }
+    }
+    const violationsPath = path3.join(patternsDir, "violations.jsonl");
+    if (fs2.existsSync(violationsPath)) {
+      try {
+        const content = fs2.readFileSync(violationsPath, "utf8");
+        const lines = content.split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          try {
+            const legacy = JSON.parse(line);
+            this.recordViolation({
+              type: legacy.type || "unknown",
+              file: legacy.file || "",
+              description: legacy.description || legacy.whatHappened || "",
+              reason: legacy.reason || legacy.whyItHappened,
+              prevention: legacy.prevention || legacy.howToPrevent || ""
+            });
+            migrated++;
+          } catch {
+            errors.push(`Failed to parse violation: ${line.substring(0, 50)}...`);
+          }
+        }
+      } catch (e) {
+        errors.push(`Failed to read violations.jsonl: ${e}`);
+      }
+    }
+    await this.save();
+    return {
+      migrated,
+      errors
+    };
+  }
+};
+function deriveEncryptionKey(workspaceId, machineId) {
+  return crypto.pbkdf2Sync(workspaceId, machineId, 1e5, 32, "sha256");
+}
+__name(deriveEncryptionKey, "deriveEncryptionKey");
+__name2(deriveEncryptionKey, "deriveEncryptionKey");
+function getMachineId() {
+  const os = __require2("os");
+  const parts = [
+    os.hostname(),
+    os.platform(),
+    os.arch(),
+    os.cpus()[0]?.model || "unknown"
+  ];
+  return crypto.createHash("sha256").update(parts.join(":")).digest("hex").substring(0, 32);
+}
+__name(getMachineId, "getMachineId");
+__name2(getMachineId, "getMachineId");
+
+export { ConfigStore, StateStore, appendJsonl, appendJsonlAsync, countInJsonl, deriveEncryptionKey, findInJsonl, generateId2 as generateId, getMachineId, loadJsonl, updateInJsonl, writeJsonl };
+//# sourceMappingURL=chunk-QLCHTUT5.js.map
+//# sourceMappingURL=chunk-QLCHTUT5.js.map