@desplega.ai/agent-swarm 1.85.0 → 1.87.0

package/src/be/modelsdev-cache.ts

@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+export interface ModelsDevCostBlock {
+  input?: number;
+  output?: number;
+  cache_read?: number;
+  cache_write?: number;
+}
+
+export interface ModelsDevModel {
+  id?: string;
+  cost?: ModelsDevCostBlock;
+}
+
+export interface ModelsDevProvider {
+  models?: Record<string, ModelsDevModel>;
+}
+
+export type ModelsDevCache = Record<string, ModelsDevProvider>;
+
+export const MODELSDEV_CACHE_PATH = path.join("src", "be", "modelsdev-cache.json");
+
+/**
+ * Resolve the vendored models.dev cache from source checkouts and compiled
+ * Docker images. The API image copies the snapshot to `/app/src/be/...`.
+ */
+export function loadModelsDevCache(): ModelsDevCache | null {
+  const explicitPath = process.env.MODELSDEV_CACHE_PATH;
+  const candidates = [
+    ...(explicitPath ? [explicitPath] : []),
+    path.join(process.cwd(), MODELSDEV_CACHE_PATH),
+    path.join(process.cwd(), "..", MODELSDEV_CACHE_PATH),
+    path.join("/app", MODELSDEV_CACHE_PATH),
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(readFileSync(candidate, "utf-8")) as ModelsDevCache;
+    } catch {
+      // try next candidate
+    }
+  }
+
+  return null;
+}

package/src/be/seed-pricing.ts

@@ -1,7 +1,7 @@
 /**
  * Phase 2 of the cost-tracking plan — seed the `pricing` table at server boot.
  *
- * The vendored models.dev snapshot at `ui/src/lib/modelsdev-cache.json` is the
+ * The vendored models.dev snapshot at `src/be/modelsdev-cache.json` is the
  * single source of truth for per-token rates. We project it into rows keyed by
  * `(provider, model, token_class)` so the recompute path in
  * `src/http/session-data.ts` can rebuild USD from tokens regardless of which
@@ -17,30 +17,15 @@
  * admin route (`POST /api/pricing`) — we don't overwrite seed rows.
  */
 
-import { readFileSync } from "node:fs";
-import path from "node:path";
 import type { PricingProvider, PricingTokenClass } from "../types";
 import { getDb } from "./db";
+import {
+  loadModelsDevCache,
+  type ModelsDevCache,
+  type ModelsDevCostBlock,
+} from "./modelsdev-cache";
 import { normalizeModelKey } from "./pricing-normalize";
 
-interface ModelsDevCostBlock {
-  input?: number;
-  output?: number;
-  cache_read?: number;
-  cache_write?: number;
-}
-
-interface ModelsDevModel {
-  id?: string;
-  cost?: ModelsDevCostBlock;
-}
-
-interface ModelsDevProvider {
-  models?: Record<string, ModelsDevModel>;
-}
-
-type ModelsDevCache = Record<string, ModelsDevProvider>;
-
 /**
  * Per-harness manual rates that models.dev doesn't carry. Keep the source URL
  * and a verification date next to each entry so {@link MANUAL_PRICING_OVERRIDES}
@@ -82,33 +67,11 @@ const MANUAL_PRICING_OVERRIDES: Array<{
  * fields the models.dev snapshot doesn't index directly; we map them here.
  */
 const ANTHROPIC_SHORTNAME_TO_MODELSDEV: Record<string, string> = {
-  opus: "claude-opus-4-7",
+  opus: "claude-opus-4-8",
   sonnet: "claude-sonnet-4-6",
   haiku: "claude-haiku-4-5",
 };
 
-/**
- * Resolve the path to the vendored models.dev cache. The UI copy is canonical.
- * We treat this as best-effort: if the file is missing (developer ran the
- * server without `ui/` checked out), we log and continue with manual rates
- * only — better than crashing the boot.
- */
-function loadModelsDevCache(): ModelsDevCache | null {
-  const candidates = [
-    path.join(process.cwd(), "ui", "src", "lib", "modelsdev-cache.json"),
-    path.join(process.cwd(), "..", "ui", "src", "lib", "modelsdev-cache.json"),
-  ];
-  for (const cand of candidates) {
-    try {
-      const raw = readFileSync(cand, "utf-8");
-      return JSON.parse(raw) as ModelsDevCache;
-    } catch {
-      // try next candidate
-    }
-  }
-  return null;
-}
-
 interface PricingSeedRow {
   provider: PricingProvider;
   model: string;

package/src/cli.tsx

@@ -16,8 +16,12 @@ import { getApiKey, setApiKey } from "./utils/api-key.ts";
 // Get CLI name from bin field (assumes single key)
 const binName = Object.keys(pkg.bin)[0];
 
-// Restore cursor on exit
-const restoreCursor = () => process.stdout.write("\x1B[?25h");
+// Restore cursor on exit — only when stdout is a TTY.  Non-TTY invocations
+// (like the codex-session-runner subprocess whose stdout is a JSON pipe)
+// must not inject terminal escape sequences into the byte stream.
+const restoreCursor = () => {
+  if (process.stdout.isTTY) process.stdout.write("\x1B[?25h");
+};
 process.on("exit", restoreCursor);
 process.on("SIGINT", () => {
   restoreCursor();
@@ -288,6 +292,27 @@ const COMMAND_HELP: Record<
       `  ${binName} claude-managed-setup --api-url https://swarm.example.com`,
     ].join("\n"),
   },
+  e2b: {
+    usage: `${binName} e2b <subcommand> [options]`,
+    description:
+      "Build Agent Swarm E2B templates and start API/worker sandboxes on demand for CI or Dockerless environments.",
+    options: [
+      "  build-template --role api|worker    Build or rebuild an E2B template",
+      "  delete-template <template...>        Delete E2B templates",
+      "  publish-template <template...>       Publish E2B templates",
+      "  unpublish-template <template...>     Make E2B templates private",
+      "  start-api --template <name>          Start the API in an E2B sandbox",
+      "  start-worker --api-url <url>         Start a worker against a public API URL",
+      "  start-stack                         Start API plus one or more workers",
+      "  list | kill <sandbox-id...>          Inspect or clean up sandboxes",
+      "  -h, --help                          Show this help",
+    ].join("\n"),
+    examples: [
+      `  ${binName} e2b build-template --role worker`,
+      `  ${binName} e2b start-worker --api-url https://swarm.example.com --api-key "$SWARM_API_KEY"`,
+      `  ${binName} e2b start-stack --workers 2 --api-key "$SWARM_API_KEY"`,
+    ].join("\n"),
+  },
 };
 
 function printHelp(command?: string) {
@@ -319,6 +344,7 @@ function printHelp(command?: string) {
     ["docs", "Open documentation (--open to launch in browser)"],
     ["codex-login", "Authenticate Codex via ChatGPT OAuth"],
     ["claude-managed-setup", "Bootstrap Anthropic Managed Agents (agent + env + skills)"],
+    ["e2b", "Build templates and start E2B API/worker sandboxes"],
     ["version", "Show version number"],
     ["help", "Show this help message"],
   ];
@@ -570,10 +596,20 @@ if (args.showHelp || args.command === "help" || args.command === undefined) {
   const { runCodexLogin } = await import("./commands/codex-login");
   const codexLoginArgs = process.argv.slice(process.argv.indexOf("codex-login") + 1);
   await runCodexLogin(codexLoginArgs);
+} else if (args.command === "codex-session-runner") {
+  // Internal subcommand — invoked by CodexSubprocessSession to host a single
+  // codex session in a throwaway subprocess. See src/commands/codex-session-runner.ts
+  // for the rationale (Picateclas spawn-OOM permanent fix, 2026-05-28).
+  const { runCodexSessionRunner } = await import("./commands/codex-session-runner");
+  await runCodexSessionRunner();
 } else if (args.command === "claude-managed-setup") {
   const { runClaudeManagedSetup } = await import("./commands/claude-managed-setup");
   const setupArgs = process.argv.slice(process.argv.indexOf("claude-managed-setup") + 1);
   await runClaudeManagedSetup(setupArgs);
+} else if (args.command === "e2b") {
+  const { runE2BCommand } = await import("./commands/e2b");
+  const e2bArgs = process.argv.slice(process.argv.indexOf("e2b") + 1);
+  await runE2BCommand(e2bArgs);
 } else {
   render(<App args={args} />);
 }

package/src/commands/codex-session-runner.ts

@@ -0,0 +1,132 @@
+/**
+ * Codex session subprocess runner.
+ *
+ * Entry point for the `codex-session-runner` CLI subcommand. Reads a
+ * `CodexSubprocessInput` payload from stdin, drives a fresh in-process
+ * `CodexSession`, and pipes the session's `ProviderEvent` stream + final
+ * `ProviderResult` back to its parent over stdout as line-delimited JSON.
+ *
+ * Why this exists: the previous architecture ran every codex session
+ * directly inside the long-lived worker runner. The `@openai/codex-sdk`
+ * leaks SDK state (parsers, transcript buffers, JSON-RPC plumbing) into
+ * the runner's heap, and after ~1,500 task completions on a hot worker
+ * (Picateclas, 2026-05-28) the runner's VSZ ballooned to 74 GB / RSS to
+ * 7.5 GB, causing every subsequent `fork()` to fail ENOMEM regardless of
+ * current RSS (the kernel reserves CoW for the full VSZ at fork time).
+ *
+ * Moving each session into its own subprocess means the SDK state dies
+ * with the subprocess. The runner stays at the ~234 MB baseline observed
+ * on Reviewer (the cohort partner that did 481 task completions without
+ * the OOM symptom). See task `fa0c0681` for the byte-by-byte breakdown.
+ *
+ * Wire protocol over stdout (one JSON object per line):
+ *   {"kind":"event", "event": <ProviderEvent>}
+ *   {"kind":"result", "result": <ProviderResult>}
+ *   {"kind":"error", "message": "..."}
+ */
+
+import { createInProcessCodexSession } from "../providers/codex-adapter";
+import type { ProviderEvent, ProviderResult, ProviderSessionConfig } from "../providers/types";
+
+interface CodexSubprocessInput {
+  config: ProviderSessionConfig;
+  skillsDir?: string;
+  parentOtelEnv?: Record<string, string>;
+}
+
+async function readAllStdin(): Promise<string> {
+  // Bun.stdin is a BunFile in some versions, Web stream in others.
+  // The safest path is to read the readable stream directly.
+  const decoder = new TextDecoder();
+  let out = "";
+  const stream = (Bun.stdin as unknown as { stream?: () => ReadableStream<Uint8Array> }).stream
+    ? (Bun.stdin as unknown as { stream: () => ReadableStream<Uint8Array> }).stream()
+    : null;
+  if (stream) {
+    const reader = stream.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value) out += decoder.decode(value, { stream: true });
+    }
+    out += decoder.decode();
+    return out;
+  }
+  // Fallback: read via Bun.file (file-like access works for piped stdin too)
+  return await Bun.file("/dev/stdin").text();
+}
+
+function writeLine(obj: unknown): void {
+  process.stdout.write(`${JSON.stringify(obj)}\n`);
+}
+
+export async function runCodexSessionRunner(): Promise<void> {
+  try {
+    await runCodexSessionRunnerInner();
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : undefined;
+    console.error(`[codex-session-runner] top-level crash: ${message}`);
+    if (stack) console.error(stack);
+    writeLine({ kind: "error", message: `codex-session-runner: unexpected crash: ${message}` });
+    process.exit(1);
+  }
+}
+
+async function runCodexSessionRunnerInner(): Promise<void> {
+  let input: CodexSubprocessInput;
+  try {
+    const raw = await readAllStdin();
+    input = JSON.parse(raw) as CodexSubprocessInput;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[codex-session-runner] stdin parse failed: ${message}`);
+    writeLine({
+      kind: "error",
+      message: `codex-session-runner: failed to parse stdin: ${message}`,
+    });
+    process.exit(1);
+  }
+
+  // Forward the parent's captured OTel TRACEPARENT (and friends) into the
+  // session config's env so the spawned Codex CLI nests its spans under our
+  // worker.session trace. We deliberately do NOT call
+  // `buildOtelTraceparentEnv` from inside this subprocess — its tracer has
+  // no active span, so it would emit nothing.
+  if (input.parentOtelEnv && Object.keys(input.parentOtelEnv).length > 0) {
+    input.config.env = { ...(input.config.env ?? {}), ...input.parentOtelEnv };
+  }
+
+  let session: Awaited<ReturnType<typeof createInProcessCodexSession>>;
+  try {
+    session = await createInProcessCodexSession(input.config, {
+      skillsDir: input.skillsDir,
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`[codex-session-runner] createSession failed: ${message}`);
+    writeLine({ kind: "error", message: `codex-session-runner: createSession failed: ${message}` });
+    process.exit(1);
+  }
+
+  // Forward SIGTERM / SIGINT to the in-process session so the runner can
+  // gracefully cancel us. The parent `CodexSubprocessSession.abort()` sends
+  // SIGTERM here; the session's AbortController catches it and the codex
+  // CLI subprocess (a grandchild) gets cleaned up.
+  const onSignal = (signal: NodeJS.Signals) => {
+    void session.abort().finally(() => {
+      // give the session a beat to emit its cancellation result, then exit
+      setTimeout(() => process.exit(signal === "SIGINT" ? 130 : 143), 250);
+    });
+  };
+  process.on("SIGTERM", () => onSignal("SIGTERM"));
+  process.on("SIGINT", () => onSignal("SIGINT"));
+
+  session.onEvent((event: ProviderEvent) => {
+    writeLine({ kind: "event", event });
+  });
+
+  const result: ProviderResult = await session.waitForCompletion();
+  writeLine({ kind: "result", result });
+  process.exit(result.exitCode ?? 0);
+}

package/src/commands/context-preamble.ts

@@ -11,6 +11,8 @@
  * resumes (see swarm memory sigterm-143-resumed-session-context-saturation-2026-05-13).
  */
 
+import { scrubSecrets } from "../utils/secret-scrubber";
+
 export const CONTEXT_PREAMBLE_MAX_TOKENS = Number(
   process.env.CONTEXT_PREAMBLE_MAX_TOKENS || "2000",
 );
@@ -18,12 +20,25 @@ export const CONTEXT_PREAMBLE_MAX_TOKENS = Number(
 export const CONTEXT_PREAMBLE_MAX_CHARS = CONTEXT_PREAMBLE_MAX_TOKENS * 4;
 export const CONTEXT_PREAMBLE_MAX_ANCESTORS = 5;
 
+/**
+ * Token budget for the resume-task preamble. Default 4000 = 2× the regular
+ * preamble, since the resume agent needs the original task brief verbatim
+ * plus a tool-call summary to avoid redoing completed work.
+ */
+export const CONTEXT_PREAMBLE_RESUME_MAX_TOKENS = Number(
+  process.env.CONTEXT_PREAMBLE_RESUME_MAX_TOKENS || "4000",
+);
+export const CONTEXT_PREAMBLE_RESUME_MAX_CHARS = CONTEXT_PREAMBLE_RESUME_MAX_TOKENS * 4;
+/** How many of the most recent session_logs rows to inspect for tool-call summary. */
+export const CONTEXT_PREAMBLE_RESUME_SESSION_LOG_LIMIT = 50;
+
 export interface TaskContextForPreamble {
   id: string;
   task: string;
   output?: string;
   progress?: string;
   status?: string;
+  taskType?: string;
   parentTaskId?: string;
   attachments?: Array<{
     kind: string;
@@ -57,6 +72,7 @@ export async function fetchTaskContextForPreamble(
       output: data.output,
       progress: data.progress,
       status: data.status,
+      taskType: data.taskType,
       parentTaskId: data.parentTaskId,
       attachments: data.attachments,
     };
@@ -176,3 +192,259 @@ export async function buildContextPreamble(
 
   return preamble;
 }
+
+// ─── Resume Preamble ───────────────────────────────────────────────────────────
+
+interface SessionLogForPreamble {
+  id: string;
+  taskId?: string;
+  sessionId: string;
+  iteration: number;
+  cli: string;
+  content: string;
+  lineNumber: number;
+  createdAt: string;
+}
+
+async function fetchSessionLogsForResume(
+  apiUrl: string,
+  apiKey: string,
+  taskId: string,
+): Promise<SessionLogForPreamble[]> {
+  const headers: Record<string, string> = {};
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  try {
+    // Bound server-side: long-running parents can accumulate large `session_logs`
+    // and the preamble only consumes the tail (see CONTEXT_PREAMBLE_RESUME_SESSION_LOG_LIMIT).
+    // Passing `?limit=N` keeps dispatch fast and memory-flat regardless of run length.
+    const url = `${apiUrl}/api/tasks/${taskId}/session-logs?limit=${CONTEXT_PREAMBLE_RESUME_SESSION_LOG_LIMIT}`;
+    const response = await fetch(url, { headers });
+    if (!response.ok) return [];
+    const data = (await response.json()) as { logs?: SessionLogForPreamble[] };
+    return Array.isArray(data.logs) ? data.logs : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Format a single session_log line as a one-line tool-call summary. Falls back
+ * to a truncated content snippet when the line isn't recognizable as a
+ * tool call. The returned text is passed through `scrubSecrets` before
+ * insertion into the preamble (no secrets in /workspace/logs/*.jsonl).
+ */
+function summarizeSessionLogLine(line: SessionLogForPreamble): string | null {
+  const ts = line.createdAt.slice(11, 19); // HH:MM:SS
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line.content);
+  } catch {
+    const snippet = line.content.replace(/\s+/g, " ").slice(0, 120);
+    return snippet ? `[${ts}] ${snippet}` : null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const obj = parsed as Record<string, unknown>;
+
+  // Anthropic / claude message-style tool calls.
+  const message = obj.message as Record<string, unknown> | undefined;
+  const content = message?.content;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block as Record<string, unknown>;
+      if (b.type === "tool_use" && typeof b.name === "string") {
+        const input = b.input as Record<string, unknown> | undefined;
+        const file = input?.file_path ?? input?.path ?? input?.command;
+        const fileStr = typeof file === "string" ? ` ${file}` : "";
+        return `[${ts}] ${b.name}${fileStr}`;
+      }
+    }
+  }
+
+  // Codex / generic event-style: { type: 'tool_use', name: '...', input: {...} }
+  if (obj.type === "tool_use" && typeof obj.name === "string") {
+    const input = obj.input as Record<string, unknown> | undefined;
+    const file = input?.file_path ?? input?.path ?? input?.command;
+    const fileStr = typeof file === "string" ? ` ${file}` : "";
+    return `[${ts}] ${obj.name}${fileStr}`;
+  }
+
+  // Fallback: short content snippet (still useful for diff/insight)
+  const snippet = JSON.stringify(parsed).replace(/\s+/g, " ").slice(0, 120);
+  return snippet ? `[${ts}] ${snippet}` : null;
+}
+
+/**
+ * Build a resume-task preamble.
+ *
+ * Reads the parent task + its recent session_logs over HTTP (never touches
+ * `bun:sqlite` worker-side). Allocates the 4000-token budget:
+ *
+ *   - 40% — full parent task description (never truncated)
+ *   - 35% — last-N session_logs summary (tool-call one-liners; scrubbed)
+ *   - 15% — artifacts/attachments index (names + pointers only)
+ *   - 10% — fixed framing (header + continuation instructions)
+ *
+ * Truncation order: session-log summary (oldest first), then artifacts.
+ * The task description is never truncated.
+ */
+/**
+ * Walk up the parentTaskId chain through `taskType === "resume"` ancestors
+ * to find the original (non-resume) task. Returns the chain in order
+ * [immediateParent, ..., original]. Caps at MAX_RESUME_CHAIN_DEPTH to
+ * defend against cycles or runaway chains.
+ *
+ * PR #594 review: cascading resumes (original → resume1 → resume2) had
+ * `buildResumeContextPreamble` fetching only the immediate parent — whose
+ * `task` text is the synthetic "Resume interrupted task..." prompt rather
+ * than the original work brief. Walking the chain restores the original
+ * description and lets us merge session logs from all resume attempts.
+ */
+const MAX_RESUME_CHAIN_DEPTH = 10;
+
+async function walkResumeChain(
+  apiUrl: string,
+  apiKey: string,
+  immediateParentId: string,
+): Promise<TaskContextForPreamble[]> {
+  const chain: TaskContextForPreamble[] = [];
+  let currentId: string | undefined = immediateParentId;
+  for (let depth = 0; depth < MAX_RESUME_CHAIN_DEPTH && currentId; depth++) {
+    const ctx: TaskContextForPreamble | null = await fetchTaskContextForPreamble(
+      apiUrl,
+      apiKey,
+      currentId,
+    );
+    if (!ctx) break;
+    chain.push(ctx);
+    // Stop once we hit a non-resume ancestor — that's the original work.
+    if (ctx.taskType !== "resume") break;
+    currentId = ctx.parentTaskId;
+  }
+  return chain;
+}
+
+export async function buildResumeContextPreamble(
+  apiUrl: string,
+  apiKey: string,
+  parentTaskId: string,
+): Promise<string | null> {
+  const chain = await walkResumeChain(apiUrl, apiKey, parentTaskId);
+  if (chain.length === 0) return null;
+  // Original = last entry (non-resume ancestor, or the deepest reachable
+  // if the chain exceeds the depth cap or hits a fetch failure).
+  const original = chain[chain.length - 1] ?? chain[0];
+  if (!original) return null;
+  // Immediate parent — its attachments are the most recent "in flight" set.
+  const parent = chain[0] ?? original;
+
+  // Fetch session logs from EVERY chain member so a re-superseded resume
+  // still surfaces tool-call history from earlier attempts. Merge, sort by
+  // createdAt ASC, then keep the most recent N.
+  const logsBatches = await Promise.all(
+    chain.map((c) => fetchSessionLogsForResume(apiUrl, apiKey, c.id)),
+  );
+  const merged = logsBatches.flat();
+  merged.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  const recentLogs = merged.slice(-CONTEXT_PREAMBLE_RESUME_SESSION_LOG_LIMIT);
+
+  const descBudget = Math.floor(CONTEXT_PREAMBLE_RESUME_MAX_CHARS * 0.4);
+  let logsBudget = Math.floor(CONTEXT_PREAMBLE_RESUME_MAX_CHARS * 0.35);
+  let artBudget = Math.floor(CONTEXT_PREAMBLE_RESUME_MAX_CHARS * 0.15);
+
+  const header = [
+    "\n---",
+    "## Resuming Interrupted Task",
+    "",
+    "This task is a fresh-session continuation of an interrupted task (graceful",
+    "shutdown / context-limit / operator action). The block below summarizes the",
+    "original task, what was done so far, and the artifacts in flight.",
+    "",
+    "**Do not redo work already completed below — extend it.**",
+    "",
+    `Original task ID: \`${original.id}\``,
+    chain.length > 1
+      ? `Resume chain depth: ${chain.length} (this is at least the ${
+          chain.length === 2 ? "2nd" : chain.length === 3 ? "3rd" : `${chain.length}th`
+        } resume attempt).`
+      : "",
+    "",
+    "---",
+    "",
+    "### Original Task Description",
+    "",
+  ]
+    .filter((s) => s !== "")
+    .join("\n");
+
+  // 40% — full description (never truncated). Pulled from the ORIGINAL
+  // (non-resume) ancestor so cascading resumes don't read each other's
+  // synthetic "Resume interrupted task..." preamble bodies (PR #594 review).
+  const descSection = original.task;
+
+  // 35% — session-log summary (tool-call lines)
+  const summaryLines: string[] = [];
+  for (const line of recentLogs) {
+    const summary = summarizeSessionLogLine(line);
+    if (!summary) continue;
+    summaryLines.push(summary);
+  }
+  // Scrub secrets BEFORE budget enforcement so secret strings don't get
+  // sliced into half-redactions mid-truncate.
+  const scrubbedSummary = summaryLines.map((s) => scrubSecrets(s));
+  let logsSection = scrubbedSummary.join("\n");
+  // FIFO truncate (drop oldest first) until under budget.
+  // We use `Math.max(0, descBudget - descSection.length)` slack adjustment so
+  // an oversized description doesn't starve the logs section entirely.
+  if (descSection.length > descBudget) {
+    const overflow = descSection.length - descBudget;
+    logsBudget = Math.max(0, logsBudget - Math.ceil(overflow / 2));
+    artBudget = Math.max(0, artBudget - Math.floor(overflow / 2));
+  }
+  while (logsSection.length > logsBudget && scrubbedSummary.length > 0) {
+    scrubbedSummary.shift();
+    logsSection = scrubbedSummary.join("\n");
+  }
+
+  // 15% — artifacts (names + pointers only)
+  const atts = parent.attachments?.filter((a) => a.name && (a.url || a.path || a.pageId)) ?? [];
+  const artLines: string[] = [];
+  for (const att of atts) {
+    const pointer = formatAttachmentPointer(att);
+    artLines.push(`  - **${att.name}**: \`${pointer}\``);
+  }
+  let artSection = artLines.join("\n");
+  while (artSection.length > artBudget && artLines.length > 0) {
+    artLines.pop();
+    artSection = artLines.join("\n");
+  }
+
+  const sections: string[] = [header, descSection, ""];
+
+  if (logsSection) {
+    sections.push("### Recent Tool Calls", "", logsSection, "");
+  }
+
+  if (artSection) {
+    sections.push("### Artifacts In Flight", "", artSection, "");
+  }
+
+  sections.push(
+    "---",
+    "",
+    `To review the full prior session call \`get-task-details\` with taskId \`${original.id}\`.`,
+    "",
+    "---",
+    "",
+  );
+
+  let preamble = sections.join("\n");
+
+  // Final hard cap — should rarely trip given the per-section budgets above,
+  // but provides a safety net for very long descriptions.
+  if (preamble.length > CONTEXT_PREAMBLE_RESUME_MAX_CHARS) {
+    preamble = `${preamble.slice(0, CONTEXT_PREAMBLE_RESUME_MAX_CHARS)}\n\n[resume preamble truncated to ${CONTEXT_PREAMBLE_RESUME_MAX_TOKENS}-token budget]\n\n---\n`;
+  }
+
+  return preamble;
+}

package/src/commands/credential-wait.ts

@@ -133,7 +133,7 @@ export async function awaitCredentials(opts: AwaitCredentialsOptions): Promise<C
 
   // Fast path: already satisfied at boot.
   let currentProvider = readProvider();
-  let status = checkProviderCredentials(currentProvider, initialEnv, opts.credCheckOptions);
+  let status = await checkProviderCredentials(currentProvider, initialEnv, opts.credCheckOptions);
   if (status.ready) {
     log(
       `[boot] credentials ready (provider=${currentProvider}, satisfiedBy=${status.satisfiedBy})`,
@@ -183,7 +183,7 @@ export async function awaitCredentials(opts: AwaitCredentialsOptions): Promise<C
       currentProvider = nextProvider;
     }
 
-    status = checkProviderCredentials(currentProvider, process.env, opts.credCheckOptions);
+    status = await checkProviderCredentials(currentProvider, process.env, opts.credCheckOptions);
 
     if (!status.ready) {
       // Exponential backoff with cap.