bopodev-api 0.1.27 → 0.1.29

package/src/services/{heartbeat-service.ts → heartbeat-service/heartbeat-run.ts}

@@ -1,6 +1,5 @@
 import { mkdir, stat } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
-import { and, desc, eq, inArray, sql } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { resolveAdapter } from "bopodev-agent-sdk";
 import type { AdapterExecutionResult, AgentState, HeartbeatContext } from "bopodev-agent-sdk";
@@ -19,294 +18,65 @@ import {
 import type { BopoDb } from "bopodev-db";
 import {
   addIssueComment,
+  and,
   approvalRequests,
   agents,
   appendActivity,
   appendHeartbeatRunMessages,
+  auditEvents,
   companies,
   createApprovalRequest,
+  desc,
+  eq,
   goals,
   heartbeatRuns,
+  inArray,
   issueComments,
   issueAttachments,
   issues,
-  projects
+  listIssueGoalIdsBatch,
+  projects,
+  sql
 } from "bopodev-db";
 import { appendAuditEvent, appendCost } from "bopodev-db";
-import { parseRuntimeConfigFromAgentRow } from "../lib/agent-config";
-import { bootstrapRepositoryWorkspace, ensureIsolatedGitWorktree, GitRuntimeError } from "../lib/git-runtime";
+import { parseRuntimeConfigFromAgentRow } from "../../lib/agent-config";
+import { bootstrapRepositoryWorkspace, ensureIsolatedGitWorktree, GitRuntimeError } from "../../lib/git-runtime";
 import {
   isInsidePath,
   normalizeCompanyWorkspacePath,
   resolveCompanyWorkspaceRootPath,
   resolveProjectWorkspacePath
-} from "../lib/instance-paths";
-import { resolveRunArtifactAbsolutePath } from "../lib/run-artifact-paths";
+} from "../../lib/instance-paths";
+import { resolveRunArtifactAbsolutePath } from "../../lib/run-artifact-paths";
 import {
   assertRuntimeCwdForCompany,
   getProjectWorkspaceContextMap,
   hasText,
   resolveAgentFallbackWorkspace
-} from "../lib/workspace-policy";
-import type { RealtimeHub } from "../realtime/hub";
-import { createHeartbeatRunsRealtimeEvent } from "../realtime/heartbeat-runs";
-import { publishAttentionSnapshot } from "../realtime/attention";
-import { publishOfficeOccupantForAgent } from "../realtime/office-space";
-import { appendProjectBudgetUsage, checkAgentBudget, checkProjectBudget } from "./budget-service";
-import { appendDurableFact, loadAgentMemoryContext, persistHeartbeatMemory } from "./memory-file-service";
-import { calculateModelPricedUsdCost } from "./model-pricing";
-import { runPluginHook } from "./plugin-runtime";
-
-type HeartbeatRunTrigger = "manual" | "scheduler";
-type HeartbeatRunMode = "default" | "resume" | "redo";
-type HeartbeatProviderType =
-  | "claude_code"
-  | "codex"
-  | "cursor"
-  | "opencode"
-  | "gemini_cli"
-  | "openai_api"
-  | "anthropic_api"
-  | "http"
-  | "shell";
-
-type ActiveHeartbeatRun = {
-  companyId: string;
-  agentId: string;
-  abortController: AbortController;
-  cancelReason?: string | null;
-  cancelRequestedAt?: string | null;
-  cancelRequestedBy?: string | null;
-};
-
-const activeHeartbeatRuns = new Map<string, ActiveHeartbeatRun>();
-type HeartbeatWakeContext = {
-  reason?: string | null;
-  commentId?: string | null;
-  commentBody?: string | null;
-  issueIds?: string[];
-};
-
-const AGENT_COMMENT_EMOJI_REGEX = /[\p{Extended_Pictographic}\uFE0F\u200D]/gu;
-
-type RunDigestSignal = {
-  sequence: number;
-  kind: "system" | "assistant" | "thinking" | "tool_call" | "tool_result" | "result" | "stderr";
-  label: string | null;
-  text: string | null;
-  payload: string | null;
-  signalLevel: "high" | "medium" | "low" | "noise";
-  groupKey: string | null;
-  source: "stdout" | "stderr" | "trace_fallback";
-};
-
-type RunDigest = {
-  status: "completed" | "failed" | "skipped";
-  headline: string;
-  summary: string;
-  successes: string[];
-  failures: string[];
-  blockers: string[];
-  nextAction: string;
-  evidence: {
-    transcriptSignalCount: number;
-    outcomeActionCount: number;
-    outcomeBlockerCount: number;
-    failureType: string | null;
-  };
-};
-
-type RunTerminalPresentation = {
-  internalStatus: "completed" | "failed" | "skipped";
-  publicStatus: "completed" | "failed";
-  completionReason: RunCompletionReason;
-};
-
-export async function claimIssuesForAgent(
-  db: BopoDb,
-  companyId: string,
-  agentId: string,
-  heartbeatRunId: string,
-  maxItems = 5
-) {
-  const result = await db.execute(sql`
-    WITH candidate AS (
-      SELECT id
-      FROM issues
-      WHERE company_id = ${companyId}
-        AND assignee_agent_id = ${agentId}
-        AND status IN ('todo', 'in_progress')
-        AND is_claimed = false
-      ORDER BY
-        CASE priority
-          WHEN 'urgent' THEN 0
-          WHEN 'high' THEN 1
-          WHEN 'medium' THEN 2
-          WHEN 'low' THEN 3
-          ELSE 4
-        END ASC,
-        updated_at ASC
-      LIMIT ${maxItems}
-      FOR UPDATE SKIP LOCKED
-    )
-    UPDATE issues i
-    SET is_claimed = true,
-        claimed_by_heartbeat_run_id = ${heartbeatRunId},
-        updated_at = CURRENT_TIMESTAMP
-    FROM candidate c
-    WHERE i.id = c.id
-    RETURNING i.id, i.project_id, i.parent_issue_id, i.title, i.body, i.status, i.priority, i.labels_json, i.tags_json;
-  `);
-
-  return (result.rows ?? []) as Array<{
-    id: string;
-    project_id: string;
-    parent_issue_id: string | null;
-    title: string;
-    body: string | null;
-    status: string;
-    priority: string;
-    labels_json: string;
-    tags_json: string;
-  }>;
-}
-
-export async function releaseClaimedIssues(db: BopoDb, companyId: string, issueIds: string[]) {
-  if (issueIds.length === 0) {
-    return;
-  }
-  await db
-    .update(issues)
-    .set({ isClaimed: false, claimedByHeartbeatRunId: null, updatedAt: new Date() })
-    .where(and(eq(issues.companyId, companyId), inArray(issues.id, issueIds)));
-}
-
-export async function stopHeartbeatRun(
-  db: BopoDb,
-  companyId: string,
-  runId: string,
-  options?: { requestId?: string; actorId?: string; trigger?: HeartbeatRunTrigger; realtimeHub?: RealtimeHub }
-) {
-  const runTrigger = options?.trigger ?? "manual";
-  const [run] = await db
-    .select({
-      id: heartbeatRuns.id,
-      status: heartbeatRuns.status,
-      agentId: heartbeatRuns.agentId
-    })
-    .from(heartbeatRuns)
-    .where(and(eq(heartbeatRuns.companyId, companyId), eq(heartbeatRuns.id, runId)))
-    .limit(1);
-  if (!run) {
-    return { ok: false as const, reason: "not_found" as const };
-  }
-  if (run.status !== "started") {
-    return { ok: false as const, reason: "invalid_status" as const, status: run.status };
-  }
-  const active = activeHeartbeatRuns.get(runId);
-  const cancelReason = "cancelled by stop request";
-  const cancelRequestedAt = new Date().toISOString();
-  if (active) {
-    active.cancelReason = cancelReason;
-    active.cancelRequestedAt = cancelRequestedAt;
-    active.cancelRequestedBy = options?.actorId ?? null;
-    active.abortController.abort(cancelReason);
-  } else {
-    const finishedAt = new Date();
-    await db
-      .update(heartbeatRuns)
-      .set({
-        status: "failed",
-        finishedAt,
-        message: "Heartbeat cancelled by stop request."
-      })
-      .where(and(eq(heartbeatRuns.companyId, companyId), eq(heartbeatRuns.id, runId)));
-    publishHeartbeatRunStatus(options?.realtimeHub, {
-      companyId,
-      runId,
-      status: "failed",
-      message: "Heartbeat cancelled by stop request.",
-      finishedAt
-    });
-  }
-  await appendAuditEvent(db, {
-    companyId,
-    actorType: "system",
-    eventType: "heartbeat.cancel_requested",
-    entityType: "heartbeat_run",
-    entityId: runId,
-    correlationId: options?.requestId ?? runId,
-    payload: {
-      agentId: run.agentId,
-      trigger: runTrigger,
-      requestId: options?.requestId ?? null,
-      actorId: options?.actorId ?? null,
-      inMemoryAbortRegistered: Boolean(active)
-    }
-  });
-  if (!active) {
-    await appendAuditEvent(db, {
-      companyId,
-      actorType: "system",
-      eventType: "heartbeat.cancelled",
-      entityType: "heartbeat_run",
-      entityId: runId,
-      correlationId: options?.requestId ?? runId,
-      payload: {
-        agentId: run.agentId,
-        reason: cancelReason,
-        trigger: runTrigger,
-        requestId: options?.requestId ?? null,
-        actorId: options?.actorId ?? null
-      }
-    });
-  }
-  return { ok: true as const, runId, agentId: run.agentId, status: run.status };
-}
-
-export async function findPendingProjectBudgetOverrideBlocksForAgent(
-  db: BopoDb,
-  companyId: string,
-  agentId: string
-) {
-  const assignedRows = await db
-    .select({ projectId: issues.projectId })
-    .from(issues)
-    .where(
-      and(
-        eq(issues.companyId, companyId),
-        eq(issues.assigneeAgentId, agentId),
-        inArray(issues.status, ["todo", "in_progress"])
-      )
-    );
-  const assignedProjectIds = new Set(assignedRows.map((row) => row.projectId));
-  if (assignedProjectIds.size === 0) {
-    return [] as string[];
-  }
-  const pendingOverrides = await db
-    .select({ payloadJson: approvalRequests.payloadJson })
-    .from(approvalRequests)
-    .where(
-      and(
-        eq(approvalRequests.companyId, companyId),
-        eq(approvalRequests.action, "override_budget"),
-        eq(approvalRequests.status, "pending")
-      )
-    );
-  const blockedProjectIds = new Set<string>();
-  for (const approval of pendingOverrides) {
-    try {
-      const payload = JSON.parse(approval.payloadJson) as Record<string, unknown>;
-      const projectId = typeof payload.projectId === "string" ? payload.projectId.trim() : "";
-      if (projectId && assignedProjectIds.has(projectId)) {
-        blockedProjectIds.add(projectId);
-      }
-    } catch {
-      // Ignore malformed payloads to keep enforcement resilient.
-    }
-  }
-  return Array.from(blockedProjectIds);
-}
+} from "../../lib/workspace-policy";
+import type { RealtimeHub } from "../../realtime/hub";
+import { createHeartbeatRunsRealtimeEvent, loadHeartbeatRunsRealtimeSnapshot } from "../../realtime/heartbeat-runs";
+import { publishAttentionSnapshot } from "../../realtime/attention";
+import { publishOfficeOccupantForAgent } from "../../realtime/office-space";
+import { appendProjectBudgetUsage, checkAgentBudget, checkProjectBudget } from "../budget-service";
+import { appendDurableFact, loadAgentMemoryContext, persistHeartbeatMemory } from "../memory-file-service";
+import { calculateModelPricedUsdCost } from "../model-pricing";
+import { runPluginHook } from "../plugin-runtime";
+import { registerActiveHeartbeatRun, unregisterActiveHeartbeatRun } from "./active-runs";
+import { claimIssuesForAgent, releaseClaimedIssues } from "./claims";
+import { publishHeartbeatRunStatus } from "./heartbeat-realtime";
+import { extractNaturalRunUpdate, sanitizeAgentSummaryCommentBody } from "./heartbeat-run-summary-text";
+import type {
+  ActiveHeartbeatRun,
+  HeartbeatIdlePolicy,
+  HeartbeatProviderType,
+  HeartbeatRunMode,
+  HeartbeatRunTrigger,
+  HeartbeatWakeContext,
+  RunDigest,
+  RunDigestSignal,
+  RunTerminalPresentation
+} from "./types";
 
 export async function runHeartbeatForAgent(
   db: BopoDb,
@@ -713,6 +483,8 @@ export async function runHeartbeatForAgent(
 
   let issueIds: string[] = [];
   let claimedIssueIds: string[] = [];
+  /** After transcript flush: remove DB row + audit noise for idle heartbeats with no issues. */
+  let discardIdleNoWorkRunAfterFlush = false;
   let executionWorkItemsForBudget: Array<{ issueId: string; projectId: string }> = [];
   let state: AgentState & {
     runtime?: {
@@ -901,7 +673,11 @@ export async function runHeartbeatForAgent(
     const heartbeatIdlePolicy = resolveHeartbeatIdlePolicy();
     const workItems = isCommentOrderWake ? [] : await claimIssuesForAgent(db, companyId, agentId, runId);
     const wakeWorkItems = await loadWakeContextWorkItems(db, companyId, options?.wakeContext?.issueIds);
-    const contextWorkItems = resolveExecutionWorkItems(workItems, wakeWorkItems, options?.wakeContext);
+    const contextWorkItems = await hydrateIssueWorkItemsWithGoalIds(
+      db,
+      companyId,
+      resolveExecutionWorkItems(workItems, wakeWorkItems, options?.wakeContext)
+    );
     executionWorkItemsForBudget = contextWorkItems.map((item) => ({ issueId: item.id, projectId: item.project_id }));
     claimedIssueIds = workItems.map((item) => item.id);
     issueIds = contextWorkItems.map((item) => item.id);
@@ -1293,7 +1069,8 @@ export async function runHeartbeatForAgent(
       mission: context.company.mission ?? null,
       goalContext: {
         companyGoals: context.goalContext?.companyGoals ?? [],
-        projectGoals: context.goalContext?.projectGoals ?? []
+        projectGoals: context.goalContext?.projectGoals ?? [],
+        agentGoals: context.goalContext?.agentGoals ?? []
       }
     });
     await appendAuditEvent(db, {
@@ -1337,7 +1114,8 @@ export async function runHeartbeatForAgent(
       summary: executionSummary,
       mission: context.company.mission ?? null,
       companyGoals: context.goalContext?.companyGoals ?? [],
-      projectGoals: context.goalContext?.projectGoals ?? []
+      projectGoals: context.goalContext?.projectGoals ?? [],
+      agentGoals: context.goalContext?.agentGoals ?? []
     });
     await appendAuditEvent(db, {
       companyId,
@@ -1716,6 +1494,11 @@ export async function runHeartbeatForAgent(
         }
       }
     });
+    discardIdleNoWorkRunAfterFlush =
+      issueIds.length === 0 &&
+      !isCommentOrderWake &&
+      (terminalPresentation.completionReason === "no_assigned_work" ||
+        (isIdleNoWork && heartbeatIdlePolicy === "skip_adapter" && persistedRunStatus === "completed"));
   } catch (error) {
     const classified = classifyHeartbeatError(error);
     executionSummary =
@@ -1951,6 +1734,17 @@ export async function runHeartbeatForAgent(
     }
   } finally {
     await transcriptWriteQueue;
+    if (discardIdleNoWorkRunAfterFlush) {
+      try {
+        await purgeIdleNoWorkHeartbeatRun(db, companyId, runId);
+        if (options?.realtimeHub) {
+          options.realtimeHub.publish(await loadHeartbeatRunsRealtimeSnapshot(db, companyId));
+        }
+      } catch (purgeError) {
+        // eslint-disable-next-line no-console
+        console.error("[heartbeat] failed to purge idle no-work run", runId, purgeError);
+      }
+    }
     unregisterActiveHeartbeatRun(runId);
     try {
       await releaseClaimedIssues(db, companyId, claimedIssueIds);
@@ -1971,7 +1765,7 @@ export async function runHeartbeatForAgent(
     }
     await publishOfficeOccupantForAgent(db, options?.realtimeHub, companyId, agentId);
     try {
-      const queueModule = await import("./heartbeat-queue-service");
+      const queueModule = await import("../heartbeat-queue-service");
       queueModule.triggerHeartbeatQueueWorker(db, companyId, {
         requestId: options?.requestId,
         realtimeHub: options?.realtimeHub
@@ -1984,17 +1778,31 @@ export async function runHeartbeatForAgent(
   return runId;
 }
 
+async function purgeIdleNoWorkHeartbeatRun(db: BopoDb, companyId: string, runId: string) {
+  await db
+    .delete(auditEvents)
+    .where(
+      and(eq(auditEvents.companyId, companyId), eq(auditEvents.entityType, "heartbeat_run"), eq(auditEvents.entityId, runId))
+    );
+  await db.delete(heartbeatRuns).where(and(eq(heartbeatRuns.companyId, companyId), eq(heartbeatRuns.id, runId)));
+}
+
 async function insertStartedRunAtomic(
   db: BopoDb,
   input: { id: string; companyId: string; agentId: string; message: string }
 ) {
-  const result = await db.execute(sql`
-    INSERT INTO heartbeat_runs (id, company_id, agent_id, status, message)
-    VALUES (${input.id}, ${input.companyId}, ${input.agentId}, 'started', ${input.message})
-    ON CONFLICT DO NOTHING
-    RETURNING id
-  `);
-  return (result.rows ?? []).length > 0;
+  const inserted = await db
+    .insert(heartbeatRuns)
+    .values({
+      id: input.id,
+      companyId: input.companyId,
+      agentId: input.agentId,
+      status: "started",
+      message: input.message
+    })
+    .onConflictDoNothing()
+    .returning({ id: heartbeatRuns.id });
+  return inserted.length > 0;
 }
 
 async function recoverStaleHeartbeatRuns(
@@ -2054,129 +1862,43 @@ async function recoverStaleHeartbeatRuns(
   }
 }
 
-export async function runHeartbeatSweep(
+type IssueWorkItemRow = {
+  id: string;
+  project_id: string;
+  parent_issue_id: string | null;
+  title: string;
+  body: string | null;
+  status: string;
+  priority: string;
+  labels_json: string;
+  tags_json: string;
+};
+
+type IssueWorkItemRowWithGoals = IssueWorkItemRow & { goal_ids: string[] };
+
+async function hydrateIssueWorkItemsWithGoalIds(
   db: BopoDb,
   companyId: string,
-  options?: { requestId?: string; realtimeHub?: RealtimeHub }
-) {
-  const companyAgents = await db.select().from(agents).where(eq(agents.companyId, companyId));
-  const latestRunByAgent = await listLatestRunByAgent(db, companyId);
-
-  const now = new Date();
-  const enqueuedJobIds: string[] = [];
-  const dueAgents: Array<{ id: string }> = [];
-  let skippedNotDue = 0;
-  let skippedStatus = 0;
-  let skippedBudgetBlocked = 0;
-  let failedStarts = 0;
-  const sweepStartedAt = Date.now();
-  for (const agent of companyAgents) {
-    if (agent.status !== "idle" && agent.status !== "running") {
-      skippedStatus += 1;
-      continue;
-    }
-    if (!isHeartbeatDue(agent.heartbeatCron, latestRunByAgent.get(agent.id) ?? null, now)) {
-      skippedNotDue += 1;
-      continue;
-    }
-    const blockedProjectIds = await findPendingProjectBudgetOverrideBlocksForAgent(db, companyId, agent.id);
-    if (blockedProjectIds.length > 0) {
-      skippedBudgetBlocked += 1;
-      continue;
-    }
-    dueAgents.push({ id: agent.id });
+  items: IssueWorkItemRow[]
+): Promise<IssueWorkItemRowWithGoals[]> {
+  if (items.length === 0) {
+    return [];
   }
-  const sweepConcurrency = resolveHeartbeatSweepConcurrency(dueAgents.length);
-  const queueModule = await import("./heartbeat-queue-service");
-  await runWithConcurrency(dueAgents, sweepConcurrency, async (agent) => {
-    try {
-      const job = await queueModule.enqueueHeartbeatQueueJob(db, {
-        companyId,
-        agentId: agent.id,
-        jobType: "scheduler",
-        priority: 80,
-        idempotencyKey: options?.requestId ? `scheduler:${agent.id}:${options.requestId}` : null,
-        payload: {}
-      });
-      enqueuedJobIds.push(job.id);
-      queueModule.triggerHeartbeatQueueWorker(db, companyId, {
-        requestId: options?.requestId,
-        realtimeHub: options?.realtimeHub
-      });
-    } catch {
-      failedStarts += 1;
-    }
-  });
-  await appendAuditEvent(db, {
+  const map = await listIssueGoalIdsBatch(
+    db,
     companyId,
-    actorType: "system",
-    eventType: "heartbeat.sweep.completed",
-    entityType: "company",
-    entityId: companyId,
-    correlationId: options?.requestId ?? null,
-    payload: {
-      runIds: enqueuedJobIds,
-      startedCount: enqueuedJobIds.length,
-      dueCount: dueAgents.length,
-      failedStarts,
-      skippedStatus,
-      skippedNotDue,
-      skippedBudgetBlocked,
-      concurrency: sweepConcurrency,
-      elapsedMs: Date.now() - sweepStartedAt,
-      requestId: options?.requestId ?? null
-    }
-  });
-  return enqueuedJobIds;
-}
-
-async function listLatestRunByAgent(db: BopoDb, companyId: string) {
-  const result = await db.execute(sql`
-    SELECT agent_id, MAX(started_at) AS latest_started_at
-    FROM heartbeat_runs
-    WHERE company_id = ${companyId}
-    GROUP BY agent_id
-  `);
-  const latestRunByAgent = new Map<string, Date>();
-  for (const row of result.rows ?? []) {
-    const agentId = typeof row.agent_id === "string" ? row.agent_id : null;
-    if (!agentId) {
-      continue;
-    }
-    const startedAt = coerceDate(row.latest_started_at);
-    if (!startedAt) {
-      continue;
-    }
-    latestRunByAgent.set(agentId, startedAt);
-  }
-  return latestRunByAgent;
-}
-
-function coerceDate(value: unknown) {
-  if (value instanceof Date) {
-    return Number.isNaN(value.getTime()) ? null : value;
-  }
-  if (typeof value === "string" || typeof value === "number") {
-    const parsed = new Date(value);
-    return Number.isNaN(parsed.getTime()) ? null : parsed;
-  }
-  return null;
+    items.map((item) => item.id)
+  );
+  return items.map((item) => ({
+    ...item,
+    goal_ids: map.get(item.id) ?? []
+  }));
 }
 
 async function loadWakeContextWorkItems(db: BopoDb, companyId: string, wakeIssueIds?: string[]) {
   const normalizedIds = Array.from(new Set((wakeIssueIds ?? []).filter((id) => id.trim().length > 0)));
   if (normalizedIds.length === 0) {
-    return [] as Array<{
-      id: string;
-      project_id: string;
-      parent_issue_id: string | null;
-      title: string;
-      body: string | null;
-      status: string;
-      priority: string;
-      labels_json: string;
-      tags_json: string;
-    }>;
+    return [] as IssueWorkItemRow[];
   }
   const rows = await db
     .select({
@@ -2196,32 +1918,9 @@ async function loadWakeContextWorkItems(db: BopoDb, companyId: string, wakeIssue
   return rows.sort((a, b) => (sortOrder.get(a.id) ?? Number.MAX_SAFE_INTEGER) - (sortOrder.get(b.id) ?? Number.MAX_SAFE_INTEGER));
 }
 
-function mergeContextWorkItems(
-  assigned: Array<{
-    id: string;
-    project_id: string;
-    parent_issue_id: string | null;
-    title: string;
-    body: string | null;
-    status: string;
-    priority: string;
-    labels_json: string;
-    tags_json: string;
-  }>,
-  wakeContext: Array<{
-    id: string;
-    project_id: string;
-    parent_issue_id: string | null;
-    title: string;
-    body: string | null;
-    status: string;
-    priority: string;
-    labels_json: string;
-    tags_json: string;
-  }>
-) {
+function mergeContextWorkItems(assigned: IssueWorkItemRow[], wakeContext: IssueWorkItemRow[]) {
   const seen = new Set<string>();
-  const merged: typeof assigned = [];
+  const merged: IssueWorkItemRow[] = [];
   for (const item of assigned) {
     if (!seen.has(item.id)) {
       seen.add(item.id);
@@ -2238,28 +1937,8 @@ function mergeContextWorkItems(
 }
 
 function resolveExecutionWorkItems(
-  assigned: Array<{
-    id: string;
-    project_id: string;
-    parent_issue_id: string | null;
-    title: string;
-    body: string | null;
-    status: string;
-    priority: string;
-    labels_json: string;
-    tags_json: string;
-  }>,
-  wakeContextItems: Array<{
-    id: string;
-    project_id: string;
-    parent_issue_id: string | null;
-    title: string;
-    body: string | null;
-    status: string;
-    priority: string;
-    labels_json: string;
-    tags_json: string;
-  }>,
+  assigned: IssueWorkItemRow[],
+  wakeContextItems: IssueWorkItemRow[],
   wakeContext?: HeartbeatWakeContext
 ) {
   if (wakeContext?.reason === "issue_comment_recipient" && wakeContextItems.length > 0) {
@@ -2297,6 +1976,62 @@ async function loadWakeContextCommentBody(db: BopoDb, companyId: string, comment
   return body && body.length > 0 ? body : null;
 }
 
+const GOAL_CONTEXT_DESC_MAX_CHARS = 280;
+const GOAL_ANCESTRY_NODE_DESC_MAX_CHARS = 120;
+const GOAL_ANCESTRY_MAX_DEPTH = 16;
+
+type GoalRowForHeartbeat = {
+  id: string;
+  title: string;
+  description: string | null;
+  parentGoalId: string | null;
+  level: string;
+  projectId: string | null;
+  status: string;
+  ownerAgentId: string | null;
+};
+
+function clipGoalDescription(text: string, max: number) {
+  const t = text.trim();
+  if (t.length <= max) {
+    return t;
+  }
+  return `${t.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function formatGoalContextLine(goal: Pick<GoalRowForHeartbeat, "title" | "description">, descMax: number) {
+  const title = goal.title.trim();
+  const desc = goal.description?.trim();
+  if (!desc) {
+    return title;
+  }
+  return `${title} — ${clipGoalDescription(desc, descMax)}`;
+}
+
+function buildGoalAncestryLines(
+  goalId: string | null | undefined,
+  byId: Map<string, GoalRowForHeartbeat>,
+  nodeDescMax: number
+) {
+  if (!goalId) {
+    return [] as string[];
+  }
+  const chain: string[] = [];
+  let current: GoalRowForHeartbeat | undefined = byId.get(goalId);
+  const visited = new Set<string>();
+  let depth = 0;
+  while (current && depth < GOAL_ANCESTRY_MAX_DEPTH) {
+    if (visited.has(current.id)) {
+      break;
+    }
+    visited.add(current.id);
+    chain.unshift(formatGoalContextLine(current, nodeDescMax));
+    current = current.parentGoalId ? byId.get(current.parentGoalId) : undefined;
+    depth += 1;
+  }
+  return chain;
+}
+
 async function buildHeartbeatContext(
   db: BopoDb,
   companyId: string,
@@ -2311,17 +2046,7 @@ async function buildHeartbeatContext(
     memoryContext?: HeartbeatContext["memoryContext"];
     runtime?: { command?: string; args?: string[]; cwd?: string; timeoutMs?: number };
     wakeContext?: HeartbeatWakeContext;
-    workItems: Array<{
-      id: string;
-      project_id: string;
-      parent_issue_id: string | null;
-      title: string;
-      body: string | null;
-      status: string;
-      priority: string;
-      labels_json: string;
-      tags_json: string;
-    }>;
+    workItems: IssueWorkItemRowWithGoals[];
   }
 ): Promise<HeartbeatContext> {
   const [company] = await db
@@ -2412,24 +2137,48 @@ async function buildHeartbeatContext(
       id: goals.id,
       level: goals.level,
       title: goals.title,
+      description: goals.description,
       status: goals.status,
-      projectId: goals.projectId
+      projectId: goals.projectId,
+      parentGoalId: goals.parentGoalId,
+      ownerAgentId: goals.ownerAgentId
     })
     .from(goals)
     .where(eq(goals.companyId, companyId));
 
+  const goalById = new Map<string, GoalRowForHeartbeat>(
+    goalRows.map((row) => [
+      row.id,
+      {
+        id: row.id,
+        title: row.title,
+        description: row.description,
+        parentGoalId: row.parentGoalId,
+        level: row.level,
+        projectId: row.projectId,
+        status: row.status,
+        ownerAgentId: row.ownerAgentId
+      }
+    ])
+  );
+
   const activeCompanyGoals = goalRows
     .filter((goal) => goal.status === "active" && goal.level === "company")
-    .map((goal) => goal.title);
+    .map((goal) => formatGoalContextLine(goal, GOAL_CONTEXT_DESC_MAX_CHARS));
   const activeProjectGoals = goalRows
     .filter(
       (goal) =>
         goal.status === "active" && goal.level === "project" && goal.projectId && projectIds.includes(goal.projectId)
     )
-    .map((goal) => goal.title);
+    .map((goal) => formatGoalContextLine(goal, GOAL_CONTEXT_DESC_MAX_CHARS));
   const activeAgentGoals = goalRows
-    .filter((goal) => goal.status === "active" && goal.level === "agent")
-    .map((goal) => goal.title);
+    .filter(
+      (goal) =>
+        goal.status === "active" &&
+        goal.level === "agent" &&
+        (!goal.ownerAgentId || goal.ownerAgentId === input.agentId)
+    )
+    .map((goal) => formatGoalContextLine(goal, GOAL_CONTEXT_DESC_MAX_CHARS));
   const isCommentOrderWake = input.wakeContext?.reason === "issue_comment_recipient";
   const promptMode = resolveHeartbeatPromptMode();
 
@@ -2468,6 +2217,11 @@ async function buildHeartbeatContext(
       issueId: item.id,
       projectId: item.project_id,
       parentIssueId: item.parent_issue_id,
+      goalIds: item.goal_ids,
+      goalAncestryChains: item.goal_ids.map((gid) => {
+        const chain = buildGoalAncestryLines(gid, goalById, GOAL_ANCESTRY_NODE_DESC_MAX_CHARS);
+        return chain.length > 0 ? chain : [gid];
+      }),
       childIssueIds: childIssueIdsByParent.get(item.id) ?? [],
       projectName: projectNameById.get(item.project_id) ?? null,
       title: item.title,
@@ -2499,10 +2253,13 @@ function computeMissionAlignmentSignal(input: {
   mission: string | null;
   companyGoals: string[];
   projectGoals: string[];
+  agentGoals: string[];
 }) {
   const summaryTokens = new Set(tokenizeAlignmentText(input.summary));
   const missionTokens = tokenizeAlignmentText(input.mission ?? "");
-  const goalTokens = tokenizeAlignmentText([...input.companyGoals, ...input.projectGoals].join(" "));
+  const goalTokens = tokenizeAlignmentText(
+    [...input.companyGoals, ...input.projectGoals, ...input.agentGoals].join(" ")
+  );
   const matchedMissionTerms = missionTokens.filter((token) => summaryTokens.has(token));
   const matchedGoalTerms = goalTokens.filter((token) => summaryTokens.has(token));
   const missionScore = missionTokens.length > 0 ? matchedMissionTerms.length / missionTokens.length : 0;
@@ -2733,34 +2490,6 @@ async function ensureProjectBudgetOverrideApprovalRequest(
   return approvalId;
 }
 
-function sanitizeAgentSummaryCommentBody(body: string) {
-  const sanitized = body.replace(AGENT_COMMENT_EMOJI_REGEX, "").trim();
-  return sanitized.length > 0 ? sanitized : "Run update.";
-}
-
-function extractNaturalRunUpdate(executionSummary: string) {
-  const normalized = executionSummary.trim();
-  const jsonSummary = extractSummaryFromJsonLikeText(normalized);
-  const source = jsonSummary ?? normalized;
-  const lines = source
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0)
-    .filter((line) => !line.startsWith("{") && !line.startsWith("}"));
-  const compact = (lines.length > 0 ? lines.slice(0, 2).join(" ") : source)
-    .replace(/^run (failure )?summary\s*:\s*/i, "")
-    .replace(/^completed all assigned issue steps\s*:\s*/i, "")
-    .replace(/^issue status\s*:\s*/i, "")
-    .replace(/`+/g, "")
-    .replace(/\s+/g, " ")
-    .trim();
-  const bounded = compact.length > 260 ? `${compact.slice(0, 257).trimEnd()}...` : compact;
-  if (!bounded) {
-    return "Run update.";
-  }
-  return /[.!?]$/.test(bounded) ? bounded : `${bounded}.`;
-}
-
 function buildRunDigest(input: {
   status: "completed" | "failed" | "skipped";
   executionSummary: string;
@@ -3156,6 +2885,11 @@ function normalizeAgentOperatingArtifactRelativePath(pathValue: string | null, c
     const [, agentId, suffix = ""] = directMatch;
     return `workspace/${companyId}/agents/${agentId}/operating${suffix}`;
   }
+  const projectAgentsMatch = normalized.match(/^projects\/agents\/([^/]+)\/operating(\/.*)?$/);
+  if (projectAgentsMatch) {
+    const [, agentId, suffix = ""] = projectAgentsMatch;
+    return `workspace/${companyId}/agents/${agentId}/operating${suffix}`;
+  }
   const issueScopedMatch = normalized.match(
     /^(?:[^/]+\/)?projects\/[^/]+\/issues\/[^/]+\/agents\/([^/]+)\/operating(\/.*)?$/
   );
@@ -3452,30 +3186,6 @@ function isMachineNoiseLine(text: string) {
   return patterns.some((pattern) => pattern.test(normalized));
 }
 
-function extractSummaryFromJsonLikeText(input: string) {
-  const fencedMatch = input.match(/```(?:json)?\s*([\s\S]*?)```/i);
-  const candidate = fencedMatch?.[1]?.trim() ?? input.match(/\{[\s\S]*\}\s*$/)?.[0]?.trim();
-  if (!candidate) {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(candidate) as Record<string, unknown>;
-    const summary = parsed.summary;
-    if (typeof summary === "string" && summary.trim().length > 0) {
-      return summary.trim();
-    }
-  } catch {
-    // Fall through to regex extraction for loosely-formatted JSON.
-  }
-  const summaryMatch = candidate.match(/"summary"\s*:\s*"([\s\S]*?)"/);
-  const summary = summaryMatch?.[1]
-    ?.replace(/\\"/g, "\"")
-    .replace(/\\n/g, " ")
-    .replace(/\s+/g, " ")
-    .trim();
-  return summary && summary.length > 0 ? summary : null;
-}
-
 async function appendRunSummaryComments(
   db: BopoDb,
   input: {
@@ -3849,32 +3559,6 @@ function isUsefulTranscriptSignal(level: "high" | "medium" | "low" | "noise") {
   return level === "high" || level === "medium";
 }
 
-function publishHeartbeatRunStatus(
-  realtimeHub: RealtimeHub | undefined,
-  input: {
-    companyId: string;
-    runId: string;
-    status: "started" | "completed" | "failed" | "skipped";
-    message?: string | null;
-    startedAt?: Date;
-    finishedAt?: Date;
-  }
-) {
-  if (!realtimeHub) {
-    return;
-  }
-  realtimeHub.publish(
-    createHeartbeatRunsRealtimeEvent(input.companyId, {
-      type: "run.status.updated",
-      runId: input.runId,
-      status: input.status,
-      message: input.message ?? null,
-      startedAt: input.startedAt?.toISOString(),
-      finishedAt: input.finishedAt?.toISOString() ?? null
-    })
-  );
-}
-
 async function resolveRuntimeWorkspaceForWorkItems(
   db: BopoDb,
   companyId: string,
@@ -4039,39 +3723,6 @@ function resolveStaleRunThresholdMs() {
   return parsed;
 }
 
-function resolveHeartbeatSweepConcurrency(dueAgentsCount: number) {
-  const configured = Number(process.env.BOPO_HEARTBEAT_SWEEP_CONCURRENCY ?? "4");
-  const fallback = 4;
-  const normalized = Number.isFinite(configured) ? Math.floor(configured) : fallback;
-  if (normalized < 1) {
-    return 1;
-  }
-  // Prevent scheduler bursts from starving the API event loop.
-  const bounded = Math.min(normalized, 16);
-  return Math.min(bounded, Math.max(1, dueAgentsCount));
-}
-
-async function runWithConcurrency<T>(
-  items: T[],
-  concurrency: number,
-  worker: (item: T, index: number) => Promise<void>
-) {
-  if (items.length === 0) {
-    return;
-  }
-  const workerCount = Math.max(1, Math.min(Math.floor(concurrency), items.length));
-  let cursor = 0;
-  await Promise.all(
-    Array.from({ length: workerCount }, async () => {
-      while (cursor < items.length) {
-        const index = cursor;
-        cursor += 1;
-        await worker(items[index] as T, index);
-      }
-    })
-  );
-}
-
 function resolveEffectiveStaleRunThresholdMs(input: {
   baseThresholdMs: number;
   runtimeTimeoutSec: number;
@@ -4291,14 +3942,6 @@ function mergeRuntimeForExecution(
   };
 }
 
-function registerActiveHeartbeatRun(runId: string, run: ActiveHeartbeatRun) {
-  activeHeartbeatRuns.set(runId, run);
-}
-
-function unregisterActiveHeartbeatRun(runId: string) {
-  activeHeartbeatRuns.delete(runId);
-}
-
 function clearResumeState(
   state: AgentState & {
     runtime?: {
@@ -4350,8 +3993,6 @@ function resolveHeartbeatPromptMode(): "full" | "compact" {
   return raw === "compact" ? "compact" : "full";
 }
 
-type HeartbeatIdlePolicy = "full" | "skip_adapter" | "micro_prompt";
-
 function resolveHeartbeatIdlePolicy(): HeartbeatIdlePolicy {
   const raw = process.env.BOPO_HEARTBEAT_IDLE_POLICY?.trim().toLowerCase();
   if (raw === "skip_adapter") {
@@ -4738,62 +4379,3 @@ async function appendFinishedRunCostEntry(input: {
     usdCostStatus
   };
 }
-
-function isHeartbeatDue(cronExpression: string, lastRunAt: Date | null, now: Date) {
-  const normalizedNow = truncateToMinute(now);
-  if (!matchesCronExpression(cronExpression, normalizedNow)) {
-    return false;
-  }
-  if (!lastRunAt) {
-    return true;
-  }
-  return truncateToMinute(lastRunAt).getTime() !== normalizedNow.getTime();
-}
-
-function truncateToMinute(date: Date) {
-  const clone = new Date(date);
-  clone.setSeconds(0, 0);
-  return clone;
-}
-
-function matchesCronExpression(expression: string, date: Date) {
-  const parts = expression.trim().split(/\s+/);
-  if (parts.length !== 5) {
-    return false;
-  }
-
-  const [minute, hour, dayOfMonth, month, dayOfWeek] = parts as [string, string, string, string, string];
-  return (
-    matchesCronField(minute, date.getMinutes(), 0, 59) &&
-    matchesCronField(hour, date.getHours(), 0, 23) &&
-    matchesCronField(dayOfMonth, date.getDate(), 1, 31) &&
-    matchesCronField(month, date.getMonth() + 1, 1, 12) &&
-    matchesCronField(dayOfWeek, date.getDay(), 0, 6)
-  );
-}
-
-function matchesCronField(field: string, value: number, min: number, max: number) {
-  return field.split(",").some((part) => matchesCronPart(part.trim(), value, min, max));
-}
-
-function matchesCronPart(part: string, value: number, min: number, max: number): boolean {
-  if (part === "*") {
-    return true;
-  }
-
-  const stepMatch = part.match(/^\*\/(\d+)$/);
-  if (stepMatch) {
-    const step = Number(stepMatch[1]);
-    return Number.isInteger(step) && step > 0 ? (value - min) % step === 0 : false;
-  }
-
-  const rangeMatch = part.match(/^(\d+)-(\d+)$/);
-  if (rangeMatch) {
-    const start = Number(rangeMatch[1]);
-    const end = Number(rangeMatch[2]);
-    return start <= value && value <= end;
-  }
-
-  const exact = Number(part);
-  return Number.isInteger(exact) && exact >= min && exact <= max && exact === value;
-}