@rohirik/openltm-core 2.8.0

package/src/__tests__/cli/detect.test.ts

@@ -0,0 +1,91 @@
+/**
+ * cli/detect.test.ts — Unit tests for the agent detection logic.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import os from "os";
+
+function makeTmp(): string {
+  const dir = join(os.tmpdir(), `ltm-detect-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+describe("detectAgents", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmp();
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("returns all false for an empty directory", async () => {
+    const { detectAgents } = await import("../../cli/detect.js");
+    const result = detectAgents(tmpDir);
+    expect(result).toEqual({ claude: false, opencode: false, pi: false });
+  });
+
+  it("detects Claude when .claude/ exists", async () => {
+    mkdirSync(join(tmpDir, ".claude"), { recursive: true });
+    const { detectAgents } = await import("../../cli/detect.js");
+    const result = detectAgents(tmpDir);
+    expect(result.claude).toBe(true);
+    expect(result.opencode).toBe(false);
+    expect(result.pi).toBe(false);
+  });
+
+  it("detects OpenCode when ~/.config/opencode exists", async () => {
+    mkdirSync(join(tmpDir, ".config", "opencode"), { recursive: true });
+    const { detectAgents } = await import("../../cli/detect.js");
+    const result = detectAgents(tmpDir);
+    expect(result.claude).toBe(false);
+    expect(result.opencode).toBe(true);
+    expect(result.pi).toBe(false);
+  });
+
+  it("detects Pi when ~/.pi/ directory exists", async () => {
+    mkdirSync(join(tmpDir, ".pi"), { recursive: true });
+    const { detectAgents } = await import("../../cli/detect.js");
+    const result = detectAgents(tmpDir);
+    expect(result.claude).toBe(false);
+    expect(result.opencode).toBe(false);
+    expect(result.pi).toBe(true);
+  });
+
+  it("detects Pi when ~/pi.toml file exists", async () => {
+    const { writeFileSync } = await import("fs");
+    writeFileSync(join(tmpDir, "pi.toml"), "# Pi config\n");
+    const { detectAgents } = await import("../../cli/detect.js");
+    const result = detectAgents(tmpDir);
+    expect(result.pi).toBe(true);
+  });
+
+  it("detects multiple agents when multiple dirs exist", async () => {
+    mkdirSync(join(tmpDir, ".claude"), { recursive: true });
+    mkdirSync(join(tmpDir, ".config", "opencode"), { recursive: true });
+    mkdirSync(join(tmpDir, ".pi"), { recursive: true });
+    const { detectAgents } = await import("../../cli/detect.js");
+    const result = detectAgents(tmpDir);
+    expect(result).toEqual({ claude: true, opencode: true, pi: true });
+  });
+
+  it("detects Claude + Pi but not OpenCode", async () => {
+    mkdirSync(join(tmpDir, ".claude"), { recursive: true });
+    mkdirSync(join(tmpDir, ".pi"), { recursive: true });
+    const { detectAgents } = await import("../../cli/detect.js");
+    const result = detectAgents(tmpDir);
+    expect(result).toEqual({ claude: true, opencode: false, pi: true });
+  });
+
+  it("exports DetectResult shape (type check via runtime properties)", async () => {
+    const { detectAgents } = await import("../../cli/detect.js");
+    const result = detectAgents(tmpDir);
+    expect(typeof result.claude).toBe("boolean");
+    expect(typeof result.opencode).toBe("boolean");
+    expect(typeof result.pi).toBe("boolean");
+  });
+});

package/src/__tests__/cli/install.test.ts

@@ -0,0 +1,161 @@
+/**
+ * cli/install.test.ts — Integration tests for the install orchestrator.
+ *
+ * Tests the runInstallCli function end-to-end using a tmp homedir so no real
+ * config files are touched.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import os from "os";
+
+function makeTmp(): string {
+  const dir = join(
+    os.tmpdir(),
+    `ltm-install-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+describe("runInstallCli — orchestration", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmp();
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("installs into Claude when --claude flag given", async () => {
+    const { runInstallCli } = await import("../../cli/install.js");
+    const result = await runInstallCli({
+      targets: { claude: true, opencode: false, pi: false },
+      dryRun: false,
+      homedir: tmpDir,
+      silent: true,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.results.length).toBe(1);
+    expect(result.results[0]!.target).toBe("claude");
+    expect(result.results[0]!.status).toBe("installed");
+    expect(existsSync(join(tmpDir, ".claude", "settings.json"))).toBe(true);
+  });
+
+  it("installs into OpenCode when --opencode flag given", async () => {
+    const { runInstallCli } = await import("../../cli/install.js");
+    const result = await runInstallCli({
+      targets: { claude: false, opencode: true, pi: false },
+      dryRun: false,
+      homedir: tmpDir,
+      silent: true,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.results[0]!.target).toBe("opencode");
+    expect(result.results[0]!.status).toBe("installed");
+  });
+
+  it("installs into Pi when --pi flag given", async () => {
+    const { runInstallCli } = await import("../../cli/install.js");
+    const result = await runInstallCli({
+      targets: { claude: false, opencode: false, pi: true },
+      dryRun: false,
+      homedir: tmpDir,
+      silent: true,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.results[0]!.target).toBe("pi");
+    // "skipped" is valid when Pi is already registered in the real environment
+    expect(["installed", "skipped"]).toContain(result.results[0]!.status);
+  });
+
+  it("e2e: installs all three targets when all flags given", async () => {
+    const { runInstallCli } = await import("../../cli/install.js");
+    const result = await runInstallCli({
+      targets: { claude: true, opencode: true, pi: true },
+      dryRun: false,
+      homedir: tmpDir,
+      silent: true,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.results.length).toBe(3);
+    const statuses = result.results.map((r) => r.status);
+    // "skipped" is also a valid success (e.g. Pi already installed)
+    expect(statuses.every((s) => s === "installed" || s === "skipped")).toBe(true);
+
+    // Verify Claude and OpenCode config files were created
+    expect(existsSync(join(tmpDir, ".claude", "settings.json"))).toBe(true);
+  });
+
+  it("second run → all skipped", async () => {
+    const { runInstallCli } = await import("../../cli/install.js");
+    const opts = {
+      targets: { claude: true, opencode: true, pi: true },
+      dryRun: false,
+      homedir: tmpDir,
+      silent: true,
+    };
+    await runInstallCli(opts);
+    const second = await runInstallCli(opts);
+    expect(second.exitCode).toBe(0);
+    const statuses = second.results.map((r) => r.status);
+    expect(statuses.every((s) => s === "skipped")).toBe(true);
+  });
+
+  it("no flags + empty homedir → exit code 2 (nothing detected)", async () => {
+    const { runInstallCli } = await import("../../cli/install.js");
+    const result = await runInstallCli({
+      targets: { claude: false, opencode: false, pi: false },
+      dryRun: false,
+      homedir: tmpDir,
+      silent: true,
+    });
+    expect(result.exitCode).toBe(2);
+    expect(result.results.length).toBe(0);
+  });
+
+  it("auto-detects Claude when .claude/ exists and no flags given", async () => {
+    mkdirSync(join(tmpDir, ".claude"), { recursive: true });
+    const { runInstallCli } = await import("../../cli/install.js");
+    const result = await runInstallCli({
+      targets: { claude: false, opencode: false, pi: false },
+      dryRun: false,
+      homedir: tmpDir,
+      silent: true,
+    });
+    expect(result.exitCode).toBe(0);
+    expect(result.results.some((r) => r.target === "claude")).toBe(true);
+  });
+
+  it("dryRun propagates to all installers — no files written", async () => {
+    const { runInstallCli } = await import("../../cli/install.js");
+    await runInstallCli({
+      targets: { claude: true, opencode: true, pi: true },
+      dryRun: true,
+      homedir: tmpDir,
+      silent: true,
+    });
+    // No files should be written
+    expect(existsSync(join(tmpDir, ".claude", "settings.json"))).toBe(false);
+    expect(existsSync(join(tmpDir, ".pi", "config.toml"))).toBe(false);
+  });
+
+  it("Claude settings.json has correct MCP entry after install", async () => {
+    const { runInstallCli } = await import("../../cli/install.js");
+    await runInstallCli({
+      targets: { claude: true, opencode: false, pi: false },
+      dryRun: false,
+      homedir: tmpDir,
+      silent: true,
+    });
+    const settings = JSON.parse(
+      readFileSync(join(tmpDir, ".claude", "settings.json"), "utf8"),
+    ) as Record<string, unknown>;
+    const ltm = (settings["mcpServers"] as Record<string, unknown>)["openltm"] as {
+      command: string;
+    };
+    expect(ltm.command).toBe("bunx");
+  });
+});

package/src/__tests__/cli/opencode.test.ts

@@ -0,0 +1,169 @@
+/**
+ * cli/opencode.test.ts — Unit tests for the OpenCode installer.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import os from "os";
+
+function makeTmp(): string {
+  const dir = join(
+    os.tmpdir(),
+    `ltm-opencode-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function defaultConfigPath(tmpDir: string): string {
+  // Tests run on linux in CI or darwin locally — always use .config path since
+  // we're not in a real darwin environment with ~/Library
+  return join(tmpDir, ".config", "opencode", "opencode.json");
+}
+
+describe("installOpenCode", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmp();
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("creates new config with correct shape when no config exists", async () => {
+    const { installOpenCode } = await import("../../cli/opencode.js");
+    const result = await installOpenCode({ homedir: tmpDir });
+    expect(result.status).toBe("installed");
+
+    // Find the created file (either .config or Library path)
+    const linuxPath = join(tmpDir, ".config", "opencode", "opencode.json");
+    const darwinPath = join(tmpDir, "Library", "Application Support", "opencode", "opencode.json");
+    const created = existsSync(linuxPath) ? linuxPath : darwinPath;
+    expect(existsSync(created)).toBe(true);
+
+    const cfg = JSON.parse(readFileSync(created, "utf8")) as Record<string, unknown>;
+    expect(cfg["$schema"]).toBe("https://opencode.ai/config.json");
+    expect(Array.isArray(cfg["plugin"])).toBe(true);
+    expect((cfg["plugin"] as string[]).some((p) => p.includes("@rohirik/opencode-ltm"))).toBe(true);
+  });
+
+  it("patches existing config by adding to plugin array", async () => {
+    // Create existing config
+    const configDir = join(tmpDir, ".config", "opencode");
+    mkdirSync(configDir, { recursive: true });
+    const configPath = join(configDir, "opencode.json");
+    writeFileSync(
+      configPath,
+      JSON.stringify({ $schema: "https://opencode.ai/config.json", theme: "dark", plugin: [] }),
+      "utf8",
+    );
+
+    const { installOpenCode } = await import("../../cli/opencode.js");
+    const result = await installOpenCode({ homedir: tmpDir });
+    expect(result.status).toBe("installed");
+
+    const cfg = JSON.parse(readFileSync(configPath, "utf8")) as Record<string, unknown>;
+    expect(cfg["theme"]).toBe("dark");
+    const plugins = cfg["plugin"] as string[];
+    expect(plugins.some((p) => p.includes("@rohirik/opencode-ltm"))).toBe(true);
+  });
+
+  it("preserves other keys in existing config", async () => {
+    const configDir = join(tmpDir, ".config", "opencode");
+    mkdirSync(configDir, { recursive: true });
+    const configPath = join(configDir, "opencode.json");
+    writeFileSync(
+      configPath,
+      JSON.stringify({
+        $schema: "https://opencode.ai/config.json",
+        model: "claude-opus-4",
+        keybindings: "vim",
+        plugin: ["@other/tool@1.0.0"],
+      }),
+      "utf8",
+    );
+
+    const { installOpenCode } = await import("../../cli/opencode.js");
+    await installOpenCode({ homedir: tmpDir });
+
+    const cfg = JSON.parse(readFileSync(configPath, "utf8")) as Record<string, unknown>;
+    expect(cfg["model"]).toBe("claude-opus-4");
+    expect(cfg["keybindings"]).toBe("vim");
+    const plugins = cfg["plugin"] as string[];
+    expect(plugins).toContain("@other/tool@1.0.0");
+    expect(plugins.some((p) => p.includes("@rohirik/opencode-ltm"))).toBe(true);
+  });
+
+  // Pre-deploy the customization components so the skip path can be exercised:
+  // status is only "skipped" when the plugin is registered AND every component
+  // is already present.
+  function preDeployComponents(configDir: string): void {
+    for (const comp of ["agents", "skills", "plugins"]) {
+      const dir = join(configDir, comp);
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(join(dir, ".installed"), "", "utf8");
+    }
+  }
+
+  it("skips when plugin is registered and components are already deployed", async () => {
+    const configDir = join(tmpDir, ".config", "opencode");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(
+      join(configDir, "opencode.json"),
+      JSON.stringify({ plugin: ["@rohirik/opencode-ltm@latest"] }),
+      "utf8",
+    );
+    preDeployComponents(configDir);
+
+    const { installOpenCode } = await import("../../cli/opencode.js");
+    const result = await installOpenCode({ homedir: tmpDir });
+    expect(result.status).toBe("skipped");
+  });
+
+  it("skips even if version differs (matches on substring @rohirik/opencode-ltm)", async () => {
+    const configDir = join(tmpDir, ".config", "opencode");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(
+      join(configDir, "opencode.json"),
+      JSON.stringify({ plugin: ["@rohirik/opencode-ltm@2.0.0"] }),
+      "utf8",
+    );
+    preDeployComponents(configDir);
+
+    const { installOpenCode } = await import("../../cli/opencode.js");
+    const result = await installOpenCode({ homedir: tmpDir });
+    expect(result.status).toBe("skipped");
+  });
+
+  it("deploys agents, skills, and plugins from the bundled assets", async () => {
+    const { installOpenCode } = await import("../../cli/opencode.js");
+    const result = await installOpenCode({ homedir: tmpDir });
+    expect(result.status).toBe("installed");
+
+    // Components co-locate with the resolved config (.config on linux,
+    // Library/Application Support on darwin).
+    const linuxDir = join(tmpDir, ".config", "opencode");
+    const darwinDir = join(tmpDir, "Library", "Application Support", "opencode");
+    const configDir = existsSync(join(linuxDir, "agents")) ? linuxDir : darwinDir;
+
+    // The bundled assets ship an aegis agent, three skills, and an aegis plugin.
+    expect(existsSync(join(configDir, "agents", "aegis.md"))).toBe(true);
+    expect(existsSync(join(configDir, "skills", "AgentTrustBoundaries", "SKILL.md"))).toBe(true);
+    expect(existsSync(join(configDir, "plugins", "aegis.ts"))).toBe(true);
+    // Lockfiles and node_modules must never be copied into the user's config.
+    expect(existsSync(join(configDir, "skills", "node_modules"))).toBe(false);
+  });
+
+  it("dryRun=true does not write any files", async () => {
+    const { installOpenCode } = await import("../../cli/opencode.js");
+    const result = await installOpenCode({ homedir: tmpDir, dryRun: true });
+    expect(result.status).toBe("installed");
+
+    const linuxPath = join(tmpDir, ".config", "opencode", "opencode.json");
+    const darwinPath = join(tmpDir, "Library", "Application Support", "opencode", "opencode.json");
+    expect(existsSync(linuxPath)).toBe(false);
+    expect(existsSync(darwinPath)).toBe(false);
+  });
+});

package/src/__tests__/cli/pi.test.ts

@@ -0,0 +1,113 @@
+/**
+ * cli/pi.test.ts — Unit tests for the Pi installer.
+ *
+ * Uses a fake `pi` shell script injected via `_piCmd` so tests never touch
+ * the real Pi installation or require Pi to be installed.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync, chmodSync } from "fs";
+import { join } from "path";
+import os from "os";
+
+function makeTmp(): string {
+  const dir = join(
+    os.tmpdir(),
+    `ltm-pi-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/** Create a fake `pi` script in tmpDir and return its path. */
+function makeFakePi(tmpDir: string, opts: { listOutput?: string; installFails?: boolean } = {}): string {
+  const piPath = join(tmpDir, "pi");
+  const listOut = opts.listOutput ?? "No packages installed.";
+  const exitCode = opts.installFails ? 1 : 0;
+
+  writeFileSync(
+    piPath,
+    `#!/bin/sh
+if [ "$1" = "list" ]; then
+  echo "${listOut}"
+  exit 0
+fi
+if [ "$1" = "install" ]; then
+  exit ${exitCode}
+fi
+exit 1
+`,
+    "utf8",
+  );
+  chmodSync(piPath, 0o755);
+  return piPath;
+}
+
+describe("installPi", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmp();
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("installs when pi CLI is available and package is not yet installed", async () => {
+    const { installPi } = await import("../../cli/pi.js");
+    const piCmd = makeFakePi(tmpDir);
+    const result = await installPi({ _piCmd: piCmd });
+    expect(result.status).toBe("installed");
+    expect(result.detail).toContain("@rohirik/pi-ltm");
+  });
+
+  it("skips when package is already installed", async () => {
+    const { installPi } = await import("../../cli/pi.js");
+    const piCmd = makeFakePi(tmpDir, { listOutput: "npm:@rohirik/pi-ltm" });
+    const result = await installPi({ _piCmd: piCmd });
+    expect(result.status).toBe("skipped");
+    expect(result.detail).toContain("already registered");
+  });
+
+  it("returns skipped with helpful message when pi CLI is not found", async () => {
+    const { installPi } = await import("../../cli/pi.js");
+    // Pass a non-existent path so `pi list` will throw
+    const result = await installPi({ _piCmd: "/nonexistent/pi" });
+    // isAlreadyInstalled catches the error and returns false, then install attempt fails
+    expect(result.status).toBe("error");
+  });
+
+  it("returns skipped when no pi CLI available (null)", async () => {
+    const { installPi } = await import("../../cli/pi.js");
+    // Simulate findPiCli returning null by not providing _piCmd and ensuring 'pi' is not in PATH
+    // We can't easily test this without mocking, so test the _piCmd=undefined path indirectly
+    // by checking the skipped result message
+    const piCmd = makeFakePi(tmpDir);
+    const result = await installPi({ _piCmd: piCmd, dryRun: true });
+    expect(result.status).toBe("installed");
+    expect(result.detail).toContain("dry-run");
+  });
+
+  it("dryRun=true does not call pi install", async () => {
+    const { installPi } = await import("../../cli/pi.js");
+    // If install ran, the fake pi would exit 0; but dryRun should short-circuit
+    const piCmd = makeFakePi(tmpDir);
+    const result = await installPi({ _piCmd: piCmd, dryRun: true });
+    expect(result.status).toBe("installed");
+    expect(result.detail).toContain("dry-run");
+  });
+
+  it("returns error when pi install fails", async () => {
+    const { installPi } = await import("../../cli/pi.js");
+    const piCmd = makeFakePi(tmpDir, { installFails: true });
+    const result = await installPi({ _piCmd: piCmd });
+    expect(result.status).toBe("error");
+  });
+
+  it("skips when already installed even in dryRun mode", async () => {
+    const { installPi } = await import("../../cli/pi.js");
+    const piCmd = makeFakePi(tmpDir, { listOutput: "npm:@rohirik/pi-ltm" });
+    const result = await installPi({ _piCmd: piCmd, dryRun: true });
+    expect(result.status).toBe("skipped");
+  });
+});

package/src/__tests__/cli.test.ts

@@ -0,0 +1,70 @@
+/**
+ * cli.test.ts — unit tests for packages/openltm-core/src/cli/types.ts and cli/install.ts
+ *
+ * RED phase: these tests are written before implementation.
+ * They define the contract for the CLI installer stub.
+ */
+import { describe, it, expect } from "bun:test";
+
+// ── types.ts ──────────────────────────────────────────────────────────────────
+
+describe("cli/types — InstallTarget shape", () => {
+  it("InstallTarget has required host and pluginDataDir fields", async () => {
+    const { InstallTarget } = await import("../cli/types.js");
+    // Runtime check: the exported object is a string-enum-like map
+    expect(typeof InstallTarget).toBe("object");
+    expect(InstallTarget["claudeCode"]).toBe("claude-code");
+    expect(InstallTarget["openCode"]).toBe("open-code");
+  });
+
+  it("CliInstallOptions type is exported (compile-time guard via import)", async () => {
+    // Just importing the module means the types compile; no runtime value to assert.
+    const mod = await import("../cli/types.js");
+    expect(mod).toBeDefined();
+  });
+
+  it("CliInstallResult type is exported from types module", async () => {
+    const mod = await import("../cli/types.js");
+    expect(mod).toBeDefined();
+    // CliInstallResult is a type-only export; confirm the module loaded successfully
+    expect(Object.keys(mod).length).toBeGreaterThan(0);
+  });
+});
+
+// ── install.ts ────────────────────────────────────────────────────────────────
+
+describe("cli/install — runInstall stub", () => {
+  it("exports a runInstall function", async () => {
+    const mod = await import("../cli/install.js");
+    expect(typeof mod.runInstall).toBe("function");
+  });
+
+  it("runInstall returns a CliInstallResult with success and message", async () => {
+    const { runInstall } = await import("../cli/install.js");
+    const result = await runInstall({ target: "claude-code", nonInteractive: true, dryRun: true });
+    expect(typeof result.success).toBe("boolean");
+    expect(typeof result.message).toBe("string");
+    expect(result.message.length).toBeGreaterThan(0);
+  });
+
+  it("runInstall dryRun=true does not write any files", async () => {
+    const { runInstall } = await import("../cli/install.js");
+    // Dry run should succeed without side-effects
+    const result = await runInstall({ target: "claude-code", nonInteractive: true, dryRun: true });
+    expect(result.success).toBe(true);
+  });
+
+  it("runInstall dryRun=true returns steps array", async () => {
+    const { runInstall } = await import("../cli/install.js");
+    const result = await runInstall({ target: "claude-code", nonInteractive: true, dryRun: true });
+    expect(Array.isArray(result.steps)).toBe(true);
+  });
+
+  it("runInstall with unknown target returns success=false", async () => {
+    const { runInstall } = await import("../cli/install.js");
+    // @ts-expect-error intentional bad input
+    const result = await runInstall({ target: "not-a-real-target", nonInteractive: true, dryRun: true });
+    expect(result.success).toBe(false);
+    expect(result.message).toContain("Unknown target");
+  });
+});

package/src/__tests__/events/crossProcess.test.ts

@@ -0,0 +1,82 @@
+/**
+ * crossProcess.test.ts — opt-in cross-agent sync contract (Phase 8 X1).
+ * The flag `ltm.crossProcessSync` defaults off; even when on, cross-process
+ * push requires Honker, so without an ext binary every entry point is a no-op.
+ */
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import { _setDbForTesting } from "../../shared-db.js";
+import { SETTING_KEYS, SETTING_DEFAULTS } from "../../janitor/providers/types.js";
+import {
+  isCrossProcessSyncEnabled,
+  notifyMemoryAdded,
+  startCrossProcessSync,
+  MEMORY_ADDED,
+} from "../../events/index.js";
+import { _resetHonkerForTesting } from "../../lib/honker.js";
+
+function seedDb(): Database {
+  const db = new Database(":memory:");
+  db.exec(`CREATE TABLE settings (key TEXT PRIMARY KEY, value TEXT NOT NULL, updated_at TEXT)`);
+  return db;
+}
+
+describe("cross-process sync — flag + dormant contract (no honker)", () => {
+  beforeEach(() => {
+    _resetHonkerForTesting();
+    delete process.env["LTM_HONKER_EXT"];
+  });
+  afterEach(() => {
+    _resetHonkerForTesting();
+  });
+
+  it("defaults off (setting default is \"off\")", () => {
+    expect(SETTING_DEFAULTS[SETTING_KEYS.CROSS_PROCESS_SYNC]).toBe("off");
+  });
+
+  it("exposes the stable memory_added event type", () => {
+    expect(MEMORY_ADDED).toBe("memory_added");
+  });
+
+  it("isCrossProcessSyncEnabled is false when unset", () => {
+    _setDbForTesting(seedDb());
+    expect(isCrossProcessSyncEnabled()).toBe(false);
+  });
+
+  it("isCrossProcessSyncEnabled is true only when the setting is \"on\"", () => {
+    const db = seedDb();
+    db.run("INSERT INTO settings(key,value) VALUES (?, 'on')", [SETTING_KEYS.CROSS_PROCESS_SYNC]);
+    _setDbForTesting(db);
+    expect(isCrossProcessSyncEnabled()).toBe(true);
+  });
+
+  it("notifyMemoryAdded returns false when the flag is off", () => {
+    _setDbForTesting(seedDb());
+    expect(notifyMemoryAdded({ id: 1 })).toBe(false);
+  });
+
+  it("notifyMemoryAdded returns false when flag on but honker unavailable", () => {
+    const db = seedDb();
+    db.run("INSERT INTO settings(key,value) VALUES (?, 'on')", [SETTING_KEYS.CROSS_PROCESS_SYNC]);
+    _setDbForTesting(db);
+    expect(notifyMemoryAdded({ id: 1, project_scope: "demo" })).toBe(false);
+  });
+
+  it("startCrossProcessSync is inert when flag off, never firing the callback", async () => {
+    _setDbForTesting(seedDb());
+    let calls = 0;
+    const h = startCrossProcessSync(() => { calls++; });
+    expect(h.running).toBe(false);
+    await expect(h.stop()).resolves.toBeUndefined();
+    expect(calls).toBe(0);
+  });
+
+  it("startCrossProcessSync is inert when flag on but honker unavailable", async () => {
+    const db = seedDb();
+    db.run("INSERT INTO settings(key,value) VALUES (?, 'on')", [SETTING_KEYS.CROSS_PROCESS_SYNC]);
+    _setDbForTesting(db);
+    const h = startCrossProcessSync(() => {});
+    expect(h.running).toBe(false);
+    await expect(h.stop()).resolves.toBeUndefined();
+  });
+});