bopodev-agent-sdk 0.1.11 → 0.1.13

package/src/adapters.ts

@@ -10,7 +10,13 @@ import type {
   HeartbeatContext
 } from "./types";
 import { ExecutionOutcomeSchema, type ExecutionOutcome } from "bopodev-contracts";
-import { checkRuntimeCommandHealth, executeAgentRuntime, executePromptRuntime } from "./runtime";
+import { checkRuntimeCommandHealth, executeAgentRuntime, executePromptRuntime } from "./runtime-core";
+import {
+  executeDirectApiRuntime,
+  probeDirectApiEnvironment,
+  resolveDirectApiCredentials,
+  type DirectApiProvider
+} from "./runtime-http";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 
@@ -79,6 +85,28 @@ export class OpenCodeAdapter implements AgentAdapter {
   }
 }
 
+export class OpenAIApiAdapter implements AgentAdapter {
+  providerType = "openai_api" as const;
+
+  async execute(context: HeartbeatContext): Promise<AdapterExecutionResult> {
+    if (context.workItems.length === 0) {
+      return createSkippedResult("OpenAI API", "openai_api", context);
+    }
+    return runDirectApiWork(context, "openai_api");
+  }
+}
+
+export class AnthropicApiAdapter implements AgentAdapter {
+  providerType = "anthropic_api" as const;
+
+  async execute(context: HeartbeatContext): Promise<AdapterExecutionResult> {
+    if (context.workItems.length === 0) {
+      return createSkippedResult("Anthropic API", "anthropic_api", context);
+    }
+    return runDirectApiWork(context, "anthropic_api");
+  }
+}
+
 export class GenericHeartbeatAdapter implements AgentAdapter {
   constructor(public providerType: "http" | "shell") {}
 
@@ -268,6 +296,24 @@ const staticMetadata: AdapterMetadata[] = [
     supportsThinkingEffort: false,
     requiresRuntimeCwd: true
   },
+  {
+    providerType: "openai_api",
+    label: "OpenAI API",
+    supportsModelSelection: true,
+    supportsEnvironmentTest: true,
+    supportsWebSearch: false,
+    supportsThinkingEffort: false,
+    requiresRuntimeCwd: false
+  },
+  {
+    providerType: "anthropic_api",
+    label: "Anthropic API",
+    supportsModelSelection: true,
+    supportsEnvironmentTest: true,
+    supportsWebSearch: false,
+    supportsThinkingEffort: false,
+    requiresRuntimeCwd: false
+  },
   {
     providerType: "http",
     label: "HTTP",
@@ -288,6 +334,8 @@ const staticMetadata: AdapterMetadata[] = [
   }
 ];
 
+const metadataByProviderType = new Map(staticMetadata.map((entry) => [entry.providerType, entry] as const));
+
 const modelCatalog: Record<Exclude<AgentProviderType, "http" | "shell">, AdapterModelOption[]> = {
   codex: [
     { id: "gpt-5.3-codex", label: "GPT-5.3 Codex" },
@@ -312,13 +360,33 @@ const modelCatalog: Record<Exclude<AgentProviderType, "http" | "shell">, Adapter
     { id: "sonnet-4.5", label: "sonnet-4.5" },
     { id: "opus-4.6", label: "opus-4.6" }
   ],
-  opencode: []
+  opencode: [],
+  openai_api: [
+    { id: "gpt-5", label: "GPT-5" },
+    { id: "gpt-5-mini", label: "GPT-5 Mini" },
+    { id: "gpt-5-nano", label: "GPT-5 Nano" },
+    { id: "o3", label: "o3" },
+    { id: "o4-mini", label: "o4-mini" }
+  ],
+  anthropic_api: [
+    { id: "claude-opus-4-6", label: "Claude Opus 4.6" },
+    { id: "claude-sonnet-4-5-20250929", label: "Claude Sonnet 4.5" },
+    { id: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5" }
+  ]
 };
 
 export function listAdapterMetadata(): AdapterMetadata[] {
   return staticMetadata;
 }
 
+export function getAdapterMetadataByProviderType(providerType: AgentProviderType): AdapterMetadata {
+  const metadata = metadataByProviderType.get(providerType);
+  if (!metadata) {
+    throw new Error(`Missing adapter metadata for provider: ${providerType}`);
+  }
+  return metadata;
+}
+
 export async function listAdapterModels(
   providerType: AgentProviderType,
   runtime?: AgentRuntimeConfig
@@ -331,7 +399,7 @@ export async function listAdapterModels(
     return dedupeModels([...discovered, ...modelCatalog.cursor]);
   }
   if (providerType === "opencode") {
-    const discovered = await discoverOpenCodeModels(runtime);
+    const discovered = await discoverOpenCodeModelsCached(runtime);
     return dedupeModels(discovered);
   }
   return modelCatalog[providerType];
@@ -342,6 +410,9 @@ export async function testAdapterEnvironment(
   runtime?: AgentRuntimeConfig
 ): Promise<AdapterEnvironmentResult> {
   const checks: AdapterEnvironmentCheck[] = [];
+  if (providerType === "openai_api" || providerType === "anthropic_api") {
+    return testDirectApiEnvironment(providerType, runtime);
+  }
   const command =
     providerType === "cursor"
       ? (await resolveCursorLaunchConfig(runtime)).command
@@ -433,7 +504,7 @@ export async function testAdapterEnvironment(
   };
 }
 
-function createSkippedResult(providerLabel: string, providerKey: string, context: HeartbeatContext): AdapterExecutionResult {
+export function createSkippedResult(providerLabel: string, providerKey: string, context: HeartbeatContext): AdapterExecutionResult {
   return {
     status: "skipped",
     summary: `${providerLabel} adapter: ${summarizeWork(context)}`,
@@ -452,7 +523,148 @@ function createSkippedResult(providerLabel: string, providerKey: string, context
   };
 }
 
-async function runProviderWork(
+export async function runDirectApiWork(
+  context: HeartbeatContext,
+  provider: "openai_api" | "anthropic_api"
+): Promise<AdapterExecutionResult> {
+  const prompt = createPrompt(context);
+  const runtime = await executeDirectApiRuntime(provider, prompt, context.runtime);
+  if (runtime.ok) {
+    return {
+      status: "ok",
+      summary: runtime.summary ?? `${provider} runtime finished in ${runtime.elapsedMs}ms.`,
+      tokenInput: runtime.tokenInput ?? 0,
+      tokenOutput: runtime.tokenOutput ?? 0,
+      usdCost: runtime.usdCost ?? 0,
+      outcome: toOutcome({
+        kind: "completed",
+        issueIdsTouched: issueIdsTouched(context),
+        actions: [{ type: "runtime.execute", status: "ok", detail: `${provider} runtime completed.` }],
+        blockers: [],
+        artifacts: [],
+        nextSuggestedState: "in_review"
+      }),
+      trace: {
+        command: runtime.endpoint,
+        cwd: context.runtime?.cwd,
+        exitCode: runtime.statusCode,
+        elapsedMs: runtime.elapsedMs,
+        failureType: runtime.failureType,
+        usageSource: "structured",
+        attemptCount: runtime.attemptCount,
+        attempts: runtime.attempts.map((attempt) => ({
+          attempt: attempt.attempt,
+          code: attempt.statusCode || null,
+          timedOut: attempt.failureType === "timeout",
+          elapsedMs: attempt.elapsedMs,
+          signal: null,
+          forcedKill: false
+        })),
+        stdoutPreview: runtime.responsePreview
+      },
+      nextState: withProviderMetadata(context, provider, runtime.elapsedMs, runtime.statusCode)
+    };
+  }
+  const failureDetail = runtime.error ?? "direct API request failed";
+  return {
+    status: "failed",
+    summary: `${provider} runtime failed: ${failureDetail}`,
+    tokenInput: 0,
+    tokenOutput: 0,
+    usdCost: 0,
+    outcome: toOutcome({
+      kind: "failed",
+      issueIdsTouched: issueIdsTouched(context),
+      actions: [{ type: "runtime.execute", status: "error", detail: failureDetail }],
+        blockers: [{
+          code: runtime.failureType ?? "runtime_failed",
+          message: failureDetail,
+          retryable: runtime.failureType !== "auth" && runtime.failureType !== "bad_response"
+        }],
+      artifacts: [],
+      nextSuggestedState: "blocked"
+    }),
+    trace: {
+      command: runtime.endpoint,
+      cwd: context.runtime?.cwd,
+      exitCode: runtime.statusCode || null,
+      elapsedMs: runtime.elapsedMs,
+      failureType: runtime.failureType,
+      usageSource: "none",
+      attemptCount: runtime.attemptCount,
+      attempts: runtime.attempts.map((attempt) => ({
+        attempt: attempt.attempt,
+        code: attempt.statusCode || null,
+        timedOut: attempt.failureType === "timeout",
+        elapsedMs: attempt.elapsedMs,
+        signal: null,
+        forcedKill: false
+      })),
+      stderrPreview: runtime.error,
+      stdoutPreview: runtime.responsePreview
+    },
+    nextState: context.state
+  };
+}
+
+export async function testDirectApiEnvironment(
+  providerType: DirectApiProvider,
+  runtime?: AgentRuntimeConfig
+): Promise<AdapterEnvironmentResult> {
+  const checks: AdapterEnvironmentCheck[] = [];
+  const credentials = resolveDirectApiCredentials(providerType, runtime);
+  if (!credentials.key) {
+    checks.push({
+      code: "api_key_missing",
+      level: "error",
+      message: `${providerType} API key is missing.`,
+      hint:
+        providerType === "openai_api"
+          ? "Set OPENAI_API_KEY or BOPO_OPENAI_API_KEY in runtime env or host environment."
+          : "Set ANTHROPIC_API_KEY or BOPO_ANTHROPIC_API_KEY in runtime env or host environment."
+    });
+    return {
+      providerType,
+      status: "fail",
+      testedAt: new Date().toISOString(),
+      checks
+    };
+  }
+  checks.push({
+    code: "api_key_present",
+    level: "info",
+    message: "API key is present."
+  });
+  checks.push({
+    code: "base_url",
+    level: "info",
+    message: `Using base URL: ${credentials.baseUrl}`
+  });
+  const probe = await probeDirectApiEnvironment(providerType, runtime);
+  if (probe.ok) {
+    checks.push({
+      code: "api_probe_ok",
+      level: "info",
+      message: `${providerType} API probe succeeded.`
+    });
+  } else {
+    checks.push({
+      code: "api_probe_failed",
+      level: probe.statusCode === 401 || probe.statusCode === 403 ? "error" : "warn",
+      message: `${providerType} API probe failed.`,
+      detail: probe.message,
+      hint: probe.statusCode === 401 || probe.statusCode === 403 ? "Verify API key and organization/project access." : undefined
+    });
+  }
+  return {
+    providerType,
+    status: toEnvironmentStatus(checks),
+    testedAt: new Date().toISOString(),
+    checks
+  };
+}
+
+export async function runProviderWork(
   context: HeartbeatContext,
   provider: "claude_code" | "codex",
   pricing: { inputRate: number; outputRate: number }
@@ -615,12 +827,13 @@ async function runProviderWork(
   };
 }
 
-async function runCursorWork(context: HeartbeatContext): Promise<AdapterExecutionResult> {
+export async function runCursorWork(context: HeartbeatContext): Promise<AdapterExecutionResult> {
   const prompt = createPrompt(context);
   const cursorLaunch = await resolveCursorLaunchConfig(context.runtime);
   const cwd = context.runtime?.cwd?.trim() || process.cwd();
   const resumeState = resolveCursorResumeState(context.state, cwd);
-  const runtimeTimeoutMs = context.runtime?.timeoutMs && context.runtime.timeoutMs > 0 ? context.runtime.timeoutMs : 30_000;
+  const runtimeTimeoutMs =
+    context.runtime?.timeoutMs && context.runtime.timeoutMs > 0 ? context.runtime.timeoutMs : 15 * 60 * 1000;
   const buildArgs = (resumeSessionId: string | null) => {
     const baseArgs = [...cursorLaunch.prefixArgs, "-p", "--output-format", "stream-json", "--workspace", cwd];
     if (resumeSessionId) {
@@ -685,9 +898,11 @@ async function runCursorWork(context: HeartbeatContext): Promise<AdapterExecutio
   });
 }
 
-async function runOpenCodeWork(context: HeartbeatContext): Promise<AdapterExecutionResult> {
+export async function runOpenCodeWork(context: HeartbeatContext): Promise<AdapterExecutionResult> {
   const prompt = createPrompt(context);
   const model = context.runtime?.model?.trim();
+  const runtimeTimeoutMs =
+    context.runtime?.timeoutMs && context.runtime.timeoutMs > 0 ? context.runtime.timeoutMs : 5 * 60 * 1000;
   if (!model) {
     return {
       status: "failed",
@@ -706,6 +921,32 @@ async function runOpenCodeWork(context: HeartbeatContext): Promise<AdapterExecut
       nextState: context.state
     };
   }
+  try {
+    await ensureOpenCodeModelConfiguredAndAvailable({
+      model,
+      command: context.runtime?.command,
+      cwd: context.runtime?.cwd,
+      env: context.runtime?.env
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "OpenCode model validation failed.";
+    return {
+      status: "failed",
+      summary: message,
+      tokenInput: 0,
+      tokenOutput: 0,
+      usdCost: 0,
+      outcome: toOutcome({
+        kind: "blocked",
+        issueIdsTouched: issueIdsTouched(context),
+        actions: [{ type: "runtime.validate", status: "error", detail: message }],
+        blockers: [{ code: "model_unavailable", message, retryable: false }],
+        artifacts: [],
+        nextSuggestedState: "blocked"
+      }),
+      nextState: context.state
+    };
+  }
   const resumeSessionId = context.state.sessionId?.trim();
   const baseArgs = ["run", "--format", "json", "--model", model];
   if (resumeSessionId) {
@@ -716,6 +957,7 @@ async function runOpenCodeWork(context: HeartbeatContext): Promise<AdapterExecut
     prompt,
     {
       ...context.runtime,
+      timeoutMs: runtimeTimeoutMs,
       args: [...baseArgs, ...(context.runtime?.args ?? [])]
     },
     { provider: "opencode" }
@@ -727,6 +969,7 @@ async function runOpenCodeWork(context: HeartbeatContext): Promise<AdapterExecut
       prompt,
       {
         ...context.runtime,
+        timeoutMs: runtimeTimeoutMs,
         args: ["run", "--format", "json", "--model", model, ...(context.runtime?.args ?? [])]
       },
       { provider: "opencode" }
@@ -744,7 +987,7 @@ async function runOpenCodeWork(context: HeartbeatContext): Promise<AdapterExecut
   });
 }
 
-function resolveFailedUsage(
+export function resolveFailedUsage(
   runtime: {
     parsedUsage?: {
       tokenInput?: number;
@@ -786,7 +1029,7 @@ function resolveFailedUsage(
   };
 }
 
-function toProviderResult(
+export function toProviderResult(
   context: HeartbeatContext,
   provider: AgentProviderType,
   prompt: string,
@@ -979,7 +1222,7 @@ function toProviderResult(
   };
 }
 
-function resolveRuntimeFailureDetail(runtime: {
+export function resolveRuntimeFailureDetail(runtime: {
   stderr: string;
   stdout: string;
   code: number | null;
@@ -1010,7 +1253,7 @@ function resolveRuntimeFailureDetail(runtime: {
   return "runtime exited without diagnostic output.";
 }
 
-function parseOpenCodeOutput(stdout: string) {
+export function parseOpenCodeOutput(stdout: string) {
   let sessionId: string | null = null;
   for (const line of stdout.split(/\r?\n/)) {
     const trimmed = line.trim();
@@ -1031,7 +1274,7 @@ function parseOpenCodeOutput(stdout: string) {
   return { sessionId };
 }
 
-function resolveCursorResumeState(state: HeartbeatContext["state"], cwd: string) {
+export function resolveCursorResumeState(state: HeartbeatContext["state"], cwd: string) {
   const savedSessionId = state.cursorSession?.sessionId?.trim() || state.sessionId?.trim() || null;
   const savedCwd = state.cursorSession?.cwd?.trim() || state.cwd?.trim() || null;
   if (!savedSessionId) {
@@ -1055,7 +1298,7 @@ function resolveCursorResumeState(state: HeartbeatContext["state"], cwd: string)
   };
 }
 
-function readRuntimeSessionId(
+export function readRuntimeSessionId(
   runtime: {
     structuredOutputDiagnostics?: {
       claudeSessionId?: string;
@@ -1067,7 +1310,7 @@ function readRuntimeSessionId(
   return runtime.structuredOutputDiagnostics?.cursorSessionId?.trim() || runtime.structuredOutputDiagnostics?.claudeSessionId?.trim() || fallback;
 }
 
-function isUnknownSessionError(stderr: string, stdout: string) {
+export function isUnknownSessionError(stderr: string, stdout: string) {
   const haystack = `${stderr}\n${stdout}`.toLowerCase();
   return (
     haystack.includes("unknown session") ||
@@ -1076,11 +1319,11 @@ function isUnknownSessionError(stderr: string, stdout: string) {
   );
 }
 
-function hasTrustFlag(args: string[]) {
+export function hasTrustFlag(args: string[]) {
   return args.includes("--trust") || args.includes("--yolo") || args.includes("-f");
 }
 
-function resolveRuntimeCommand(providerType: AgentProviderType, runtime?: AgentRuntimeConfig) {
+export function resolveRuntimeCommand(providerType: AgentProviderType, runtime?: AgentRuntimeConfig) {
   if (runtime?.command?.trim()) return runtime.command.trim();
   if (providerType === "claude_code") return "claude";
   if (providerType === "codex") return "codex";
@@ -1089,7 +1332,7 @@ function resolveRuntimeCommand(providerType: AgentProviderType, runtime?: AgentR
   return providerType;
 }
 
-async function runRuntimeProbe(providerType: AgentProviderType, runtime?: AgentRuntimeConfig) {
+export async function runRuntimeProbe(providerType: AgentProviderType, runtime?: AgentRuntimeConfig) {
   const prompt = "Respond with hello.";
   if (providerType === "claude_code" || providerType === "codex") {
     return executeAgentRuntime(providerType, prompt, {
@@ -1136,7 +1379,7 @@ async function runRuntimeProbe(providerType: AgentProviderType, runtime?: AgentR
   });
 }
 
-async function discoverCursorModels(runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]> {
+export async function discoverCursorModels(runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]> {
   const cursorLaunch = await resolveCursorLaunchConfig(runtime);
   const probe = await executePromptRuntime(
     cursorLaunch.command,
@@ -1155,25 +1398,98 @@ async function discoverCursorModels(runtime?: AgentRuntimeConfig): Promise<Adapt
   return parseModelLines(`${probe.stdout}\n${probe.stderr}`);
 }
 
-async function discoverOpenCodeModels(runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]> {
+export async function discoverOpenCodeModels(runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]> {
   const probe = await executePromptRuntime(
     resolveRuntimeCommand("opencode", runtime),
-    "models",
+    "",
     {
       ...runtime,
       args: ["models"],
-      timeoutMs: 10_000,
+      timeoutMs: 120_000,
       retryCount: 0
     },
     { provider: "opencode" }
   );
-  if (!probe.ok && !probe.stdout.trim()) {
+  if (!probe.ok && !probe.stdout.trim() && !probe.stderr.trim()) {
     return [];
   }
-  return parseModelLines(probe.stdout).filter((entry) => entry.id.includes("/"));
+  return parseModelLines(`${probe.stdout}\n${probe.stderr}`).filter((entry) => entry.id.includes("/"));
+}
+
+const OPENCODE_MODEL_DISCOVERY_TTL_MS = 60_000;
+const openCodeModelDiscoveryCache = new Map<string, { expiresAt: number; models: AdapterModelOption[] }>();
+
+function normalizeRuntimeEnv(env: unknown): Record<string, string> {
+  if (!env || typeof env !== "object" || Array.isArray(env)) {
+    return {};
+  }
+  const out: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env as Record<string, unknown>)) {
+    if (typeof value === "string") {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+
+function openCodeModelCacheKey(runtime?: AgentRuntimeConfig) {
+  const command = resolveRuntimeCommand("opencode", runtime);
+  const cwd = runtime?.cwd?.trim() || process.cwd();
+  const env = normalizeRuntimeEnv(runtime?.env);
+  const envSignature = Object.entries(env)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([key, value]) => `${key}=${value}`)
+    .join("\n");
+  return `${command}\n${cwd}\n${envSignature}`;
+}
+
+export async function discoverOpenCodeModelsCached(runtime?: AgentRuntimeConfig): Promise<AdapterModelOption[]> {
+  const key = openCodeModelCacheKey(runtime);
+  const now = Date.now();
+  for (const [cacheKey, cacheValue] of openCodeModelDiscoveryCache.entries()) {
+    if (cacheValue.expiresAt <= now) {
+      openCodeModelDiscoveryCache.delete(cacheKey);
+    }
+  }
+  const cached = openCodeModelDiscoveryCache.get(key);
+  if (cached && cached.expiresAt > now) {
+    return cached.models;
+  }
+  const models = await discoverOpenCodeModels(runtime);
+  openCodeModelDiscoveryCache.set(key, {
+    expiresAt: now + OPENCODE_MODEL_DISCOVERY_TTL_MS,
+    models
+  });
+  return models;
+}
+
+export async function ensureOpenCodeModelConfiguredAndAvailable(input: {
+  model?: string;
+  command?: string;
+  cwd?: string;
+  env?: Record<string, string>;
+}) {
+  const normalizedModel = input.model?.trim();
+  if (!normalizedModel) {
+    throw new Error("OpenCode requires runtimeModel in provider/model format.");
+  }
+  const models = await discoverOpenCodeModelsCached({
+    command: input.command,
+    cwd: input.cwd,
+    env: input.env
+  });
+  if (models.length === 0) {
+    throw new Error("OpenCode returned no models. Run `opencode models` and verify provider auth.");
+  }
+  if (!models.some((entry) => entry.id === normalizedModel)) {
+    const sample = models.slice(0, 12).map((entry) => entry.id).join(", ");
+    throw new Error(
+      `Configured OpenCode model is unavailable: ${normalizedModel}. Available models: ${sample}${models.length > 12 ? ", ..." : ""}`
+    );
+  }
 }
 
-function parseModelLines(text: string): AdapterModelOption[] {
+export function parseModelLines(text: string): AdapterModelOption[] {
   const out: AdapterModelOption[] = [];
   const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
   for (const line of lines) {
@@ -1203,7 +1519,7 @@ function parseModelLines(text: string): AdapterModelOption[] {
   return dedupeModels(out);
 }
 
-function dedupeModels(models: AdapterModelOption[]) {
+export function dedupeModels(models: AdapterModelOption[]) {
   const seen = new Set<string>();
   const deduped: AdapterModelOption[] = [];
   for (const model of models) {
@@ -1215,7 +1531,7 @@ function dedupeModels(models: AdapterModelOption[]) {
   return deduped;
 }
 
-async function resolveCursorLaunchConfig(runtime?: AgentRuntimeConfig): Promise<{ command: string; prefixArgs: string[] }> {
+export async function resolveCursorLaunchConfig(runtime?: AgentRuntimeConfig): Promise<{ command: string; prefixArgs: string[] }> {
   const configuredCommand = runtime?.command?.trim();
   if (configuredCommand) {
     const commandToken = configuredCommand.split(/[\\/]/).pop()?.toLowerCase() ?? configuredCommand.toLowerCase();
@@ -1256,13 +1572,13 @@ async function resolveCursorLaunchConfig(runtime?: AgentRuntimeConfig): Promise<
   return { command: "agent", prefixArgs: [] };
 }
 
-function toEnvironmentStatus(checks: AdapterEnvironmentCheck[]): "pass" | "warn" | "fail" {
+export function toEnvironmentStatus(checks: AdapterEnvironmentCheck[]): "pass" | "warn" | "fail" {
   if (checks.some((check) => check.level === "error")) return "fail";
   if (checks.some((check) => check.level === "warn")) return "warn";
   return "pass";
 }
 
-function createPrompt(context: HeartbeatContext) {
+export function createPrompt(context: HeartbeatContext) {
   const bootstrapPrompt = context.runtime?.bootstrapPrompt?.trim();
   const companyGoals = context.goalContext?.companyGoals.length
     ? context.goalContext.companyGoals.map((goal) => `- ${goal}`).join("\n")
@@ -1283,13 +1599,33 @@ function createPrompt(context: HeartbeatContext) {
             item.priority ? `  Priority: ${item.priority}` : null,
             item.body ? `  Body: ${item.body}` : null,
             item.labels?.length ? `  Labels: ${item.labels.join(", ")}` : null,
-            item.tags?.length ? `  Tags: ${item.tags.join(", ")}` : null
+            item.tags?.length ? `  Tags: ${item.tags.join(", ")}` : null,
+            item.attachments?.length
+              ? [
+                  "  Attachments:",
+                  ...item.attachments.map((attachment) =>
+                    `    - ${attachment.fileName} | path: ${attachment.absolutePath} | relative: ${attachment.relativePath}`
+                  )
+                ].join("\n")
+              : null
           ]
             .filter(Boolean)
             .join("\n")
         )
         .join("\n")
     : "- No assigned work";
+  const memoryContext = context.memoryContext;
+  const memoryTacitNotes = memoryContext?.tacitNotes?.trim()
+    ? memoryContext.tacitNotes.trim()
+    : "No tacit notes were recorded yet.";
+  const memoryDurableFacts =
+    memoryContext?.durableFacts && memoryContext.durableFacts.length > 0
+      ? memoryContext.durableFacts.map((fact) => `- ${fact}`).join("\n")
+      : "- No durable facts available.";
+  const memoryDailyNotes =
+    memoryContext?.dailyNotes && memoryContext.dailyNotes.length > 0
+      ? memoryContext.dailyNotes.map((note) => `- ${note}`).join("\n")
+      : "- No recent daily notes.";
 
   const executionDirectives = [
     "Execution directives:",
@@ -1299,11 +1635,15 @@ function createPrompt(context: HeartbeatContext) {
     "- Prefer completing assigned issue work in this repository over non-essential coordination tasks.",
     "- Keep command usage minimal and task-focused; avoid broad repository scans unless strictly required for the assigned issue.",
     "- Shell commands run under zsh on macOS; avoid Bash-only features such as `local -n`, `declare -n`, `mapfile`, and `readarray`.",
-    "- Prefer POSIX/zsh-compatible shell snippets, direct `curl` headers, `jq`, and temp JSON files/heredocs.",
+    "- Prefer POSIX/zsh-compatible shell snippets, direct `curl` headers, and `jq`.",
+    "- Prefer heredoc/stdin payloads (for example `curl --data-binary @- <<'JSON' ... JSON`) so cleanup is not blocked by runtime policy.",
+    "- If payload files are required, write under `agents/<agent-id>/tmp/` (or OS temp via `mktemp`) and do not treat cleanup command failures as task blockers.",
     "- If control-plane API connectivity fails, report the exact failing command/error once and stop retry loops for the same endpoint.",
     "- If any command fails, avoid further exploratory commands and still return the required final JSON summary.",
     "- Do not stop after planning. You must execute concrete steps for assigned issues in this run (file edits, API calls, or other verifiable actions).",
     "- If you cannot complete concrete execution, set summary to include the blocker explicitly instead of claiming success.",
+    "- Treat file memory as source of truth for long-term context: append raw observations to daily notes first, then promote stable patterns to durable facts.",
+    "- Avoid writing duplicate durable facts when existing memory already contains the same lesson.",
     "- Your final output must be only the JSON object below, with no prose before or after it.",
     "- Do not invent token or cost values; the runtime records usage separately."
   ].join("\n");
@@ -1326,6 +1666,15 @@ ${agentGoals}
 Assigned issues:
 ${workItems}
 
+Memory context:
+- Memory root: ${memoryContext?.memoryRoot ?? "Unavailable"}
+- Tacit notes:
+${memoryTacitNotes}
+- Durable facts:
+${memoryDurableFacts}
+- Recent daily notes:
+${memoryDailyNotes}
+
 ${executionDirectives}
 
 At the end of your response, output exactly one JSON object on a single line and nothing else:
@@ -1333,7 +1682,7 @@ At the end of your response, output exactly one JSON object on a single line and
 `;
 }
 
-function withProviderMetadata(
+export function withProviderMetadata(
   context: HeartbeatContext,
   provider: string,
   lastRuntimeMs?: number,
@@ -1351,7 +1700,7 @@ function withProviderMetadata(
   };
 }
 
-function applyProviderSessionState(
+export function applyProviderSessionState(
   context: HeartbeatContext,
   provider: AgentProviderType,
   sessionUpdate?: ProviderSessionUpdate,
@@ -1385,14 +1734,14 @@ function applyProviderSessionState(
   return nextState;
 }
 
-function toPreview(value: string, max = 1600) {
+export function toPreview(value: string, max = 1600) {
   if (value.length <= max) {
     return value;
   }
   return `${value.slice(0, max)}\n...[truncated]`;
 }
 
-function buildMissingStructuredOutputDetail(
+export function buildMissingStructuredOutputDetail(
   provider: string,
   runtime: {
     structuredOutputSource?: "stdout" | "stderr";
@@ -1476,7 +1825,7 @@ function buildMissingStructuredOutputDetail(
   return hints.length > 0 ? `${base} Diagnostics: ${[...hints, ...diagnostics].join("; ")}.` : `${base} Diagnostics: ${diagnostics.join("; ")}.`;
 }
 
-function isClaudeRunIncomplete(runtime: {
+export function isClaudeRunIncomplete(runtime: {
   structuredOutputDiagnostics?: {
     claudeStopReason?: string;
     claudeResultSubtype?: string;