@folterung/project-memory 0.1.0

package/packages/cli/src/commands/scaffold.ts

@@ -0,0 +1,55 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import chalk from "chalk";
+import { configExists } from "../config/load.js";
+import { dockerComposeUp, waitForQdrantHealth } from "../docker/compose.js";
+import { runPhase1 } from "../phase1/pipeline.js";
+
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+
+export async function runScaffold(cwd: string): Promise<void> {
+  if (!configExists(cwd)) {
+    console.error(chalk.red("No config found. Run"), chalk.cyan("mem init"), chalk.red("first."));
+    process.exit(1);
+  }
+
+  console.log(chalk.bold("Project Memory Scaffold (Phase 1)\n"));
+
+  console.log(chalk.dim("Starting Docker Compose..."));
+  try {
+    dockerComposeUp(cwd);
+  } catch (err) {
+    console.error(chalk.red("Docker Compose failed:"), (err as Error).message);
+    process.exit(1);
+  }
+
+  console.log(chalk.dim("Waiting for Qdrant..."));
+  try {
+    await waitForQdrantHealth();
+  } catch (err) {
+    console.error(chalk.red("Qdrant health check failed:"), (err as Error).message);
+    process.exit(1);
+  }
+  console.log(chalk.green("✓"), "Qdrant ready");
+
+  console.log(chalk.dim("Phase 1: file tree, symbol index, module summaries, system maps, embedding..."));
+  try {
+    await runPhase1(cwd);
+  } catch (err) {
+    console.error(chalk.red("Phase 1 failed:"), (err as Error).message);
+    process.exit(1);
+  }
+
+  const serverPath = join(__dirname, "..", "..", "..", "server", "dist", "index.js");
+  const env = { ...process.env, MEM_CWD: cwd };
+  try {
+    spawn(process.execPath, [serverPath], { env, stdio: "ignore", detached: true }).unref();
+  } catch {
+    console.log(chalk.yellow("Could not start memory server. Run: cd packages/server && MEM_CWD=" + cwd + " npm start"));
+  }
+  console.log(chalk.green("✓"), "Memory server started (detached)");
+
+  console.log(chalk.green("\nScaffold Phase 1 complete. Cursor integration ready."));
+  console.log(chalk.dim("Run"), chalk.cyan("mem deep-index"), chalk.dim("to embed remaining chunks (Phase 2)."));
+}

package/packages/cli/src/commands/update.ts

@@ -0,0 +1,22 @@
+import chalk from "chalk";
+import { configExists } from "../config/load.js";
+import { runPhase1 } from "../phase1/pipeline.js";
+
+/**
+ * Incremental update: re-run Phase 1 (full scope+ignore, chunk, embed Phase 1 points).
+ * V1: full Phase 1 re-run; true incremental (changed files only) can be added later via manifest.
+ */
+export async function runUpdate(cwd: string): Promise<void> {
+  if (!configExists(cwd)) {
+    console.error(chalk.red("No config found. Run"), chalk.cyan("mem init"), chalk.red("first."));
+    process.exit(1);
+  }
+  console.log(chalk.bold("Project Memory Update\n"));
+  try {
+    await runPhase1(cwd);
+    console.log(chalk.green("Update complete."));
+  } catch (err) {
+    console.error(chalk.red("Update failed:"), (err as Error).message);
+    process.exit(1);
+  }
+}

package/packages/cli/src/commands/watch.ts

@@ -0,0 +1,47 @@
+import chalk from "chalk";
+import { configExists, loadConfig } from "../config/load.js";
+import { listInScopeFiles } from "../scope/allowlist.js";
+import { createIgnoreFilter } from "../scope/ignore.js";
+import { toRelativePath } from "../scope/allowlist.js";
+import { runUpdate } from "./update.js";
+
+export async function runWatch(cwd: string): Promise<void> {
+  if (!configExists(cwd)) {
+    console.error(chalk.red("No config found. Run"), chalk.cyan("mem init"), chalk.red("first."));
+    process.exit(1);
+  }
+  const config = loadConfig(cwd);
+  const isIgnored = createIgnoreFilter(cwd, config.indexing?.exclude ?? []);
+  const inScopePaths = listInScopeFiles(cwd, config);
+  const eligiblePaths: string[] = [];
+  for (const abs of inScopePaths) {
+    const rel = toRelativePath(cwd, abs);
+    if (!isIgnored(rel)) eligiblePaths.push(abs);
+  }
+
+  const { default: chokidar } = await import("chokidar");
+  let debounceMs = 2000;
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+
+  const watcher = chokidar.watch(eligiblePaths, {
+    ignoreInitial: true,
+    awaitWriteFinish: { stabilityThreshold: 500 },
+  });
+
+  watcher.on("change", () => {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(async () => {
+      console.log(chalk.dim("Change detected, running update..."));
+      try {
+        await runUpdate(cwd);
+      } catch (e) {
+        console.error(chalk.red("Update failed:"), (e as Error).message);
+      }
+      timeout = null;
+    }, debounceMs);
+  });
+
+  console.log(chalk.bold("Project Memory Watch"));
+  console.log(chalk.dim("Watching"), eligiblePaths.length, "files. Ctrl+C to stop.");
+  console.log(chalk.dim("Run mem update manually or wait for file changes."));
+}

package/packages/cli/src/config/defaults.ts

@@ -0,0 +1,49 @@
+import type { MemConfig } from "./types.js";
+import { DEFAULT_CONFIG } from "./types.js";
+
+export function getDefaultConfigYaml(): string {
+  const c: MemConfig = {
+    indexing: {
+      include: ["src/**", "docs/**"],
+      exclude: [],
+    },
+    phase1: DEFAULT_CONFIG.phase1,
+    qdrant: DEFAULT_CONFIG.qdrant,
+    chunk: DEFAULT_CONFIG.chunk,
+    embedding: DEFAULT_CONFIG.embedding,
+  };
+  return `# Project Memory config
+# indexing.include: allowlist globs (only these paths are eligible). Omit to index repo root.
+indexing:
+  include:
+    - "src/**"
+    - "docs/**"
+  exclude: []
+
+phase1:
+  maxEntrypointFiles: ${c.phase1!.maxEntrypointFiles}
+  maxEntrypointChunks: ${c.phase1!.maxEntrypointChunks}
+
+qdrant:
+  host: ${c.qdrant!.host}
+  port: ${c.qdrant!.port}
+  collection: ${c.qdrant!.collection}
+
+chunk:
+  maxLines: ${c.chunk!.maxLines}
+  minLines: ${c.chunk!.minLines}
+
+embedding:
+  provider: ${c.embedding!.provider}
+`;
+}
+
+export function getDefaultMemignore(): string {
+  return `# Project Memory ignore rules (gitignore-style)
+# Tests
+**/*.test.*
+**/*.spec.*
+**/__tests__/**
+**/tests/**
+`;
+}

package/packages/cli/src/config/load.test.ts

@@ -0,0 +1,55 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { loadConfig, getConfigPath, configExists } from "./load.js";
+
+describe("config load", () => {
+  it("loadConfig with no file returns merged defaults", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "mem-config-"));
+    try {
+      const config = loadConfig(cwd);
+      assert.strictEqual(config.phase1?.maxEntrypointFiles, 50);
+      assert.strictEqual(config.qdrant?.port, 6333);
+      assert.strictEqual(config.embedding?.provider, "local");
+    } finally {
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it("getConfigPath returns .mem/config.yml under cwd", () => {
+    const cwd = "/some/repo";
+    assert.ok(getConfigPath(cwd).endsWith(".mem/config.yml"));
+    assert.ok(getConfigPath(cwd).includes("some"));
+  });
+
+  it("configExists returns false when file missing", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "mem-config-"));
+    try {
+      assert.strictEqual(configExists(cwd), false);
+    } finally {
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it("loadConfig merges overrides when file exists", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "mem-config-"));
+    const configPath = join(cwd, ".mem", "config.yml");
+    mkdirSync(join(cwd, ".mem"), { recursive: true });
+    writeFileSync(
+      configPath,
+      "phase1:\n  maxEntrypointFiles: 10\nqdrant:\n  port: 9999\n",
+      "utf8"
+    );
+    try {
+      const config = loadConfig(cwd);
+      assert.strictEqual(config.phase1?.maxEntrypointFiles, 10);
+      assert.strictEqual(config.qdrant?.port, 9999);
+      assert.strictEqual(config.embedding?.provider, "local");
+      assert.strictEqual(configExists(cwd), true);
+    } finally {
+      rmSync(cwd, { recursive: true, force: true });
+    }
+  });
+});

package/packages/cli/src/config/load.ts

@@ -0,0 +1,33 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import yaml from "js-yaml";
+import type { MemConfig } from "./types.js";
+import { DEFAULT_CONFIG, CONFIG_FILE } from "./types.js";
+
+function mergeConfig(loaded: MemConfig): MemConfig {
+  return {
+    indexing: loaded.indexing ?? DEFAULT_CONFIG.indexing,
+    phase1: { ...DEFAULT_CONFIG.phase1, ...loaded.phase1 },
+    qdrant: { ...DEFAULT_CONFIG.qdrant, ...loaded.qdrant },
+    chunk: { ...DEFAULT_CONFIG.chunk, ...loaded.chunk },
+    embedding: { ...DEFAULT_CONFIG.embedding, ...loaded.embedding },
+  };
+}
+
+export function loadConfig(cwd: string): MemConfig {
+  const path = join(cwd, CONFIG_FILE);
+  if (!existsSync(path)) {
+    return mergeConfig({});
+  }
+  const raw = readFileSync(path, "utf8");
+  const parsed = yaml.load(raw) as MemConfig | undefined;
+  return mergeConfig(parsed ?? {});
+}
+
+export function getConfigPath(cwd: string): string {
+  return join(cwd, CONFIG_FILE);
+}
+
+export function configExists(cwd: string): boolean {
+  return existsSync(join(cwd, CONFIG_FILE));
+}

package/packages/cli/src/config/types.test.ts

@@ -0,0 +1,43 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import {
+  DEFAULT_CONFIG,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  MEMIGNORE_FILE,
+  DEEP_INDEX_STATE_FILE,
+} from "./types.js";
+
+describe("config types", () => {
+  it("DEFAULT_CONFIG has phase1 caps", () => {
+    assert.strictEqual(DEFAULT_CONFIG.phase1.maxEntrypointFiles, 50);
+    assert.strictEqual(DEFAULT_CONFIG.phase1.maxEntrypointChunks, 300);
+  });
+
+  it("DEFAULT_CONFIG has qdrant defaults", () => {
+    assert.strictEqual(DEFAULT_CONFIG.qdrant.host, "127.0.0.1");
+    assert.strictEqual(DEFAULT_CONFIG.qdrant.port, 6333);
+    assert.strictEqual(DEFAULT_CONFIG.qdrant.collection, "project_memory");
+  });
+
+  it("DEFAULT_CONFIG has chunk defaults", () => {
+    assert.strictEqual(DEFAULT_CONFIG.chunk.maxLines, 400);
+    assert.ok((DEFAULT_CONFIG.chunk.minLines ?? 0) >= 0);
+  });
+
+  it("CONFIG_DIR is .mem", () => {
+    assert.strictEqual(CONFIG_DIR, ".mem");
+  });
+
+  it("CONFIG_FILE is .mem/config.yml", () => {
+    assert.strictEqual(CONFIG_FILE, ".mem/config.yml");
+  });
+
+  it("MEMIGNORE_FILE is .memignore", () => {
+    assert.strictEqual(MEMIGNORE_FILE, ".memignore");
+  });
+
+  it("DEEP_INDEX_STATE_FILE is .mem/state/deep-index.json", () => {
+    assert.strictEqual(DEEP_INDEX_STATE_FILE, ".mem/state/deep-index.json");
+  });
+});

package/packages/cli/src/config/types.ts

@@ -0,0 +1,49 @@
+export interface MemConfig {
+  indexing?: {
+    include?: string[];
+    exclude?: string[];
+  };
+  phase1?: {
+    maxEntrypointFiles?: number;
+    maxEntrypointChunks?: number;
+  };
+  qdrant?: {
+    host?: string;
+    port?: number;
+    collection?: string;
+  };
+  chunk?: {
+    maxLines?: number;
+    minLines?: number;
+  };
+  embedding?: {
+    provider?: string;
+  };
+}
+
+export const DEFAULT_CONFIG: Required<
+  Pick<MemConfig, "phase1" | "qdrant" | "chunk" | "embedding">
+> & { indexing: { include?: string[]; exclude?: string[] } } = {
+  phase1: {
+    maxEntrypointFiles: 50,
+    maxEntrypointChunks: 300,
+  },
+  qdrant: {
+    host: "127.0.0.1",
+    port: 6333,
+    collection: "project_memory",
+  },
+  chunk: {
+    maxLines: 400,
+    minLines: 50,
+  },
+  embedding: {
+    provider: "local",
+  },
+  indexing: {},
+};
+
+export const CONFIG_DIR = ".mem";
+export const CONFIG_FILE = ".mem/config.yml";
+export const MEMIGNORE_FILE = ".memignore";
+export const DEEP_INDEX_STATE_FILE = ".mem/state/deep-index.json";

package/packages/cli/src/docker/compose.ts

@@ -0,0 +1,75 @@
+import { execSync, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+const QDRANT_HEALTH_URL = "http://127.0.0.1:6333/health";
+const HEALTH_POLL_MS = 1000;
+const HEALTH_TIMEOUT_MS = 60_000;
+
+function getComposeDir(cwd: string): string {
+  const atRoot = join(cwd, "docker-compose.yml");
+  const atMem = join(cwd, ".mem", "docker-compose.yml");
+  if (existsSync(atRoot)) return cwd;
+  if (existsSync(atMem)) return join(cwd, ".mem");
+  return cwd;
+}
+
+function composeCmd(cwd: string): "docker compose" | "docker-compose" {
+  try {
+    execSync("docker compose version", { stdio: "pipe", cwd });
+    return "docker compose";
+  } catch {
+    try {
+      execSync("docker-compose --version", { stdio: "pipe", cwd });
+      return "docker-compose";
+    } catch {
+      throw new Error("Docker Compose not found. Install Docker and Docker Compose.");
+    }
+  }
+}
+
+export function dockerComposeUp(cwd: string): void {
+  const dir = getComposeDir(cwd);
+  const cmd = composeCmd(dir);
+  execSync(`${cmd} up -d`, { stdio: "inherit", cwd: dir });
+}
+
+export function dockerComposeDown(cwd: string): void {
+  const dir = getComposeDir(cwd);
+  const cmd = composeCmd(dir);
+  execSync(`${cmd} down`, { stdio: "inherit", cwd: dir });
+}
+
+export function waitForQdrantHealth(timeoutMs: number = HEALTH_TIMEOUT_MS): Promise<void> {
+  const start = Date.now();
+  return new Promise((resolve, reject) => {
+    function poll() {
+      if (Date.now() - start > timeoutMs) {
+        reject(new Error("Qdrant health check timed out"));
+        return;
+      }
+      fetch(QDRANT_HEALTH_URL)
+        .then((r) => {
+          if (r.ok) resolve();
+          else setTimeout(poll, HEALTH_POLL_MS);
+        })
+        .catch(() => setTimeout(poll, HEALTH_POLL_MS));
+    }
+    poll();
+  });
+}
+
+export function checkDockerAvailable(cwd: string): boolean {
+  try {
+    composeCmd(getComposeDir(cwd));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function checkQdrantHealthy(): Promise<boolean> {
+  return fetch(QDRANT_HEALTH_URL)
+    .then((r) => r.ok)
+    .catch(() => false);
+}

package/packages/cli/src/embedding/stub.test.ts

@@ -0,0 +1,35 @@
+import { strict as assert } from "node:assert";
+import { describe, it } from "node:test";
+import { embedText, embedBatch, getVectorSize } from "./stub.js";
+
+describe("embedding stub", () => {
+  it("getVectorSize returns 384", () => {
+    assert.strictEqual(getVectorSize(), 384);
+  });
+
+  it("embedText returns array of length 384", () => {
+    const vec = embedText("hello world");
+    assert.strictEqual(vec.length, 384);
+    assert.ok(vec.every((x) => typeof x === "number" && x >= 0 && x <= 1));
+  });
+
+  it("embedText is deterministic", () => {
+    const a = embedText("same text");
+    const b = embedText("same text");
+    assert.deepStrictEqual(a, b);
+  });
+
+  it("embedText differs for different input", () => {
+    const a = embedText("foo");
+    const b = embedText("bar");
+    assert.notDeepStrictEqual(a, b);
+  });
+
+  it("embedBatch returns one vector per text", () => {
+    const batch = embedBatch(["a", "b", "c"]);
+    assert.strictEqual(batch.length, 3);
+    assert.strictEqual(batch[0].length, 384);
+    assert.strictEqual(batch[1].length, 384);
+    assert.strictEqual(batch[2].length, 384);
+  });
+});

package/packages/cli/src/embedding/stub.ts

@@ -0,0 +1,32 @@
+const VECTOR_SIZE = 384;
+
+function simpleHash(str: string): number {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    h = (h * 31 + str.charCodeAt(i)) >>> 0;
+  }
+  return h;
+}
+
+/**
+ * Stub embedder: must match server's stub (same size and logic) for vector compatibility.
+ */
+export function embedText(text: string): number[] {
+  const vec: number[] = [];
+  const words = text.split(/\s+/).filter(Boolean);
+  for (let i = 0; i < VECTOR_SIZE; i++) {
+    const seed = words[i % words.length]
+      ? simpleHash(words[i % words.length]) + i * 31
+      : i;
+    vec.push(Math.sin(seed) * 0.5 + 0.5);
+  }
+  return vec;
+}
+
+export function embedBatch(texts: string[]): number[][] {
+  return texts.map(embedText);
+}
+
+export function getVectorSize(): number {
+  return VECTOR_SIZE;
+}

package/packages/cli/src/phase1/pipeline.ts

@@ -0,0 +1,164 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { loadConfig } from "../config/load.js";
+import { chunkFile } from "../chunking/chunker.js";
+import type { Chunk } from "../chunking/types.js";
+import { getModuleFromPath } from "../chunking/types.js";
+import { toRelativePath } from "../scope/allowlist.js";
+import { embedBatch } from "../embedding/stub.js";
+import { createQdrantClient, ensureCollection, upsertPoints } from "../qdrant/upsert.js";
+import { listInScopeFiles } from "../scope/allowlist.js";
+import { createIgnoreFilter } from "../scope/ignore.js";
+import { DEEP_INDEX_STATE_FILE } from "../config/types.js";
+import { writeFileSync, mkdirSync, existsSync } from "node:fs";
+
+const BATCH_SIZE = 16;
+const PHASE1_KINDS = ["system_map", "module_summary", "entrypoint"] as const;
+
+function selectEntrypoints(
+  chunks: Chunk[],
+  maxFiles: number,
+  maxChunks: number
+): Chunk[] {
+  const byPath = new Map<string, Chunk[]>();
+  for (const c of chunks) {
+    const list = byPath.get(c.metadata.path) ?? [];
+    list.push(c);
+    byPath.set(c.metadata.path, list);
+  }
+  const paths = [...byPath.keys()].sort();
+  const entrypointPaths = paths.slice(0, maxFiles);
+  const result: Chunk[] = [];
+  let count = 0;
+  for (const p of entrypointPaths) {
+    const list = byPath.get(p) ?? [];
+    for (const c of list) {
+      if (count >= maxChunks) break;
+      result.push(c);
+      count++;
+    }
+    if (count >= maxChunks) break;
+  }
+  return result;
+}
+
+function buildModuleSummaries(eligiblePaths: string[], cwd: string): { id: string; text: string; path: string; kind: string }[] {
+  const byDir = new Map<string, string[]>();
+  for (const abs of eligiblePaths) {
+    const rel = toRelativePath(cwd, abs);
+    const dir = getModuleFromPath(rel);
+    const list = byDir.get(dir) ?? [];
+    list.push(rel);
+    byDir.set(dir, list);
+  }
+  const out: { id: string; text: string; path: string; kind: string }[] = [];
+  for (const [dir, files] of byDir) {
+    const text = `Module: ${dir}\nFiles: ${files.slice(0, 50).join(", ")}${files.length > 50 ? ` (+${files.length - 50} more)` : ""}`;
+    const id = `module_summary:${dir.replace(/\//g, "_")}`;
+    out.push({ id, text, path: dir, kind: "module_summary" });
+  }
+  return out;
+}
+
+function buildSystemMaps(cwd: string, eligiblePaths: string[]): { id: string; text: string; path: string; kind: string }[] {
+  const relPaths = eligiblePaths.map((p) => toRelativePath(cwd, p)).sort();
+  const overview = `System overview\nIndexed paths (${relPaths.length}):\n${relPaths.slice(0, 100).join("\n")}${relPaths.length > 100 ? `\n... and ${relPaths.length - 100} more` : ""}`;
+  return [
+    { id: "system_map:overview", text: overview, path: "", kind: "system_map" },
+  ];
+}
+
+export async function runPhase1(cwd: string): Promise<void> {
+  const config = loadConfig(cwd);
+  const isIgnored = createIgnoreFilter(cwd, config.indexing?.exclude ?? []);
+  const inScopePaths = listInScopeFiles(cwd, config);
+  const eligiblePaths: string[] = [];
+  for (const abs of inScopePaths) {
+    const rel = toRelativePath(cwd, abs);
+    if (!isIgnored(rel)) eligiblePaths.push(abs);
+  }
+
+  const allChunks: Chunk[] = [];
+  for (const abs of eligiblePaths) {
+    try {
+      const content = readFileSync(abs, "utf8");
+      const chunks = chunkFile(toRelativePath(cwd, abs), content);
+      allChunks.push(...chunks);
+    } catch {
+      // skip binary or unreadable
+    }
+  }
+
+  const maxFiles = config.phase1?.maxEntrypointFiles ?? 50;
+  const maxChunks = config.phase1?.maxEntrypointChunks ?? 300;
+  const entrypointChunks = selectEntrypoints(allChunks, maxFiles, maxChunks);
+
+  const moduleSummaries = buildModuleSummaries(eligiblePaths, cwd);
+  const systemMaps = buildSystemMaps(cwd, eligiblePaths);
+
+  const host = config.qdrant?.host ?? "127.0.0.1";
+  const port = config.qdrant?.port ?? 6333;
+  const collection = config.qdrant?.collection ?? "project_memory";
+  const client = createQdrantClient(host, port);
+
+  await ensureCollection(client, collection);
+
+  const points: { id: string; vector: number[]; payload: { kind: string; path?: string; text: string } }[] = [];
+
+  for (const sm of systemMaps) {
+    points.push({
+      id: sm.id,
+      vector: embedBatch([sm.text])[0],
+      payload: { kind: sm.kind, path: sm.path || undefined, text: sm.text },
+    });
+  }
+  for (const ms of moduleSummaries) {
+    points.push({
+      id: ms.id,
+      vector: embedBatch([ms.text])[0],
+      payload: { kind: ms.kind, path: ms.path, text: ms.text },
+    });
+  }
+
+  const entrypointTexts = entrypointChunks.map((c) => c.text);
+  const entrypointVectors = embedBatch(entrypointTexts);
+  for (let i = 0; i < entrypointChunks.length; i++) {
+    const c = entrypointChunks[i];
+    points.push({
+      id: c.id,
+      vector: entrypointVectors[i],
+      payload: {
+        kind: "entrypoint",
+        path: c.metadata.path,
+        text: c.text.slice(0, 8000),
+      },
+    });
+  }
+
+  for (let i = 0; i < points.length; i += BATCH_SIZE) {
+    const batch = points.slice(i, i + BATCH_SIZE);
+    await upsertPoints(client, collection, batch);
+  }
+
+  const stateDir = join(cwd, ".mem", "state");
+  if (!existsSync(stateDir)) mkdirSync(stateDir, { recursive: true });
+  const deepIndexStatePath = join(cwd, DEEP_INDEX_STATE_FILE);
+  const totalChunks = allChunks.length;
+  const phase1Embedded = points.length;
+  const embeddedIds = points.map((p) => p.id);
+  writeFileSync(
+    deepIndexStatePath,
+    JSON.stringify({
+      embedded: phase1Embedded,
+      total: totalChunks,
+      embeddedIds,
+      phase1Complete: true,
+      lastUpdated: new Date().toISOString(),
+    }),
+    "utf8"
+  );
+
+  console.log(chalk.green("✓"), "Phase 1: embedded", phase1Embedded, "points (system maps, module summaries, entrypoints)");
+  console.log(chalk.dim("  Total chunks (for deep-index):"), totalChunks);
+}