memorix 1.1.13 → 1.2.0

package/dist/maintenance-runner.js

@@ -45,9 +45,9 @@ function loadSqlite() {
     throw new Error("[memorix] Neither better-sqlite3 nor bun:sqlite is available");
   }
 }
-function createDatabase(path8, options) {
+function createDatabase(path13, options) {
   const Sqlite = loadSqlite();
-  const db2 = new Sqlite(path8, options);
+  const db2 = new Sqlite(path13, options);
   if (!db2.pragma) {
     db2.pragma = function(pragma, options2) {
       if (options2 && options2.simple) {
@@ -81,6 +81,28 @@ function loadBetterSqlite3() {
     throw new Error("[memorix] SQLite is not available (neither better-sqlite3 nor bun:sqlite)");
   }
 }
+function hasColumn(db2, table, column) {
+  return db2.prepare("PRAGMA table_info(" + table + ")").all().some((row) => row.name === column);
+}
+function addColumnIfMissing(db2, table, column, definition) {
+  if (hasColumn(db2, table, column)) return;
+  db2.exec("ALTER TABLE " + table + " ADD COLUMN " + definition);
+}
+function applySchemaMigrations(db2) {
+  db2.exec(CREATE_SCHEMA_MIGRATIONS_TABLE);
+  for (const migration of SCHEMA_MIGRATIONS) {
+    const applied = db2.prepare("SELECT 1 FROM schema_migrations WHERE id = ?").get(migration.id);
+    if (applied) continue;
+    const apply = db2.transaction(() => {
+      migration.apply(db2);
+      db2.prepare("INSERT INTO schema_migrations (id, applied_at) VALUES (?, ?)").run(
+        migration.id,
+        (/* @__PURE__ */ new Date()).toISOString()
+      );
+    });
+    apply();
+  }
+}
 function getDatabase(dataDir) {
   const normalized = path2.resolve(dataDir);
   const existing = _dbCache.get(normalized);
@@ -143,6 +165,7 @@ function getDatabase(dataDir) {
     db2.exec(`ALTER TABLE team_messages ADD COLUMN handoff_status TEXT`);
   } catch {
   }
+  applySchemaMigrations(db2);
   db2.exec(CREATE_INDEXES);
   db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('storage_generation', '0')`).run();
   db2.prepare(`INSERT OR IGNORE INTO meta (key, value) VALUES ('next_id', '1')`).run();
@@ -159,7 +182,7 @@ function closeAllDatabases() {
     _dbCache.delete(key);
   }
 }
-var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_INDEXES, _dbCache;
+var BetterSqlite3, CREATE_OBSERVATIONS_TABLE, CREATE_MINI_SKILLS_TABLE, CREATE_SESSIONS_TABLE, CREATE_META_TABLE, CREATE_TEAM_AGENTS_TABLE, CREATE_TEAM_MESSAGES_TABLE, CREATE_TEAM_TASKS_TABLE, CREATE_TEAM_TASK_DEPS_TABLE, CREATE_TEAM_LOCKS_TABLE, CREATE_TEAM_ROLES_TABLE, CREATE_CHAT_TRANSCRIPT_TABLE, CREATE_GRAPH_ENTITIES_TABLE, CREATE_GRAPH_RELATIONS_TABLE, CREATE_CODE_FILES_TABLE, CREATE_CODE_SYMBOLS_TABLE, CREATE_CODE_EDGES_TABLE, CREATE_OBSERVATION_CODE_REFS_TABLE, CREATE_SCHEMA_MIGRATIONS_TABLE, CREATE_CODE_STATE_SNAPSHOTS_TABLE, CREATE_KNOWLEDGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE, CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE, CREATE_KNOWLEDGE_WORKSPACES_TABLE, CREATE_KNOWLEDGE_PAGES_TABLE, CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE, CREATE_KNOWLEDGE_PAGE_LINKS_TABLE, CREATE_KNOWLEDGE_PROPOSALS_TABLE, CREATE_KNOWLEDGE_WORKFLOWS_TABLE, CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE, CREATE_MAINTENANCE_JOBS_TABLE, CREATE_MAINTENANCE_TARGETS_TABLE, CREATE_INDEXES, SCHEMA_MIGRATIONS, _dbCache;
 var init_sqlite_db = __esm({
   "src/store/sqlite-db.ts"() {
     "use strict";
@@ -399,6 +422,188 @@ CREATE TABLE IF NOT EXISTS observation_code_refs (
   updatedAt          TEXT
 );
 `;
+    CREATE_SCHEMA_MIGRATIONS_TABLE = [
+      "CREATE TABLE IF NOT EXISTS schema_migrations (",
+      "  id TEXT PRIMARY KEY,",
+      "  applied_at TEXT NOT NULL",
+      ");"
+    ].join("\n");
+    CREATE_CODE_STATE_SNAPSHOTS_TABLE = [
+      "CREATE TABLE IF NOT EXISTS code_state_snapshots (",
+      "  id                   TEXT PRIMARY KEY,",
+      "  projectId            TEXT NOT NULL,",
+      "  provider             TEXT NOT NULL,",
+      "  baseRevision         TEXT,",
+      "  worktreeFingerprint  TEXT NOT NULL,",
+      "  worktreeState        TEXT NOT NULL,",
+      "  changedPathCount     INTEGER NOT NULL DEFAULT 0,",
+      "  indexedAt            TEXT NOT NULL,",
+      "  sourceEpoch          INTEGER NOT NULL,",
+      "  completenessJson     TEXT NOT NULL DEFAULT '{}',",
+      "  previousSnapshotId   TEXT,",
+      "  UNIQUE(projectId, sourceEpoch)",
+      ");"
+    ].join("\n");
+    CREATE_KNOWLEDGE_CLAIMS_TABLE = `
+CREATE TABLE IF NOT EXISTS knowledge_claims (
+  id              TEXT PRIMARY KEY,
+  projectId       TEXT NOT NULL,
+  subject         TEXT NOT NULL,
+  predicate       TEXT NOT NULL,
+  objectValue     TEXT NOT NULL,
+  scope           TEXT NOT NULL,
+  claimKey        TEXT NOT NULL,
+  conflictKey     TEXT NOT NULL,
+  status          TEXT NOT NULL,
+  confidence      REAL NOT NULL,
+  observedAt      TEXT NOT NULL,
+  validFrom       TEXT,
+  validTo         TEXT,
+  supersededBy    TEXT,
+  reviewState     TEXT NOT NULL,
+  origin          TEXT NOT NULL,
+  createdAt       TEXT NOT NULL,
+  updatedAt       TEXT NOT NULL
+);
+`;
+    CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE = `
+CREATE TABLE IF NOT EXISTS knowledge_claim_evidence (
+  id              TEXT PRIMARY KEY,
+  claimId         TEXT NOT NULL,
+  evidenceKind    TEXT NOT NULL,
+  evidenceId      TEXT NOT NULL,
+  relation        TEXT NOT NULL,
+  snapshotId      TEXT,
+  locator         TEXT,
+  capturedHash    TEXT,
+  evidenceKey     TEXT NOT NULL,
+  createdAt       TEXT NOT NULL,
+  UNIQUE(claimId, evidenceKey),
+  FOREIGN KEY (claimId) REFERENCES knowledge_claims(id) ON DELETE CASCADE
+);
+`;
+    CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE = `
+CREATE TABLE IF NOT EXISTS knowledge_claim_events (
+  id              TEXT PRIMARY KEY,
+  projectId       TEXT NOT NULL,
+  claimId         TEXT NOT NULL,
+  kind            TEXT NOT NULL,
+  fromStatus      TEXT,
+  toStatus        TEXT,
+  relatedClaimId  TEXT,
+  detail          TEXT,
+  createdAt       TEXT NOT NULL,
+  FOREIGN KEY (claimId) REFERENCES knowledge_claims(id) ON DELETE CASCADE
+);
+`;
+    CREATE_KNOWLEDGE_WORKSPACES_TABLE = [
+      "CREATE TABLE IF NOT EXISTS knowledge_workspaces (",
+      "  id              TEXT PRIMARY KEY,",
+      "  projectId       TEXT NOT NULL,",
+      "  mode            TEXT NOT NULL,",
+      "  rootPath        TEXT NOT NULL,",
+      "  projectRoot     TEXT,",
+      "  status          TEXT NOT NULL,",
+      "  createdAt       TEXT NOT NULL,",
+      "  updatedAt       TEXT NOT NULL,",
+      "  lastCompiledAt  TEXT,",
+      "  lastLintedAt    TEXT,",
+      "  UNIQUE(projectId, mode)",
+      ");"
+    ].join("\n");
+    CREATE_KNOWLEDGE_PAGES_TABLE = [
+      "CREATE TABLE IF NOT EXISTS knowledge_pages (",
+      "  id                TEXT PRIMARY KEY,",
+      "  workspaceId       TEXT NOT NULL,",
+      "  relativePath      TEXT NOT NULL,",
+      "  title             TEXT NOT NULL,",
+      "  kind              TEXT NOT NULL,",
+      "  status            TEXT NOT NULL,",
+      "  reviewState       TEXT NOT NULL,",
+      "  contentHash       TEXT NOT NULL,",
+      "  sourceHash        TEXT NOT NULL,",
+      "  claimIdsJson      TEXT NOT NULL DEFAULT '[]',",
+      "  snapshotId        TEXT,",
+      "  tagsJson          TEXT NOT NULL DEFAULT '[]',",
+      "  generatedAt       TEXT NOT NULL,",
+      "  updatedAt         TEXT NOT NULL,",
+      "  lastLintedAt      TEXT,",
+      "  manualContentHash TEXT,",
+      "  UNIQUE(workspaceId, relativePath),",
+      "  FOREIGN KEY (workspaceId) REFERENCES knowledge_workspaces(id) ON DELETE CASCADE",
+      ");"
+    ].join("\n");
+    CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE = [
+      "CREATE TABLE IF NOT EXISTS knowledge_page_claims (",
+      "  pageId   TEXT NOT NULL,",
+      "  claimId  TEXT NOT NULL,",
+      "  role     TEXT NOT NULL,",
+      "  PRIMARY KEY (pageId, claimId),",
+      "  FOREIGN KEY (pageId) REFERENCES knowledge_pages(id) ON DELETE CASCADE,",
+      "  FOREIGN KEY (claimId) REFERENCES knowledge_claims(id) ON DELETE RESTRICT",
+      ");"
+    ].join("\n");
+    CREATE_KNOWLEDGE_PAGE_LINKS_TABLE = [
+      "CREATE TABLE IF NOT EXISTS knowledge_page_links (",
+      "  sourcePageId TEXT NOT NULL,",
+      "  targetPath   TEXT NOT NULL,",
+      "  PRIMARY KEY (sourcePageId, targetPath),",
+      "  FOREIGN KEY (sourcePageId) REFERENCES knowledge_pages(id) ON DELETE CASCADE",
+      ");"
+    ].join("\n");
+    CREATE_KNOWLEDGE_PROPOSALS_TABLE = [
+      "CREATE TABLE IF NOT EXISTS knowledge_proposals (",
+      "  id              TEXT PRIMARY KEY,",
+      "  workspaceId     TEXT NOT NULL,",
+      "  pageId          TEXT NOT NULL,",
+      "  targetPath      TEXT NOT NULL,",
+      "  proposalPath    TEXT NOT NULL,",
+      "  baseContentHash TEXT,",
+      "  sourceHash      TEXT NOT NULL,",
+      "  reason          TEXT NOT NULL,",
+      "  status          TEXT NOT NULL,",
+      "  createdAt       TEXT NOT NULL,",
+      "  appliedAt       TEXT,",
+      "  UNIQUE(workspaceId, proposalPath),",
+      "  FOREIGN KEY (workspaceId) REFERENCES knowledge_workspaces(id) ON DELETE CASCADE,",
+      "  FOREIGN KEY (pageId) REFERENCES knowledge_pages(id) ON DELETE CASCADE",
+      ");"
+    ].join("\n");
+    CREATE_KNOWLEDGE_WORKFLOWS_TABLE = [
+      "CREATE TABLE IF NOT EXISTS knowledge_workflows (",
+      "  id            TEXT PRIMARY KEY,",
+      "  workspaceId   TEXT NOT NULL,",
+      "  sourcePath    TEXT NOT NULL,",
+      "  title         TEXT NOT NULL,",
+      "  status        TEXT NOT NULL,",
+      "  version       INTEGER NOT NULL,",
+      "  sourceHash    TEXT NOT NULL,",
+      "  contentHash   TEXT NOT NULL,",
+      "  specJson      TEXT NOT NULL,",
+      "  importedFrom  TEXT,",
+      "  createdAt     TEXT NOT NULL,",
+      "  updatedAt     TEXT NOT NULL,",
+      "  UNIQUE(workspaceId, sourcePath),",
+      "  FOREIGN KEY (workspaceId) REFERENCES knowledge_workspaces(id) ON DELETE CASCADE",
+      ");"
+    ].join("\n");
+    CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE = [
+      "CREATE TABLE IF NOT EXISTS knowledge_workflow_runs (",
+      "  id                    TEXT PRIMARY KEY,",
+      "  workflowId            TEXT NOT NULL,",
+      "  projectId             TEXT NOT NULL,",
+      "  task                  TEXT NOT NULL,",
+      "  startingSnapshotId    TEXT,",
+      "  selectedEvidenceJson  TEXT NOT NULL DEFAULT '[]',",
+      "  phaseStateJson        TEXT NOT NULL DEFAULT '{}',",
+      "  outcome               TEXT NOT NULL,",
+      "  verificationVerdict   TEXT NOT NULL,",
+      "  failureReason         TEXT,",
+      "  startedAt             TEXT NOT NULL,",
+      "  completedAt           TEXT,",
+      "  FOREIGN KEY (workflowId) REFERENCES knowledge_workflows(id) ON DELETE CASCADE",
+      ");"
+    ].join("\n");
     CREATE_MAINTENANCE_JOBS_TABLE = `
 CREATE TABLE IF NOT EXISTS maintenance_jobs (
   id               TEXT PRIMARY KEY,
@@ -450,8 +655,23 @@ CREATE INDEX IF NOT EXISTS idx_code_files_project ON code_files(projectId);
 CREATE INDEX IF NOT EXISTS idx_code_symbols_project_name ON code_symbols(projectId, name);
 CREATE INDEX IF NOT EXISTS idx_code_symbols_file ON code_symbols(fileId);
 CREATE INDEX IF NOT EXISTS idx_code_edges_project ON code_edges(projectId, type);
+CREATE INDEX IF NOT EXISTS idx_code_snapshots_project_epoch ON code_state_snapshots(projectId, sourceEpoch DESC);
+CREATE INDEX IF NOT EXISTS idx_code_files_snapshot ON code_files(projectId, snapshotId);
+CREATE INDEX IF NOT EXISTS idx_code_symbols_snapshot ON code_symbols(projectId, snapshotId);
+CREATE INDEX IF NOT EXISTS idx_code_edges_snapshot ON code_edges(projectId, snapshotId);
 CREATE INDEX IF NOT EXISTS idx_observation_code_refs_obs ON observation_code_refs(projectId, observationId);
 CREATE INDEX IF NOT EXISTS idx_observation_code_refs_status ON observation_code_refs(projectId, status);
+CREATE INDEX IF NOT EXISTS idx_knowledge_claims_project_status ON knowledge_claims(projectId, status, updatedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_knowledge_claims_project_conflict ON knowledge_claims(projectId, conflictKey, status);
+CREATE INDEX IF NOT EXISTS idx_knowledge_claims_project_key ON knowledge_claims(projectId, claimKey, status);
+CREATE INDEX IF NOT EXISTS idx_knowledge_claim_evidence_claim ON knowledge_claim_evidence(claimId, createdAt);
+CREATE INDEX IF NOT EXISTS idx_knowledge_claim_events_claim ON knowledge_claim_events(claimId, createdAt);
+CREATE INDEX IF NOT EXISTS idx_knowledge_workspaces_project ON knowledge_workspaces(projectId, mode);
+CREATE INDEX IF NOT EXISTS idx_knowledge_pages_workspace_status ON knowledge_pages(workspaceId, status, updatedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_knowledge_page_claims_claim ON knowledge_page_claims(claimId);
+CREATE INDEX IF NOT EXISTS idx_knowledge_proposals_workspace_status ON knowledge_proposals(workspaceId, status, createdAt DESC);
+CREATE INDEX IF NOT EXISTS idx_knowledge_workflows_workspace_status ON knowledge_workflows(workspaceId, status, updatedAt DESC);
+CREATE INDEX IF NOT EXISTS idx_knowledge_workflow_runs_project_workflow ON knowledge_workflow_runs(projectId, workflowId, startedAt DESC);
 CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_ready ON maintenance_jobs(status, run_after);
 CREATE INDEX IF NOT EXISTS idx_maintenance_jobs_project ON maintenance_jobs(project_id, status, run_after);
 CREATE INDEX IF NOT EXISTS idx_maintenance_targets_updated ON maintenance_targets(updated_at);
@@ -459,6 +679,61 @@ CREATE UNIQUE INDEX IF NOT EXISTS idx_maintenance_jobs_active_dedupe
   ON maintenance_jobs(project_id, kind, dedupe_key)
   WHERE status IN ('pending', 'running', 'retry');
 `;
+    SCHEMA_MIGRATIONS = [
+      {
+        id: "1.2-code-state-snapshots",
+        apply: (db2) => {
+          db2.exec(CREATE_CODE_STATE_SNAPSHOTS_TABLE);
+          addColumnIfMissing(db2, "code_files", "snapshotId", "snapshotId TEXT");
+          addColumnIfMissing(db2, "code_files", "sourceEpoch", "sourceEpoch INTEGER");
+          addColumnIfMissing(db2, "code_symbols", "snapshotId", "snapshotId TEXT");
+          addColumnIfMissing(db2, "code_symbols", "sourceEpoch", "sourceEpoch INTEGER");
+          addColumnIfMissing(db2, "code_edges", "snapshotId", "snapshotId TEXT");
+          addColumnIfMissing(db2, "code_edges", "sourceEpoch", "sourceEpoch INTEGER");
+          addColumnIfMissing(db2, "observation_code_refs", "snapshotId", "snapshotId TEXT");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_code_snapshots_project_epoch ON code_state_snapshots(projectId, sourceEpoch DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_code_files_snapshot ON code_files(projectId, snapshotId)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_code_symbols_snapshot ON code_symbols(projectId, snapshotId)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_code_edges_snapshot ON code_edges(projectId, snapshotId)");
+        }
+      },
+      {
+        id: "1.2-knowledge-claim-ledger",
+        apply: (db2) => {
+          db2.exec(CREATE_KNOWLEDGE_CLAIMS_TABLE);
+          db2.exec(CREATE_KNOWLEDGE_CLAIM_EVIDENCE_TABLE);
+          db2.exec(CREATE_KNOWLEDGE_CLAIM_EVENTS_TABLE);
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_claims_project_status ON knowledge_claims(projectId, status, updatedAt DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_claims_project_conflict ON knowledge_claims(projectId, conflictKey, status)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_claims_project_key ON knowledge_claims(projectId, claimKey, status)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_claim_evidence_claim ON knowledge_claim_evidence(claimId, createdAt)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_claim_events_claim ON knowledge_claim_events(claimId, createdAt)");
+        }
+      },
+      {
+        id: "1.2-knowledge-workspace",
+        apply: (db2) => {
+          db2.exec(CREATE_KNOWLEDGE_WORKSPACES_TABLE);
+          db2.exec(CREATE_KNOWLEDGE_PAGES_TABLE);
+          db2.exec(CREATE_KNOWLEDGE_PAGE_CLAIMS_TABLE);
+          db2.exec(CREATE_KNOWLEDGE_PAGE_LINKS_TABLE);
+          db2.exec(CREATE_KNOWLEDGE_PROPOSALS_TABLE);
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_workspaces_project ON knowledge_workspaces(projectId, mode)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_pages_workspace_status ON knowledge_pages(workspaceId, status, updatedAt DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_page_claims_claim ON knowledge_page_claims(claimId)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_proposals_workspace_status ON knowledge_proposals(workspaceId, status, createdAt DESC)");
+        }
+      },
+      {
+        id: "1.2-workflow-inheritance",
+        apply: (db2) => {
+          db2.exec(CREATE_KNOWLEDGE_WORKFLOWS_TABLE);
+          db2.exec(CREATE_KNOWLEDGE_WORKFLOW_RUNS_TABLE);
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_workflows_workspace_status ON knowledge_workflows(workspaceId, status, updatedAt DESC)");
+          db2.exec("CREATE INDEX IF NOT EXISTS idx_knowledge_workflow_runs_project_workflow ON knowledge_workflow_runs(projectId, workflowId, startedAt DESC)");
+        }
+      }
+    ];
     _dbCache = /* @__PURE__ */ new Map();
   }
 });
@@ -598,8 +873,8 @@ function parseYaml(content) {
     return yaml.load(content) ?? {};
   } catch {
     try {
-      const matter = require2("gray-matter");
-      const parsed = matter(`---
+      const matter4 = require2("gray-matter");
+      const parsed = matter4(`---
 ${content}
 ---`);
       return parsed.data ?? {};
@@ -851,9 +1126,9 @@ function parseTomlConfig(content, filePath) {
   }
   return root;
 }
-function ensureTable(root, path8) {
+function ensureTable(root, path13) {
   let cursor = root;
-  for (const part of path8) {
+  for (const part of path13) {
     const value = cursor[part];
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       cursor[part] = {};
@@ -1000,7 +1275,23 @@ function getResolvedConfig(options = {}) {
     },
     codegraph: {
       excludePatterns: firstArray(toml.codegraph?.exclude_patterns, yaml.codegraph?.excludePatterns),
-      maxFileBytes: firstNumber(toml.codegraph?.max_file_bytes, yaml.codegraph?.maxFileBytes)
+      maxFileBytes: firstNumber(toml.codegraph?.max_file_bytes, yaml.codegraph?.maxFileBytes),
+      externalContext: first(
+        normalizeExternalContext(process.env.MEMORIX_CODEGRAPH_EXTERNAL_CONTEXT),
+        toml.codegraph?.external_context,
+        yaml.codegraph?.externalContext,
+        "auto"
+      ),
+      externalCommand: first(
+        process.env.MEMORIX_CODEGRAPH_EXTERNAL_COMMAND,
+        toml.codegraph?.external_command,
+        yaml.codegraph?.externalCommand
+      ),
+      externalTimeoutMs: firstNumber(
+        parseNumber(process.env.MEMORIX_CODEGRAPH_EXTERNAL_TIMEOUT_MS),
+        toml.codegraph?.external_timeout_ms,
+        yaml.codegraph?.externalTimeoutMs
+      )
     },
     server: {
       transport: first(toml.server?.transport, yaml.server?.transport),
@@ -1085,6 +1376,9 @@ function getEnvSourceNames() {
     "MEMORIX_EMBEDDING_BASE_URL",
     "MEMORIX_EMBEDDING_MODEL",
     "MEMORIX_EMBEDDING_DIMENSIONS",
+    "MEMORIX_CODEGRAPH_EXTERNAL_CONTEXT",
+    "MEMORIX_CODEGRAPH_EXTERNAL_COMMAND",
+    "MEMORIX_CODEGRAPH_EXTERNAL_TIMEOUT_MS",
     "OPENROUTER_API_KEY"
   ].filter((name) => process.env[name]);
 }
@@ -1097,6 +1391,11 @@ function isOpenRouterUrl(value) {
     return /(^|\.)openrouter\.ai(?::|\/|$)/i.test(value);
   }
 }
+function normalizeExternalContext(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (normalized === "auto" || normalized === "off") return normalized;
+  return void 0;
+}
 var init_resolved_config = __esm({
   "src/config/resolved-config.ts"() {
     "use strict";
@@ -2394,7 +2693,12 @@ var init_maintenance_jobs = __esm({
       "vector-backfill",
       "retention-archive",
       "consolidation",
-      "codegraph-refresh"
+      "codegraph-refresh",
+      "claim-derive",
+      "claim-requalification",
+      "knowledge-compile",
+      "knowledge-lint",
+      "workflow-index"
     ];
     DEFAULT_MAX_ATTEMPTS = 8;
     DEFAULT_LEASE_MS = 3e4;
@@ -2407,14 +2711,14 @@ var init_maintenance_jobs = __esm({
         this.db = getDatabase(dataDir);
       }
       enqueue(input) {
-        const now = input.now ?? Date.now();
+        const now3 = input.now ?? Date.now();
         const dedupeKey = input.dedupeKey ?? input.kind;
-        const runAfter = input.runAfter ?? now;
+        const runAfter = input.runAfter ?? now3;
         const maxAttempts = clampPositiveInteger(input.maxAttempts, DEFAULT_MAX_ATTEMPTS);
         const payloadJson = JSON.stringify(input.payload ?? {});
         this.begin();
         try {
-          this.pruneCompletedHistory({ now });
+          this.pruneCompletedHistory({ now: now3 });
           const existing = this.db.prepare(`
         SELECT * FROM maintenance_jobs
         WHERE project_id = ? AND kind = ? AND dedupe_key = ?
@@ -2427,7 +2731,7 @@ var init_maintenance_jobs = __esm({
           UPDATE maintenance_jobs
           SET payload_json = ?, run_after = ?, updated_at = ?
           WHERE id = ?
-        `).run(payloadJson, nextRunAfter, now, existing.id);
+        `).run(payloadJson, nextRunAfter, now3, existing.id);
             const updated = this.getRow(existing.id);
             this.commit();
             return rowToJob(updated);
@@ -2438,7 +2742,7 @@ var init_maintenance_jobs = __esm({
           id, project_id, kind, dedupe_key, payload_json, status, attempts,
           max_attempts, run_after, created_at, updated_at
         ) VALUES (?, ?, ?, ?, ?, 'pending', 0, ?, ?, ?, ?)
-      `).run(id, input.projectId, input.kind, dedupeKey, payloadJson, maxAttempts, runAfter, now, now);
+      `).run(id, input.projectId, input.kind, dedupeKey, payloadJson, maxAttempts, runAfter, now3, now3);
           const created = this.getRow(id);
           this.commit();
           return rowToJob(created);
@@ -2507,18 +2811,18 @@ var init_maintenance_jobs = __esm({
        * resolves them or clears the database.
        */
       pruneCompletedHistory(options = {}) {
-        const now = options.now ?? Date.now();
+        const now3 = options.now ?? Date.now();
         const maxAgeMs = Number.isFinite(options.maxAgeMs) ? Math.max(0, Math.floor(options.maxAgeMs)) : DEFAULT_COMPLETED_HISTORY_RETENTION_MS;
         const result = this.db.prepare(`
       DELETE FROM maintenance_jobs
       WHERE status = 'completed'
         AND completed_at IS NOT NULL
         AND completed_at < ?
-    `).run(now - maxAgeMs);
+    `).run(now3 - maxAgeMs);
         return Number(result.changes ?? 0);
       }
       claimNext(options) {
-        const now = options.now ?? Date.now();
+        const now3 = options.now ?? Date.now();
         const leaseMs = clampPositiveInteger(options.leaseMs, DEFAULT_LEASE_MS);
         const kinds = normalizedKinds(options.kinds);
         this.begin();
@@ -2533,12 +2837,12 @@ var init_maintenance_jobs = __esm({
           last_error = COALESCE(last_error, 'worker lease expired'),
           updated_at = ?
         WHERE status = 'running' AND lease_expires_at IS NOT NULL AND lease_expires_at <= ?
-      `).run(now, now, now);
+      `).run(now3, now3, now3);
           this.db.prepare(`
         UPDATE maintenance_jobs
         SET status = 'failed', updated_at = ?
         WHERE status IN ('pending', 'retry') AND attempts >= max_attempts
-      `).run(now);
+      `).run(now3);
           if (options.kinds && kinds?.length === 0) {
             this.commit();
             return void 0;
@@ -2546,7 +2850,7 @@ var init_maintenance_jobs = __esm({
           const projectClause = options.projectId ? "AND project_id = ?" : "";
           const kindClause = kinds?.length ? `AND kind IN (${kinds.map(() => "?").join(", ")})` : "";
           const values = [
-            now,
+            now3,
             ...kinds ?? [],
             ...options.projectId ? [options.projectId] : []
           ];
@@ -2562,13 +2866,13 @@ var init_maintenance_jobs = __esm({
             this.commit();
             return void 0;
           }
-          const leaseExpiresAt = now + leaseMs;
+          const leaseExpiresAt = now3 + leaseMs;
           this.db.prepare(`
         UPDATE maintenance_jobs
         SET status = 'running', attempts = attempts + 1, lease_owner = ?,
             lease_expires_at = ?, updated_at = ?
         WHERE id = ?
-      `).run(options.workerId, leaseExpiresAt, now, candidate.id);
+      `).run(options.workerId, leaseExpiresAt, now3, candidate.id);
           const claimed = this.getRow(candidate.id);
           this.commit();
           return rowToJob(claimed);
@@ -2581,26 +2885,26 @@ var init_maintenance_jobs = __esm({
        * Extend a running job's lease. A worker may only renew its own lease, so a
        * stale worker cannot reclaim work that was already recovered elsewhere.
        */
-      renewLease(id, workerId, leaseMs = DEFAULT_LEASE_MS, now = Date.now()) {
-        const expiresAt = now + clampPositiveInteger(leaseMs, DEFAULT_LEASE_MS);
+      renewLease(id, workerId, leaseMs = DEFAULT_LEASE_MS, now3 = Date.now()) {
+        const expiresAt = now3 + clampPositiveInteger(leaseMs, DEFAULT_LEASE_MS);
         const result = this.db.prepare(`
       UPDATE maintenance_jobs
       SET lease_expires_at = ?, updated_at = ?
       WHERE id = ? AND status = 'running' AND lease_owner = ?
-    `).run(expiresAt, now, id, workerId);
+    `).run(expiresAt, now3, id, workerId);
         return Number(result.changes) > 0;
       }
-      complete(id, workerId, now = Date.now()) {
+      complete(id, workerId, now3 = Date.now()) {
         this.db.prepare(`
       UPDATE maintenance_jobs
       SET status = 'completed', lease_owner = NULL, lease_expires_at = NULL,
           completed_at = ?, updated_at = ?
       WHERE id = ? AND status = 'running' AND lease_owner = ?
-    `).run(now, now, id, workerId);
+    `).run(now3, now3, id, workerId);
         return this.get(id);
       }
       reschedule(id, workerId, options) {
-        const now = options.now ?? Date.now();
+        const now3 = options.now ?? Date.now();
         const delayMs = Number.isFinite(options.delayMs) ? Math.max(0, Math.floor(options.delayMs)) : 0;
         const payloadJson = options.payload === void 0 ? null : JSON.stringify(options.payload);
         this.db.prepare(`
@@ -2609,10 +2913,10 @@ var init_maintenance_jobs = __esm({
           payload_json = COALESCE(?, payload_json),
           lease_owner = NULL, lease_expires_at = NULL, updated_at = ?
       WHERE id = ? AND status = 'running' AND lease_owner = ?
-    `).run(now + delayMs, options.resetAttempts ? 1 : 0, payloadJson, now, id, workerId);
+    `).run(now3 + delayMs, options.resetAttempts ? 1 : 0, payloadJson, now3, id, workerId);
         return this.get(id);
       }
-      fail(id, workerId, error, now = Date.now()) {
+      fail(id, workerId, error, now3 = Date.now()) {
         this.begin();
         try {
           const current = this.db.prepare(`
@@ -2626,13 +2930,13 @@ var init_maintenance_jobs = __esm({
           const attempts = Number(current.attempts);
           const exhausted = attempts >= Number(current.max_attempts);
           const status = exhausted ? "failed" : "retry";
-          const runAfter = exhausted ? Number(current.run_after) : now + getMaintenanceRetryDelayMs(attempts);
+          const runAfter = exhausted ? Number(current.run_after) : now3 + getMaintenanceRetryDelayMs(attempts);
           this.db.prepare(`
         UPDATE maintenance_jobs
         SET status = ?, run_after = ?, lease_owner = NULL, lease_expires_at = NULL,
             last_error = ?, updated_at = ?
         WHERE id = ?
-      `).run(status, runAfter, errorText(error), now, id);
+      `).run(status, runAfter, errorText(error), now3, id);
           const updated = this.getRow(id);
           this.commit();
           return rowToJob(updated);
@@ -2676,7 +2980,7 @@ var init_maintenance_jobs = __esm({
       kinds;
       timer = null;
       running = false;
-      async runOnce(now = Date.now()) {
+      async runOnce(now3 = Date.now()) {
         if (this.running) return { state: "busy" };
         this.running = true;
         try {
@@ -2684,7 +2988,7 @@ var init_maintenance_jobs = __esm({
             workerId: this.workerId,
             projectId: this.projectId,
             kinds: this.kinds,
-            now,
+            now: now3,
             leaseMs: this.leaseMs
           });
           if (!job) return { state: "idle" };
@@ -2707,14 +3011,14 @@ var init_maintenance_jobs = __esm({
                 delayMs: result.delayMs,
                 resetAttempts: result.resetAttempts,
                 payload: result.payload,
-                now
+                now: now3
               });
               return { state: "rescheduled", job: updated2 };
             }
-            const updated = this.store.complete(job.id, this.workerId, now);
+            const updated = this.store.complete(job.id, this.workerId, now3);
             return { state: "completed", job: updated };
           } catch (error) {
-            const updated = this.store.fail(job.id, this.workerId, error, now);
+            const updated = this.store.fail(job.id, this.workerId, error, now3);
             return { state: "failed", job: updated };
           } finally {
             clearInterval(heartbeat);
@@ -2742,6 +3046,527 @@ var init_maintenance_jobs = __esm({
   }
 });
 
+// src/runtime/lifecycle.ts
+function queueFor(input) {
+  return input.queue ?? new MaintenanceJobStore(input.dataDir);
+}
+function enqueueClaimRequalification(input) {
+  queueFor(input).enqueue({
+    projectId: input.projectId,
+    kind: "claim-requalification",
+    dedupeKey: "claim-requalification",
+    payload: {
+      source: input.source,
+      ...input.snapshotId ? { snapshotId: input.snapshotId } : {}
+    }
+  });
+}
+function enqueueClaimDerivation(input) {
+  queueFor(input).enqueue({
+    projectId: input.projectId,
+    kind: "claim-derive",
+    dedupeKey: "claim-derive:" + input.observationId,
+    payload: { observationId: input.observationId }
+  });
+}
+function enqueueKnowledgeFollowups(input) {
+  const queue = queueFor(input);
+  const payload = {
+    source: input.source,
+    ...input.workspaceMode ? { workspaceMode: input.workspaceMode } : {},
+    ...input.allowVersionedWrite ? { allowVersionedWrite: true } : {}
+  };
+  if (input.includeCompile) {
+    queue.enqueue({
+      projectId: input.projectId,
+      kind: "knowledge-compile",
+      dedupeKey: "knowledge-compile",
+      payload
+    });
+  }
+  queue.enqueue({
+    projectId: input.projectId,
+    kind: "knowledge-lint",
+    dedupeKey: "knowledge-lint",
+    payload
+  });
+  queue.enqueue({
+    projectId: input.projectId,
+    kind: "workflow-index",
+    dedupeKey: "workflow-index",
+    payload
+  });
+}
+var init_lifecycle = __esm({
+  "src/runtime/lifecycle.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_maintenance_jobs();
+  }
+});
+
+// src/store/file-lock.ts
+import { promises as fs3 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import path6 from "path";
+async function acquireLock(lockPath) {
+  for (let i = 0; i < MAX_RETRIES; i++) {
+    try {
+      const fd = await fs3.open(lockPath, "wx");
+      await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
+      await fd.close();
+      return;
+    } catch (err) {
+      const code = err instanceof Error && "code" in err ? err.code : void 0;
+      if (code === "EEXIST" || code === "EPERM") {
+        try {
+          const stat = await fs3.stat(lockPath);
+          if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+            await fs3.unlink(lockPath).catch(() => {
+            });
+            continue;
+          }
+        } catch {
+          continue;
+        }
+        await new Promise((r) => setTimeout(r, RETRY_INTERVAL_MS));
+      } else {
+        throw err;
+      }
+    }
+  }
+  await fs3.unlink(lockPath).catch(() => {
+  });
+  try {
+    const fd = await fs3.open(lockPath, "wx");
+    await fd.writeFile(JSON.stringify({ pid: process.pid, time: Date.now() }));
+    await fd.close();
+    return;
+  } catch {
+    throw new Error(`Failed to acquire lock: ${lockPath} (timeout after ${MAX_RETRIES * RETRY_INTERVAL_MS}ms)`);
+  }
+}
+async function releaseLock(lockPath) {
+  await fs3.unlink(lockPath).catch(() => {
+  });
+}
+async function withFileLock(projectDir2, fn) {
+  const lockPath = path6.join(projectDir2, ".memorix.lock");
+  await acquireLock(lockPath);
+  try {
+    return await fn();
+  } finally {
+    await releaseLock(lockPath);
+  }
+}
+async function atomicWriteFileOnce(filePath, data) {
+  const tmpPath = filePath + `.tmp.${process.pid}.${randomUUID2()}`;
+  try {
+    await fs3.writeFile(tmpPath, data, "utf-8");
+    await fs3.rename(tmpPath, filePath);
+  } catch (error) {
+    await fs3.unlink(tmpPath).catch(() => {
+    });
+    throw error;
+  }
+}
+function atomicWriteFile(filePath, data) {
+  const previous = atomicWriteTails.get(filePath) ?? Promise.resolve();
+  const next = previous.catch(() => void 0).then(() => atomicWriteFileOnce(filePath, data));
+  atomicWriteTails.set(filePath, next);
+  return next.finally(() => {
+    if (atomicWriteTails.get(filePath) === next) atomicWriteTails.delete(filePath);
+  });
+}
+var LOCK_STALE_MS, RETRY_INTERVAL_MS, MAX_RETRIES, atomicWriteTails;
+var init_file_lock = __esm({
+  "src/store/file-lock.ts"() {
+    "use strict";
+    init_esm_shims();
+    LOCK_STALE_MS = 1e4;
+    RETRY_INTERVAL_MS = 50;
+    MAX_RETRIES = 60;
+    atomicWriteTails = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/knowledge/workspace-store.ts
+import { randomUUID as randomUUID3 } from "crypto";
+function arrayValue(raw) {
+  if (typeof raw !== "string" || !raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function optionalText(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function rowToWorkspace(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    mode: row.mode,
+    rootPath: row.rootPath,
+    ...optionalText(row.projectRoot) ? { projectRoot: row.projectRoot } : {},
+    status: row.status,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    ...optionalText(row.lastCompiledAt) ? { lastCompiledAt: row.lastCompiledAt } : {},
+    ...optionalText(row.lastLintedAt) ? { lastLintedAt: row.lastLintedAt } : {}
+  };
+}
+function rowToPage(row) {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    relativePath: row.relativePath,
+    title: row.title,
+    kind: row.kind,
+    status: row.status,
+    reviewState: row.reviewState,
+    contentHash: row.contentHash,
+    sourceHash: row.sourceHash,
+    claimIds: arrayValue(row.claimIdsJson),
+    ...optionalText(row.snapshotId) ? { snapshotId: row.snapshotId } : {},
+    tags: arrayValue(row.tagsJson),
+    generatedAt: row.generatedAt,
+    updatedAt: row.updatedAt,
+    ...optionalText(row.lastLintedAt) ? { lastLintedAt: row.lastLintedAt } : {},
+    ...optionalText(row.manualContentHash) ? { manualContentHash: row.manualContentHash } : {}
+  };
+}
+function rowToProposal(row) {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    pageId: row.pageId,
+    targetPath: row.targetPath,
+    proposalPath: row.proposalPath,
+    ...optionalText(row.baseContentHash) ? { baseContentHash: row.baseContentHash } : {},
+    sourceHash: row.sourceHash,
+    reason: row.reason,
+    status: row.status,
+    createdAt: row.createdAt,
+    ...optionalText(row.appliedAt) ? { appliedAt: row.appliedAt } : {}
+  };
+}
+var KnowledgeWorkspaceStore;
+var init_workspace_store = __esm({
+  "src/knowledge/workspace-store.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    KnowledgeWorkspaceStore = class {
+      db = null;
+      async init(dataDir) {
+        this.db = getDatabase(dataDir);
+      }
+      upsertWorkspace(input) {
+        const now3 = input.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+        const createdAt = input.createdAt ?? now3;
+        this.db.prepare(
+          "INSERT INTO knowledge_workspaces (id, projectId, mode, rootPath, projectRoot, status, createdAt, updatedAt, lastCompiledAt, lastLintedAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(id) DO UPDATE SET mode = excluded.mode, rootPath = excluded.rootPath, projectRoot = excluded.projectRoot, status = excluded.status, updatedAt = excluded.updatedAt, lastCompiledAt = excluded.lastCompiledAt, lastLintedAt = excluded.lastLintedAt"
+        ).run(
+          input.id,
+          input.projectId,
+          input.mode,
+          input.rootPath,
+          input.projectRoot ?? null,
+          input.status,
+          createdAt,
+          now3,
+          input.lastCompiledAt ?? null,
+          input.lastLintedAt ?? null
+        );
+        return this.getWorkspace(input.id);
+      }
+      getWorkspace(id) {
+        const row = this.db.prepare("SELECT * FROM knowledge_workspaces WHERE id = ?").get(id);
+        return row ? rowToWorkspace(row) : void 0;
+      }
+      findWorkspace(projectId, mode) {
+        const row = this.db.prepare("SELECT * FROM knowledge_workspaces WHERE projectId = ? AND mode = ? ORDER BY updatedAt DESC LIMIT 1").get(projectId, mode);
+        return row ? rowToWorkspace(row) : void 0;
+      }
+      upsertPage(page) {
+        this.db.prepare(
+          "INSERT INTO knowledge_pages (id, workspaceId, relativePath, title, kind, status, reviewState, contentHash, sourceHash, claimIdsJson, snapshotId, tagsJson, generatedAt, updatedAt, lastLintedAt, manualContentHash) VALUES (@id, @workspaceId, @relativePath, @title, @kind, @status, @reviewState, @contentHash, @sourceHash, @claimIdsJson, @snapshotId, @tagsJson, @generatedAt, @updatedAt, @lastLintedAt, @manualContentHash) ON CONFLICT(workspaceId, relativePath) DO UPDATE SET id = excluded.id, title = excluded.title, kind = excluded.kind, status = excluded.status, reviewState = excluded.reviewState, contentHash = excluded.contentHash, sourceHash = excluded.sourceHash, claimIdsJson = excluded.claimIdsJson, snapshotId = excluded.snapshotId, tagsJson = excluded.tagsJson, generatedAt = excluded.generatedAt, updatedAt = excluded.updatedAt, lastLintedAt = excluded.lastLintedAt, manualContentHash = excluded.manualContentHash"
+        ).run({
+          ...page,
+          claimIdsJson: JSON.stringify(page.claimIds),
+          snapshotId: page.snapshotId ?? null,
+          tagsJson: JSON.stringify(page.tags),
+          lastLintedAt: page.lastLintedAt ?? null,
+          manualContentHash: page.manualContentHash ?? null
+        });
+      }
+      getPage(workspaceId2, relativePath) {
+        const row = this.db.prepare("SELECT * FROM knowledge_pages WHERE workspaceId = ? AND relativePath = ?").get(workspaceId2, relativePath);
+        return row ? rowToPage(row) : void 0;
+      }
+      getPageById(id) {
+        const row = this.db.prepare("SELECT * FROM knowledge_pages WHERE id = ?").get(id);
+        return row ? rowToPage(row) : void 0;
+      }
+      listPages(workspaceId2) {
+        return this.db.prepare("SELECT * FROM knowledge_pages WHERE workspaceId = ? ORDER BY relativePath").all(workspaceId2).map(rowToPage);
+      }
+      replacePageClaims(pageId, claimIds) {
+        const remove3 = this.db.prepare("DELETE FROM knowledge_page_claims WHERE pageId = ?");
+        const insert3 = this.db.prepare("INSERT OR IGNORE INTO knowledge_page_claims (pageId, claimId, role) VALUES (?, ?, 'primary')");
+        this.db.transaction(() => {
+          remove3.run(pageId);
+          for (const claimId of [...new Set(claimIds)]) insert3.run(pageId, claimId);
+        })();
+      }
+      replacePageLinks(pageId, targets) {
+        const remove3 = this.db.prepare("DELETE FROM knowledge_page_links WHERE sourcePageId = ?");
+        const insert3 = this.db.prepare("INSERT OR IGNORE INTO knowledge_page_links (sourcePageId, targetPath) VALUES (?, ?)");
+        this.db.transaction(() => {
+          remove3.run(pageId);
+          for (const target of [...new Set(targets)]) insert3.run(pageId, target);
+        })();
+      }
+      createProposal(input) {
+        const proposal = {
+          id: input.id ?? randomUUID3(),
+          ...input,
+          status: input.status ?? "pending",
+          createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.db.prepare(
+          "INSERT INTO knowledge_proposals (id, workspaceId, pageId, targetPath, proposalPath, baseContentHash, sourceHash, reason, status, createdAt, appliedAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(workspaceId, proposalPath) DO UPDATE SET pageId = excluded.pageId, targetPath = excluded.targetPath, baseContentHash = excluded.baseContentHash, sourceHash = excluded.sourceHash, reason = excluded.reason, status = excluded.status, createdAt = excluded.createdAt, appliedAt = excluded.appliedAt"
+        ).run(
+          proposal.id,
+          proposal.workspaceId,
+          proposal.pageId,
+          proposal.targetPath,
+          proposal.proposalPath,
+          proposal.baseContentHash ?? null,
+          proposal.sourceHash,
+          proposal.reason,
+          proposal.status,
+          proposal.createdAt,
+          proposal.appliedAt ?? null
+        );
+        const row = this.db.prepare("SELECT * FROM knowledge_proposals WHERE workspaceId = ? AND proposalPath = ?").get(proposal.workspaceId, proposal.proposalPath);
+        return rowToProposal(row);
+      }
+      getProposal(id) {
+        const row = this.db.prepare("SELECT * FROM knowledge_proposals WHERE id = ?").get(id);
+        return row ? rowToProposal(row) : void 0;
+      }
+      listProposals(workspaceId2, status) {
+        const rows = status ? this.db.prepare("SELECT * FROM knowledge_proposals WHERE workspaceId = ? AND status = ? ORDER BY createdAt DESC, id").all(workspaceId2, status) : this.db.prepare("SELECT * FROM knowledge_proposals WHERE workspaceId = ? ORDER BY createdAt DESC, id").all(workspaceId2);
+        return rows.map(rowToProposal);
+      }
+      markProposalApplied(id, appliedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+        this.db.prepare("UPDATE knowledge_proposals SET status = 'applied', appliedAt = ? WHERE id = ?").run(appliedAt, id);
+        return this.getProposal(id);
+      }
+      markWorkspaceCompiled(id, at = (/* @__PURE__ */ new Date()).toISOString()) {
+        this.db.prepare("UPDATE knowledge_workspaces SET lastCompiledAt = ?, updatedAt = ? WHERE id = ?").run(at, at, id);
+      }
+      markWorkspaceLinted(id, status, at = (/* @__PURE__ */ new Date()).toISOString()) {
+        this.db.prepare("UPDATE knowledge_workspaces SET status = ?, lastLintedAt = ?, updatedAt = ? WHERE id = ?").run(status, at, at, id);
+      }
+    };
+  }
+});
+
+// src/knowledge/workspace.ts
+var workspace_exports = {};
+__export(workspace_exports, {
+  getKnowledgeWorkspacePaths: () => getKnowledgeWorkspacePaths,
+  initializeKnowledgeWorkspace: () => initializeKnowledgeWorkspace,
+  loadKnowledgeWorkspace: () => loadKnowledgeWorkspace,
+  resolveKnowledgeWorkspaceFile: () => resolveKnowledgeWorkspaceFile
+});
+import { createHash } from "crypto";
+import { execFile } from "child_process";
+import { promises as fs4 } from "fs";
+import path7 from "path";
+import { promisify } from "util";
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function workspaceId(projectId, mode) {
+  return "workspace:" + hash(projectId + ":" + mode).slice(0, 24);
+}
+function localWorkspacePath(dataDir, projectId) {
+  return path7.join(path7.resolve(dataDir), "knowledge-workspaces", hash(projectId).slice(0, 24));
+}
+function isWithin(root, candidate) {
+  const relative2 = path7.relative(root, candidate);
+  return relative2 !== "" && !relative2.startsWith(".." + path7.sep) && relative2 !== ".." && !path7.isAbsolute(relative2);
+}
+function ensureVersionedPath(projectRoot, rootPath) {
+  if (!path7.isAbsolute(rootPath)) {
+    throw new Error("A versioned knowledge workspace requires an explicit absolute path");
+  }
+  const resolvedProject = path7.resolve(projectRoot);
+  const resolvedWorkspace = path7.resolve(rootPath);
+  if (!isWithin(resolvedProject, resolvedWorkspace)) {
+    throw new Error("A versioned knowledge workspace must live inside the Git project");
+  }
+  const segments = path7.relative(resolvedProject, resolvedWorkspace).split(path7.sep);
+  if (segments.includes(".git") || segments.includes("node_modules") || segments.includes("dist")) {
+    throw new Error("The selected knowledge workspace path is not safe for project artifacts");
+  }
+  return resolvedWorkspace;
+}
+async function isIgnoredByGit(projectRoot, workspaceRoot) {
+  const relative2 = path7.relative(projectRoot, workspaceRoot).split(path7.sep).join("/");
+  const probes = [relative2, relative2.replace(/\/+$/, "") + "/.memorix-workspace-probe"];
+  for (const probe of probes) {
+    try {
+      await execFileAsync("git", ["-C", projectRoot, "check-ignore", "--quiet", "--no-index", "--", probe], {
+        timeout: 3e3,
+        windowsHide: true
+      });
+      return true;
+    } catch (error) {
+      const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+      if (code === 1 || code === "1") continue;
+      return false;
+    }
+  }
+  return false;
+}
+async function assertNoSymlinkEscape(projectRoot, workspaceRoot) {
+  const [realProject, realWorkspace] = await Promise.all([
+    fs4.realpath(projectRoot),
+    fs4.realpath(workspaceRoot)
+  ]);
+  if (!isWithin(realProject, realWorkspace)) {
+    throw new Error("The selected knowledge workspace resolves outside the Git project");
+  }
+}
+function getKnowledgeWorkspacePaths(workspace) {
+  const root = path7.resolve(workspace.rootPath);
+  return {
+    root,
+    pages: path7.join(root, "pages"),
+    proposals: path7.join(root, "proposals"),
+    workflows: path7.join(root, "workflows"),
+    index: path7.join(root, "index.md"),
+    log: path7.join(root, "log.md"),
+    schema: path7.join(root, "schema.md")
+  };
+}
+function resolveKnowledgeWorkspaceFile(workspace, relativePath) {
+  if (!relativePath || path7.isAbsolute(relativePath)) {
+    throw new Error("Knowledge workspace paths must be relative");
+  }
+  const root = path7.resolve(workspace.rootPath);
+  const candidate = path7.resolve(root, relativePath);
+  if (candidate === root || !isWithin(root, candidate)) {
+    throw new Error("Knowledge workspace path escapes its root");
+  }
+  return candidate;
+}
+async function writeIfMissing(filePath, content) {
+  try {
+    await fs4.access(filePath);
+  } catch {
+    await atomicWriteFile(filePath, content);
+  }
+}
+function schemaContent() {
+  return [
+    "# Memorix Knowledge Workspace",
+    "",
+    "This workspace is compiled from source-qualified Memorix claims.",
+    "Topic pages are proposal-first: review and apply a proposal before relying",
+    "on it as a published project knowledge page.",
+    "",
+    "Do not remove claim ids, evidence references, source hashes, or snapshot",
+    "references from page frontmatter. Manual body edits are preserved and cause",
+    "later compiler output to remain a proposal.",
+    ""
+  ].join("\n");
+}
+function indexContent() {
+  return [
+    "# Knowledge Workspace",
+    "",
+    "## Published pages",
+    "",
+    "No published pages yet.",
+    "",
+    "## Review queue",
+    "",
+    "No pending proposals.",
+    ""
+  ].join("\n");
+}
+function logContent() {
+  return "# Knowledge log\n\n";
+}
+async function initializeKnowledgeWorkspace(input) {
+  if (!input.projectId.trim()) throw new Error("Knowledge workspace project id is required");
+  if (!input.dataDir.trim()) throw new Error("Knowledge workspace data directory is required");
+  let rootPath;
+  let projectRoot;
+  if (input.mode === "local") {
+    rootPath = localWorkspacePath(input.dataDir, input.projectId);
+  } else {
+    if (!input.projectRoot || !input.rootPath) {
+      throw new Error("A versioned knowledge workspace requires projectRoot and rootPath");
+    }
+    projectRoot = path7.resolve(input.projectRoot);
+    rootPath = ensureVersionedPath(projectRoot, input.rootPath);
+    if (await isIgnoredByGit(projectRoot, rootPath)) {
+      throw new Error("The selected versioned knowledge workspace is ignored by Git");
+    }
+  }
+  const paths = getKnowledgeWorkspacePaths({ rootPath });
+  await fs4.mkdir(paths.pages, { recursive: true });
+  await Promise.all([
+    fs4.mkdir(paths.proposals, { recursive: true }),
+    fs4.mkdir(paths.workflows, { recursive: true })
+  ]);
+  if (projectRoot) await assertNoSymlinkEscape(projectRoot, paths.root);
+  const workspace = {
+    id: workspaceId(input.projectId, input.mode),
+    projectId: input.projectId,
+    dataDir: path7.resolve(input.dataDir),
+    mode: input.mode,
+    rootPath: paths.root,
+    ...projectRoot ? { projectRoot } : {},
+    status: "ready",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await withFileLock(paths.root, async () => {
+    await writeIfMissing(paths.schema, schemaContent());
+    await writeIfMissing(paths.index, indexContent());
+    await writeIfMissing(paths.log, logContent());
+  });
+  const store = new KnowledgeWorkspaceStore();
+  await store.init(input.dataDir);
+  return { ...store.upsertWorkspace(workspace), dataDir: workspace.dataDir };
+}
+async function loadKnowledgeWorkspace(input) {
+  const store = new KnowledgeWorkspaceStore();
+  await store.init(input.dataDir);
+  const workspace = store.findWorkspace(input.projectId, input.mode ?? "local");
+  return workspace ? { ...workspace, dataDir: path7.resolve(input.dataDir) } : void 0;
+}
+var execFileAsync;
+var init_workspace = __esm({
+  "src/knowledge/workspace.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_lock();
+    init_workspace_store();
+    execFileAsync = promisify(execFile);
+  }
+});
+
 // src/memory/consolidation.ts
 var consolidation_exports = {};
 __export(consolidation_exports, {
@@ -3174,12 +3999,12 @@ function getImportanceLevel(doc) {
   return TYPE_IMPORTANCE[doc.type] ?? "medium";
 }
 function calculateRelevance(doc, referenceTime) {
-  const now = referenceTime ?? /* @__PURE__ */ new Date();
+  const now3 = referenceTime ?? /* @__PURE__ */ new Date();
   const importance = getImportanceLevel(doc);
   const base = BASE_IMPORTANCE[importance];
   const retention = getEffectiveRetentionDays(doc);
   const createdAt = new Date(doc.createdAt);
-  const ageDays = Math.max(0, (now.getTime() - createdAt.getTime()) / (1e3 * 60 * 60 * 24));
+  const ageDays = Math.max(0, (now3.getTime() - createdAt.getTime()) / (1e3 * 60 * 60 * 24));
   const decayFactor = Math.exp(-ageDays / retention);
   const accessCount = doc.accessCount ?? 0;
   const accessBoost = Math.min(2, 1 + 0.1 * accessCount);
@@ -3202,14 +4027,14 @@ function rankByRelevance(docs, referenceTime) {
   return docs.map((doc) => calculateRelevance(doc, referenceTime)).sort((a, b) => b.totalScore - a.totalScore);
 }
 function getRetentionZone(doc, referenceTime) {
-  const now = referenceTime ?? /* @__PURE__ */ new Date();
+  const now3 = referenceTime ?? /* @__PURE__ */ new Date();
   const importance = getImportanceLevel(doc);
   const retention = getEffectiveRetentionDays(doc);
   const createdAt = new Date(doc.createdAt);
-  const ageDays = (now.getTime() - createdAt.getTime()) / (1e3 * 60 * 60 * 24);
+  const ageDays = (now3.getTime() - createdAt.getTime()) / (1e3 * 60 * 60 * 24);
   if (doc.lastAccessedAt) {
     const lastAccess = new Date(doc.lastAccessedAt);
-    const daysSinceAccess = (now.getTime() - lastAccess.getTime()) / (1e3 * 60 * 60 * 24);
+    const daysSinceAccess = (now3.getTime() - lastAccess.getTime()) / (1e3 * 60 * 60 * 24);
     if (daysSinceAccess < 7) return "active";
   }
   if (isImmune(doc)) return "active";
@@ -3243,10 +4068,10 @@ function explainRetention(doc, referenceTime) {
   const zone = getRetentionZone(doc, referenceTime);
   const immuneFlag = isImmune(doc);
   const immunityReason = getImmunityReason(doc);
-  const now = referenceTime ?? /* @__PURE__ */ new Date();
+  const now3 = referenceTime ?? /* @__PURE__ */ new Date();
   const ageDays = Math.max(
     0,
-    (now.getTime() - new Date(doc.createdAt).getTime()) / (1e3 * 60 * 60 * 24)
+    (now3.getTime() - new Date(doc.createdAt).getTime()) / (1e3 * 60 * 60 * 24)
   );
   const parts = [];
   parts.push(`${importance} importance (${baseRetention}d base)`);
@@ -3402,16 +4227,16 @@ var init_retention = __esm({
 });
 
 // src/codegraph/ids.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 function digest(input) {
-  return createHash("sha256").update(input).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(input).digest("hex").slice(0, 16);
 }
-function normalizeCodePath(path8) {
-  return path8.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
+function normalizeCodePath(path13) {
+  return path13.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/");
 }
-function makeCodeFileId(projectId, path8) {
+function makeCodeFileId(projectId, path13) {
   return `file:${digest(`${projectId}
-${normalizeCodePath(path8)}`)}`;
+${normalizeCodePath(path13)}`)}`;
 }
 function makeCodeSymbolId(input) {
   return `symbol:${digest([
@@ -3424,8 +4249,8 @@ function makeCodeSymbolId(input) {
 function makeCodeEdgeId(projectId, from, type, to) {
   return `edge:${digest([projectId, from, type, to].join("\n"))}`;
 }
-function makeObservationCodeRefId(projectId, observationId, fileId, symbolId) {
-  return `coderef:${digest([projectId, String(observationId), fileId ?? "", symbolId ?? ""].join("\n"))}`;
+function makeObservationCodeRefId(projectId, observationId2, fileId, symbolId) {
+  return `coderef:${digest([projectId, String(observationId2), fileId ?? "", symbolId ?? ""].join("\n"))}`;
 }
 var init_ids = __esm({
   "src/codegraph/ids.ts"() {
@@ -3439,6 +4264,7 @@ var store_exports = {};
 __export(store_exports, {
   CodeGraphStore: () => CodeGraphStore
 });
+import { randomUUID as randomUUID4 } from "crypto";
 function rowToFile(row) {
   return {
     id: row.id,
@@ -3449,7 +4275,9 @@ function rowToFile(row) {
     ...row.mtimeMs != null ? { mtimeMs: row.mtimeMs } : {},
     ...row.sizeBytes != null ? { sizeBytes: row.sizeBytes } : {},
     indexedAt: row.indexedAt,
-    ...row.gitCommit ? { gitCommit: row.gitCommit } : {}
+    ...row.gitCommit ? { gitCommit: row.gitCommit } : {},
+    ...row.snapshotId ? { snapshotId: row.snapshotId } : {},
+    ...row.sourceEpoch != null ? { sourceEpoch: Number(row.sourceEpoch) } : {}
   };
 }
 function rowToSymbol(row) {
@@ -3466,7 +4294,9 @@ function rowToSymbol(row) {
     ...row.signature ? { signature: row.signature } : {},
     ...row.contentHash ? { contentHash: row.contentHash } : {},
     indexedAt: row.indexedAt,
-    stale: !!row.stale
+    stale: !!row.stale,
+    ...row.snapshotId ? { snapshotId: row.snapshotId } : {},
+    ...row.sourceEpoch != null ? { sourceEpoch: Number(row.sourceEpoch) } : {}
   };
 }
 function rowToEdge(row) {
@@ -3480,7 +4310,9 @@ function rowToEdge(row) {
     type: row.type,
     confidence: row.confidence,
     ...row.evidence ? { evidence: row.evidence } : {},
-    indexedAt: row.indexedAt
+    indexedAt: row.indexedAt,
+    ...row.snapshotId ? { snapshotId: row.snapshotId } : {},
+    ...row.sourceEpoch != null ? { sourceEpoch: Number(row.sourceEpoch) } : {}
   };
 }
 function rowToRef(row) {
@@ -3495,7 +4327,52 @@ function rowToRef(row) {
     status: row.status,
     ...row.reason ? { reason: row.reason } : {},
     createdAt: row.createdAt,
-    ...row.updatedAt ? { updatedAt: row.updatedAt } : {}
+    ...row.updatedAt ? { updatedAt: row.updatedAt } : {},
+    ...row.snapshotId ? { snapshotId: row.snapshotId } : {}
+  };
+}
+function parseCompleteness(raw) {
+  try {
+    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("invalid completeness");
+    return {
+      scannedFiles: Number(parsed.scannedFiles) || 0,
+      maxFiles: Number(parsed.maxFiles) || 0,
+      changedFiles: Number(parsed.changedFiles) || 0,
+      unchangedFiles: Number(parsed.unchangedFiles) || 0,
+      metadataOnlyFiles: Number(parsed.metadataOnlyFiles) || 0,
+      removedFiles: Number(parsed.removedFiles) || 0,
+      skippedOversizedFiles: Number(parsed.skippedOversizedFiles) || 0,
+      unreadableFiles: Number(parsed.unreadableFiles) || 0,
+      removalScanDeferred: Boolean(parsed.removalScanDeferred)
+    };
+  } catch {
+    return {
+      scannedFiles: 0,
+      maxFiles: 0,
+      changedFiles: 0,
+      unchangedFiles: 0,
+      metadataOnlyFiles: 0,
+      removedFiles: 0,
+      skippedOversizedFiles: 0,
+      unreadableFiles: 0,
+      removalScanDeferred: false
+    };
+  }
+}
+function rowToSnapshot(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    provider: row.provider,
+    ...row.baseRevision ? { baseRevision: row.baseRevision } : {},
+    worktreeFingerprint: row.worktreeFingerprint,
+    worktreeState: row.worktreeState,
+    changedPathCount: Number(row.changedPathCount),
+    indexedAt: row.indexedAt,
+    sourceEpoch: Number(row.sourceEpoch),
+    completeness: parseCompleteness(row.completenessJson),
+    ...row.previousSnapshotId ? { previousSnapshotId: row.previousSnapshotId } : {}
   };
 }
 var CodeGraphStore;
@@ -3507,9 +4384,16 @@ var init_store = __esm({
     init_ids();
     CodeGraphStore = class {
       db = null;
+      dataDir = null;
       async init(dataDir) {
+        this.dataDir = dataDir;
         this.db = getDatabase(dataDir);
       }
+      /** Data directory shared with the rest of the local project evidence stores. */
+      getDataDir() {
+        if (!this.dataDir) throw new Error("CodeGraphStore is not initialized");
+        return this.dataDir;
+      }
       upsertFiles(files) {
         if (files.length === 0) return;
         const stmt = this.db.prepare(`
@@ -3770,9 +4654,9 @@ var init_store = __esm({
         if (refs.length === 0) return;
         const stmt = this.db.prepare(`
       INSERT OR REPLACE INTO observation_code_refs
-        (id, projectId, observationId, fileId, symbolId, capturedFileHash, capturedSymbolHash, status, reason, createdAt, updatedAt)
+        (id, projectId, observationId, fileId, symbolId, capturedFileHash, capturedSymbolHash, status, reason, createdAt, updatedAt, snapshotId)
       VALUES
-        (@id, @projectId, @observationId, @fileId, @symbolId, @capturedFileHash, @capturedSymbolHash, @status, @reason, @createdAt, @updatedAt)
+        (@id, @projectId, @observationId, @fileId, @symbolId, @capturedFileHash, @capturedSymbolHash, @status, @reason, @createdAt, @updatedAt, @snapshotId)
     `);
         const tx = this.db.transaction((items) => {
           for (const ref of items) {
@@ -3787,25 +4671,26 @@ var init_store = __esm({
               status: ref.status,
               reason: ref.reason ?? null,
               createdAt: ref.createdAt,
-              updatedAt: ref.updatedAt ?? null
+              updatedAt: ref.updatedAt ?? null,
+              snapshotId: ref.snapshotId ?? this.latestSnapshot(ref.projectId)?.id ?? null
             });
           }
         });
         tx(refs);
       }
-      replaceObservationRefs(projectId, observationId, refs) {
+      replaceObservationRefs(projectId, observationId2, refs) {
         const deleteRefs = this.db.prepare(`
       DELETE FROM observation_code_refs
       WHERE projectId = ? AND observationId = ?
     `);
         const insertRef = this.db.prepare(`
       INSERT OR REPLACE INTO observation_code_refs
-        (id, projectId, observationId, fileId, symbolId, capturedFileHash, capturedSymbolHash, status, reason, createdAt, updatedAt)
+        (id, projectId, observationId, fileId, symbolId, capturedFileHash, capturedSymbolHash, status, reason, createdAt, updatedAt, snapshotId)
       VALUES
-        (@id, @projectId, @observationId, @fileId, @symbolId, @capturedFileHash, @capturedSymbolHash, @status, @reason, @createdAt, @updatedAt)
+        (@id, @projectId, @observationId, @fileId, @symbolId, @capturedFileHash, @capturedSymbolHash, @status, @reason, @createdAt, @updatedAt, @snapshotId)
     `);
         const tx = this.db.transaction(() => {
-          deleteRefs.run(projectId, observationId);
+          deleteRefs.run(projectId, observationId2);
           for (const ref of refs) {
             insertRef.run({
               id: ref.id,
@@ -3818,14 +4703,15 @@ var init_store = __esm({
               status: ref.status,
               reason: ref.reason ?? null,
               createdAt: ref.createdAt,
-              updatedAt: ref.updatedAt ?? null
+              updatedAt: ref.updatedAt ?? null,
+              snapshotId: ref.snapshotId ?? this.latestSnapshot(ref.projectId)?.id ?? null
             });
           }
         });
         tx();
       }
-      getFile(projectId, path8) {
-        const row = this.db.prepare(`SELECT * FROM code_files WHERE projectId = ? AND path = ?`).get(projectId, normalizeCodePath(path8));
+      getFile(projectId, path13) {
+        const row = this.db.prepare(`SELECT * FROM code_files WHERE projectId = ? AND path = ?`).get(projectId, normalizeCodePath(path13));
         return row ? rowToFile(row) : null;
       }
       listFiles(projectId) {
@@ -3884,12 +4770,12 @@ var init_store = __esm({
       listEdges(projectId) {
         return this.db.prepare(`SELECT * FROM code_edges WHERE projectId = ? ORDER BY type, id`).all(projectId).map(rowToEdge);
       }
-      listObservationRefs(projectId, observationId) {
+      listObservationRefs(projectId, observationId2) {
         return this.db.prepare(`
       SELECT * FROM observation_code_refs
       WHERE projectId = ? AND observationId = ?
       ORDER BY status, id
-    `).all(projectId, observationId).map(rowToRef);
+    `).all(projectId, observationId2).map(rowToRef);
       }
       listProjectObservationRefs(projectId) {
         return this.db.prepare(`
@@ -3907,18 +4793,152 @@ var init_store = __esm({
       ORDER BY symbols.path, symbols.startLine
     `).all(projectId, projectId).map(rowToSymbol);
       }
+      latestSnapshot(projectId) {
+        const row = this.db.prepare(
+          "SELECT * FROM code_state_snapshots WHERE projectId = ? ORDER BY sourceEpoch DESC LIMIT 1"
+        ).get(projectId);
+        return row ? rowToSnapshot(row) : void 0;
+      }
+      listSnapshots(projectId, limit = 20) {
+        const safeLimit = Number.isFinite(limit) ? Math.max(1, Math.min(200, Math.floor(limit))) : 20;
+        return this.db.prepare(
+          "SELECT * FROM code_state_snapshots WHERE projectId = ? ORDER BY sourceEpoch DESC LIMIT ?"
+        ).all(projectId, safeLimit).map(rowToSnapshot);
+      }
+      /**
+       * Record a completed scan and mark all current structural facts with its
+       * epoch. The snapshot is written only after refresh reconciliation succeeds,
+       * so an interrupted scan cannot be advertised as complete.
+       */
+      recordCodeStateSnapshot(input) {
+        const id = randomUUID4();
+        let snapshot;
+        const tx = this.db.transaction(() => {
+          const previous = this.db.prepare(
+            "SELECT id, sourceEpoch FROM code_state_snapshots WHERE projectId = ? ORDER BY sourceEpoch DESC LIMIT 1"
+          ).get(input.projectId);
+          const sourceEpoch = Number(previous?.sourceEpoch ?? 0) + 1;
+          const previousSnapshotId = previous?.id;
+          this.db.prepare(
+            "INSERT INTO code_state_snapshots (id, projectId, provider, baseRevision, worktreeFingerprint, worktreeState, changedPathCount, indexedAt, sourceEpoch, completenessJson, previousSnapshotId) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+          ).run(
+            id,
+            input.projectId,
+            input.provider,
+            input.baseRevision ?? null,
+            input.worktreeFingerprint,
+            input.worktreeState,
+            input.changedPathCount,
+            input.indexedAt,
+            sourceEpoch,
+            JSON.stringify(input.completeness),
+            previousSnapshotId ?? null
+          );
+          this.db.prepare(
+            "UPDATE code_files SET snapshotId = ?, sourceEpoch = ?, gitCommit = COALESCE(?, gitCommit) WHERE projectId = ?"
+          ).run(id, sourceEpoch, input.baseRevision ?? null, input.projectId);
+          this.db.prepare(
+            "UPDATE code_symbols SET snapshotId = ?, sourceEpoch = ? WHERE projectId = ? AND stale = 0"
+          ).run(id, sourceEpoch, input.projectId);
+          this.db.prepare(
+            "UPDATE code_edges SET snapshotId = ?, sourceEpoch = ? WHERE projectId = ?"
+          ).run(id, sourceEpoch, input.projectId);
+          this.db.prepare(
+            "UPDATE observation_code_refs SET snapshotId = ? WHERE projectId = ? AND status = 'current'"
+          ).run(id, input.projectId);
+          snapshot = {
+            ...input,
+            id,
+            sourceEpoch,
+            ...previousSnapshotId ? { previousSnapshotId } : {}
+          };
+        });
+        tx();
+        return snapshot;
+      }
       status(projectId) {
         const files = this.db.prepare(`SELECT COUNT(*) AS count FROM code_files WHERE projectId = ?`).get(projectId).count;
         const symbols = this.db.prepare(`SELECT COUNT(*) AS count FROM code_symbols WHERE projectId = ? AND stale = 0`).get(projectId).count;
         const edges = this.db.prepare(`SELECT COUNT(*) AS count FROM code_edges WHERE projectId = ?`).get(projectId).count;
         const refs = this.db.prepare(`SELECT COUNT(*) AS count FROM observation_code_refs WHERE projectId = ?`).get(projectId).count;
         const latest = this.db.prepare(`SELECT MAX(indexedAt) AS indexedAt FROM code_files WHERE projectId = ?`).get(projectId);
-        return { provider: "lite", files, symbols, edges, refs, ...latest?.indexedAt ? { indexedAt: latest.indexedAt } : {} };
+        const latestSnapshot = this.latestSnapshot(projectId);
+        return {
+          provider: "lite",
+          files,
+          symbols,
+          edges,
+          refs,
+          ...latest?.indexedAt ? { indexedAt: latest.indexedAt } : {},
+          ...latestSnapshot ? { latestSnapshot } : {}
+        };
       }
     };
   }
 });
 
+// src/codegraph/code-state.ts
+import { execFile as execFile2 } from "child_process";
+import { createHash as createHash3 } from "crypto";
+import { promisify as promisify2 } from "util";
+async function runGit(rootPath, args) {
+  try {
+    const result = await execFileAsync2("git", ["-C", rootPath, ...args], {
+      encoding: "buffer",
+      windowsHide: true,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: GIT_MAX_BUFFER_BYTES
+    });
+    const output = Buffer.isBuffer(result.stdout) ? result.stdout : Buffer.from(result.stdout ?? "");
+    return { ok: true, output };
+  } catch {
+    return { ok: false, output: Buffer.alloc(0) };
+  }
+}
+function changedPathCount(status) {
+  const entries = status.toString("utf8").split("\0");
+  let count2 = 0;
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    if (!entry) continue;
+    count2++;
+    const code = entry.slice(0, 2);
+    if (code.includes("R") || code.includes("C")) index++;
+  }
+  return count2;
+}
+function fingerprint(baseRevision, status) {
+  return createHash3("sha256").update(baseRevision ?? "").update("\0").update(status).digest("hex");
+}
+async function collectCodeStateSnapshot(input) {
+  const [revision, status] = await Promise.all([
+    runGit(input.projectRoot, ["rev-parse", "HEAD"]),
+    runGit(input.projectRoot, ["status", "--porcelain=v1", "-z", "--untracked-files=normal"])
+  ]);
+  const baseRevision = revision.ok ? revision.output.toString("utf8").trim() || void 0 : void 0;
+  const worktreeState = status.ok ? status.output.length > 0 ? "dirty" : "clean" : "unavailable";
+  return {
+    projectId: input.projectId,
+    provider: input.provider,
+    ...baseRevision ? { baseRevision } : {},
+    worktreeFingerprint: fingerprint(baseRevision, status.ok ? status.output : Buffer.alloc(0)),
+    worktreeState,
+    changedPathCount: status.ok ? changedPathCount(status.output) : 0,
+    indexedAt: input.indexedAt,
+    completeness: input.completeness
+  };
+}
+var execFileAsync2, GIT_TIMEOUT_MS, GIT_MAX_BUFFER_BYTES;
+var init_code_state = __esm({
+  "src/codegraph/code-state.ts"() {
+    "use strict";
+    init_esm_shims();
+    execFileAsync2 = promisify2(execFile2);
+    GIT_TIMEOUT_MS = 3e3;
+    GIT_MAX_BUFFER_BYTES = 256 * 1024;
+  }
+});
+
 // src/codegraph/exclude.ts
 function normalizeCodeGraphExcludePatterns(exclude) {
   return [.../* @__PURE__ */ new Set([
@@ -3926,30 +4946,30 @@ function normalizeCodeGraphExcludePatterns(exclude) {
     ...(exclude ?? []).map((pattern) => pattern.trim()).filter(Boolean)
   ])];
 }
-function isCodeGraphExcludedPath(path8, exclude) {
-  const normalized = normalizeCodePath2(path8);
+function isCodeGraphExcludedPath(path13, exclude) {
+  const normalized = normalizeCodePath2(path13);
   return normalizeCodeGraphExcludePatterns(exclude).some((pattern) => matchesPattern(normalized, normalizeCodePath2(pattern)));
 }
-function normalizeCodePath2(path8) {
-  return path8.replace(/\\/g, "/").replace(/^\.\/+/, "");
+function normalizeCodePath2(path13) {
+  return path13.replace(/\\/g, "/").replace(/^\.\/+/, "");
 }
-function matchesPattern(path8, pattern) {
+function matchesPattern(path13, pattern) {
   if (pattern.endsWith("/**")) {
     const base = pattern.slice(0, -3);
     if (base.startsWith("**/")) {
       const suffix = base.slice(3);
-      return path8 === suffix || path8.endsWith(`/${suffix}`) || path8.includes(`/${suffix}/`);
+      return path13 === suffix || path13.endsWith(`/${suffix}`) || path13.includes(`/${suffix}/`);
     }
     if (!base.includes("/")) {
-      return path8 === base || path8.startsWith(`${base}/`) || path8.includes(`/${base}/`);
+      return path13 === base || path13.startsWith(`${base}/`) || path13.includes(`/${base}/`);
     }
-    return path8 === base || path8.startsWith(`${base}/`);
+    return path13 === base || path13.startsWith(`${base}/`);
   }
   if (pattern.startsWith("**/")) {
     const suffix = pattern.slice(3);
-    return path8 === suffix || path8.endsWith(`/${suffix}`);
+    return path13 === suffix || path13.endsWith(`/${suffix}`);
   }
-  return path8 === pattern || path8.startsWith(`${pattern}/`);
+  return path13 === pattern || path13.startsWith(`${pattern}/`);
 }
 var DEFAULT_CODEGRAPH_EXCLUDES;
 var init_exclude = __esm({
@@ -3988,18 +5008,18 @@ __export(lite_provider_exports, {
   indexProjectLite: () => indexProjectLite,
   refreshProjectLite: () => refreshProjectLite
 });
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { readdirSync as readdirSync2, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
 import { join as join2, relative } from "path";
 function hashText(text) {
-  return createHash2("sha256").update(text).digest("hex");
+  return createHash4("sha256").update(text).digest("hex");
 }
-function extension(path8) {
-  const index = path8.lastIndexOf(".");
-  return index === -1 ? "" : path8.slice(index);
+function extension(path13) {
+  const index = path13.lastIndexOf(".");
+  return index === -1 ? "" : path13.slice(index);
 }
-function languageForPath(path8) {
-  const ext = extension(path8);
+function languageForPath(path13) {
+  const ext = extension(path13);
   return LANGUAGE_BY_EXTENSION.get(ext) ?? "unknown";
 }
 function resolveMaxFileBytes(value) {
@@ -4117,17 +5137,22 @@ function indexFileLite(projectId, projectRoot, abs, indexedAt, fileStat) {
       path: rel,
       language: languageForPath(rel),
       contentHash: hashText(text),
-      mtimeMs: Math.round(Number(stat.mtimeMs)),
+      // Preserve filesystem precision. Rounding here made same-size edits in
+      // a short Windows timestamp window indistinguishable to refresh.
+      mtimeMs: Number(stat.mtimeMs),
       sizeBytes: Number(stat.size),
       indexedAt
     };
     return {
-      file,
-      symbols: extractSymbols(projectId, file, text, indexedAt),
-      edges: extractImportEdges(projectId, file, text, indexedAt)
+      delta: {
+        file,
+        symbols: extractSymbols(projectId, file, text, indexedAt),
+        edges: extractImportEdges(projectId, file, text, indexedAt)
+      },
+      unreadable: false
     };
   } catch {
-    return void 0;
+    return { unreadable: true };
   }
 }
 async function indexProjectLite(options) {
@@ -4140,24 +5165,29 @@ async function indexProjectLite(options) {
   const symbols = [];
   const edges = [];
   let skippedOversizedFiles = 0;
+  let unreadableFiles = 0;
   for (const abs of paths) {
     let stat;
     try {
       stat = statSync2(abs);
     } catch {
+      unreadableFiles++;
       continue;
     }
     if (Number(stat.size) > maxFileBytes) {
       skippedOversizedFiles++;
       continue;
     }
-    const delta = indexFileLite(options.projectId, options.projectRoot, abs, indexedAt, stat);
-    if (!delta) continue;
-    files.push(delta.file);
-    symbols.push(...delta.symbols);
-    edges.push(...delta.edges);
+    const attempt = indexFileLite(options.projectId, options.projectRoot, abs, indexedAt, stat);
+    if (!attempt.delta) {
+      if (attempt.unreadable) unreadableFiles++;
+      continue;
+    }
+    files.push(attempt.delta.file);
+    symbols.push(...attempt.delta.symbols);
+    edges.push(...attempt.delta.edges);
   }
-  return { files, symbols, edges, skippedOversizedFiles };
+  return { files, symbols, edges, skippedOversizedFiles, unreadableFiles };
 }
 async function refreshProjectLite(store, options) {
   const exclude = normalizeCodeGraphExcludePatterns(options.exclude);
@@ -4172,29 +5202,35 @@ async function refreshProjectLite(store, options) {
   const oversizedExistingFileIds = /* @__PURE__ */ new Set();
   let unchangedFiles = 0;
   let skippedOversizedFiles = 0;
+  let unreadableFiles = 0;
   for (const abs of paths) {
     const rel = normalizeCodePath(relative(options.projectRoot, abs));
+    seenPaths.add(rel);
     let stat;
     try {
       stat = statSync2(abs);
     } catch {
+      unreadableFiles++;
       continue;
     }
-    seenPaths.add(rel);
     const existing = existingByPath.get(rel);
-    const roundedMtime = Math.round(Number(stat.mtimeMs));
+    const mtimeMs = Number(stat.mtimeMs);
     const sizeBytes = Number(stat.size);
     if (sizeBytes > maxFileBytes) {
       skippedOversizedFiles++;
       if (existing) oversizedExistingFileIds.add(existing.id);
       continue;
     }
-    if (existing && existing.mtimeMs === roundedMtime && existing.sizeBytes === sizeBytes) {
+    if (existing && existing.mtimeMs === mtimeMs && existing.sizeBytes === sizeBytes) {
       unchangedFiles++;
       continue;
     }
-    const delta = indexFileLite(options.projectId, options.projectRoot, abs, indexedAt, stat);
-    if (!delta) continue;
+    const attempt = indexFileLite(options.projectId, options.projectRoot, abs, indexedAt, stat);
+    if (!attempt.delta) {
+      if (attempt.unreadable) unreadableFiles++;
+      continue;
+    }
+    const delta = attempt.delta;
     if (existing?.contentHash === delta.file.contentHash) {
       metadataOnly.push(delta.file);
       unchangedFiles++;
@@ -4212,23 +5248,44 @@ async function refreshProjectLite(store, options) {
     metadataOnly,
     removedFileIds
   });
-  return {
+  const completeness = {
     scannedFiles: paths.length,
+    maxFiles,
     changedFiles: changed.length,
     unchangedFiles,
     metadataOnlyFiles: metadataOnly.length,
     removedFiles: removedFileIds.length,
-    indexedSymbols: changed.reduce((total, delta) => total + delta.symbols.length, 0),
-    indexedEdges: changed.reduce((total, delta) => total + delta.edges.length, 0),
     skippedOversizedFiles,
+    unreadableFiles,
     removalScanDeferred
   };
-}
-var DEFAULT_CODEGRAPH_MAX_FILE_BYTES, LANGUAGE_BY_EXTENSION, SUPPORTED_EXTENSIONS, identifier, languageProfiles;
-var init_lite_provider = __esm({
+  const snapshot = store.recordCodeStateSnapshot(await collectCodeStateSnapshot({
+    projectId: options.projectId,
+    projectRoot: options.projectRoot,
+    provider: "lite",
+    indexedAt,
+    completeness
+  }));
+  return {
+    scannedFiles: paths.length,
+    changedFiles: changed.length,
+    unchangedFiles,
+    metadataOnlyFiles: metadataOnly.length,
+    removedFiles: removedFileIds.length,
+    indexedSymbols: changed.reduce((total, delta) => total + delta.symbols.length, 0),
+    indexedEdges: changed.reduce((total, delta) => total + delta.edges.length, 0),
+    skippedOversizedFiles,
+    unreadableFiles,
+    removalScanDeferred,
+    snapshot
+  };
+}
+var DEFAULT_CODEGRAPH_MAX_FILE_BYTES, LANGUAGE_BY_EXTENSION, SUPPORTED_EXTENSIONS, identifier, languageProfiles;
+var init_lite_provider = __esm({
   "src/codegraph/lite-provider.ts"() {
     "use strict";
     init_esm_shims();
+    init_code_state();
     init_ids();
     init_exclude();
     DEFAULT_CODEGRAPH_MAX_FILE_BYTES = 2 * 1024 * 1024;
@@ -4382,138 +5439,2274 @@ function codeIdentifierCandidates(text) {
   for (const match of text.matchAll(/\b([A-Za-z_$][\w$]*(?:::[A-Za-z_$][\w$]*)*[!?=]?)\s*\(/g)) explicit.add(match[1]);
   return identifierCandidates(text).filter((candidate) => explicit.has(candidate) || candidate.includes("::") || /[!?=]$/.test(candidate) || /^[A-Z]/.test(candidate) || /[_$]/.test(candidate) || /[a-z0-9][A-Z]/.test(candidate) || /[A-Z]{2}/.test(candidate));
 }
-function fileRef(projectId, obs, file) {
+function fileRef(projectId, obs, file) {
+  return {
+    id: makeObservationCodeRefId(projectId, obs.id, file.id),
+    projectId,
+    observationId: obs.id,
+    fileId: file.id,
+    capturedFileHash: file.contentHash,
+    status: "current",
+    reason: "bound by file path",
+    createdAt: obs.createdAt
+  };
+}
+function symbolRef(projectId, obs, file, symbol) {
+  return {
+    id: makeObservationCodeRefId(projectId, obs.id, file.id, symbol.id),
+    projectId,
+    observationId: obs.id,
+    fileId: file.id,
+    symbolId: symbol.id,
+    capturedFileHash: file.contentHash,
+    ...symbol.contentHash ? { capturedSymbolHash: symbol.contentHash } : {},
+    status: "current",
+    reason: "bound by symbol mention",
+    createdAt: obs.createdAt
+  };
+}
+function resolveObservationCodeRefs(obs, lookup) {
+  const refs = /* @__PURE__ */ new Map();
+  const text = observationText(obs);
+  const candidateFiles = /* @__PURE__ */ new Map();
+  for (const rawPath of obs.filesModified ?? []) {
+    const file = lookup.findFile(normalizeCodePath(rawPath));
+    if (!file) continue;
+    candidateFiles.set(file.id, file);
+    const ref = fileRef(obs.projectId, obs, file);
+    refs.set(ref.id, ref);
+  }
+  const hintedFileIds = new Set(candidateFiles.keys());
+  const symbolNames = hintedFileIds.size > 0 ? identifierCandidates(text) : codeIdentifierCandidates(text);
+  const symbols = lookup.findSymbols(symbolNames, [...hintedFileIds]);
+  const symbolsByName = /* @__PURE__ */ new Map();
+  for (const symbol of symbols) {
+    const group = symbolsByName.get(symbol.name) ?? [];
+    group.push(symbol);
+    symbolsByName.set(symbol.name, group);
+  }
+  for (const group of symbolsByName.values()) {
+    const candidates = group.length === 1 ? group : [];
+    for (const symbol of candidates) {
+      if (!mentionsSymbol(text, symbol)) continue;
+      const file = candidateFiles.get(symbol.fileId) ?? lookup.findFile(symbol.path);
+      if (!file) continue;
+      candidateFiles.set(file.id, file);
+      const ref = symbolRef(obs.projectId, obs, file, symbol);
+      refs.set(ref.id, ref);
+    }
+  }
+  return [...refs.values()];
+}
+function createStoreLookup(store, projectId) {
+  return {
+    findFile: (path13) => store.getFile(projectId, path13) ?? void 0,
+    findSymbols: (names, hintedFileIds) => store.findSymbolsByNames(projectId, names, hintedFileIds)
+  };
+}
+function createSnapshotLookup(files, symbols) {
+  const filesByPath = new Map(files.map((file) => [normalizeCodePath(file.path), file]));
+  const symbolsByName = /* @__PURE__ */ new Map();
+  for (const symbol of symbols) {
+    const group = symbolsByName.get(symbol.name) ?? [];
+    group.push(symbol);
+    symbolsByName.set(symbol.name, group);
+  }
+  return {
+    findFile: (path13) => filesByPath.get(normalizeCodePath(path13)),
+    findSymbols: (names, hintedFileIds) => {
+      const hinted = new Set(hintedFileIds);
+      const found = [];
+      for (const name of names) {
+        const candidates = symbolsByName.get(name) ?? [];
+        found.push(...hinted.size > 0 ? candidates.filter((symbol) => hinted.has(symbol.fileId)) : candidates);
+      }
+      return found;
+    }
+  };
+}
+async function bindObservationToCode(store, obs) {
+  const refs = resolveObservationCodeRefs(obs, createStoreLookup(store, obs.projectId));
+  store.replaceObservationRefs(obs.projectId, obs.id, refs);
+  return refs;
+}
+async function backfillMissingObservationCodeRefs(store, observations2) {
+  let observationsBackfilled = 0;
+  let refsBackfilled = 0;
+  const boundObservationIdsByProject = /* @__PURE__ */ new Map();
+  const lookupByProject = /* @__PURE__ */ new Map();
+  for (const projectId of new Set(observations2.map((observation) => observation.projectId))) {
+    boundObservationIdsByProject.set(
+      projectId,
+      new Set(store.listProjectObservationRefs(projectId).map((ref) => ref.observationId))
+    );
+    lookupByProject.set(
+      projectId,
+      createSnapshotLookup(store.listFiles(projectId), store.listSymbols(projectId))
+    );
+  }
+  const refsToInsert = [];
+  for (const observation of observations2) {
+    if (boundObservationIdsByProject.get(observation.projectId)?.has(observation.id)) continue;
+    if ((observation.filesModified?.length ?? 0) === 0 && codeIdentifierCandidates(observationText(observation)).length === 0) {
+      continue;
+    }
+    const lookup = lookupByProject.get(observation.projectId);
+    if (!lookup) continue;
+    const refs = resolveObservationCodeRefs(observation, lookup);
+    if (refs.length === 0) continue;
+    observationsBackfilled += 1;
+    refsBackfilled += refs.length;
+    refsToInsert.push(...refs);
+  }
+  store.upsertObservationRefs(refsToInsert);
+  return {
+    observationsScanned: observations2.length,
+    observationsBackfilled,
+    refsBackfilled
+  };
+}
+var init_binder = __esm({
+  "src/codegraph/binder.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_ids();
+  }
+});
+
+// src/knowledge/claim-store.ts
+var claim_store_exports = {};
+__export(claim_store_exports, {
+  ClaimStore: () => ClaimStore
+});
+import { createHash as createHash5, randomUUID as randomUUID5 } from "crypto";
+function optionalText2(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+function rowToClaim(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    subject: row.subject,
+    predicate: row.predicate,
+    objectValue: row.objectValue,
+    scope: row.scope,
+    claimKey: row.claimKey,
+    conflictKey: row.conflictKey,
+    status: row.status,
+    confidence: Number(row.confidence),
+    observedAt: row.observedAt,
+    ...optionalText2(row.validFrom) ? { validFrom: row.validFrom } : {},
+    ...optionalText2(row.validTo) ? { validTo: row.validTo } : {},
+    ...optionalText2(row.supersededBy) ? { supersededBy: row.supersededBy } : {},
+    reviewState: row.reviewState,
+    origin: row.origin,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+function rowToEvidence(row) {
+  return {
+    id: row.id,
+    claimId: row.claimId,
+    evidenceKind: row.evidenceKind,
+    evidenceId: row.evidenceId,
+    relation: row.relation,
+    ...optionalText2(row.snapshotId) ? { snapshotId: row.snapshotId } : {},
+    ...optionalText2(row.locator) ? { locator: row.locator } : {},
+    ...optionalText2(row.capturedHash) ? { capturedHash: row.capturedHash } : {},
+    createdAt: row.createdAt
+  };
+}
+function rowToEvent(row) {
+  return {
+    id: row.id,
+    projectId: row.projectId,
+    claimId: row.claimId,
+    kind: row.kind,
+    ...optionalText2(row.fromStatus) ? { fromStatus: row.fromStatus } : {},
+    ...optionalText2(row.toStatus) ? { toStatus: row.toStatus } : {},
+    ...optionalText2(row.relatedClaimId) ? { relatedClaimId: row.relatedClaimId } : {},
+    ...optionalText2(row.detail) ? { detail: row.detail } : {},
+    createdAt: row.createdAt
+  };
+}
+function evidenceKey(input) {
+  return createHash5("sha256").update(JSON.stringify([
+    input.evidenceKind,
+    input.evidenceId,
+    input.relation,
+    input.snapshotId ?? "",
+    input.locator ?? "",
+    input.capturedHash ?? ""
+  ])).digest("hex");
+}
+var ClaimStore;
+var init_claim_store = __esm({
+  "src/knowledge/claim-store.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_secret_filter();
+    init_sqlite_db();
+    ClaimStore = class {
+      db = null;
+      async init(dataDir) {
+        this.db = getDatabase(dataDir);
+      }
+      transaction(fn) {
+        return this.db.transaction(fn)();
+      }
+      getClaim(id) {
+        const row = this.db.prepare("SELECT * FROM knowledge_claims WHERE id = ?").get(id);
+        return row ? rowToClaim(row) : void 0;
+      }
+      listClaims(projectId, options = {}) {
+        const limit = Math.max(1, Math.min(1e3, Math.floor(options.limit ?? 500)));
+        if (options.statuses && options.statuses.length > 0) {
+          return this.db.prepare(`
+        SELECT * FROM knowledge_claims
+        WHERE projectId = ? AND status IN (SELECT value FROM json_each(?))
+        ORDER BY updatedAt DESC, id
+        LIMIT ?
+      `).all(projectId, JSON.stringify([...new Set(options.statuses)]), limit).map(rowToClaim);
+        }
+        return this.db.prepare(`
+      SELECT * FROM knowledge_claims
+      WHERE projectId = ?
+      ORDER BY updatedAt DESC, id
+      LIMIT ?
+    `).all(projectId, limit).map(rowToClaim);
+      }
+      findReusableClaim(projectId, claimKey) {
+        const row = this.db.prepare(`
+      SELECT * FROM knowledge_claims
+      WHERE projectId = ? AND claimKey = ? AND status IN ('active', 'disputed')
+      ORDER BY updatedAt DESC
+      LIMIT 1
+    `).get(projectId, claimKey);
+        return row ? rowToClaim(row) : void 0;
+      }
+      listClaimsByConflictKey(projectId, conflictKey) {
+        return this.db.prepare(`
+      SELECT * FROM knowledge_claims
+      WHERE projectId = ? AND conflictKey = ?
+      ORDER BY createdAt ASC, id
+    `).all(projectId, conflictKey).map(rowToClaim);
+      }
+      listConflicts(projectId) {
+        const rows = this.db.prepare(`
+      SELECT conflictKey
+      FROM knowledge_claims
+      WHERE projectId = ? AND status IN ('active', 'disputed') AND reviewState = 'approved'
+      GROUP BY conflictKey
+      HAVING COUNT(DISTINCT claimKey) > 1
+      ORDER BY conflictKey
+    `).all(projectId);
+        return rows.map(({ conflictKey }) => ({
+          conflictKey,
+          claims: this.listClaimsByConflictKey(projectId, conflictKey).filter((claim) => claim.status === "active" || claim.status === "disputed")
+        }));
+      }
+      insertClaim(claim) {
+        this.db.prepare(`
+      INSERT INTO knowledge_claims (
+        id, projectId, subject, predicate, objectValue, scope, claimKey, conflictKey,
+        status, confidence, observedAt, validFrom, validTo, supersededBy,
+        reviewState, origin, createdAt, updatedAt
+      ) VALUES (
+        @id, @projectId, @subject, @predicate, @objectValue, @scope, @claimKey, @conflictKey,
+        @status, @confidence, @observedAt, @validFrom, @validTo, @supersededBy,
+        @reviewState, @origin, @createdAt, @updatedAt
+      )
+    `).run({
+          ...claim,
+          validFrom: claim.validFrom ?? null,
+          validTo: claim.validTo ?? null,
+          supersededBy: claim.supersededBy ?? null
+        });
+      }
+      updateClaim(claim) {
+        this.db.prepare(`
+      UPDATE knowledge_claims SET
+        subject = @subject,
+        predicate = @predicate,
+        objectValue = @objectValue,
+        scope = @scope,
+        claimKey = @claimKey,
+        conflictKey = @conflictKey,
+        status = @status,
+        confidence = @confidence,
+        observedAt = @observedAt,
+        validFrom = @validFrom,
+        validTo = @validTo,
+        supersededBy = @supersededBy,
+        reviewState = @reviewState,
+        origin = @origin,
+        updatedAt = @updatedAt
+      WHERE id = @id
+    `).run({
+          ...claim,
+          validFrom: claim.validFrom ?? null,
+          validTo: claim.validTo ?? null,
+          supersededBy: claim.supersededBy ?? null
+        });
+      }
+      touchClaim(id, updatedAt) {
+        this.db.prepare("UPDATE knowledge_claims SET updatedAt = ? WHERE id = ?").run(updatedAt, id);
+      }
+      insertEvidence(input) {
+        const createdAt = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+        const key = evidenceKey(input);
+        const result = this.db.prepare(`
+      INSERT OR IGNORE INTO knowledge_claim_evidence (
+        id, claimId, evidenceKind, evidenceId, relation, snapshotId,
+        locator, capturedHash, evidenceKey, createdAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          randomUUID5(),
+          input.claimId,
+          input.evidenceKind,
+          input.evidenceId,
+          input.relation,
+          input.snapshotId ?? null,
+          input.locator ? sanitizeCredentials(input.locator) : null,
+          input.capturedHash ?? null,
+          key,
+          createdAt
+        );
+        return Number(result.changes ?? 0) > 0;
+      }
+      listEvidence(claimId) {
+        return this.db.prepare(`
+      SELECT * FROM knowledge_claim_evidence
+      WHERE claimId = ?
+      ORDER BY createdAt ASC, id
+    `).all(claimId).map(rowToEvidence);
+      }
+      recordEvent(input) {
+        const event = {
+          id: randomUUID5(),
+          ...input,
+          ...input.detail ? { detail: sanitizeCredentials(input.detail) } : {},
+          createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.db.prepare(`
+      INSERT INTO knowledge_claim_events (
+        id, projectId, claimId, kind, fromStatus, toStatus,
+        relatedClaimId, detail, createdAt
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+          event.id,
+          event.projectId,
+          event.claimId,
+          event.kind,
+          event.fromStatus ?? null,
+          event.toStatus ?? null,
+          event.relatedClaimId ?? null,
+          event.detail ?? null,
+          event.createdAt
+        );
+        return event;
+      }
+      listEvents(claimId) {
+        return this.db.prepare(`
+      SELECT * FROM knowledge_claim_events
+      WHERE claimId = ?
+      ORDER BY createdAt ASC, id
+    `).all(claimId).map(rowToEvent);
+      }
+    };
+  }
+});
+
+// src/compact/token-budget.ts
+import { countTokens, isWithinTokenLimit } from "gpt-tokenizer";
+function countTextTokens(text) {
+  return countTokens(text);
+}
+var init_token_budget = __esm({
+  "src/compact/token-budget.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/knowledge/claims.ts
+var claims_exports = {};
+__export(claims_exports, {
+  buildClaimIdentity: () => buildClaimIdentity,
+  deriveLowRiskClaimsFromObservation: () => deriveLowRiskClaimsFromObservation,
+  requalifyClaimsForCodeState: () => requalifyClaimsForCodeState,
+  selectClaimsForTask: () => selectClaimsForTask,
+  supersedeClaim: () => supersedeClaim,
+  writeClaim: () => writeClaim
+});
+import { createHash as createHash6, randomUUID as randomUUID6 } from "crypto";
+function compactText(value, field) {
+  if (typeof value !== "string") throw new Error("Claim " + field + " must be text");
+  const sanitized = sanitizeCredentials(value).trim().replace(/\s+/g, " ");
+  if (!sanitized) throw new Error("Claim " + field + " is required");
+  if (sanitized.length > MAX_TERM_LENGTH) throw new Error("Claim " + field + " is too long");
+  return sanitized;
+}
+function normalizedTerm(value) {
+  return compactText(value, "identity").toLocaleLowerCase("en-US");
+}
+function hashIdentity(parts) {
+  return createHash6("sha256").update(parts.join(String.fromCharCode(31))).digest("hex");
+}
+function buildClaimIdentity(input) {
+  const subject = normalizedTerm(input.subject);
+  const predicate = normalizedTerm(input.predicate);
+  const objectValue = normalizedTerm(input.objectValue);
+  return {
+    claimKey: hashIdentity([subject, predicate, objectValue, input.scope]),
+    conflictKey: hashIdentity([subject, predicate, input.scope])
+  };
+}
+function clampConfidence(value) {
+  if (value === void 0) return 0.7;
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new Error("Claim confidence must be a number between 0 and 1");
+  }
+  return value;
+}
+function validateEvidence(input) {
+  if (!Array.isArray(input) || input.length === 0) {
+    throw new Error("A knowledge claim requires at least one evidence reference");
+  }
+  return input.map((evidence) => {
+    if (!evidence || typeof evidence !== "object") {
+      throw new Error("Claim evidence must be an object");
+    }
+    const evidenceId = compactText(evidence.evidenceId, "evidence id");
+    if (evidenceId.length > MAX_EVIDENCE_ID_LENGTH) {
+      throw new Error("Claim evidence id is too long");
+    }
+    if (!["observation", "git", "code", "test", "document", "workflow", "run"].includes(evidence.evidenceKind)) {
+      throw new Error("Claim evidence kind is invalid");
+    }
+    if (!["supports", "contradicts", "derives", "verifies"].includes(evidence.relation)) {
+      throw new Error("Claim evidence relation is invalid");
+    }
+    return {
+      evidenceKind: evidence.evidenceKind,
+      evidenceId,
+      relation: evidence.relation,
+      ...evidence.snapshotId ? { snapshotId: compactText(evidence.snapshotId, "evidence snapshot id") } : {},
+      ...evidence.locator ? { locator: compactText(evidence.locator, "evidence locator") } : {},
+      ...evidence.capturedHash ? { capturedHash: compactText(evidence.capturedHash, "evidence hash") } : {}
+    };
+  });
+}
+function normalizeClaimInput(input) {
+  if (!["project", "workspace", "team", "workflow", "task"].includes(input.scope)) {
+    throw new Error("Claim scope is invalid");
+  }
+  const projectId = compactText(input.projectId, "project id");
+  const subject = compactText(input.subject, "subject");
+  const predicate = compactText(input.predicate, "predicate");
+  const objectValue = compactText(input.objectValue, "object value");
+  const identity = buildClaimIdentity({ subject, predicate, objectValue, scope: input.scope });
+  const origin = input.origin ?? "explicit";
+  let reviewState = input.reviewState ?? "approved";
+  let status = input.status ?? "active";
+  if (origin === "model") {
+    if (input.reviewState === "approved" || input.status === "active") {
+      throw new Error("A model-origin claim cannot be approved or active without explicit review");
+    }
+    reviewState = input.reviewState ?? "draft";
+    status = input.status ?? "unknown";
+  }
+  if (!["approved", "needs-review", "draft", "rejected"].includes(reviewState)) {
+    throw new Error("Claim review state is invalid");
+  }
+  if (!["active", "superseded", "disputed", "unknown"].includes(status)) {
+    throw new Error("Claim status is invalid");
+  }
+  const now3 = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    claim: {
+      id: randomUUID6(),
+      projectId,
+      subject,
+      predicate,
+      objectValue,
+      scope: input.scope,
+      claimKey: identity.claimKey,
+      conflictKey: identity.conflictKey,
+      status,
+      confidence: clampConfidence(input.confidence),
+      observedAt: input.observedAt ?? now3,
+      ...input.validFrom ? { validFrom: input.validFrom } : {},
+      ...input.validTo ? { validTo: input.validTo } : {},
+      reviewState,
+      origin,
+      createdAt: now3,
+      updatedAt: now3
+    },
+    evidence: validateEvidence(input.evidence)
+  };
+}
+function activeConflictClaims(store, projectId, conflictKey) {
+  return store.listClaimsByConflictKey(projectId, conflictKey).filter((claim) => (claim.status === "active" || claim.status === "disputed") && claim.reviewState === "approved");
+}
+function reconcileConflicts(store, projectId, conflictKey, now3) {
+  const claims = activeConflictClaims(store, projectId, conflictKey);
+  const hasConflict = new Set(claims.map((claim) => claim.claimKey)).size > 1;
+  for (const claim of claims) {
+    const nextStatus = hasConflict ? "disputed" : "active";
+    if (claim.status === nextStatus) continue;
+    store.updateClaim({ ...claim, status: nextStatus, updatedAt: now3 });
+    store.recordEvent({
+      projectId,
+      claimId: claim.id,
+      kind: hasConflict ? "conflicted" : "requalified",
+      fromStatus: claim.status,
+      toStatus: nextStatus,
+      detail: hasConflict ? "A different approved assertion has the same subject, predicate, and scope." : "No remaining approved competing assertion exists.",
+      createdAt: now3
+    });
+  }
+  return store.listConflicts(projectId).filter((conflict) => conflict.conflictKey === conflictKey);
+}
+function persistEvidence(store, claim, evidence, now3) {
+  let added = false;
+  for (const item of evidence) {
+    added = store.insertEvidence({ claimId: claim.id, ...item, createdAt: now3 }) || added;
+  }
+  if (added) {
+    store.touchClaim(claim.id, now3);
+    store.recordEvent({
+      projectId: claim.projectId,
+      claimId: claim.id,
+      kind: "evidence-added",
+      detail: "Additional source evidence was attached.",
+      createdAt: now3
+    });
+  }
+}
+function writeClaim(store, input) {
+  const normalized = normalizeClaimInput(input);
+  return store.transaction(() => {
+    const existing = store.findReusableClaim(normalized.claim.projectId, normalized.claim.claimKey);
+    if (existing) {
+      persistEvidence(store, existing, normalized.evidence, normalized.claim.updatedAt);
+      return {
+        claim: store.getClaim(existing.id) ?? existing,
+        created: false,
+        conflicts: store.listConflicts(existing.projectId).filter((conflict) => conflict.conflictKey === existing.conflictKey)
+      };
+    }
+    store.insertClaim(normalized.claim);
+    for (const evidence of normalized.evidence) {
+      store.insertEvidence({ claimId: normalized.claim.id, ...evidence, createdAt: normalized.claim.createdAt });
+    }
+    store.recordEvent({
+      projectId: normalized.claim.projectId,
+      claimId: normalized.claim.id,
+      kind: "created",
+      toStatus: normalized.claim.status,
+      detail: "Claim created with source evidence.",
+      createdAt: normalized.claim.createdAt
+    });
+    const conflicts = reconcileConflicts(
+      store,
+      normalized.claim.projectId,
+      normalized.claim.conflictKey,
+      normalized.claim.updatedAt
+    );
+    return {
+      claim: store.getClaim(normalized.claim.id) ?? normalized.claim,
+      created: true,
+      conflicts
+    };
+  });
+}
+function supersedeClaim(store, input) {
+  const evidence = validateEvidence(input.evidence);
+  return store.transaction(() => {
+    const claim = store.getClaim(input.claimId);
+    const replacement = store.getClaim(input.replacementClaimId);
+    if (!claim || !replacement) throw new Error("Both claims must exist before supersession");
+    if (claim.projectId !== replacement.projectId || claim.conflictKey !== replacement.conflictKey) {
+      throw new Error("A replacement claim must address the same project assertion");
+    }
+    if (claim.id === replacement.id) throw new Error("A claim cannot supersede itself");
+    const now3 = (/* @__PURE__ */ new Date()).toISOString();
+    persistEvidence(store, claim, evidence, now3);
+    const updated = {
+      ...claim,
+      status: "superseded",
+      validTo: now3,
+      supersededBy: replacement.id,
+      updatedAt: now3
+    };
+    store.updateClaim(updated);
+    store.recordEvent({
+      projectId: claim.projectId,
+      claimId: claim.id,
+      kind: "superseded",
+      fromStatus: claim.status,
+      toStatus: "superseded",
+      relatedClaimId: replacement.id,
+      detail: "Superseded by an evidence-backed replacement claim.",
+      createdAt: now3
+    });
+    reconcileConflicts(store, claim.projectId, claim.conflictKey, now3);
+    return {
+      superseded: store.getClaim(claim.id) ?? updated,
+      replacement: store.getClaim(replacement.id) ?? replacement
+    };
+  });
+}
+function hashObservation(observation) {
+  return createHash6("sha256").update(JSON.stringify([
+    observation.title,
+    observation.narrative,
+    observation.facts,
+    observation.filesModified,
+    observation.updatedAt ?? observation.createdAt
+  ])).digest("hex");
+}
+function evidenceFromCodeRef(ref) {
+  return {
+    evidenceKind: "code",
+    evidenceId: "code-ref:" + ref.id,
+    relation: "supports",
+    ...ref.snapshotId ? { snapshotId: ref.snapshotId } : {},
+    locator: "code-ref/" + ref.id,
+    ...ref.capturedSymbolHash || ref.capturedFileHash ? { capturedHash: ref.capturedSymbolHash ?? ref.capturedFileHash } : {}
+  };
+}
+function deriveLowRiskClaimsFromObservation(store, observation, codeStore) {
+  const predicate = PREDICATE_BY_OBSERVATION_TYPE[observation.type];
+  const isExplicit = observation.sourceDetail === "explicit";
+  const isGit = observation.source === "git" || observation.sourceDetail === "git-ingest";
+  if (!predicate || observation.status !== "active" || !isExplicit && !isGit) return [];
+  const evidence = [{
+    evidenceKind: "observation",
+    evidenceId: "observation:" + observation.id,
+    relation: "supports",
+    locator: "observation/" + observation.id,
+    capturedHash: hashObservation(observation)
+  }];
+  if (observation.commitHash) {
+    evidence.push({
+      evidenceKind: "git",
+      evidenceId: "git:" + observation.commitHash,
+      relation: "verifies",
+      locator: "git:" + observation.commitHash,
+      capturedHash: observation.commitHash
+    });
+  }
+  const refs = codeStore?.listObservationRefs(observation.projectId, observation.id) ?? [];
+  for (const ref of refs) evidence.push(evidenceFromCodeRef(ref));
+  const confidence = Math.min(0.9, (isGit ? 0.75 : 0.7) + refs.filter((ref) => ref.status === "current").length * 0.05);
+  const result = writeClaim(store, {
+    projectId: observation.projectId,
+    subject: observation.entityName,
+    predicate,
+    objectValue: observation.title,
+    scope: "project",
+    confidence,
+    observedAt: observation.updatedAt ?? observation.createdAt,
+    reviewState: "approved",
+    origin: isGit ? "git" : "derived",
+    evidence
+  });
+  return [result.claim];
+}
+function incompleteSnapshot(snapshot) {
+  if (!snapshot) return false;
+  return snapshot.completeness.skippedOversizedFiles > 0 || (snapshot.completeness.unreadableFiles ?? 0) > 0 || snapshot.completeness.removalScanDeferred;
+}
+function requalification(claim, refs, evidence, snapshot) {
+  if (claim.status === "superseded" || claim.reviewState === "draft" || claim.reviewState === "rejected") return void 0;
+  const codeEvidence = evidence.filter((item) => item.evidenceKind === "code");
+  if (codeEvidence.length === 0) return void 0;
+  const linkedRefs = codeEvidence.map((item) => refs.get(item.evidenceId.replace(/^code-ref:/, ""))).filter((ref) => !!ref);
+  const missingOrStale = linkedRefs.length !== codeEvidence.length || linkedRefs.some((ref) => ref.status === "stale");
+  if (missingOrStale) {
+    return {
+      status: "unknown",
+      confidence: Math.min(claim.confidence, 0.2),
+      reviewState: "needs-review",
+      reason: "Bound code evidence is no longer current."
+    };
+  }
+  if (linkedRefs.some((ref) => ref.status === "suspect")) {
+    return {
+      status: claim.status === "disputed" ? "disputed" : "active",
+      confidence: Math.min(claim.confidence, 0.5),
+      reviewState: "needs-review",
+      reason: "Bound file evidence changed and needs review."
+    };
+  }
+  if (incompleteSnapshot(snapshot)) {
+    return {
+      status: claim.status === "disputed" ? "disputed" : "active",
+      confidence: Math.min(claim.confidence, 0.55),
+      reviewState: "needs-review",
+      reason: "The latest code scan is incomplete."
+    };
+  }
+  return void 0;
+}
+function requalifyClaimsForCodeState(store, codeStore, projectId) {
+  const snapshot = codeStore.latestSnapshot(projectId);
+  const refs = new Map(codeStore.listProjectObservationRefs(projectId).map((ref) => [ref.id, ref]));
+  let requalified = 0;
+  store.transaction(() => {
+    for (const claim of store.listClaims(projectId)) {
+      const next = requalification(claim, refs, store.listEvidence(claim.id), snapshot);
+      if (!next) continue;
+      if (next.status === claim.status && next.confidence === claim.confidence && next.reviewState === claim.reviewState) {
+        continue;
+      }
+      const updated = {
+        ...claim,
+        status: next.status,
+        confidence: next.confidence,
+        reviewState: next.reviewState,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      store.updateClaim(updated);
+      store.recordEvent({
+        projectId,
+        claimId: claim.id,
+        kind: "requalified",
+        fromStatus: claim.status,
+        toStatus: next.status,
+        detail: next.reason,
+        createdAt: updated.updatedAt
+      });
+      requalified += 1;
+    }
+  });
+  return { requalified, incompleteSnapshot: incompleteSnapshot(snapshot) };
+}
+function normalizedTokens(value) {
+  const raw = sanitizeCredentials(value).toLocaleLowerCase("en-US").match(TOKEN_PATTERN) ?? [];
+  return new Set(raw.map((token) => token.replace(/^[,;:!?]+|[,;:!?.]+$/g, "")).filter((token) => token.length > 1));
+}
+function taskTokens(task) {
+  return normalizedTokens(task);
+}
+function scoreClaim(claim, tokens) {
+  const text = [claim.subject, claim.predicate, claim.objectValue].join(" ").toLocaleLowerCase("en-US");
+  const words = normalizedTokens(text);
+  let matches = 0;
+  for (const token of tokens) {
+    if (words.has(token)) matches += 1;
+  }
+  if (matches === 0) return 0;
+  const statusWeight = claim.status === "active" ? 0.25 : claim.status === "disputed" ? 0.2 : 0.1;
+  return matches * 10 + claim.confidence + statusWeight;
+}
+function formatClaim(claim) {
+  return sanitizeCredentials([claim.subject, claim.predicate, claim.objectValue].join(" "));
+}
+function selectClaimsForTask(store, input) {
+  const limit = Math.max(1, Math.min(12, Math.floor(input.limit ?? 4)));
+  const maxTokens = Math.max(16, Math.min(1e3, Math.floor(input.maxTokens ?? 160)));
+  const tokens = taskTokens(input.task);
+  if (tokens.size === 0) return { claims: [], cautions: [], tokenCount: 0, reasons: {} };
+  const candidates = store.listClaims(input.projectId, {
+    statuses: ["active", "disputed", "unknown"],
+    limit: 1e3
+  }).filter((claim) => claim.reviewState !== "draft" && claim.reviewState !== "rejected");
+  const scored = candidates.map((claim) => ({ claim, score: scoreClaim(claim, tokens) })).filter((item) => item.score > 0).sort((left, right) => right.score - left.score || left.claim.id.localeCompare(right.claim.id));
+  if (scored.length === 0) return { claims: [], cautions: [], tokenCount: 0, reasons: {} };
+  const selected = /* @__PURE__ */ new Map();
+  for (const { claim } of scored.slice(0, limit)) selected.set(claim.id, claim);
+  for (const claim of [...selected.values()]) {
+    for (const sibling of store.listClaimsByConflictKey(input.projectId, claim.conflictKey)) {
+      if (sibling.status === "active" || sibling.status === "disputed") selected.set(sibling.id, sibling);
+    }
+  }
+  const ordered = [...selected.values()].sort((left, right) => scoreClaim(right, tokens) - scoreClaim(left, tokens) || left.id.localeCompare(right.id));
+  const included = [];
+  let tokenCount = 0;
+  for (const claim of ordered) {
+    const nextTokens = countTextTokens(formatClaim(claim));
+    if (included.length > 0 && tokenCount + nextTokens > maxTokens) continue;
+    included.push(claim);
+    tokenCount += nextTokens;
+  }
+  const cautions = /* @__PURE__ */ new Set();
+  const reasons = {};
+  for (const claim of included) {
+    reasons[claim.id] = "task terms matched source-qualified claim";
+    if (claim.status === "disputed") cautions.add("claim-conflict");
+    if (claim.status === "unknown" || claim.reviewState === "needs-review") {
+      cautions.add("claim-needs-review");
+    }
+  }
+  return { claims: included, cautions: [...cautions].sort(), tokenCount, reasons };
+}
+var MAX_TERM_LENGTH, MAX_EVIDENCE_ID_LENGTH, TOKEN_PATTERN, PREDICATE_BY_OBSERVATION_TYPE;
+var init_claims = __esm({
+  "src/knowledge/claims.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_token_budget();
+    init_secret_filter();
+    MAX_TERM_LENGTH = 2e3;
+    MAX_EVIDENCE_ID_LENGTH = 1e3;
+    TOKEN_PATTERN = /[\p{L}\p{N}_./:-]+/gu;
+    PREDICATE_BY_OBSERVATION_TYPE = {
+      decision: "decision",
+      "trade-off": "trade-off",
+      "why-it-exists": "rationale",
+      "what-changed": "changed",
+      "problem-solution": "workaround",
+      gotcha: "caution",
+      "how-it-works": "behavior",
+      discovery: "finding",
+      reasoning: "rationale"
+    };
+  }
+});
+
+// src/knowledge/markdown.ts
+import { createHash as createHash7 } from "crypto";
+import { promises as fs5 } from "fs";
+import path8 from "path";
+import matter from "gray-matter";
+function hashContent(content) {
+  return createHash7("sha256").update(content).digest("hex");
+}
+function stringField(data, key) {
+  const value = data[key];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("missing required field " + key);
+  }
+  return value.trim();
+}
+function stringArray(data, key) {
+  const value = data[key];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error("field " + key + " must be a string array");
+  }
+  return value.map((item) => item.trim()).filter(Boolean);
+}
+function optionalString(data, key) {
+  const value = data[key];
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") throw new Error("field " + key + " must be text");
+  return value.trim() || void 0;
+}
+function validateKnowledgePageFrontmatter(data) {
+  const kind = stringField(data, "kind");
+  const status = stringField(data, "status");
+  const reviewState = stringField(data, "reviewState");
+  if (!PAGE_KINDS.includes(kind)) throw new Error("field kind is invalid");
+  if (!PAGE_STATUSES.includes(status)) throw new Error("field status is invalid");
+  if (!REVIEW_STATES.includes(reviewState)) throw new Error("field reviewState is invalid");
+  return {
+    id: stringField(data, "id"),
+    title: stringField(data, "title"),
+    kind,
+    status,
+    reviewState,
+    claimIds: stringArray(data, "claimIds"),
+    evidenceRefs: stringArray(data, "evidenceRefs"),
+    ...optionalString(data, "snapshotId") ? { snapshotId: optionalString(data, "snapshotId") } : {},
+    tags: stringArray(data, "tags"),
+    sourceHash: stringField(data, "sourceHash"),
+    generatedAt: stringField(data, "generatedAt"),
+    updatedAt: stringField(data, "updatedAt")
+  };
+}
+function extractInternalMarkdownLinks(body) {
+  const links = /* @__PURE__ */ new Set();
+  for (const match of body.matchAll(LINK_PATTERN)) {
+    const raw = match[1].trim();
+    if (!raw || raw.startsWith("#") || /^[a-z][a-z0-9+.-]*:/i.test(raw)) continue;
+    const pathPart = raw.split("#", 1)[0].replace(/\\/g, "/");
+    if (!pathPart.endsWith(".md")) continue;
+    links.add(pathPart);
+  }
+  return [...links].sort();
+}
+function resolvePageLink(sourceRelativePath, target) {
+  const sourceDir = path8.posix.dirname(sourceRelativePath.replace(/\\/g, "/"));
+  const normalized = path8.posix.normalize(path8.posix.join(sourceDir, target.replace(/\\/g, "/")));
+  if (!normalized || normalized === "." || normalized === ".." || normalized.startsWith("../")) return void 0;
+  return normalized;
+}
+function renderKnowledgePage(frontmatter, body) {
+  const normalizedBody = body.trimEnd() + "\n";
+  return matter.stringify(normalizedBody, {
+    id: frontmatter.id,
+    title: frontmatter.title,
+    kind: frontmatter.kind,
+    status: frontmatter.status,
+    reviewState: frontmatter.reviewState,
+    claimIds: frontmatter.claimIds,
+    evidenceRefs: frontmatter.evidenceRefs,
+    ...frontmatter.snapshotId ? { snapshotId: frontmatter.snapshotId } : {},
+    tags: frontmatter.tags,
+    sourceHash: frontmatter.sourceHash,
+    generatedAt: frontmatter.generatedAt,
+    updatedAt: frontmatter.updatedAt
+  });
+}
+async function readKnowledgePage(absolutePath, workspaceRoot) {
+  const raw = await fs5.readFile(absolutePath, "utf8");
+  try {
+    const parsed = matter(raw);
+    const frontmatter = validateKnowledgePageFrontmatter(parsed.data);
+    return {
+      absolutePath,
+      relativePath: workspaceRoot ? path8.relative(workspaceRoot, absolutePath).split(path8.sep).join("/") : path8.basename(absolutePath),
+      frontmatter,
+      body: parsed.content.trim(),
+      contentHash: hashContent(raw),
+      links: extractInternalMarkdownLinks(parsed.content)
+    };
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : "invalid page data";
+    throw new Error("Malformed knowledge page frontmatter in " + absolutePath + ": " + detail);
+  }
+}
+async function writeKnowledgePage(absolutePath, content) {
+  await fs5.mkdir(path8.dirname(absolutePath), { recursive: true });
+  await atomicWriteFile(absolutePath, content);
+  return hashContent(content);
+}
+function pageContentHash(content) {
+  return hashContent(content);
+}
+var PAGE_KINDS, PAGE_STATUSES, REVIEW_STATES, LINK_PATTERN;
+var init_markdown = __esm({
+  "src/knowledge/markdown.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_lock();
+    PAGE_KINDS = ["topic", "decision", "risk", "index", "schema", "log"];
+    PAGE_STATUSES = ["active", "proposed"];
+    REVIEW_STATES = ["approved", "needs-review"];
+    LINK_PATTERN = /\[[^\]]+\]\(([^)]+)\)/g;
+  }
+});
+
+// src/knowledge/wiki.ts
+var wiki_exports = {};
+__export(wiki_exports, {
+  applyKnowledgeProposal: () => applyKnowledgeProposal,
+  compileKnowledgeWorkspace: () => compileKnowledgeWorkspace,
+  lintKnowledgeWorkspace: () => lintKnowledgeWorkspace,
+  readKnowledgePage: () => readKnowledgePage
+});
+import { createHash as createHash8 } from "crypto";
+import { promises as fs6 } from "fs";
+import path9 from "path";
+function hash2(value) {
+  return createHash8("sha256").update(value).digest("hex");
+}
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function storeFor(workspace) {
+  if (!workspace.dataDir) throw new Error("Knowledge workspace has no operational data directory");
+  const store = new KnowledgeWorkspaceStore();
+  await store.init(workspace.dataDir);
+  return store;
+}
+function topicSlug(subject) {
+  const safe = subject.toLocaleLowerCase("en-US").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+  return (safe || "topic") + "-" + hash2(subject).slice(0, 8);
+}
+function groupClaims(claims) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const claim of claims) {
+    const group = groups.get(claim.subject) ?? [];
+    group.push(claim);
+    groups.set(claim.subject, group);
+  }
+  return groups;
+}
+function selectPublishableClaims(claims, projectId) {
+  return claims.listClaims(projectId, { statuses: ["active"], limit: 1e3 }).filter((claim) => claim.reviewState === "approved");
+}
+function evidenceRefs(claims, store) {
+  const refs = /* @__PURE__ */ new Set();
+  for (const claim of claims) {
+    for (const evidence of store.listEvidence(claim.id)) {
+      refs.add("claim:" + claim.id + ":evidence:" + evidence.id);
+    }
+  }
+  return [...refs].sort();
+}
+function snapshotIdForClaims(claims, store) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const claim of claims) {
+    for (const evidence of store.listEvidence(claim.id)) {
+      if (evidence.snapshotId) ids.add(evidence.snapshotId);
+    }
+  }
+  return ids.size === 1 ? [...ids][0] : void 0;
+}
+function sourceHashForClaims(claims, store) {
+  const source = claims.map((claim) => ({
+    id: claim.id,
+    status: claim.status,
+    confidence: claim.confidence,
+    evidence: store.listEvidence(claim.id).map((item) => ({
+      id: item.id,
+      kind: item.evidenceKind,
+      evidenceId: item.evidenceId,
+      relation: item.relation,
+      snapshotId: item.snapshotId ?? "",
+      capturedHash: item.capturedHash ?? ""
+    }))
+  }));
+  return hash2(JSON.stringify(source));
+}
+function renderTopicBody(title, claims, store) {
+  const lines = [
+    "# " + title,
+    "",
+    "This page is compiled from approved source-qualified claims.",
+    "",
+    "## Current claims",
+    ""
+  ];
+  for (const claim of claims) {
+    lines.push("- " + claim.predicate + ": " + claim.objectValue + " (claim " + claim.id + ")");
+  }
+  lines.push("");
+  lines.push("## Evidence");
+  lines.push("");
+  for (const claim of claims) {
+    lines.push("### Claim " + claim.id);
+    const evidence = store.listEvidence(claim.id);
+    if (evidence.length === 0) {
+      lines.push("- Missing evidence.");
+      continue;
+    }
+    for (const item of evidence) {
+      const location = item.locator ? " at " + item.locator : "";
+      const snapshot = item.snapshotId ? " (snapshot " + item.snapshotId + ")" : "";
+      lines.push("- " + item.evidenceKind + ": " + item.evidenceId + location + snapshot);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function candidatePage(workspace, title, claims, store) {
+  const sourceHash = sourceHashForClaims(claims, store);
+  const generatedAt = now();
+  const slug2 = topicSlug(title);
+  const targetRelativePath = "pages/" + slug2 + ".md";
+  const proposalRelativePath = "proposals/" + slug2 + ".md";
+  const frontmatter = {
+    id: "page:" + hash2(workspace.projectId + ":" + title).slice(0, 24),
+    title,
+    kind: "topic",
+    status: "proposed",
+    reviewState: "needs-review",
+    claimIds: claims.map((claim) => claim.id).sort(),
+    evidenceRefs: evidenceRefs(claims, store),
+    ...snapshotIdForClaims(claims, store) ? { snapshotId: snapshotIdForClaims(claims, store) } : {},
+    tags: ["generated", "topic"],
+    sourceHash,
+    generatedAt,
+    updatedAt: generatedAt
+  };
+  const content = renderKnowledgePage(frontmatter, renderTopicBody(title, claims, store));
+  const proposalPath = resolveKnowledgeWorkspaceFile(workspace, proposalRelativePath);
+  return {
+    page: {
+      absolutePath: proposalPath,
+      relativePath: proposalRelativePath,
+      frontmatter,
+      body: renderTopicBody(title, claims, store),
+      contentHash: pageContentHash(content),
+      links: []
+    },
+    content,
+    targetRelativePath,
+    proposalRelativePath
+  };
+}
+async function fileHashIfPresent(filePath) {
+  try {
+    return pageContentHash(await fs6.readFile(filePath, "utf8"));
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+    if (code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function writeIndex(workspace, store) {
+  const paths = getKnowledgeWorkspacePaths(workspace);
+  const published = store.listPages(workspace.id).filter((page) => page.status === "active").sort((left, right) => left.title.localeCompare(right.title));
+  const pending = store.listProposals(workspace.id, "pending").sort((left, right) => left.proposalPath.localeCompare(right.proposalPath));
+  const lines = ["# Knowledge Workspace", "", "## Published pages", ""];
+  if (published.length === 0) {
+    lines.push("No published pages yet.");
+  } else {
+    for (const page of published) lines.push("- [" + page.title + "](" + page.relativePath + ")");
+  }
+  lines.push("");
+  lines.push("## Review queue");
+  lines.push("");
+  if (pending.length === 0) {
+    lines.push("No pending proposals.");
+  } else {
+    for (const proposal of pending) {
+      const relative2 = path9.relative(paths.root, proposal.proposalPath).split(path9.sep).join("/");
+      lines.push("- [" + path9.basename(proposal.proposalPath, ".md") + "](" + relative2 + ")");
+    }
+  }
+  lines.push("");
+  await writeKnowledgePage(paths.index, lines.join("\n"));
+}
+async function appendLog(workspace, line) {
+  const logPath = getKnowledgeWorkspacePaths(workspace).log;
+  await fs6.appendFile(logPath, "- " + now() + " " + line + "\n", "utf8");
+}
+function toPageRecord(workspace, page, status, contentHash, manualContentHash) {
+  return {
+    id: page.frontmatter.id,
+    workspaceId: workspace.id,
+    relativePath: page.relativePath.replace(/^proposals\//, "pages/"),
+    title: page.frontmatter.title,
+    kind: page.frontmatter.kind,
+    status,
+    reviewState: page.frontmatter.reviewState,
+    contentHash,
+    sourceHash: page.frontmatter.sourceHash,
+    claimIds: page.frontmatter.claimIds,
+    ...page.frontmatter.snapshotId ? { snapshotId: page.frontmatter.snapshotId } : {},
+    tags: page.frontmatter.tags,
+    generatedAt: page.frontmatter.generatedAt,
+    updatedAt: page.frontmatter.updatedAt,
+    ...manualContentHash ? { manualContentHash } : {}
+  };
+}
+async function compileKnowledgeWorkspace(input) {
+  const store = await storeFor(input.workspace);
+  const published = [];
+  const proposals = [];
+  const claims = selectPublishableClaims(input.claims, input.workspace.projectId);
+  await withFileLock(getKnowledgeWorkspacePaths(input.workspace).root, async () => {
+    for (const [title, group] of groupClaims(claims)) {
+      const candidate = candidatePage(input.workspace, title, group, input.claims);
+      const targetPath = resolveKnowledgeWorkspaceFile(input.workspace, candidate.targetRelativePath);
+      const proposalPath = resolveKnowledgeWorkspaceFile(input.workspace, candidate.proposalRelativePath);
+      let existing = store.getPage(input.workspace.id, candidate.targetRelativePath);
+      const actualTargetHash = await fileHashIfPresent(targetPath);
+      if (actualTargetHash && !existing) {
+        const manualRecord = {
+          ...toPageRecord(input.workspace, candidate.page, "active", actualTargetHash, actualTargetHash),
+          reviewState: "needs-review",
+          sourceHash: "manual:" + actualTargetHash
+        };
+        store.upsertPage(manualRecord);
+        existing = manualRecord;
+      }
+      if (actualTargetHash && existing && existing.status === "active" && !existing.manualContentHash && actualTargetHash === existing.contentHash && existing.sourceHash === candidate.page.frontmatter.sourceHash) {
+        published.push(existing);
+        continue;
+      }
+      let reason = "new-page";
+      let baseContentHash;
+      if (actualTargetHash) {
+        baseContentHash = existing?.contentHash;
+        if (!existing || existing.status !== "active" || !!existing.manualContentHash || actualTargetHash !== existing.contentHash) {
+          reason = "manual-edit-protected";
+        } else {
+          reason = "source-changed";
+        }
+      }
+      if (!actualTargetHash) {
+        store.upsertPage(toPageRecord(input.workspace, candidate.page, "proposed", candidate.page.contentHash));
+      }
+      await writeKnowledgePage(proposalPath, candidate.content);
+      const proposal = store.createProposal({
+        workspaceId: input.workspace.id,
+        pageId: candidate.page.frontmatter.id,
+        targetPath,
+        proposalPath,
+        ...baseContentHash ? { baseContentHash } : {},
+        sourceHash: candidate.page.frontmatter.sourceHash,
+        reason
+      });
+      proposals.push(proposal);
+      await appendLog(input.workspace, "proposed " + candidate.targetRelativePath + " (" + reason + ").");
+    }
+    store.markWorkspaceCompiled(input.workspace.id);
+    await writeIndex(input.workspace, store);
+  });
+  return { proposals, published };
+}
+async function applyKnowledgeProposal(input) {
+  const store = await storeFor(input.workspace);
+  const proposal = store.getProposal(input.proposalId);
+  if (!proposal || proposal.workspaceId !== input.workspace.id) {
+    throw new Error("Knowledge proposal was not found for this workspace");
+  }
+  if (proposal.status !== "pending") throw new Error("Knowledge proposal is not pending review");
+  const root = getKnowledgeWorkspacePaths(input.workspace).root;
+  const targetPath = path9.resolve(proposal.targetPath);
+  const proposalPath = path9.resolve(proposal.proposalPath);
+  if (!targetPath.startsWith(root + path9.sep) || !proposalPath.startsWith(root + path9.sep)) {
+    throw new Error("Knowledge proposal path escapes its workspace");
+  }
+  await withFileLock(root, async () => {
+    const actualTargetHash = await fileHashIfPresent(targetPath);
+    if (proposal.baseContentHash && actualTargetHash !== proposal.baseContentHash && !input.allowManualOverwrite) {
+      throw new Error("The target page has manual changes; review the proposal before applying it");
+    }
+    if (!proposal.baseContentHash && actualTargetHash && !input.allowManualOverwrite) {
+      throw new Error("The target page already exists and has no known safe base revision");
+    }
+    const proposalPage = await readKnowledgePage(proposalPath, root);
+    const activeFrontmatter = {
+      ...proposalPage.frontmatter,
+      status: "active",
+      reviewState: "approved",
+      updatedAt: now()
+    };
+    const content = renderKnowledgePage(activeFrontmatter, proposalPage.body);
+    const contentHash = await writeKnowledgePage(targetPath, content);
+    const activePage = await readKnowledgePage(targetPath, root);
+    const record = toPageRecord(input.workspace, activePage, "active", contentHash);
+    store.upsertPage(record);
+    store.replacePageClaims(record.id, record.claimIds);
+    store.replacePageLinks(record.id, activePage.links.map((link) => resolvePageLink(record.relativePath, link)).filter((link) => !!link));
+    store.markProposalApplied(proposal.id);
+    await appendLog(
+      input.workspace,
+      "applied " + record.relativePath + (input.allowManualOverwrite ? " after explicit manual overwrite review." : ".")
+    );
+    await writeIndex(input.workspace, store);
+  });
+  return { proposal: store.getProposal(proposal.id), targetPath };
+}
+async function markdownFiles(directory) {
+  const files = [];
+  let entries;
+  try {
+    entries = await fs6.readdir(directory, { withFileTypes: true });
+  } catch {
+    return files;
+  }
+  for (const entry of entries) {
+    const filePath = path9.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await markdownFiles(filePath));
+    } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+async function lintKnowledgeWorkspace(input) {
+  const store = await storeFor(input.workspace);
+  const paths = getKnowledgeWorkspacePaths(input.workspace);
+  const issues = [];
+  const validPages = [];
+  const files = await markdownFiles(paths.pages);
+  for (const filePath of files) {
+    try {
+      validPages.push(await readKnowledgePage(filePath, paths.root));
+    } catch (error) {
+      issues.push({
+        kind: "malformed-frontmatter",
+        severity: "error",
+        message: error instanceof Error ? error.message : "Malformed knowledge page.",
+        relativePath: path9.relative(paths.root, filePath).split(path9.sep).join("/")
+      });
+    }
+  }
+  const indexed = /* @__PURE__ */ new Set();
+  try {
+    const index = await fs6.readFile(paths.index, "utf8");
+    for (const link of extractInternalMarkdownLinks(index)) {
+      const resolved = resolvePageLink("index.md", link);
+      if (resolved) indexed.add(resolved);
+    }
+  } catch {
+    issues.push({
+      kind: "broken-link",
+      severity: "error",
+      message: "Knowledge index is missing.",
+      relativePath: "index.md"
+    });
+  }
+  const latestSnapshotId = input.codeStore?.latestSnapshot(input.workspace.projectId)?.id;
+  for (const page of validPages) {
+    if (!indexed.has(page.relativePath)) {
+      issues.push({
+        kind: "orphan-page",
+        severity: "warning",
+        message: "Page is not linked from index.md.",
+        relativePath: page.relativePath
+      });
+    }
+    for (const link of page.links) {
+      const target = resolvePageLink(page.relativePath, link);
+      if (!target || !await fileHashIfPresent(resolveKnowledgeWorkspaceFile(input.workspace, target))) {
+        issues.push({
+          kind: "broken-link",
+          severity: "error",
+          message: "Internal Markdown link does not resolve to a workspace page.",
+          relativePath: page.relativePath
+        });
+      }
+    }
+    for (const claimId of page.frontmatter.claimIds) {
+      const claim = input.claims.getClaim(claimId);
+      if (!claim) {
+        issues.push({
+          kind: "missing-claim",
+          severity: "error",
+          message: "Page references a claim that is not present in the ledger.",
+          relativePath: page.relativePath,
+          claimId
+        });
+        continue;
+      }
+      if (input.claims.listEvidence(claim.id).length === 0) {
+        issues.push({
+          kind: "missing-evidence",
+          severity: "error",
+          message: "Page claim has no source evidence.",
+          relativePath: page.relativePath,
+          claimId
+        });
+      }
+      if (claim.status === "superseded") {
+        issues.push({
+          kind: "superseded-claim",
+          severity: "error",
+          message: "Page still presents a superseded primary claim.",
+          relativePath: page.relativePath,
+          claimId
+        });
+      }
+      if (claim.status === "disputed") {
+        issues.push({
+          kind: "unresolved-conflict",
+          severity: "error",
+          message: "Page claim has an unresolved competing assertion.",
+          relativePath: page.relativePath,
+          claimId
+        });
+      }
+    }
+    if (latestSnapshotId && page.frontmatter.snapshotId && page.frontmatter.snapshotId !== latestSnapshotId) {
+      issues.push({
+        kind: "stale-snapshot",
+        severity: "warning",
+        message: "Page was compiled against an older code snapshot.",
+        relativePath: page.relativePath
+      });
+    }
+  }
+  for (const proposal of store.listProposals(input.workspace.id, "pending")) {
+    if (proposal.reason === "manual-edit-protected") {
+      issues.push({
+        kind: "manual-edit-protected",
+        severity: "warning",
+        message: "A newer proposal was held because the target page has manual edits.",
+        relativePath: path9.relative(paths.root, proposal.targetPath).split(path9.sep).join("/")
+      });
+    }
+  }
+  const valid = !issues.some((issue) => issue.severity === "error");
+  store.markWorkspaceLinted(input.workspace.id, valid ? "ready" : "needs-review");
+  return { valid, pagesScanned: validPages.length, issues };
+}
+var init_wiki = __esm({
+  "src/knowledge/wiki.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_lock();
+    init_markdown();
+    init_workspace_store();
+    init_workspace();
+    init_markdown();
+  }
+});
+
+// src/workspace/workflow-sync.ts
+import matter2 from "gray-matter";
+var WorkflowSyncer;
+var init_workflow_sync = __esm({
+  "src/workspace/workflow-sync.ts"() {
+    "use strict";
+    init_esm_shims();
+    WorkflowSyncer = class {
+      /**
+       * Parse a Windsurf workflow markdown file into a WorkflowEntry.
+       */
+      parseWindsurfWorkflow(fileName, raw) {
+        const name = fileName.replace(/\.md$/i, "");
+        let description = "";
+        let content = raw;
+        try {
+          const parsed = matter2(raw);
+          description = parsed.data?.description ?? "";
+          content = parsed.content.trim();
+        } catch {
+        }
+        return {
+          name,
+          description,
+          content,
+          source: "windsurf",
+          filePath: `.windsurf/workflows/${fileName}`
+        };
+      }
+      /**
+       * Convert a workflow to Codex SKILL.md format.
+       */
+      toCodexSkill(wf) {
+        const safeName = this.sanitizeName(wf.name);
+        const fm = { name: safeName };
+        if (wf.description) {
+          fm.description = wf.description;
+        }
+        const content = matter2.stringify(wf.content, fm);
+        return {
+          filePath: `.agents/skills/${safeName}/SKILL.md`,
+          content
+        };
+      }
+      /**
+       * Convert a workflow to Cursor .mdc rule format.
+       */
+      toCursorRule(wf) {
+        const safeName = this.sanitizeName(wf.name);
+        const fm = {};
+        if (wf.description) {
+          fm.description = wf.description;
+        }
+        fm.globs = "";
+        fm.alwaysApply = "false";
+        const content = matter2.stringify(wf.content, fm);
+        return {
+          filePath: `.cursor/rules/${safeName}.mdc`,
+          content
+        };
+      }
+      /**
+       * Convert a workflow to a CLAUDE.md section string.
+       */
+      toClaudeSection(wf) {
+        const lines = [];
+        lines.push(`## Workflow: ${wf.name}`);
+        if (wf.description) {
+          lines.push("");
+          lines.push(`> ${wf.description}`);
+        }
+        lines.push("");
+        lines.push(wf.content);
+        return lines.join("\n");
+      }
+      /**
+       * Convert all workflows to the target agent format.
+       * Returns an array of { filePath, content } for each generated file.
+       */
+      convertAll(workflows, target) {
+        if (target === "windsurf") {
+          return [];
+        }
+        if (target === "codex") {
+          return workflows.map((wf) => this.toCodexSkill(wf));
+        }
+        if (target === "cursor") {
+          return workflows.map((wf) => this.toCursorRule(wf));
+        }
+        if (target === "claude-code") {
+          const sections = workflows.map((wf) => this.toClaudeSection(wf));
+          return [
+            {
+              filePath: "CLAUDE.md",
+              content: sections.join("\n\n")
+            }
+          ];
+        }
+        return [];
+      }
+      // ---- Helpers ----
+      sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "workflow";
+      }
+    };
+  }
+});
+
+// src/knowledge/workflow-store.ts
+import { randomUUID as randomUUID7 } from "crypto";
+function parseJson(value, fallback) {
+  if (typeof value !== "string" || !value) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+function optionalText3(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function rowToWorkflow(row) {
+  return parseJson(row.specJson, {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    title: row.title,
+    description: "",
+    status: row.status,
+    version: row.version,
+    taskLenses: [],
+    triggers: [],
+    assumptions: [],
+    requiredContext: [],
+    guardrails: [],
+    allowedTools: [],
+    phases: [],
+    verificationGates: [],
+    claimIds: [],
+    evidenceRefs: [],
+    codeRefs: [],
+    compatibleAgents: [],
+    body: "",
+    sourcePath: row.sourcePath,
+    sourceHash: row.sourceHash,
+    contentHash: row.contentHash,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  });
+}
+function rowToRun(row) {
+  return {
+    id: row.id,
+    workflowId: row.workflowId,
+    projectId: row.projectId,
+    task: row.task,
+    ...optionalText3(row.startingSnapshotId) ? { startingSnapshotId: row.startingSnapshotId } : {},
+    selectedEvidence: parseJson(row.selectedEvidenceJson, []),
+    phaseState: parseJson(row.phaseStateJson, {}),
+    outcome: row.outcome,
+    verificationVerdict: row.verificationVerdict,
+    ...optionalText3(row.failureReason) ? { failureReason: row.failureReason } : {},
+    startedAt: row.startedAt,
+    ...optionalText3(row.completedAt) ? { completedAt: row.completedAt } : {}
+  };
+}
+var WorkflowStore;
+var init_workflow_store = __esm({
+  "src/knowledge/workflow-store.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_sqlite_db();
+    WorkflowStore = class {
+      db = null;
+      async init(dataDir) {
+        this.db = getDatabase(dataDir);
+      }
+      upsertWorkflow(workflow) {
+        this.db.prepare(
+          "INSERT INTO knowledge_workflows (id, workspaceId, sourcePath, title, status, version, sourceHash, contentHash, specJson, importedFrom, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(workspaceId, sourcePath) DO UPDATE SET id = excluded.id, title = excluded.title, status = excluded.status, version = excluded.version, sourceHash = excluded.sourceHash, contentHash = excluded.contentHash, specJson = excluded.specJson, importedFrom = excluded.importedFrom, updatedAt = excluded.updatedAt"
+        ).run(
+          workflow.id,
+          workflow.workspaceId,
+          workflow.sourcePath,
+          workflow.title,
+          workflow.status,
+          workflow.version,
+          workflow.sourceHash,
+          workflow.contentHash,
+          JSON.stringify(workflow),
+          workflow.importedFrom ?? null,
+          workflow.createdAt,
+          workflow.updatedAt
+        );
+        return this.getWorkflowByPath(workflow.workspaceId, workflow.sourcePath);
+      }
+      getWorkflow(id) {
+        const row = this.db.prepare("SELECT * FROM knowledge_workflows WHERE id = ?").get(id);
+        return row ? rowToWorkflow(row) : void 0;
+      }
+      getWorkflowByPath(workspaceId2, sourcePath) {
+        const row = this.db.prepare("SELECT * FROM knowledge_workflows WHERE workspaceId = ? AND sourcePath = ?").get(workspaceId2, sourcePath);
+        return row ? rowToWorkflow(row) : void 0;
+      }
+      listWorkflows(workspaceId2, status) {
+        const rows = status ? this.db.prepare("SELECT * FROM knowledge_workflows WHERE workspaceId = ? AND status = ? ORDER BY title, id").all(workspaceId2, status) : this.db.prepare("SELECT * FROM knowledge_workflows WHERE workspaceId = ? ORDER BY title, id").all(workspaceId2);
+        return rows.map(rowToWorkflow);
+      }
+      recordRun(input) {
+        const run = {
+          id: randomUUID7(),
+          workflowId: input.workflowId,
+          projectId: input.projectId,
+          task: input.task.trim(),
+          ...input.startingSnapshotId ? { startingSnapshotId: input.startingSnapshotId } : {},
+          selectedEvidence: [...new Set(input.selectedEvidence ?? [])],
+          phaseState: input.phaseState ?? {},
+          outcome: input.outcome,
+          verificationVerdict: input.verificationVerdict ?? (input.outcome === "failed" ? "failed" : "not-run"),
+          ...input.failureReason?.trim() ? { failureReason: input.failureReason.trim() } : {},
+          startedAt: input.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+          ...input.completedAt ? { completedAt: input.completedAt } : input.outcome !== "in-progress" ? { completedAt: (/* @__PURE__ */ new Date()).toISOString() } : {}
+        };
+        this.db.prepare(
+          "INSERT INTO knowledge_workflow_runs (id, workflowId, projectId, task, startingSnapshotId, selectedEvidenceJson, phaseStateJson, outcome, verificationVerdict, failureReason, startedAt, completedAt) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)"
+        ).run(
+          run.id,
+          run.workflowId,
+          run.projectId,
+          run.task,
+          run.startingSnapshotId ?? null,
+          JSON.stringify(run.selectedEvidence),
+          JSON.stringify(run.phaseState),
+          run.outcome,
+          run.verificationVerdict,
+          run.failureReason ?? null,
+          run.startedAt,
+          run.completedAt ?? null
+        );
+        return this.getRun(run.id);
+      }
+      getRun(id) {
+        const row = this.db.prepare("SELECT * FROM knowledge_workflow_runs WHERE id = ?").get(id);
+        return row ? rowToRun(row) : void 0;
+      }
+      listRuns(projectId, workflowId, limit = 20) {
+        const boundedLimit = Math.max(1, Math.min(Math.floor(limit), 100));
+        const rows = workflowId ? this.db.prepare("SELECT * FROM knowledge_workflow_runs WHERE projectId = ? AND workflowId = ? ORDER BY startedAt DESC LIMIT ?").all(projectId, workflowId, boundedLimit) : this.db.prepare("SELECT * FROM knowledge_workflow_runs WHERE projectId = ? ORDER BY startedAt DESC LIMIT ?").all(projectId, boundedLimit);
+        return rows.map(rowToRun);
+      }
+      recentFailureCautions(projectId, workflowId, limit = 2) {
+        return this.listRuns(projectId, workflowId, limit).filter((run) => run.outcome === "failed" || run.verificationVerdict === "failed").map((run) => run.failureReason ? "Previous run failed: " + run.failureReason : "Previous run has a failed verification gate.");
+      }
+    };
+  }
+});
+
+// src/knowledge/workflows.ts
+var workflows_exports = {};
+__export(workflows_exports, {
+  WORKFLOW_ADAPTER_TARGETS: () => WORKFLOW_ADAPTER_TARGETS,
+  applyWorkflowAdapter: () => applyWorkflowAdapter,
+  importWindsurfWorkflows: () => importWindsurfWorkflows,
+  parseWorkflowMarkdown: () => parseWorkflowMarkdown,
+  previewWorkflowAdapter: () => previewWorkflowAdapter,
+  recordWorkflowRun: () => recordWorkflowRun,
+  renderWorkflowMarkdown: () => renderWorkflowMarkdown,
+  selectWorkflows: () => selectWorkflows,
+  selectWorkspaceWorkflows: () => selectWorkspaceWorkflows,
+  syncCanonicalWorkflows: () => syncCanonicalWorkflows,
+  writeCanonicalWorkflow: () => writeCanonicalWorkflow
+});
+import { createHash as createHash9 } from "crypto";
+import { promises as fs7 } from "fs";
+import path10 from "path";
+import matter3 from "gray-matter";
+function hash3(value) {
+  return createHash9("sha256").update(value).digest("hex");
+}
+function now2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function slug(value) {
+  const normalized = value.trim().toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 72);
+  return normalized || "workflow";
+}
+function titleFromName(name) {
+  return name.replace(/[-_]+/g, " ").split(" ").filter(Boolean).map((part) => part.slice(0, 1).toUpperCase() + part.slice(1)).join(" ") || "Imported Workflow";
+}
+function requiredText(data, key) {
+  const value = data[key];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error("workflow frontmatter requires " + key);
+  }
+  return value.trim();
+}
+function optionalText4(data, key) {
+  const value = data[key];
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") throw new Error("workflow frontmatter field " + key + " must be text");
+  return value.trim() || void 0;
+}
+function optionalStringArray(data, key) {
+  const value = data[key];
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error("workflow frontmatter field " + key + " must be a string array");
+  }
+  return [...new Set(value.map((item) => item.trim()).filter(Boolean))];
+}
+function optionalNumber(data, key, fallback) {
+  const value = data[key];
+  if (value === void 0 || value === null || value === "") return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    throw new Error("workflow frontmatter field " + key + " must be a positive integer");
+  }
+  return value;
+}
+function optionalStatus(data) {
+  const value = data.status;
+  if (value === void 0 || value === null || value === "") return "draft";
+  if (typeof value !== "string" || !STATUS_VALUES.includes(value)) {
+    throw new Error("workflow frontmatter field status is invalid");
+  }
+  return value;
+}
+function normalizeAgents(values) {
+  const unknown = values.filter((value) => !KNOWN_AGENTS.includes(value));
+  if (unknown.length > 0) {
+    throw new Error("workflow frontmatter has unsupported agent: " + unknown[0]);
+  }
+  return values;
+}
+function phaseFromValue(value, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("workflow frontmatter phases must contain objects");
+  }
+  const data = value;
+  const title = requiredText(data, "title");
+  const phaseId = optionalText4(data, "id") ?? slug(title) + "-" + (index + 1);
+  return {
+    id: phaseId,
+    title,
+    instructions: optionalText4(data, "instructions") ?? "",
+    branches: optionalStringArray(data, "branches"),
+    expectedOutputs: optionalStringArray(data, "expectedOutputs"),
+    verificationGates: optionalStringArray(data, "verificationGates")
+  };
+}
+function phasesFromBody(body) {
+  const headers = [...body.matchAll(/^##\s+(.+?)\s*$/gm)];
+  if (headers.length === 0) {
+    const instructions = body.trim();
+    return instructions ? [{
+      id: "execute",
+      title: "Execute",
+      instructions,
+      branches: [],
+      expectedOutputs: [],
+      verificationGates: []
+    }] : [];
+  }
+  return headers.map((match, index) => {
+    const title = match[1].trim();
+    const start = (match.index ?? 0) + match[0].length;
+    const end = index + 1 < headers.length ? headers[index + 1].index ?? body.length : body.length;
+    return {
+      id: slug(title) + "-" + (index + 1),
+      title,
+      instructions: body.slice(start, end).trim(),
+      branches: [],
+      expectedOutputs: [],
+      verificationGates: []
+    };
+  });
+}
+function normalizeSourcePath(sourcePath) {
+  const normalized = sourcePath.replace(/\\/g, "/");
+  if (!normalized.startsWith("workflows/") || !normalized.toLowerCase().endsWith(".md") || normalized.includes("../") || path10.posix.normalize(normalized) !== normalized) {
+    throw new Error("workflow source path must be a safe workflows/*.md path");
+  }
+  return normalized;
+}
+function sourceHashFor(workflow) {
+  return hash3(JSON.stringify({
+    id: workflow.id,
+    title: workflow.title,
+    description: workflow.description,
+    status: workflow.status,
+    version: workflow.version,
+    taskLenses: workflow.taskLenses,
+    triggers: workflow.triggers,
+    assumptions: workflow.assumptions,
+    requiredContext: workflow.requiredContext,
+    guardrails: workflow.guardrails,
+    allowedTools: workflow.allowedTools,
+    phases: workflow.phases,
+    verificationGates: workflow.verificationGates,
+    claimIds: workflow.claimIds,
+    evidenceRefs: workflow.evidenceRefs,
+    codeRefs: workflow.codeRefs,
+    compatibleAgents: workflow.compatibleAgents,
+    body: workflow.body,
+    sourcePath: workflow.sourcePath,
+    importedFrom: workflow.importedFrom ?? null
+  }));
+}
+function workflowFrontmatter(workflow, sourceHash) {
   return {
-    id: makeObservationCodeRefId(projectId, obs.id, file.id),
-    projectId,
-    observationId: obs.id,
-    fileId: file.id,
-    capturedFileHash: file.contentHash,
-    status: "current",
-    reason: "bound by file path",
-    createdAt: obs.createdAt
+    id: workflow.id,
+    title: workflow.title,
+    description: workflow.description,
+    status: workflow.status,
+    version: workflow.version,
+    taskLenses: workflow.taskLenses,
+    triggers: workflow.triggers,
+    assumptions: workflow.assumptions,
+    requiredContext: workflow.requiredContext,
+    guardrails: workflow.guardrails,
+    allowedTools: workflow.allowedTools,
+    phases: workflow.phases.map((phase) => ({
+      id: phase.id,
+      title: phase.title,
+      ...phase.instructions ? { instructions: phase.instructions } : {},
+      ...phase.branches.length ? { branches: phase.branches } : {},
+      ...phase.expectedOutputs.length ? { expectedOutputs: phase.expectedOutputs } : {},
+      ...phase.verificationGates.length ? { verificationGates: phase.verificationGates } : {}
+    })),
+    verificationGates: workflow.verificationGates,
+    claimIds: workflow.claimIds,
+    evidenceRefs: workflow.evidenceRefs,
+    codeRefs: workflow.codeRefs,
+    compatibleAgents: workflow.compatibleAgents,
+    sourceHash,
+    createdAt: workflow.createdAt,
+    updatedAt: workflow.updatedAt,
+    ...workflow.importedFrom ? { importedFrom: workflow.importedFrom } : {}
   };
 }
-function symbolRef(projectId, obs, file, symbol) {
+function renderWorkflowMarkdown(workflow) {
+  const sourceHash = sourceHashFor(workflow);
+  return matter3.stringify(workflow.body.trimEnd() + "\n", workflowFrontmatter(workflow, sourceHash));
+}
+function parsedWorkflow(data, body, input) {
+  const phasesValue = data.phases;
+  const parsedPhases = phasesValue === void 0 || phasesValue === null ? phasesFromBody(body) : Array.isArray(phasesValue) ? phasesValue.map(phaseFromValue) : (() => {
+    throw new Error("workflow frontmatter field phases must be an array");
+  })();
+  const candidate = {
+    id: requiredText(data, "id"),
+    workspaceId: input.workspaceId,
+    title: requiredText(data, "title"),
+    description: optionalText4(data, "description") ?? "",
+    status: optionalStatus(data),
+    version: optionalNumber(data, "version", 1),
+    taskLenses: optionalStringArray(data, "taskLenses"),
+    triggers: optionalStringArray(data, "triggers"),
+    assumptions: optionalStringArray(data, "assumptions"),
+    requiredContext: optionalStringArray(data, "requiredContext"),
+    guardrails: optionalStringArray(data, "guardrails"),
+    allowedTools: optionalStringArray(data, "allowedTools"),
+    phases: parsedPhases,
+    verificationGates: optionalStringArray(data, "verificationGates"),
+    claimIds: optionalStringArray(data, "claimIds"),
+    evidenceRefs: optionalStringArray(data, "evidenceRefs"),
+    codeRefs: optionalStringArray(data, "codeRefs"),
+    compatibleAgents: normalizeAgents(optionalStringArray(data, "compatibleAgents").length ? optionalStringArray(data, "compatibleAgents") : optionalStringArray(data, "allowedAgents")),
+    body: body.trim(),
+    sourcePath: normalizeSourcePath(input.sourcePath),
+    sourceHash: "",
+    contentHash: input.contentHash,
+    createdAt: optionalText4(data, "createdAt") ?? now2(),
+    updatedAt: optionalText4(data, "updatedAt") ?? now2(),
+    ...optionalText4(data, "importedFrom") ? { importedFrom: optionalText4(data, "importedFrom") } : {}
+  };
+  if (candidate.phases.length === 0) {
+    throw new Error("workflow must contain at least one phase or a non-empty body");
+  }
+  return { ...candidate, sourceHash: sourceHashFor(candidate) };
+}
+function parseWorkflowMarkdown(raw, input) {
+  let parsed;
+  try {
+    parsed = matter3(raw);
+  } catch (error) {
+    throw new Error("Malformed workflow Markdown: " + (error instanceof Error ? error.message : String(error)));
+  }
+  return parsedWorkflow(parsed.data, parsed.content, {
+    workspaceId: input.workspaceId,
+    sourcePath: input.sourcePath,
+    contentHash: hash3(raw)
+  });
+}
+function workflowStoreDataDir(workspace) {
+  if (!workspace.dataDir) throw new Error("Knowledge workspace is missing its local data directory");
+  return workspace.dataDir;
+}
+async function storeFor2(workspace) {
+  const store = new WorkflowStore();
+  await store.init(workflowStoreDataDir(workspace));
+  return store;
+}
+function materializeWorkflow(workflow) {
+  const updatedAt = workflow.updatedAt || now2();
+  const withDates = {
+    ...workflow,
+    createdAt: workflow.createdAt || updatedAt,
+    updatedAt
+  };
+  const sourceHash = sourceHashFor(withDates);
+  const content = renderWorkflowMarkdown({ ...withDates, sourceHash, contentHash: "" });
   return {
-    id: makeObservationCodeRefId(projectId, obs.id, file.id, symbol.id),
-    projectId,
-    observationId: obs.id,
-    fileId: file.id,
-    symbolId: symbol.id,
-    capturedFileHash: file.contentHash,
-    ...symbol.contentHash ? { capturedSymbolHash: symbol.contentHash } : {},
-    status: "current",
-    reason: "bound by symbol mention",
-    createdAt: obs.createdAt
+    ...withDates,
+    sourceHash,
+    contentHash: hash3(content)
   };
 }
-function resolveObservationCodeRefs(obs, lookup) {
-  const refs = /* @__PURE__ */ new Map();
-  const text = observationText(obs);
-  const candidateFiles = /* @__PURE__ */ new Map();
-  for (const rawPath of obs.filesModified ?? []) {
-    const file = lookup.findFile(normalizeCodePath(rawPath));
-    if (!file) continue;
-    candidateFiles.set(file.id, file);
-    const ref = fileRef(obs.projectId, obs, file);
-    refs.set(ref.id, ref);
+async function writeCanonicalWorkflow(input) {
+  const paths = getKnowledgeWorkspacePaths(input.workspace);
+  const workflow = materializeWorkflow({
+    ...input.workflow,
+    workspaceId: input.workspace.id,
+    sourcePath: normalizeSourcePath(input.workflow.sourcePath)
+  });
+  const filePath = resolveKnowledgeWorkspaceFile(input.workspace, workflow.sourcePath);
+  const content = renderWorkflowMarkdown(workflow);
+  await withFileLock(paths.root, async () => {
+    await fs7.mkdir(path10.dirname(filePath), { recursive: true });
+    await atomicWriteFile(filePath, content);
+  });
+  const store = await storeFor2(input.workspace);
+  return store.upsertWorkflow({ ...workflow, contentHash: hash3(content) });
+}
+async function markdownFiles2(directory) {
+  let entries;
+  try {
+    entries = await fs7.readdir(directory, { withFileTypes: true });
+  } catch {
+    return [];
   }
-  const hintedFileIds = new Set(candidateFiles.keys());
-  const symbolNames = hintedFileIds.size > 0 ? identifierCandidates(text) : codeIdentifierCandidates(text);
-  const symbols = lookup.findSymbols(symbolNames, [...hintedFileIds]);
-  const symbolsByName = /* @__PURE__ */ new Map();
-  for (const symbol of symbols) {
-    const group = symbolsByName.get(symbol.name) ?? [];
-    group.push(symbol);
-    symbolsByName.set(symbol.name, group);
+  const files = [];
+  for (const entry of entries) {
+    const absolutePath = path10.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await markdownFiles2(absolutePath));
+    } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+      files.push(absolutePath);
+    }
+  }
+  return files;
+}
+async function syncCanonicalWorkflows(workspace) {
+  const paths = getKnowledgeWorkspacePaths(workspace);
+  const store = await storeFor2(workspace);
+  const workflows = [];
+  const errors = [];
+  for (const absolutePath of await markdownFiles2(paths.workflows)) {
+    const sourcePath = path10.relative(paths.root, absolutePath).split(path10.sep).join("/");
+    try {
+      const raw = await fs7.readFile(absolutePath, "utf8");
+      const workflow = parseWorkflowMarkdown(raw, { workspaceId: workspace.id, sourcePath });
+      workflows.push(store.upsertWorkflow(workflow));
+    } catch (error) {
+      errors.push({
+        sourcePath,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
-  for (const group of symbolsByName.values()) {
-    const candidates = group.length === 1 ? group : [];
-    for (const symbol of candidates) {
-      if (!mentionsSymbol(text, symbol)) continue;
-      const file = candidateFiles.get(symbol.fileId) ?? lookup.findFile(symbol.path);
-      if (!file) continue;
-      candidateFiles.set(file.id, file);
-      const ref = symbolRef(obs.projectId, obs, file, symbol);
-      refs.set(ref.id, ref);
+  return { workflows, errors };
+}
+function inferTaskLenses(value) {
+  const text = value.toLowerCase();
+  return Object.entries(LENS_TERMS).filter(([, terms]) => terms.some((term) => text.includes(term))).map(([lens]) => lens);
+}
+function taskScore(workflow, task) {
+  const text = task.toLowerCase();
+  let score = 0;
+  const reasons = [];
+  for (const lens of workflow.taskLenses) {
+    const terms = LENS_TERMS[lens.toLowerCase()] ?? [lens.toLowerCase()];
+    if (terms.some((term) => text.includes(term))) {
+      score += 20;
+      reasons.push("matches " + lens + " workflow");
     }
   }
-  return [...refs.values()];
+  for (const trigger of workflow.triggers) {
+    const term = trigger.toLowerCase().trim();
+    if (term.length >= 2 && text.includes(term)) {
+      score += 8;
+      reasons.push('matches trigger "' + trigger + '"');
+    }
+  }
+  return { score, reasons: [...new Set(reasons)] };
 }
-function createStoreLookup(store, projectId) {
-  return {
-    findFile: (path8) => store.getFile(projectId, path8) ?? void 0,
-    findSymbols: (names, hintedFileIds) => store.findSymbolsByNames(projectId, names, hintedFileIds)
+function selectWorkflows(input) {
+  const selected = input.workflows.filter((workflow) => workflow.status === "active").map((workflow) => {
+    const match = taskScore(workflow, input.task);
+    const cautions = input.store && input.projectId ? input.store.recentFailureCautions(input.projectId, workflow.id) : [];
+    return {
+      workflow,
+      score: match.score,
+      reasons: match.reasons,
+      firstPhase: workflow.phases[0],
+      cautions
+    };
+  }).filter((item) => item.score > 0).sort((left, right) => right.score - left.score || left.workflow.title.localeCompare(right.workflow.title));
+  return selected.slice(0, Math.max(1, Math.min(input.limit ?? 2, 2)));
+}
+function importedWorkflowSpec(input) {
+  const entry = new WorkflowSyncer().parseWindsurfWorkflow(input.sourceName, input.raw);
+  const content = entry.content.trim() || "## Execute\n\nFollow the imported workflow.";
+  const lenses = inferTaskLenses(entry.name + "\n" + entry.description + "\n" + content);
+  const createdAt = now2();
+  const sourcePath = "workflows/" + slug(entry.name) + ".md";
+  const spec = {
+    id: "workflow:" + hash3(input.workspace.id + ":" + sourcePath).slice(0, 24),
+    workspaceId: input.workspace.id,
+    title: titleFromName(entry.name),
+    description: entry.description || "Imported from " + input.sourcePath,
+    status: "active",
+    version: 1,
+    taskLenses: lenses,
+    triggers: lenses,
+    assumptions: [],
+    requiredContext: [],
+    guardrails: [],
+    allowedTools: [],
+    phases: phasesFromBody(content),
+    verificationGates: [],
+    claimIds: [],
+    evidenceRefs: [],
+    codeRefs: [],
+    compatibleAgents: WORKFLOW_ADAPTER_TARGETS,
+    body: content,
+    sourcePath,
+    sourceHash: "",
+    contentHash: "",
+    createdAt,
+    updatedAt: createdAt,
+    importedFrom: input.sourcePath.replace(/\\/g, "/")
   };
-}
-function createSnapshotLookup(files, symbols) {
-  const filesByPath = new Map(files.map((file) => [normalizeCodePath(file.path), file]));
-  const symbolsByName = /* @__PURE__ */ new Map();
-  for (const symbol of symbols) {
-    const group = symbolsByName.get(symbol.name) ?? [];
-    group.push(symbol);
-    symbolsByName.set(symbol.name, group);
+  return materializeWorkflow(spec);
+}
+async function importWindsurfWorkflows(input) {
+  const sourceDirectory = path10.join(path10.resolve(input.projectRoot), ".windsurf", "workflows");
+  const paths = getKnowledgeWorkspacePaths(input.workspace);
+  const imported = [];
+  const skipped = [];
+  let entries;
+  try {
+    entries = await fs7.readdir(sourceDirectory, { withFileTypes: true });
+  } catch {
+    return { imported, skipped };
   }
-  return {
-    findFile: (path8) => filesByPath.get(normalizeCodePath(path8)),
-    findSymbols: (names, hintedFileIds) => {
-      const hinted = new Set(hintedFileIds);
-      const found = [];
-      for (const name of names) {
-        const candidates = symbolsByName.get(name) ?? [];
-        found.push(...hinted.size > 0 ? candidates.filter((symbol) => hinted.has(symbol.fileId)) : candidates);
+  for (const entry of entries.filter((item) => item.isFile() && item.name.toLowerCase().endsWith(".md"))) {
+    const originalPath = path10.join(sourceDirectory, entry.name);
+    const sourcePath = path10.relative(path10.resolve(input.projectRoot), originalPath).split(path10.sep).join("/");
+    try {
+      const raw = await fs7.readFile(originalPath, "utf8");
+      const workflow = importedWorkflowSpec({
+        workspace: input.workspace,
+        sourceName: entry.name,
+        sourcePath,
+        raw
+      });
+      const targetPath = resolveKnowledgeWorkspaceFile(input.workspace, workflow.sourcePath);
+      try {
+        await fs7.access(targetPath);
+        skipped.push({ sourcePath, reason: "canonical workflow already exists and was preserved" });
+        continue;
+      } catch {
       }
-      return found;
+      imported.push(await writeCanonicalWorkflow({ workspace: input.workspace, workflow }));
+    } catch (error) {
+      skipped.push({
+        sourcePath,
+        reason: error instanceof Error ? error.message : String(error)
+      });
     }
-  };
+  }
+  await fs7.mkdir(paths.workflows, { recursive: true });
+  return { imported, skipped };
+}
+function isWithin2(root, candidate) {
+  const relative2 = path10.relative(root, candidate);
+  return relative2 !== "" && relative2 !== ".." && !relative2.startsWith(".." + path10.sep) && !path10.isAbsolute(relative2);
+}
+function adapterRelativePath(workflow, agent) {
+  const name = "memorix-workflow-" + slug(workflow.id.replace(/^workflow:/, ""));
+  if (agent === "codex") return ".agents/skills/" + name + "/SKILL.md";
+  if (agent === "claude-code") return ".claude/skills/" + name + "/SKILL.md";
+  if (agent === "cursor") return ".cursor/rules/" + name + ".mdc";
+  return ".windsurf/workflows/" + name + ".md";
+}
+function adapterMarker(workflow) {
+  return '<!-- memorix:workflow-adapter id="' + workflow.id + '" -->';
+}
+function adapterContent(workflow, agent) {
+  const marker = adapterMarker(workflow);
+  const firstPhase = workflow.phases[0];
+  const gates = workflow.verificationGates.length ? workflow.verificationGates : firstPhase.verificationGates;
+  if (agent === "codex" || agent === "claude-code") {
+    return matter3.stringify([
+      marker,
+      "",
+      "# " + workflow.title,
+      "",
+      workflow.description,
+      "",
+      "## Start",
+      "",
+      firstPhase.instructions || firstPhase.title,
+      "",
+      "## Verification",
+      "",
+      ...gates.length ? gates.map((gate) => "- " + gate) : ["- Follow the project verification standards."],
+      "",
+      "## Full workflow",
+      "",
+      workflow.body.trim(),
+      ""
+    ].join("\n"), {
+      name: "memorix-workflow-" + slug(workflow.id.replace(/^workflow:/, "")),
+      description: workflow.description || workflow.title
+    });
+  }
+  if (agent === "cursor") {
+    return matter3.stringify([
+      marker,
+      "",
+      "# " + workflow.title,
+      "",
+      workflow.body.trim(),
+      ""
+    ].join("\n"), {
+      description: workflow.description || workflow.title,
+      globs: "",
+      alwaysApply: false
+    });
+  }
+  return matter3.stringify([
+    marker,
+    "",
+    "# " + workflow.title,
+    "",
+    workflow.body.trim(),
+    ""
+  ].join("\n"), {
+    description: workflow.description || workflow.title
+  });
 }
-async function bindObservationToCode(store, obs) {
-  const refs = resolveObservationCodeRefs(obs, createStoreLookup(store, obs.projectId));
-  store.replaceObservationRefs(obs.projectId, obs.id, refs);
-  return refs;
+function isWorkflowAdapterTarget(agent) {
+  return WORKFLOW_ADAPTER_TARGETS.includes(agent);
 }
-async function backfillMissingObservationCodeRefs(store, observations2) {
-  let observationsBackfilled = 0;
-  let refsBackfilled = 0;
-  const boundObservationIdsByProject = /* @__PURE__ */ new Map();
-  const lookupByProject = /* @__PURE__ */ new Map();
-  for (const projectId of new Set(observations2.map((observation) => observation.projectId))) {
-    boundObservationIdsByProject.set(
-      projectId,
-      new Set(store.listProjectObservationRefs(projectId).map((ref) => ref.observationId))
-    );
-    lookupByProject.set(
-      projectId,
-      createSnapshotLookup(store.listFiles(projectId), store.listSymbols(projectId))
-    );
+async function previewWorkflowAdapter(input) {
+  if (!isWorkflowAdapterTarget(input.agent)) {
+    return {
+      agent: input.agent,
+      workflowId: input.workflow.id,
+      status: "unsupported",
+      reason: "This agent has no safe native workflow adapter. Use Memorix Project Context instead."
+    };
   }
-  const refsToInsert = [];
-  for (const observation of observations2) {
-    if (boundObservationIdsByProject.get(observation.projectId)?.has(observation.id)) continue;
-    if ((observation.filesModified?.length ?? 0) === 0 && codeIdentifierCandidates(observationText(observation)).length === 0) {
-      continue;
-    }
-    const lookup = lookupByProject.get(observation.projectId);
-    if (!lookup) continue;
-    const refs = resolveObservationCodeRefs(observation, lookup);
-    if (refs.length === 0) continue;
-    observationsBackfilled += 1;
-    refsBackfilled += refs.length;
-    refsToInsert.push(...refs);
+  if (input.workflow.compatibleAgents.length > 0 && !input.workflow.compatibleAgents.includes(input.agent)) {
+    return {
+      agent: input.agent,
+      workflowId: input.workflow.id,
+      status: "unsupported",
+      reason: "The canonical workflow does not declare compatibility with this agent."
+    };
   }
-  store.upsertObservationRefs(refsToInsert);
+  const projectRoot = path10.resolve(input.projectRoot);
+  const targetPath = path10.resolve(projectRoot, adapterRelativePath(input.workflow, input.agent));
+  if (!isWithin2(projectRoot, targetPath)) {
+    throw new Error("Workflow adapter target escapes the project root");
+  }
+  const content = adapterContent(input.workflow, input.agent);
+  let existing;
+  try {
+    existing = await fs7.readFile(targetPath, "utf8");
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+    if (code !== "ENOENT") throw error;
+  }
+  if (existing === void 0) {
+    return { agent: input.agent, workflowId: input.workflow.id, targetPath, content, status: "create", reason: "No existing project adapter file." };
+  }
+  if (existing === content) {
+    return { agent: input.agent, workflowId: input.workflow.id, targetPath, content, status: "unchanged", reason: "Existing Memorix adapter already matches the canonical workflow." };
+  }
+  if (existing.includes(adapterMarker(input.workflow))) {
+    return { agent: input.agent, workflowId: input.workflow.id, targetPath, content, status: "update", reason: "Existing Memorix-owned adapter will be updated." };
+  }
+  return { agent: input.agent, workflowId: input.workflow.id, targetPath, content, status: "conflict", reason: "A user-owned project file already occupies this adapter path." };
+}
+async function applyWorkflowAdapter(input) {
+  const initial = await previewWorkflowAdapter(input);
+  if (initial.status === "unsupported" || initial.status === "conflict" || initial.status === "unchanged") {
+    return initial;
+  }
+  const projectRoot = path10.resolve(input.projectRoot);
+  return withFileLock(projectRoot, async () => {
+    const current = await previewWorkflowAdapter(input);
+    if (current.status !== "create" && current.status !== "update") return current;
+    await fs7.mkdir(path10.dirname(current.targetPath), { recursive: true });
+    await atomicWriteFile(current.targetPath, current.content);
+    return current;
+  });
+}
+async function recordWorkflowRun(input) {
+  const store = await storeFor2(input.workspace);
+  const workflow = store.getWorkflow(input.run.workflowId);
+  if (!workflow || workflow.workspaceId !== input.workspace.id) {
+    throw new Error("Workflow was not found for this workspace");
+  }
+  if (!input.run.task.trim()) throw new Error("Workflow run task is required");
+  return store.recordRun(input.run);
+}
+async function selectWorkspaceWorkflows(input) {
+  const synced = await syncCanonicalWorkflows(input.workspace);
+  const store = await storeFor2(input.workspace);
   return {
-    observationsScanned: observations2.length,
-    observationsBackfilled,
-    refsBackfilled
+    selections: selectWorkflows({
+      workflows: synced.workflows,
+      task: input.task,
+      projectId: input.workspace.projectId,
+      store,
+      limit: input.limit
+    }),
+    errors: synced.errors
   };
 }
-var init_binder = __esm({
-  "src/codegraph/binder.ts"() {
+var KNOWN_AGENTS, WORKFLOW_ADAPTER_TARGETS, STATUS_VALUES, LENS_TERMS;
+var init_workflows = __esm({
+  "src/knowledge/workflows.ts"() {
     "use strict";
     init_esm_shims();
-    init_ids();
+    init_file_lock();
+    init_workflow_sync();
+    init_workspace();
+    init_workflow_store();
+    KNOWN_AGENTS = [
+      "windsurf",
+      "cursor",
+      "claude-code",
+      "codex",
+      "copilot",
+      "antigravity",
+      "gemini-cli",
+      "openclaw",
+      "hermes",
+      "omp",
+      "kiro",
+      "opencode",
+      "trae"
+    ];
+    WORKFLOW_ADAPTER_TARGETS = [
+      "codex",
+      "claude-code",
+      "cursor",
+      "windsurf"
+    ];
+    STATUS_VALUES = ["draft", "active", "archived"];
+    LENS_TERMS = {
+      release: ["release", "publish", "npm", "version", "\u53D1\u7248", "\u53D1\u5E03"],
+      bugfix: ["bug", "fix", "error", "failure", "issue", "repair", "\u4FEE\u590D", "\u62A5\u9519", "\u6545\u969C"],
+      migration: ["migration", "migrate", "upgrade", "\u8FC1\u79FB", "\u5347\u7EA7"],
+      review: ["review", "audit", "pr", "code review", "\u5BA1\u67E5", "\u8BC4\u5BA1"],
+      onboarding: ["onboard", "onboarding", "understand", "introduce", "\u63A5\u624B", "\u4E86\u89E3"],
+      refactor: ["refactor", "cleanup", "restructure", "\u91CD\u6784", "\u6574\u7406"],
+      test: ["test", "verify", "smoke", "\u6D4B\u8BD5", "\u9A8C\u8BC1"]
+    };
   }
 });
 
@@ -4522,12 +7715,12 @@ var fastembed_provider_exports = {};
 __export(fastembed_provider_exports, {
   FastEmbedProvider: () => FastEmbedProvider
 });
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import { readFile, writeFile, mkdir } from "fs/promises";
 import { join as join3 } from "path";
 import { homedir as homedir6 } from "os";
 function textHash(text) {
-  return createHash3("sha256").update(text).digest("hex").slice(0, 16);
+  return createHash10("sha256").update(text).digest("hex").slice(0, 16);
 }
 async function loadDiskCache() {
   try {
@@ -4579,15 +7772,15 @@ var init_fastembed_provider = __esm({
         return new _FastEmbedProvider(model);
       }
       async embed(text) {
-        const hash = textHash(text);
-        const cached = cache.get(hash);
+        const hash4 = textHash(text);
+        const cached = cache.get(hash4);
         if (cached) return cached;
         const raw = await this.model.queryEmbed(text);
         const result = Array.from(raw);
         if (result.length !== this.dimensions) {
           throw new Error(`Expected ${this.dimensions}d embedding, got ${result.length}d`);
         }
-        this.cacheSet(hash, result);
+        this.cacheSet(hash4, result);
         return result;
       }
       async embedBatch(texts) {
@@ -4595,8 +7788,8 @@ var init_fastembed_provider = __esm({
         const uncachedIndices = [];
         const uncachedTexts = [];
         for (let i = 0; i < texts.length; i++) {
-          const hash = textHash(texts[i]);
-          const cached = cache.get(hash);
+          const hash4 = textHash(texts[i]);
+          const cached = cache.get(hash4);
           if (cached) {
             results[i] = cached;
           } else {
@@ -4620,12 +7813,12 @@ var init_fastembed_provider = __esm({
         }
         return results;
       }
-      cacheSet(hash, value) {
+      cacheSet(hash4, value) {
         if (cache.size >= MAX_CACHE_SIZE) {
           const firstKey = cache.keys().next().value;
           if (firstKey !== void 0) cache.delete(firstKey);
         }
-        cache.set(hash, value);
+        cache.set(hash4, value);
         diskCacheDirty = true;
       }
     };
@@ -4724,7 +7917,7 @@ var api_provider_exports = {};
 __export(api_provider_exports, {
   APIEmbeddingProvider: () => APIEmbeddingProvider
 });
-import { createHash as createHash4 } from "crypto";
+import { createHash as createHash11 } from "crypto";
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
 import { join as join4 } from "path";
 import { homedir as homedir7 } from "os";
@@ -4740,7 +7933,7 @@ function cacheNamespace(config) {
   ].join("|");
 }
 function textHash2(text, namespace) {
-  return createHash4("sha256").update(`${namespace}\0${text}`).digest("hex").slice(0, 16);
+  return createHash11("sha256").update(`${namespace}\0${text}`).digest("hex").slice(0, 16);
 }
 async function loadDiskCache2() {
   if (diskCacheLoaded) return;
@@ -4894,12 +8087,12 @@ function scheduleDiskSave() {
     diskSaveTimer = null;
   }, DISK_SAVE_DEBOUNCE_MS);
 }
-function cacheSet(hash, value) {
+function cacheSet(hash4, value) {
   if (cache3.size >= MAX_CACHE_SIZE3) {
     const firstKey = cache3.keys().next().value;
     if (firstKey !== void 0) cache3.delete(firstKey);
   }
-  cache3.set(hash, value);
+  cache3.set(hash4, value);
   diskCacheDirty2 = true;
 }
 function resolveEnvEmbeddingApiKey() {
@@ -4946,18 +8139,18 @@ async function fetchWithRetry(url, apiKey, body, attempt = 0) {
   if (response.ok) {
     return response.json();
   }
-  if ((response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES) {
+  if ((response.status === 429 || response.status >= 500) && attempt < MAX_RETRIES2) {
     const delay = BASE_DELAY_MS * Math.pow(2, attempt);
     const retryAfter = response.headers.get("retry-after");
     const waitMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : delay;
-    console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES} in ${waitMs}ms`);
+    console.error(`[memorix] Embedding API ${response.status}, retry ${attempt + 1}/${MAX_RETRIES2} in ${waitMs}ms`);
     await new Promise((resolve) => setTimeout(resolve, waitMs));
     return fetchWithRetry(url, apiKey, body, attempt + 1);
   }
   const errorText2 = await response.text().catch(() => "unknown error");
   throw new Error(`Embedding API error (${response.status}): ${errorText2}`);
 }
-var CACHE_DIR2, CACHE_FILE2, DIMS_CACHE_FILE, CACHE_META_FILE, cache3, MAX_CACHE_SIZE3, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES, BASE_DELAY_MS, APIEmbeddingProvider;
+var CACHE_DIR2, CACHE_FILE2, DIMS_CACHE_FILE, CACHE_META_FILE, cache3, MAX_CACHE_SIZE3, diskCacheDirty2, diskSaveTimer, diskCacheLoaded, diskCacheLoadPromise, MAX_INPUT_CHARS, MAX_CONCURRENCY, DISK_SAVE_DEBOUNCE_MS, DEFAULT_MAX_BATCH_SIZE, DASHSCOPE_MAX_BATCH_SIZE, MAX_RETRIES2, BASE_DELAY_MS, APIEmbeddingProvider;
 var init_api_provider = __esm({
   "src/embedding/api-provider.ts"() {
     "use strict";
@@ -4977,7 +8170,7 @@ var init_api_provider = __esm({
     DISK_SAVE_DEBOUNCE_MS = 5e3;
     DEFAULT_MAX_BATCH_SIZE = 2048;
     DASHSCOPE_MAX_BATCH_SIZE = 10;
-    MAX_RETRIES = 3;
+    MAX_RETRIES2 = 3;
     BASE_DELAY_MS = 500;
     APIEmbeddingProvider = class _APIEmbeddingProvider {
       name;
@@ -5070,9 +8263,9 @@ var init_api_provider = __esm({
       }
       async embed(text) {
         const normalized = normalizeText(text);
-        const hash = textHash2(normalized, this.cacheKeyNamespace);
+        const hash4 = textHash2(normalized, this.cacheKeyNamespace);
         if (diskCacheLoaded) {
-          const cached = cache3.get(hash);
+          const cached = cache3.get(hash4);
           if (cached) return cached;
         }
         const apiCall = async () => {
@@ -5098,7 +8291,7 @@ var init_api_provider = __esm({
         let embedding;
         if (!diskCacheLoaded && diskCacheLoadPromise) {
           const cacheRace = diskCacheLoadPromise.then(() => {
-            const cached = cache3.get(hash);
+            const cached = cache3.get(hash4);
             if (cached) return cached;
             return null;
           });
@@ -5116,7 +8309,7 @@ var init_api_provider = __esm({
         } else {
           embedding = await apiCall();
         }
-        cacheSet(hash, embedding);
+        cacheSet(hash4, embedding);
         scheduleDiskSave();
         return embedding;
       }
@@ -5127,8 +8320,8 @@ var init_api_provider = __esm({
         const uncachedIndices = [];
         const uncachedTexts = [];
         for (let i = 0; i < normalizedTexts.length; i++) {
-          const hash = textHash2(normalizedTexts[i], this.cacheKeyNamespace);
-          const cached = cache3.get(hash);
+          const hash4 = textHash2(normalizedTexts[i], this.cacheKeyNamespace);
+          const cached = cache3.get(hash4);
           if (cached) {
             results[i] = cached;
           } else {
@@ -5198,8 +8391,8 @@ var init_api_provider = __esm({
       async getCachedEmbeddings(texts) {
         await ensureDiskCacheLoaded();
         return texts.map((text) => {
-          const hash = textHash2(normalizeText(text), this.cacheKeyNamespace);
-          return cache3.get(hash) ?? null;
+          const hash4 = textHash2(normalizeText(text), this.cacheKeyNamespace);
+          return cache3.get(hash4) ?? null;
         });
       }
       getStats() {
@@ -5228,12 +8421,12 @@ __export(provider_exports2, {
   resetProvider: () => resetProvider
 });
 function warnOnce(message) {
-  const now = Date.now();
-  if (message === lastEmbeddingWarning && now - lastEmbeddingWarningAt < WARNING_COOLDOWN_MS) {
+  const now3 = Date.now();
+  if (message === lastEmbeddingWarning && now3 - lastEmbeddingWarningAt < WARNING_COOLDOWN_MS) {
     return;
   }
   lastEmbeddingWarning = message;
-  lastEmbeddingWarningAt = now;
+  lastEmbeddingWarningAt = now3;
   console.error(message);
 }
 function getEmbeddingMode2() {
@@ -5512,8 +8705,8 @@ var init_types = __esm({
 });
 
 // src/store/mini-skill-store.ts
-import path6 from "path";
-import fs3 from "fs";
+import path11 from "path";
+import fs8 from "fs";
 function isMiniSkillStoreInitialized() {
   return _store2 !== null;
 }
@@ -5532,18 +8725,6 @@ var init_mini_skill_store = __esm({
   }
 });
 
-// src/compact/token-budget.ts
-import { countTokens, isWithinTokenLimit } from "gpt-tokenizer";
-function countTextTokens(text) {
-  return countTokens(text);
-}
-var init_token_budget = __esm({
-  "src/compact/token-budget.ts"() {
-    "use strict";
-    init_esm_shims();
-  }
-});
-
 // src/skills/mini-skills.ts
 function resolveKnowledgeLayer(documentType, sourceDetail, source) {
   if (documentType === "mini-skill") return "promoted";
@@ -5939,8 +9120,8 @@ __export(aliases_exports, {
   resetAliasCache: () => resetAliasCache,
   resolveAliases: () => resolveAliases
 });
-import { promises as fs4 } from "fs";
-import path7 from "path";
+import { promises as fs9 } from "fs";
+import path12 from "path";
 import os from "os";
 function normalizePath(p) {
   let normalized = p.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -5955,12 +9136,12 @@ function idPriority(id) {
   return 2;
 }
 function getRegistryPath(baseDir) {
-  return path7.join(baseDir ?? registryDir ?? DEFAULT_DATA_DIR, ALIAS_FILE);
+  return path12.join(baseDir ?? registryDir ?? DEFAULT_DATA_DIR, ALIAS_FILE);
 }
 async function loadRegistry(baseDir) {
   if (registryCache) return registryCache;
   try {
-    const data = await fs4.readFile(getRegistryPath(baseDir), "utf-8");
+    const data = await fs9.readFile(getRegistryPath(baseDir), "utf-8");
     const parsed = JSON.parse(data);
     if (parsed.version === 1 && Array.isArray(parsed.groups)) {
       registryCache = parsed;
@@ -5974,8 +9155,8 @@ async function loadRegistry(baseDir) {
 async function saveRegistry(baseDir) {
   if (!registryCache) return;
   const filePath = getRegistryPath(baseDir);
-  await fs4.mkdir(path7.dirname(filePath), { recursive: true });
-  await fs4.writeFile(filePath, JSON.stringify(registryCache, null, 2), "utf-8");
+  await fs9.mkdir(path12.dirname(filePath), { recursive: true });
+  await fs9.writeFile(filePath, JSON.stringify(registryCache, null, 2), "utf-8");
 }
 function findMatchingGroup(registry, projectInfo) {
   const normalizedRoot = normalizePath(projectInfo.rootPath);
@@ -6132,7 +9313,7 @@ var init_aliases = __esm({
   "src/project/aliases.ts"() {
     "use strict";
     init_esm_shims();
-    DEFAULT_DATA_DIR = process.env.MEMORIX_DATA_DIR || path7.join(os.homedir(), ".memorix", "data");
+    DEFAULT_DATA_DIR = process.env.MEMORIX_DATA_DIR || path12.join(os.homedir(), ".memorix", "data");
     ALIAS_FILE = ".project-aliases.json";
     registryCache = null;
     registryDir = null;
@@ -6406,11 +9587,11 @@ import { create, insert as insert2, search, remove as remove2, update, count, ge
 function getLastSearchMode(projectId) {
   return lastSearchModeByProject.get(projectId ?? SEARCH_MODE_DEFAULT_KEY) ?? "fulltext";
 }
-function makeOramaObservationId(projectId, observationId) {
-  return `obs-${encodeURIComponent(projectId)}-${observationId}`;
+function makeOramaObservationId(projectId, observationId2) {
+  return `obs-${encodeURIComponent(projectId)}-${observationId2}`;
 }
-function makeEntryKey(projectId, observationId) {
-  return `${projectId ?? ""}::${observationId}`;
+function makeEntryKey(projectId, observationId2) {
+  return `${projectId ?? ""}::${observationId2}`;
 }
 function rememberObservationDoc(doc) {
   const publicDoc = { ...doc };
@@ -6639,9 +9820,9 @@ async function hydrateIndexForStartup(observations2) {
 function getDeferredCachedVectorHydration() {
   return deferredCachedVectorHydration;
 }
-function hasObservationVector(projectId, observationId) {
+function hasObservationVector(projectId, observationId2) {
   if (!db || !embeddingEnabled || embeddingDimensions === null) return false;
-  const document = getByID(db, makeOramaObservationId(projectId, observationId));
+  const document = getByID(db, makeOramaObservationId(projectId, observationId2));
   return Array.isArray(document?.embedding) && document.embedding.length === embeddingDimensions && document.embedding.every(Number.isFinite);
 }
 async function insertObservation(doc) {
@@ -6664,8 +9845,8 @@ async function searchObservations(options) {
   const t0 = perf ? performance.now() : 0;
   const mark = (label) => {
     if (perf) {
-      const now = performance.now();
-      process.stderr.write(`  [search-perf] ${label}: ${(now - t0).toFixed(0)}ms
+      const now3 = performance.now();
+      process.stderr.write(`  [search-perf] ${label}: ${(now3 - t0).toFixed(0)}ms
 `);
     }
   };
@@ -7129,13 +10310,13 @@ async function getTimeline(anchorId, projectId, depthBefore = 3, depthAfter = 3)
 }
 async function recordAccessBatch(hitDocs) {
   const database = await getDb();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const now3 = (/* @__PURE__ */ new Date()).toISOString();
   for (const { id, doc } of hitDocs) {
     try {
       await update(database, id, {
         ...doc,
         accessCount: (doc.accessCount ?? 0) + 1,
-        lastAccessedAt: now
+        lastAccessedAt: now3
       });
     } catch {
     }
@@ -7333,10 +10514,10 @@ __export(observations_exports, {
   withFreshObservations: () => withFreshObservations
 });
 function logEmbeddingFailureOnce(key, message) {
-  const now = Date.now();
+  const now3 = Date.now();
   const last = embeddingFailureLogTimestamps.get(key) ?? 0;
-  if (now - last < EMBEDDING_FAILURE_LOG_COOLDOWN_MS) return;
-  embeddingFailureLogTimestamps.set(key, now);
+  if (now3 - last < EMBEDDING_FAILURE_LOG_COOLDOWN_MS) return;
+  embeddingFailureLogTimestamps.set(key, now3);
   console.error(message);
 }
 function normalizeEmbeddingFailure(error) {
@@ -7382,6 +10563,20 @@ async function bindObservationCodeRefsBestEffort(observation) {
   } catch {
   }
 }
+function queueClaimDerivation(observation) {
+  const dataDir = projectDir;
+  const isExplicit = observation.sourceDetail === "explicit";
+  const isGit = observation.source === "git" || observation.sourceDetail === "git-ingest";
+  if (!dataDir || !isExplicit && !isGit) return;
+  try {
+    enqueueClaimDerivation({
+      dataDir,
+      projectId: observation.projectId,
+      observationId: observation.id
+    });
+  } catch {
+  }
+}
 function isVectorCompatibleWithCurrentIndex(embedding) {
   if (!embedding) return false;
   const vectorDimensions = getVectorDimensions();
@@ -7429,7 +10624,7 @@ async function withFreshObservations(fn) {
   return fn();
 }
 async function storeObservation(input) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const now3 = (/* @__PURE__ */ new Date()).toISOString();
   input = { ...input, title: sanitizeCredentials(input.title), narrative: sanitizeCredentials(input.narrative), facts: input.facts?.map(sanitizeCredentials) };
   await ensureFreshObservations();
   if (input.topicKey) {
@@ -7437,7 +10632,7 @@ async function storeObservation(input) {
       (o) => o.topicKey === input.topicKey && o.projectId === input.projectId
     );
     if (existing) {
-      return { observation: await upsertObservation(existing, input, now), upserted: true };
+      return { observation: await upsertObservation(existing, input, now3), upserted: true };
     }
   }
   const contentForExtraction = [input.title, input.narrative, ...input.facts ?? []].join(" ");
@@ -7489,7 +10684,7 @@ async function storeObservation(input) {
           filesModified: enrichedFiles,
           concepts: enrichedConcepts,
           tokens,
-          createdAt: now,
+          createdAt: now3,
           projectId: input.projectId,
           hasCausalLanguage: extracted.hasCausalLanguage,
           topicKey: input.topicKey,
@@ -7535,7 +10730,7 @@ async function storeObservation(input) {
         filesModified: enrichedFiles,
         concepts: enrichedConcepts,
         tokens,
-        createdAt: now,
+        createdAt: now3,
         projectId: input.projectId,
         hasCausalLanguage: extracted.hasCausalLanguage,
         topicKey: input.topicKey,
@@ -7565,7 +10760,7 @@ async function storeObservation(input) {
       filesModified: enrichedFiles.join("\n"),
       concepts: enrichedConcepts.map((c) => c.replace(/-/g, " ")).join(", "),
       tokens,
-      createdAt: now,
+      createdAt: now3,
       projectId: input.projectId,
       accessCount: 0,
       lastAccessedAt: "",
@@ -7578,9 +10773,10 @@ async function storeObservation(input) {
   };
   await assignAndPersist();
   if (upsertedInsideLock) {
-    return { observation: await upsertObservation(observation, input, now), upserted: true };
+    return { observation: await upsertObservation(observation, input, now3), upserted: true };
   }
   await bindObservationCodeRefsBestEffort(observation);
+  queueClaimDerivation(observation);
   const obsId = observation.id;
   vectorMissingIds.add(obsId);
   const searchableText = [input.title, input.narrative, ...input.facts ?? []].join(" ");
@@ -7625,7 +10821,7 @@ async function storeObservation(input) {
   });
   return { observation, upserted: false };
 }
-async function upsertObservation(existing, input, now) {
+async function upsertObservation(existing, input, now3) {
   input = { ...input, title: sanitizeCredentials(input.title), narrative: sanitizeCredentials(input.narrative), facts: input.facts?.map(sanitizeCredentials) };
   const contentForExtraction = [input.title, input.narrative, ...input.facts ?? []].join(" ");
   const extracted = extractEntities(contentForExtraction);
@@ -7645,7 +10841,7 @@ async function upsertObservation(existing, input, now) {
   existing.filesModified = enrichedFiles;
   existing.concepts = enrichedConcepts;
   existing.tokens = tokens;
-  existing.updatedAt = now;
+  existing.updatedAt = now3;
   existing.hasCausalLanguage = extracted.hasCausalLanguage;
   existing.revisionCount = (existing.revisionCount ?? 1) + 1;
   existing.status = "active";
@@ -7694,6 +10890,7 @@ async function upsertObservation(existing, input, now) {
     await store.update(existing);
   }
   await bindObservationCodeRefsBestEffort(existing);
+  queueClaimDerivation(existing);
   const searchableText = [input.title, input.narrative, ...input.facts ?? []].join(" ");
   const obsId = existing.id;
   vectorMissingIds.add(obsId);
@@ -7736,7 +10933,7 @@ async function resolveObservations(ids, status = "resolved") {
   const resolved = [];
   const notFound = [];
   const changed = [];
-  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const now3 = (/* @__PURE__ */ new Date()).toISOString();
   for (const id of ids) {
     const obs = observations.find((o) => o.id === id);
     if (!obs) {
@@ -7744,7 +10941,7 @@ async function resolveObservations(ids, status = "resolved") {
       continue;
     }
     obs.status = status;
-    obs.updatedAt = now;
+    obs.updatedAt = now3;
     if (obs.progress) {
       obs.progress.status = status === "resolved" ? "completed" : obs.progress.status;
     }
@@ -7838,9 +11035,9 @@ function suggestTopicKey(type, title) {
       break;
     }
   }
-  const slug = title.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff\s-]/g, "").trim().replace(/\s+/g, "-").slice(0, 60);
-  if (!slug) return "";
-  return `${family}/${slug}`;
+  const slug2 = title.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff\s-]/g, "").trim().replace(/\s+/g, "-").slice(0, 60);
+  if (!slug2) return "";
+  return `${family}/${slug2}`;
 }
 async function reindexObservations() {
   if (observations.length === 0) return 0;
@@ -8078,6 +11275,7 @@ var init_observations = __esm({
     init_entity_extractor();
     init_provider2();
     init_secret_filter();
+    init_lifecycle();
     observations = [];
     nextId = 1;
     projectDir = null;
@@ -8110,16 +11308,23 @@ var MAINTENANCE_RESULT_PREFIX = "__MEMORIX_MAINTENANCE_RESULT__";
 var ISOLATED_MAINTENANCE_JOB_KINDS = [
   "retention-archive",
   "consolidation",
-  "codegraph-refresh"
+  "codegraph-refresh",
+  "claim-derive",
+  "claim-requalification",
+  "knowledge-compile",
+  "knowledge-lint",
+  "workflow-index"
 ];
 var DEFAULT_TIMEOUT_MS = 5 * 6e4;
 
 // src/runtime/project-maintenance.ts
 init_esm_shims();
+init_lifecycle();
 var DEFAULT_VECTOR_BATCH_SIZE = 12;
 var DEFAULT_RETENTION_BATCH_SIZE = 100;
 var DEFAULT_CONSOLIDATION_BATCH_SIZE = 200;
 var DEFAULT_CODEGRAPH_MAX_FILES = 5e3;
+var DEFAULT_CLAIM_DERIVATION_BATCH_SIZE = 100;
 var VECTOR_RETRY_DELAY_MS = 5e3;
 var DEDUP_PER_PAIR_TIMEOUT_MS = 5e3;
 function vectorBatchSize(payload) {
@@ -8150,6 +11355,31 @@ function codeGraphMaxFiles(payload) {
   if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_CODEGRAPH_MAX_FILES;
   return Math.min(2e4, Math.max(1, Math.floor(value)));
 }
+function claimDerivationBatchSize(payload) {
+  const value = payload.limit;
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_CLAIM_DERIVATION_BATCH_SIZE;
+  return Math.min(500, Math.max(1, Math.floor(value)));
+}
+function claimDerivationCursor(payload) {
+  const value = payload.cursor;
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+function observationId(payload) {
+  const value = payload.observationId;
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+function workspaceMode(payload) {
+  return payload.workspaceMode === "local" || payload.workspaceMode === "versioned" ? payload.workspaceMode : void 0;
+}
+async function loadWorkspaceForMaintenance(projectId, projectDir2, mode) {
+  const { loadKnowledgeWorkspace: loadKnowledgeWorkspace2 } = await Promise.resolve().then(() => (init_workspace(), workspace_exports));
+  if (mode) return loadKnowledgeWorkspace2({ projectId, dataDir: projectDir2, mode });
+  const [versioned, local] = await Promise.all([
+    loadKnowledgeWorkspace2({ projectId, dataDir: projectDir2, mode: "versioned" }),
+    loadKnowledgeWorkspace2({ projectId, dataDir: projectDir2, mode: "local" })
+  ]);
+  return versioned ?? local;
+}
 function withTimeout(promise, ms, label) {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
@@ -8236,7 +11466,7 @@ async function runAutomaticConsolidation(projectId, projectDir2, options) {
   }
   return nextCursor === void 0 ? {} : { nextCursor };
 }
-function createProjectMaintenanceHandler(projectId, projectDir2, projectRoot) {
+function createProjectMaintenanceHandler(projectId, projectDir2, projectRoot, options = {}) {
   return async (job) => {
     if (job.projectId !== projectId) {
       return { action: "reschedule", delayMs: VECTOR_RETRY_DELAY_MS };
@@ -8304,6 +11534,144 @@ function createProjectMaintenanceHandler(projectId, projectDir2, projectRoot) {
       });
       const activeObservations = await getObservationStore2().loadByProject(projectId, { status: "active" });
       await backfillMissingObservationCodeRefs2(store, activeObservations);
+      const snapshot = store.latestSnapshot(projectId);
+      enqueueClaimRequalification({
+        projectId,
+        dataDir: projectDir2,
+        source: "codegraph-refresh",
+        ...snapshot?.id ? { snapshotId: snapshot.id } : {},
+        ...options.maintenanceQueue ? { queue: options.maintenanceQueue } : {}
+      });
+      return { action: "complete" };
+    }
+    if (job.kind === "claim-derive") {
+      const id = observationId(job.payload);
+      if (!id) throw new Error("Claim derivation requires a positive observationId");
+      const [
+        { CodeGraphStore: CodeGraphStore2 },
+        { ClaimStore: ClaimStore2 },
+        { bindObservationToCode: bindObservationToCode2 },
+        { deriveLowRiskClaimsFromObservation: deriveLowRiskClaimsFromObservation2 },
+        { getObservationStore: getObservationStore2 }
+      ] = await Promise.all([
+        Promise.resolve().then(() => (init_store(), store_exports)),
+        Promise.resolve().then(() => (init_claim_store(), claim_store_exports)),
+        Promise.resolve().then(() => (init_binder(), binder_exports)),
+        Promise.resolve().then(() => (init_claims(), claims_exports)),
+        Promise.resolve().then(() => (init_obs_store(), obs_store_exports))
+      ]);
+      const observation = await getObservationStore2().getById(id);
+      if (!observation || observation.projectId !== projectId) return { action: "complete" };
+      const codeStore = new CodeGraphStore2();
+      const claimStore = new ClaimStore2();
+      await Promise.all([codeStore.init(projectDir2), claimStore.init(projectDir2)]);
+      await bindObservationToCode2(codeStore, observation);
+      const derived = deriveLowRiskClaimsFromObservation2(claimStore, observation, codeStore);
+      if (derived.length > 0) {
+        enqueueKnowledgeFollowups({
+          projectId,
+          dataDir: projectDir2,
+          source: "claim-derive:" + id,
+          includeCompile: true,
+          ...options.maintenanceQueue ? { queue: options.maintenanceQueue } : {}
+        });
+      }
+      return { action: "complete" };
+    }
+    if (job.kind === "claim-requalification") {
+      const [
+        { CodeGraphStore: CodeGraphStore2 },
+        { ClaimStore: ClaimStore2 },
+        { bindObservationToCode: bindObservationToCode2 },
+        { deriveLowRiskClaimsFromObservation: deriveLowRiskClaimsFromObservation2, requalifyClaimsForCodeState: requalifyClaimsForCodeState2 },
+        { getObservationStore: getObservationStore2 }
+      ] = await Promise.all([
+        Promise.resolve().then(() => (init_store(), store_exports)),
+        Promise.resolve().then(() => (init_claim_store(), claim_store_exports)),
+        Promise.resolve().then(() => (init_binder(), binder_exports)),
+        Promise.resolve().then(() => (init_claims(), claims_exports)),
+        Promise.resolve().then(() => (init_obs_store(), obs_store_exports))
+      ]);
+      const codeStore = new CodeGraphStore2();
+      const claimStore = new ClaimStore2();
+      await Promise.all([codeStore.init(projectDir2), claimStore.init(projectDir2)]);
+      const limit = claimDerivationBatchSize(job.payload);
+      const observations2 = await getObservationStore2().loadByProject(projectId, {
+        status: "active",
+        afterId: claimDerivationCursor(job.payload),
+        limit
+      });
+      let derivedCount = 0;
+      for (const observation of observations2) {
+        await bindObservationToCode2(codeStore, observation);
+        derivedCount += deriveLowRiskClaimsFromObservation2(claimStore, observation, codeStore).length;
+      }
+      requalifyClaimsForCodeState2(claimStore, codeStore, projectId);
+      if (observations2.length === limit) {
+        return {
+          action: "reschedule",
+          delayMs: 0,
+          resetAttempts: true,
+          payload: {
+            ...job.payload,
+            cursor: observations2[observations2.length - 1].id,
+            limit
+          }
+        };
+      }
+      enqueueKnowledgeFollowups({
+        projectId,
+        dataDir: projectDir2,
+        source: "claim-requalification",
+        includeCompile: derivedCount > 0,
+        ...options.maintenanceQueue ? { queue: options.maintenanceQueue } : {}
+      });
+      return { action: "complete" };
+    }
+    if (job.kind === "knowledge-compile") {
+      const workspace = await loadWorkspaceForMaintenance(projectId, projectDir2, workspaceMode(job.payload));
+      if (!workspace) return { action: "complete" };
+      if (workspace.mode === "versioned" && job.payload.allowVersionedWrite !== true) {
+        return { action: "complete" };
+      }
+      const [{ ClaimStore: ClaimStore2 }, { compileKnowledgeWorkspace: compileKnowledgeWorkspace2 }] = await Promise.all([
+        Promise.resolve().then(() => (init_claim_store(), claim_store_exports)),
+        Promise.resolve().then(() => (init_wiki(), wiki_exports))
+      ]);
+      const claims = new ClaimStore2();
+      await claims.init(projectDir2);
+      await compileKnowledgeWorkspace2({ workspace, claims });
+      enqueueKnowledgeFollowups({
+        projectId,
+        dataDir: projectDir2,
+        source: "knowledge-compile",
+        ...options.maintenanceQueue ? { queue: options.maintenanceQueue } : {}
+      });
+      return { action: "complete" };
+    }
+    if (job.kind === "workflow-index") {
+      const workspace = await loadWorkspaceForMaintenance(projectId, projectDir2, workspaceMode(job.payload));
+      if (!workspace) return { action: "complete" };
+      const { syncCanonicalWorkflows: syncCanonicalWorkflows2 } = await Promise.resolve().then(() => (init_workflows(), workflows_exports));
+      await syncCanonicalWorkflows2(workspace);
+      return { action: "complete" };
+    }
+    if (job.kind === "knowledge-lint") {
+      const workspace = await loadWorkspaceForMaintenance(projectId, projectDir2, workspaceMode(job.payload));
+      if (!workspace) return { action: "complete" };
+      const [
+        { ClaimStore: ClaimStore2 },
+        { CodeGraphStore: CodeGraphStore2 },
+        { lintKnowledgeWorkspace: lintKnowledgeWorkspace2 }
+      ] = await Promise.all([
+        Promise.resolve().then(() => (init_claim_store(), claim_store_exports)),
+        Promise.resolve().then(() => (init_store(), store_exports)),
+        Promise.resolve().then(() => (init_wiki(), wiki_exports))
+      ]);
+      const claims = new ClaimStore2();
+      const codeStore = new CodeGraphStore2();
+      await Promise.all([claims.init(projectDir2), codeStore.init(projectDir2)]);
+      await lintKnowledgeWorkspace2({ workspace, claims, codeStore });
       return { action: "complete" };
     }
     if (job.kind !== "vector-backfill") {