@contextline/contextline 0.1.1 → 0.2.0

package/dist/cli.js

@@ -3,9 +3,6 @@
 // src/cli.ts
 import { Command } from "commander";
 
-// src/tools/appendFragment.ts
-import fs5 from "fs/promises";
-
 // src/config.ts
 import fs from "fs";
 import path from "path";
@@ -17,9 +14,145 @@ function resolveRoot(folder) {
   if (folder) return path.resolve(folder);
   return getMemoryRoot();
 }
+function hasMemoryRoot(folder) {
+  const root = resolveRoot(folder);
+  try {
+    return fs.statSync(root).isDirectory();
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
 
-// src/paths.ts
+// src/core/instructions.ts
+var CONTEXTLINE_INSTRUCTIONS_FILE = "contextline_instructions.md";
+function memorySaveRules(root) {
+  const l2 = root ? `"${root}/L2_Deep/[topic].md"` : `L2_Deep/[topic].md`;
+  const l1 = root ? `"${root}/L1_Quick.md"` : `L1_Quick.md`;
+  return `SAVE THESE \u2014 do not skip any:
+- Any decision made, even informal ("skip this", "do it this way", "won't fix")
+- Any finding or discovery made by either user or assistant
+- Any correction to prior understanding
+- Any document reviewed and key feedback given
+- Any item resolved, approved, or declined
+- Any new direction chosen \u2014 save alternatives considered and rationale too
+
+DO NOT SAVE: transient tool outputs, session navigation, file paths read, intermediate mechanics.
+
+HOW TO SAVE (use file read/write tools \u2014 NOT Bash or shell commands):
+1. Save to ${l2} \u2014 the DETAIL layer. Write 2\u20134 sentences per fact:
+   what happened + why + what was considered + what it means going forward.
+   Format: "(YYYY-MM-DD) [full context with rationale and impact]"
+   - Read the file, then Write it back with the new entry at the TOP, above existing entries (after any leading # header line)
+   - Create the file if the topic is new
+   - Semantic filenames: project_x.md, preference_user.md, person_alice.md, area_work.md
+   - Save to ALL relevant topic files when a fact involves multiple topics
+   - If your L2 entry looks like your L1 summary, it is too thin \u2014 add the why and context.
+2. Save a SHORT pointer to ${l1} \u2014 the INDEX layer. \u226415 words, no detail.
+   "(YYYY-MM-DD) [subject + what happened]. \u2192 [topic].md"
+   - Read the file, then Write it back with the new line at the TOP of the entries (after any leading header lines)
+   - L1 is a scannable index only. If you are writing more than 15 words, move the detail to L2.
+
+ADD ONLY \u2014 never modify or delete existing lines. New entries go at the top. Date every L2 entry: (YYYY-MM-DD).
+
+"No new facts to save" should be RARE. If in doubt, save. Missed saves break continuity; redundant saves are harmless.
+
+Before responding, confirm on one line \u2014 either "Saved: [what] \u2192 [topic].md" or "Nothing saved: [reason]". This line is mandatory. Skipping it means the user cannot verify whether memory was updated.`;
+}
+var DEFAULT_CONTEXTLINE_INSTRUCTIONS = `# ContextLine Memory
+
+CONTEXTLINE-INSTRUCTIONS-V2
+
+Memory lives in two layers inside this folder:
+
+- **L1_Quick.md** \u2014 compact one-line facts and topic pointers. One line per topic, kept brief.
+- **L2_Deep/[topic].md** \u2014 full dated detail per topic. Always append; never edit existing lines.
+
+## Rules
+
+ADD ONLY. Every write adds new lines at the top of the file's entry list (after any # header lines). Never modify or delete existing content.
+
+Date every L2 line: (YYYY-MM-DD). Newer entries win on contradictions \u2014 do not remove older ones. New entries go at the top so the LLM encounters the most recent context first.
+
+Use semantic filenames for L2 files: project_debatrix.md, preference_user.md, person_alice.md, area_work.md, decision_auth.md, event_launch.md.
+
+Cross-save: if a fact involves multiple topics (person + project, place + event), append the relevant angle to each file.
+
+## Saving
+
+${memorySaveRules()}
+`;
+
+// src/hook.ts
 import path2 from "path";
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  return Buffer.concat(chunks).toString("utf8");
+}
+function sessionStartInstruction(root) {
+  return `ContextLine memory is available. Read the file at "${root}/L1_Quick.md" to load your memory index. It contains compact facts and topic pointers. If you need detail on a specific topic, read the relevant file from "${root}/L2_Deep/". Only read L2 files when needed \u2014 do not load the entire directory.`;
+}
+function checkpointInstruction(root) {
+  return `ContextLine memory checkpoint. Before responding, append any new durable facts to disk.
+
+${memorySaveRules(root)}`;
+}
+function continueWithoutContext() {
+  process.stdout.write(JSON.stringify({ continue: true }));
+}
+async function runHook(rootInput) {
+  const raw = await readStdin();
+  const event = raw.trim() ? JSON.parse(raw) : {};
+  const root = rootInput ? path2.resolve(rootInput) : resolveRoot();
+  const hasRoot = hasMemoryRoot(root);
+  if (event.hook_event_name === "SessionStart") {
+    if (!hasRoot) {
+      continueWithoutContext();
+      return;
+    }
+    process.stdout.write(
+      JSON.stringify({
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "SessionStart",
+          additionalContext: sessionStartInstruction(root)
+        }
+      })
+    );
+    return;
+  }
+  if (event.hook_event_name === "UserPromptSubmit") {
+    if (!hasRoot) {
+      continueWithoutContext();
+      return;
+    }
+    process.stdout.write(
+      JSON.stringify({
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext: checkpointInstruction(root)
+        }
+      })
+    );
+    return;
+  }
+}
+
+// src/setup.ts
+import { cwd } from "process";
+
+// src/host/claude.ts
+import fs3 from "fs/promises";
+import os from "os";
+import path4 from "path";
+
+// src/tools/createMemorySkeleton.ts
+import fs2 from "fs/promises";
+
+// src/paths.ts
+import path3 from "path";
 
 // src/core/errors.ts
 var ContextLineError = class extends Error {
@@ -38,12 +171,11 @@ var PathSafetyError = class extends ContextLineError {
 // src/paths.ts
 var L1_FILE = "L1_Quick.md";
 var L2_DIR = "L2_Deep";
-var L3_DIR = "L3_Details";
 function assertSafeRelative(input) {
   if (!input || input.trim() !== input) {
     throw new PathSafetyError("Path input must be non-empty and contain no leading/trailing whitespace.");
   }
-  if (path2.isAbsolute(input)) {
+  if (path3.isAbsolute(input)) {
     throw new PathSafetyError("Absolute paths are not allowed in tool inputs.");
   }
   const parts = input.split(/[\\/]+/);
@@ -51,454 +183,185 @@ function assertSafeRelative(input) {
     throw new PathSafetyError("Path traversal and empty path segments are not allowed.");
   }
 }
-function assertSafeRelativeFile(input) {
-  assertSafeRelative(input);
-  if (!input.endsWith(".md")) {
-    throw new PathSafetyError("Memory file paths must end with .md.");
-  }
-}
 function safeJoin(root, ...segments) {
   for (const segment of segments) {
     assertSafeRelative(segment);
   }
-  const resolvedRoot = path2.resolve(root);
-  const target = path2.resolve(resolvedRoot, ...segments);
-  const rel = path2.relative(resolvedRoot, target);
-  if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+  const resolvedRoot = path3.resolve(root);
+  const target = path3.resolve(resolvedRoot, ...segments);
+  const rel = path3.relative(resolvedRoot, target);
+  if (rel.startsWith("..") || path3.isAbsolute(rel)) {
     throw new PathSafetyError("Resolved path escapes ContextLine root.");
   }
   return target;
 }
-function deepPath(root, file) {
-  assertSafeRelativeFile(file);
-  if (file.includes("/") || file.includes("\\")) {
-    throw new PathSafetyError("L2 deep memory files must be flat filenames inside L2_Deep for V1.");
-  }
-  return safeJoin(root, L2_DIR, file);
-}
-function detailPath(root, file) {
-  assertSafeRelativeFile(file);
-  return safeJoin(root, L3_DIR, file);
-}
-function l1Path(root) {
-  return safeJoin(root, L1_FILE);
-}
 
-// src/core/atomicWrite.ts
-import fs2 from "fs/promises";
-import path3 from "path";
-async function atomicWriteFile(filePath, content) {
-  await fs2.mkdir(path3.dirname(filePath), { recursive: true });
-  const tmp = path3.join(path3.dirname(filePath), `.${path3.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
-  const handle = await fs2.open(tmp, "w");
-  try {
-    await handle.writeFile(content, "utf8");
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-  await fs2.rename(tmp, filePath);
-}
-
-// src/core/markdown.ts
-function ensureTrailingNewline(content) {
-  return content.endsWith("\n") ? content : `${content}
-`;
-}
-function upsertLineByPrefix(content, prefix, nextLine) {
-  const lines = ensureTrailingNewline(content).split("\n");
-  const index = lines.findIndex((line) => line.trimStart().startsWith(prefix));
-  if (index >= 0) {
-    lines[index] = nextLine;
-  } else {
-    lines.splice(Math.max(0, lines.length - 1), 0, nextLine);
-  }
-  return ensureTrailingNewline(lines.join("\n").replace(/\n{3,}/g, "\n\n"));
-}
+// src/tools/createMemorySkeleton.ts
+var DEFAULT_L1 = `# ContextLine Memory Index
 
-// src/core/details.ts
-import { format, parseISO } from "date-fns";
-function detailFilename(dateInput) {
-  const date = dateInput ? parseISO(dateInput) : /* @__PURE__ */ new Date();
-  if (Number.isNaN(date.getTime())) {
-    throw new Error("Invalid date. Expected YYYY-MM-DD.");
-  }
-  return `L3_${format(date, "yyyy_MM")}.md`;
-}
-function detailHeader(dateInput) {
-  const date = dateInput ? parseISO(dateInput) : /* @__PURE__ */ new Date();
-  if (Number.isNaN(date.getTime())) {
-    throw new Error("Invalid date. Expected YYYY-MM-DD.");
-  }
-  return `# ${format(date, "MMMM yyyy")} Detailed Memory
+Compact facts and topic pointers. One line per topic.
 
 `;
-}
-function detailLine(text, dateInput) {
-  const date = dateInput ? parseISO(dateInput) : /* @__PURE__ */ new Date();
-  if (Number.isNaN(date.getTime())) {
-    throw new Error("Invalid date. Expected YYYY-MM-DD.");
-  }
-  const clean = text.replace(/\s+/g, " ").trim();
-  if (!clean) {
-    throw new Error("Detail text must be non-empty.");
+async function createMemorySkeleton(root) {
+  const created = [];
+  await fs2.mkdir(root, { recursive: true });
+  const l2Dir = safeJoin(root, L2_DIR);
+  await fs2.mkdir(l2Dir, { recursive: true });
+  created.push(L2_DIR);
+  const l1Target = safeJoin(root, L1_FILE);
+  try {
+    await fs2.writeFile(l1Target, DEFAULT_L1, { encoding: "utf8", flag: "wx" });
+    created.push(L1_FILE);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
   }
-  return `* [${format(date, "yyyy-MM-dd")}]: ${clean}`;
+  const instructionsTarget = safeJoin(root, CONTEXTLINE_INSTRUCTIONS_FILE);
+  await fs2.writeFile(instructionsTarget, DEFAULT_CONTEXTLINE_INSTRUCTIONS, { encoding: "utf8" });
+  created.push(CONTEXTLINE_INSTRUCTIONS_FILE);
+  return { ok: true, root, created };
 }
 
-// src/core/lock.ts
-import fs3 from "fs/promises";
-import path4 from "path";
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function withLock(root, fn) {
-  const lockPath = path4.join(root, ".lock");
-  const start = Date.now();
-  let handle;
-  while (!handle) {
-    try {
-      await fs3.mkdir(root, { recursive: true });
-      handle = await fs3.open(lockPath, "wx");
-    } catch (error) {
-      const code = error.code;
-      if (code !== "EEXIST" || Date.now() - start > 5e3) {
-        throw error;
-      }
-      await sleep(50);
-    }
-  }
+// src/host/claude.ts
+async function readJsonObject(filePath) {
   try {
-    return await fn();
-  } finally {
-    await handle.close();
-    await fs3.rm(lockPath, { force: true });
+    const raw = await fs3.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
   }
 }
+async function writeHookScript(scriptPath) {
+  const script = `#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
 
-// src/tools/init.ts
-import fs4 from "fs/promises";
-import path5 from "path";
-
-// src/core/instructions.ts
-var CONTEXTLINE_INSTRUCTIONS_FILE = "contextline_instructions.md";
-var DEFAULT_CONTEXTLINE_INSTRUCTIONS = `# ContextLine Instructions
-
-CONTEXTLINE-INSTRUCTIONS-V1
-This file contains generic operating instructions for ContextLine memory.
-Use the single MCP tool named "contextline" for all ContextLine reads and writes.
-Do not use shell commands to read or write .contextline files.
-Do not mention memory saving unless the user asks.
-
-## Operating Policy
-
-Use the single ContextLine MCP tool "contextline" silently for durable memory. Do not use shell commands to read or write .contextline files. Do not mention memory saving unless asked.
-
-Durable memory means stable facts likely to help future sessions: user/project facts, preferences, goals, constraints, decisions, relationships, recurring patterns, and important events. Do not save filler, acknowledgements, or one-off chatter.
-
-Do not save every message. Periodically batch-save useful durable memory since the last ContextLine save in this session.
-
-Use ContextLine as a human-like cache:
-
-- L1_Quick.md stores compact facts, summaries, and active pointers.
-- L2_Deep/ stores deeper facts per important object, person, event, project, preference area, or decision thread.
-- L3_Details/ stores timestamped specifics, receipts, and supporting history.
-
-For V1, use flat L2 filenames with semantic prefixes instead of folders. Prefer names like person_user.md, project_contextline.md, area_work.md, place_san_jose.md, preference_media.md, preference_language.md, decision_memory_architecture.md, event_launch.md, or org_meta.md.
-
-When saving durable memory, complete the full chain. Do not stop after writing L3_Details:
-
-1. Append one L3_Details receipt when supporting specifics are useful.
-2. Cross-save extracted meaning into every relevant L2_Deep file.
-3. Update L1_Quick only for compact high-level facts or active pointers.
-4. Link every L1 line to relevant L2 files.
-5. Link every L2 line to relevant L3 details when supporting detail exists.
-
-Typical tool sequence:
-
-Call "contextline" once with action "save_memory", including:
-
-- detail.text for the L3_Details receipt
-- deep[] entries for every relevant L2_Deep file, such as person_user.md, area_work.md, place_san_jose.md, or preference_media.md
-- quick[] entries for compact L1_Quick facts linked to L2 files
-
-If you write L3_Details but do not update L2_Deep and L1_Quick, the memory is incomplete. Prefer the bundled "save_memory" action so the full chain is saved together.
-`;
-
-// src/tools/init.ts
-var DEFAULT_L1 = `# ContextLine L1 Index
-
-This is the quick memory cache: compact facts, summaries, and active pointers.
-
-## Quick Facts
+const input = fs.readFileSync(0, "utf8");
+const result = spawnSync("contextline", ["hook"], {
+  input,
+  encoding: "utf8",
+  shell: process.platform === "win32"
+});
 
+if (result.stderr) process.stderr.write(result.stderr);
+if (result.stdout) process.stdout.write(result.stdout);
+process.exit(result.status ?? 0);
 `;
-async function initContextLine(root) {
-  const created = [];
-  await fs4.mkdir(root, { recursive: true });
-  for (const dir of [
-    L2_DIR,
-    L3_DIR,
-    "maintenance",
-    "maintenance/proposals"
-  ]) {
-    const target = safeJoin(root, ...dir.split("/"));
-    await fs4.mkdir(target, { recursive: true });
-    created.push(path5.relative(root, target));
-  }
-  const files = [
-    [L1_FILE, DEFAULT_L1],
-    [CONTEXTLINE_INSTRUCTIONS_FILE, DEFAULT_CONTEXTLINE_INSTRUCTIONS],
-    ["config.json", `${JSON.stringify({ version: 1, capture: { promotion: "selective" } }, null, 2)}
-`]
-  ];
-  for (const [file, content] of files) {
-    const target = safeJoin(root, file);
-    try {
-      await fs4.writeFile(target, content, { encoding: "utf8", flag: "wx" });
-      created.push(path5.relative(root, target));
-    } catch (error) {
-      if (error.code !== "EEXIST") {
-        throw error;
-      }
-    }
-  }
-  return { ok: true, root, created };
-}
-
-// src/tools/appendFragment.ts
-async function appendFragment(text, date, rootInput) {
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  return withLock(root, async () => {
-    const detail_file = detailFilename(date);
-    const filePath = detailPath(root, detail_file);
-    let content;
-    try {
-      content = await fs5.readFile(filePath, "utf8");
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-      content = detailHeader(date);
-    }
-    const fragment = detailLine(text, date);
-    await atomicWriteFile(filePath, `${ensureTrailingNewline(content)}${fragment}
-`);
-    return {
-      ok: true,
-      detail_file,
-      fragment,
-      next_required_steps: [
-        "Call contextline with action save_memory to save L3, L2, and L1 together.",
-        "If manually continuing, call contextline action update_deep for every relevant L2_Deep file and action update_index for compact L1_Quick facts."
-      ],
-      display: `ContextLine L3 detail appended
-- Detail file: ${detail_file}`
-    };
+  await fs3.writeFile(scriptPath, script, "utf8");
+}
+function containsContextlineHook(entry) {
+  if (!entry || typeof entry !== "object") return false;
+  const hooks = entry.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => {
+    if (!hook || typeof hook !== "object") return false;
+    const h = hook;
+    const command = typeof h.command === "string" ? h.command : "";
+    const args = Array.isArray(h.args) ? h.args.filter((arg) => typeof arg === "string") : [];
+    return command === "node" && args.some((arg) => arg.replaceAll("\\", "/").endsWith("/.claude/hooks/contextline-hook.mjs"));
   });
 }
-
-// src/tools/hydrate.ts
-import fs6 from "fs/promises";
-async function hydrate(rootInput) {
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  const l1_path = l1Path(root);
-  const instructions_path = safeJoin(root, CONTEXTLINE_INSTRUCTIONS_FILE);
-  const content = await fs6.readFile(l1_path, "utf8");
-  const instructions = await fs6.readFile(instructions_path, "utf8");
-  return {
-    ok: true,
-    root,
-    l1_path,
-    instructions_path,
-    content,
-    instructions,
-    instruction: "Use this L1 content as quick memory. Follow the included ContextLine instructions for reading and saving memory.",
-    display: `ContextLine hydrated
-- Quick memory: ${l1_path}
-- Instructions: ${instructions_path}`
-  };
-}
-
-// src/tools/inspect.ts
-import fs7 from "fs/promises";
-import path6 from "path";
-async function countFiles(dir) {
-  try {
-    return (await fs7.readdir(dir)).length;
-  } catch {
-    return 0;
+async function upsertClaudeSettings(settingsPath, projectRoot, contextlineRoot) {
+  const existing = await readJsonObject(settingsPath);
+  if (!existing.hooks || typeof existing.hooks !== "object" || Array.isArray(existing.hooks)) {
+    existing.hooks = {};
   }
-}
-async function inspect(rootInput) {
-  const root = resolveRoot(rootInput);
-  return {
-    root,
-    l1: path6.join(root, L1_FILE),
-    l2_deep_files: await countFiles(safeJoin(root, L2_DIR)),
-    l3_detail_files: await countFiles(safeJoin(root, L3_DIR))
+  const hooks = existing.hooks;
+  const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
+  const userPromptSubmit = Array.isArray(hooks.UserPromptSubmit) ? hooks.UserPromptSubmit : [];
+  const filteredSessionStart = sessionStart.filter((entry) => !containsContextlineHook(entry));
+  const filteredUserPromptSubmit = userPromptSubmit.filter((entry) => !containsContextlineHook(entry));
+  const hook = {
+    type: "command",
+    command: "node",
+    args: ["${CLAUDE_PROJECT_DIR}/.claude/hooks/contextline-hook.mjs"]
   };
+  const sessionStartEntry = {
+    matcher: "startup|resume|clear|compact",
+    hooks: [hook]
+  };
+  const userPromptSubmitEntry = {
+    hooks: [hook]
+  };
+  hooks.SessionStart = [sessionStartEntry, ...filteredSessionStart];
+  hooks.UserPromptSubmit = [userPromptSubmitEntry, ...filteredUserPromptSubmit];
+  const memPath = path4.relative(projectRoot, contextlineRoot).replaceAll("\\", "/");
+  const memPermissions = [`Read(${memPath}/**)`, `Write(${memPath}/**)`, `Edit(${memPath}/**)`];
+  if (!existing.permissions || typeof existing.permissions !== "object" || Array.isArray(existing.permissions)) {
+    existing.permissions = {};
+  }
+  const permissions = existing.permissions;
+  const existingAllow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const filteredAllow = existingAllow.filter((r) => typeof r !== "string" || !memPermissions.includes(r));
+  permissions.allow = [...memPermissions, ...filteredAllow];
+  await fs3.writeFile(settingsPath, `${JSON.stringify(existing, null, 2)}
+`, "utf8");
 }
-
-// src/core/topology.ts
-import fs8 from "fs/promises";
-import path7 from "path";
-
-// src/core/links.ts
-var WIKI_LINK_RE = /\[\[([^\]]+)\]\]/g;
-function extractWikiLinks(content) {
-  return [...content.matchAll(WIKI_LINK_RE)].map((match) => match[1]);
-}
-function hasWikiLink(line, filename) {
-  return extractWikiLinks(line).includes(filename);
-}
-function ensureWikiLink(line, filename) {
-  return hasWikiLink(line, filename) ? line : `${line.trim()} [[${filename}]]`;
-}
-
-// src/core/topology.ts
-async function exists(target) {
-  try {
-    await fs8.access(target);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function listMarkdown(dir) {
-  const out = [];
-  try {
-    const entries = await fs8.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = path7.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        const nested = await listMarkdown(full);
-        out.push(...nested.map((file) => path7.join(entry.name, file)));
-      } else if (entry.name.endsWith(".md")) {
-        out.push(entry.name);
-      }
-    }
-    return out;
-  } catch {
-    return [];
-  }
-}
-async function validateTopology(root) {
-  const errors = [];
-  const warnings = [];
-  const l1 = l1Path(root);
-  const l2 = safeJoin(root, L2_DIR);
-  const l3 = safeJoin(root, L3_DIR);
-  if (!await exists(l1)) errors.push("L1_Quick.md is missing.");
-  if (!await exists(l2)) errors.push("L2_Deep directory is missing.");
-  if (!await exists(l3)) errors.push("L3_Details directory is missing.");
-  if (errors.length) return { ok: false, errors, warnings };
-  const l1Content = await fs8.readFile(l1, "utf8");
-  for (const link of extractWikiLinks(l1Content)) {
-    if (link.startsWith("L3_")) {
-      errors.push(`L1 must not link directly to L3 detail file: ${link}`);
-    } else if (!await exists(path7.join(l2, link))) {
-      errors.push(`L1 links to missing L2 deep memory file: ${link}`);
-    }
-  }
-  for (const file of await listMarkdown(l2)) {
-    const content = await fs8.readFile(path7.join(l2, file), "utf8");
-    for (const link of extractWikiLinks(content)) {
-      if (link === L1_FILE) {
-        errors.push(`L2 deep memory file ${file} must not link upward to L1_Quick.md.`);
-      } else if (!link.startsWith("L3_")) {
-        warnings.push(`L2 deep memory file ${file} links to non-L3 file: ${link}`);
-      } else if (!await exists(path7.join(l3, link))) {
-        errors.push(`L2 deep memory file ${file} links to missing L3 detail file: ${link}`);
-      }
-    }
-  }
-  for (const file of await listMarkdown(l3)) {
-    const content = await fs8.readFile(path7.join(l3, file), "utf8");
-    const links = extractWikiLinks(content);
-    if (links.length) {
-      errors.push(`L3 detail file ${file} must not contain wiki links.`);
+async function detectClaude(projectRoot) {
+  const details = [];
+  const candidates = [
+    path4.join(projectRoot, ".claude"),
+    path4.join(projectRoot, ".mcp.json"),
+    path4.join(os.homedir(), ".claude"),
+    path4.join(os.homedir(), ".claude.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      await fs3.access(candidate);
+      details.push(`found ${candidate}`);
+    } catch {
     }
   }
-  return { ok: errors.length === 0, errors, warnings };
-}
-
-// src/tools/validateTopology.ts
-async function validateTopology2(rootInput) {
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  const result = await validateTopology(root);
-  return {
-    ...result,
-    display: result.ok ? "ContextLine topology valid" : `ContextLine topology invalid
-- Errors: ${result.errors.length}
-- Warnings: ${result.warnings.length}`
-  };
-}
-
-// src/hook.ts
-import path8 from "path";
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
-  return Buffer.concat(chunks).toString("utf8");
+  if (details.length) return { host: "claude", confidence: "high", details };
+  return { host: "none", confidence: "none", details: [] };
 }
-async function runHook(rootInput) {
-  const raw = await readStdin();
-  const event = raw.trim() ? JSON.parse(raw) : {};
-  const root = rootInput ? path8.resolve(rootInput) : resolveRoot();
-  if (event.hook_event_name === "SessionStart") {
-    process.stdout.write(
-      JSON.stringify({
-        continue: true,
-        hookSpecificOutput: {
-          hookEventName: "SessionStart",
-          additionalContext: `ContextLine memory is available. Call the "contextline" MCP tool with action "hydrate" and root ${JSON.stringify(root)} to load your memory index. This reads only files inside the .contextline folder at that path \u2014 it does not scan or ingest the parent directory. Use that same root for all ContextLine calls this session, then follow the returned instructions.`
-        }
-      })
-    );
-    return;
-  }
+async function setupClaude(projectRoot, contextlineRoot) {
+  await createMemorySkeleton(contextlineRoot);
+  const claudeDir = path4.join(projectRoot, ".claude");
+  const hooksDir = path4.join(claudeDir, "hooks");
+  await fs3.mkdir(hooksDir, { recursive: true });
+  const hookScriptPath = path4.join(hooksDir, "contextline-hook.mjs");
+  await writeHookScript(hookScriptPath);
+  const settingsPath = path4.join(claudeDir, "settings.json");
+  await upsertClaudeSettings(settingsPath, projectRoot, contextlineRoot);
+  return { settingsPath, hookScriptPath };
 }
 
-// src/setup.ts
-import { cwd } from "process";
-
 // src/host/codex.ts
-import fs9 from "fs/promises";
-import path9 from "path";
-import os from "os";
-function contextlineMcpBlock(contextlineRoot) {
-  return `[mcp_servers.contextline]
+import fs4 from "fs/promises";
+import path5 from "path";
+import os2 from "os";
+function filesystemMcpBlock(contextlineRoot) {
+  return `[mcp_servers.filesystem]
 type = "stdio"
-command = "contextline-mcp"
-args = []
-env = { CONTEXTLINE_ROOT = ${JSON.stringify(contextlineRoot)} }
+command = "npx"
+args = ["-y", "@modelcontextprotocol/server-filesystem", ${JSON.stringify(contextlineRoot)}]
 startup_timeout_sec = 10
 tool_timeout_sec = 10
 `;
 }
-async function upsertContextlineMcpConfig(configTomlPath, contextlineRoot) {
+async function upsertFilesystemMcpConfig(configTomlPath, contextlineRoot) {
   let existingConfig = "";
   try {
-    existingConfig = await fs9.readFile(configTomlPath, "utf8");
+    existingConfig = await fs4.readFile(configTomlPath, "utf8");
   } catch (error) {
     if (error.code !== "ENOENT") throw error;
   }
-  const withoutContextLine = existingConfig.replace(/\n?\[mcp_servers\.contextline\][\s\S]*?(?=\n\[|$)/, "").trim();
-  const mcpBlock = contextlineMcpBlock(contextlineRoot);
-  await fs9.writeFile(configTomlPath, `${withoutContextLine ? `${withoutContextLine}
+  const withoutFilesystem = existingConfig.replace(/\n?\[mcp_servers\.filesystem\][\s\S]*?(?=\n\[|$)/, "").trim();
+  const mcpBlock = filesystemMcpBlock(contextlineRoot);
+  await fs4.writeFile(configTomlPath, `${withoutFilesystem ? `${withoutFilesystem}
 
 ` : ""}${mcpBlock}
 `, "utf8");
 }
-async function writeHookScript(scriptPath, contextlineRoot) {
+async function writeHookScript2(scriptPath) {
   const script = `#!/usr/bin/env node
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 
 const input = fs.readFileSync(0, "utf8");
-const result = spawnSync("contextline", ["hook", "--root", ${JSON.stringify(contextlineRoot)}], {
+const result = spawnSync("contextline", ["hook"], {
   input,
   encoding: "utf8",
   shell: process.platform === "win32"
@@ -508,12 +371,12 @@ if (result.stderr) process.stderr.write(result.stderr);
 if (result.stdout) process.stdout.write(result.stdout);
 process.exit(result.status ?? 0);
 `;
-  await fs9.writeFile(scriptPath, script, "utf8");
+  await fs4.writeFile(scriptPath, script, "utf8");
 }
 async function upsertHooksJson(hooksJsonPath, hookScriptPath) {
   let existing = {};
   try {
-    const raw = await fs9.readFile(hooksJsonPath, "utf8");
+    const raw = await fs4.readFile(hooksJsonPath, "utf8");
     existing = JSON.parse(raw);
   } catch {
   }
@@ -522,29 +385,36 @@ async function upsertHooksJson(hooksJsonPath, hookScriptPath) {
   }
   const hooks = existing.hooks;
   const sessionStart = Array.isArray(hooks.SessionStart) ? hooks.SessionStart : [];
-  const filtered = sessionStart.filter((entry) => {
-    if (!entry || typeof entry !== "object") return true;
+  const userPromptSubmit = Array.isArray(hooks.UserPromptSubmit) ? hooks.UserPromptSubmit : [];
+  const containsContextlineHook2 = (entry) => {
+    if (!entry || typeof entry !== "object") return false;
     const e = entry;
-    return !e.hooks?.some((h) => h.command?.includes("contextline"));
-  });
+    return e.hooks?.some((h) => h.command?.includes("contextline")) ?? false;
+  };
+  const filteredSessionStart = sessionStart.filter((entry) => !containsContextlineHook2(entry));
+  const filteredUserPromptSubmit = userPromptSubmit.filter((entry) => !containsContextlineHook2(entry));
   const contextlineEntry = {
     matcher: "startup|resume|clear|compact",
     hooks: [{ type: "command", command: `node ${JSON.stringify(hookScriptPath)}` }]
   };
-  hooks.SessionStart = [contextlineEntry, ...filtered];
-  await fs9.writeFile(hooksJsonPath, `${JSON.stringify(existing, null, 2)}
+  const contextlinePromptEntry = {
+    hooks: [{ type: "command", command: `node ${JSON.stringify(hookScriptPath)}` }]
+  };
+  hooks.SessionStart = [contextlineEntry, ...filteredSessionStart];
+  hooks.UserPromptSubmit = [contextlinePromptEntry, ...filteredUserPromptSubmit];
+  await fs4.writeFile(hooksJsonPath, `${JSON.stringify(existing, null, 2)}
 `, "utf8");
 }
 async function detectCodex(projectRoot) {
   const details = [];
   const candidates = [
-    path9.join(os.homedir(), ".codex"),
-    path9.join(projectRoot, ".codex"),
+    path5.join(os2.homedir(), ".codex"),
+    path5.join(projectRoot, ".codex"),
     process.env.CODEX_HOME
   ].filter(Boolean);
   for (const candidate of candidates) {
     try {
-      await fs9.access(candidate);
+      await fs4.access(candidate);
       details.push(`found ${candidate}`);
     } catch {
     }
@@ -553,160 +423,69 @@ async function detectCodex(projectRoot) {
   return { host: "none", confidence: "none", details: [] };
 }
 async function setupCodex(projectRoot, contextlineRoot) {
-  await initContextLine(contextlineRoot);
-  const codexDir = path9.join(projectRoot, ".codex");
-  const hooksDir = path9.join(codexDir, "hooks");
-  await fs9.mkdir(hooksDir, { recursive: true });
-  const hookScriptPath = path9.join(hooksDir, "contextline-hook.mjs");
-  await writeHookScript(hookScriptPath, contextlineRoot);
-  const hooksJsonPath = path9.join(codexDir, "hooks.json");
+  await createMemorySkeleton(contextlineRoot);
+  const codexDir = path5.join(projectRoot, ".codex");
+  const hooksDir = path5.join(codexDir, "hooks");
+  await fs4.mkdir(hooksDir, { recursive: true });
+  const hookScriptPath = path5.join(hooksDir, "contextline-hook.mjs");
+  await writeHookScript2(hookScriptPath);
+  const hooksJsonPath = path5.join(codexDir, "hooks.json");
   await upsertHooksJson(hooksJsonPath, hookScriptPath);
-  const configTomlPath = path9.join(codexDir, "config.toml");
-  await upsertContextlineMcpConfig(configTomlPath, contextlineRoot);
-  const globalCodexDir = process.env.CODEX_HOME ?? path9.join(os.homedir(), ".codex");
-  const globalHooksDir = path9.join(globalCodexDir, "hooks");
-  await fs9.mkdir(globalHooksDir, { recursive: true });
-  const globalHookScriptPath = path9.join(globalHooksDir, "contextline-hook.mjs");
-  await writeHookScript(globalHookScriptPath, contextlineRoot);
-  const globalHooksJsonPath = path9.join(globalCodexDir, "hooks.json");
-  await upsertHooksJson(globalHooksJsonPath, globalHookScriptPath);
-  const globalConfigTomlPath = path9.join(globalCodexDir, "config.toml");
-  if (path9.resolve(globalConfigTomlPath) !== path9.resolve(configTomlPath)) {
-    await upsertContextlineMcpConfig(globalConfigTomlPath, contextlineRoot);
-  }
-  const agentsPath = path9.join(projectRoot, "AGENTS.md");
-  try {
-    const existingAgents = await fs9.readFile(agentsPath, "utf8");
-    if (existingAgents.includes("# ContextLine Memory")) {
-      const cleanedAgents = existingAgents.slice(0, existingAgents.indexOf("# ContextLine Memory")).trim();
-      if (cleanedAgents) {
-        await fs9.writeFile(agentsPath, `${cleanedAgents}
-`, "utf8");
-      } else {
-        await fs9.rm(agentsPath, { force: true });
-      }
-    }
-  } catch (error) {
-    if (error.code !== "ENOENT") throw error;
-  }
-  return { hooksJsonPath, hookScriptPath, configTomlPath, globalHooksJsonPath, globalHookScriptPath, globalConfigTomlPath };
+  const configTomlPath = path5.join(codexDir, "config.toml");
+  await upsertFilesystemMcpConfig(configTomlPath, contextlineRoot);
+  return { hooksJsonPath, hookScriptPath, configTomlPath };
 }
 
 // src/setup.ts
 async function runSetup(options = {}) {
   const projectRoot = cwd();
   const root = getMemoryRoot();
-  const requestedHost = options.host ?? "auto";
-  let host = requestedHost;
+  const requestedHostInput = (options.host ?? "auto").toLowerCase();
+  const requestedHost = requestedHostInput === "claude-code" || requestedHostInput === "claudecode" ? "claude" : requestedHostInput;
+  let hosts = [];
   let detectionDetails = [];
   if (requestedHost === "auto") {
-    const detected = await detectCodex(projectRoot);
-    host = detected.host === "codex" ? "codex" : "none";
-    detectionDetails = detected.details;
-  }
-  await initContextLine(root);
-  let hostSetup = null;
-  if (host === "codex") {
-    hostSetup = await setupCodex(projectRoot, root);
+    const [codex, claude] = await Promise.all([detectCodex(projectRoot), detectClaude(projectRoot)]);
+    if (codex.host === "codex") hosts.push("codex");
+    if (claude.host === "claude") hosts.push("claude");
+    detectionDetails = [
+      ...codex.details.map((detail) => `codex: ${detail}`),
+      ...claude.details.map((detail) => `claude: ${detail}`)
+    ];
+  } else if (requestedHost === "codex" || requestedHost === "claude") {
+    hosts = [requestedHost];
+  } else if (requestedHost !== "none") {
+    throw new Error(`Unsupported host adapter: ${options.host}`);
+  }
+  const hostSetup = {};
+  for (const host of hosts) {
+    if (host === "codex") {
+      hostSetup.codex = await setupCodex(projectRoot, root);
+    } else if (host === "claude") {
+      hostSetup.claude = await setupClaude(projectRoot, root);
+    }
   }
-  const validation = await validateTopology2(root);
   return {
-    ok: validation.ok,
+    ok: true,
     root,
-    host,
+    host: hosts.length ? hosts.join(",") : "none",
+    hosts,
     detectionDetails,
-    hostSetup,
-    validation,
-    mcpConfig: {
-      mcpServers: {
-        contextline: {
-          command: "contextline-mcp",
-          args: [],
-          env: {
-            CONTEXTLINE_ROOT: root
-          }
-        }
-      }
-    }
+    hostSetup
   };
 }
 
-// src/tools/updateDeepPointer.ts
-import fs10 from "fs/promises";
-import path10 from "path";
-async function updateDeepPointer(file, factText, detailFile, rootInput) {
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  detailPath(root, detailFile);
-  return withLock(root, async () => {
-    const filePath = deepPath(root, file);
-    let content = "";
-    try {
-      content = await fs10.readFile(filePath, "utf8");
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
-      content = `# ${path10.basename(file, ".md")}
-
-`;
-    }
-    const updated_line = ensureWikiLink(factText, detailFile);
-    const next = upsertLineByPrefix(ensureTrailingNewline(content), factText.trim(), updated_line);
-    await atomicWriteFile(filePath, next);
-    return { ok: true, file, updated_line, display: `ContextLine L2 updated
-- File: ${file}` };
-  });
-}
-
-// src/tools/updateIndexPointer.ts
-import fs11 from "fs/promises";
-async function updateIndexPointer(indexLine, files, rootInput) {
-  if (files.some((file) => file.startsWith("L3_"))) {
-    throw new Error("L1 quick memory pointers may only reference L2 deep memory files.");
-  }
-  const root = resolveRoot(rootInput);
-  await initContextLine(root);
-  for (const file of files) {
-    deepPath(root, file);
-  }
-  return withLock(root, async () => {
-    const filePath = l1Path(root);
-    const content = await fs11.readFile(filePath, "utf8");
-    const updated_line = files.reduce((line, file) => ensureWikiLink(line, file), indexLine);
-    const next = upsertLineByPrefix(ensureTrailingNewline(content), indexLine.trim(), updated_line);
-    await atomicWriteFile(filePath, next);
-    return { ok: true, updated_line, display: "ContextLine L1 updated" };
-  });
-}
-
 // src/cli.ts
-function print(data) {
-  console.log(JSON.stringify(data, null, 2));
-}
 var program = new Command();
-program.name("contextline").description("Local-first pointer-chain memory for AI agents.").version("0.1.0");
-program.command("init").argument("[root]").description("Create a .contextline memory folder.").action(async (root) => print(await initContextLine(resolveRoot(root))));
-program.command("hydrate").argument("[root]").description("Read L1_Quick.md as the bounded quick memory cache.").action(async (root) => print(await hydrate(root)));
-program.command("validate").argument("[root]").description("Validate ContextLine topology.").action(async (root) => {
-  const result = await validateTopology2(root);
-  print(result);
-  if (!result.ok) process.exitCode = 1;
-});
-program.command("inspect").argument("[root]").description("Inspect ContextLine folder counts and paths.").action(async (root) => print(await inspect(root)));
-program.command("append").argument("<text>").argument("[root]").option("--date <date>", "Date in YYYY-MM-DD format").description("Append an immutable L3 detail fragment.").action(async (text, root, options) => print(await appendFragment(text, options.date, root)));
-program.command("update-deep").argument("<file>").argument("<fact-text>").argument("<detail-file>").argument("[root]").description("Update an L2 deep memory line with a pointer to an L3 detail file.").action(async (file, factText, detailFile, root) => print(await updateDeepPointer(file, factText, detailFile, root)));
-program.command("update-index").argument("<index-line>").argument("<files...>").option("--root <root>", "Memory folder path").description("Update an L1 quick memory line with pointers to L2 deep memory files.").action(async (indexLine, files, options) => print(await updateIndexPointer(indexLine, files, options.root)));
-program.command("setup").option("--host <host>", "Host adapter: auto, codex, none", "auto").option("--verbose", "Print full JSON result").description("Initialize memory and configure supported host integrations.").action(async (options) => {
+program.name("contextline").description("Persistent memory for AI agents.").version("0.2.0");
+program.command("setup").option("--host <host>", "Host adapter: auto, codex, claude, claude-code, none", "auto").option("--verbose", "Print full JSON result").description("Create memory folder and configure host integrations.").action(async (options) => {
   const result = await runSetup(options);
   if (options.verbose) {
-    print(result);
+    console.log(JSON.stringify(result, null, 2));
   } else {
-    process.stdout.write(result.ok ? `ContextLine ready at ${result.root}
-` : `Setup failed.
+    process.stdout.write(`ContextLine ready at ${result.root}
 `);
   }
-  if (!result.ok) process.exitCode = 1;
 });
 program.command("hook").option("--root <root>", "Memory folder path").description("Run ContextLine host hook. Reads hook JSON from stdin.").action(async (options) => runHook(options.root));
 program.parseAsync(process.argv).catch((error) => {