scopecairn 0.1.0

package/dist/cli.js

@@ -0,0 +1,2423 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import path13 from "path";
+
+// src/scanner.ts
+import fs5 from "fs";
+import path6 from "path";
+
+// src/languages.ts
+var EXT_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".py": "python"
+};
+function detectLanguage(filePath) {
+  const dot = filePath.lastIndexOf(".");
+  if (dot === -1) return "other";
+  const ext = filePath.slice(dot).toLowerCase();
+  return EXT_MAP[ext] ?? "other";
+}
+function isSourceFile(filePath) {
+  return detectLanguage(filePath) !== "other";
+}
+
+// src/db.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { createRequire } from "module";
+function loadDatabaseSync() {
+  const req = createRequire(import.meta.url);
+  const spec = "node:sqlite";
+  const m = req(spec);
+  return m.DatabaseSync;
+}
+var DATA_DIR_NAME = ".scopecairn";
+var DB_FILE_NAME = "scopecairn.db";
+var SCHEMA_VERSION = 4;
+function dataDir(repoRoot2) {
+  return path.join(repoRoot2, DATA_DIR_NAME);
+}
+function dbPath(repoRoot2) {
+  return path.join(dataDir(repoRoot2), DB_FILE_NAME);
+}
+function openDb(repoRoot2) {
+  fs.mkdirSync(dataDir(repoRoot2), { recursive: true });
+  const DatabaseSync = loadDatabaseSync();
+  const db = new DatabaseSync(dbPath(repoRoot2));
+  db.exec(`
+    PRAGMA journal_mode = WAL;
+    PRAGMA foreign_keys = ON;
+    CREATE TABLE IF NOT EXISTS files (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      path TEXT NOT NULL UNIQUE,
+      language TEXT NOT NULL,
+      hash TEXT NOT NULL,
+      size INTEGER NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE TABLE IF NOT EXISTS symbols (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      type TEXT NOT NULL,
+      signature TEXT NOT NULL DEFAULT '',
+      start_line INTEGER NOT NULL DEFAULT 1,
+      end_line INTEGER NOT NULL DEFAULT 1
+    );
+    CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_id);
+    CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+    CREATE INDEX IF NOT EXISTS idx_symbols_type ON symbols(type);
+    CREATE TABLE IF NOT EXISTS relationships (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_id INTEGER NOT NULL REFERENCES symbols(id) ON DELETE CASCADE,
+      target_id INTEGER NOT NULL REFERENCES symbols(id) ON DELETE CASCADE,
+      relationship_type TEXT NOT NULL,
+      weight REAL NOT NULL DEFAULT 0.5,
+      confidence REAL NOT NULL DEFAULT 1.0
+    );
+    CREATE INDEX IF NOT EXISTS idx_rel_source ON relationships(source_id);
+    CREATE INDEX IF NOT EXISTS idx_rel_target ON relationships(target_id);
+    CREATE INDEX IF NOT EXISTS idx_rel_type ON relationships(relationship_type);
+    CREATE TABLE IF NOT EXISTS meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+    -- Fase 3: FTS5 symbol index (token match, bukan embedding).
+    CREATE VIRTUAL TABLE IF NOT EXISTS symbol_index USING fts5(
+      symbol_id UNINDEXED, tokens
+    );
+    CREATE TABLE IF NOT EXISTS tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      description TEXT NOT NULL,
+      complexity TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      completed_at TEXT
+    );
+    CREATE TABLE IF NOT EXISTS task_context (
+      task_id INTEGER NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+      symbol_id INTEGER NOT NULL REFERENCES symbols(id) ON DELETE CASCADE,
+      score REAL NOT NULL DEFAULT 0,
+      reason TEXT NOT NULL DEFAULT ''
+    );
+    CREATE INDEX IF NOT EXISTS idx_task_context_task ON task_context(task_id);
+    -- Fase 5: invocation log untuk compliance rate (AI-5, \xA718).
+    CREATE TABLE IF NOT EXISTS invocations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      task_id INTEGER REFERENCES tasks(id) ON DELETE SET NULL,
+      command TEXT NOT NULL,
+      timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+    CREATE INDEX IF NOT EXISTS idx_invocations_cmd ON invocations(command);
+  `);
+  db.prepare(
+    `INSERT INTO meta(key, value) VALUES ('schema_version', ?)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+  ).run(String(SCHEMA_VERSION));
+  return db;
+}
+function hashContent(buf) {
+  return crypto.createHash("sha256").update(buf).digest("hex");
+}
+
+// src/ignore.ts
+import fs2 from "fs";
+import path2 from "path";
+import ignore from "ignore";
+var DEFAULT_DIR_IGNORES = [
+  "node_modules/",
+  ".git/",
+  ".next/",
+  "dist/",
+  "build/",
+  "coverage/",
+  ".scopecairn/"
+];
+var DEFAULT_FILE_IGNORES = [
+  ".env",
+  ".env.*",
+  "*.pem",
+  "*.key",
+  "credentials.*",
+  "secrets.*",
+  "*.min.js",
+  "*.map"
+];
+function loadIgnoreRules(repoRoot2) {
+  const ig = ignore();
+  ig.add(DEFAULT_DIR_IGNORES);
+  ig.add(DEFAULT_FILE_IGNORES);
+  for (const name of [".gitignore", ".scopecairnignore"]) {
+    const p = path2.join(repoRoot2, name);
+    if (fs2.existsSync(p)) {
+      try {
+        const content = fs2.readFileSync(p, "utf8");
+        ig.add(content);
+      } catch {
+      }
+    }
+  }
+  return { ig };
+}
+function isIgnored(relPosix, rules) {
+  return rules.ig.ignores(relPosix);
+}
+
+// src/indexer.ts
+import path3 from "path";
+
+// src/extract/types.ts
+var WEIGHT = {
+  CONTAINS: 1,
+  IMPORTS: 0.9,
+  EXPORTS: 0.9,
+  TESTS: 0.9,
+  EXTENDS: 0.8,
+  IMPLEMENTS: 0.8,
+  CALLS: 0.7,
+  REFERENCES: 0.5,
+  USES: 0.5
+};
+
+// src/extract/typescript.ts
+function lineOf(text, index) {
+  return text.slice(0, index).split("\n").length;
+}
+function stripStringsAndComments(src) {
+  let out = "";
+  let i = 0;
+  let quote = null;
+  while (i < src.length) {
+    const c = src[i];
+    const nxt = src[i + 1] ?? "";
+    if (quote) {
+      if (c === "\\") {
+        out += "  ";
+        i += 2;
+        continue;
+      }
+      if (c === "\n") {
+        out += "\n";
+        if (quote !== "`") quote = null;
+        i++;
+        continue;
+      }
+      if (c === quote) quote = null;
+      out += " ";
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      quote = c;
+      out += " ";
+      i++;
+      continue;
+    }
+    if (c === "/" && nxt === "/") {
+      while (i < src.length && src[i] !== "\n") {
+        out += " ";
+        i++;
+      }
+      continue;
+    }
+    if (c === "/" && nxt === "*") {
+      out += "  ";
+      i += 2;
+      while (i < src.length && !(src[i] === "*" && src[i + 1] === "/")) {
+        out += src[i] === "\n" ? "\n" : " ";
+        i++;
+      }
+      out += "  ";
+      i += 2;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+function extractTypeScript(source, isTsx) {
+  const symbols = [];
+  const relations = [];
+  const pushRel = (from, to, rel, confidence = 1) => relations.push({ from, to, rel, weight: WEIGHT[rel], confidence });
+  const importRe = /import\s+(?:(?:[\w*{}\s,]+?)\s+from\s+)?["']([^"']+)["']|require\(\s*["']([^"']+)["']\s*\)/g;
+  let m;
+  while ((m = importRe.exec(source)) !== null) {
+    const mod = m[1] ?? m[2];
+    if (!mod) continue;
+    const ln = lineOf(source, m.index);
+    symbols.push({
+      name: `import:${mod}`,
+      type: "import",
+      signature: m[0].slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+    const dynamic = m[0].trimStart().startsWith("import(");
+    pushRel("__file__", mod, "IMPORTS", dynamic ? 0.6 : 1);
+  }
+  const exportStarRe = /export\s+\*\s+from\s+["']([^"']+)["']/g;
+  while ((m = exportStarRe.exec(source)) !== null) {
+    const mod = m[1];
+    const ln = lineOf(source, m.index);
+    symbols.push({
+      name: `export*:${mod}`,
+      type: "export",
+      signature: m[0].slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+    pushRel("__file__", mod, "EXPORTS", 0.7);
+  }
+  const funcRe = /(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+(\w+)\s*\(|(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*async\s*\(/g;
+  const funcNames = /* @__PURE__ */ new Set();
+  while ((m = funcRe.exec(source)) !== null) {
+    const name = m[1] ?? m[2];
+    if (!name) continue;
+    funcNames.add(name);
+    const ln = lineOf(source, m.index);
+    const looksJsx = isTsx && /^[A-Z]/.test(name) && /<[A-Z][\w]*|<>|return\s*\(/.test(source.slice(m.index, m.index + 2e3));
+    symbols.push({
+      name,
+      type: looksJsx ? "component" : "function",
+      signature: m[0].slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+    if (/^export\s/.test(m[0])) pushRel("__file__", name, "EXPORTS", 1);
+  }
+  const arrowRe = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s*)?(?:<[^=]*>)?\([^)]*\)\s*=>/g;
+  while ((m = arrowRe.exec(source)) !== null) {
+    const name = m[1];
+    if (funcNames.has(name)) continue;
+    funcNames.add(name);
+    const ln = lineOf(source, m.index);
+    symbols.push({
+      name,
+      type: /^[A-Z]/.test(name) && isTsx ? "component" : "function",
+      signature: m[0].slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+    if (/^export\s/.test(m[0])) pushRel("__file__", name, "EXPORTS", 1);
+  }
+  const classRe = /(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w\s,]+))?/g;
+  const classNames = /* @__PURE__ */ new Set();
+  while ((m = classRe.exec(source)) !== null) {
+    const [, name, base, impls] = m;
+    classNames.add(name);
+    const ln = lineOf(source, m.index);
+    symbols.push({
+      name,
+      type: "class",
+      signature: m[0].slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+    if (base) pushRel(name, base, "EXTENDS", 1);
+    if (impls)
+      for (const i of impls.split(",")) {
+        const t = i.trim();
+        if (t) pushRel(name, t, "IMPLEMENTS", 1);
+      }
+    if (/^export\s/.test(m[0])) pushRel("__file__", name, "EXPORTS", 1);
+  }
+  const methodRe = /(?:^|\n)\s*(?:public|private|protected|static|async|override|readonly|\s)*\s*(?:get\s+|set\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*[^{=;]+)?\s*\{/g;
+  while ((m = methodRe.exec(source)) !== null) {
+    const name = m[1];
+    if (["if", "for", "while", "switch", "catch", "function"].includes(name)) continue;
+    const ln = lineOf(source, m.index);
+    symbols.push({
+      name,
+      type: "method",
+      signature: m[0].trim().slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+  }
+  const ifaceRe = /(?:export\s+)?interface\s+(\w+)/g;
+  while ((m = ifaceRe.exec(source)) !== null) {
+    const ln = lineOf(source, m.index);
+    symbols.push({
+      name: m[1],
+      type: "interface",
+      signature: m[0].slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+  }
+  const typeRe = /(?:export\s+)?type\s+(\w+)\s*=/g;
+  while ((m = typeRe.exec(source)) !== null) {
+    const ln = lineOf(source, m.index);
+    symbols.push({
+      name: m[1],
+      type: "type",
+      signature: m[0].slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+  }
+  const varRe = /(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[:=]/g;
+  while ((m = varRe.exec(source)) !== null) {
+    const name = m[1];
+    if (funcNames.has(name)) continue;
+    const ln = lineOf(source, m.index);
+    symbols.push({
+      name,
+      type: "variable",
+      signature: m[0].slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+  }
+  const callSource = stripStringsAndComments(source);
+  const callRe = /(\w+)\s*\(/g;
+  const keywords = /* @__PURE__ */ new Set([
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "return",
+    "function",
+    "class",
+    "import",
+    "export",
+    "new",
+    "typeof",
+    "instanceof"
+  ]);
+  const funcsByLine = symbols.filter((s) => s.type === "function" || s.type === "component" || s.type === "method").sort((a, b) => a.startLine - b.startLine);
+  let guard = 0;
+  while ((m = callRe.exec(callSource)) !== null && guard++ < 4e3) {
+    const callee = m[1];
+    if (keywords.has(callee)) continue;
+    const ln = lineOf(callSource, m.index);
+    let caller = "__file__";
+    for (const f of funcsByLine) {
+      if (f.startLine <= ln) caller = f.name;
+      else break;
+    }
+    if (caller === callee) continue;
+    relations.push({
+      from: caller,
+      to: callee,
+      rel: "CALLS",
+      weight: WEIGHT.CALLS,
+      confidence: 0.7,
+      // regex can't resolve scope precisely
+      methodCall: callSource[m.index - 1] === "."
+    });
+  }
+  return { symbols, relations };
+}
+
+// src/extract/python.ts
+function lineOf2(text, index) {
+  return text.slice(0, index).split("\n").length;
+}
+function extractPython(source) {
+  const symbols = [];
+  const relations = [];
+  const push = (from, to, rel, confidence = 1) => relations.push({ from, to, rel, weight: WEIGHT[rel], confidence });
+  let m;
+  const importRe = /^\s*(?:import\s+([\w.,\s]+)|from\s+([\w.]+)\s+import\s+([^\n#]+))/gm;
+  while ((m = importRe.exec(source)) !== null) {
+    const mod = (m[2] ?? m[1] ?? "").trim();
+    if (!mod) continue;
+    const ln = lineOf2(source, m.index);
+    symbols.push({
+      name: `import:${mod}`,
+      type: "import",
+      signature: m[0].trim().slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+    push("__file__", mod, "IMPORTS", 1);
+  }
+  const classRe = /^\s*class\s+(\w+)(?:\s*\(([^)]*)\))?\s*:/gm;
+  while ((m = classRe.exec(source)) !== null) {
+    const ln = lineOf2(source, m.index);
+    symbols.push({
+      name: m[1],
+      type: "class",
+      signature: m[0].trim().slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+    const bases = (m[2] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    for (const b of bases) {
+      if (!["object"].includes(b)) push(m[1], b, "EXTENDS", 0.9);
+    }
+  }
+  const defRe = /^\s*(?:async\s+)?def\s+(\w+)\s*\(/gm;
+  const funcs = [];
+  while ((m = defRe.exec(source)) !== null) {
+    const ln = lineOf2(source, m.index);
+    const indented = /^\s+/.test(m[0]);
+    symbols.push({
+      name: m[1],
+      type: indented ? "method" : "function",
+      signature: m[0].trim().slice(0, 120),
+      startLine: ln,
+      endLine: ln
+    });
+    funcs.push({ name: m[1], line: ln });
+  }
+  funcs.sort((a, b) => a.line - b.line);
+  const callRe = /(\w+)\s*\(/g;
+  const kw = /* @__PURE__ */ new Set(["def", "class", "if", "for", "while", "return", "import", "print"]);
+  let guard = 0;
+  while ((m = callRe.exec(source)) !== null && guard++ < 4e3) {
+    const callee = m[1];
+    if (kw.has(callee)) continue;
+    const ln = lineOf2(source, m.index);
+    let caller = "__file__";
+    for (const f of funcs) {
+      if (f.line <= ln) caller = f.name;
+      else break;
+    }
+    if (caller === callee) continue;
+    relations.push({
+      from: caller,
+      to: callee,
+      rel: "CALLS",
+      weight: WEIGHT.CALLS,
+      confidence: 0.7,
+      methodCall: source[m.index - 1] === "."
+    });
+  }
+  return { symbols, relations };
+}
+
+// src/extract/index.ts
+function extractFile(relPath, source) {
+  const lang = detectLanguage(relPath);
+  switch (lang) {
+    case "typescript":
+      return extractTypeScript(source, relPath.endsWith("x"));
+    case "javascript":
+      return extractTypeScript(source, relPath.endsWith("x"));
+    case "python":
+      return extractPython(source);
+    default:
+      return { symbols: [], relations: [] };
+  }
+}
+function testTarget(testRel) {
+  const base = testRel.split("/").pop() ?? testRel;
+  let stem = null;
+  const m1 = base.match(/^(.+)\.(test|spec)\.[^.]+$/);
+  if (m1) stem = m1[1];
+  const m2 = base.match(/^test_(.+)\.py$/);
+  if (m2) stem = m2[1];
+  const m3 = base.match(/^(.+)_test\.py$/);
+  if (m3) stem = m3[1];
+  if (!stem) return null;
+  const dir = testRel.includes("/") ? testRel.slice(0, testRel.lastIndexOf("/")) : "";
+  return (dir ? dir + "/" : "") + stem;
+}
+
+// src/retrieval/tokenize.ts
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "of",
+  "to",
+  "in",
+  "for",
+  "on",
+  "with",
+  "and",
+  "or",
+  "src",
+  "lib",
+  "app",
+  "test",
+  "tests",
+  "spec"
+]);
+function tokenizeIdentifier(raw) {
+  const parts = raw.replace(/[\\/]/g, " ").replace(/[.:\-_"']/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().split(/[^a-z0-9]+/g).filter((t) => t.length >= 2 && !/^\d+$/.test(t) && !STOP.has(t));
+  return [...new Set(parts)];
+}
+function tokenizeTask(text) {
+  return tokenizeIdentifier(text);
+}
+
+// src/retrieval/symbolIndex.ts
+function syncFileIndex(db, fileId, relPath) {
+  db.prepare(
+    `DELETE FROM symbol_index WHERE symbol_id IN (SELECT id FROM symbols WHERE file_id = ?)`
+  ).run(fileId);
+  const rows = db.prepare(
+    `SELECT id, name, type, signature FROM symbols WHERE file_id = ?`
+  ).all(fileId);
+  const ins = db.prepare(
+    `INSERT INTO symbol_index(symbol_id, tokens) VALUES (?, ?)`
+  );
+  for (const r of rows) {
+    const toks = tokenizeIdentifier(`${r.name} ${r.signature} ${relPath}`).join(" ");
+    if (toks) ins.run(r.id, toks);
+  }
+}
+function cleanupIndex(db) {
+  db.exec(
+    `DELETE FROM symbol_index WHERE symbol_id NOT IN (SELECT id FROM symbols)`
+  );
+}
+function seedSearch(db, tokens, limit = 30) {
+  if (tokens.length === 0) return [];
+  const q = tokens.map((t) => `"${t.replace(/"/g, "")}"`).join(" OR ");
+  let rows;
+  try {
+    rows = db.prepare(
+      `SELECT symbol_id, bm25(symbol_index) AS rank
+         FROM symbol_index WHERE symbol_index MATCH ? LIMIT ${limit}`
+    ).all(q);
+  } catch {
+    return [];
+  }
+  if (rows.length === 0) return [];
+  const worst = Math.min(...rows.map((r) => r.rank));
+  const range = Math.max(1e-9, 0 - worst + 1);
+  return rows.map((r) => ({
+    symbolId: r.symbol_id,
+    bm25: Math.max(0, Math.min(1, (0 - r.rank + 0.5) / range))
+  }));
+}
+
+// src/indexer.ts
+function fileSymbolId(db, fileId, relPath) {
+  const existing = db.prepare(`SELECT id FROM symbols WHERE file_id = ? AND type = 'file'`).get(fileId);
+  if (existing) return existing.id;
+  const r = db.prepare(
+    `INSERT INTO symbols(file_id, name, type, signature, start_line, end_line)
+       VALUES (?, ?, 'file', '', 1, 1)`
+  ).run(fileId, relPath);
+  return Number(r.lastInsertRowid);
+}
+function symbolIdInFile(db, fileId, name) {
+  const r = db.prepare(`SELECT id FROM symbols WHERE file_id = ? AND name = ? LIMIT 1`).get(fileId, name);
+  return r ? r.id : null;
+}
+function globalSymbolId(db, name) {
+  const r = db.prepare(`SELECT id FROM symbols WHERE name = ? LIMIT 1`).get(name);
+  return r ? r.id : null;
+}
+function methodSymbolId(db, fileId, ids, name) {
+  const local = ids.get(name);
+  if (local) {
+    const t = db.prepare(`SELECT type FROM symbols WHERE id = ?`).get(local);
+    if (t && ["method", "component"].includes(t.type)) return local;
+  }
+  const r = db.prepare(
+    `SELECT id FROM symbols WHERE name = ? AND type IN ('method','component') LIMIT 1`
+  ).get(name);
+  return r ? r.id : null;
+}
+function resolveModuleToFile(db, fromRel, spec) {
+  if (!spec.startsWith(".")) return null;
+  const dir = fromRel.includes("/") ? fromRel.slice(0, fromRel.lastIndexOf("/")) : "";
+  const joined = path3.posix.normalize((dir ? dir + "/" : "") + spec);
+  const bases = [joined];
+  const jsExt = joined.match(/\.(js|mjs|cjs|jsx)$/);
+  if (jsExt) {
+    const stripped = joined.slice(0, -jsExt[0].length);
+    bases.push(stripped, stripped + ".ts", stripped + ".tsx");
+  }
+  const candidates = [
+    ...bases,
+    joined + ".ts",
+    joined + ".tsx",
+    joined + ".js",
+    joined + ".jsx",
+    joined + ".py",
+    joined + "/index.ts",
+    joined + "/index.js"
+  ];
+  for (const c of candidates) {
+    const r = db.prepare(`SELECT id FROM files WHERE path = ?`).get(c);
+    if (r) {
+      const s = db.prepare(`SELECT id FROM symbols WHERE file_id = ? AND type = 'file'`).get(r.id);
+      if (s) return s.id;
+    }
+  }
+  return null;
+}
+function indexFileSymbols(db, fileId, relPath, content) {
+  db.prepare(`DELETE FROM symbols WHERE file_id = ?`).run(fileId);
+  const fileSym = fileSymbolId(db, fileId, relPath);
+  const ext = extractFile(relPath, content);
+  const insSym = db.prepare(
+    `INSERT INTO symbols(file_id, name, type, signature, start_line, end_line)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  );
+  for (const s of ext.symbols) {
+    if (s.type === "import" || s.type === "export") continue;
+    insSym.run(fileId, s.name, s.type, s.signature, s.startLine, s.endLine);
+  }
+  syncFileIndex(db, fileId, relPath);
+  return { extraction: ext, fileSym };
+}
+function indexFileRelations(db, fileId, relPath, extraction, fileSym) {
+  const ids = /* @__PURE__ */ new Map();
+  const rows = db.prepare(`SELECT id, name FROM symbols WHERE file_id = ? AND type != 'file'`).all(fileId);
+  for (const r of rows) if (!ids.has(r.name)) ids.set(r.name, r.id);
+  const insRel = db.prepare(
+    `INSERT INTO relationships(source_id, target_id, relationship_type, weight, confidence)
+     VALUES (?, ?, ?, ?, ?)`
+  );
+  const contains = db.prepare(
+    `INSERT INTO relationships(source_id, target_id, relationship_type, weight, confidence)
+     VALUES (?, ?, 'CONTAINS', 1.0, 1.0)`
+  );
+  let rels = 0;
+  for (const id of ids.values()) {
+    contains.run(fileSym, id);
+    rels++;
+  }
+  const resolveLocal = (name) => {
+    if (name === "__file__") return fileSym;
+    return ids.get(name) ?? symbolIdInFile(db, fileId, name) ?? globalSymbolId(db, name);
+  };
+  for (const r of extraction.relations) {
+    if (r.rel === "IMPORTS") {
+      const target = resolveModuleToFile(db, relPath, r.to);
+      if (target) {
+        insRel.run(fileSym, target, "IMPORTS", r.weight, r.confidence);
+        rels++;
+      }
+      continue;
+    }
+    if (r.rel === "EXPORTS") {
+      if (r.to.startsWith("export*:")) {
+        const target2 = resolveModuleToFile(db, relPath, r.to.slice(8));
+        if (target2) {
+          insRel.run(fileSym, target2, "EXPORTS", r.weight, r.confidence);
+          rels++;
+        }
+        continue;
+      }
+      const target = resolveLocal(r.to);
+      if (target && target !== fileSym) {
+        insRel.run(fileSym, target, "EXPORTS", r.weight, r.confidence);
+        rels++;
+      }
+      continue;
+    }
+    const src = resolveLocal(r.from);
+    const dst = r.rel === "CALLS" && r.methodCall ? methodSymbolId(db, fileId, ids, r.to) : ids.get(r.to) ?? globalSymbolId(db, r.to);
+    if (src && dst && src !== dst) {
+      insRel.run(src, dst, r.rel, r.weight, r.confidence);
+      rels++;
+    }
+  }
+  return { symbols: ids.size, relations: rels };
+}
+function indexMetaFile(db, fileId, relPath) {
+  db.prepare(`DELETE FROM symbols WHERE file_id = ?`).run(fileId);
+  fileSymbolId(db, fileId, relPath);
+  syncFileIndex(db, fileId, relPath);
+}
+function linkTests(db) {
+  const files = db.prepare(`SELECT id, path FROM files`).all();
+  const byPath = new Map(files.map((f) => [f.path, f.id]));
+  const fileSymOf = (fid) => {
+    const r = db.prepare(`SELECT id FROM symbols WHERE file_id = ? AND type = 'file'`).get(fid);
+    return r ? r.id : null;
+  };
+  db.prepare(`DELETE FROM relationships WHERE relationship_type = 'TESTS'`).run();
+  let n = 0;
+  const ins = db.prepare(
+    `INSERT INTO relationships(source_id, target_id, relationship_type, weight, confidence)
+     VALUES (?, ?, 'TESTS', 0.9, 0.8)`
+  );
+  for (const f of files) {
+    const stemBase = testTarget(f.path);
+    if (!stemBase) continue;
+    const matches = [...byPath.keys()].filter((p) => {
+      const noExt = p.replace(/\.[^.]+$/, "");
+      return noExt === stemBase && p !== f.path;
+    });
+    const srcSym = fileSymOf(f.id);
+    for (const mp of matches) {
+      const dstSym = fileSymOf(byPath.get(mp));
+      if (srcSym && dstSym) {
+        ins.run(srcSym, dstSym);
+        n++;
+      }
+    }
+  }
+  return n;
+}
+
+// src/retrieval/config.ts
+import fs4 from "fs";
+import path5 from "path";
+
+// src/scope/protected.ts
+import fs3 from "fs";
+import path4 from "path";
+var DEFAULT_PROTECTED_PATTERNS = [
+  "migrations/**",
+  "prisma/**",
+  "schema.prisma",
+  "*.sql",
+  "alembic/**",
+  ".env*",
+  "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lockb"
+];
+function globToRegExp(pattern) {
+  let re = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        if (pattern[i + 2] === "/") {
+          re += "(.*/)?";
+          i += 3;
+        } else {
+          re += ".*";
+          i += 2;
+        }
+      } else {
+        re += "[^/]*";
+        i++;
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+      i++;
+    } else {
+      re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+      i++;
+    }
+  }
+  return new RegExp(`^${re}$`);
+}
+function matchPattern(pattern, posixPath) {
+  const base = posixPath.split("/").pop() ?? posixPath;
+  if (pattern.endsWith("/")) {
+    const dir = pattern.slice(0, -1);
+    return posixPath === dir || posixPath.startsWith(dir + "/");
+  }
+  if (!pattern.includes("/")) {
+    return globToRegExp(pattern).test(base);
+  }
+  return globToRegExp(pattern).test(posixPath);
+}
+function loadProtectedPatterns(repoRoot2) {
+  const p = path4.join(dataDir(repoRoot2), "protected.yml");
+  if (!fs3.existsSync(p)) return [...DEFAULT_PROTECTED_PATTERNS];
+  try {
+    const patterns = [];
+    for (const line of fs3.readFileSync(p, "utf8").split("\n")) {
+      const t = line.trim();
+      if (!t || t.startsWith("#")) continue;
+      patterns.push(t);
+    }
+    return patterns.length > 0 ? patterns : [...DEFAULT_PROTECTED_PATTERNS];
+  } catch {
+    return [...DEFAULT_PROTECTED_PATTERNS];
+  }
+}
+function isProtected(posixPath, patterns = DEFAULT_PROTECTED_PATTERNS) {
+  let hit = false;
+  for (const p of patterns) {
+    if (p.startsWith("!")) {
+      if (matchPattern(p.slice(1), posixPath)) hit = false;
+    } else if (matchPattern(p, posixPath)) {
+      hit = true;
+    }
+  }
+  return hit;
+}
+var SECRET_PATTERNS = [
+  ".env",
+  ".env.*",
+  "*.pem",
+  "*.key",
+  "credentials.*",
+  "secrets.*"
+];
+function isSecretFile(posixPath) {
+  return SECRET_PATTERNS.some((p) => matchPattern(p, posixPath));
+}
+var META_EXTS = /* @__PURE__ */ new Set([
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".sql",
+  ".prisma",
+  ".cfg",
+  ".ini"
+]);
+var META_BASENAMES = /* @__PURE__ */ new Set([
+  "dockerfile",
+  "makefile",
+  "package.json"
+]);
+function isIndexableMetaFile(posixPath) {
+  if (isSecretFile(posixPath)) return false;
+  const base = (posixPath.split("/").pop() ?? "").toLowerCase();
+  if (META_BASENAMES.has(base)) return true;
+  const dot = base.lastIndexOf(".");
+  if (dot !== -1 && META_EXTS.has(base.slice(dot))) return true;
+  if (isProtected(posixPath)) return true;
+  return false;
+}
+function ensureProtectedFile(repoRoot2) {
+  const dir = dataDir(repoRoot2);
+  fs3.mkdirSync(dir, { recursive: true });
+  const p = path4.join(dir, "protected.yml");
+  if (!fs3.existsSync(p)) {
+    fs3.writeFileSync(
+      p,
+      `# ScopeCairn Protected patterns (FR-07). Satu pola per baris, \`!\` negasi.
+` + DEFAULT_PROTECTED_PATTERNS.join("\n") + `
+`
+    );
+  }
+}
+
+// src/retrieval/config.ts
+var DEFAULT_CONFIG = {
+  wSeed: 0.3,
+  wProximity: 0.35,
+  wCentrality: 0.15,
+  wRecency: 0.1,
+  wCochange: 0.1,
+  maxDepth: 2,
+  topN: 20,
+  decayPerHop: 0.7
+};
+function parseSimpleYml(text) {
+  const out = {};
+  for (const line of text.split("\n")) {
+    const t = line.trim();
+    if (!t || t.startsWith("#")) continue;
+    const i = t.indexOf(":");
+    if (i === -1) continue;
+    out[t.slice(0, i).trim()] = t.slice(i + 1).trim();
+  }
+  return out;
+}
+function loadConfig(repoRoot2) {
+  const cfg = { ...DEFAULT_CONFIG };
+  const p = path5.join(dataDir(repoRoot2), "config.yml");
+  if (!fs4.existsSync(p)) return cfg;
+  try {
+    const kv = parseSimpleYml(fs4.readFileSync(p, "utf8"));
+    const num = (k, cur) => {
+      const v = Number(kv[k]);
+      return Number.isFinite(v) ? v : cur;
+    };
+    cfg.wSeed = num("w_seed", cfg.wSeed);
+    cfg.wProximity = num("w_proximity", cfg.wProximity);
+    cfg.wCentrality = num("w_centrality", cfg.wCentrality);
+    cfg.wRecency = num("w_recency", cfg.wRecency);
+    cfg.wCochange = num("w_cochange", cfg.wCochange);
+    cfg.maxDepth = Math.max(1, Math.min(4, Math.round(num("max_depth", cfg.maxDepth))));
+    cfg.topN = Math.max(5, Math.min(100, Math.round(num("top_n", cfg.topN))));
+  } catch {
+  }
+  return cfg;
+}
+function loadGlossary(repoRoot2) {
+  const out = /* @__PURE__ */ new Map();
+  const p = path5.join(dataDir(repoRoot2), "glossary.yml");
+  if (!fs4.existsSync(p)) return out;
+  try {
+    for (const line of fs4.readFileSync(p, "utf8").split("\n")) {
+      const t = line.trim();
+      if (!t || t.startsWith("#")) continue;
+      const i = t.indexOf(":");
+      if (i === -1) continue;
+      const term = t.slice(0, i).trim().toLowerCase();
+      const aliases = t.slice(i + 1).replace(/[[ \]]/g, "").split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+      if (term && aliases.length > 0) out.set(term, aliases);
+    }
+  } catch {
+  }
+  return out;
+}
+function ensureDefaultFiles(repoRoot2) {
+  const dir = dataDir(repoRoot2);
+  fs4.mkdirSync(dir, { recursive: true });
+  const cfgPath = path5.join(dir, "config.yml");
+  if (!fs4.existsSync(cfgPath)) {
+    fs4.writeFileSync(
+      cfgPath,
+      `# ScopeCairn retrieval config (bobot FR-05, dikalibrasi Fase 6)
+w_seed: 0.3
+w_proximity: 0.35
+w_centrality: 0.15
+w_recency: 0.1
+w_cochange: 0.1
+max_depth: 2
+top_n: 20
+`
+    );
+  }
+  const gloPath = path5.join(dir, "glossary.yml");
+  if (!fs4.existsSync(gloPath)) {
+    fs4.writeFileSync(
+      gloPath,
+      `# Sinonim domain (opsional). Format: istilah: [alias1, alias2]
+# approval: [authorize, persetujuan]
+`
+    );
+  }
+  ensureProtectedFile(repoRoot2);
+}
+
+// src/scanner.ts
+function toPosixRel(repoRoot2, abs) {
+  return path6.relative(repoRoot2, abs).split(path6.sep).join("/");
+}
+function walk(absDir, out) {
+  const entries = fs5.readdirSync(absDir, { withFileTypes: true });
+  for (const e of entries) {
+    const abs = path6.join(absDir, e.name);
+    if (e.isDirectory()) {
+      if (e.isSymbolicLink()) continue;
+      walk(abs, out);
+    } else if (e.isFile()) {
+      out.push(abs);
+    }
+  }
+}
+function scanRepository(repoRoot2) {
+  const started = Date.now();
+  const rules = loadIgnoreRules(repoRoot2);
+  const db = openDb(repoRoot2);
+  ensureDefaultFiles(repoRoot2);
+  try {
+    const allAbs = [];
+    walk(repoRoot2, allAbs);
+    let totalFilesSeen = 0;
+    let inserted = 0;
+    let updated = 0;
+    let unchanged = 0;
+    const seenPaths = /* @__PURE__ */ new Set();
+    const getStmt = db.prepare(`SELECT id, hash FROM files WHERE path = ?`);
+    const insertStmt = db.prepare(
+      `INSERT INTO files(path, language, hash, size) VALUES (?, ?, ?, ?)`
+    );
+    const updateStmt = db.prepare(
+      `UPDATE files SET hash = ?, size = ?, language = ?, updated_at = datetime('now') WHERE path = ?`
+    );
+    let sourceFiles = 0;
+    let metaFiles = 0;
+    const symbolCount = db.prepare(`SELECT COUNT(*) AS n FROM symbols`).get().n;
+    let ftsCount = 0;
+    try {
+      ftsCount = db.prepare(`SELECT COUNT(*) AS n FROM symbol_index`).get().n;
+    } catch {
+      ftsCount = 0;
+    }
+    const backfill = symbolCount === 0 || ftsCount === 0;
+    const pending = [];
+    for (const abs of allAbs) {
+      const rel = toPosixRel(repoRoot2, abs);
+      if (isIgnored(rel, rules)) continue;
+      totalFilesSeen++;
+      const source = isSourceFile(abs);
+      const meta = !source && isIndexableMetaFile(rel);
+      if (!source && !meta) continue;
+      if (source) sourceFiles++;
+      else metaFiles++;
+      seenPaths.add(rel);
+      let buf;
+      try {
+        buf = fs5.readFileSync(abs);
+      } catch {
+        continue;
+      }
+      const hash = hashContent(buf);
+      const language = source ? detectLanguage(abs) : "other";
+      const row = getStmt.get(rel);
+      if (!row) {
+        const r = insertStmt.run(rel, language, hash, buf.length);
+        if (source) {
+          pending.push({ fileId: Number(r.lastInsertRowid), rel, content: buf.toString("utf8") });
+        } else {
+          indexMetaFile(db, Number(r.lastInsertRowid), rel);
+        }
+        inserted++;
+      } else if (row.hash !== hash || backfill) {
+        updateStmt.run(hash, buf.length, language, rel);
+        if (source) {
+          pending.push({ fileId: row.id, rel, content: buf.toString("utf8") });
+        } else {
+          indexMetaFile(db, row.id, rel);
+        }
+        updated++;
+      } else {
+        unchanged++;
+      }
+    }
+    const existing = db.prepare(`SELECT path FROM files`).all();
+    const delStmt = db.prepare(`DELETE FROM files WHERE path = ?`);
+    let removed = 0;
+    for (const r of existing) {
+      if (!seenPaths.has(r.path)) {
+        delStmt.run(r.path);
+        removed++;
+      }
+    }
+    const phased = pending.map((p) => ({
+      ...p,
+      ...indexFileSymbols(db, p.fileId, p.rel, p.content)
+    }));
+    for (const p of phased) {
+      indexFileRelations(db, p.fileId, p.rel, p.extraction, p.fileSym);
+    }
+    db.prepare(
+      `INSERT INTO meta(key, value) VALUES ('last_scan', datetime('now'))
+       ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run();
+    linkTests(db);
+    cleanupIndex(db);
+    const symbols = db.prepare(`SELECT COUNT(*) AS n FROM symbols`).get().n;
+    const relationships = db.prepare(`SELECT COUNT(*) AS n FROM relationships`).get().n;
+    return {
+      repoRoot: repoRoot2,
+      totalFilesSeen,
+      sourceFiles,
+      metaFiles,
+      symbols,
+      relationships,
+      inserted,
+      updated,
+      unchanged,
+      removed,
+      durationMs: Date.now() - started
+    };
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/scan.ts
+function cmdScan(repoRoot2) {
+  console.log("ScopeCairn");
+  console.log("\u2713 Repository detected");
+  const stats = scanRepository(repoRoot2);
+  console.log(`\u2713 ${stats.totalFilesSeen} files found (non-ignored)`);
+  console.log(`\u2713 ${stats.sourceFiles} source files (ts/tsx/js/jsx/py)`);
+  if (stats.metaFiles > 0) {
+    console.log(`\u2713 ${stats.metaFiles} config/schema files (json/yml/sql/prisma, file-level)`);
+  }
+  console.log(`\u2713 ${stats.symbols} symbols`);
+  console.log(`\u2713 ${stats.relationships} relationships`);
+  console.log(
+    `\u2713 index: +${stats.inserted} new, ~${stats.updated} updated, =${stats.unchanged} unchanged, -${stats.removed} removed`
+  );
+  console.log(`\u2713 ${(stats.durationMs / 1e3).toFixed(2)}s`);
+  console.log("Ready.");
+}
+
+// src/commands/status.ts
+import fs6 from "fs";
+import path7 from "path";
+function cmdStatus(repoRoot2) {
+  const dir = dataDir(repoRoot2);
+  if (!fs6.existsSync(path7.join(dir, "scopecairn.db"))) {
+    console.log("ScopeCairn");
+    console.log("Status: NOT INITIALIZED (run `scopecairn scan`)");
+    return;
+  }
+  const db = openDb(repoRoot2);
+  try {
+    const files = db.prepare(`SELECT COUNT(*) AS n FROM files`).get().n;
+    const byLang = db.prepare(`SELECT language, COUNT(*) AS n FROM files GROUP BY language ORDER BY n DESC`).all();
+    const lastScan = db.prepare(`SELECT value FROM meta WHERE key = 'last_scan'`).get()?.value ?? "-";
+    console.log("ScopeCairn");
+    console.log(`Index: ${dbPath(repoRoot2)}`);
+    console.log(`Files indexed: ${files}`);
+    for (const r of byLang) console.log(`  ${r.language}: ${r.n}`);
+    try {
+      const symbols = db.prepare(`SELECT COUNT(*) AS n FROM symbols`).get().n;
+      const rels = db.prepare(`SELECT COUNT(*) AS n FROM relationships`).get().n;
+      console.log(`Symbols: ${symbols}`);
+      console.log(`Relationships: ${rels}`);
+      try {
+        const fts = db.prepare(`SELECT COUNT(*) AS n FROM symbol_index`).get().n;
+        console.log(`Symbol index (FTS5): ${fts} rows`);
+      } catch {
+        console.log(`Symbol index (FTS5): -`);
+      }
+    } catch {
+    }
+    console.log(`Last scan: ${lastScan}`);
+    try {
+      const inv = db.prepare(
+        `SELECT command, COUNT(*) AS n FROM invocations GROUP BY command ORDER BY n DESC`
+      ).all();
+      const total = inv.reduce((a, r) => a + r.n, 0);
+      if (total > 0) {
+        console.log(`Invocations: ${total} (${inv.map((r) => `${r.command} ${r.n}`).join(", ")})`);
+      }
+    } catch {
+    }
+  } finally {
+    db.close();
+  }
+}
+function cmdClean(repoRoot2) {
+  const dir = dataDir(repoRoot2);
+  fs6.rmSync(dir, { recursive: true, force: true });
+  console.log(`Cleaned ${dir}`);
+}
+
+// src/commands/rebuild.ts
+function cmdRebuild(repoRoot2) {
+  cmdClean(repoRoot2);
+  cmdScan(repoRoot2);
+}
+
+// src/commands/doctor.ts
+import fs8 from "fs";
+import path9 from "path";
+
+// src/treesitter.ts
+var cached = null;
+async function checkTreeSitter() {
+  if (cached !== null) {
+    return cached ? { ok: true, detail: "cached OK" } : { ok: false, detail: "cached FAIL" };
+  }
+  try {
+    const mod = await import("web-tree-sitter");
+    const Parser = mod.Parser;
+    if (!Parser || typeof Parser.init !== "function") {
+      cached = false;
+      return { ok: false, detail: "Parser.init not found" };
+    }
+    await Parser.init();
+    cached = true;
+    return { ok: true, detail: "WASM parser runtime OK (grammars load in Fase 2)" };
+  } catch (e) {
+    cached = false;
+    return { ok: false, detail: e instanceof Error ? e.message : String(e) };
+  }
+}
+
+// src/integrate/detect.ts
+import fs7 from "fs";
+import path8 from "path";
+function detectAgentDir(repoRoot2) {
+  const plural = fs7.existsSync(path8.join(repoRoot2, ".agents"));
+  const singular = fs7.existsSync(path8.join(repoRoot2, ".agent"));
+  if (singular && !plural) return ".agent";
+  return ".agents";
+}
+function detectPrefix(repoRoot2) {
+  try {
+    const pkg = JSON.parse(
+      fs7.readFileSync(path8.join(repoRoot2, "package.json"), "utf8")
+    );
+    if (pkg.dependencies?.["scopecairn"] || pkg.devDependencies?.["scopecairn"]) {
+      return "npx scopecairn";
+    }
+  } catch {
+  }
+  return "scopecairn";
+}
+function extractPrefixUsed(text) {
+  if (text.includes("npx scopecairn context")) return "npx scopecairn";
+  if (/(^|[\s`"'`])scopecairn context/.test(text)) return "scopecairn";
+  return null;
+}
+
+// src/integrate/templates.ts
+var MARKER = "<!-- scopecairn:managed -->";
+function agentsMd(prefix) {
+  return `${MARKER}
+# ScopeCairn
+
+## Wajib untuk setiap task coding
+Sebelum membaca file atau menjalankan grep, jalankan:
+
+    ${prefix} context "<permintaan user>"
+
+Gunakan hasilnya sebagai titik awal. Jangan menjelajah repository dari nol.
+
+## Selama bekerja
+- Ubah hanya file di daftar Required dan Optional.
+- Jangan sentuh file di daftar Protected tanpa persetujuan user.
+- Sebelum mengubah simbol yang dipakai banyak tempat, jalankan:
+  \`${prefix} impact <path>\`
+- Butuh source sebuah fungsi? Gunakan \`${prefix} read symbol <nama>\`
+  alih-alih membaca file penuh.
+
+## Pengecualian
+Lewati ScopeCairn hanya untuk pertanyaan non-coding.
+`;
+}
+function skillMd(prefix) {
+  return `---
+name: scopecairn
+description: Gunakan untuk SEMUA task coding (fitur baru, bug fix, refactor,
+  pertanyaan tentang kode) sebelum menjelajah repository.
+---
+
+Langkah:
+1. Jalankan \`${prefix} context "<permintaan user>"\`.
+2. Baca bagian Relevant Files dan Task Scope.
+3. Jika ada perubahan pada simbol bersama, jalankan \`${prefix} impact <path>\`.
+4. Kerjakan task sesuai scope, lalu berhenti saat selesai.
+`;
+}
+function workflowMd(prefix) {
+  return `# /scopecairn
+
+Shortcut manual bila agent lupa memanggil ScopeCairn otomatis.
+
+1. Jalankan \`${prefix} context "<permintaan user>"\`.
+2. Ikuti Relevant Files dan Task Scope dari output.
+3. Perlu dampak perubahan? \`${prefix} impact <path>\`.
+4. Perlu source simbol? \`${prefix} read symbol <nama>\`.
+`;
+}
+var ALLOWLIST_COMMANDS = [
+  "context",
+  "impact",
+  "read",
+  "query",
+  "graph",
+  "status",
+  "doctor"
+];
+function allowlistGuide(prefix) {
+  const lines = ALLOWLIST_COMMANDS.map((c) => `  ${prefix} ${c}`);
+  return `Agar agent dapat memakai ScopeCairn tanpa persetujuan per panggilan,
+tambahkan entri berikut ke Terminal Allow List Antigravity
+(Settings \u2192 Advanced Settings \u2192 Terminal):
+
+` + lines.join("\n") + `
+
+Catatan: ScopeCairn tidak mengubah pengaturan IDE Anda secara otomatis.`;
+}
+
+// src/commands/doctor.ts
+function tick(ok) {
+  return ok ? "\u2713" : "\u2717";
+}
+async function cmdDoctor(repoRoot2) {
+  const nodeOk = Number(process.versions.node.split(".")[0]) >= 20;
+  console.log(`${tick(nodeOk)} Node.js ${process.version} (need >=20)`);
+  let sqliteOk = false;
+  try {
+    const { createRequire: createRequire2 } = await import("module");
+    const req = createRequire2(import.meta.url);
+    const m = req("node:sqlite");
+    sqliteOk = typeof m.DatabaseSync === "function";
+  } catch {
+    sqliteOk = false;
+  }
+  console.log(`${tick(sqliteOk)} SQLite (node:sqlite built-in)`);
+  const ts = await checkTreeSitter();
+  console.log(`${tick(ts.ok)} Tree-sitter ${ts.detail}`);
+  let dbOk = false;
+  let graphDetail = "";
+  try {
+    const db = openDb(repoRoot2);
+    db.prepare(`SELECT 1`).get();
+    const s = db.prepare(`SELECT COUNT(*) AS n FROM symbols`).get().n;
+    const r = db.prepare(`SELECT COUNT(*) AS n FROM relationships`).get().n;
+    db.close();
+    dbOk = fs8.existsSync(dbPath(repoRoot2));
+    graphDetail = ` (${s} symbols, ${r} rels)`;
+  } catch {
+    dbOk = false;
+  }
+  console.log(`${tick(dbOk)} Database ${dbPath(repoRoot2)}${graphDetail}`);
+  const protPath = path9.join(dataDir(repoRoot2), "protected.yml");
+  console.log(`${tick(fs8.existsSync(protPath))} Protected ${protPath}`);
+  const expectedPrefix = detectPrefix(repoRoot2);
+  const agentDir = detectAgentDir(repoRoot2);
+  const agentsPath = path9.join(repoRoot2, "AGENTS.md");
+  let agentsOk = false;
+  let agentsPrefix = null;
+  if (fs8.existsSync(agentsPath)) {
+    const text = fs8.readFileSync(agentsPath, "utf8");
+    agentsOk = text.includes(MARKER);
+    agentsPrefix = extractPrefixUsed(text);
+  }
+  console.log(`${tick(agentsOk)} AGENTS.md (${agentsOk ? "blok ScopeCairn ada" : "hilang \u2014 jalankan `scopecairn init`"})`);
+  const skillPath = path9.join(repoRoot2, agentDir, "skills", "scopecairn", "SKILL.md");
+  const skillOk = fs8.existsSync(skillPath);
+  console.log(`${tick(skillOk)} Skill (${agentDir}/skills/scopecairn/SKILL.md)`);
+  const wfPath = path9.join(repoRoot2, "workflows", "scopecairn.md");
+  console.log(`${tick(fs8.existsSync(wfPath))} Workflow (workflows/scopecairn.md, opsional)`);
+  let prefixOk = true;
+  if (agentsOk && agentsPrefix && agentsPrefix !== expectedPrefix) {
+    prefixOk = false;
+    console.log(
+      `\u2717 Prefix tak konsisten: AGENTS.md memakai \`${agentsPrefix}\`, instalasi terdeteksi \`${expectedPrefix}\`. Jalankan ulang \`scopecairn init\`.`
+    );
+  } else if (agentsOk) {
+    console.log(`\u2713 Prefix konsisten (\`${expectedPrefix} context\`)`);
+  }
+  console.log(`i Strict Mode mengabaikan allowlist \u2014 semua perintah tetap perlu persetujuan.`);
+  const healthy = nodeOk && sqliteOk && ts.ok && dbOk && agentsOk && skillOk && prefixOk;
+  console.log(`Status: ${healthy ? "HEALTHY" : "DEGRADED (see \u2717 above)"}`);
+}
+
+// src/invocations.ts
+function logInvocation(db, command, taskId) {
+  try {
+    db.prepare(`INSERT INTO invocations(task_id, command) VALUES (?, ?)`).run(
+      taskId ?? null,
+      command
+    );
+  } catch {
+  }
+}
+
+// src/graph.ts
+function asNode(r) {
+  return {
+    id: r["id"],
+    name: r["name"],
+    type: r["type"],
+    file: r["file"] ?? ""
+  };
+}
+function findSymbols(db, key) {
+  const byName = db.prepare(
+    `SELECT s.id, s.name, s.type, f.path AS file FROM symbols s
+       JOIN files f ON f.id = s.file_id WHERE s.name = ? LIMIT 20`
+  ).all(key);
+  if (byName.length > 0) return byName.map(asNode);
+  const like = db.prepare(
+    `SELECT s.id, s.name, s.type, f.path AS file FROM symbols s
+       JOIN files f ON f.id = s.file_id
+       WHERE s.name LIKE ? OR f.path LIKE ? LIMIT 20`
+  ).all(`%${key}%`, `%${key}%`);
+  return like.map(asNode);
+}
+function neighbors(db, id, limit = 50) {
+  const out = db.prepare(
+    `SELECT r.relationship_type AS rel, r.weight, r.confidence,
+              t.id, t.name, t.type, f.path AS file
+       FROM relationships r JOIN symbols t ON t.id = r.target_id
+       JOIN files f ON f.id = t.file_id
+       WHERE r.source_id = ? LIMIT ${limit}`
+  ).all(id);
+  const inn = db.prepare(
+    `SELECT r.relationship_type AS rel, r.weight, r.confidence,
+              s.id, s.name, s.type, f.path AS file
+       FROM relationships r JOIN symbols s ON s.id = r.source_id
+       JOIN files f ON f.id = s.file_id
+       WHERE r.target_id = ? LIMIT ${limit}`
+  ).all(id);
+  return [
+    ...out.map((r) => ({
+      rel: r["rel"],
+      weight: r["weight"],
+      confidence: r["confidence"],
+      other: asNode(r),
+      direction: "out"
+    })),
+    ...inn.map((r) => ({
+      rel: r["rel"],
+      weight: r["weight"],
+      confidence: r["confidence"],
+      other: asNode(r),
+      direction: "in"
+    }))
+  ];
+}
+
+// src/commands/graph.ts
+function cmdGraph(repoRoot2, key) {
+  const db = openDb(repoRoot2);
+  try {
+    logInvocation(db, "graph");
+    const hits = findSymbols(db, key);
+    if (hits.length === 0) {
+      console.log(`No symbol or file matching "${key}".`);
+      return;
+    }
+    const node = hits.find((h) => h.name === key) ?? hits[0];
+    if (hits.length > 1) {
+      console.log(`Matches: ${hits.map((h) => `${h.name} (${h.type}, ${h.file})`).join(" | ")}`);
+      console.log(`Showing: ${node.name} (${node.type}, ${node.file})`);
+      console.log("");
+    } else {
+      console.log(`${node.name} (${node.type}) \u2014 ${node.file}`);
+      console.log("");
+    }
+    const edges = neighbors(db, node.id);
+    if (edges.length === 0) {
+      console.log("(no relations)");
+      return;
+    }
+    const out = edges.filter((e) => e.direction === "out");
+    const inn = edges.filter((e) => e.direction === "in");
+    if (out.length > 0) {
+      console.log("Outgoing:");
+      for (const e of out.slice(0, 30)) {
+        console.log(
+          `  ${e.rel} \u2192 ${e.other.name} (${e.other.type}, ${e.other.file}) [w=${e.weight} c=${e.confidence}]`
+        );
+      }
+    }
+    if (inn.length > 0) {
+      console.log("Incoming:");
+      for (const e of inn.slice(0, 30)) {
+        console.log(
+          `  ${e.rel} \u2190 ${e.other.name} (${e.other.type}, ${e.other.file}) [w=${e.weight} c=${e.confidence}]`
+        );
+      }
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/query.ts
+function cmdQuery(repoRoot2, text) {
+  const db = openDb(repoRoot2);
+  try {
+    logInvocation(db, "query");
+    const rows = db.prepare(
+      `SELECT s.name, s.type, s.signature, f.path AS file
+         FROM symbols s JOIN files f ON f.id = s.file_id
+         WHERE s.name LIKE ? OR f.path LIKE ? OR s.signature LIKE ?
+         ORDER BY CASE WHEN s.name = ? THEN 0 WHEN s.name LIKE ? THEN 1 ELSE 2 END,
+                  s.name LIMIT 30`
+    ).all(`%${text}%`, `%${text}%`, `%${text}%`, text, `${text}%`);
+    if (rows.length === 0) {
+      console.log(`No matches for "${text}".`);
+      return;
+    }
+    for (const r of rows) {
+      console.log(`${r.name} (${r.type}) \u2014 ${r.file}${r.signature ? ` \u2014 ${r.signature.slice(0, 80)}` : ""}`);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/read.ts
+import fs9 from "fs";
+import path10 from "path";
+function cmdRead(repoRoot2, kind, name) {
+  if (kind !== "symbol") {
+    console.log(`Unknown read kind "${kind}". Usage: scopecairn read symbol <nama>`);
+    return;
+  }
+  const db = openDb(repoRoot2);
+  try {
+    logInvocation(db, "read");
+    const hits = findSymbols(db, name);
+    const node = hits.find((h) => h.name === name && h.type !== "file") ?? hits.find((h) => h.type !== "file") ?? hits[0];
+    if (!node) {
+      console.log(`No symbol matching "${name}".`);
+      return;
+    }
+    const row = db.prepare(`SELECT start_line, end_line FROM symbols WHERE id = ?`).get(node.id);
+    const abs = path10.join(repoRoot2, node.file);
+    let lines;
+    try {
+      lines = fs9.readFileSync(abs, "utf8").split("\n");
+    } catch {
+      console.log(`Cannot read ${node.file}.`);
+      return;
+    }
+    const start = Math.max(1, row.start_line - 1);
+    const end = Math.min(lines.length, Math.max(row.end_line, row.start_line + 40));
+    console.log(`# ${node.name} (${node.type}) \u2014 ${node.file}:${start}-${end}`);
+    console.log(lines.slice(start - 1, end).join("\n"));
+  } finally {
+    db.close();
+  }
+}
+
+// src/refresh.ts
+var BULK_THRESHOLD = 50;
+function refreshIndex(repoRoot2) {
+  const stats = scanRepository(repoRoot2);
+  const bulk = stats.inserted + stats.updated > BULK_THRESHOLD;
+  return { stats, bulk };
+}
+
+// src/retrieval/git.ts
+import { execFileSync } from "child_process";
+function runGit(repoRoot2, args) {
+  try {
+    return execFileSync("git", args, {
+      cwd: repoRoot2,
+      encoding: "utf8",
+      timeout: 8e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+  } catch {
+    return null;
+  }
+}
+function gitSignals(repoRoot2, seedFiles, maxCommits = 120) {
+  const empty = { recency: /* @__PURE__ */ new Map(), cochange: /* @__PURE__ */ new Map(), available: false };
+  const log = runGit(repoRoot2, [
+    "log",
+    `--max-count=${maxCommits}`,
+    "--name-only",
+    "--format=COMMIT:%h"
+  ]);
+  if (!log) return empty;
+  const commits = [];
+  let cur = [];
+  for (const line of log.split("\n")) {
+    const t = line.trim();
+    if (t.startsWith("COMMIT:")) {
+      if (cur.length > 0) commits.push(cur);
+      cur = [];
+    } else if (t) {
+      cur.push(t);
+    }
+  }
+  if (cur.length > 0) commits.push(cur);
+  if (commits.length === 0) return empty;
+  const recency = /* @__PURE__ */ new Map();
+  commits.forEach((files, i) => {
+    const score = 1 - i / commits.length;
+    for (const f of files) {
+      if (!recency.has(f)) recency.set(f, score);
+    }
+  });
+  const seedSet = new Set(seedFiles);
+  const partner = /* @__PURE__ */ new Map();
+  let seedCommits = 0;
+  for (const files of commits) {
+    if (files.some((f) => seedSet.has(f))) {
+      seedCommits++;
+      for (const f of files) {
+        if (!seedSet.has(f)) partner.set(f, (partner.get(f) ?? 0) + 1);
+      }
+    }
+  }
+  const cochange = /* @__PURE__ */ new Map();
+  if (seedCommits > 0) {
+    for (const [f, n] of partner) cochange.set(f, n / seedCommits);
+  }
+  return { recency, cochange, available: true };
+}
+
+// src/retrieval/retrieve.ts
+function expandGlossary(tokens, glossary) {
+  const out = new Set(tokens);
+  for (const t of tokens) {
+    for (const a of glossary.get(t) ?? []) out.add(a);
+    for (const [term, aliases] of glossary) {
+      if (aliases.includes(t)) out.add(term);
+    }
+  }
+  return [...out];
+}
+function retrieve(db, repoRoot2, task, opts) {
+  const config = loadConfig(repoRoot2);
+  if (opts?.topN) config.topN = opts.topN;
+  if (opts?.maxDepth) config.maxDepth = opts.maxDepth;
+  if (opts?.weights) Object.assign(config, opts.weights);
+  const baseTokens = tokenizeTask(task);
+  const tokens = expandGlossary(baseTokens, loadGlossary(repoRoot2));
+  const seeds = seedSearch(db, tokens);
+  const seedScore = new Map(seeds.map((s) => [s.symbolId, s.bm25]));
+  const proximity = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  let frontier = seeds.map((s) => s.symbolId);
+  seeds.forEach((s) => {
+    proximity.set(s.symbolId, Math.max(proximity.get(s.symbolId) ?? 0, s.bm25));
+    visited.add(s.symbolId);
+  });
+  const edgeStmt = db.prepare(
+    `SELECT source_id, target_id, weight FROM relationships`
+  );
+  const adj = /* @__PURE__ */ new Map();
+  for (const r of edgeStmt.all()) {
+    if (!adj.has(r.source_id)) adj.set(r.source_id, []);
+    adj.get(r.source_id).push({ to: r.target_id, w: r.weight });
+    if (!adj.has(r.target_id)) adj.set(r.target_id, []);
+    adj.get(r.target_id).push({ to: r.source_id, w: r.weight * 0.8 });
+  }
+  let hopScore = 1;
+  for (let depth = 1; depth <= config.maxDepth; depth++) {
+    hopScore *= config.decayPerHop;
+    const next = [];
+    for (const id of frontier) {
+      const base = proximity.get(id) ?? 0;
+      for (const e of adj.get(id) ?? []) {
+        const cand = base * e.w * hopScore;
+        if (cand > (proximity.get(e.to) ?? 0)) proximity.set(e.to, cand);
+        if (!visited.has(e.to)) {
+          visited.add(e.to);
+          next.push(e.to);
+        }
+      }
+    }
+    frontier = next;
+    if (frontier.length === 0) break;
+  }
+  const fanin = /* @__PURE__ */ new Map();
+  let maxFan = 1;
+  for (const r of db.prepare(`SELECT target_id AS id, COUNT(*) AS n FROM relationships GROUP BY target_id`).all()) {
+    fanin.set(r.id, r.n);
+    if (r.n > maxFan) maxFan = r.n;
+  }
+  const seedFiles = /* @__PURE__ */ new Set();
+  if (seeds.length > 0) {
+    const ph = seeds.map(() => "?").join(",");
+    for (const r of db.prepare(`SELECT DISTINCT f.path AS p FROM symbols s JOIN files f ON f.id = s.file_id WHERE s.id IN (${ph})`).all(...seeds.map((s) => s.symbolId))) {
+      seedFiles.add(r.p);
+    }
+  }
+  const git = gitSignals(repoRoot2, [...seedFiles]);
+  const meta = /* @__PURE__ */ new Map();
+  if (visited.size > 0) {
+    const ph = [...visited].map(() => "?").join(",");
+    for (const r of db.prepare(
+      `SELECT s.id, s.name, s.type, s.signature, f.path AS file FROM symbols s
+         JOIN files f ON f.id = s.file_id WHERE s.id IN (${ph})`
+    ).all(...[...visited])) {
+      meta.set(r.id, r);
+    }
+  }
+  const ranked = [];
+  let skippedFiles = 0;
+  for (const [id, prox] of proximity) {
+    const m = meta.get(id);
+    if (!m) continue;
+    if (m.type === "file") {
+      skippedFiles++;
+      continue;
+    }
+    const seed = seedScore.get(id) ?? 0;
+    const centrality = (fanin.get(id) ?? 0) / maxFan;
+    const recency = git.recency.get(m.file) ?? 0;
+    const cochange = git.cochange.get(m.file) ?? 0;
+    const score = config.wSeed * seed + config.wProximity * Math.min(1, prox) + config.wCentrality * centrality + config.wRecency * recency + config.wCochange * cochange;
+    const why = [];
+    if (seed > 0.05) why.push("seed");
+    if (prox > 0.05 && seed <= 0.05) why.push("graph");
+    if (centrality > 0.3) why.push("central");
+    if (recency > 0.5) why.push("recent");
+    if (cochange > 0.3) why.push("co-change");
+    ranked.push({
+      id,
+      name: m.name,
+      type: m.type,
+      file: m.file,
+      signature: m.signature,
+      score,
+      parts: { seed, proximity: Math.min(1, prox), centrality, recency, cochange },
+      reason: why.join("+") || "graph"
+    });
+  }
+  ranked.sort((a, b) => b.score - a.score);
+  if (ranked.length === 0 && skippedFiles > 0) {
+    const fileSeeds = seeds.map((s) => ({ id: s.symbolId, seed: s.bm25, m: meta.get(s.symbolId) })).filter((s) => s.m && s.m.type === "file").sort((a, b) => b.seed - a.seed).slice(0, 5);
+    for (const f of fileSeeds) {
+      ranked.push({
+        id: f.id,
+        name: f.m.name,
+        type: "file",
+        file: f.m.file,
+        signature: "",
+        score: config.wSeed * f.seed + 0.05,
+        parts: { seed: f.seed, proximity: 0, centrality: 0, recency: 0, cochange: 0 },
+        reason: "seed"
+      });
+    }
+  }
+  return { tokens, seeds: seeds.map((s) => s.symbolId), ranked: ranked.slice(0, config.topN), config, gitAvailable: git.available };
+}
+
+// src/retrieval/classify.ts
+var FANIN_THRESHOLD = 5;
+function moduleOf(file) {
+  const i = file.indexOf("/");
+  return i === -1 ? "." : file.slice(0, i);
+}
+function classify(ranked, faninOf, threshold = 0.15) {
+  const relevant = ranked.filter((r) => r.score >= threshold);
+  const files = [...new Set(relevant.map((r) => r.file))];
+  const modules = [...new Set(files.map(moduleOf))];
+  const reasons = [];
+  const DEFINITIONAL = /* @__PURE__ */ new Set([
+    "function",
+    "class",
+    "method",
+    "component",
+    "interface",
+    "type"
+  ]);
+  const highFanin = relevant.filter((r) => DEFINITIONAL.has(r.type) && faninOf(r.id) >= FANIN_THRESHOLD).map((r) => r.name);
+  const protectedHits = files.filter((f) => isProtected(f));
+  let complexity = "SIMPLE";
+  if (files.length >= 3) {
+    complexity = "COMPLEX";
+    reasons.push(`estimasi ${files.length} file (\u22653)`);
+  }
+  if (modules.length > 1) {
+    complexity = "COMPLEX";
+    reasons.push(`lintas modul (${modules.join(", ")})`);
+  }
+  if (highFanin.length > 0) {
+    complexity = "COMPLEX";
+    reasons.push(`simbol dipakai banyak tempat: ${highFanin.slice(0, 3).join(", ")}`);
+  }
+  if (protectedHits.length > 0) {
+    complexity = "COMPLEX";
+    reasons.push(`menyentuh area sensitif: ${protectedHits.slice(0, 3).join(", ")}`);
+  }
+  if (complexity === "SIMPLE") reasons.push(`estimasi ${files.length} file, 1 modul`);
+  return {
+    complexity,
+    estimatedFiles: files.length,
+    modules,
+    reasons,
+    highFanin,
+    protectedHits
+  };
+}
+
+// src/scope/scope.ts
+function computeScope(highFiles, mediumFiles, testFiles, patterns) {
+  const required = [];
+  const optional = [];
+  const protectedFiles = [];
+  const seen = /* @__PURE__ */ new Set();
+  const place = (f) => {
+    if (seen.has(f)) return;
+    seen.add(f);
+    if (isProtected(f, patterns)) protectedFiles.push(f);
+    else if (highFiles.includes(f)) required.push(f);
+    else optional.push(f);
+  };
+  for (const f of highFiles) place(f);
+  for (const f of mediumFiles) place(f);
+  for (const t of testFiles) {
+    if (seen.has(t)) continue;
+    seen.add(t);
+    if (isProtected(t, patterns)) protectedFiles.push(t);
+    else optional.push(t);
+  }
+  return { required, optional, protected: protectedFiles };
+}
+function scopeBlock(scope) {
+  const fmt = (xs) => xs.length > 0 ? xs.join(", ") : "-";
+  return `## Scope
+Required: ${fmt(scope.required)}
+Optional: ${fmt(scope.optional)}
+Protected: ${fmt(scope.protected)}
+`;
+}
+
+// src/scope/guard.ts
+var TASK_GUARD_RULES = [
+  "Ubah hanya file Required dan Optional; Protected perlu persetujuan user.",
+  "Jangan refactor, upgrade dependency, atau abstraksi prematur yang tak diminta.",
+  "Jangan tulis ulang kode berjalan; jangan tambah file/komentar tak perlu.",
+  "Berhenti saat acceptance criteria terpenuhi."
+];
+var DEFINITION_OF_DONE = [
+  "Fungsionalitas yang diminta terimplementasi",
+  "Test relevan lulus",
+  "Tidak ada file berubah tanpa alasan",
+  "Tidak ada refactoring tak terkait",
+  "Acceptance criteria terpenuhi"
+];
+function guardBlock() {
+  return `## Task Guard
+${TASK_GUARD_RULES.map((r) => `- ${r}`).join("\n")}
+
+## Definition of Done
+${DEFINITION_OF_DONE.map((d) => `- [ ] ${d}`).join("\n")}
+`;
+}
+
+// src/retrieval/contextBuilder.ts
+function buildContext(db, task, result, cls, opts) {
+  const complex = cls.complexity === "COMPLEX" || opts?.escalate === true;
+  if (!complex) {
+    const files = [];
+    for (const r of result.ranked) {
+      if (!files.includes(r.file)) files.push(r.file);
+      if (files.length >= 3) break;
+    }
+    const cand = files.length > 0 ? files.map((f) => `\`${f}\``).join(", ") : "pencarian langsung (tidak ada simbol cocok di index)";
+    return {
+      markdown: `# Task Context
+
+## Task
+${task}
+
+## Complexity
+SIMPLE (${cls.reasons.join("; ")})
+
+Task sederhana. Gunakan pencarian langsung. Kandidat: ${cand}
+`,
+      high: [],
+      medium: [],
+      tests: [],
+      dependencies: []
+    };
+  }
+  const ranked = result.ranked;
+  const hi = ranked.filter((r) => r.score >= 0.3).slice(0, 10);
+  const med = ranked.filter((r) => r.score >= 0.15 && r.score < 0.3).slice(0, 10);
+  const highFiles = [...new Set(hi.map((r) => r.file))];
+  const medFiles = [...new Set(med.map((r) => r.file))].filter((f) => !highFiles.includes(f));
+  const deps = [];
+  if (highFiles.length > 0) {
+    const ph = highFiles.map(() => "?").join(",");
+    try {
+      const rows = db.prepare(
+        `SELECT DISTINCT f1.path AS a, f2.path AS b
+           FROM relationships r
+           JOIN symbols s1 ON s1.id = r.source_id
+           JOIN symbols s2 ON s2.id = r.target_id
+           JOIN files f1 ON f1.id = s1.file_id
+           JOIN files f2 ON f2.id = s2.file_id
+           WHERE r.relationship_type IN ('IMPORTS','CALLS')
+             AND f1.path IN (${ph}) AND f2.path IN (${ph}) AND f1.path != f2.path
+           LIMIT 10`
+      ).all(...highFiles, ...highFiles);
+      for (const r of rows) deps.push(`${r.a} \u2192 ${r.b}`);
+    } catch {
+    }
+  }
+  const testSet = /* @__PURE__ */ new Set();
+  if (highFiles.length > 0) {
+    const ph = highFiles.map(() => "?").join(",");
+    try {
+      const rows = db.prepare(
+        `SELECT DISTINCT f2.path AS t
+           FROM relationships r
+           JOIN symbols s1 ON s1.id = r.source_id
+           JOIN symbols s2 ON s2.id = r.target_id
+           JOIN files f1 ON f1.id = s1.file_id
+           JOIN files f2 ON f2.id = s2.file_id
+           WHERE r.relationship_type = 'TESTS'
+             AND (f1.path IN (${ph}) OR f2.path IN (${ph}))`
+      ).all(...highFiles, ...highFiles);
+      for (const r of rows) testSet.add(r.t);
+    } catch {
+    }
+  }
+  for (const r of ranked) {
+    if (/(test|spec)/i.test(r.file)) testSet.add(r.file);
+  }
+  const tests = [...testSet].slice(0, 10);
+  const symLine = (r) => `- ${r.name} (${r.type}) \u2014 \`${r.file}\` [${r.score.toFixed(2)} ${r.reason}]`;
+  const scope = computeScope(
+    highFiles,
+    medFiles,
+    tests,
+    loadProtectedPatterns(opts?.repoRoot ?? ".")
+  );
+  const md = `# Task Context
+
+## Task
+${task}
+
+## Complexity
+${cls.complexity} (${cls.reasons.join("; ")})
+
+## Relevant Files
+### HIGH
+${highFiles.map((f) => `- ${f}`).join("\n") || "-"}
+### MEDIUM
+${medFiles.map((f) => `- ${f}`).join("\n") || "-"}
+
+## Key Symbols
+${hi.slice(0, 8).map(symLine).join("\n") || "-"}
+
+## Dependencies
+${deps.map((d) => `- ${d}`).join("\n") || "-"}
+
+## Related Tests
+${tests.map((t) => `- ${t}`).join("\n") || "-"}
+
+` + scopeBlock(scope) + `
+` + guardBlock();
+  return { markdown: md, high: highFiles, medium: medFiles, tests, dependencies: deps };
+}
+
+// src/commands/context.ts
+function cmdContext(repoRoot2, task, opts = {}) {
+  if (!opts.noRefresh) {
+    const { stats, bulk } = refreshIndex(repoRoot2);
+    if (bulk) {
+      console.log(
+        `> Note: ${stats.inserted + stats.updated} file berubah (mis. git pull/ganti branch). Konteks tetap dibuat; jalankan \`scopecairn scan\` bila hasil terasa usang.
+`
+      );
+    }
+  }
+  const db = openDb(repoRoot2);
+  try {
+    const fileCount = db.prepare(`SELECT COUNT(*) AS n FROM files`).get().n;
+    if (fileCount === 0) {
+      console.log("Index kosong. Jalankan `scopecairn scan` dulu.");
+      return;
+    }
+    const result = retrieve(db, repoRoot2, task);
+    if (result.ranked.length === 0) {
+      logInvocation(db, "context");
+      console.log(
+        `# Task Context
+
+## Task
+${task}
+
+## Complexity
+SIMPLE (tidak ada simbol cocok di index)
+
+Task sederhana. Gunakan pencarian langsung. Bila istilah domain tak cocok dengan nama kode, tambah alias di \`.scopecairn/glossary.yml\`.
+`
+      );
+      return;
+    }
+    const faninOf = (id) => {
+      const r = db.prepare(`SELECT COUNT(*) AS n FROM relationships WHERE target_id = ?`).get(id);
+      return r.n;
+    };
+    const cls = classify(result.ranked, faninOf);
+    const t = db.prepare(`INSERT INTO tasks(description, complexity) VALUES (?, ?)`).run(task, opts.escalate ? "COMPLEX" : cls.complexity);
+    const taskId = Number(t.lastInsertRowid);
+    const insCtx = db.prepare(
+      `INSERT INTO task_context(task_id, symbol_id, score, reason) VALUES (?, ?, ?, ?)`
+    );
+    for (const r of result.ranked.slice(0, 20)) {
+      insCtx.run(taskId, r.id, r.score, r.reason);
+    }
+    logInvocation(db, "context", taskId);
+    const built = buildContext(db, task, result, cls, {
+      escalate: opts.escalate,
+      repoRoot: repoRoot2
+    });
+    console.log(built.markdown);
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/impact.ts
+function cmdImpact(repoRoot2, target, opts = {}) {
+  if (!opts.noRefresh) refreshIndex(repoRoot2);
+  const db = openDb(repoRoot2);
+  try {
+    logInvocation(db, "impact");
+    let seeds = findSymbols(db, target);
+    if (seeds.length === 0) {
+      const rows = db.prepare(
+        `SELECT s.id, s.name, s.type, f.path AS file FROM symbols s
+           JOIN files f ON f.id = s.file_id WHERE f.path LIKE ? LIMIT 20`
+      ).all(`%${target}`);
+      seeds = rows;
+    }
+    if (seeds.length === 0) {
+      console.log(`Tidak ada file/simbol yang cocok dengan "${target}".`);
+      return;
+    }
+    const fileHit = seeds.find((s) => s.type === "file");
+    const center = fileHit ?? seeds[0];
+    const centerLabel = fileHit != null ? `${center.file}` : `${center.name} (${center.type}, ${center.file})`;
+    const direct = neighbors(db, center.id);
+    const directIds = new Set(direct.map((e) => e.other.id));
+    const indirect = /* @__PURE__ */ new Map();
+    for (const e of direct.slice(0, 20)) {
+      for (const e2 of neighbors(db, e.other.id, 20)) {
+        if (e2.other.id === center.id || directIds.has(e2.other.id)) continue;
+        if (!indirect.has(e2.other.id)) {
+          indirect.set(e2.other.id, {
+            name: e2.other.name,
+            type: e2.other.type,
+            file: e2.other.file,
+            via: e.other.name,
+            rel: e2.rel
+          });
+        }
+        if (indirect.size >= 15) break;
+      }
+      if (indirect.size >= 15) break;
+    }
+    const fmtFile = (f) => isProtected(f, loadProtectedPatterns(repoRoot2)) ? `${f} \u26A0 Protected` : f;
+    const byRel = (rel, dir) => {
+      const seen = /* @__PURE__ */ new Set();
+      const out = [];
+      for (const e of direct) {
+        if (e.rel !== rel || e.direction !== dir) continue;
+        const label = e.other.type === "file" ? e.other.file : `${e.other.name} (${e.other.file})`;
+        if (!seen.has(label)) {
+          seen.add(label);
+          out.push(label);
+        }
+        if (out.length >= 15) break;
+      }
+      if (out.length === 0 && fileHit != null && (rel === "CALLS" || rel === "USES")) {
+        try {
+          const rows = db.prepare(
+            `SELECT DISTINCT t.name AS n, f.path AS p
+               FROM relationships r
+               JOIN symbols s ON s.id = ${dir === "out" ? "r.source_id" : "r.target_id"}
+               JOIN symbols t ON t.id = ${dir === "out" ? "r.target_id" : "r.source_id"}
+               JOIN files f ON f.id = t.file_id
+               WHERE s.file_id = (SELECT file_id FROM symbols WHERE id = ?)
+                 AND r.relationship_type = ? AND t.type != 'file'
+               LIMIT 8`
+          ).all(center.id, rel);
+          for (const r of rows) {
+            const label = `${r.n} (${r.p})`;
+            if (!seen.has(label)) {
+              seen.add(label);
+              out.push(label);
+            }
+          }
+        } catch {
+        }
+      }
+      return out;
+    };
+    const directFiles = [...new Set(direct.map((e) => e.other.file))].filter(
+      (f) => f !== center.file
+    );
+    const indirectVals = [...indirect.values()];
+    const testFiles = [
+      .../* @__PURE__ */ new Set([
+        ...direct.filter((e) => e.rel === "TESTS").map((e) => e.other.file),
+        ...indirectVals.filter((v) => v.rel === "TESTS").map((v) => v.file),
+        ...directFiles.filter((f) => /(test|spec)/i.test(f)),
+        ...indirectVals.map((v) => v.file).filter((f) => /(test|spec)/i.test(f))
+      ])
+    ].slice(0, 10);
+    const ui = [
+      ...new Set(
+        [...direct.map((e) => e.other), ...indirectVals].filter((n) => n.type === "component").map((n) => `${n.name} (${n.file})`)
+      )
+    ].slice(0, 10);
+    const lines = [
+      `# Impact: ${centerLabel}`,
+      ``,
+      `## Direct (${directFiles.length} file)`,
+      ...directFiles.slice(0, 15).map((f) => `- ${fmtFile(f)}`),
+      ...directFiles.length === 0 ? ["- (tidak ada)"] : [],
+      ``,
+      `## Detail`,
+      `Diimpor oleh: ${byRel("IMPORTS", "in").join(", ") || "-"}`,
+      `Memanggil: ${byRel("CALLS", "out").join(", ") || "-"}`,
+      `Dipanggil oleh: ${byRel("CALLS", "in").join(", ") || "-"}`,
+      ``,
+      `## Indirect (${indirect.size})`,
+      ...[...indirect.values()].slice(0, 15).map((v) => `- ${v.name} (${v.type}, ${v.file}) via ${v.via}`),
+      ...indirect.size === 0 ? ["- (tidak ada)"] : [],
+      ``,
+      `## Tests`,
+      ...testFiles.map((t) => `- ${t}`),
+      ...testFiles.length === 0 ? ["- (tidak ada test terkait di index)"] : [],
+      ``,
+      `## UI Components`,
+      ...ui.map((u) => `- ${u}`),
+      ...ui.length === 0 ? ["- (tidak ada)"] : []
+    ];
+    console.log(lines.join("\n"));
+  } finally {
+    db.close();
+  }
+}
+
+// src/commands/init.ts
+import fs10 from "fs";
+import path11 from "path";
+function cmdInit(repoRoot2) {
+  console.log("ScopeCairn");
+  console.log("\u2713 Repository detected");
+  const stats = scanRepository(repoRoot2);
+  console.log(`\u2713 ${stats.sourceFiles} source files`);
+  if (stats.metaFiles > 0) console.log(`\u2713 ${stats.metaFiles} config/schema files`);
+  console.log(`\u2713 ${stats.symbols} symbols`);
+  console.log(`\u2713 ${stats.relationships} relationships`);
+  const prefix = detectPrefix(repoRoot2);
+  const agentDir = detectAgentDir(repoRoot2);
+  const agentsPath = path11.join(repoRoot2, "AGENTS.md");
+  const block = agentsMd(prefix);
+  if (fs10.existsSync(agentsPath)) {
+    const cur = fs10.readFileSync(agentsPath, "utf8");
+    if (cur.includes(MARKER)) {
+      const re = new RegExp(`${MARKER}[\\s\\S]*?(?=\\n#[^#]|$)`, "");
+      const next = cur.replace(re, block.trimEnd());
+      fs10.writeFileSync(agentsPath, next.trimEnd() + "\n");
+      console.log("\u2713 AGENTS.md updated (blok ScopeCairn diganti)");
+    } else {
+      fs10.writeFileSync(agentsPath, cur.trimEnd() + "\n\n" + block);
+      console.log("\u2713 AGENTS.md extended (blok ScopeCairn ditambahkan)");
+    }
+  } else {
+    fs10.writeFileSync(agentsPath, block);
+    console.log("\u2713 AGENTS.md generated");
+  }
+  const skillPath = path11.join(repoRoot2, agentDir, "skills", "scopecairn", "SKILL.md");
+  fs10.mkdirSync(path11.dirname(skillPath), { recursive: true });
+  fs10.writeFileSync(skillPath, skillMd(prefix));
+  console.log(`\u2713 Skill installed (${path11.relative(repoRoot2, skillPath)})`);
+  const wfPath = path11.join(repoRoot2, "workflows", "scopecairn.md");
+  fs10.mkdirSync(path11.dirname(wfPath), { recursive: true });
+  fs10.writeFileSync(wfPath, workflowMd(prefix));
+  console.log(`\u2713 Workflow installed (${path11.relative(repoRoot2, wfPath)})`);
+  console.log("Ready.");
+  console.log("");
+  console.log(allowlistGuide(prefix));
+}
+
+// src/benchmark/run.ts
+import fs11 from "fs";
+import path12 from "path";
+
+// src/benchmark/dataset.ts
+var BENCHMARK_TASKS = [
+  {
+    task: "Add ranking weight configuration",
+    expected: ["src/retrieval/retrieve.ts", "src/retrieval/config.ts"]
+  },
+  {
+    task: "Change impact analysis for a file",
+    expected: ["src/commands/impact.ts", "src/graph.ts"]
+  },
+  {
+    task: "Task scope required optional protected files",
+    expected: ["src/scope/scope.ts", "src/scope/protected.ts"]
+  },
+  {
+    task: "Generate AGENTS.md skill workflow on init",
+    expected: ["src/commands/init.ts", "src/integrate/templates.ts"]
+  },
+  {
+    task: "Repository scanner ignore rules",
+    expected: ["src/scanner.ts", "src/ignore.ts"]
+  },
+  {
+    task: "Symbol extraction typescript functions classes",
+    expected: ["src/extract/typescript.ts", "src/extract/types.ts"]
+  },
+  {
+    task: "Invocation logging compliance rate",
+    expected: ["src/invocations.ts", "src/commands/status.ts"]
+  },
+  {
+    task: "Upgrade dependencies in package json",
+    expected: ["package.json", "package-lock.json"]
+  },
+  {
+    task: "Read symbol source excerpt",
+    expected: ["src/commands/read.ts", "src/graph.ts"]
+  },
+  {
+    task: "Git recency co-change signals ranking",
+    expected: ["src/retrieval/git.ts", "src/retrieval/retrieve.ts"]
+  },
+  {
+    task: "Complexity classifier simple versus complex",
+    expected: ["src/retrieval/classify.ts", "src/retrieval/contextBuilder.ts"]
+  },
+  {
+    task: "Health check integration files prefix",
+    expected: ["src/commands/doctor.ts", "src/integrate/detect.ts"]
+  }
+];
+
+// src/benchmark/run.ts
+function fileChars(repoRoot2, rel) {
+  try {
+    return fs11.readFileSync(path12.join(repoRoot2, rel), "utf8").length;
+  } catch {
+    return 0;
+  }
+}
+function runBenchmark(db, repoRoot2, opts) {
+  const tasks = [];
+  for (const t of BENCHMARK_TASKS) {
+    const res = retrieve(db, repoRoot2, t.task, opts);
+    const files = [];
+    const high = [];
+    for (const r of res.ranked) {
+      if (r.score >= 0.3 && !high.includes(r.file)) high.push(r.file);
+      if (r.score < 0.15) break;
+      if (!files.includes(r.file)) files.push(r.file);
+      if (files.length >= 10) break;
+    }
+    const firstRead = high.length > 0 ? high : files.slice(0, 3);
+    const hits = t.expected.filter((e) => files.includes(e));
+    const recall = t.expected.length > 0 ? hits.length / t.expected.length : 1;
+    const highHits = t.expected.filter((e) => firstRead.includes(e));
+    const irrelevantRatio = firstRead.length > 0 ? (firstRead.length - highHits.length) / firstRead.length : 0;
+    const baselineChars = t.expected.reduce((a, f) => a + fileChars(repoRoot2, f), 0) * 2;
+    const optimizedChars = Math.max(1, res.ranked.slice(0, 8).length * 1200);
+    const contextReduction = baselineChars > 0 ? Math.max(0, 1 - optimizedChars / baselineChars) : 0;
+    tasks.push({
+      task: t.task,
+      expected: t.expected,
+      retrievedFiles: files,
+      highFiles: firstRead,
+      hits,
+      recall,
+      irrelevantRatio,
+      baselineChars,
+      optimizedChars,
+      contextReduction
+    });
+  }
+  const avg = (xs) => xs.length > 0 ? xs.reduce((a, b) => a + b, 0) / xs.length : 0;
+  return {
+    tasks,
+    avgRecall: avg(tasks.map((t) => t.recall)),
+    avgIrrelevant: avg(tasks.map((t) => t.irrelevantRatio)),
+    avgReduction: avg(tasks.map((t) => t.contextReduction)),
+    recallAtThreshold: tasks.filter((t) => t.recall >= 0.5).length / tasks.length
+  };
+}
+function tuneWeights(db, repoRoot2) {
+  const base = {
+    weights: { wSeed: 0.3, wProximity: 0.35, wCentrality: 0.15 },
+    avgRecall: 0,
+    avgIrrelevant: 0
+  };
+  const baseSum = runBenchmark(db, repoRoot2, { weights: base.weights });
+  base.avgRecall = baseSum.avgRecall;
+  base.avgIrrelevant = baseSum.avgIrrelevant;
+  let best = base;
+  let tried = 0;
+  for (const wSeed of [0.2, 0.3, 0.4, 0.5]) {
+    for (const wProximity of [0.25, 0.35, 0.45]) {
+      for (const wCentrality of [0.1, 0.15, 0.2]) {
+        tried++;
+        const s = runBenchmark(db, repoRoot2, {
+          weights: { wSeed, wProximity, wCentrality }
+        });
+        const better = s.avgRecall > best.avgRecall || s.avgRecall === best.avgRecall && s.avgIrrelevant < best.avgIrrelevant;
+        if (better) {
+          best = {
+            weights: { wSeed, wProximity, wCentrality },
+            avgRecall: s.avgRecall,
+            avgIrrelevant: s.avgIrrelevant
+          };
+        }
+      }
+    }
+  }
+  return { best, baseline: base, tried };
+}
+
+// src/benchmark/report.ts
+function benchmarkReport(summary, tune, gitAvailable) {
+  const pct = (x) => `${(x * 100).toFixed(0)}%`;
+  const lines = [
+    `# ScopeCairn Benchmark`,
+    ``,
+    `Dataset: ${summary.tasks.length} task (repo sendiri, ground truth file relevan).`,
+    `Git signals: ${gitAvailable ? "aktif" : "nonaktif (bukan repo git \u2014 wRecency/wCochange = 0)"}.`,
+    ``,
+    `## Ringkasan otomatis`,
+    ``,
+    `| Metrik | Hasil | Ambang \xA718 | Status |`,
+    `|---|---|---|---|`,
+    `| Retrieval recall (rata-rata, konteks penuh) | ${pct(summary.avgRecall)} | ditetapkan awal \u2265 70% | ${summary.avgRecall >= 0.7 ? "\u2713" : "\u2717"} |`,
+    `| Task recall \u2265 50% | ${pct(summary.recallAtThreshold)} | \u2014 | \u2014 |`,
+    `| Irrelevant file ratio (bacaan pertama HIGH) | ${pct(summary.avgIrrelevant)} | < 20% | ${summary.avgIrrelevant < 0.2 ? "\u2713" : "\u2717"} |`,
+    `| Context reduction (estimasi) | ${pct(summary.avgReduction)} | \u2265 30% | ${summary.avgReduction >= 0.3 ? "\u2713" : "\u2717"} |`,
+    ``,
+    `## Per task`,
+    ``,
+    `| Task | Recall | Irrelevant | Ditemukan | Bacaan pertama |`,
+    `|---|---|---|---|---|`
+  ];
+  for (const t of summary.tasks) {
+    lines.push(
+      `| ${t.task} | ${pct(t.recall)} | ${pct(t.irrelevantRatio)} | ${t.hits.join(", ") || "-"} | ${t.highFiles.join(", ") || "-"} |`
+    );
+  }
+  if (tune) {
+    const b = tune.best;
+    lines.push(
+      ``,
+      `## Kalibrasi bobot (${tune.tried} kombinasi)`,
+      ``,
+      `Baseline: seed=${tune.baseline.weights.wSeed} prox=${tune.baseline.weights.wProximity} cent=${tune.baseline.weights.wCentrality} \u2192 recall ${pct(tune.baseline.avgRecall)}, irrelevant ${pct(tune.baseline.avgIrrelevant)}`,
+      `Terbaik: seed=${b.weights.wSeed} prox=${b.weights.wProximity} cent=${b.weights.wCentrality} \u2192 recall ${pct(b.avgRecall)}, irrelevant ${pct(b.avgIrrelevant)}`,
+      tune.best.avgRecall - tune.baseline.avgRecall > 0.05 ? `Rekomendasi: terapkan ke \`.scopecairn/config.yml\` (gain > 5%).` : `Rekomendasi: pertahankan default (gain \u2264 5% \u2014 hindari overfit ke 12 task).`
+    );
+  }
+  lines.push(
+    ``,
+    `## Protokol manual (butuh agent run)`,
+    ``,
+    `Otomatisasi di atas tak mengukur: token input riil, tool call, waktu,`,
+    `task success, compliance rate. Protokol: 10 task nyata \xD7 2 kondisi`,
+    `(agent saja vs agent + \`scopecairn context\`), catat token/tool/file/success`,
+    `per \xA718.2. Compliance = task dengan pemanggilan tercatat di \`invocations\`.`
+  );
+  return lines.join("\n");
+}
+
+// src/commands/benchmark.ts
+function cmdBenchmark(repoRoot2, opts = {}) {
+  if (!opts.noRefresh) refreshIndex(repoRoot2);
+  const db = openDb(repoRoot2);
+  try {
+    const fileCount = db.prepare(`SELECT COUNT(*) AS n FROM files`).get().n;
+    if (fileCount === 0) {
+      console.log("Index kosong. Jalankan `scopecairn scan` dulu.");
+      return;
+    }
+    const git = gitSignals(repoRoot2, []);
+    const summary = runBenchmark(db, repoRoot2);
+    const tune = opts.tune ? tuneWeights(db, repoRoot2) : null;
+    console.log(benchmarkReport(summary, tune, git.available));
+  } finally {
+    db.close();
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("scopecairn").description("ScopeCairn \u2014 local-first codebase intelligence layer").version("0.1.0");
+function repoRoot() {
+  return path13.resolve(process.cwd());
+}
+program.command("scan").description("Index repository (Fase 1: files + hash + language)").action(() => cmdScan(repoRoot()));
+program.command("status").description("Show index status").action(() => cmdStatus(repoRoot()));
+program.command("clean").description("Remove generated index data").action(() => cmdClean(repoRoot()));
+program.command("rebuild").description("Rebuild index from scratch (recover from corrupt index)").action(() => cmdRebuild(repoRoot()));
+program.command("doctor").description("Check integration health").action(async () => {
+  await cmdDoctor(repoRoot());
+});
+program.command("graph <symbol>").description("Show relations of a symbol (Fase 2: 1-hop traversal)").action((symbol) => cmdGraph(repoRoot(), symbol));
+program.command("query <text>").description("Search symbols/codebase knowledge (substring match)").action((text) => cmdQuery(repoRoot(), text));
+program.command("read").argument("<kind>", "what to read (symbol)").argument("<name>", "symbol name").description("Read a symbol's source excerpt (not the whole file)").action((kind, name) => cmdRead(repoRoot(), kind, name));
+program.command("context <task>").description("Main entry point: auto-refresh + classify + relevant context + scope").option("--escalate", "force full COMPLEX context").option("--no-refresh", "skip incremental refresh (debugging/benchmark)").action(
+  (task, opts) => cmdContext(repoRoot(), task, opts)
+);
+program.command("impact <target>").description("Change impact analysis: file, symbol, function, or class").option("--no-refresh", "skip incremental refresh (debugging/benchmark)").action(
+  (target, opts) => cmdImpact(repoRoot(), target, opts)
+);
+program.command("init").description("Initial indexing + generate AGENTS.md, Skill, Workflow").action(() => cmdInit(repoRoot()));
+program.command("benchmark").description("Retrieval recall, irrelevant ratio, context reduction + weight tuning").option("--tune", "grid search bobot FR-05").option("--no-refresh", "skip incremental refresh (debugging/benchmark)").action(
+  (opts) => cmdBenchmark(repoRoot(), opts)
+);
+program.parseAsync(process.argv);