@bubblebrain-ai/bubble 0.0.34 → 0.0.36

package/dist/agent/discovery-barrier.js

@@ -46,7 +46,7 @@ export class DiscoveryBarrier {
             return undefined;
         return {
             content: `Blocked speculative ${target.kind}. The path "${target.path}" has not been discovered in this repository context ` +
-                "and was not explicitly requested by the user. Run glob/grep/lsp discovery first, then read only returned paths. " +
+                "and was not explicitly requested by the user. Run glob/grep discovery first, then read only returned paths. " +
                 "Do not infer from this blocked call whether the path exists.",
             isError: true,
             status: "blocked",

package/dist/agent/profiles.d.ts

@@ -20,8 +20,6 @@ export interface AgentProfile {
     category?: string;
     tools: AgentProfileTools;
     maxTurns?: number;
-    /** Optional per-child token cap declared by the profile (may only lower the runtime default). */
-    maxTokens?: number;
     approval: AgentProfileApproval;
     nicknameCandidates?: string[];
     prompt: string;
@@ -69,3 +67,4 @@ export declare function allowedToolEffectsForMode(mode: AgentProfileMode): Set<s
 export declare function selectToolsForAgentProfile(tools: ToolRegistryEntry[], profile: AgentProfile, approval?: AgentProfileApproval): ToolRegistryEntry[];
 export declare function validateAgentProfileTools(tools: ToolRegistryEntry[], profile: AgentProfile, approval?: AgentProfileApproval): AgentProfileDiagnostic[];
 export declare function mergeUsage(current: SubagentRunResult["usage"], usage: TokenUsage): SubagentRunResult["usage"];
+export declare function canonicalToolName(name: string): string;

package/dist/agent/profiles.js

@@ -10,21 +10,17 @@ const READONLY_PRESET = [
     "lsp",
     "web_search",
     "web_fetch",
-    "memory_search",
-    "memory_read_summary",
+    "memory",
     "skill",
     "todo_write",
 ];
 const SUBAGENT_DENY_TOOLS = new Set([
     "subagent",
-    "task",
     "spawn_agent",
     "wait_agent",
     "send_input",
     "close_agent",
     "list_agents",
-    "agent_team",
-    "agent_batch",
     "run_workflow",
     "wait_workflow",
 ]);
@@ -128,12 +124,12 @@ export function builtinAgentProfiles() {
             "You are an explorer subagent for codebase reconnaissance.",
             "Answer the specific question by inspecting the repository directly. Prefer precise file paths and line-level evidence.",
             "Keep the answer compact and avoid broad refactors or implementation plans unless asked.",
-        ].join("\n"), ["read", "glob", "grep", "lsp", "memory_search", "memory_read_summary", "skill", "todo_write"]),
+        ].join("\n"), ["read", "glob", "grep", "lsp", "memory", "skill", "todo_write"]),
         roleProfile("worker", "Implementation-planning worker subagent", [
             "You are a worker subagent. In this Phase 1 runtime you are read-only, so you must not modify files.",
             "Analyze the assigned implementation slice, identify exact files to change, and return a concrete patch plan or findings.",
             "If write-capable worker mode is needed, say so explicitly.",
-        ].join("\n"), ["read", "glob", "grep", "lsp", "memory_search", "memory_read_summary", "skill", "todo_write"]),
+        ].join("\n"), ["read", "glob", "grep", "lsp", "memory", "skill", "todo_write"]),
         toProfile("search"),
         toProfile("security_investigation"),
         toProfile("evidence_correlation"),
@@ -169,7 +165,7 @@ export function allowedToolEffectsForMode(mode) {
         : new Set(["read"]);
 }
 export function selectToolsForAgentProfile(tools, profile, approval = profile.approval) {
-    const explicitInclude = new Set(profile.tools.include ?? []);
+    const explicitInclude = new Set((profile.tools.include ?? []).map(canonicalToolName));
     const selected = requestedToolNames(profile);
     for (const tool of SUBAGENT_DENY_TOOLS)
         selected.delete(tool);
@@ -185,13 +181,17 @@ export function selectToolsForAgentProfile(tools, profile, approval = profile.ap
             continue;
         if (approval === "disabled" && tool.requiresApproval)
             continue;
-        out.push(wrapApprovalFailTool(tool, approval));
+        // Explicit include is the profile author pre-unlocking the tool: the
+        // child is a fresh Agent with its own (empty) unlock set, so a deferred
+        // flag surviving here would re-lock the tool inside the child.
+        const entry = tool.deferred ? { ...tool, deferred: false } : tool;
+        out.push(wrapApprovalFailTool(entry, approval));
     }
     return out;
 }
 export function validateAgentProfileTools(tools, profile, approval = profile.approval) {
     const available = new Map(tools.map((tool) => [tool.name, tool]));
-    const explicitInclude = new Set(profile.tools.include ?? []);
+    const explicitInclude = new Set((profile.tools.include ?? []).map(canonicalToolName));
     const allowedEffects = allowedToolEffectsForMode(profile.mode);
     const diagnostics = [];
     for (const name of requestedToolNames(profile)) {
@@ -258,6 +258,18 @@ function wrapApprovalFailTool(tool, approval) {
         }),
     };
 }
+/**
+ * Renamed/merged tools keep working for user-defined profiles written
+ * against the old names (memory_search/memory_read_summary merged into
+ * "memory", 2026-07-13).
+ */
+const LEGACY_TOOL_ALIASES = {
+    memory_search: "memory",
+    memory_read_summary: "memory",
+};
+export function canonicalToolName(name) {
+    return LEGACY_TOOL_ALIASES[name] ?? name;
+}
 function requestedToolNames(profile) {
     const selected = new Set();
     if (profile.tools.preset === "readonly") {
@@ -266,12 +278,12 @@ function requestedToolNames(profile) {
     }
     else if (profile.tools.preset === "explicit") {
         for (const tool of profile.tools.include ?? [])
-            selected.add(tool);
+            selected.add(canonicalToolName(tool));
     }
     for (const tool of profile.tools.include ?? [])
-        selected.add(tool);
+        selected.add(canonicalToolName(tool));
     for (const tool of profile.tools.exclude ?? [])
-        selected.delete(tool);
+        selected.delete(canonicalToolName(tool));
     return selected;
 }
 function loadProfilesFromDir(dir, source, diagnostics) {
@@ -323,7 +335,6 @@ function parseAgentProfileFile(raw, source, filePath) {
         category: stringValue(frontmatter.category),
         tools: toolsValue(frontmatter.tools),
         maxTurns: numberValue(frontmatter.maxTurns),
-        maxTokens: numberValue(frontmatter.maxTokens),
         approval: approvalValue(frontmatter.approval),
         nicknameCandidates: stringArray(frontmatter.nicknameCandidates) ?? stringArray(frontmatter.nicknames),
         prompt: parsed.body.trim(),

package/dist/agent/routing-catalog.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Routing catalog: the single source of catalog truth for subagent model
+ * routing (docs/model-routing-design.md §1).
+ *
+ * No routing consumer reads `listBuiltinModels` / `getConfigured` directly —
+ * neither reflects what is actually runnable. Consumers read a
+ * `RoutingSnapshot` through the live accessor created here; the accessor
+ * caches by the registry's routing revision and rebuilds lazily, so tier
+ * resolution, validation, the detector, and the menu are never stale (§1.5).
+ */
+import { type ModelTier } from "../model-catalog.js";
+import type { ProviderRegistry } from "../provider-registry.js";
+import { selectTierCandidates, type AgentCategoriesConfig, type TierRoutingContext } from "./categories.js";
+import type { ThinkingLevel } from "../types.js";
+export interface AgentRoutingConfig {
+    /** Automatic builtin-tier downgrade routing (§3.2). */
+    autoTier: boolean;
+    /** Call-site cross-provider routing; default open, set false to lock (§7.2). */
+    allowCrossProvider: boolean;
+}
+export declare const DEFAULT_AGENT_ROUTING: AgentRoutingConfig;
+export declare function sanitizeAgentRouting(value: unknown): AgentRoutingConfig;
+export interface RoutingModelEntry {
+    id: string;
+    name: string;
+    tier?: ModelTier;
+    routingPriority?: number;
+    /** Index in the builtin catalog order, when the id is builtin (§3.2 tiebreak). */
+    builtinIndex?: number;
+    source: "builtin" | "dynamic" | "custom";
+}
+export type RoutingMembershipSource = "custom-allowlist" | "complete-discovery" | "fallback-union";
+export interface RoutingSnapshot {
+    parent: {
+        providerId: string;
+        model: string;
+        tier?: ModelTier;
+    };
+    /** Catalog-effective provider id (openai OAuth -> "openai-codex" alias). */
+    effectiveProviderId: string;
+    membershipSource: RoutingMembershipSource;
+    /** Model list for the PARENT provider only (§1.2 scope note). */
+    models: RoutingModelEntry[];
+    /** True iff membershipSource === "custom-allowlist" — the only catalog
+     *  that hard-rejects unknown ids (§1.4). */
+    authoritative: boolean;
+    registryRevision: number;
+    /**
+     * Earliest expiry of the discovery data this snapshot consumed. TTL expiry
+     * is passive — it bumps no revision — so the accessor must rebuild past
+     * this instant or it serves a catalog the registry itself no longer would.
+     */
+    discoveryExpiresAt?: number;
+    /** Provider ids with active credentials (getEnabled, §1.1). */
+    runnableProviderIds: string[];
+    /** Post-merge, post-tier-resolution category bindings (§3). */
+    resolvedCategories: Array<{
+        name: string;
+        model: string | "inherit";
+        thinkingLevel?: ThinkingLevel;
+        tierSource?: "builtin" | "user";
+    }>;
+}
+export type RoutingSnapshotAccessor = (parent: {
+    providerId: string;
+    model: string;
+}) => RoutingSnapshot;
+/**
+ * Membership versus metadata (§1.3): an authoritative source alone decides
+ * which ids exist; lower-priority sources only enrich per-field metadata
+ * (tier: dynamic ?? custom ?? builtin).
+ */
+export declare function buildRoutingSnapshot(registry: ProviderRegistry, parent: {
+    providerId: string;
+    model: string;
+}, agentCategories: AgentCategoriesConfig, agentRouting: AgentRoutingConfig): RoutingSnapshot;
+/** Tier-resolution context derived from a snapshot (consumed by categories §3.2). */
+export declare function tierContextFromSnapshot(snapshot: RoutingSnapshot, agentRouting: AgentRoutingConfig): TierRoutingContext;
+/**
+ * Live accessor (§1.5): caches by (routing revision, parent route) and
+ * rebuilds lazily, so a discovery completion or provider mutation is
+ * reflected at the very next read. Building is synchronous over cached
+ * registry state — microseconds, never I/O.
+ */
+export declare function createRoutingSnapshotAccessor(registry: ProviderRegistry, getAgentCategories: () => AgentCategoriesConfig, getAgentRouting: () => AgentRoutingConfig): RoutingSnapshotAccessor;
+/** Tier of a model within a snapshot, when known. */
+export declare function snapshotModelTier(snapshot: RoutingSnapshot, modelId: string): ModelTier | undefined;
+export interface RoutableModelEntry {
+    /** Routable provider id — what goes before the colon in provider:model. */
+    providerId: string;
+    id: string;
+    name: string;
+}
+export type RoutableModelIndex = () => RoutableModelEntry[];
+/** Revision-cached index over all runnable providers' catalogs. */
+export declare function createRoutableModelIndex(registry: ProviderRegistry): RoutableModelIndex;
+/** Loose normalization for model-name matching: case/punctuation-insensitive. */
+export declare function normalizeModelToken(value: string): string;
+/**
+ * Near-match candidates for a (probably mistyped) model id within one
+ * provider's catalog. "suggest" matches normalized prefixes in either
+ * direction (soft "did you mean" notes). "truncation" matches only inputs
+ * the catalog EXTENDS ("gpt-5.6" -> gpt-5.6-sol/-terra/-luna) — the one
+ * direction that is typo evidence. An input extending a catalog id
+ * (gpt-5.6-sol-20260701 vs cataloged gpt-5.6-sol) is more likely a newly
+ * released variant the local catalog lags on, and must not be treated as a
+ * typo by hard-reject paths. Capped, deterministic order.
+ */
+export declare function nearModelMatches(input: string, candidates: RoutableModelEntry[], options?: {
+    limit?: number;
+    mode?: "suggest" | "truncation";
+}): string[];
+export { selectTierCandidates };

package/dist/agent/routing-catalog.js

@@ -0,0 +1,240 @@
+/**
+ * Routing catalog: the single source of catalog truth for subagent model
+ * routing (docs/model-routing-design.md §1).
+ *
+ * No routing consumer reads `listBuiltinModels` / `getConfigured` directly —
+ * neither reflects what is actually runnable. Consumers read a
+ * `RoutingSnapshot` through the live accessor created here; the accessor
+ * caches by the registry's routing revision and rebuilds lazily, so tier
+ * resolution, validation, the detector, and the menu are never stale (§1.5).
+ */
+import { getBuiltinModel, listBuiltinModels, listDynamicModelMetadata, } from "../model-catalog.js";
+import { mergeAgentCategoriesWithProvenance, resolveSubagentRoute, selectTierCandidates, } from "./categories.js";
+export const DEFAULT_AGENT_ROUTING = {
+    autoTier: true,
+    allowCrossProvider: true,
+};
+export function sanitizeAgentRouting(value) {
+    const config = { ...DEFAULT_AGENT_ROUTING };
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const record = value;
+        if (typeof record.autoTier === "boolean")
+            config.autoTier = record.autoTier;
+        if (typeof record.allowCrossProvider === "boolean") {
+            config.allowCrossProvider = record.allowCrossProvider;
+        }
+    }
+    return config;
+}
+/**
+ * Membership versus metadata (§1.3): an authoritative source alone decides
+ * which ids exist; lower-priority sources only enrich per-field metadata
+ * (tier: dynamic ?? custom ?? builtin).
+ */
+export function buildRoutingSnapshot(registry, parent, agentCategories, agentRouting) {
+    const configured = registry.getConfigured().find((item) => item.id === parent.providerId);
+    const effectiveProviderId = parent.providerId === "openai" && configured?.authType === "oauth"
+        ? "openai-codex"
+        : parent.providerId;
+    const builtins = listBuiltinModels(effectiveProviderId);
+    const builtinIndex = new Map(builtins.map((model, index) => [model.id, index]));
+    const dynamic = listDynamicModelMetadata(effectiveProviderId);
+    const custom = registry.getModelConfig().getCustomModels(parent.providerId);
+    const discovery = registry.getCachedDiscoverySnapshot(parent.providerId);
+    const metadataFor = (id) => {
+        const dynamicEntry = dynamic.find((model) => model.id === id);
+        const discoveryEntry = discovery?.models.find((model) => model.id === id);
+        const customEntry = custom.find((model) => model.id === id);
+        const builtinEntry = builtins.find((model) => model.id === id);
+        return {
+            id,
+            name: dynamicEntry?.name ?? discoveryEntry?.name ?? customEntry?.name ?? builtinEntry?.name ?? id,
+            // Field-level merge (§1.3): discovery decides existence, but tier falls
+            // back through custom to builtin when the fresher source omits it.
+            tier: dynamicEntry?.tier ?? discoveryEntry?.tier ?? customEntry?.tier ?? builtinEntry?.tier,
+            routingPriority: customEntry?.routingPriority,
+            builtinIndex: builtinIndex.get(id),
+        };
+    };
+    let membershipSource;
+    let memberIds;
+    const memberSource = new Map();
+    if (custom.length > 0) {
+        membershipSource = "custom-allowlist";
+        memberIds = custom.map((model) => model.id);
+        for (const id of memberIds)
+            memberSource.set(id, "custom");
+    }
+    else if (discovery && discovery.complete) {
+        membershipSource = "complete-discovery";
+        memberIds = discovery.models.map((model) => model.id);
+        for (const id of memberIds)
+            memberSource.set(id, "dynamic");
+    }
+    else {
+        membershipSource = "fallback-union";
+        memberIds = [];
+        for (const model of dynamic) {
+            if (!memberSource.has(model.id)) {
+                memberSource.set(model.id, "dynamic");
+                memberIds.push(model.id);
+            }
+        }
+        for (const model of custom) {
+            if (!memberSource.has(model.id)) {
+                memberSource.set(model.id, "custom");
+                memberIds.push(model.id);
+            }
+        }
+        for (const model of builtins) {
+            if (!memberSource.has(model.id)) {
+                memberSource.set(model.id, "builtin");
+                memberIds.push(model.id);
+            }
+        }
+    }
+    const models = memberIds.map((id) => ({
+        ...metadataFor(id),
+        source: memberSource.get(id) ?? "builtin",
+    }));
+    const parentTier = models.find((model) => model.id === parent.model)?.tier
+        ?? getBuiltinModel(effectiveProviderId, parent.model)?.tier;
+    const runnableProviderIds = registry.getEnabled().map((provider) => provider.id);
+    return {
+        parent: { ...parent, tier: parentTier },
+        effectiveProviderId,
+        membershipSource,
+        models,
+        authoritative: membershipSource === "custom-allowlist",
+        registryRevision: registry.getRoutingRevision(),
+        discoveryExpiresAt: discovery?.expiresAt,
+        runnableProviderIds,
+        resolvedCategories: resolveCategoriesForMenu(parent, parentTier, models, agentCategories, agentRouting),
+    };
+}
+/** Tier-resolution context derived from a snapshot (consumed by categories §3.2). */
+export function tierContextFromSnapshot(snapshot, agentRouting) {
+    return {
+        parentTier: snapshot.parent.tier,
+        models: snapshot.models.map((model) => ({
+            id: model.id,
+            tier: model.tier,
+            routingPriority: model.routingPriority,
+            builtinIndex: model.builtinIndex,
+        })),
+        autoTier: agentRouting.autoTier,
+    };
+}
+/**
+ * Live accessor (§1.5): caches by (routing revision, parent route) and
+ * rebuilds lazily, so a discovery completion or provider mutation is
+ * reflected at the very next read. Building is synchronous over cached
+ * registry state — microseconds, never I/O.
+ */
+export function createRoutingSnapshotAccessor(registry, getAgentCategories, getAgentRouting) {
+    let cached;
+    return (parent) => {
+        if (cached
+            && cached.registryRevision === registry.getRoutingRevision()
+            && cached.parent.providerId === parent.providerId
+            && cached.parent.model === parent.model
+            && (cached.discoveryExpiresAt === undefined || Date.now() < cached.discoveryExpiresAt)) {
+            return cached;
+        }
+        cached = buildRoutingSnapshot(registry, parent, getAgentCategories(), getAgentRouting());
+        return cached;
+    };
+}
+function resolveCategoriesForMenu(parent, parentTier, models, agentCategories, agentRouting) {
+    const merged = mergeAgentCategoriesWithProvenance(agentCategories);
+    const tierContext = {
+        parentTier,
+        models: models.map((model) => ({
+            id: model.id,
+            tier: model.tier,
+            routingPriority: model.routingPriority,
+            builtinIndex: model.builtinIndex,
+        })),
+        autoTier: agentRouting.autoTier,
+    };
+    return Object.entries(merged).map(([name, entry]) => {
+        const resolution = resolveSubagentRoute(name, { providerId: parent.providerId, model: parent.model, thinkingLevel: "medium" }, agentCategories, tierContext);
+        const route = "route" in resolution ? resolution.route : undefined;
+        return {
+            name,
+            model: route && route.model !== parent.model ? route.model : "inherit",
+            thinkingLevel: entry.config.thinkingLevel,
+            tierSource: entry.provenance.tierSource,
+        };
+    });
+}
+/** Tier of a model within a snapshot, when known. */
+export function snapshotModelTier(snapshot, modelId) {
+    return snapshot.models.find((model) => model.id === modelId)?.tier;
+}
+/** Revision-cached index over all runnable providers' catalogs. */
+export function createRoutableModelIndex(registry) {
+    let cachedRevision = -1;
+    let cached = [];
+    return () => {
+        const revision = registry.getRoutingRevision();
+        if (revision === cachedRevision)
+            return cached;
+        const entries = [];
+        for (const provider of registry.getEnabled()) {
+            const effectiveProviderId = provider.id === "openai" && provider.authType === "oauth"
+                ? "openai-codex"
+                : provider.id;
+            const seen = new Set();
+            const push = (id, name) => {
+                if (seen.has(id))
+                    return;
+                seen.add(id);
+                entries.push({ providerId: provider.id, id, name });
+            };
+            for (const model of registry.getModelConfig().getCustomModels(provider.id))
+                push(model.id, model.name);
+            for (const model of listDynamicModelMetadata(effectiveProviderId))
+                push(model.id, model.name);
+            for (const model of listBuiltinModels(effectiveProviderId))
+                push(model.id, model.name);
+        }
+        cachedRevision = revision;
+        cached = entries;
+        return cached;
+    };
+}
+/** Loose normalization for model-name matching: case/punctuation-insensitive. */
+export function normalizeModelToken(value) {
+    return value.toLowerCase().replace(/[-._\s]/g, "");
+}
+/**
+ * Near-match candidates for a (probably mistyped) model id within one
+ * provider's catalog. "suggest" matches normalized prefixes in either
+ * direction (soft "did you mean" notes). "truncation" matches only inputs
+ * the catalog EXTENDS ("gpt-5.6" -> gpt-5.6-sol/-terra/-luna) — the one
+ * direction that is typo evidence. An input extending a catalog id
+ * (gpt-5.6-sol-20260701 vs cataloged gpt-5.6-sol) is more likely a newly
+ * released variant the local catalog lags on, and must not be treated as a
+ * typo by hard-reject paths. Capped, deterministic order.
+ */
+export function nearModelMatches(input, candidates, options = {}) {
+    const limit = options.limit ?? 5;
+    const mode = options.mode ?? "suggest";
+    const normalized = normalizeModelToken(input);
+    if (normalized.length < 3)
+        return [];
+    return candidates
+        .filter((candidate) => {
+        const other = normalizeModelToken(candidate.id);
+        if (other === normalized)
+            return false;
+        if (other.startsWith(normalized))
+            return true;
+        return mode === "suggest" && normalized.startsWith(other);
+    })
+        .map((candidate) => candidate.id)
+        .sort()
+        .slice(0, limit);
+}
+export { selectTierCandidates };

package/dist/agent/subagent-control.d.ts

@@ -8,17 +8,8 @@ export type SubagentThreadStatus = "queued" | "running" | "completed" | "failed"
  * rendered in lifecycle tool replies (design doc §3.1) — a resume hint is
  * emitted iff the runtime judged the run resumable, never as a blanket string.
  */
-export type SubagentFinalReason = "completed" | "failed_transient" | "failed_fatal" | "rate_limited_exhausted" | "blocked" | "cancelled_interrupt" | "cancelled_user" | "cancelled_budget" | "cancelled_parent_abort";
+export type SubagentFinalReason = "completed" | "failed_transient" | "failed_fatal" | "rate_limited_exhausted" | "blocked" | "cancelled_interrupt" | "cancelled_user" | "cancelled_parent_abort";
 export declare function isResumableReason(reason: SubagentFinalReason): boolean;
-/** Per-child token budget, fixed at dispatch time (design doc §6). */
-export interface SubagentTokenCap {
-    /** Soft cap: crossing it injects a wrap-up reminder into the child. */
-    soft: number;
-    /** Hard cap: crossing it aborts this child only. Updated at turn checks. */
-    hard: number;
-    /** Ledger tokens already attributed to this child when the run started. */
-    baseline: number;
-}
 export interface SubagentThreadSnapshot {
     agentId: string;
     runId: string;
@@ -40,7 +31,6 @@ export interface SubagentThreadSnapshot {
     deliveredAt?: number;
     /** 1-based position in the scheduler queue while status is "queued". */
     queuePosition?: number;
-    tokenCap?: SubagentTokenCap;
     /** Present for write_worktree children: where the isolated checkout lives. */
     worktree?: SubagentWorktree;
 }
@@ -63,8 +53,11 @@ export interface SubagentThreadRecord {
     createdAt: number;
     updatedAt: number;
     deliveredAt?: number;
-    tokenCap?: SubagentTokenCap;
     worktree?: SubagentWorktree;
+    /** True when the child was asked for schema-validated structured output:
+     * a compact JSON handoff is complete by construction, so the token-floor
+     * restate turn must not fire on it. */
+    expectsStructuredOutput?: boolean;
     /** True for agents spawned inside a run_workflow: kept out of list_agents /
      * wait_agent and not persisted (design v2 appendix; option C). */
     workflowInternal?: boolean;

package/dist/agent/subagent-control.js

@@ -9,7 +9,6 @@ export function isResumableReason(reason) {
         case "completed":
         case "failed_fatal":
         case "blocked":
-        case "cancelled_budget":
             return false;
     }
 }
@@ -33,7 +32,6 @@ export function snapshotSubagentThread(record) {
         createdAt: record.createdAt,
         updatedAt: record.updatedAt,
         deliveredAt: record.deliveredAt,
-        tokenCap: record.tokenCap ? { ...record.tokenCap } : undefined,
         worktree: record.worktree ? { ...record.worktree } : undefined,
     };
 }

package/dist/agent/subagent-store.d.ts

@@ -7,7 +7,7 @@
  * Persistence (design §7): final-state children are written to
  * `<persistDir>/<agentId>.json` as snapshot + compacted message history, so a
  * later process can resume them via send_input. The on-disk schema carries
- * `finalReason` / `resumable` / `deliveredAt` / `tokenCap` — the fields the
+ * `finalReason` / `resumable` / `deliveredAt` — the fields the
  * reply protocol and delivery dedup depend on. Child transcripts never mix
  * into the parent transcript.
  */

package/dist/agent/subagent-store.js

@@ -7,7 +7,7 @@
  * Persistence (design §7): final-state children are written to
  * `<persistDir>/<agentId>.json` as snapshot + compacted message history, so a
  * later process can resume them via send_input. The on-disk schema carries
- * `finalReason` / `resumable` / `deliveredAt` / `tokenCap` — the fields the
+ * `finalReason` / `resumable` / `deliveredAt` — the fields the
  * reply protocol and delivery dedup depend on. Child transcripts never mix
  * into the parent transcript.
  */
@@ -84,7 +84,6 @@ export class SubagentStore {
                 createdAt: record.createdAt,
                 updatedAt: record.updatedAt,
                 deliveredAt: record.deliveredAt,
-                tokenCap: record.tokenCap,
                 messages: record.agent?.messages ?? record.messages,
             };
             writeFileSync(join(this.persistDir, `${record.agentId}.json`), JSON.stringify(payload));
@@ -135,7 +134,6 @@ export class SubagentStore {
                     createdAt: parsed.createdAt,
                     updatedAt: parsed.updatedAt,
                     deliveredAt: parsed.deliveredAt,
-                    tokenCap: parsed.tokenCap,
                     abortController: new AbortController(),
                     waiters: new Set(),
                     messages: parsed.messages,

package/dist/agent/workflow/control.d.ts

@@ -16,6 +16,8 @@ export interface WorkflowRunRecord {
     snapshots: SubagentThreadSnapshot[];
     logs: string[];
     result?: WorkflowResult;
+    /** Where the full rendered result was persisted (unset if the write failed). */
+    resultPath?: string;
     abortController: AbortController;
     waiters: Set<() => void>;
     promise?: Promise<void>;
@@ -30,8 +32,27 @@ export interface WorkflowRunSnapshot {
     status: WorkflowRunStatus;
     agentCount: number;
     result?: WorkflowResult;
+    resultPath?: string;
     logs: string[];
     snapshots: SubagentThreadSnapshot[];
 }
 /** System-reminder injected at the next turn when a background workflow finishes. */
+/**
+ * Failed members must surface in EVERY channel that renders a finished
+ * workflow (delivery notice and wait_workflow): agent() converts failures to
+ * null inside the script, so without this line a "completed" workflow could
+ * silently omit items whose agents never delivered.
+ */
+export declare function workflowMemberWarning(snapshot: WorkflowRunSnapshot): string | undefined;
+/** Chars of the result shown inline; the full rendering is persisted to resultPath. */
+export declare const WORKFLOW_RESULT_PREVIEW_LIMIT = 8000;
+export declare function renderWorkflowResultValue(value: unknown): string;
+/**
+ * Result block shared by every channel that hands a finished workflow to the
+ * parent (delivery notice and wait_workflow). Truncation must preserve line
+ * structure — the value is often pretty-printed JSON or markdown — and a cut
+ * preview must always point at the persisted full result plus the durable fix
+ * (distill inside the script), or the parent silently works from partial data.
+ */
+export declare function buildWorkflowResultBlock(snapshot: WorkflowRunSnapshot, limit?: number): string[];
 export declare function buildWorkflowDeliveryNotice(snapshot: WorkflowRunSnapshot): string;