@desplega.ai/agent-swarm 1.98.1 → 1.99.0

package/README.md

@@ -127,6 +127,7 @@ Check [our templates](https://templates.agent-swarm.dev) for a quick start.
 - **Workflow engine with Human-in-the-Loop** — DAG-based automation with approval gates, retries, and structured I/O. [Workflows →](https://docs.agent-swarm.dev/docs/concepts/workflows)
 - **Scheduled & recurring tasks** — cron-based automation for standing work. [Scheduling →](https://docs.agent-swarm.dev/docs/concepts/scheduling)
 - **Durable script workflows** — launch background script runs, inspect their journals, and track them from the dashboard when a one-shot `script-run` is too small. [Guide →](https://docs.agent-swarm.dev/docs/guides/script-workflow-runs)
+- **E2B-backed eval harness** — run a scenario × harness-config matrix against real swarm stacks, capture transcripts/artifacts, and grade outcomes with deterministic checks plus LLM or agentic judges. [Guide →](https://docs.agent-swarm.dev/docs/guides/evals-harness)
 - **Harness & LLM agnostic** — run with Claude Code, Claude Bridge, OpenAI Codex, pi-mono (Anthropic, OpenRouter, or Amazon Bedrock), Devin, Claude Managed Agents, raw LLMs, or opencode. Tasks, schedules, and workflow agent-task nodes can use portable `modelTier` intent (`smol`, `regular`, `smart`, `ultra`) and resolve it per worker/provider at run time. [Harness config →](https://docs.agent-swarm.dev/docs/guides/harness-configuration) · [Add a new provider →](https://docs.agent-swarm.dev/docs/guides/harness-providers)
 - **Follow-up continuity across all harnesses** — child tasks inherit a bounded prior-task context preamble built from the task chain, so continuity survives restarts and works the same across every provider. [Task lifecycle →](https://docs.agent-swarm.dev/docs/concepts/task-lifecycle)
 - **Skills & MCP servers** — reusable procedural knowledge, bundled skill reference files, and per-agent MCP servers with scope cascade. [MCP tools →](https://docs.agent-swarm.dev/docs/reference/mcp-tools)

package/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.1.0",
   "info": {
     "title": "Agent Swarm API",
-    "version": "1.98.1",
+    "version": "1.99.0",
     "description": "Multi-agent orchestration API for Claude Code, Codex, and Gemini CLI. Enables task distribution, agent communication, and service discovery.\n\nMCP tools are documented separately in [MCP.md](./MCP.md)."
   },
   "servers": [
@@ -4248,6 +4248,9 @@
                   },
                   "persistMemory": {
                     "type": "boolean"
+                  },
+                  "contextKey": {
+                    "type": "string"
                   }
                 },
                 "required": [
@@ -4291,6 +4294,11 @@
                     "type": "string",
                     "minLength": 1
                   },
+                  "intent": {
+                    "type": "string",
+                    "minLength": 1,
+                    "description": "Why you are searching. Required for agent recall-edge tracking; omit for UI browse/search calls."
+                  },
                   "limit": {
                     "type": "integer",
                     "minimum": 1,
@@ -4516,6 +4524,17 @@
             "required": true,
             "name": "id",
             "in": "path"
+          },
+          {
+            "schema": {
+              "type": "string",
+              "minLength": 1,
+              "description": "Why you are retrieving this memory. Required for agent recall-edge tracking; omit for UI browse calls."
+            },
+            "required": false,
+            "description": "Why you are retrieving this memory. Required for agent recall-edge tracking; omit for UI browse calls.",
+            "name": "intent",
+            "in": "query"
           }
         ],
         "responses": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@desplega.ai/agent-swarm",
-  "version": "1.98.1",
+  "version": "1.99.0",
   "description": "Multi-agent orchestration for Claude Code, Codex, Gemini CLI, and other AI coding assistants",
   "license": "MIT",
   "author": "desplega.sh <contact@desplega.sh>",
@@ -64,8 +64,8 @@
     "start:portless": "portless api.swarm bun --expose-gc src/http.ts",
     "inspector": "bunx @modelcontextprotocol/inspector --transport stdio bun src/stdio.ts",
     "inspector:http": "bunx @modelcontextprotocol/inspector --transport http https://api.swarm.localhost:1355/mcp",
-    "lint": "biome check src",
-    "lint:fix": "biome check --write src",
+    "lint": "biome check src evals",
+    "lint:fix": "biome check --write src evals",
     "format": "biome format --write src",
     "build:binary": "bun build ./src/cli.tsx --compile --compile-exec-argv='--expose-gc' --target=bun-linux-x64 --outfile ./dist/agent-swarm",
     "build:binary:arm64": "bun build ./src/cli.tsx --compile --compile-exec-argv='--expose-gc' --target=bun-linux-arm64 --outfile ./dist/agent-swarm",

package/src/be/memory/link-resolver.ts

@@ -0,0 +1,226 @@
+/**
+ * Deterministic link resolver for memory content.
+ *
+ * Scans memory content for recognizable patterns (wikilinks, agent-fs paths,
+ * PR references, agent-UI URLs) and resolves them to typed `memory_link` rows.
+ * Phase 1: capture layer only — no traversal tools, no reranker integration.
+ */
+import { getDb } from "@/be/db";
+
+export type LinkType =
+  | "wikilink"
+  | "sequel"
+  | "agent-fs-file"
+  | "agent-ui"
+  | "pr"
+  | "external-source";
+export type TargetKind = "memory" | "agent-fs-file" | "agent-ui" | "pr" | "external-source";
+
+export interface ResolvedLink {
+  linkType: LinkType;
+  targetKind: TargetKind;
+  targetId: string;
+  strength: number;
+  resolver: string;
+  sourceText: string;
+  metadata?: Record<string, unknown>;
+}
+
+interface MatcherResult {
+  linkType: LinkType;
+  targetKind: TargetKind;
+  targetId: string;
+  sourceText: string;
+  resolver: string;
+  metadata?: Record<string, unknown>;
+}
+
+type Matcher = (content: string) => MatcherResult[];
+
+const WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
+const PR_HASH_RE = /(?:^|[\s(])#(\d{1,5})(?=[\s,.)!?]|$)/gm;
+const PR_PREFIX_RE = /\bPR\s*#(\d{1,5})\b/gi;
+const GITHUB_PR_URL_RE = /https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/pull\/(\d+)/g;
+const AGENT_FS_PATH_RE =
+  /(?:agent-fs|live\.agent-fs\.dev)\/file\/~\/([a-f0-9-]+)\/([a-f0-9-]+)\/([\w/.%-]+)/g;
+const AGENT_UI_PAGE_RE = /(?:app\.[^/]+|localhost:\d+)\/pages\/([a-f0-9-]+)/g;
+const AGENT_UI_TASK_RE = /(?:app\.[^/]+|localhost:\d+)\/tasks\/([a-f0-9-]+)/g;
+
+const wikilinkMatcher: Matcher = (content) => {
+  const results: MatcherResult[] = [];
+  for (const match of content.matchAll(WIKILINK_RE)) {
+    const name = match[1]!.trim();
+    if (!name) continue;
+    results.push({
+      linkType: "wikilink",
+      targetKind: "memory",
+      targetId: name,
+      sourceText: match[0],
+      resolver: "wikilink",
+    });
+  }
+  return results;
+};
+
+const prMatcher: Matcher = (content) => {
+  const results: MatcherResult[] = [];
+  const seen = new Set<string>();
+
+  for (const match of content.matchAll(GITHUB_PR_URL_RE)) {
+    const id = `github:${match[1]}/${match[2]}#${match[3]}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    results.push({
+      linkType: "pr",
+      targetKind: "pr",
+      targetId: id,
+      sourceText: match[0],
+      resolver: "pr-url",
+      metadata: { owner: match[1], repo: match[2], number: Number(match[3]) },
+    });
+  }
+
+  for (const match of content.matchAll(PR_PREFIX_RE)) {
+    const id = `pr:${match[1]}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    results.push({
+      linkType: "pr",
+      targetKind: "pr",
+      targetId: id,
+      sourceText: match[0].trim(),
+      resolver: "pr-prefix",
+      metadata: { number: Number(match[1]) },
+    });
+  }
+
+  for (const match of content.matchAll(PR_HASH_RE)) {
+    const id = `pr:${match[1]}`;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    results.push({
+      linkType: "pr",
+      targetKind: "pr",
+      targetId: id,
+      sourceText: `#${match[1]}`,
+      resolver: "pr-hash",
+      metadata: { number: Number(match[1]) },
+    });
+  }
+
+  return results;
+};
+
+const agentFsMatcher: Matcher = (content) => {
+  const results: MatcherResult[] = [];
+  for (const match of content.matchAll(AGENT_FS_PATH_RE)) {
+    const orgId = match[1]!;
+    const driveId = match[2]!;
+    const path = match[3]!;
+    results.push({
+      linkType: "agent-fs-file",
+      targetKind: "agent-fs-file",
+      targetId: `${orgId}/${driveId}/${path}`,
+      sourceText: match[0],
+      resolver: "agent-fs-path",
+      metadata: { orgId, driveId, path },
+    });
+  }
+  return results;
+};
+
+const agentUiMatcher: Matcher = (content) => {
+  const results: MatcherResult[] = [];
+  for (const match of content.matchAll(AGENT_UI_PAGE_RE)) {
+    results.push({
+      linkType: "agent-ui",
+      targetKind: "agent-ui",
+      targetId: `page:${match[1]}`,
+      sourceText: match[0],
+      resolver: "agent-ui-page",
+    });
+  }
+  for (const match of content.matchAll(AGENT_UI_TASK_RE)) {
+    results.push({
+      linkType: "agent-ui",
+      targetKind: "agent-ui",
+      targetId: `task:${match[1]}`,
+      sourceText: match[0],
+      resolver: "agent-ui-task",
+    });
+  }
+  return results;
+};
+
+const MATCHERS: Matcher[] = [wikilinkMatcher, prMatcher, agentFsMatcher, agentUiMatcher];
+
+export function resolveLinks(content: string): ResolvedLink[] {
+  const results: ResolvedLink[] = [];
+  for (const matcher of MATCHERS) {
+    for (const link of matcher(content)) {
+      results.push({ ...link, strength: 1.0 });
+    }
+  }
+  return results;
+}
+
+export function resolveWikilinksToMemoryIds(
+  agentId: string,
+  links: ResolvedLink[],
+): ResolvedLink[] {
+  const db = getDb();
+  const findByName = db.prepare<{ id: string }, [string, string]>(
+    "SELECT id FROM agent_memory WHERE name = ? AND (agentId = ? OR scope = 'swarm') LIMIT 1",
+  );
+
+  return links.map((link) => {
+    if (link.linkType !== "wikilink") return link;
+    const row = findByName.get(link.targetId, agentId);
+    if (row) {
+      return { ...link, targetId: row.id };
+    }
+    return link;
+  });
+}
+
+export function storeLinks(memoryId: string, agentId: string, content: string): void {
+  const links = resolveLinks(content);
+  if (links.length === 0) return;
+
+  const resolved = resolveWikilinksToMemoryIds(agentId, links);
+  const db = getDb();
+  const now = new Date().toISOString();
+  const insert = db.prepare(
+    `INSERT OR IGNORE INTO memory_link
+       (id, from_memory_id, linkType, targetKind, targetId, strength, resolver, sourceText, metadata, createdAt, updatedAt)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+  );
+
+  db.transaction(() => {
+    for (const link of resolved) {
+      insert.run(
+        crypto.randomUUID(),
+        memoryId,
+        link.linkType,
+        link.targetKind,
+        link.targetId,
+        link.strength,
+        link.resolver,
+        link.sourceText,
+        link.metadata ? JSON.stringify(link.metadata) : null,
+        now,
+        now,
+      );
+    }
+  })();
+}
+
+export function storeSequelLink(fromMemoryId: string, toMemoryId: string): void {
+  const db = getDb();
+  const now = new Date().toISOString();
+  db.prepare(
+    `INSERT OR IGNORE INTO memory_link
+       (id, from_memory_id, linkType, targetKind, targetId, strength, resolver, sourceText, metadata, createdAt, updatedAt)
+     VALUES (?, ?, 'sequel', 'memory', ?, 1.0, 'sequel-auto', NULL, NULL, ?, ?)`,
+  ).run(crypto.randomUUID(), fromMemoryId, toMemoryId, now, now);
+}

package/src/be/memory/providers/sqlite-store.ts

@@ -259,10 +259,11 @@ export class SqliteMemoryStore implements MemoryStore {
           string | null,
           number,
           string | null,
+          string | null,
         ]
       >(
-        `INSERT INTO agent_memory (id, agentId, scope, name, content, summary, source, sourceTaskId, sourcePath, chunkIndex, totalChunks, tags, createdAt, accessedAt, expiresAt, accessCount, embeddingModel)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
+        `INSERT INTO agent_memory (id, agentId, scope, name, content, summary, source, sourceTaskId, sourcePath, chunkIndex, totalChunks, tags, createdAt, accessedAt, expiresAt, accessCount, embeddingModel, contextKey)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) RETURNING *`,
       )
       .get(
         id,
@@ -282,6 +283,7 @@ export class SqliteMemoryStore implements MemoryStore {
         expiresAt,
         0,
         null,
+        input.contextKey ?? null,
       );
 
     if (!row) throw new Error("Failed to create memory");

package/src/be/memory/raters/retrieval.ts

@@ -24,24 +24,32 @@ export type RetrievalRecord = {
   similarity: number;
 };
 
+export type RetrievalExtras = {
+  intent?: string;
+  contextKey?: string;
+  eventType?: "search" | "get";
+};
+
 export function recordRetrievals(
   taskId: string | undefined,
   agentId: string,
   results: RetrievalRecord[],
   sessionId?: string,
+  extras?: RetrievalExtras,
 ): void {
   if (!taskId || results.length === 0) return;
 
   const db = getDb();
   const insert = db.prepare(
     `INSERT INTO memory_retrieval
-       (id, taskId, agentId, sessionId, memoryId, similarity, retrievedAt)
-     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+       (id, taskId, agentId, sessionId, memoryId, similarity, retrievedAt, contextKey, intent, eventType)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   );
   const now = new Date().toISOString();
+  const contextKey = extras?.contextKey ?? null;
+  const intent = extras?.intent ?? null;
+  const eventType = extras?.eventType ?? "search";
 
-  // Single transaction: even on a 100-row paginated search this is one
-  // commit, not N. No-op when results is empty.
   db.transaction(() => {
     for (const r of results) {
       insert.run(
@@ -52,6 +60,9 @@ export function recordRetrievals(
         r.memoryId,
         r.similarity,
         now,
+        contextKey,
+        intent,
+        eventType,
       );
     }
   })();

package/src/be/memory/raters/store.ts

@@ -31,6 +31,7 @@ export type ApplyRatingResult = {
 
 export type ApplyRatingContext = {
   taskId?: string;
+  contextKey?: string;
 };
 
 export class ExplicitSelfDuplicateError extends Error {
@@ -100,8 +101,8 @@ export function applyRating(
   );
   const insertRating = db.prepare(
     `INSERT INTO memory_rating
-       (id, memoryId, taskId, source, signal, weight, reasoning, createdAt)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+       (id, memoryId, taskId, source, signal, weight, reasoning, createdAt, contextKey)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   );
   // Step-6 §3 — UPSERT the edge with the SAME deltas as the memory row.
   // The `- 1.0` corrections in DO UPDATE undo the default-prior offset that
@@ -141,6 +142,7 @@ export function applyRating(
           event.weight,
           event.reasoning ?? null,
           new Date().toISOString(),
+          ctx.contextKey ?? null,
         );
       } catch (err) {
         // Partial unique index on (taskId, memoryId) WHERE source='explicit-self'

package/src/be/memory/types.ts

@@ -52,6 +52,7 @@ export interface MemoryInput {
   chunkIndex?: number;
   totalChunks?: number;
   tags?: string[];
+  contextKey?: string | null;
 }
 
 export interface MemoryCandidate extends AgentMemory {

package/src/be/migrations/096_memory_graph_phase1.sql

@@ -0,0 +1,50 @@
+-- Phase 1 of memory-graph recall-edges: contextKey threading, intent capture,
+-- memory-get retrieval events, and deterministic typed links.
+
+-- 1. Add contextKey to agent_memory (born-under context)
+ALTER TABLE agent_memory ADD COLUMN contextKey TEXT;
+CREATE INDEX idx_agent_memory_context_key ON agent_memory(contextKey);
+
+-- 2. Extend memory_retrieval with contextKey, intent, and eventType
+ALTER TABLE memory_retrieval ADD COLUMN contextKey TEXT;
+ALTER TABLE memory_retrieval ADD COLUMN intent TEXT;
+ALTER TABLE memory_retrieval ADD COLUMN eventType TEXT NOT NULL DEFAULT 'search'
+    CHECK (eventType IN ('search', 'get'));
+CREATE INDEX idx_memret_context_key ON memory_retrieval(contextKey);
+CREATE INDEX idx_memret_event_type ON memory_retrieval(eventType);
+
+-- 3. Add contextKey to memory_rating
+ALTER TABLE memory_rating ADD COLUMN contextKey TEXT;
+CREATE INDEX idx_memrat_context_key ON memory_rating(contextKey);
+
+-- 4. New table: memory_link — deterministic typed links between memories
+--    and external entities (agent-fs files, PRs, agent-UI pages, etc.)
+CREATE TABLE IF NOT EXISTS memory_link (
+    id             TEXT PRIMARY KEY,
+    from_memory_id TEXT NOT NULL,
+    linkType       TEXT NOT NULL CHECK (
+        linkType IN (
+            'wikilink',
+            'sequel',
+            'agent-fs-file',
+            'agent-ui',
+            'pr',
+            'external-source'
+        )
+    ),
+    targetKind     TEXT NOT NULL CHECK (
+        targetKind IN ('memory', 'agent-fs-file', 'agent-ui', 'pr', 'external-source')
+    ),
+    targetId       TEXT NOT NULL,
+    strength       REAL NOT NULL DEFAULT 1.0,
+    resolver       TEXT NOT NULL,
+    sourceText     TEXT,
+    metadata       TEXT,
+    createdAt      TEXT NOT NULL,
+    updatedAt      TEXT NOT NULL,
+    UNIQUE (from_memory_id, linkType, targetKind, targetId, sourceText),
+    FOREIGN KEY (from_memory_id) REFERENCES agent_memory(id) ON DELETE CASCADE
+);
+CREATE INDEX idx_memlink_from ON memory_link(from_memory_id);
+CREATE INDEX idx_memlink_target ON memory_link(targetKind, targetId);
+CREATE INDEX idx_memlink_type ON memory_link(linkType);

package/src/be/scripts/typecheck.ts

@@ -51,8 +51,8 @@ export interface SwarmConfig {
 
 export interface SwarmSdk {
   // --- memory ---
-  memory_search(args: { query: string; scope?: "all" | "agent" | "swarm"; limit?: number; source?: string }): Promise<unknown>;
-  memory_get(args: { memoryId: string }): Promise<unknown>;
+  memory_search(args: { query: string; intent: string; scope?: "all" | "agent" | "swarm"; limit?: number; source?: string }): Promise<unknown>;
+  memory_get(args: { memoryId: string; intent: string }): Promise<unknown>;
   memory_rate(args: { id: string; useful: boolean; note?: string }): Promise<unknown>;
   // --- tasks ---
   task_list(args?: Record<string, unknown>): Promise<unknown>;
@@ -176,6 +176,7 @@ export interface SwarmSdk {
   // --- skills ---
   skill_list(args?: { scope?: string; scopeId?: string; includeBuiltin?: boolean }): Promise<unknown>;
   skill_get(args: { id: string }): Promise<unknown>;
+  skill_getFile(args: { skillId: string; path: string }): Promise<unknown>;
   skill_search(args: { query: string; limit?: number }): Promise<unknown>;
   skill_create(args: Record<string, unknown>): Promise<unknown>;
   skill_update(args: Record<string, unknown>): Promise<unknown>;

package/src/commands/runner.ts

@@ -1317,6 +1317,7 @@ async function getPausedTasksFromAPI(config: ApiConfig): Promise<
     finishedAt?: string;
     output?: string;
     status?: string;
+    contextKey?: string;
   }>
 > {
   const headers: Record<string, string> = {
@@ -2329,6 +2330,7 @@ async function fetchRelevantMemories(
   agentId: string,
   taskDescription: string,
   taskId?: string,
+  contextKey?: string,
 ): Promise<string | null> {
   try {
     const headers: Record<string, string> = {
@@ -2341,11 +2343,12 @@ async function fetchRelevantMemories(
     // memories they surface against this task's session_logs at completion.
     // Plan: thoughts/taras/plans/2026-05-05-memory-rater-v1.5/step-2.md §2
     if (taskId) headers["X-Source-Task-ID"] = taskId;
+    if (contextKey) headers["X-Context-Key"] = contextKey;
 
     const response = await fetch(`${apiUrl}/api/memory/search`, {
       method: "POST",
       headers,
-      body: JSON.stringify({ query: taskDescription, limit: 5 }),
+      body: JSON.stringify({ query: taskDescription, limit: 5, intent: "pre-task memory recall" }),
     });
 
     if (!response.ok) return null;
@@ -2600,6 +2603,7 @@ async function spawnProviderProcess(
     harnessProvider: ProviderName;
     cwd?: string;
     vcsRepo?: string;
+    contextKey?: string;
   },
   logDir: string,
   isYolo: boolean,
@@ -2688,6 +2692,7 @@ async function spawnProviderProcess(
     // Propagate the selected OAuth slot so the adapter refreshes back to the
     // correct pool key. Undefined for non-codex providers and single-cred deploys.
     codexSlot: oauthSelection?.index,
+    contextKey: opts.contextKey,
   };
 
   // Create the long-lived `worker.session` span up front so the provider
@@ -4412,6 +4417,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
           agentId,
           task.task,
           task.id,
+          (task as { contextKey?: string }).contextKey,
         );
         if (resumeMemoryContext) {
           resumePrompt += resumeMemoryContext;
@@ -4537,6 +4543,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
               harnessProvider: state.harnessProvider,
               cwd: resumeCwd,
               vcsRepo: task.vcsRepo,
+              contextKey: (task as { contextKey?: string }).contextKey,
             },
             logDir,
             isYolo,
@@ -4802,7 +4809,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
         if (trigger.type === "task_assigned" || trigger.type === "task_offered") {
           const task =
             trigger.task && typeof trigger.task === "object" && "task" in trigger.task
-              ? (trigger.task as { task: string; id?: string })
+              ? (trigger.task as { task: string; id?: string; contextKey?: string })
               : null;
           if (task?.task) {
             const memoryContext = await fetchRelevantMemories(
@@ -4811,6 +4818,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
               agentId,
               task.task,
               task.id,
+              task.contextKey,
             );
             if (memoryContext) {
               triggerPrompt += memoryContext;
@@ -4870,6 +4878,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
         // Extract model from task data for per-task model selection
         const taskModel = (trigger.task as { model?: string } | undefined)?.model;
         const taskModelTier = (trigger.task as { modelTier?: string } | undefined)?.modelTier;
+        const taskContextKey = (trigger.task as { contextKey?: string } | undefined)?.contextKey;
 
         // Detect Slack context for conditional prompt sections
         const taskSlackChannelId = (trigger.task as { slackChannelId?: string } | undefined)
@@ -5016,6 +5025,7 @@ export async function runAgent(config: RunnerConfig, opts: RunnerOptions) {
               harnessProvider: state.harnessProvider,
               cwd: effectiveCwd,
               vcsRepo: taskVcsRepo,
+              contextKey: taskContextKey,
             },
             logDir,
             isYolo,

package/src/e2b/dispatch.ts

@@ -361,6 +361,11 @@ export async function startDetachedProcess(opts: StartDetachedOptions): Promise<
     cwd: opts.cwd ?? "/",
     envs: opts.env,
     background: true,
+    // CRITICAL: the SDK's default `timeoutMs` is 60s and applies to background
+    // commands too — envd kills the whole tracked tree (entrypoint + children)
+    // when it expires, silently stopping the worker runner ~60s after boot.
+    // 0 disables the limit; sandbox lifetime is governed by its own TTL.
+    timeoutMs: 0,
   });
 
   // Early liveness poll: give the entrypoint a moment to fault, then check the