@abelxiaoxing/cadence 1.2.4 → 1.4.0

package/src/sqlite-schema.ts

@@ -0,0 +1,171 @@
+import { DatabaseSync } from "node:sqlite";
+import { canonicalJson } from "./canonical.ts";
+
+export class SqliteSchemaError extends Error {
+  readonly code = "storage-schema-invalid";
+  constructor() {
+    super("storage-schema-invalid");
+  }
+}
+
+type Row = Record<string, string | number | null>;
+interface TableContract {
+  columns: Row[];
+  foreignKeys: string[];
+  uniqueKeys: string[];
+  strict: number;
+}
+const contracts = new Map<string, Map<string, TableContract>>();
+const identifier = (name: string): string => `"${name.replaceAll('"', '""')}"`;
+
+export function configureSqlite(
+  database: DatabaseSync,
+  busyTimeoutMs = 5000,
+): void {
+  database.exec("PRAGMA foreign_keys = ON");
+  database.exec("PRAGMA journal_mode = WAL");
+  database.exec("PRAGMA synchronous = FULL");
+  database.exec(
+    `PRAGMA busy_timeout = ${Math.max(1, Math.min(30_000, busyTimeoutMs))}`,
+  );
+}
+
+function describeTable(database: DatabaseSync, table: string): TableContract {
+  const columns = database
+    .prepare(`PRAGMA table_info(${identifier(table)})`)
+    .all() as Row[];
+  const foreignKeys = database
+    .prepare(`PRAGMA foreign_key_list(${identifier(table)})`)
+    .all() as Row[];
+  const indexes = database
+    .prepare(`PRAGMA index_list(${identifier(table)})`)
+    .all() as Row[];
+  const uniqueKeys = indexes
+    .filter((row) => row.unique === 1)
+    .map((row) => {
+      const fields = database
+        .prepare(`PRAGMA index_xinfo(${identifier(String(row.name))})`)
+        .all() as Row[];
+      return canonicalJson({
+        partial: row.partial,
+        fields: fields
+          .filter((field) => field.key === 1)
+          .map(({ name, coll, desc }) => ({ name, coll, desc })),
+      });
+    })
+    .sort();
+  const strict = (
+    database
+      .prepare(
+        "SELECT strict FROM pragma_table_list WHERE schema = 'main' AND name = ?",
+      )
+      .get(table) as Row | undefined
+  )?.strict;
+  return {
+    columns: columns.map(({ name, type, notnull, dflt_value, pk }) => ({
+      name,
+      type,
+      notnull,
+      dflt_value,
+      pk,
+    })),
+    foreignKeys: foreignKeys
+      .map(({ table: target, from, to, on_update, on_delete, match, seq }) =>
+        canonicalJson({ target, from, to, on_update, on_delete, match, seq }),
+      )
+      .sort(),
+    uniqueKeys,
+    strict: Number(strict ?? 0),
+  };
+}
+
+function schemaContract(schema: string): Map<string, TableContract> {
+  const cached = contracts.get(schema);
+  if (cached) return cached;
+  const reference = new DatabaseSync(":memory:");
+  try {
+    reference.exec(schema);
+    const names = reference
+      .prepare(
+        "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%'",
+      )
+      .all() as Row[];
+    const contract = new Map(
+      names.map(({ name }) => [
+        String(name),
+        describeTable(reference, String(name)),
+      ]),
+    );
+    contracts.set(schema, contract);
+    return contract;
+  } finally {
+    reference.close();
+  }
+}
+
+/** Check every required column, key, foreign key and STRICT boundary; permit additive columns. */
+export function matchesSqliteSchema(
+  database: DatabaseSync,
+  schema: string,
+): boolean {
+  for (const [table, expected] of schemaContract(schema)) {
+    const actual = describeTable(database, table);
+    if (
+      actual.strict !== expected.strict ||
+      expected.columns.some(
+        (column) =>
+          !actual.columns.some(
+            (candidate) => canonicalJson(candidate) === canonicalJson(column),
+          ),
+      ) ||
+      canonicalJson(actual.foreignKeys) !==
+        canonicalJson(expected.foreignKeys) ||
+      canonicalJson(actual.uniqueKeys) !== canonicalJson(expected.uniqueKeys)
+    )
+      return false;
+  }
+  return true;
+}
+
+/** Serialize creation and the closed, additive migration set across concurrent openers. */
+export function ensureSqliteSchema(
+  database: DatabaseSync,
+  schema: string,
+  additions: Record<string, Record<string, string>> = {},
+): void {
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    const expected = [...schemaContract(schema).keys()];
+    const present = expected.filter((table) =>
+      database
+        .prepare(
+          "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?",
+        )
+        .get(table),
+    );
+    // An absent namespace is a first open; a partially missing namespace is damaged.
+    if (present.length > 0 && present.length !== expected.length)
+      throw new SqliteSchemaError();
+    database.exec(schema);
+    for (const [table, columns] of Object.entries(additions)) {
+      const existing = new Set(
+        describeTable(database, table).columns.map(({ name }) => name),
+      );
+      for (const [column, declaration] of Object.entries(columns)) {
+        if (!existing.has(column))
+          database.exec(
+            `ALTER TABLE ${identifier(table)} ADD COLUMN ${identifier(column)} ${declaration}`,
+          );
+      }
+    }
+    if (!matchesSqliteSchema(database, schema)) throw new SqliteSchemaError();
+    database.exec("COMMIT");
+  } catch (error) {
+    try {
+      database.exec("ROLLBACK");
+    } catch {
+      /* Preserve the original failure. */
+    }
+    throw error;
+  }
+}

package/src/storage-schema.ts

@@ -0,0 +1,352 @@
+export const ROUTE_HEALTH_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS route_health (
+    route_fingerprint TEXT PRIMARY KEY,
+    state TEXT NOT NULL,
+    next_half_open_at INTEGER,
+    projection_json TEXT NOT NULL
+  ) STRICT;
+`;
+
+/** Owner-private storage contracts. Migrations run atomically before use. */
+export const RUN_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS runs (
+    run_id TEXT PRIMARY KEY,
+    root_hash TEXT NOT NULL,
+    stage TEXT NOT NULL,
+    lookup_key TEXT NOT NULL,
+    change_name TEXT,
+    provisional_key TEXT,
+    state TEXT NOT NULL,
+    sequence INTEGER NOT NULL,
+    event_hash TEXT NOT NULL,
+    delivery_revision INTEGER,
+    projection_json TEXT NOT NULL,
+    terminal_tombstone TEXT,
+    UNIQUE (root_hash, stage, lookup_key)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS delivery_bindings (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    gate TEXT NOT NULL,
+    revision INTEGER NOT NULL,
+    receipt_hash TEXT NOT NULL,
+    approval_revision INTEGER,
+    contract_hash TEXT,
+    record_hash TEXT,
+    operation_id TEXT NOT NULL,
+    PRIMARY KEY (run_id, gate, revision),
+    UNIQUE (run_id, operation_id)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS events (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    sequence INTEGER NOT NULL,
+    type TEXT NOT NULL,
+    payload_json TEXT NOT NULL,
+    prior_hash TEXT NOT NULL,
+    event_hash TEXT NOT NULL,
+    PRIMARY KEY (run_id, sequence),
+    UNIQUE (run_id, event_hash)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS tasks (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    task_id TEXT NOT NULL,
+    state TEXT NOT NULL,
+    phase TEXT,
+    projection_json TEXT NOT NULL,
+    PRIMARY KEY (run_id, task_id)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS operations (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    operation_id TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    state TEXT NOT NULL,
+    outcome_json TEXT,
+    lease_token TEXT,
+    lease_expires_at INTEGER,
+    PRIMARY KEY (run_id, operation_id)
+  ) STRICT;
+
+${ROUTE_HEALTH_SCHEMA}
+
+  CREATE TABLE IF NOT EXISTS artifacts (
+    content_hash TEXT PRIMARY KEY,
+    size_bytes INTEGER NOT NULL,
+    seal_state TEXT NOT NULL,
+    owner_run_id TEXT REFERENCES runs(run_id) ON DELETE CASCADE,
+    reference_count INTEGER NOT NULL
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS workspace_revisions (
+    revision_id TEXT PRIMARY KEY,
+    owner_run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    parent_revision_id TEXT,
+    manifest_hash TEXT NOT NULL
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS apply_transactions (
+    transaction_id TEXT PRIMARY KEY,
+    owner_run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    state TEXT NOT NULL,
+    intent_json TEXT NOT NULL,
+    recovery_json TEXT
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS bootstrap_handoffs (
+    handoff_id TEXT PRIMARY KEY,
+    owner_run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    receipt_hash TEXT NOT NULL UNIQUE,
+    state TEXT NOT NULL,
+    facts_json TEXT NOT NULL
+  ) STRICT;
+`;
+
+export const DESIGN_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS design_facts (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    sequence INTEGER NOT NULL,
+    kind TEXT NOT NULL,
+    identity TEXT NOT NULL,
+    payload_json TEXT NOT NULL,
+    canonical_hash TEXT NOT NULL,
+    prior_record_hash TEXT NOT NULL,
+    record_hash TEXT NOT NULL,
+    PRIMARY KEY (run_id, sequence),
+    UNIQUE (run_id, kind, identity),
+    UNIQUE (run_id, record_hash)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS design_operations (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    operation_id TEXT NOT NULL,
+    operation TEXT NOT NULL,
+    request_hash TEXT NOT NULL,
+    outcome_json TEXT NOT NULL,
+    PRIMARY KEY (run_id, operation_id)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS design_compiled_plans (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    revision INTEGER NOT NULL,
+    fact_sequence INTEGER NOT NULL,
+    raw_sha256 TEXT NOT NULL,
+    canonical_hash TEXT NOT NULL,
+    plan_bytes BLOB NOT NULL,
+    PRIMARY KEY (run_id, revision),
+    UNIQUE (run_id, fact_sequence),
+    FOREIGN KEY (run_id, fact_sequence)
+      REFERENCES design_facts(run_id, sequence) ON DELETE CASCADE
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS design_finalization_leases (
+    run_id TEXT PRIMARY KEY REFERENCES runs(run_id) ON DELETE CASCADE,
+    operation_id TEXT NOT NULL,
+    token TEXT NOT NULL UNIQUE,
+    expires_at INTEGER NOT NULL
+  ) STRICT;
+`;
+
+export const ENGINE_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS workflow_engine_runs (
+    run_id TEXT PRIMARY KEY REFERENCES runs(run_id) ON DELETE CASCADE,
+    current_revision INTEGER,
+    baseline_workspace_revision TEXT,
+    current_workspace_revision TEXT,
+    cleanup_state TEXT NOT NULL DEFAULT 'none',
+    route_id TEXT,
+    route_fingerprint TEXT,
+    transaction_id TEXT,
+    verification_json TEXT,
+    delivery_diagnostics_json TEXT,
+    next_queue_position INTEGER NOT NULL DEFAULT 1
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS workflow_engine_deliveries (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    revision INTEGER NOT NULL,
+    gate TEXT NOT NULL,
+    receipt_hash TEXT NOT NULL,
+    plan_json TEXT NOT NULL,
+    PRIMARY KEY (run_id, revision)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS workflow_engine_tasks (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    task_id TEXT NOT NULL,
+    task_order INTEGER NOT NULL,
+    delivery_revision INTEGER NOT NULL,
+    plan_json TEXT NOT NULL,
+    state TEXT NOT NULL,
+    phase TEXT NOT NULL,
+    pause_code TEXT,
+    context_request_json TEXT,
+    attempt_diagnostic_json TEXT,
+    route_id TEXT,
+    route_fingerprint TEXT,
+    queue_position INTEGER,
+    PRIMARY KEY (run_id, task_id)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS workflow_engine_operations (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    operation_id TEXT NOT NULL,
+    command TEXT NOT NULL,
+    state TEXT NOT NULL,
+    lease_token TEXT,
+    lease_expires_at INTEGER,
+    outcome_json TEXT,
+    PRIMARY KEY (run_id, operation_id)
+  ) STRICT;
+`;
+
+export const RECOVERY_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS workflow_context_reads (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    task_id TEXT NOT NULL,
+    path TEXT NOT NULL,
+    PRIMARY KEY (run_id, task_id, path)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS workflow_work_budget (
+    run_id TEXT PRIMARY KEY REFERENCES runs(run_id) ON DELETE CASCADE,
+    used INTEGER NOT NULL CHECK (used >= 0),
+    max_work INTEGER NOT NULL CHECK (max_work > 0 AND used <= max_work),
+    phase_high_water INTEGER NOT NULL DEFAULT 0,
+    hard_limit INTEGER NOT NULL DEFAULT 512,
+    recovery_policy INTEGER NOT NULL DEFAULT 0
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS workflow_recovery_incidents (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    incident_key TEXT NOT NULL,
+    failures INTEGER NOT NULL CHECK (failures >= 0),
+    max_attempts INTEGER NOT NULL CHECK (max_attempts > 0),
+    feedback_json TEXT NOT NULL,
+    conditions_json TEXT NOT NULL DEFAULT '{}',
+    PRIMARY KEY (run_id, incident_key)
+  ) STRICT;
+
+  CREATE TABLE IF NOT EXISTS workflow_recovery_events (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    sequence INTEGER NOT NULL CHECK (sequence > 0),
+    incident_key TEXT NOT NULL,
+    kind TEXT NOT NULL CHECK (kind IN ('failure', 'resolved', 'repair', 'launch')),
+    PRIMARY KEY (run_id, sequence)
+  ) STRICT;
+`;
+
+// Independent namespace so existing recovery stores remain atomically additive.
+export const AMENDMENT_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS workflow_amendment_budget (
+    run_id TEXT PRIMARY KEY REFERENCES runs(run_id) ON DELETE CASCADE,
+    used INTEGER NOT NULL CHECK (used >= 0 AND used <= 64)
+  ) STRICT;
+`;
+
+export const REJECTED_DELIVERY_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS workflow_rejected_deliveries (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    delivery_revision INTEGER NOT NULL CHECK (delivery_revision > 0),
+    receipt_hash TEXT NOT NULL,
+    PRIMARY KEY (run_id, delivery_revision, receipt_hash)
+  ) STRICT;
+`;
+
+export const TASK_SCHEMA = `
+      CREATE TABLE IF NOT EXISTS candidates (
+        candidate_id TEXT PRIMARY KEY,
+        identity_json TEXT NOT NULL,
+        state TEXT NOT NULL,
+        next_sequence INTEGER NOT NULL,
+        total_bytes INTEGER NOT NULL,
+        artifact_hash TEXT,
+        candidate_hash TEXT,
+        segment_count INTEGER,
+        paths_json TEXT,
+        pause_code TEXT
+      ) STRICT;
+      CREATE TABLE IF NOT EXISTS candidate_segments (
+        candidate_id TEXT NOT NULL REFERENCES candidates(candidate_id) ON DELETE CASCADE,
+        sequence INTEGER NOT NULL,
+        artifact_hash TEXT NOT NULL,
+        size_bytes INTEGER NOT NULL,
+        segment_hash TEXT NOT NULL,
+        PRIMARY KEY (candidate_id, sequence)
+      ) STRICT;
+      CREATE TABLE IF NOT EXISTS task_ledger (
+        run_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        delivery_revision INTEGER NOT NULL,
+        boundary_hash TEXT NOT NULL,
+        objective TEXT NOT NULL,
+        context_refs_json TEXT NOT NULL,
+        initial_phase TEXT NOT NULL,
+        PRIMARY KEY (run_id, task_id)
+      ) STRICT;
+      CREATE TABLE IF NOT EXISTS task_events (
+        run_id TEXT NOT NULL,
+        task_id TEXT NOT NULL,
+        ordinal INTEGER NOT NULL,
+        event_id TEXT NOT NULL,
+        event_json TEXT NOT NULL,
+        prior_hash TEXT NOT NULL,
+        event_hash TEXT NOT NULL,
+        PRIMARY KEY (run_id, task_id, ordinal),
+        UNIQUE (run_id, task_id, event_id),
+        FOREIGN KEY (run_id, task_id) REFERENCES task_ledger(run_id, task_id) ON DELETE CASCADE
+      ) STRICT;
+      CREATE TABLE IF NOT EXISTS durable_facts (
+        fact_key TEXT PRIMARY KEY,
+        fact_json TEXT NOT NULL
+      ) STRICT;
+    `;
+
+export const APPLY_SCHEMA = `
+      CREATE TABLE IF NOT EXISTS apply_transaction_journal (
+        transaction_id TEXT PRIMARY KEY,
+        journal_json TEXT NOT NULL,
+        journal_hash TEXT NOT NULL
+      ) STRICT;
+    `;
+
+export const ENGINE_ADDITIONS = {
+  workflow_engine_runs: {
+    baseline_workspace_revision: "TEXT",
+    current_workspace_revision: "TEXT",
+    cleanup_state: "TEXT NOT NULL DEFAULT 'none'",
+    verification_json: "TEXT",
+    delivery_diagnostics_json: "TEXT",
+    route_fingerprint: "TEXT",
+  },
+  workflow_engine_tasks: {
+    route_fingerprint: "TEXT",
+    context_request_json: "TEXT",
+    attempt_diagnostic_json: "TEXT",
+  },
+};
+
+export const RECOVERY_ADDITIONS = {
+  workflow_work_budget: {
+    phase_high_water: "INTEGER NOT NULL DEFAULT 0",
+    hard_limit: "INTEGER NOT NULL DEFAULT 512",
+    recovery_policy: "INTEGER NOT NULL DEFAULT 0",
+  },
+  workflow_recovery_incidents: {
+    conditions_json: "TEXT NOT NULL DEFAULT '{}'",
+  },
+};
+
+export const RECOVERY_GRANT_SCHEMA = `
+  CREATE TABLE IF NOT EXISTS workflow_recovery_grants (
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    operation_id TEXT NOT NULL,
+    incident_key TEXT NOT NULL,
+    failure_sequence INTEGER NOT NULL,
+    reason TEXT NOT NULL,
+    consumed INTEGER NOT NULL DEFAULT 0 CHECK (consumed IN (0, 1)),
+    PRIMARY KEY (run_id, operation_id),
+    UNIQUE (run_id, incident_key, failure_sequence)
+  ) STRICT;
+`;

package/src/subagent-activity.ts

@@ -532,6 +532,17 @@ function asRecord(value: unknown): Record<string, unknown> | undefined {
     : undefined;
 }
 
+function hasAutomaticContinuation(result: Record<string, unknown>): boolean {
+  const continuation = asRecord(result.continuation);
+  return (
+    ["paused", "approval-needed"].includes(String(result.state)) &&
+    asRecord(result.pause)?.code !== "operation-cancelled" &&
+    continuation?.owner === "parent" &&
+    continuation.automatic === true &&
+    (continuation.action === "amend" || continuation.command === "resume")
+  );
+}
+
 function workflowStateOf(
   result: Record<string, unknown>,
 ): WorkflowActivityState {
@@ -544,6 +555,7 @@ function workflowStateOf(
   ) {
     return "operation-cancelled";
   }
+  if (hasAutomaticContinuation(result)) return "recovering";
   const state = result.state;
   switch (state) {
     case "not-started":
@@ -755,7 +767,8 @@ export function projectWorkflowActivity(
     ...(workflowWait(state, payload)
       ? { wait: workflowWait(state, payload) }
       : {}),
-    ...(nextWorkflowAction(state, legalCommands)
+    ...(!hasAutomaticContinuation(payload) &&
+    nextWorkflowAction(state, legalCommands)
       ? { nextAction: nextWorkflowAction(state, legalCommands) }
       : {}),
   };

package/src/submit-tool.ts

@@ -225,6 +225,7 @@ export interface CandidateContextBoundary {
   writePaths: readonly string[];
   deletePaths?: readonly string[];
   taskPaths: readonly string[];
+  contextReadRoots?: readonly string[];
   redWritePaths: readonly string[];
   agents: {
     impact: "none" | "update-existing" | "create-index" | "remove-index";
@@ -354,6 +355,19 @@ function pathWithinAny(relative: string, approved: readonly string[]): boolean {
   return approved.some((path) => contextRefWithinBoundary(relative, path));
 }
 
+export function permitsContextRead(
+  relative: string,
+  roots: readonly string[],
+): boolean {
+  // Dynamic discovery never grants hidden credentials or a directory tree.
+  return (
+    isValidRelativePath(relative) &&
+    relative.split("/").every((part) => !part.startsWith(".")) &&
+    !/\.(?:pem|key|p12|pfx)$/iu.test(relative) &&
+    pathWithinAny(relative, roots)
+  );
+}
+
 export function classifyCandidateContextRequest(
   request: {
     kind: "context-request";
@@ -377,11 +391,15 @@ export function classifyCandidateContextRequest(
   const ordinaryRequested = requested.filter((ref) => !isAgentsPath(ref.path));
   const outsideOrdinary = ordinaryRequested.filter(
     (ref) =>
+      !(
+        ref.access === "read" &&
+        permitsContextRead(ref.path, boundary.contextReadRoots ?? [])
+      ) &&
       !pathWithinAny(
         ref.path,
         ref.access === "write"
           ? [...boundary.writePaths, ...(boundary.deletePaths ?? [])]
-          : phasePaths,
+          : [...phasePaths, ...boundary.taskPaths],
       ),
   );
   const agentsRequested = requested.filter((ref) => isAgentsPath(ref.path));
@@ -428,7 +446,7 @@ export function classifyCandidateContextRequest(
     classification = { kind: "paused", code: "agents-context-needed" };
   } else {
     classification = {
-      kind: request.code === "approved-context-needed" ? "retryable" : "paused",
+      kind: "retryable",
       code:
         request.code === "task-split-needed"
           ? "task-split-needed"