bopodev-api 0.1.10 → 0.1.12

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 BopoHQ contributors
+Copyright (c) 2026 BopoDev contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bopodev-api",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "license": "MIT",
   "type": "module",
   "files": [
@@ -16,9 +16,9 @@
     "nanoid": "^5.1.5",
     "ws": "^8.19.0",
     "zod": "^4.1.5",
-    "bopodev-agent-sdk": "0.1.10",
-    "bopodev-contracts": "0.1.10",
-    "bopodev-db": "0.1.10"
+    "bopodev-contracts": "0.1.12",
+    "bopodev-db": "0.1.12",
+    "bopodev-agent-sdk": "0.1.12"
   },
   "devDependencies": {
     "@types/cors": "^2.8.19",

package/src/lib/agent-config.ts

@@ -34,7 +34,13 @@ export type NormalizedRuntimeConfig = {
 };
 
 export function requiresRuntimeCwd(providerType: string) {
-  return providerType === "codex" || providerType === "claude_code" || providerType === "shell";
+  return (
+    providerType === "codex" ||
+    providerType === "claude_code" ||
+    providerType === "cursor" ||
+    providerType === "opencode" ||
+    providerType === "shell"
+  );
 }
 
 export function normalizeRuntimeConfig(input: {

package/src/middleware/request-actor.ts

@@ -1,4 +1,5 @@
 import type { NextFunction, Request, Response } from "express";
+import { RequestActorHeadersSchema } from "bopodev-contracts";
 import { sendError } from "../http";
 
 export type RequestActor = {
@@ -18,27 +19,36 @@ declare global {
   }
 }
 
-export function attachRequestActor(req: Request, _res: Response, next: NextFunction) {
-  const actorTypeHeader = req.header("x-actor-type")?.trim().toLowerCase();
-  const actorTypeFromHeader =
-    actorTypeHeader === "agent" || actorTypeHeader === "member" || actorTypeHeader === "board"
-      ? actorTypeHeader
-      : null;
-  const actorIdHeader = req.header("x-actor-id")?.trim();
-  const companyIdsHeader = req.header("x-actor-companies")?.trim();
-  const permissionsHeader = req.header("x-actor-permissions")?.trim();
-
-  const companyIds = parseCommaList(companyIdsHeader);
-  const permissions = parseCommaList(permissionsHeader) ?? [];
-  const hasActorHeaders = Boolean(actorTypeFromHeader || actorIdHeader || companyIds || permissions.length > 0);
+export function attachRequestActor(req: Request, res: Response, next: NextFunction) {
+  const actorHeadersResult = RequestActorHeadersSchema.safeParse({
+    "x-actor-type": req.header("x-actor-type")?.trim().toLowerCase(),
+    "x-actor-id": req.header("x-actor-id")?.trim(),
+    "x-actor-companies": req.header("x-actor-companies")?.trim(),
+    "x-actor-permissions": req.header("x-actor-permissions")?.trim()
+  });
+  if (!actorHeadersResult.success) {
+    return sendError(
+      res,
+      `Invalid actor headers: ${actorHeadersResult.error.issues
+        .map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`)
+        .join("; ")}`,
+      400
+    );
+  }
+  const actorHeaders = actorHeadersResult.data;
+  const companyIds = parseCommaList(actorHeaders["x-actor-companies"]);
+  const permissions = parseCommaList(actorHeaders["x-actor-permissions"]) ?? [];
+  const hasActorHeaders = Boolean(
+    actorHeaders["x-actor-type"] || actorHeaders["x-actor-id"] || companyIds || permissions.length > 0
+  );
   const allowLocalBoardFallback = process.env.NODE_ENV !== "production" && process.env.BOPO_ALLOW_LOCAL_BOARD_FALLBACK !== "0";
   const actorType = hasActorHeaders
-    ? actorTypeFromHeader ?? "member"
+    ? actorHeaders["x-actor-type"] ?? "member"
     : allowLocalBoardFallback
       ? "board"
       : "member";
   const actorId = hasActorHeaders
-    ? actorIdHeader || "unknown-actor"
+    ? actorHeaders["x-actor-id"] || "unknown-actor"
     : allowLocalBoardFallback
       ? "local-board"
       : "anonymous-member";

package/src/routes/agents.ts

@@ -1,7 +1,11 @@
 import { Router } from "express";
 import { mkdir } from "node:fs/promises";
 import { z } from "zod";
-import { executeAgentRuntime } from "bopodev-agent-sdk";
+import {
+  getAdapterMetadata,
+  getAdapterModels,
+  runAdapterEnvironmentTest
+} from "bopodev-agent-sdk";
 import { AgentCreateRequestSchema, AgentUpdateRequestSchema } from "bopodev-contracts";
 import {
   appendAuditEvent,
@@ -59,12 +63,10 @@ const updateAgentSchema = AgentUpdateRequestSchema.extend({
 });
 
 const runtimePreflightSchema = z.object({
-  providerType: z.enum(["claude_code", "codex", "http", "shell"]),
+  providerType: z.enum(["claude_code", "codex", "cursor", "opencode", "http", "shell"]),
   runtimeConfig: z.record(z.string(), z.unknown()).optional(),
   ...legacyRuntimeConfigSchema.shape
 });
-const CODEX_AUTH_REQUIRED_RE =
-  /(not\s+logged\s+in|login\s+required|authentication\s+required|unauthorized|invalid(?:\s+or\s+missing)?\s+api(?:[_\s-]?key)?|openai[_\s-]?api[_\s-]?key|api[_\s-]?key.*required|missing bearer|missing bearer or basic authentication)/i;
 const UPDATE_AGENT_ALLOWED_KEYS = new Set([
   "managerAgentId",
   "role",
@@ -127,6 +129,35 @@ export function createAgentsRouter(ctx: AppContext) {
     return sendOk(res, { runtimeCwd });
   });
 
+  router.get("/adapter-metadata", async (_req, res) => {
+    return sendOk(res, { adapters: getAdapterMetadata() });
+  });
+
+  router.get("/adapter-models/:providerType", async (req, res) => {
+    const providerType = req.params.providerType;
+    if (!runtimePreflightSchema.shape.providerType.safeParse(providerType).success) {
+      return sendError(res, `Unsupported provider type: ${providerType}`, 422);
+    }
+    const defaultRuntimeCwd = await resolveDefaultRuntimeCwdForCompany(ctx.db, req.companyId!);
+    const runtimeConfig = normalizeRuntimeConfig({
+      runtimeConfig: req.body?.runtimeConfig,
+      defaultRuntimeCwd
+    });
+    const typedProviderType = providerType as "claude_code" | "codex" | "cursor" | "opencode" | "http" | "shell";
+    const models = await getAdapterModels(typedProviderType, {
+      command: runtimeConfig.runtimeCommand,
+      args: runtimeConfig.runtimeArgs,
+      cwd: runtimeConfig.runtimeCwd,
+      env: runtimeConfig.runtimeEnv,
+      model: runtimeConfig.runtimeModel,
+      thinkingEffort: runtimeConfig.runtimeThinkingEffort,
+      timeoutMs: runtimeConfig.runtimeTimeoutSec > 0 ? runtimeConfig.runtimeTimeoutSec * 1000 : undefined,
+      interruptGraceSec: runtimeConfig.interruptGraceSec,
+      runPolicy: runtimeConfig.runPolicy
+    });
+    return sendOk(res, { providerType: typedProviderType, models });
+  });
+
   router.post("/runtime-preflight", async (req, res) => {
     const parsed = runtimePreflightSchema.safeParse(req.body);
     if (!parsed.success) {
@@ -151,42 +182,13 @@ export function createAgentsRouter(ctx: AppContext) {
       defaultRuntimeCwd
     });
 
-    const checks: Array<{
-      code: string;
-      level: "info" | "warn" | "error";
-      message: string;
-      detail?: string;
-      hint?: string;
-    }> = [];
-
-    if (parsed.data.providerType !== "codex") {
-      return sendOk(res, {
-        status: "pass",
-        testedAt: new Date().toISOString(),
-        checks: [
-          {
-            code: "preflight_not_required",
-            level: "info",
-            message: "Preflight probe is currently required only for Codex runtime."
-          }
-        ]
-      });
-    }
-
-    if (!runtimeConfig.runtimeCwd) {
-      checks.push({
-        code: "codex_cwd_missing",
-        level: "error",
-        message: "Runtime working directory is required for Codex preflight."
-      });
-      return sendOk(res, { status: "fail", testedAt: new Date().toISOString(), checks });
+    if (runtimeConfig.runtimeCwd) {
+      await mkdir(runtimeConfig.runtimeCwd, { recursive: true });
     }
 
-    await mkdir(runtimeConfig.runtimeCwd, { recursive: true });
-
     const timeoutMs =
-      runtimeConfig.runtimeTimeoutSec > 0 ? Math.min(runtimeConfig.runtimeTimeoutSec * 1000, 45_000) : 45_000;
-    const probe = await executeAgentRuntime("codex", "Respond with hello.", {
+      runtimeConfig.runtimeTimeoutSec > 0 ? Math.min(runtimeConfig.runtimeTimeoutSec * 1000, 45_000) : undefined;
+    const result = await runAdapterEnvironmentTest(parsed.data.providerType, {
       command: runtimeConfig.runtimeCommand,
       args: runtimeConfig.runtimeArgs,
       cwd: runtimeConfig.runtimeCwd,
@@ -195,65 +197,13 @@ export function createAgentsRouter(ctx: AppContext) {
       thinkingEffort: runtimeConfig.runtimeThinkingEffort,
       runPolicy: runtimeConfig.runPolicy,
       timeoutMs,
+      interruptGraceSec: runtimeConfig.interruptGraceSec,
       retryCount: 0
     });
-
-    if (probe.ok) {
-      const summary = (probe.parsedUsage?.summary ?? "").trim();
-      const hasHello = /\bhello\b/i.test(summary || probe.stdout);
-      checks.push({
-        code: hasHello ? "codex_hello_probe_passed" : "codex_hello_probe_unexpected_output",
-        level: hasHello ? "info" : "warn",
-        message: hasHello ? "Codex preflight probe succeeded." : "Codex probe succeeded but response was unexpected.",
-        ...(summary ? { detail: summary.slice(0, 240) } : {})
-      });
-    } else {
-      const detail = `${probe.stderr || ""}\n${probe.stdout || ""}`.trim().slice(0, 500);
-      if (probe.failureType === "spawn_error") {
-        checks.push({
-          code: "codex_command_unresolvable",
-          level: "error",
-          message: "Codex command is not executable from this runtime configuration.",
-          detail,
-          hint: "Install Codex CLI or set runtime command to an executable path."
-        });
-      } else if (probe.timedOut) {
-        checks.push({
-          code: "codex_hello_probe_timed_out",
-          level: "warn",
-          message: "Codex preflight timed out.",
-          detail,
-          hint: "Retry preflight. If this repeats, check runtime command/cwd and local Codex health."
-        });
-      } else if (CODEX_AUTH_REQUIRED_RE.test(detail)) {
-        checks.push({
-          code: "codex_auth_required",
-          level: "warn",
-          message: "Codex authentication is not ready for this runtime.",
-          detail,
-          hint: "Run `codex login` locally or set a global `BOPO_OPENAI_API_KEY`/`OPENAI_API_KEY`."
-        });
-      } else {
-        checks.push({
-          code: "codex_hello_probe_failed",
-          level: "error",
-          message: "Codex preflight failed.",
-          detail,
-          hint: "Run `codex exec --json -` manually in the runtime directory with prompt `Respond with hello.`."
-        });
-      }
-    }
-
-    const status =
-      checks.some((check) => check.level === "error")
-        ? "fail"
-        : checks.some((check) => check.level === "warn")
-          ? "warn"
-          : "pass";
     return sendOk(res, {
-      status,
-      testedAt: new Date().toISOString(),
-      checks
+      status: result.status,
+      testedAt: result.testedAt,
+      checks: result.checks
     });
   });
 

package/src/routes/heartbeats.ts

@@ -6,11 +6,14 @@ import type { AppContext } from "../context";
 import { sendError, sendOk } from "../http";
 import { requireCompanyScope } from "../middleware/company-scope";
 import { requirePermission } from "../middleware/request-actor";
-import { runHeartbeatForAgent, runHeartbeatSweep } from "../services/heartbeat-service";
+import { runHeartbeatForAgent, runHeartbeatSweep, stopHeartbeatRun } from "../services/heartbeat-service";
 
 const runAgentSchema = z.object({
   agentId: z.string().min(1)
 });
+const runIdParamsSchema = z.object({
+  runId: z.string().min(1)
+});
 
 export function createHeartbeatRouter(ctx: AppContext) {
   const router = Router();
@@ -64,6 +67,146 @@ export function createHeartbeatRouter(ctx: AppContext) {
     });
   });
 
+  router.post("/:runId/stop", async (req, res) => {
+    requirePermission("heartbeats:run")(req, res, () => {});
+    if (res.headersSent) {
+      return;
+    }
+    const parsed = runIdParamsSchema.safeParse(req.params);
+    if (!parsed.success) {
+      return sendError(res, parsed.error.message, 422);
+    }
+    const stopResult = await stopHeartbeatRun(ctx.db, req.companyId!, parsed.data.runId, {
+      requestId: req.requestId,
+      trigger: "manual",
+      actorId: req.actor?.id ?? undefined
+    });
+    if (!stopResult.ok) {
+      if (stopResult.reason === "not_found") {
+        return sendError(res, "Heartbeat run not found.", 404);
+      }
+      return sendError(res, `Heartbeat run is not stoppable in status '${stopResult.status}'.`, 409);
+    }
+    return sendOk(res, {
+      runId: stopResult.runId,
+      requestId: req.requestId,
+      status: "stop_requested"
+    });
+  });
+
+  async function rerunFromHistory(input: {
+    mode: "resume" | "redo";
+    runId: string;
+    companyId: string;
+    requestId?: string;
+  }) {
+    const [run] = await ctx.db
+      .select({
+        id: heartbeatRuns.id,
+        status: heartbeatRuns.status,
+        agentId: heartbeatRuns.agentId
+      })
+      .from(heartbeatRuns)
+      .where(and(eq(heartbeatRuns.companyId, input.companyId), eq(heartbeatRuns.id, input.runId)))
+      .limit(1);
+    if (!run) {
+      return { ok: false as const, statusCode: 404, message: "Heartbeat run not found." };
+    }
+    if (run.status === "started") {
+      return { ok: false as const, statusCode: 409, message: "Run is still in progress and cannot be replayed yet." };
+    }
+    const [agent] = await ctx.db
+      .select({ id: agents.id, status: agents.status })
+      .from(agents)
+      .where(and(eq(agents.companyId, input.companyId), eq(agents.id, run.agentId)))
+      .limit(1);
+    if (!agent) {
+      return { ok: false as const, statusCode: 404, message: "Agent not found." };
+    }
+    if (agent.status === "paused" || agent.status === "terminated") {
+      return { ok: false as const, statusCode: 409, message: `Agent is not invokable in status '${agent.status}'.` };
+    }
+    const nextRunId = await runHeartbeatForAgent(ctx.db, input.companyId, run.agentId, {
+      requestId: input.requestId,
+      trigger: "manual",
+      realtimeHub: ctx.realtimeHub,
+      mode: input.mode,
+      sourceRunId: run.id
+    });
+    if (!nextRunId) {
+      return { ok: false as const, statusCode: 409, message: "Heartbeat could not be started for this agent." };
+    }
+    const [runRow] = await ctx.db
+      .select({ id: heartbeatRuns.id, status: heartbeatRuns.status, message: heartbeatRuns.message })
+      .from(heartbeatRuns)
+      .where(and(eq(heartbeatRuns.companyId, input.companyId), eq(heartbeatRuns.id, nextRunId)))
+      .limit(1);
+    const invokeStatus =
+      runRow?.status === "skipped" && String(runRow.message ?? "").includes("already in progress")
+        ? "skipped_overlap"
+        : runRow?.status === "skipped"
+          ? "skipped"
+          : "started";
+    return {
+      ok: true as const,
+      runId: nextRunId,
+      status: invokeStatus,
+      message: runRow?.message ?? null
+    };
+  }
+
+  router.post("/:runId/resume", async (req, res) => {
+    requirePermission("heartbeats:run")(req, res, () => {});
+    if (res.headersSent) {
+      return;
+    }
+    const parsed = runIdParamsSchema.safeParse(req.params);
+    if (!parsed.success) {
+      return sendError(res, parsed.error.message, 422);
+    }
+    const result = await rerunFromHistory({
+      mode: "resume",
+      runId: parsed.data.runId,
+      companyId: req.companyId!,
+      requestId: req.requestId
+    });
+    if (!result.ok) {
+      return sendError(res, result.message, result.statusCode);
+    }
+    return sendOk(res, {
+      runId: result.runId,
+      requestId: req.requestId,
+      status: result.status,
+      message: result.message
+    });
+  });
+
+  router.post("/:runId/redo", async (req, res) => {
+    requirePermission("heartbeats:run")(req, res, () => {});
+    if (res.headersSent) {
+      return;
+    }
+    const parsed = runIdParamsSchema.safeParse(req.params);
+    if (!parsed.success) {
+      return sendError(res, parsed.error.message, 422);
+    }
+    const result = await rerunFromHistory({
+      mode: "redo",
+      runId: parsed.data.runId,
+      companyId: req.companyId!,
+      requestId: req.requestId
+    });
+    if (!result.ok) {
+      return sendError(res, result.message, result.statusCode);
+    }
+    return sendOk(res, {
+      runId: result.runId,
+      requestId: req.requestId,
+      status: result.status,
+      message: result.message
+    });
+  });
+
   router.post("/sweep", async (req, res) => {
     requirePermission("heartbeats:sweep")(req, res, () => {});
     if (res.headersSent) {

package/src/routes/observability.ts

@@ -31,7 +31,30 @@ export function createObservabilityRouter(ctx: AppContext) {
   });
 
   router.get("/heartbeats", async (req, res) => {
-    return sendOk(res, await listHeartbeatRuns(ctx.db, req.companyId!));
+    const companyId = req.companyId!;
+    const [runs, auditRows] = await Promise.all([
+      listHeartbeatRuns(ctx.db, companyId),
+      listAuditEvents(ctx.db, companyId)
+    ]);
+    const outcomeByRunId = new Map<string, unknown>();
+    for (const row of auditRows) {
+      if (
+        row.entityType === "heartbeat_run" &&
+        (row.eventType === "heartbeat.completed" || row.eventType === "heartbeat.failed")
+      ) {
+        const payload = parsePayload(row.payloadJson);
+        if (payload && typeof payload === "object" && "outcome" in payload) {
+          outcomeByRunId.set(row.entityId, (payload as Record<string, unknown>).outcome ?? null);
+        }
+      }
+    }
+    return sendOk(
+      res,
+      runs.map((run) => ({
+        ...run,
+        outcome: outcomeByRunId.get(run.id) ?? null
+      }))
+    );
   });
 
   return router;

package/src/scripts/onboard-seed.ts

@@ -29,11 +29,11 @@ export interface OnboardSeedSummary {
 const DEFAULT_COMPANY_NAME_ENV = "BOPO_DEFAULT_COMPANY_NAME";
 const DEFAULT_COMPANY_ID_ENV = "BOPO_DEFAULT_COMPANY_ID";
 const DEFAULT_AGENT_PROVIDER_ENV = "BOPO_DEFAULT_AGENT_PROVIDER";
-type AgentProvider = "codex" | "claude_code" | "shell";
+type AgentProvider = "codex" | "claude_code" | "cursor" | "opencode" | "shell";
 const CEO_BOOTSTRAP_SUMMARY = "ceo bootstrap heartbeat";
 const STARTUP_PROJECT_NAME = "Leadership Setup";
 const CEO_STARTUP_TASK_TITLE = "Set up CEO operating files and hire founding engineer";
-const CEO_STARTUP_TASK_MARKER = "[bopohq:onboarding:ceo-startup:v1]";
+const CEO_STARTUP_TASK_MARKER = "[bopodev:onboarding:ceo-startup:v1]";
 
 export async function ensureOnboardingSeed(input: {
   dbPath?: string;
@@ -188,8 +188,8 @@ async function ensureCeoStartupTask(
     "   - If using `runtimeConfig`, only `runtimeConfig.bootstrapPrompt` is supported there.",
     "   - Use a temp JSON file or heredoc with `curl --data @file`; do not hand-escape multiline JSON.",
     "4. To inspect your own agent record, use `GET /agents` and filter by your agent id. Do not call `GET /agents/:agentId`.",
-    "   - `GET /agents` may be wrapped as `{ \"ok\": true, \"data\": [...] }` or returned as a raw array.",
-    "   - Shape-safe filter: `jq -er --arg id \"$BOPOHQ_AGENT_ID\" '(.data? // .) | if type==\"array\" then . else [] end | map(select(.id == $id))[0] | {id,name,role,bootstrapPrompt}'`",
+    "   - `GET /agents` uses envelope shape `{ \"ok\": true, \"data\": [...] }`; treat any other shape as failure.",
+    "   - Deterministic filter: `jq -er --arg id \"$BOPODEV_AGENT_ID\" '.data | if type==\"array\" then . else error(\"invalid_agents_payload\") end | map(select((.id? // \"\") == $id))[0] | {id,name,role,bootstrapPrompt}'`",
     "5. Heartbeat-assigned issues are already claimed for the current run. Do not call a checkout endpoint; update status with `PUT /issues/:issueId` only.",
     "6. After your operating files are active, submit a hire request for a Founding Engineer via `POST /agents` using supported fields:",
     "   - `name`, `role`, `providerType`, `heartbeatCron`, `monthlyBudgetUsd`",
@@ -200,6 +200,7 @@ async function ensureCeoStartupTask(
     "Safety checks before requesting hire:",
     "- Do not request duplicates if a Founding Engineer already exists.",
     "- Do not request duplicates if a pending approval for the same role is already open.",
+    "- For control-plane calls, prefer direct header env vars (`BOPODEV_COMPANY_ID`, `BOPODEV_ACTOR_TYPE`, `BOPODEV_ACTOR_ID`, `BOPODEV_ACTOR_COMPANIES`, `BOPODEV_ACTOR_PERMISSIONS`) instead of parsing `BOPODEV_REQUEST_HEADERS_JSON`.",
     "- Do not assume `python` is installed in the runtime shell; prefer direct headers, `node`, or `jq` when scripting.",
     "- Shell commands run under `zsh`; avoid Bash-only features such as `local -n`, `declare -n`, `mapfile`, and `readarray`."
   ].join("\n");
@@ -247,23 +248,32 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
 }
 
 function parseAgentProvider(value: unknown): AgentProvider | null {
-  if (value === "codex" || value === "claude_code" || value === "shell") {
+  if (value === "codex" || value === "claude_code" || value === "cursor" || value === "opencode" || value === "shell") {
     return value;
   }
   return null;
 }
 
 function resolveSeedRuntimeEnv(agentProvider: AgentProvider): Record<string, string> {
-  if (agentProvider !== "codex") {
-    return {};
+  if (agentProvider === "codex") {
+    const key = (process.env.BOPO_OPENAI_API_KEY ?? process.env.OPENAI_API_KEY)?.trim();
+    if (!key) {
+      return {};
+    }
+    return {
+      OPENAI_API_KEY: key
+    };
   }
-  const key = (process.env.BOPO_OPENAI_API_KEY ?? process.env.OPENAI_API_KEY)?.trim();
-  if (!key) {
-    return {};
+  if (agentProvider === "claude_code") {
+    const key = (process.env.BOPO_ANTHROPIC_API_KEY ?? process.env.ANTHROPIC_API_KEY)?.trim();
+    if (!key) {
+      return {};
+    }
+    return {
+      ANTHROPIC_API_KEY: key
+    };
   }
-  return {
-    OPENAI_API_KEY: key
-  };
+  return {};
 }
 
 function isBootstrapCeoRuntime(providerType: string, stateBlob: string | null) {

package/src/server.ts

@@ -61,7 +61,7 @@ async function main() {
   server.on("request", app);
   server.listen(port, () => {
     // eslint-disable-next-line no-console
-    console.log(`BopoHQ API running on http://localhost:${port}`);
+    console.log(`BopoDev API running on http://localhost:${port}`);
   });
 
   const defaultCompanyId = process.env.BOPO_DEFAULT_COMPANY_ID;

package/src/services/governance-service.ts

@@ -57,7 +57,7 @@ const activateGoalPayloadSchema = z.object({
   description: z.string().optional()
 });
 const AGENT_STARTUP_PROJECT_NAME = "Agent Onboarding";
-const AGENT_STARTUP_TASK_MARKER = "[bopohq:onboarding:agent-startup:v1]";
+const AGENT_STARTUP_TASK_MARKER = "[bopodev:onboarding:agent-startup:v1]";
 
 export class GovernanceError extends Error {
   constructor(message: string) {