@abot-ai/runtime 1.5.0 → 1.6.0

package/plugins/system-probe/src/index.cjs

@@ -96,8 +96,28 @@ function defineRuntimePlugin(definition) {
   return definition;
 }
 
+// src/capabilities/tool-context-text.ts
+function hasValidToolContextText(carrier) {
+  const fields = carrier.contextTextFields;
+  if (fields === void 0) return true;
+  if (!Array.isArray(fields) || fields.length === 0 || fields.length > 3)
+    return false;
+  if (new Set(fields).size !== fields.length) return false;
+  for (const field of fields) {
+    if (!isContextTextField(field)) return false;
+    if (typeof carrier[field] !== "string") return false;
+  }
+  return true;
+}
+function isContextTextField(value) {
+  return value === "output" || value === "stdout" || value === "stderr";
+}
+
+// src/capabilities/result-budget.ts
+var CAPABILITY_RESULT_ENVELOPE_MAX_BYTES = 256 * 1024;
+
 // src/plugin-sdk/results.ts
-var PLUGIN_RESULT_SERIALIZED_MAX_BYTES = 128 * 1024;
+var PLUGIN_RESULT_SERIALIZED_MAX_BYTES = CAPABILITY_RESULT_ENVELOPE_MAX_BYTES;
 function resultBoundsFailure(code, message) {
   return {
     ok: false,
@@ -107,9 +127,27 @@ function resultBoundsFailure(code, message) {
     errorCode: code
   };
 }
-function enforcePluginResultByteBudget(result) {
-  let serialized;
+function enforcePluginResultByteBudget(result, resultBudget) {
+  let requiresContextTextHost = false;
+  let serializedBytes;
+  let envelopeBytes;
+  let maxBytes = PLUGIN_RESULT_SERIALIZED_MAX_BYTES;
+  let fitsDeclaredBudget = true;
   try {
+    if (!hasValidToolContextText(result)) {
+      return resultBoundsFailure(
+        "plugin_context_text_invalid",
+        "The plugin declared invalid context text fields."
+      );
+    }
+    requiresContextTextHost = result.contextTextFields !== void 0;
+    const lacksContextTextHost = requiresContextTextHost && resultBudget?.acceptsContextText !== true;
+    if (lacksContextTextHost) {
+      return resultBoundsFailure(
+        "plugin_context_text_unavailable",
+        "The host does not support context-managed tool text."
+      );
+    }
     const candidate = JSON.stringify(result);
     if (candidate === void 0) {
       return resultBoundsFailure(
@@ -117,50 +155,60 @@ function enforcePluginResultByteBudget(result) {
         "The plugin produced a result that is not JSON-safe."
       );
     }
-    serialized = candidate;
+    const assessment = resultBudget?.assess(result);
+    serializedBytes = assessment?.serializedBytes ?? Buffer.byteLength(candidate, "utf8");
+    envelopeBytes = assessment?.envelopeBytes ?? serializedBytes;
+    maxBytes = Math.min(assessment?.maxBytes ?? maxBytes, maxBytes);
+    fitsDeclaredBudget = assessment?.fits ?? true;
   } catch {
     return resultBoundsFailure(
       "plugin_result_not_json_safe",
       "The plugin produced a result that is not JSON-safe."
     );
   }
-  if (Buffer.byteLength(serialized, "utf8") > PLUGIN_RESULT_SERIALIZED_MAX_BYTES) {
-    return resultBoundsFailure(
-      "plugin_result_too_large",
-      `The plugin result exceeds the ${PLUGIN_RESULT_SERIALIZED_MAX_BYTES}-byte safety limit.`
-    );
+  const hasResultDeliveryHeadroom = fitsDeclaredBudget && envelopeBytes <= maxBytes;
+  if (!hasResultDeliveryHeadroom) {
+    const message = requiresContextTextHost ? `The plugin result envelope is ${envelopeBytes} bytes (${serializedBytes} total bytes) and exceeds the ${maxBytes}-byte delivery limit.` : `The plugin result is ${serializedBytes} bytes and exceeds the ${maxBytes}-byte delivery limit.`;
+    return resultBoundsFailure("plugin_result_too_large", message);
   }
   return result;
 }
-function successResult(input) {
-  return enforcePluginResultByteBudget({
-    ok: true,
-    ...input.media !== void 0 ? { media: input.media } : {},
-    output: input.output,
-    producedNewInformation: input.producedNewInformation ?? true,
-    ...input.progress !== void 0 ? { progress: input.progress } : {},
-    ...input.actions !== void 0 ? { actions: input.actions } : {},
-    ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
-    ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
-    ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
-    ...input.data !== void 0 ? { data: input.data } : {}
-  });
+function successResult(input, resultBudget) {
+  return enforcePluginResultByteBudget(
+    {
+      ok: true,
+      ...input.media !== void 0 ? { media: input.media } : {},
+      output: input.output,
+      producedNewInformation: input.producedNewInformation ?? true,
+      ...input.progress !== void 0 ? { progress: input.progress } : {},
+      ...input.actions !== void 0 ? { actions: input.actions } : {},
+      ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
+      ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
+      ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
+      ...input.data !== void 0 ? { data: input.data } : {}
+    },
+    resultBudget
+  );
 }
-function failureResult(input) {
-  return enforcePluginResultByteBudget({
-    ok: false,
-    ...input.media !== void 0 ? { media: input.media } : {},
-    output: input.output ?? input.message,
-    producedNewInformation: false,
-    ...input.progress !== void 0 ? { progress: input.progress } : {},
-    ...input.actions !== void 0 ? { actions: input.actions } : {},
-    ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
-    ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
-    ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
-    ...input.data !== void 0 ? { data: input.data } : {},
-    error: input.message,
-    errorCode: input.errorCode
-  });
+function failureResult(input, resultBudget) {
+  return enforcePluginResultByteBudget(
+    {
+      ok: false,
+      ...input.interruption ? { interruption: input.interruption } : {},
+      ...input.media !== void 0 ? { media: input.media } : {},
+      output: input.output ?? input.message,
+      producedNewInformation: false,
+      ...input.progress !== void 0 ? { progress: input.progress } : {},
+      ...input.actions !== void 0 ? { actions: input.actions } : {},
+      ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
+      ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
+      ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
+      ...input.data !== void 0 ? { data: input.data } : {},
+      error: input.message,
+      errorCode: input.errorCode
+    },
+    resultBudget
+  );
 }
 function failureFromError(error, options) {
   const pathCode = runtimeToolPathErrorCode(error);
@@ -226,10 +274,14 @@ function filesystemErrorCode(error) {
 }
 var index_default = defineRuntimePlugin((context) => ({
   handlers: {
-    async system_probe(params) {
+    async system_probe(params, executionContext = void 0) {
       const explicitPath = readOptionalString(params.path);
+      const pathContext = {
+        ...context,
+        runtimePathResolver: executionContext?.runtimePathResolver ?? context.runtimePathResolver
+      };
       try {
-        const target = resolvePluginPath(context, explicitPath ?? "/", {
+        const target = resolvePluginPath(pathContext, explicitPath ?? "/", {
           requirePath: true,
           allowedLocations: ALLOWED_PATH_LOCATIONS
         });

package/plugins/web/README.md

@@ -5,6 +5,15 @@ providers. A trimmed, non-empty `braveSearchApiKey` selects Brave. An absent or
 blank key selects Light. Provider selection happens when the plugin loads;
 Brave failures never trigger a second search through Light.
 
+## Brave source retrieval
+
+Brave results remain available when an optional source-page fetch times out.
+The failed page is recorded in `sourceFetchErrors` and its source receipt;
+coverage reports the evidence actually retrieved, including weak coverage when
+only search snippets are available. Caller cancellation and the overall search
+deadline still fail the request. Brave API timeouts and direct `web_fetch`
+timeouts remain failures; no retry or provider fallback is added.
+
 ## Light search
 
 Light retrieves public origin pages, publisher feeds, and sitemaps from a

package/plugins/web/source/plugin.ts

@@ -29,11 +29,13 @@ export type WebPluginDependencies = Readonly<{
   httpClient?: PublicHttpClient;
 }>;
 
-function failure(error: unknown, operation: string) {
+function failure(error: unknown, operation: string, signal?: AbortSignal) {
   const lightFailure = lightSearchFailureResult(error);
   if (lightFailure) return lightFailure;
   if (isWebPluginError(error)) {
+    const abortedByCaller = signal?.aborted === true && error.code === "web_request_aborted";
     return failureResult({
+      ...(abortedByCaller ? { interruption: "aborted" as const } : {}),
       errorCode: error.code,
       message: error.message,
       output: `${operation} failed: ${error.message}`,
@@ -99,7 +101,7 @@ export function createWebPlugin(
           { version: 1, operation: "fetch", sources: presentation.sources },
         );
       } catch (error) {
-        return failure(error, "web_fetch");
+        return failure(error, "web_fetch", executionContext?.abortSignal);
       }
     },
     async web_search(params, executionContext) {
@@ -151,7 +153,7 @@ export function createWebPlugin(
           search.webSources,
         );
       } catch (error) {
-        return failure(error, "web_search");
+        return failure(error, "web_search", executionContext?.abortSignal);
       }
     },
   };

package/plugins/web/source/research.ts

@@ -24,6 +24,12 @@ export function uniqueHits(
   );
 }
 
+function isSourceRetrievalInterrupted(error: unknown, abortSignal: AbortSignal): boolean {
+  if (!isWebPluginError(error)) return false;
+  if (error.code === "web_request_aborted") return true;
+  return error.code === "web_request_timed_out" && abortSignal.aborted;
+}
+
 export async function fetchSources(
   hits: readonly SearchHit[],
   fetchService: WebFetchService,
@@ -52,13 +58,7 @@ export async function fetchSources(
             page: await fetchService.fetchPage(hit.url, abortSignal),
           });
         } catch (error) {
-          if (
-            isWebPluginError(error) &&
-            (error.code === "web_request_aborted" ||
-              error.code === "web_request_timed_out")
-          ) {
-            throw error;
-          }
+          if (isSourceRetrievalInterrupted(error, abortSignal)) throw error;
           return Object.freeze({
             hit,
             errorCode: isWebPluginError(error)

package/plugins/web/src/index.cjs

@@ -170,8 +170,28 @@ function defineRuntimePlugin(definition) {
   return definition;
 }
 
+// src/capabilities/tool-context-text.ts
+function hasValidToolContextText(carrier) {
+  const fields = carrier.contextTextFields;
+  if (fields === void 0) return true;
+  if (!Array.isArray(fields) || fields.length === 0 || fields.length > 3)
+    return false;
+  if (new Set(fields).size !== fields.length) return false;
+  for (const field of fields) {
+    if (!isContextTextField(field)) return false;
+    if (typeof carrier[field] !== "string") return false;
+  }
+  return true;
+}
+function isContextTextField(value) {
+  return value === "output" || value === "stdout" || value === "stderr";
+}
+
+// src/capabilities/result-budget.ts
+var CAPABILITY_RESULT_ENVELOPE_MAX_BYTES = 256 * 1024;
+
 // src/plugin-sdk/results.ts
-var PLUGIN_RESULT_SERIALIZED_MAX_BYTES = 128 * 1024;
+var PLUGIN_RESULT_SERIALIZED_MAX_BYTES = CAPABILITY_RESULT_ENVELOPE_MAX_BYTES;
 function resultBoundsFailure(code, message) {
   return {
     ok: false,
@@ -181,9 +201,27 @@ function resultBoundsFailure(code, message) {
     errorCode: code
   };
 }
-function enforcePluginResultByteBudget(result) {
-  let serialized;
+function enforcePluginResultByteBudget(result, resultBudget) {
+  let requiresContextTextHost = false;
+  let serializedBytes;
+  let envelopeBytes;
+  let maxBytes = PLUGIN_RESULT_SERIALIZED_MAX_BYTES;
+  let fitsDeclaredBudget = true;
   try {
+    if (!hasValidToolContextText(result)) {
+      return resultBoundsFailure(
+        "plugin_context_text_invalid",
+        "The plugin declared invalid context text fields."
+      );
+    }
+    requiresContextTextHost = result.contextTextFields !== void 0;
+    const lacksContextTextHost = requiresContextTextHost && resultBudget?.acceptsContextText !== true;
+    if (lacksContextTextHost) {
+      return resultBoundsFailure(
+        "plugin_context_text_unavailable",
+        "The host does not support context-managed tool text."
+      );
+    }
     const candidate = JSON.stringify(result);
     if (candidate === void 0) {
       return resultBoundsFailure(
@@ -191,50 +229,60 @@ function enforcePluginResultByteBudget(result) {
         "The plugin produced a result that is not JSON-safe."
       );
     }
-    serialized = candidate;
+    const assessment = resultBudget?.assess(result);
+    serializedBytes = assessment?.serializedBytes ?? Buffer.byteLength(candidate, "utf8");
+    envelopeBytes = assessment?.envelopeBytes ?? serializedBytes;
+    maxBytes = Math.min(assessment?.maxBytes ?? maxBytes, maxBytes);
+    fitsDeclaredBudget = assessment?.fits ?? true;
   } catch {
     return resultBoundsFailure(
       "plugin_result_not_json_safe",
       "The plugin produced a result that is not JSON-safe."
     );
   }
-  if (Buffer.byteLength(serialized, "utf8") > PLUGIN_RESULT_SERIALIZED_MAX_BYTES) {
-    return resultBoundsFailure(
-      "plugin_result_too_large",
-      `The plugin result exceeds the ${PLUGIN_RESULT_SERIALIZED_MAX_BYTES}-byte safety limit.`
-    );
+  const hasResultDeliveryHeadroom = fitsDeclaredBudget && envelopeBytes <= maxBytes;
+  if (!hasResultDeliveryHeadroom) {
+    const message = requiresContextTextHost ? `The plugin result envelope is ${envelopeBytes} bytes (${serializedBytes} total bytes) and exceeds the ${maxBytes}-byte delivery limit.` : `The plugin result is ${serializedBytes} bytes and exceeds the ${maxBytes}-byte delivery limit.`;
+    return resultBoundsFailure("plugin_result_too_large", message);
   }
   return result;
 }
-function successResult(input) {
-  return enforcePluginResultByteBudget({
-    ok: true,
-    ...input.media !== void 0 ? { media: input.media } : {},
-    output: input.output,
-    producedNewInformation: input.producedNewInformation ?? true,
-    ...input.progress !== void 0 ? { progress: input.progress } : {},
-    ...input.actions !== void 0 ? { actions: input.actions } : {},
-    ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
-    ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
-    ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
-    ...input.data !== void 0 ? { data: input.data } : {}
-  });
+function successResult(input, resultBudget) {
+  return enforcePluginResultByteBudget(
+    {
+      ok: true,
+      ...input.media !== void 0 ? { media: input.media } : {},
+      output: input.output,
+      producedNewInformation: input.producedNewInformation ?? true,
+      ...input.progress !== void 0 ? { progress: input.progress } : {},
+      ...input.actions !== void 0 ? { actions: input.actions } : {},
+      ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
+      ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
+      ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
+      ...input.data !== void 0 ? { data: input.data } : {}
+    },
+    resultBudget
+  );
 }
-function failureResult(input) {
-  return enforcePluginResultByteBudget({
-    ok: false,
-    ...input.media !== void 0 ? { media: input.media } : {},
-    output: input.output ?? input.message,
-    producedNewInformation: false,
-    ...input.progress !== void 0 ? { progress: input.progress } : {},
-    ...input.actions !== void 0 ? { actions: input.actions } : {},
-    ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
-    ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
-    ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
-    ...input.data !== void 0 ? { data: input.data } : {},
-    error: input.message,
-    errorCode: input.errorCode
-  });
+function failureResult(input, resultBudget) {
+  return enforcePluginResultByteBudget(
+    {
+      ok: false,
+      ...input.interruption ? { interruption: input.interruption } : {},
+      ...input.media !== void 0 ? { media: input.media } : {},
+      output: input.output ?? input.message,
+      producedNewInformation: false,
+      ...input.progress !== void 0 ? { progress: input.progress } : {},
+      ...input.actions !== void 0 ? { actions: input.actions } : {},
+      ...input.exitCode !== void 0 ? { exitCode: input.exitCode } : {},
+      ...input.stdout !== void 0 ? { stdout: input.stdout } : {},
+      ...input.stderr !== void 0 ? { stderr: input.stderr } : {},
+      ...input.data !== void 0 ? { data: input.data } : {},
+      error: input.message,
+      errorCode: input.errorCode
+    },
+    resultBudget
+  );
 }
 function failureFromError(error, options) {
   const pathCode = runtimeToolPathErrorCode(error);
@@ -1594,6 +1642,11 @@ function uniqueHits(results) {
     })
   );
 }
+function isSourceRetrievalInterrupted(error, abortSignal) {
+  if (!isWebPluginError(error)) return false;
+  if (error.code === "web_request_aborted") return true;
+  return error.code === "web_request_timed_out" && abortSignal.aborted;
+}
 async function fetchSources(hits, fetchService, abortSignal) {
   const candidates = hits.slice(0, WEB_LIMITS.searchSourceFetches);
   const results = [];
@@ -1612,9 +1665,7 @@ async function fetchSources(hits, fetchService, abortSignal) {
             page: await fetchService.fetchPage(hit.url, abortSignal)
           });
         } catch (error) {
-          if (isWebPluginError(error) && (error.code === "web_request_aborted" || error.code === "web_request_timed_out")) {
-            throw error;
-          }
+          if (isSourceRetrievalInterrupted(error, abortSignal)) throw error;
           return Object.freeze({
             hit,
             errorCode: isWebPluginError(error) ? error.code : "web_response_invalid",
@@ -4770,11 +4821,13 @@ function successWithSourceReceipts(input, receipt) {
 }
 
 // plugins/web/source/plugin.ts
-function failure(error, operation) {
+function failure(error, operation, signal) {
   const lightFailure = lightSearchFailureResult(error);
   if (lightFailure) return lightFailure;
   if (isWebPluginError(error)) {
+    const abortedByCaller = signal?.aborted === true && error.code === "web_request_aborted";
     return failureResult({
+      ...abortedByCaller ? { interruption: "aborted" } : {},
       errorCode: error.code,
       message: error.message,
       output: `${operation} failed: ${error.message}`
@@ -4833,7 +4886,7 @@ function createWebPlugin(context, dependencies = {}) {
           { version: 1, operation: "fetch", sources: presentation.sources }
         );
       } catch (error) {
-        return failure(error, "web_fetch");
+        return failure(error, "web_fetch", executionContext?.abortSignal);
       }
     },
     async web_search(params, executionContext) {
@@ -4882,7 +4935,7 @@ function createWebPlugin(context, dependencies = {}) {
           search.webSources
         );
       } catch (error) {
-        return failure(error, "web_search");
+        return failure(error, "web_search", executionContext?.abortSignal);
       }
     }
   };

package/src/runtime/README.md

@@ -154,14 +154,21 @@ isolation boundaries.
   `reviewer_verdict_v1` receipt to its exact caller. The receipt is passive
   canonical evidence; it does not choose remediation or finalization.
 - **Auditor** receives typed criteria and a complete canonical work inventory
-  in the direct policy. It independently selects whole original evidence,
+  in the direct policy. It independently selects evidence by execution ID,
   then returns a passive pass/gaps/needs_evidence advisory. A request for more
   evidence identifies the complete next bundle; the next root invocation of
   the same criteria binds those exact records without rerunning tools. Pass
-  requires full inventory classification and all needed originals in the
-  current bundle. Previews and prior advisory summaries are not proof.
-  Exact evidence is never compacted or truncated to fit. The configured model
-  context budget controls admission, with no separate fixed evidence-count or
+  requires full inventory classification and sufficient facts from all needed
+  entries in the current bundle. Previews and prior advisory summaries are not
+  proof. A verified existing EA source digest replaces the corresponding raw
+  adapter result, using the same source identity check as payload authoring;
+  new or uncompacted results retain their original representation. The audit
+  retains its own criteria and receives no EA continuation or decisions.
+  Summary omissions do not prove absence: missing material detail returns as
+  `gaps` for the EA to collect focused fresh evidence. `needs_evidence` selects
+  other existing representations, not hidden originals behind summaries.
+  Selected representations are never compacted again or truncated to fit. The
+  configured model context budget controls admission, with no separate fixed evidence-count or
   character ceiling. Exact duplicate receipt supplements use explicit paths
   into the same unchanged original adapter result. Capacity failures return a
   failed advisory instead of requesting repair of a valid evidence selection;
@@ -226,8 +233,11 @@ overall completion, or write the final response.
 Worker-owned and root-owned capabilities use the same `tool_payload.raw`
 payload author. The author validates the active principal against the frozen
 policy authority. The delegated Worker keeps its established assignment
-capsule; a direct root payload binds the exact request source, ordered steering,
-and immutable controls. Capability `intent` is bounded client-facing
+capsule; a direct root payload carries its selected bounded `operationObjective`
+through the same `authoringObjective` channel, bound to the exact request source,
+ordered steering and immutable controls. Fully selected controls need no extra
+model round. Controls-only objectives do not enter payload authoring.
+Capability `intent` is bounded client-facing
 presentation metadata and is never projected as payload authority or execution
 evidence. Before Worker payload or result authoring, dependency results are
 narrowed to their existing result fields and optional `semanticCheckpoints`;
@@ -235,6 +245,22 @@ work receipts and derived lineage do not cross either raw authoring boundary.
 There is no second payload or adapter pipeline for
 `execution-agent-v1`.
 
+When an Execution Agent operation has remaining controls, its decision selects
+`controlsEvidenceExecutionIds` from the settled executions of that same root
+call. The decision state exposes eligible IDs even after root compaction. An
+empty selection supplies no prior tool-result bodies to Controls. Selected
+results use the canonical evidence projection once per batch; each slot retains
+its own evidence bindings and bounded operation objective. Results already
+covered by the same EA call's verified checkpoint use their source digests;
+fresh or uncovered results retain their original representation. Reuse uses
+the shared source identity check and transfers neither the EA continuation nor
+unselected sources. The canonical ledger and selected-result binding stay exact;
+only the model-visible bodies change. Controls compaction
+is bound to that frozen assignment and steering version. The selection field
+ends at refinement and never enters adapter controls or prepared approvals.
+The delegated Supervisor workflow retains its shared Worker evidence scope and
+staged decision, Controls, payload, result and review contracts.
+
 When direct capability controls refinement exhausts structured-output
 validation, the kernel commits the canonical
 `reconsider_capability_selection` RoleCall transition. It records the exact
@@ -393,15 +419,45 @@ output-token limit.
 
 Current-session conversation continuity is core-owned. The raw transcript stays
 canonical, while root decision and response steps receive one passive session
-checkpoint plus every uncovered complete turn. At the shared 70 percent
-context threshold, the runtime summarizes only the old settled prefix and
-keeps the latest ten complete user-agent turns raw. The checkpoint is persisted
-with exact message fingerprints and an optimistic source revision; it is not
+checkpoint plus every uncovered settled turn. A standalone assistant initiative
+is a settled turn with no user message; it stays in ordinary chronological history
+and follows the same retention policy. At the shared 70 percent context threshold,
+the runtime summarizes only the old settled prefix and keeps the latest ten turns
+raw. The checkpoint is persisted with exact message fingerprints and an optimistic
+source revision; it is not
 projected to Planner, Worker, Reviewer, Auditor, payload authors, or tools.
 Profiles cannot cap conversation messages independently. Client lifecycle uses
 the existing `context.compaction.*` events, with `session_history` retained as
 diagnostic scope metadata.
 
+Active-request semantic checkpoints retain their separate source scope. The
+compactor receives invocation-local source keys, and each returned digest is
+bound to that key before the runtime stores the existing v2 checkpoint. Every
+checkpoint projection identifies its contents as passive evidence from the
+listed sources; an omitted fact does not establish absence or change the active
+assignment, tool authority, approval state, or completion status.
+
+The complete active-request checkpoint (source digests, continuation, and its
+reference envelope) has a shared token budget of 30 percent of the consuming
+model's configured context window. Generation validates the projected checkpoint
+using provider input counting when available, otherwise the configured estimator.
+There is no aggregate 8,000-character quota. Structural identity and per-field
+continuation constraints remain enforced; full-message admission separately
+accounts for instructions, other retained input, and response headroom. Oversized
+checkpoint output uses the existing repair path with measured usage and allowance.
+
+Immediate operation-supervision evidence is bound to the current request, call,
+activation and ledger revision. After checkpoint projection, EA decision/response
+and SUPER Worker decision/result inputs retain an exact action/result reference
+when that lane remains present. If the same owner's verified checkpoint covers
+the canonical result, the notice keeps its accepted action and outcome receipt
+and refers to that checkpoint's partial source digest instead of restoring the
+raw result. The binding uses registered source bytes and fingerprints, never
+model-authored envelope labels. Uncovered and cross-call evidence keeps its
+canonical original. The final input, including this evidence, passes ordinary
+context admission before a new checkpoint is committed. Controls and payload
+authors do not receive this current supervision capsule.
+
 Every tool and skill binding is declared once by a package under root
 `plugins/`. Runtime config only applies `plugins.enabled`, `plugins.allow`, and
 `plugins.deny`. The request-scoped capability provider projects the effective
@@ -409,6 +465,39 @@ registered operations generically for an authorized Worker or root. Adding,
 removing, or renaming a tool must not require a request-runner or role prompt
 branch.
 
+ABot Studio draft authoring uses the same capability engine. The
+`automation_builder` capability creates a draft from optional `settings` and
+ordered `steps`. Each step has a local `key`; explicit `$key` result bindings
+connect steps, and parallel steps contain arrays of branch steps. A focused
+compiler generates the canonical mutation envelopes, parent references and
+positions, with the same defaults as individual edits. Updating an existing
+draft still uses the canonical mutation batch and expected revision; legacy
+batch creation remains supported. Both routes commit in one transaction.
+The draft manager owns generated node IDs,
+local-reference resolution, graph validation, revision checks, and the single
+commit. A rejected group persists none of its changes. The model-facing
+authoring surface offers connected writes, discovery, reads,
+validation and saved-agent reuse. Granular editing actions remain supported by
+the direct adapter API but are not offered as competing model capabilities. Neither
+authoring capability can grant permission, publish, activate, or run a draft,
+and neither is selectable as a step within an automation.
+
+Model-facing `browse_catalog` reads the compact global index without requiring
+a draft. `prepare_draft` resolves a bounded set of exact operation references
+from that canonical catalog and returns their schemas plus the complete
+authoring reference. That passive reference includes structured agent results,
+bindings, settings and their limits; it grants no authority to execute future
+steps. Discovery controls are selected completely so no extra controls-model
+round is required. Legacy direct catalog and granular-edit contracts remain
+available for compatibility.
+The builder declares one structured payload stage through the existing generic
+tool metadata. Its bounded generation schema reaches both root and Worker
+payload models and is projected by each provider adapter. Canonical parsers
+still enforce field limits, references and graph semantics before persistence;
+the generation format neither repairs invalid output nor retries it.
+Authoring changes do not alter context-window capacity, compaction, role
+authority, or the shared request loop.
+
 Environment profiles under `environment.profiles` isolate generated runtime
 data roots. Model profiles under `models.profiles` select providers,
 calibration, and optionally one registered `execution.policy`. Omission uses