karajan-code 3.12.0 → 3.12.2

package/node_modules/@karajan/core/tests/paths.test.js

@@ -1,51 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import os from "node:os";
-import path from "node:path";
-import {
-  resolveHome,
-  getKarajanHome,
-  getSessionRoot,
-  getRunsDir,
-  getPromptsDir,
-  __resetKjHomeWarningForTests,
-} from "../src/paths.js";
-
-describe("@karajan/core/paths", () => {
-  let originalKarajanHome;
-  let originalKjHome;
-
-  beforeEach(() => {
-    originalKarajanHome = process.env.KARAJAN_HOME;
-    originalKjHome = process.env.KJ_HOME;
-    delete process.env.KARAJAN_HOME;
-    delete process.env.KJ_HOME;
-    __resetKjHomeWarningForTests();
-  });
-
-  afterEach(() => {
-    if (originalKarajanHome !== undefined) process.env.KARAJAN_HOME = originalKarajanHome;
-    if (originalKjHome !== undefined) process.env.KJ_HOME = originalKjHome;
-  });
-
-  it("KARAJAN_HOME takes precedence", () => {
-    process.env.KARAJAN_HOME = "/tmp/explicit-home";
-    expect(resolveHome()).toBe(path.resolve("/tmp/explicit-home"));
-  });
-
-  it("getKarajanHome defaults to .karajan segment", () => {
-    process.env.KARAJAN_HOME = "/tmp/root";
-    expect(getKarajanHome()).toBe(path.resolve("/tmp/root"));
-  });
-
-  it("derived dirs hang off getKarajanHome", () => {
-    process.env.KARAJAN_HOME = "/tmp/root";
-    const home = path.resolve("/tmp/root");
-    expect(getSessionRoot()).toBe(path.join(home, "sessions"));
-    expect(getRunsDir()).toBe(path.join(home, "runs"));
-    expect(getPromptsDir()).toBe(path.join(home, "prompts"));
-  });
-
-  it("VITEST env auto-isolates to tmpdir", () => {
-    expect(resolveHome().startsWith(os.tmpdir())).toBe(true);
-  });
-});

package/node_modules/@karajan/core/tests/plan-hu-ops.test.js

@@ -1,68 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  addHu,
-  removeHu,
-  updateHu,
-  updateHuStatus,
-  certifyAllHus,
-  assertPlanRunnable,
-  computePlanOutcome,
-} from "../src/plan-hu-ops.js";
-
-const newPlan = () => ({ planId: "plan-T", hus: [], updatedAt: null });
-
-describe("@karajan/core/plan-hu-ops", () => {
-  it("addHu assigns sequential ID + defaults", () => {
-    const plan = newPlan();
-    const hu = addHu(plan, { title: "T1" });
-    expect(hu.id).toBe("hu_plan-T_001");
-    expect(hu.status).toBe("pending");
-    expect(plan.hus).toHaveLength(1);
-  });
-
-  it("removeHu cleans blocked_by + reuse refs", () => {
-    const plan = newPlan();
-    addHu(plan, { title: "T1" });
-    addHu(plan, { title: "T2", blocked_by: ["hu_plan-T_001"], reuse: ["hu_plan-T_001"] });
-    expect(removeHu(plan, "hu_plan-T_001")).toBe(true);
-    expect(plan.hus[0].blocked_by).toEqual([]);
-    expect(plan.hus[0].reuse).toEqual([]);
-  });
-
-  it("updateHu only writes allowed fields", () => {
-    const plan = newPlan();
-    addHu(plan, { title: "T1" });
-    updateHu(plan, "hu_plan-T_001", { title: "T1!", id: "evil" });
-    expect(plan.hus[0].title).toBe("T1!");
-    expect(plan.hus[0].id).toBe("hu_plan-T_001");
-  });
-
-  it("updateHuStatus + certifyAllHus + assertPlanRunnable", () => {
-    const plan = newPlan();
-    addHu(plan, { title: "T1" });
-    expect(updateHuStatus(plan, "hu_plan-T_001", "in_progress")).toBe(true);
-    addHu(plan, { title: "T2" });
-    expect(certifyAllHus(plan)).toBe(1);
-    expect(plan.status).toBe("ready");
-    expect(() => assertPlanRunnable(plan, "plan-T")).not.toThrow();
-  });
-
-  it("assertPlanRunnable throws when no HU certified", () => {
-    const plan = newPlan();
-    addHu(plan, { title: "T1" });
-    expect(() => assertPlanRunnable(plan, "plan-T")).toThrow(/0 HU/);
-  });
-
-  it("computePlanOutcome rolls up counts + dedupes", () => {
-    const plan = newPlan();
-    addHu(plan, { title: "T1" });
-    addHu(plan, { title: "T2" });
-    plan.hus[0].outcome = { status: "done", pr_url: "u", blockers: [] };
-    plan.hus[1].outcome = { status: "failed", pr_url: "u", blockers: ["x"] };
-    const o = computePlanOutcome(plan, { duration_ms: 1 });
-    expect(o.status).toBe("partial");
-    expect(o.counts).toEqual({ done: 1, failed: 1, blocked: 0, pending: 0 });
-    expect(o.prs).toEqual(["u"]);
-    expect(o.blockers).toEqual(["x"]);
-  });
-});

package/node_modules/@karajan/core/tests/plan-id.test.js

@@ -1,21 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { generatePlanId, generateHuId, normaliseAlias } from "../src/plan-id.js";
-
-describe("@karajan/core/plan-id", () => {
-  it("generatePlanId returns plan-<ts>-<rand>", () => {
-    const id = generatePlanId();
-    expect(id).toMatch(/^plan-\d{14}-[a-z0-9]{4}$/);
-  });
-
-  it("generateHuId formats sequence zero-padded", () => {
-    expect(generateHuId("plan-X", 1)).toBe("hu_plan-X_001");
-    expect(generateHuId("plan-X", 42)).toBe("hu_plan-X_042");
-  });
-
-  it("normaliseAlias slugifies + caps to 60 chars", () => {
-    expect(normaliseAlias("Greta App")).toBe("greta-app");
-    expect(normaliseAlias("Café — Ñoño")).toBe("cafe-nono");
-    expect(normaliseAlias("")).toBeNull();
-    expect(normaliseAlias(null)).toBeNull();
-  });
-});

package/node_modules/@karajan/core/tests/plan-validation.test.js

@@ -1,39 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { validateBlockedByChange } from "../src/plan-validation.js";
-
-const plan = () => ({
-  hus: [
-    { id: "a", blocked_by: [] },
-    { id: "b", blocked_by: ["a"] },
-    { id: "c", blocked_by: ["b"] },
-  ],
-});
-
-describe("@karajan/core/plan-validation", () => {
-  it("ok when the new blocked_by is a valid subset", () => {
-    expect(validateBlockedByChange(plan(), "c", ["a"]).ok).toBe(true);
-  });
-
-  it("rejects self-dependency", () => {
-    const r = validateBlockedByChange(plan(), "a", ["a"]);
-    expect(r.ok).toBe(false);
-    expect(r.error).toMatch(/auto-dependencia/);
-  });
-
-  it("rejects unknown HU reference", () => {
-    const r = validateBlockedByChange(plan(), "a", ["zzz"]);
-    expect(r.ok).toBe(false);
-    expect(r.error).toMatch(/inexistente/);
-  });
-
-  it("rejects cycle creation", () => {
-    const r = validateBlockedByChange(plan(), "a", ["c"]);
-    expect(r.ok).toBe(false);
-    expect(r.cycle).toBeDefined();
-    expect(r.error).toMatch(/Ciclo/);
-  });
-
-  it("rejects non-array blocked_by", () => {
-    expect(validateBlockedByChange(plan(), "a", "nope").ok).toBe(false);
-  });
-});

package/node_modules/@karajan/core/tests/port-check.test.js

@@ -1,47 +0,0 @@
-// Smoke coverage for the @karajan/core/port-check extraction
-// (KJC-TSK-0511 PR2). Real socket binding — tiny but fast.
-import { createServer } from "node:net";
-import { describe, it, expect } from "vitest";
-
-import { isPortAvailable, findAvailablePort } from "../src/port-check.js";
-
-function occupy() {
-  return new Promise((resolve) => {
-    const srv = createServer();
-    srv.listen(0, () => resolve({ srv, port: srv.address().port }));
-  });
-}
-
-describe("@karajan/core/port-check", () => {
-  it("isPortAvailable returns false for a port we already bound", async () => {
-    const { srv, port } = await occupy();
-    try {
-      expect(await isPortAvailable(port)).toBe(false);
-    } finally {
-      srv.close();
-    }
-  });
-
-  it("findAvailablePort skips busy ports and returns the next free one", async () => {
-    const { srv, port } = await occupy();
-    try {
-      const got = await findAvailablePort(port, 5);
-      expect(got).toBeGreaterThan(port);
-    } finally {
-      srv.close();
-    }
-  });
-
-  it("findAvailablePort throws when the range is exhausted", async () => {
-    const occupied = [];
-    for (let i = 0; i < 3; i += 1) occupied.push(await occupy());
-    const ports = occupied.map((o) => o.port).sort((a, b) => a - b);
-    try {
-      const gap = ports[2] - ports[0];
-      if (gap > 2) return;
-      await expect(findAvailablePort(ports[0], gap + 1)).rejects.toThrow(/No available port/);
-    } finally {
-      for (const { srv } of occupied) srv.close();
-    }
-  });
-});

package/node_modules/@karajan/core/tests/pricing/index.test.js

@@ -1,95 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-import { dirname, join } from "node:path";
-
-import {
-  getModelPricing,
-  listKnownModels,
-  _resetCache,
-} from "../../src/pricing/index.js";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const REGISTRY_PATH = join(__dirname, "../../src/pricing/model-pricing.json");
-
-describe("pricing — model-pricing.json structure", () => {
-  it("is valid JSON with a _meta block", () => {
-    const raw = readFileSync(REGISTRY_PATH, "utf8");
-    const data = JSON.parse(raw);
-    expect(data._meta).toBeDefined();
-    expect(data._meta.currency).toBe("USD");
-    expect(data._meta.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-    expect(data._meta.unit).toMatch(/1M tokens/);
-  });
-
-  it("every entry (except _meta) has inputPerMTok, outputPerMTok and source", () => {
-    const raw = readFileSync(REGISTRY_PATH, "utf8");
-    const data = JSON.parse(raw);
-    for (const [key, entry] of Object.entries(data)) {
-      if (key.startsWith("_")) continue;
-      expect(typeof entry.inputPerMTok).toBe("number");
-      expect(typeof entry.outputPerMTok).toBe("number");
-      expect(entry.inputPerMTok).toBeGreaterThanOrEqual(0);
-      expect(entry.outputPerMTok).toBeGreaterThanOrEqual(0);
-      expect(typeof entry.source).toBe("string");
-      expect(entry.source.length).toBeGreaterThan(0);
-    }
-  });
-});
-
-describe("pricing — getModelPricing()", () => {
-  beforeEach(() => _resetCache());
-
-  it("returns full pricing for a known Anthropic model", () => {
-    const p = getModelPricing("claude-opus-4-7");
-    expect(p).not.toBeNull();
-    expect(p.inputPerMTok).toBe(15.0);
-    expect(p.outputPerMTok).toBe(75.0);
-    expect(p.currency).toBe("USD");
-    expect(p.source).toBe("anthropic");
-    expect(p.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}$/);
-  });
-
-  it("returns full pricing for an OpenAI model", () => {
-    const p = getModelPricing("gpt-4o");
-    expect(p).not.toBeNull();
-    expect(p.source).toBe("openai");
-    expect(p.inputPerMTok).toBeGreaterThan(0);
-  });
-
-  it("returns full pricing for a Google model", () => {
-    const p = getModelPricing("gemini-1.5-flash");
-    expect(p).not.toBeNull();
-    expect(p.source).toBe("google");
-  });
-
-  it("returns null for an unknown model", () => {
-    expect(getModelPricing("nonexistent-model-xyz")).toBeNull();
-  });
-
-  it("returns null for the _meta key (does not leak metadata)", () => {
-    expect(getModelPricing("_meta")).toBeNull();
-  });
-
-  it("returns null for empty / non-string inputs", () => {
-    expect(getModelPricing("")).toBeNull();
-    expect(getModelPricing(null)).toBeNull();
-    expect(getModelPricing(undefined)).toBeNull();
-    expect(getModelPricing(42)).toBeNull();
-  });
-});
-
-describe("pricing — listKnownModels()", () => {
-  it("returns a non-empty list and never includes _meta", () => {
-    const models = listKnownModels();
-    expect(Array.isArray(models)).toBe(true);
-    expect(models.length).toBeGreaterThan(5);
-    expect(models).not.toContain("_meta");
-  });
-
-  it("every listed model resolves via getModelPricing", () => {
-    for (const m of listKnownModels()) {
-      expect(getModelPricing(m)).not.toBeNull();
-    }
-  });
-});

package/node_modules/@karajan/core/tests/process.test.js

@@ -1,22 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { runCommand } from "../src/process.js";
-
-describe("@karajan/core/process", () => {
-  it("captures stdout from a real subprocess", async () => {
-    const r = await runCommand("node", ["-e", "process.stdout.write('hi')"]);
-    expect(r.exitCode).toBe(0);
-    expect(r.stdout).toBe("hi");
-  });
-
-  it("returns exitCode 1 + spawnError when binary missing (ENOENT)", async () => {
-    const r = await runCommand("__definitely_not_a_real_bin__", []);
-    expect(r.exitCode).toBe(1);
-    expect(r.stderr).toBeTruthy();
-  });
-
-  it("times out and reports timedOut", async () => {
-    const r = await runCommand("node", ["-e", "setInterval(() => {}, 1000)"], { timeout: 200 });
-    expect(r.timedOut).toBe(true);
-    expect(r.exitCode).toBe(143);
-  });
-});

package/node_modules/@karajan/core/tests/run-registry.test.js

@@ -1,71 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import {
-  registerRun,
-  unregisterRun,
-  listActiveRuns,
-  runsDir,
-} from "../src/run-registry.js";
-
-describe("@karajan/core/run-registry", () => {
-  let tmpHome;
-  let originalKarajanHome;
-
-  beforeEach(() => {
-    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "kj-runreg-"));
-    originalKarajanHome = process.env.KARAJAN_HOME;
-    process.env.KARAJAN_HOME = tmpHome;
-  });
-
-  afterEach(() => {
-    if (originalKarajanHome === undefined) delete process.env.KARAJAN_HOME;
-    else process.env.KARAJAN_HOME = originalKarajanHome;
-    fs.rmSync(tmpHome, { recursive: true, force: true });
-  });
-
-  it("runsDir hangs off KARAJAN_HOME/runs", () => {
-    expect(runsDir()).toBe(path.join(path.resolve(tmpHome), "runs"));
-  });
-
-  it("registerRun → listActiveRuns round-trips for the live process", () => {
-    const runId = registerRun({
-      pid: process.pid,
-      planId: "PLN-1",
-      huIds: ["HU-1"],
-      projectDir: "/tmp/x",
-      source: "test",
-    });
-    expect(runId).toMatch(/^run-\d+-\d+-[a-z0-9]+$/);
-    const list = listActiveRuns({ planId: "PLN-1" });
-    expect(list.length).toBe(1);
-    expect(list[0].pid).toBe(process.pid);
-    unregisterRun(runId);
-    expect(listActiveRuns({ planId: "PLN-1" })).toEqual([]);
-  });
-
-  it("listActiveRuns reaps entries with dead PIDs from disk", () => {
-    fs.mkdirSync(runsDir(), { recursive: true });
-    const deadEntry = {
-      runId: "run-dead",
-      pid: 999_999_999,
-      planId: "PLN-x",
-      huIds: null,
-      projectDir: null,
-      source: "test",
-      startedAt: new Date().toISOString(),
-    };
-    fs.writeFileSync(
-      path.join(runsDir(), "run-dead.json"),
-      JSON.stringify(deadEntry),
-    );
-    expect(listActiveRuns()).toEqual([]);
-    expect(fs.existsSync(path.join(runsDir(), "run-dead.json"))).toBe(false);
-  });
-
-  it("registerRun returns null when pid is missing", () => {
-    expect(registerRun({})).toBeNull();
-    expect(registerRun({ pid: 0 })).toBeNull();
-  });
-});

package/node_modules/@karajan/core/tests/shared-paths.test.js

@@ -1,30 +0,0 @@
-// Smoke coverage for the @karajan/core/shared-paths extraction
-// (KJC-TSK-0511 PR2). Full unit coverage stays next to the CLI;
-// this file proves the new package entry point resolves and returns
-// stable paths so a future workspace-wiring regression fails loudly.
-import { sep } from "node:path";
-import { describe, it, expect } from "vitest";
-
-import {
-  SHARED_DIR_NAME,
-  getSharedRoot,
-  getSharedPlansDir,
-  getSharedHuStoriesDir,
-  isSharedPath,
-} from "../src/shared-paths.js";
-
-describe("@karajan/core/shared-paths", () => {
-  it("constants and joins land inside the project dir", () => {
-    expect(SHARED_DIR_NAME).toBe(".karajan-shared");
-    expect(getSharedRoot("/tmp/proj")).toBe(`/tmp/proj${sep}.karajan-shared`);
-    expect(getSharedPlansDir("/tmp/proj").endsWith(`${sep}plans`)).toBe(true);
-    expect(getSharedHuStoriesDir("/tmp/proj").endsWith(`${sep}hu-stories`)).toBe(true);
-  });
-
-  it("isSharedPath recognises only paths within .karajan-shared", () => {
-    expect(isSharedPath("/repo/.karajan-shared/plans/x.json")).toBe(true);
-    expect(isSharedPath("/repo/local/plans/x.json")).toBe(false);
-    expect(isSharedPath("")).toBe(false);
-    expect(isSharedPath(null)).toBe(false);
-  });
-});

package/node_modules/@karajan/core/tests/standby.test.js

@@ -1,66 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { tmpdir } from "node:os";
-import { mkdtempSync, rmSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import {
-  persistStandby, loadStandby, listPendingStandby, markStandbyDone,
-  acquireStandbyLock, standbyDir,
-} from "../src/standby-store.js";
-import {
-  scheduleResume, cancelScheduled, _resetScheduledForTests,
-} from "../src/standby-scheduler.js";
-
-let tmp;
-beforeEach(() => {
-  tmp = mkdtempSync(join(tmpdir(), "kj-core-standby-"));
-  process.env.KJ_HOME = tmp;
-  _resetScheduledForTests();
-});
-afterEach(() => {
-  delete process.env.KJ_HOME;
-  rmSync(tmp, { recursive: true, force: true });
-});
-
-describe("@karajan/core/standby-store", () => {
-  it("persists + loads + lists pending sessions", () => {
-    persistStandby({ sessionId: "s_1", cooldownUntil: "2099-01-01T00:00:00Z", reason: "QUOTA" });
-    const loaded = loadStandby("s_1");
-    expect(loaded.sessionId).toBe("s_1");
-    expect(listPendingStandby()).toHaveLength(1);
-    expect(standbyDir().startsWith(tmp)).toBe(true);
-  });
-
-  it("markStandbyDone moves the file under done/", () => {
-    persistStandby({ sessionId: "s_2", cooldownUntil: "2099-01-01T00:00:00Z" });
-    expect(markStandbyDone("s_2")).toBe(true);
-    expect(loadStandby("s_2")).toBe(null);
-  });
-
-  it("acquireStandbyLock is exclusive", () => {
-    const a = acquireStandbyLock("s_3");
-    expect(a.acquired).toBe(true);
-    const b = acquireStandbyLock("s_3");
-    expect(b.acquired).toBe(false);
-    a.release();
-    const c = acquireStandbyLock("s_3");
-    expect(c.acquired).toBe(true);
-    c.release();
-  });
-});
-
-describe("@karajan/core/standby-scheduler", () => {
-  it("scheduleResume with expired cooldown fires immediate", async () => {
-    const cb = vi.fn();
-    const r = scheduleResume({ sessionId: "s_4", cooldownUntil: "1990-01-01T00:00:00Z", onResume: cb });
-    expect(r.scheduled).toBe(true);
-    expect(r.immediate).toBe(true);
-    await new Promise((res) => setImmediate(res));
-    expect(cb).toHaveBeenCalledWith("s_4");
-  });
-
-  it("cancelScheduled removes a queued timeout", () => {
-    scheduleResume({ sessionId: "s_5", cooldownUntil: "2099-01-01T00:00:00Z", onResume: () => {} });
-    expect(cancelScheduled("s_5")).toBe(true);
-    expect(cancelScheduled("s_5")).toBe(false);
-  });
-});

package/node_modules/@karajan/core/tests/vec-store.test.js

@@ -1,98 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import {
-  openVecStore,
-  insertChunk,
-  searchSimilar,
-  countChunks,
-  projectSlug,
-  deleteChunksBySource,
-  findChunkByHash,
-  getLastIndexedCommit,
-  setLastIndexedCommit,
-  dbPath,
-} from "../src/vec-store.js";
-
-describe("@karajan/core/vec-store", () => {
-  let tmpDir;
-  let originalRagDb;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "kj-vecstore-"));
-    originalRagDb = process.env.KJ_RAG_DB;
-    process.env.KJ_RAG_DB = path.join(tmpDir, "rag.db");
-  });
-
-  afterEach(() => {
-    if (originalRagDb === undefined) delete process.env.KJ_RAG_DB;
-    else process.env.KJ_RAG_DB = originalRagDb;
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("dbPath honours KJ_RAG_DB env", () => {
-    expect(dbPath()).toBe(path.join(tmpDir, "rag.db"));
-  });
-
-  it("openVecStore initialises chunks + vec_chunks + fts tables", () => {
-    const db = openVecStore({ dim: 4 });
-    expect(countChunks(db)).toBe(0);
-    db.close();
-  });
-
-  it("insertChunk + searchSimilar round-trip", () => {
-    const db = openVecStore({ dim: 4 });
-    const id = insertChunk(db, {
-      source: "/a.md",
-      kind: "code",
-      text: "hola mundo",
-      embedding: [1, 0, 0, 0],
-    });
-    expect(id).toBeGreaterThan(0);
-    const hits = searchSimilar(db, [1, 0, 0, 0], 1);
-    expect(hits.length).toBe(1);
-    expect(hits[0].text).toBe("hola mundo");
-    db.close();
-  });
-
-  it("deleteChunksBySource removes chunks + vec rows", () => {
-    const db = openVecStore({ dim: 4 });
-    insertChunk(db, { source: "/x.md", kind: "code", text: "a", embedding: [1, 0, 0, 0] });
-    insertChunk(db, { source: "/x.md", kind: "code", text: "b", embedding: [0, 1, 0, 0] });
-    expect(deleteChunksBySource(db, "/x.md")).toBe(2);
-    expect(countChunks(db)).toBe(0);
-    db.close();
-  });
-
-  it("projectSlug normalises basenames", () => {
-    expect(projectSlug("/home/me/My Project")).toBe("my-project");
-    expect(projectSlug("/home/me/karajan-code/")).toBe("karajan-code");
-    expect(projectSlug(null)).toBeNull();
-  });
-
-  it("findChunkByHash scopes to project", () => {
-    const db = openVecStore({ dim: 4 });
-    insertChunk(db, {
-      source: "/y.md",
-      kind: "code",
-      text: "hi",
-      embedding: [1, 0, 0, 0],
-      project: "p1",
-      contentHash: "h1",
-    });
-    expect(findChunkByHash(db, "h1", "p1").source).toBe("/y.md");
-    expect(findChunkByHash(db, "h1", "p2")).toBeNull();
-    db.close();
-  });
-
-  it("get/setLastIndexedCommit persists per-project watermark", () => {
-    const db = openVecStore({ dim: 4 });
-    expect(getLastIndexedCommit(db, "p1")).toBeNull();
-    setLastIndexedCommit(db, "p1", "abc123");
-    expect(getLastIndexedCommit(db, "p1")).toBe("abc123");
-    setLastIndexedCommit(db, "p1", "def456");
-    expect(getLastIndexedCommit(db, "p1")).toBe("def456");
-    db.close();
-  });
-});

package/node_modules/@karajan/core/vitest.config.js

@@ -1,12 +0,0 @@
-// Local Vitest config for @karajan/core so the workspace package does
-// not inherit the root config (which excludes `packages/**` and points
-// at a global setup file outside the workspace).
-
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    include: ["tests/**/*.test.js"],
-    environment: "node",
-  },
-});