bopodev-api 0.1.34 → 0.1.35

package/src/services/plugin-worker-host.ts

@@ -0,0 +1,167 @@
+import { randomUUID } from "node:crypto";
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type { PluginManifest } from "bopodev-contracts";
+import { PluginManifestV2Schema } from "bopodev-contracts";
+import { z } from "zod";
+import {
+  PluginRpcLineBuffer,
+  createPluginRpcRequest,
+  encodePluginRpcMessage,
+  type PluginRpcResponse
+} from "./plugin-rpc";
+
+type WorkerEntry = {
+  process: ChildProcessWithoutNullStreams;
+  parser: PluginRpcLineBuffer;
+  pending: Map<string, { resolve: (value: unknown) => void; reject: (error: Error) => void; timeout: NodeJS.Timeout }>;
+};
+
+type PluginWorkerHostOptions = {
+  maxPayloadBytes: number;
+  requestTimeoutMs: number;
+  disabled: boolean;
+};
+type PluginManifestV2 = z.infer<typeof PluginManifestV2Schema>;
+
+function parseBoolEnv(value: string | undefined): boolean {
+  return value === "1" || value === "true";
+}
+
+/**
+ * Older demos used `dist/worker.js`, which is often missing (and gitignored). Prefer `worker/worker.js` in the same plugin directory.
+ */
+function resolveWorkerExecutable(manifest: PluginManifestV2): string {
+  const workerPath = manifest.entrypoints.worker;
+  if (existsSync(workerPath)) {
+    return workerPath;
+  }
+  const pluginRoot = dirname(dirname(workerPath));
+  const fallback = join(pluginRoot, "worker", "worker.js");
+  if (existsSync(fallback)) {
+    return fallback;
+  }
+  return workerPath;
+}
+
+export class PluginWorkerHost {
+  private readonly workers = new Map<string, WorkerEntry>();
+  private readonly options: PluginWorkerHostOptions;
+
+  constructor() {
+    this.options = {
+      maxPayloadBytes: Number(process.env.BOPO_PLUGIN_RPC_MAX_PAYLOAD_BYTES ?? 256_000),
+      requestTimeoutMs: Number(process.env.BOPO_PLUGIN_WORKER_REQUEST_TIMEOUT_MS ?? 8_000),
+      disabled: parseBoolEnv(process.env.BOPO_PLUGIN_WORKERS_DISABLED)
+    };
+  }
+
+  isEnabled() {
+    return !this.options.disabled;
+  }
+
+  async shutdown() {
+    for (const [pluginId, entry] of this.workers.entries()) {
+      for (const pending of entry.pending.values()) {
+        clearTimeout(pending.timeout);
+        pending.reject(new Error(`plugin worker '${pluginId}' was shut down`));
+      }
+      entry.pending.clear();
+      entry.process.kill("SIGTERM");
+    }
+    this.workers.clear();
+  }
+
+  async invoke(
+    manifest: PluginManifest,
+    input: {
+      method: "plugin.health" | "plugin.action" | "plugin.data" | "plugin.hook" | "plugin.job" | "plugin.webhook";
+      params: Record<string, unknown>;
+    }
+  ) {
+    if (!this.isEnabled()) {
+      throw new Error("plugin workers disabled by BOPO_PLUGIN_WORKERS_DISABLED");
+    }
+    const v2 = PluginManifestV2Schema.safeParse(manifest);
+    if (!v2.success) {
+      throw new Error(`plugin '${manifest.id}' does not declare apiVersion '2'`);
+    }
+    const entry = await this.ensureWorker(v2.data);
+    const requestId = randomUUID();
+    const request = createPluginRpcRequest(input.method, input.params, requestId);
+    const encoded = encodePluginRpcMessage(request);
+    if (Buffer.byteLength(encoded, "utf8") > this.options.maxPayloadBytes) {
+      throw new Error(`plugin rpc payload exceeds ${this.options.maxPayloadBytes} bytes`);
+    }
+    return await new Promise<unknown>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        entry.pending.delete(requestId);
+        reject(new Error(`plugin rpc request timed out for '${manifest.id}' method '${input.method}'`));
+      }, this.options.requestTimeoutMs);
+      entry.pending.set(requestId, { resolve, reject, timeout });
+      entry.process.stdin.write(encoded);
+    });
+  }
+
+  private async ensureWorker(manifest: PluginManifestV2) {
+    const existing = this.workers.get(manifest.id);
+    if (existing && !existing.process.killed) {
+      return existing;
+    }
+    const command = process.env.BOPO_PLUGIN_WORKER_COMMAND ?? "node";
+    const workerScript = resolveWorkerExecutable(manifest);
+    const child = spawn(command, [workerScript], {
+      stdio: "pipe",
+      env: process.env
+    });
+    const parser = new PluginRpcLineBuffer();
+    const pending = new Map<
+      string,
+      { resolve: (value: unknown) => void; reject: (error: Error) => void; timeout: NodeJS.Timeout }
+    >();
+    parser.on("message", (message: PluginRpcResponse) => {
+      const waiter = pending.get(message.id);
+      if (!waiter) {
+        return;
+      }
+      clearTimeout(waiter.timeout);
+      pending.delete(message.id);
+      if ("error" in message) {
+        waiter.reject(new Error(`${message.error.message} (${message.error.code})`));
+        return;
+      }
+      waiter.resolve(message.result);
+    });
+    child.stdout.on("data", (chunk) => {
+      parser.push(String(chunk));
+    });
+    child.stderr.on("data", (chunk) => {
+      // eslint-disable-next-line no-console
+      console.warn(`[plugins] worker '${manifest.id}' stderr: ${String(chunk).trim()}`);
+    });
+    child.on("exit", (code, signal) => {
+      if (code !== 0 && code !== null) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          `[plugins] worker '${manifest.id}' exited with code ${code}${signal ? ` signal ${signal}` : ""} (script: ${workerScript})`
+        );
+      }
+      this.workers.delete(manifest.id);
+      for (const wait of pending.values()) {
+        clearTimeout(wait.timeout);
+        wait.reject(new Error(`plugin worker '${manifest.id}' exited`));
+      }
+      pending.clear();
+    });
+    child.on("error", (error) => {
+      // eslint-disable-next-line no-console
+      console.warn(`[plugins] worker '${manifest.id}' failed to spawn: ${String(error.message)}`);
+    });
+    const entry: WorkerEntry = { process: child, parser, pending };
+    this.workers.set(manifest.id, entry);
+    return entry;
+  }
+}
+
+export const pluginWorkerHost = new PluginWorkerHost();

package/src/services/starter-pack-registry.ts

@@ -0,0 +1,68 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { listBuiltinStarterTemplates } from "./template-catalog";
+
+const PACK_DIR = join(dirname(fileURLToPath(import.meta.url)), "../assets/starter-packs");
+
+export type StarterPackDefinition = {
+  id: string;
+  label: string;
+  description: string;
+  filename: string;
+};
+
+/** Optional extra packs as zips only (id must not match a builtin template slug). */
+export const STARTER_PACK_DEFINITIONS: StarterPackDefinition[] = [
+  {
+    id: "product-delivery-trio",
+    label: "Product Delivery Trio",
+    description:
+      "CEO, Product, and Engineering with strategy, delivery, and quality projects; weekly leadership sync and release hygiene; skills for triage and RCA.",
+    filename: "product-delivery-trio.zip"
+  },
+  {
+    id: "revenue-gtm-b2b",
+    label: "Revenue GTM (B2B)",
+    description:
+      "CEO, Head of GTM, and Pipeline Owner with pipeline, deals, and customer success projects; revenue review and pipeline hygiene loops; ICP and discovery skills.",
+    filename: "revenue-gtm-b2b.zip"
+  },
+  {
+    id: "devrel-growth",
+    label: "DevRel & Growth",
+    description:
+      "CEO, DevRel Lead, and Technical Content Producer with docs, community, and partners projects; content planning and community health loops.",
+    filename: "devrel-growth.zip"
+  },
+  {
+    id: "customer-support-excellence",
+    label: "Customer Support Excellence",
+    description:
+      "CEO, Support Lead, and Support Specialist with queue, knowledge base, and quality projects; daily standup and KB gap sweep loops.",
+    filename: "customer-support-excellence.zip"
+  }
+];
+
+export function listStarterPackMetadata(): Array<{ id: string; label: string; description: string }> {
+  const fromTemplates = listBuiltinStarterTemplates();
+  const builtinIds = new Set(fromTemplates.map((t) => t.id));
+  const fromZips = STARTER_PACK_DEFINITIONS.filter((p) => !builtinIds.has(p.id)).map(({ id, label, description }) => ({
+    id,
+    label,
+    description
+  }));
+  return [...fromTemplates, ...fromZips];
+}
+
+export function resolveStarterPackDefinition(id: string): StarterPackDefinition | null {
+  return STARTER_PACK_DEFINITIONS.find((p) => p.id === id) ?? null;
+}
+
+export async function readStarterPackZipBuffer(id: string): Promise<Buffer> {
+  const def = resolveStarterPackDefinition(id);
+  if (!def) {
+    throw new Error(`Unknown starter pack id: ${id}`);
+  }
+  return readFile(join(PACK_DIR, def.filename));
+}

package/src/services/template-apply-service.ts

@@ -69,6 +69,8 @@ export async function applyTemplateManifest(
       heartbeatCron: agent.heartbeatCron,
       monthlyBudgetUsd: agent.monthlyBudgetUsd.toFixed(4),
       canHireAgents: agent.canHireAgents,
+      canAssignAgents: agent.canAssignAgents,
+      canCreateIssues: agent.canCreateIssues,
       runtimeCommand: agent.runtimeConfig?.runtimeCommand,
       runtimeArgsJson,
       runtimeCwd: agent.runtimeConfig?.runtimeCwd,
@@ -150,7 +152,7 @@ export async function applyTemplateManifest(
     if (loop) {
       await addWorkLoopTrigger(db, {
         companyId: input.companyId,
-        workLoopId: loop.id,
+        routineId: loop.id,
         cronExpression: job.cron
       });
     }

package/src/services/template-catalog.ts

@@ -89,6 +89,8 @@ const builtinTemplateDefinitions: BuiltinTemplateDefinition[] = [
           heartbeatCron: "*/15 * * * *",
           monthlyBudgetUsd: 150,
           canHireAgents: true,
+          canAssignAgents: true,
+          canCreateIssues: true,
           runtimeConfig: {
             bootstrapPrompt: [
               "You are Founder CEO for {{brandName}}.",
@@ -139,6 +141,8 @@ const builtinTemplateDefinitions: BuiltinTemplateDefinition[] = [
           heartbeatCron: "*/15 * * * *",
           monthlyBudgetUsd: 300,
           canHireAgents: false,
+          canAssignAgents: true,
+          canCreateIssues: true,
           runtimeConfig: {
             bootstrapPrompt: [
               "You are Founding Engineer for {{productName}}.",
@@ -176,6 +180,8 @@ const builtinTemplateDefinitions: BuiltinTemplateDefinition[] = [
           heartbeatCron: "*/30 * * * *",
           monthlyBudgetUsd: 200,
           canHireAgents: false,
+          canAssignAgents: true,
+          canCreateIssues: true,
           runtimeConfig: {
             bootstrapPrompt: [
               "You are Growth Operator for {{brandName}}.",
@@ -304,6 +310,8 @@ const builtinTemplateDefinitions: BuiltinTemplateDefinition[] = [
           heartbeatCron: "*/20 * * * *",
           monthlyBudgetUsd: 250,
           canHireAgents: true,
+          canAssignAgents: true,
+          canCreateIssues: true,
           runtimeConfig: {
             bootstrapPrompt: [
               "You are Head of Marketing for {{brandName}}.",
@@ -345,6 +353,8 @@ const builtinTemplateDefinitions: BuiltinTemplateDefinition[] = [
           heartbeatCron: "*/30 * * * *",
           monthlyBudgetUsd: 180,
           canHireAgents: false,
+          canAssignAgents: true,
+          canCreateIssues: true,
           runtimeConfig: {
             bootstrapPrompt: [
               "You are Content Strategist for {{brandName}}.",
@@ -378,6 +388,8 @@ const builtinTemplateDefinitions: BuiltinTemplateDefinition[] = [
           heartbeatCron: "*/30 * * * *",
           monthlyBudgetUsd: 220,
           canHireAgents: false,
+          canAssignAgents: true,
+          canCreateIssues: true,
           runtimeConfig: {
             bootstrapPrompt: [
               "You are Content Writer for {{brandName}}.",
@@ -412,6 +424,8 @@ const builtinTemplateDefinitions: BuiltinTemplateDefinition[] = [
           heartbeatCron: "*/30 * * * *",
           monthlyBudgetUsd: 180,
           canHireAgents: false,
+          canAssignAgents: true,
+          canCreateIssues: true,
           runtimeConfig: {
             bootstrapPrompt: [
               "You are Distribution Manager for {{brandName}}.",
@@ -483,6 +497,21 @@ const builtinTemplateDefinitions: BuiltinTemplateDefinition[] = [
   }
 ];
 
+export type BuiltinStarterTemplateDefinition = (typeof builtinTemplateDefinitions)[number];
+
+/** Built-in DB templates offered as “Start with” options when creating a company (full org, same as Templates UI). */
+export function listBuiltinStarterTemplates(): Array<{ id: string; label: string; description: string }> {
+  return builtinTemplateDefinitions.map((d) => ({
+    id: d.slug,
+    label: d.name,
+    description: d.description
+  }));
+}
+
+export function getBuiltinStarterTemplateBySlug(slug: string): BuiltinStarterTemplateDefinition | null {
+  return builtinTemplateDefinitions.find((d) => d.slug === slug) ?? null;
+}
+
 export async function ensureBuiltinTemplatesRegistered(db: BopoDb, companyIds: string[] = []) {
   for (const companyId of companyIds) {
     await ensureCompanyBuiltinTemplateDefaults(db, companyId);

package/src/services/work-loop-service/work-loop-service.ts

@@ -130,7 +130,7 @@ export async function addWorkLoopTrigger(
   db: BopoDb,
   input: {
     companyId: string;
-    workLoopId: string;
+    routineId: string;
     cronExpression: string;
     timezone?: string;
     label?: string | null;
@@ -148,7 +148,7 @@ export async function addWorkLoopTrigger(
   await db.insert(workLoopTriggers).values({
     id,
     companyId: input.companyId,
-    workLoopId: input.workLoopId,
+    routineId: input.routineId,
     kind: "schedule",
     label: input.label ?? null,
     enabled: input.enabled ?? true,
@@ -164,7 +164,7 @@ export async function addWorkLoopTriggerFromPreset(
   db: BopoDb,
   input: {
     companyId: string;
-    workLoopId: string;
+    routineId: string;
     preset: "daily" | "weekly";
     hour24: number;
     minute: number;
@@ -182,7 +182,7 @@ export async function addWorkLoopTriggerFromPreset(
       : weeklyCronAtLocalTime(input.dayOfWeek ?? 1, input.hour24, input.minute);
   return addWorkLoopTrigger(db, {
     companyId: input.companyId,
-    workLoopId: input.workLoopId,
+    routineId: input.routineId,
     cronExpression: cron,
     timezone: tz,
     label: input.label,
@@ -242,7 +242,7 @@ export async function updateWorkLoopTrigger(
 export async function deleteWorkLoopTrigger(
   db: BopoDb,
   companyId: string,
-  workLoopId: string,
+  routineId: string,
   triggerId: string
 ): Promise<boolean> {
   const [existing] = await db
@@ -252,7 +252,7 @@ export async function deleteWorkLoopTrigger(
       and(
         eq(workLoopTriggers.id, triggerId),
         eq(workLoopTriggers.companyId, companyId),
-        eq(workLoopTriggers.workLoopId, workLoopId)
+        eq(workLoopTriggers.routineId, routineId)
       )
     )
     .limit(1);
@@ -263,19 +263,19 @@ export async function deleteWorkLoopTrigger(
   return true;
 }
 
-export async function listWorkLoopTriggers(db: BopoDb, companyId: string, workLoopId: string) {
+export async function listWorkLoopTriggers(db: BopoDb, companyId: string, routineId: string) {
   return db
     .select()
     .from(workLoopTriggers)
-    .where(and(eq(workLoopTriggers.companyId, companyId), eq(workLoopTriggers.workLoopId, workLoopId)))
+    .where(and(eq(workLoopTriggers.companyId, companyId), eq(workLoopTriggers.routineId, routineId)))
     .orderBy(asc(workLoopTriggers.createdAt));
 }
 
-export async function listWorkLoopRuns(db: BopoDb, companyId: string, workLoopId: string, limit = 100) {
+export async function listWorkLoopRuns(db: BopoDb, companyId: string, routineId: string, limit = 100) {
   return db
     .select()
     .from(workLoopRuns)
-    .where(and(eq(workLoopRuns.companyId, companyId), eq(workLoopRuns.workLoopId, workLoopId)))
+    .where(and(eq(workLoopRuns.companyId, companyId), eq(workLoopRuns.routineId, routineId)))
     .orderBy(desc(workLoopRuns.triggeredAt), desc(workLoopRuns.id))
     .limit(Math.min(500, Math.max(1, limit)));
 }
@@ -287,7 +287,7 @@ async function findOpenIssueForLoop(db: BopoDb, companyId: string, loopId: strin
     .where(
       and(
         eq(issues.companyId, companyId),
-        eq(issues.loopId, loopId),
+        eq(issues.routineId, loopId),
         inArray(issues.status, [...OPEN_ISSUE_STATUSES])
       )
     )
@@ -348,7 +348,7 @@ export async function dispatchLoopRun(
         .where(
           and(
             eq(workLoopRuns.companyId, input.companyId),
-            eq(workLoopRuns.workLoopId, input.loopId),
+            eq(workLoopRuns.routineId, input.loopId),
             eq(workLoopRuns.source, input.source),
             eq(workLoopRuns.idempotencyKey, input.idempotencyKey),
             input.triggerId ? eq(workLoopRuns.triggerId, input.triggerId) : isNull(workLoopRuns.triggerId)
@@ -371,7 +371,7 @@ export async function dispatchLoopRun(
       await txDb.insert(workLoopRuns).values({
         id: runId,
         companyId: input.companyId,
-        workLoopId: loop.id,
+        routineId: loop.id,
         triggerId: input.triggerId,
         source: input.source,
         status: "failed",
@@ -390,7 +390,7 @@ export async function dispatchLoopRun(
     await txDb.insert(workLoopRuns).values({
       id: runId,
       companyId: input.companyId,
-      workLoopId: loop.id,
+      routineId: loop.id,
       triggerId: input.triggerId,
       source: input.source,
       status: "received",
@@ -410,7 +410,7 @@ export async function dispatchLoopRun(
         .set({
           status,
           linkedIssueId: activeIssue.id,
-          coalescedIntoRunId: activeIssue.loopRunId,
+          coalescedIntoRunId: activeIssue.routineRunId,
           completedAt: triggeredAt,
           updatedAt: new Date()
         })
@@ -465,8 +465,8 @@ export async function dispatchLoopRun(
       assigneeAgentId: loop.assigneeAgentId,
       labelsJson: JSON.stringify(["work-loop"]),
       tagsJson: "[]",
-      loopId: loop.id,
-      loopRunId: runId
+      routineId: loop.id,
+      routineRunId: runId
     });
     if (goalIds.length > 0) {
       await syncIssueGoals(txDb, {
@@ -567,7 +567,7 @@ export async function runLoopSweep(
       loop: workLoops
     })
     .from(workLoopTriggers)
-    .innerJoin(workLoops, eq(workLoopTriggers.workLoopId, workLoops.id))
+    .innerJoin(workLoops, eq(workLoopTriggers.routineId, workLoops.id))
     .where(
       and(
         eq(workLoopTriggers.companyId, companyId),

package/src/shutdown/graceful-shutdown.ts

@@ -19,8 +19,9 @@ export function attachGracefulShutdownHandlers(options: {
   realtimeHub: RealtimeHub;
   dbClient: unknown;
   scheduler?: { stop: () => Promise<void> };
+  pluginWorkers?: { shutdown: () => Promise<void> };
 }) {
-  const { server, realtimeHub, dbClient, scheduler } = options;
+  const { server, realtimeHub, dbClient, scheduler, pluginWorkers } = options;
   let shutdownInFlight: Promise<void> | null = null;
 
   function shutdown(signal: string) {
@@ -38,6 +39,7 @@ export function attachGracefulShutdownHandlers(options: {
       beginIssueCommentDispatchShutdown();
       await Promise.allSettled([
         scheduler?.stop() ?? Promise.resolve(),
+        pluginWorkers?.shutdown() ?? Promise.resolve(),
         new Promise<void>((resolve, reject) => {
           server.close((err) => {
             if (err) {

package/src/worker/scheduler.ts

@@ -4,6 +4,7 @@ import { runHeartbeatSweep } from "../services/heartbeat-service";
 import { runHeartbeatQueueSweep } from "../services/heartbeat-queue-service";
 import { runIssueCommentDispatchSweep } from "../services/comment-recipient-dispatch-service";
 import { runLoopSweep } from "../services/work-loop-service";
+import { runPluginJobSweep } from "../services/plugin-jobs-service";
 
 export type HeartbeatSchedulerHandle = {
   stop: () => Promise<void>;
@@ -14,15 +15,18 @@ export function createHeartbeatScheduler(db: BopoDb, companyId: string, realtime
   const queueIntervalMs = Number(process.env.BOPO_HEARTBEAT_QUEUE_SWEEP_MS ?? 2_000);
   const commentDispatchIntervalMs = Number(process.env.BOPO_COMMENT_DISPATCH_SWEEP_MS ?? 3_000);
   const loopSweepIntervalMs = Number(process.env.BOPO_LOOP_SWEEP_MS ?? 60_000);
+  const pluginJobSweepIntervalMs = Number(process.env.BOPO_PLUGIN_JOB_SWEEP_MS ?? 60_000);
   const loopSweepEnabled = (process.env.BOPO_LOOP_SWEEP_ENABLED ?? "1").trim() !== "0";
   let heartbeatRunning = false;
   let queueRunning = false;
   let commentDispatchRunning = false;
   let loopSweepRunning = false;
+  let pluginJobSweepRunning = false;
   let heartbeatPromise: Promise<unknown> | null = null;
   let queuePromise: Promise<unknown> | null = null;
   let commentDispatchPromise: Promise<unknown> | null = null;
   let loopSweepPromise: Promise<unknown> | null = null;
+  let pluginJobSweepPromise: Promise<unknown> | null = null;
   const heartbeatTimer = setInterval(() => {
     if (heartbeatRunning) {
       return;
@@ -85,6 +89,21 @@ export function createHeartbeatScheduler(db: BopoDb, companyId: string, realtime
           });
       }, loopSweepIntervalMs)
     : null;
+  const pluginJobTimer = setInterval(() => {
+    if (pluginJobSweepRunning) {
+      return;
+    }
+    pluginJobSweepRunning = true;
+    pluginJobSweepPromise = runPluginJobSweep(db, companyId)
+      .catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error("[scheduler] plugin job sweep failed", error);
+      })
+      .finally(() => {
+        pluginJobSweepRunning = false;
+        pluginJobSweepPromise = null;
+      });
+  }, pluginJobSweepIntervalMs);
   const stop = async () => {
     clearInterval(heartbeatTimer);
     clearInterval(queueTimer);
@@ -92,8 +111,9 @@ export function createHeartbeatScheduler(db: BopoDb, companyId: string, realtime
     if (loopSweepTimer) {
       clearInterval(loopSweepTimer);
     }
+    clearInterval(pluginJobTimer);
     await Promise.allSettled(
-      [heartbeatPromise, queuePromise, commentDispatchPromise, loopSweepPromise].filter(
+      [heartbeatPromise, queuePromise, commentDispatchPromise, loopSweepPromise, pluginJobSweepPromise].filter(
         (promise): promise is Promise<unknown> => promise !== null
       )
     );

package/src/services/company-export-service.ts

@@ -1,63 +0,0 @@
-import type { BopoDb } from "bopodev-db";
-import { getCompany, listAgents, listGoals, listIssues, listProjects } from "bopodev-db";
-
-function serializeValue(value: unknown): unknown {
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-    return serializeRow(value as Record<string, unknown>);
-  }
-  if (Array.isArray(value)) {
-    return value.map((entry) => serializeValue(entry));
-  }
-  return value;
-}
-
-function serializeRow<T extends Record<string, unknown>>(row: T): Record<string, unknown> {
-  const out: Record<string, unknown> = {};
-  for (const [key, val] of Object.entries(row)) {
-    out[key] = serializeValue(val);
-  }
-  return out;
-}
-
-/** Strip agent fields that commonly hold secrets or session state for shareable exports. */
-function scrubAgentRow(agent: Record<string, unknown>) {
-  const base = serializeRow(agent);
-  return {
-    ...base,
-    runtimeEnvJson: "{}",
-    bootstrapPrompt: null,
-    stateBlob: "{}",
-    runtimeCommand: null,
-    runtimeArgsJson: "[]"
-  };
-}
-
-/**
- * Portable company snapshot for backup, templates, or handoff (secrets and agent session state redacted).
- */
-export async function buildCompanyPortabilityExport(db: BopoDb, companyId: string) {
-  const company = await getCompany(db, companyId);
-  if (!company) {
-    return null;
-  }
-
-  const [projects, goals, issues, agents] = await Promise.all([
-    listProjects(db, companyId),
-    listGoals(db, companyId),
-    listIssues(db, companyId),
-    listAgents(db, companyId)
-  ]);
-
-  return {
-    exportedAt: new Date().toISOString(),
-    formatVersion: 1,
-    company: serializeRow(company as unknown as Record<string, unknown>),
-    projects: projects.map((p) => serializeRow(p as unknown as Record<string, unknown>)),
-    goals: goals.map((g) => serializeRow(g as unknown as Record<string, unknown>)),
-    issues: issues.map((issue) => serializeRow(issue as unknown as Record<string, unknown>)),
-    agents: agents.map((agent) => scrubAgentRow(agent as unknown as Record<string, unknown>))
-  };
-}