agent-mockingbird 0.0.1

package/apps/server/src/cli/agent-mockingbird.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { testing } from "./agent-mockingbird.mjs";
+
+describe("agent-mockingbird CLI onboarding diagnostics", () => {
+  test("builds actionable diagnostics when runtime model discovery is empty", () => {
+    const diagnostics = testing.buildEmptyModelDiscoveryDiagnostics({
+      workspaceDir: "/var/home/agent-mockingbird/.agent-mockingbird/workspace",
+      currentModel: "opencode/big-pickle",
+      authAttempts: 1,
+      authSuccess: true,
+      authRefresh: {
+        ok: true,
+        message: "opencode.service restarted to refresh provider credentials.",
+      },
+    });
+
+    expect(diagnostics[0]).toBe("No runtime models were discovered after provider setup.");
+    expect(diagnostics).toContain("Current runtime default: opencode/big-pickle");
+    expect(diagnostics).toContain("Provider auth attempts: 1 (at least one succeeded)");
+    expect(diagnostics).toContain("OpenCode auth refresh: opencode.service restarted to refresh provider credentials.");
+    expect(diagnostics).toContain(
+      "- curl -sS http://127.0.0.1:3001/api/opencode/models",
+    );
+  });
+});
+
+describe("agent-mockingbird CLI opencode version resolution", () => {
+  test("prefers explicit env version", () => {
+    const version = testing.readOpenCodePackageVersion({
+      env: { AGENT_MOCKINGBIRD_OPENCODE_VERSION: "1.2.99" },
+      argv: ["bun", "/tmp/fake-bin/agent-mockingbird"],
+      moduleDir: "/tmp/fake-module",
+    });
+
+    expect(version).toBe("1.2.99");
+  });
+
+  test("resolves version from installed package root", () => {
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "agent-mockingbird-cli-test-"));
+    const appDir = path.join(tempRoot, "npm", "lib", "node_modules", "@waffleophagus", "agent-mockingbird");
+    fs.mkdirSync(appDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(appDir, "opencode.lock.json"),
+      JSON.stringify({ packageVersion: "1.2.27" }),
+      "utf8",
+    );
+
+    try {
+      const version = testing.readOpenCodePackageVersion({
+        paths: {
+          agentMockingbirdAppDirGlobal: appDir,
+          agentMockingbirdAppDirLocal: path.join(tempRoot, "missing-local"),
+        },
+        env: {},
+        argv: ["bun", "/tmp/fake-bin/agent-mockingbird"],
+        moduleDir: "/tmp/fake-module",
+      });
+
+      expect(version).toBe("1.2.27");
+    } finally {
+      fs.rmSync(tempRoot, { recursive: true, force: true });
+    }
+  });
+});

package/apps/server/src/cli/runtime-assets.mjs

@@ -0,0 +1,269 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+const STATE_VERSION = 1;
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function normalizeRelativePath(filePath) {
+  return filePath.split(path.sep).join("/");
+}
+
+function listRelativeFiles(rootDir, currentDir = rootDir) {
+  const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const absolutePath = path.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listRelativeFiles(rootDir, absolutePath));
+      continue;
+    }
+    if (!entry.isFile()) {
+      continue;
+    }
+    files.push(normalizeRelativePath(path.relative(rootDir, absolutePath)));
+  }
+  files.sort((left, right) => left.localeCompare(right));
+  return files;
+}
+
+function hashFile(filePath) {
+  const data = fs.readFileSync(filePath);
+  return crypto.createHash("sha256").update(data).digest("hex");
+}
+
+function safeReadState(stateFilePath) {
+  if (!fs.existsSync(stateFilePath)) {
+    return { version: STATE_VERSION, files: {} };
+  }
+  try {
+    const parsed = JSON.parse(fs.readFileSync(stateFilePath, "utf8"));
+    const files = typeof parsed?.files === "object" && parsed.files ? parsed.files : {};
+    return {
+      version: Number.isInteger(parsed?.version) ? parsed.version : STATE_VERSION,
+      files,
+    };
+  } catch {
+    return { version: STATE_VERSION, files: {} };
+  }
+}
+
+function writeState(stateFilePath, state) {
+  ensureDir(path.dirname(stateFilePath));
+  fs.writeFileSync(stateFilePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+}
+
+function timestampForBackup(now = new Date()) {
+  const year = String(now.getUTCFullYear());
+  const month = String(now.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(now.getUTCDate()).padStart(2, "0");
+  const hours = String(now.getUTCHours()).padStart(2, "0");
+  const minutes = String(now.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(now.getUTCSeconds()).padStart(2, "0");
+  return `${year}${month}${day}-${hours}${minutes}${seconds}`;
+}
+
+function makeBackupPath(targetFilePath) {
+  const stamp = timestampForBackup();
+  let candidate = `${targetFilePath}.backup-${stamp}`;
+  let suffix = 1;
+  while (fs.existsSync(candidate)) {
+    candidate = `${targetFilePath}.backup-${stamp}-${suffix}`;
+    suffix += 1;
+  }
+  return candidate;
+}
+
+function readDecision(value) {
+  if (value === "keep-local" || value === "use-packaged") {
+    return value;
+  }
+  return "use-packaged";
+}
+
+export async function syncRuntimeWorkspaceAssets(input) {
+  const mode = input?.mode === "update" ? "update" : "install";
+  const sourceWorkspaceDir = path.resolve(String(input?.sourceWorkspaceDir ?? ""));
+  const targetWorkspaceDir = path.resolve(String(input?.targetWorkspaceDir ?? ""));
+  const stateFilePath = path.resolve(String(input?.stateFilePath ?? ""));
+
+  if (!sourceWorkspaceDir || !fs.existsSync(sourceWorkspaceDir)) {
+    throw new Error(`runtime asset source directory missing: ${sourceWorkspaceDir}`);
+  }
+  if (!targetWorkspaceDir) {
+    throw new Error("runtime asset target directory is required");
+  }
+  if (!stateFilePath) {
+    throw new Error("runtime asset state file path is required");
+  }
+
+  const interactive = Boolean(input?.interactive);
+  const logger = typeof input?.logger === "function" ? input.logger : null;
+  const onConflict = typeof input?.onConflict === "function" ? input.onConflict : null;
+
+  ensureDir(targetWorkspaceDir);
+  const previousState = safeReadState(stateFilePath);
+  const relativeFiles = listRelativeFiles(sourceWorkspaceDir);
+  const nowIso = new Date().toISOString();
+
+  const summary = {
+    mode,
+    source: sourceWorkspaceDir,
+    target: targetWorkspaceDir,
+    stateFile: stateFilePath,
+    scannedFiles: relativeFiles.length,
+    copied: 0,
+    overwritten: 0,
+    unchanged: 0,
+    keptLocal: 0,
+    conflicts: 0,
+    backupsCreated: 0,
+    removed: 0,
+    conflictResolutions: [],
+    backups: [],
+  };
+
+  const nextState = {
+    version: STATE_VERSION,
+    updatedAt: nowIso,
+    files: {},
+  };
+
+  for (const relativePath of relativeFiles) {
+    const sourceFilePath = path.join(sourceWorkspaceDir, relativePath);
+    const targetFilePath = path.join(targetWorkspaceDir, relativePath);
+    const sourceHash = hashFile(sourceFilePath);
+    const previous = previousState.files?.[relativePath] ?? null;
+
+    const targetExists = fs.existsSync(targetFilePath);
+    const targetHash = targetExists ? hashFile(targetFilePath) : null;
+    const previousSourceHash = typeof previous?.sourceHash === "string" ? previous.sourceHash : null;
+    const previousAppliedHash = typeof previous?.appliedHash === "string" ? previous.appliedHash : null;
+
+    const packageChanged = previousSourceHash === null || previousSourceHash !== sourceHash;
+    const localChanged = previousAppliedHash === null ? false : targetHash !== previousAppliedHash;
+
+    let appliedHash = targetHash;
+
+    if (!targetExists) {
+      ensureDir(path.dirname(targetFilePath));
+      fs.copyFileSync(sourceFilePath, targetFilePath);
+      summary.copied += 1;
+      appliedHash = hashFile(targetFilePath);
+      if (logger) logger(`runtime-assets: copied ${relativePath}`);
+    } else if (mode === "install") {
+      fs.copyFileSync(sourceFilePath, targetFilePath);
+      summary.overwritten += 1;
+      appliedHash = hashFile(targetFilePath);
+      if (logger) logger(`runtime-assets: overwritten ${relativePath}`);
+    } else if (!packageChanged) {
+      summary.unchanged += 1;
+      if (logger) logger(`runtime-assets: unchanged ${relativePath}`);
+    } else if (!localChanged) {
+      fs.copyFileSync(sourceFilePath, targetFilePath);
+      summary.overwritten += 1;
+      appliedHash = hashFile(targetFilePath);
+      if (logger) logger(`runtime-assets: updated ${relativePath}`);
+    } else {
+      summary.conflicts += 1;
+      const conflictInput = {
+        relativePath,
+        targetFilePath,
+        sourceFilePath,
+      };
+
+      const decision =
+        interactive && onConflict ? readDecision(await onConflict(conflictInput)) : "use-packaged";
+
+      if (decision === "keep-local") {
+        summary.keptLocal += 1;
+        summary.conflictResolutions.push({ path: relativePath, decision: "keep-local" });
+        if (logger) logger(`runtime-assets: kept local ${relativePath}`);
+      } else {
+        if (!interactive) {
+          const backupPath = makeBackupPath(targetFilePath);
+          fs.copyFileSync(targetFilePath, backupPath);
+          summary.backupsCreated += 1;
+          summary.backups.push({ path: relativePath, backupPath });
+          if (logger) logger(`runtime-assets: backup ${relativePath} -> ${backupPath}`);
+        }
+        fs.copyFileSync(sourceFilePath, targetFilePath);
+        summary.overwritten += 1;
+        appliedHash = hashFile(targetFilePath);
+        summary.conflictResolutions.push({ path: relativePath, decision: "use-packaged" });
+        if (logger) logger(`runtime-assets: replaced ${relativePath}`);
+      }
+    }
+
+    nextState.files[relativePath] = {
+      sourceHash,
+      appliedHash,
+      updatedAt: nowIso,
+    };
+  }
+
+  const removedPaths = Object.keys(previousState.files ?? {})
+    .filter(relativePath => !relativeFiles.includes(relativePath))
+    .sort((left, right) => left.localeCompare(right));
+
+  for (const relativePath of removedPaths) {
+    const previous = previousState.files?.[relativePath] ?? null;
+    const targetFilePath = path.join(targetWorkspaceDir, relativePath);
+    if (!fs.existsSync(targetFilePath)) {
+      if (logger) logger(`runtime-assets: already absent ${relativePath}`);
+      continue;
+    }
+
+    const targetHash = hashFile(targetFilePath);
+    const previousAppliedHash = typeof previous?.appliedHash === "string" ? previous.appliedHash : null;
+    const localChanged = previousAppliedHash === null ? true : targetHash !== previousAppliedHash;
+
+    if (!localChanged || mode === "install") {
+      fs.rmSync(targetFilePath, { force: true });
+      summary.removed += 1;
+      if (logger) logger(`runtime-assets: removed ${relativePath}`);
+      continue;
+    }
+
+    const conflictInput = {
+      relativePath,
+      targetFilePath,
+      sourceFilePath: null,
+      removed: true,
+    };
+
+    const decision =
+      interactive && onConflict ? readDecision(await onConflict(conflictInput)) : "use-packaged";
+
+    if (decision === "keep-local") {
+      summary.keptLocal += 1;
+      summary.conflictResolutions.push({ path: relativePath, decision: "keep-local" });
+      if (logger) logger(`runtime-assets: kept removed local file ${relativePath}`);
+      nextState.files[relativePath] = {
+        sourceHash: null,
+        appliedHash: targetHash,
+        updatedAt: nowIso,
+      };
+      continue;
+    }
+
+    if (!interactive) {
+      const backupPath = makeBackupPath(targetFilePath);
+      fs.copyFileSync(targetFilePath, backupPath);
+      summary.backupsCreated += 1;
+      summary.backups.push({ path: relativePath, backupPath });
+      if (logger) logger(`runtime-assets: backup ${relativePath} -> ${backupPath}`);
+    }
+
+    fs.rmSync(targetFilePath, { force: true });
+    summary.removed += 1;
+    summary.conflictResolutions.push({ path: relativePath, decision: "use-packaged" });
+    if (logger) logger(`runtime-assets: removed stale ${relativePath}`);
+  }
+
+  writeState(stateFilePath, nextState);
+  return summary;
+}

package/apps/server/src/cli/runtime-assets.test.ts

@@ -0,0 +1,52 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { syncRuntimeWorkspaceAssets } from "./runtime-assets.mjs";
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+function makeTempDir() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "agent-mockingbird-runtime-assets-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("syncRuntimeWorkspaceAssets", () => {
+  test("removes previously managed files that no longer exist in the source bundle", async () => {
+    const sourceDir = makeTempDir();
+    const targetDir = makeTempDir();
+    const stateFilePath = path.join(makeTempDir(), "runtime-assets-state.json");
+
+    fs.mkdirSync(path.join(sourceDir, "plugins"), { recursive: true });
+    fs.mkdirSync(path.join(targetDir, "plugins"), { recursive: true });
+    fs.writeFileSync(path.join(sourceDir, "plugins", "memory_search.ts"), "export default 1\n");
+
+    await syncRuntimeWorkspaceAssets({
+      sourceWorkspaceDir: sourceDir,
+      targetWorkspaceDir: targetDir,
+      stateFilePath,
+      mode: "install",
+    });
+
+    expect(fs.existsSync(path.join(targetDir, "plugins", "memory_search.ts"))).toBe(true);
+
+    fs.rmSync(path.join(sourceDir, "plugins", "memory_search.ts"));
+    const result = await syncRuntimeWorkspaceAssets({
+      sourceWorkspaceDir: sourceDir,
+      targetWorkspaceDir: targetDir,
+      stateFilePath,
+      mode: "update",
+    });
+
+    expect(result.removed).toBe(1);
+    expect(fs.existsSync(path.join(targetDir, "plugins", "memory_search.ts"))).toBe(false);
+  });
+});

package/apps/server/src/cli/runtime-layout.mjs

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+function workspaceFingerprint(workspaceDir) {
+  return createHash("sha256").update(path.resolve(workspaceDir)).digest("hex").slice(0, 16);
+}
+
+function resolveManagedOpencodeConfigDir({
+  rootDir,
+  dataDir = path.join(rootDir, "data"),
+  workspaceDir = path.join(rootDir, "workspace"),
+  explicitConfigDir = process.env.OPENCODE_CONFIG_DIR,
+}) {
+  if (typeof explicitConfigDir === "string" && explicitConfigDir.trim()) {
+    return path.resolve(explicitConfigDir.trim());
+  }
+  return path.join(dataDir, "opencode-config", workspaceFingerprint(workspaceDir));
+}
+
+export function opencodeEnvironment(paths, baseEnv = process.env) {
+  return {
+    ...baseEnv,
+    OPENCODE_CONFIG_DIR: paths.opencodeConfigDir,
+    OPENCODE_DISABLE_PROJECT_CONFIG: "1",
+  };
+}
+
+export function pathsFor({ rootDir, scope, userUnitDir }) {
+  const normalizedScope = scope.replace(/^@/, "");
+  const npmPrefix = path.join(rootDir, "npm");
+  const workspaceDir = path.join(rootDir, "workspace");
+  const dataDir = path.join(rootDir, "data");
+  const localBinDir = path.join(process.env.HOME || "", ".local", "bin");
+
+  return {
+    rootDir,
+    npmPrefix,
+    localBinDir,
+    agentMockingbirdShimPath: path.join(localBinDir, "agent-mockingbird"),
+    opencodeShimPath: path.join(localBinDir, "opencode"),
+    dataDir,
+    workspaceDir,
+    opencodeConfigDir: resolveManagedOpencodeConfigDir({ rootDir, dataDir, workspaceDir }),
+    logsDir: path.join(rootDir, "logs"),
+    etcDir: path.join(rootDir, "etc"),
+    npmrcPath: path.join(rootDir, "etc", "npmrc"),
+    agentMockingbirdAppDirGlobal: path.join(npmPrefix, "lib", "node_modules", `@${normalizedScope}`, "agent-mockingbird"),
+    agentMockingbirdAppDirLocal: path.join(npmPrefix, "node_modules", `@${normalizedScope}`, "agent-mockingbird"),
+    agentMockingbirdBinGlobal: path.join(npmPrefix, "bin", "agent-mockingbird"),
+    agentMockingbirdBinLocal: path.join(npmPrefix, "node_modules", ".bin", "agent-mockingbird"),
+    opencodeBinGlobal: path.join(npmPrefix, "bin", "opencode"),
+    opencodeBinLocal: path.join(npmPrefix, "node_modules", ".bin", "opencode"),
+    bunBinManagedGlobal: path.join(npmPrefix, "bin", "bun"),
+    bunBinManagedLocal: path.join(npmPrefix, "node_modules", ".bin", "bun"),
+    bunBinTools: path.join(rootDir, "tools", "bun", "bin", "bun"),
+    opencodeUnitPath: path.join(userUnitDir, "opencode.service"),
+    agentMockingbirdUnitPath: path.join(userUnitDir, "agent-mockingbird.service"),
+  };
+}
+
+export function prepareRuntimeAssetSources(agentMockingbirdAppDir) {
+  const workspaceSourceDir = path.join(agentMockingbirdAppDir, "runtime-assets", "workspace");
+  const opencodeConfigSourceDir = path.join(agentMockingbirdAppDir, "runtime-assets", "opencode-config");
+  if (!fs.existsSync(workspaceSourceDir) || !fs.existsSync(opencodeConfigSourceDir)) {
+    throw new Error(
+      `runtime assets missing in package: expected ${workspaceSourceDir} and ${opencodeConfigSourceDir}`,
+    );
+  }
+  return {
+    workspaceSourceDir,
+    opencodeConfigSourceDir,
+  };
+}

package/apps/server/src/cli/standaloneBuild.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from "bun:test";
+import path from "node:path";
+
+import { createStandaloneBuildOptions, STANDALONE_ENTRYPOINTS_RELATIVE } from "./standaloneBuild";
+
+test("standalone build config uses the main server entrypoint", () => {
+  const repoRoot = path.resolve(import.meta.dir, "../../../..");
+  const outfile = path.join(repoRoot, "dist", "agent-mockingbird");
+
+  const options = createStandaloneBuildOptions(repoRoot, outfile);
+  expect(options.compile).toEqual({ outfile });
+  expect(options.sourcemap).toBe("linked");
+  expect(options.minify).toBe(true);
+
+  const entrypoints = options.entrypoints as string[];
+  for (const relativeEntrypoint of STANDALONE_ENTRYPOINTS_RELATIVE) {
+    expect(entrypoints).toContain(path.join(repoRoot, relativeEntrypoint));
+  }
+});

package/apps/server/src/cli/standaloneBuild.ts

@@ -0,0 +1,19 @@
+import path from "node:path";
+
+export const STANDALONE_ENTRYPOINTS_RELATIVE = ["apps/server/src/index.ts"] as const;
+
+function resolveStandaloneEntrypoints(repoRoot: string): string[] {
+  return STANDALONE_ENTRYPOINTS_RELATIVE.map(entrypoint => path.join(repoRoot, entrypoint));
+}
+
+export function createStandaloneBuildOptions(repoRoot: string, outfile: string): Bun.BuildConfig {
+  return {
+    root: repoRoot,
+    entrypoints: resolveStandaloneEntrypoints(repoRoot),
+    compile: {
+      outfile,
+    },
+    minify: true,
+    sourcemap: "linked",
+  };
+}

package/apps/server/src/cli/standaloneCronBinary.test.ts

@@ -0,0 +1,187 @@
+import { expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+
+function allocatePort(): Promise<number> {
+  return new Promise((resolvePort, rejectPort) => {
+    const server = net.createServer();
+    server.once("error", rejectPort);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        rejectPort(new Error("Failed to allocate port"));
+        return;
+      }
+      const { port } = address;
+      server.close(error => {
+        if (error) {
+          rejectPort(error);
+          return;
+        }
+        resolvePort(port);
+      });
+    });
+  });
+}
+
+async function waitForJson(url: string, timeoutMs: number) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError: unknown = null;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) {
+        return response.json();
+      }
+      lastError = new Error(`Unexpected status ${response.status}`);
+    } catch (error) {
+      lastError = error;
+    }
+    await Bun.sleep(250);
+  }
+  throw lastError instanceof Error ? lastError : new Error(`Timed out waiting for ${url}`);
+}
+
+async function waitForInstance(baseUrl: string, jobId: string, timeoutMs: number) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const response = await fetch(`${baseUrl}/api/mockingbird/cron/instances?jobId=${encodeURIComponent(jobId)}&limit=1`);
+    const payload = (await response.json()) as {
+      instances?: Array<{ state?: string; error?: { message?: string } | null }>;
+    };
+    const instance = payload.instances?.[0];
+    if (instance?.state === "completed" || instance?.state === "failed" || instance?.state === "dead") {
+      return instance;
+    }
+    await Bun.sleep(250);
+  }
+  throw new Error(`Timed out waiting for cron instance ${jobId}`);
+}
+
+test(
+  "compiled binary runs module-backed background cron jobs without worker ModuleNotFound",
+  async () => {
+    const repoRoot = path.resolve(import.meta.dir, "../../../..");
+    const build = Bun.spawnSync({
+      cmd: ["bun", "run", "build:bin"],
+      cwd: repoRoot,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: process.env,
+    });
+    expect(build.exitCode).toBe(0);
+
+    const sidecarPort = await allocatePort();
+    const apiPort = await allocatePort();
+    const tempRoot = mkdtempSync(path.join(os.tmpdir(), "agent-mockingbird-bin-cron-"));
+    const workspaceDir = path.join(tempRoot, "workspace");
+    const configPath = path.join(tempRoot, "config.json");
+    const dbPath = path.join(tempRoot, "agent-mockingbird.db");
+    mkdirSync(path.join(workspaceDir, "cron"), { recursive: true });
+
+    const config = JSON.parse(readFileSync(path.join(repoRoot, "agent-mockingbird.config.example.json"), "utf8")) as {
+      workspace: { pinnedDirectory: string };
+      runtime: {
+        opencode: { baseUrl: string; directory: string };
+        memory: { enabled: boolean; workspaceDir: string };
+      };
+    };
+    config.workspace.pinnedDirectory = workspaceDir;
+    config.runtime.opencode.baseUrl = `http://127.0.0.1:${sidecarPort}`;
+    config.runtime.opencode.directory = workspaceDir;
+    config.runtime.memory.enabled = false;
+    config.runtime.memory.workspaceDir = workspaceDir;
+    writeFileSync(configPath, JSON.stringify(config, null, 2), "utf8");
+    writeFileSync(
+      path.join(workspaceDir, "cron", "compiled-background.ts"),
+      [
+        "export default async function run(ctx) {",
+        "  return { status: 'ok', summary: `compiled check ${ctx.payload.symbol}` };",
+        "}",
+      ].join("\n"),
+      "utf8",
+    );
+
+    let sessionCount = 0;
+    const sidecar = Bun.serve({
+      hostname: "127.0.0.1",
+      port: sidecarPort,
+      fetch(req) {
+        const url = new URL(req.url);
+        if (url.pathname === "/config" && req.method === "GET") {
+          return Response.json({ data: {} });
+        }
+        if (url.pathname === "/config" && req.method === "PUT") {
+          return Response.json({ data: {} });
+        }
+        if (url.pathname === "/session" && req.method === "POST") {
+          sessionCount += 1;
+          return Response.json({
+            data: {
+              id: `sess-${sessionCount}`,
+              title: sessionCount === 1 ? "main" : "Cron background",
+            },
+          });
+        }
+        return new Response("Not found", { status: 404 });
+      },
+    });
+
+    const binary = Bun.spawn({
+      cmd: [path.join(repoRoot, "dist", "agent-mockingbird")],
+      cwd: repoRoot,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        NODE_ENV: "production",
+        PORT: String(apiPort),
+        AGENT_MOCKINGBIRD_DB_PATH: dbPath,
+        AGENT_MOCKINGBIRD_CONFIG_PATH: configPath,
+        AGENT_MOCKINGBIRD_MEMORY_ENABLED: "false",
+        AGENT_MOCKINGBIRD_MEMORY_EMBED_PROVIDER: "none",
+      },
+    });
+
+    try {
+      await waitForJson(`http://127.0.0.1:${apiPort}/api/mockingbird/cron/health`, 15_000);
+
+      const createResponse = await fetch(`http://127.0.0.1:${apiPort}/api/mockingbird/cron/jobs`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          id: "compiled-background-check",
+          name: "Compiled Background Check",
+          enabled: true,
+          scheduleKind: "every",
+          everyMs: 60_000,
+          runMode: "background",
+          conditionModulePath: "cron/compiled-background.ts",
+          conditionDescription: "Compiled binary module smoke test",
+          payload: { symbol: "AAPL" },
+        }),
+      });
+      expect(createResponse.status).toBe(201);
+
+      const runResponse = await fetch(`http://127.0.0.1:${apiPort}/api/mockingbird/cron/jobs/compiled-background-check/run`, {
+        method: "POST",
+      });
+      expect(runResponse.status).toBe(202);
+
+      const instance = await waitForInstance(`http://127.0.0.1:${apiPort}`, "compiled-background-check", 15_000);
+      if (instance?.state !== "completed") {
+        throw new Error(`Cron instance failed: ${JSON.stringify(instance)}`);
+      }
+      expect(instance.error ?? null).toBeNull();
+    } finally {
+      binary.kill();
+      await binary.exited;
+      sidecar.stop(true);
+      rmSync(tempRoot, { recursive: true, force: true });
+    }
+  },
+  60_000,
+);