@abot-ai/runtime 1.1.0 → 1.2.0

package/dist/src/web-ui/app/styles/90-responsive.css

@@ -5,24 +5,6 @@
     padding-inline: 18px;
   }
 
-  .header-controls {
-    max-width: 64%;
-  }
-
-  .control-label {
-    display: none;
-  }
-
-  .agent-mode-control {
-    width: 116px;
-    min-width: 116px;
-  }
-
-  .model-control {
-    width: 170px;
-    min-width: 0;
-  }
-
   .workspace-page-body {
     padding-inline: 28px;
   }
@@ -38,25 +20,6 @@
     padding-block: 12px;
   }
 
-  .header-controls {
-    display: grid;
-    grid-template-columns: minmax(112px, 0.8fr) minmax(150px, 1.2fr);
-    width: 100%;
-    max-width: 520px;
-  }
-
-  .agent-mode-control,
-  .model-control,
-  .agent-mode-button,
-  #modelSelect {
-    width: 100%;
-    min-width: 0;
-  }
-
-  .chat-header h2 {
-    max-width: min(72vw, 620px);
-  }
-
   .workspace-page-header {
     padding-inline: 28px;
   }
@@ -99,7 +62,6 @@
   }
 
   .app-shell,
-  .app-shell.operations-workspace,
   .app-shell.config-workspace {
     display: grid;
     grid-template-columns: minmax(0, 1fr);
@@ -115,7 +77,7 @@
     inset: auto;
     z-index: 80;
     display: grid;
-    grid-template-columns: repeat(5, minmax(0, 1fr));
+    grid-template-columns: repeat(4, minmax(0, 1fr));
     gap: 4px;
     grid-column: 1;
     grid-row: 2;
@@ -131,6 +93,10 @@
     backdrop-filter: blur(20px);
   }
 
+  .app-shell.config-workspace .workspace-rail {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+
   .rail-spacer,
   .rail-runtime {
     display: none;
@@ -153,17 +119,13 @@
     order: 2;
   }
 
-  #operationsWorkspaceButton {
-    order: 4;
-  }
-
   #configWorkspaceButton {
-    order: 5;
+    order: 4;
   }
 
   .workspace-rail button.rail-button {
     display: grid;
-    grid-template-rows: 22px 14px;
+    grid-template-rows: 22px minmax(1.125rem, auto);
     gap: 1px;
     place-items: center;
     width: 100%;
@@ -191,8 +153,8 @@
     color: currentColor;
     text-overflow: ellipsis;
     white-space: nowrap;
-    font-size: 9.5px;
-    line-height: 1;
+    font-size: var(--font-size-xs);
+    line-height: 1.2;
     opacity: 1;
     pointer-events: none;
     transform: none;
@@ -259,15 +221,7 @@
   }
 
   .chat-header h2 {
-    max-width: calc(100vw - 44px);
-    font-size: 15px;
-  }
-
-  .header-controls {
-    grid-template-columns: minmax(0, 0.85fr) minmax(0, 1.15fr);
-    gap: 6px;
-    width: 100%;
-    max-width: none;
+    font-size: var(--font-size-2xl);
   }
 
   .messages-list {
@@ -316,16 +270,10 @@
   }
 
   .composer {
-    grid-template-columns: 34px auto minmax(0, 1fr) 36px;
-    grid-template-rows: auto auto auto;
     padding: 10px;
     border-radius: 15px;
   }
 
-  .composer.composer-has-split-action {
-    grid-template-columns: 34px auto minmax(0, 1fr) auto;
-  }
-
   .composer-submit-control.split .send-button {
     width: 32px;
     min-width: 32px;
@@ -341,17 +289,6 @@
     min-height: 36px;
   }
 
-  .permission-mode-control {
-    grid-column: 2;
-    grid-row: 3;
-  }
-
-  .permission-mode-button {
-    width: auto;
-    height: 31px;
-    min-height: 31px;
-  }
-
   .attachment-preview {
     grid-column: 1 / -1;
     grid-row: 2;
@@ -373,7 +310,7 @@
   }
 
   .workspace-page-heading h2 {
-    font-size: 18px;
+    font-size: var(--font-size-4xl);
   }
 
   .workspace-page-body {
@@ -546,7 +483,7 @@
   }
 
   .mode-empty-title {
-    font-size: 24px;
+    font-size: var(--font-size-6xl);
   }
 
   .workspace-page-heading .eyebrow {
@@ -565,7 +502,7 @@
   }
 
   .config-workspace-heading h2 {
-    font-size: 17px;
+    font-size: var(--font-size-3xl);
   }
 
   .config-workspace-heading > p:last-child {
@@ -585,7 +522,7 @@
   .config-category-tab {
     min-height: 38px;
     padding-inline: 6px;
-    font-size: 11px;
+    font-size: var(--font-size-sm);
   }
 
   .config-dashboard #configRawEditor,

package/dist/src/web-ui/app/styles/foundation.css

@@ -81,11 +81,11 @@ button,
 input,
 select {
   min-height: 32px;
-  font-size: 13px;
+  font-size: var(--font-size-lg);
 }
 
 textarea {
-  font-size: 14px;
+  font-size: var(--font-size-xl);
 }
 
 button {

package/dist/src/web-ui/app/styles.css

@@ -1,9 +1,16 @@
 @import url("./styles/foundation.css");
 @import url("./styles/00-tokens-base.css");
 @import url("./styles/10-shell-sessions.css");
+@import url("./styles/12-conversation-sidebar.css");
 @import url("./styles/20-chat-composer.css");
+@import url("./styles/21-composer-controls.css");
+@import url("./styles/22-composer-context-window.css");
+@import url("./styles/23-composer-plan.css");
+@import url("./styles/24-conversation-role-cards.css");
+@import url("./styles/25-conversation-sources.css");
 @import url("./styles/30-inspector-config.css");
 @import url("./styles/40-config-workspace.css");
 @import url("./styles/35-memory-onboarding.css");
 @import url("./styles/36-memory-management.css");
+@import url("./styles/37-config-operations.css");
 @import url("./styles/90-responsive.css");

package/dist/src/web-ui/app/ui-behavior.d.ts

@@ -28,7 +28,7 @@ export declare function wrappedIndex(
 
 export declare function normalizeWorkspaceDestination(
   value: unknown,
-): "chat" | "operations" | "config";
+): "chat" | "config";
 
 export declare function createInitialWorkspaceShellState(): {
   workspace: "chat";

package/dist/src/web-ui/app/ui-behavior.js

@@ -37,7 +37,7 @@ export function normalizeWorkspaceDestination(value) {
   const destination = String(value ?? "")
     .trim()
     .toLowerCase();
-  return ["operations", "config"].includes(destination) ? destination : "chat";
+  return destination === "config" ? "config" : "chat";
 }
 
 export function createInitialWorkspaceShellState() {

package/docs/configuration.md

@@ -31,11 +31,16 @@ AGENT_BRIDGE_TOKEN=
 LLM_RUNTIME_CONFIG_FILE=local/runtime.config.json
 ```
 
-`BRAVE_SEARCH_API_KEY` is optional for startup and URL fetching. The bundled
-Web plugin always exposes `web_fetch` and `web_search`; invoking `web_search`
-without a non-empty key returns a clear plugin configuration error without
-making a search request. The key never belongs in runtime JSON or a plugin
-manifest.
+`BRAVE_SEARCH_API_KEY` is optional. The bundled Web plugin always exposes
+`web_fetch` and `web_search`. A non-empty key selects Brave Search; without one,
+`web_search` uses Light search over a limited catalog of public Hebrew and
+English sources. Light reads those sources directly without an external search
+engine. A failing configured key does not silently switch providers. The key
+never belongs in runtime JSON or a plugin manifest.
+
+Light uses the Web plugin's defaults and an in-memory cache; no background
+crawler or separate service is installed. See
+[Known Limitations](known-limitations.md#web-search) for its coverage and limits.
 
 Provider configs should reference env var names:
 
@@ -310,10 +315,12 @@ the request-runner context block supplies only admission headroom.
 subtracted while projecting messages so the prompt does not consume the whole
 context window; it is never forwarded to a provider as an output limit. Model
 steps may vary their prompt contract, timeout, format, or other generation
-controls, but they do not receive a shared per-step output-token cap.
+controls, but configuration does not define a shared per-step output-token cap.
 The Ollama adapter still sends a finite provider-native `num_predict`, derived
-mechanically from the final provider input, the physical context remainder,
-and a strict bounded output schema when one applies.
+mechanically from the final provider input and the physical context remainder.
+Registered core-decision steps additionally retain their internal output-token
+limit. Output schema size does not impose another generation limit; schema
+projection, validation, input estimation, and compaction remain unchanged.
 
 The required context fields remain explicit. Unknown fields, unknown step ids,
 and invalid explicit overrides are rejected during configuration loading;

package/docs/installation.md

@@ -155,10 +155,13 @@ a bundled plugin: duplicate plugin ids fail closed.
 The passive long-term memory service belongs to the Runtime core and does not
 depend on the bundled `memory` plugin.
 
-Web URL fetching is available through the bundled Web plugin without a search
-credential. Set `BRAVE_SEARCH_API_KEY` to make `web_search` operational. With
-no key, `web_fetch` remains operational and a `web_search` invocation fails
-locally with a configuration error before any search request is made.
+The bundled Web plugin supports URL fetching and Light search without a search
+credential. Light searches a limited catalog of public Hebrew and English
+sources directly; it does not query an external search engine or provide
+whole-web coverage. Set `BRAVE_SEARCH_API_KEY` to use Brave Search instead.
+A configured Brave key that fails remains a Brave error. See
+[Known Limitations](known-limitations.md#web-search) for Light's discovery and
+cache boundaries.
 
 ## Run From Source
 

package/docs/known-limitations.md

@@ -61,6 +61,27 @@ plugin entrypoints are not currently supported.
 Plugin behavior belongs inside the plugin. Runtime orchestration should only
 see the generic selected catalog and execution results.
 
+## Web Search
+
+With a configured `BRAVE_SEARCH_API_KEY`, `web_search` uses Brave Search and
+preserves its authentication and rate-limit errors. Without a key, Light search
+discovers and ranks pages within a catalog of public Hebrew and English
+sources. It contacts content sources directly, without another search engine.
+
+Light does not maintain a whole-web index. Its source selection, crawl depth,
+candidate count, response sizes, and request deadline are bounded. Results may
+be partial because a source is unavailable, disallows crawling, or exceeds a
+budget. Zero matches mean no matches in the inspected sources, not that the
+information is absent from the web. Source coverage accompanies the results.
+
+The document cache exists only in the plugin instance's memory, bounded to
+16 MiB of serialized content and 500 documents. Feed entries expire within
+five minutes and page entries within 30 minutes; origin directives can shorten
+these lifetimes. Restarting the runtime clears the cache. There is no background
+crawl, browser rendering, or persistent search database. Content that requires
+JavaScript may therefore be unavailable. Exact public URL fetching remains a
+separate `web_fetch` capability with its existing public-network restrictions.
+
 ## Passive Long-Term Memory
 
 Passive long-term memory is disabled by default and requires an embedding model

package/docs/plugins.md

@@ -127,19 +127,34 @@ must be unique bounded lowercase ids matching
 built-in conventions, not a closed enum. Manifests that omit both levels remain
 compatible and use the plugin name as their single catalog group.
 
-The delegated Supervisor and Planner receive only an aggregate catalog of these
-group ids, membership counts, descriptions, and declared effects. When either
-invokes a Worker against a non-empty catalog, it supplies one or more group
-ids; the runtime stores that scope on the Worker call and exposes the OR-union
-of matching capabilities. The Worker still selects the concrete capability and
-controls.
-
-Each group description is generated from every member capability's manifest
-id and summary in stable order. There is no second category-description JSON or
-manually maintained routing registry.
-
-Under `execution-agent-v1`, the canonical root receives the same aggregate
-group projection and may mechanically open or extend its own RoleCall scope.
+The delegated Supervisor and Planner select group ids when invoking a Worker
+against a non-empty catalog. The runtime stores that scope on the Worker call
+and exposes the OR-union of matching capabilities. The Worker still selects
+the concrete capability and controls.
+
+Supervisor routing receives one optional, passive text brief from the same
+request-filtered registry used by `capability-brief`. It chooses the richest
+complete representation that fits: tool names with operation ids and groups,
+tool names by group, group counts and effects, or no brief. The brief replaces
+the previous aggregate catalog text; group ids remain in the response schema
+in every mode. It includes no tool descriptions, inputs, or operating
+instructions. Its 512-token estimate ceiling is further reduced by existing
+context headroom, including history and instruction reserves. No subset of
+tools is selected to fit, and no model call summarizes the catalog.
+This admission uses the context estimate at projection time. A later provider
+token count, steering update, or structured-output repair can still trigger
+the existing context-compaction path; the brief is not reselected there.
+
+The SDK exports `buildToolAvailabilityBrief` for the unchanged on-demand plugin
+output and `buildToolAvailabilityOverview` for informational representations.
+The runtime context helper owns token admission and the passive reference
+message; another step can explicitly attach it using the existing context
+reference API. Supervisor's working-directory and response phases do not
+receive it. Planner retains its existing group-routing projection.
+
+Under `execution-agent-v1`, the canonical root receives group descriptions
+generated from member capability ids and summaries, and may mechanically open
+or extend its own RoleCall scope.
 It then selects a concrete capability only from that active scope. Scope
 updates, capability binding, payload authoring, adapter execution, and
 settlement use the same ledger and capability engine as delegated Worker

package/docs/runtime-invariant-coverage.md

@@ -4,23 +4,24 @@ This map records the invariants that protect the single request kernel across
 the default `supervisor-worker-v1` policy and the opt-in
 `execution-agent-v1` policy.
 
-| Invariant                                                                                                                                                                                                                                                                                                             | Owner                                                                                                                                                            | Primary coverage                                                                                                                |
-| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| Every request creates one canonical root and one RoleCall ledger; only that root may commit the final response.                                                                                                                                                                                                       | `src/runtime/request/handler.ts`, `src/runtime/request/runner.ts`, `src/runtime/request/root-execution-kernel.ts`, `src/runtime/orchestration/role-calls/`       | `root-execution-kernel-policy-mechanics.test.ts`, `role-call-ledger.test.ts`, `request-finalization.test.ts`                    |
-| The handler resolves one compiled execution policy from the selected model profile and supplies its same authority to capability composition and the runner. Omission remains `supervisor-worker-v1`.                                                                                                                 | `src/runtime/model/model-selection.ts`, `src/runtime/request/handler.ts`, `src/runtime/request/role-executor-composition.ts`                                     | `model-execution-policy.test.ts`, `request-execution-policy-composition.test.ts`                                                |
-| `supervisor-worker-v1` retains the delegated Supervisor, Planner, Worker, and Reviewer contracts; `execution-agent-v1` changes model-facing contracts and authority without adding another runner, ledger, reducer, capability engine, or finalizer.                                                                  | `src/runtime/request/root-execution-kernel.ts`, `src/runtime/request/role-executor-composition.ts`                                                               | `root-execution-kernel-policy-mechanics.test.ts`, `supervisor-request-runner.test.ts`, `execution-agent-request-runner.test.ts` |
-| Role choice is model-owned and limited to the exact subordinate contracts registered by the frozen policy.                                                                                                                                                                                                            | `src/runtime/steps/*`, `src/runtime/orchestration/role-executors/`, `src/runtime/orchestration/role-calls/`                                                      | `role-executor-registry.test.ts`, `planner-decision.test.ts`, `execution-agent-advisory-executors.test.ts`                      |
-| Every subordinate result returns to its exact caller through an exact-head ledger commit. Planner Graph and Auditor outputs are passive terminal child results, never executable plan or completion state.                                                                                                            | `src/runtime/orchestration/role-calls/`, `src/runtime/steps/planner-graph/`, `src/runtime/steps/auditor-decision/`                                               | `role-call-ledger.test.ts`, `execution-agent-advisory-executors.test.ts`, `supervisor-request-runner.test.ts`                   |
-| Capability authority is validated against the frozen policy and bound to the exact authorized call and activation: Worker for the default policy, canonical root for the direct policy. Both use the same binding and adapter engine.                                                                                 | `src/runtime/orchestration/role-calls/`, `src/runtime/orchestration/worker-capabilities/`, `src/runtime/request/root-execution-kernel.ts`                        | `root-execution-kernel-policy-mechanics.test.ts`, `worker-capability-binding.test.ts`, `execution-agent-request-runner.test.ts` |
-| Worker and root payloads use the same `tool_payload.raw` author; the principal, accepted intent, controls, exact request source, and admitted evidence are mechanically bounded before model invocation.                                                                                                              | `src/runtime/orchestration/worker-capabilities/payload-author.ts`, `src/runtime/request/worker-capability-payload.ts`                                            | `worker-capability-payload-author.test.ts`, `execution-agent-request-runner.test.ts`                                            |
-| Direct capability continuations use strict provider-native assistant tool calls followed by their exact linked tool results; linkage, order, names, content, and token accounting are validated.                                                                                                                      | `src/model-gateway/message-contract.ts`, `src/runtime/steps/execution-agent/state-context.ts`                                                                    | `tool-interaction.test.ts`, `tool-interaction-token-estimator.test.ts`, `execution-agent-context.test.ts`                       |
-| Exhausted direct controls structured-output validation commits `reconsider_capability_selection` without executing an adapter. Its passive projection records the exact selection fingerprint but makes no semantic judgment, chooses no replacement, and suppresses no later selection.                              | `src/runtime/orchestration/role-calls/`, `src/runtime/orchestration/role-calls/capability-selection-reconsideration.ts`, `src/runtime/steps/execution-agent/`    | `role-call-ledger.test.ts`, `execution-agent-context.test.ts`, `execution-agent-request-runner.test.ts`                         |
-| Delegated Worker control decisions remain strict JSON while its substantive result uses the existing raw authoring boundary. Only `execution-agent-v1` opts into byte-exact terminal text; default finalization remains normalized.                                                                                   | `src/runtime/steps/worker-decision/`, `src/runtime/steps/execution-agent/`, `src/runtime/lifecycle/request-finalizer.ts`                                         | `worker-decision.test.ts`, `execution-agent-request-runner.test.ts`, `request-finalization.test.ts`                             |
-| Capability adapters report bounded operation outcomes and never decide semantic completion.                                                                                                                                                                                                                           | `src/runtime/adapters/registered-tool-worker-capabilities.ts`, `src/capabilities/tool-executor.ts`                                                               | `registered-tool-worker-capabilities.test.ts`, `tool-executor.test.ts`, `normal-invocation.test.ts`                             |
-| Every capability settlement, whether produced by a delegated Worker or the direct root, atomically persists exactly one validated canonical `CapabilityAdapterResult`. Running executions cannot carry a result; invalid, non-JSON-safe, cyclic, or oversized evidence cannot settle and is never silently truncated. | `src/runtime/orchestration/capability-adapters/result.ts`, `src/runtime/orchestration/worker-capabilities/execution.ts`, `src/runtime/orchestration/role-calls/` | `registered-tool-worker-capabilities.test.ts`, `worker-capability-binding.test.ts`, `role-call-ledger.test.ts`                  |
-| The complete canonical result is projected only to the exact producing call and its later same-call payload author. Direct native tool linkage is not duplicated; callers, siblings, unrelated requests, and other roles retain bounded receipts and ordinary child handoffs.                                         | `src/runtime/orchestration/worker-capabilities/settled-results.ts`, `src/runtime/steps/worker-decision/`, `src/runtime/steps/execution-agent/state-context.ts`   | `worker-decision.test.ts`, `worker-capability-payload-author.test.ts`, `execution-agent-context.test.ts`                        |
-| Delegated Planner client events project committed canonical plan state and never write progress. Planner Graph advisories do not create canonical plan items.                                                                                                                                                         | `src/runtime/request/role-call-planner-events.ts`, `src/runtime/request/planner-plan-events.ts`, `src/runtime/steps/planner-graph/`                              | `role-call-planner-events.test.ts`, `execution-agent-advisory-executors.test.ts`                                                |
-| Final response persistence and terminal request completion remain one shared request-finalizer boundary for both policies.                                                                                                                                                                                            | `src/runtime/lifecycle/request-finalizer.ts`                                                                                                                     | `request-finalization.test.ts`, `execution-agent-request-runner.test.ts`                                                        |
+| Invariant                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Owner                                                                                                                                                                                                                                                  | Primary coverage                                                                                                                                                                                                                             |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Every request creates one canonical root and one RoleCall ledger; only that root may commit the final response.                                                                                                                                                                                                                                                                                                                                                             | `src/runtime/request/handler.ts`, `src/runtime/request/runner.ts`, `src/runtime/request/root-execution-kernel.ts`, `src/runtime/orchestration/role-calls/`                                                                                             | `root-execution-kernel-policy-mechanics.test.ts`, `role-call-ledger.test.ts`, `request-finalization.test.ts`                                                                                                                                 |
+| The handler resolves one compiled execution policy from the selected model profile and supplies its same authority to capability composition and the runner. Omission remains `supervisor-worker-v1`.                                                                                                                                                                                                                                                                       | `src/runtime/model/model-selection.ts`, `src/runtime/request/handler.ts`, `src/runtime/request/role-executor-composition.ts`                                                                                                                           | `model-execution-policy.test.ts`, `request-execution-policy-composition.test.ts`                                                                                                                                                             |
+| `supervisor-worker-v1` retains the delegated Supervisor, Planner, Worker, and Reviewer contracts; `execution-agent-v1` changes model-facing contracts and authority without adding another runner, ledger, reducer, capability engine, or finalizer.                                                                                                                                                                                                                        | `src/runtime/request/root-execution-kernel.ts`, `src/runtime/request/role-executor-composition.ts`                                                                                                                                                     | `root-execution-kernel-policy-mechanics.test.ts`, `supervisor-request-runner.test.ts`, `execution-agent-request-runner.test.ts`                                                                                                              |
+| Role choice is model-owned and limited to the exact subordinate contracts registered by the frozen policy.                                                                                                                                                                                                                                                                                                                                                                  | `src/runtime/steps/*`, `src/runtime/orchestration/role-executors/`, `src/runtime/orchestration/role-calls/`                                                                                                                                            | `role-executor-registry.test.ts`, `planner-decision.test.ts`, `execution-agent-advisory-executors.test.ts`                                                                                                                                   |
+| Every subordinate result returns to its exact caller through an exact-head ledger v17 commit. Under `supervisor-worker-v1`, terminal Planner and Worker results receive a runtime-owned, constant-size `work_result_v1` receipt; supplied work receipts are rejected, lineage is derived and fingerprint-verified from that ledger, and `execution-agent-v1` receives none. Planner Graph and Auditor outputs remain passive terminal child results.                        | `src/runtime/orchestration/role-calls/`, `src/runtime/steps/planner-graph/`, `src/runtime/steps/auditor-decision/`                                                                                                                                     | `role-call-ledger.test.ts`, `role-call-work-result-receipt-reducer.test.ts`, `role-call-planner-work-result-receipt.test.ts`, `execution-agent-advisory-executors.test.ts`, `supervisor-request-runner.test.ts`                              |
+| Planner's semantic contract requires declaring every currently known execution outcome before the first child dispatch; schema and parser mechanically bind exactly one independently completable production item per Worker dispatch. A directly bound Worker receives that item, explicit dependencies, supervision evidence, and its own capability-result lane without the broader request, Planner objective, or sibling execution summaries.                          | `src/runtime/steps/planner-decision/`, `src/runtime/steps/worker-decision/`, `src/runtime/context/request-tool-results.ts`                                                                                                                             | `planner-plan-contract.test.ts`, `planner-single-item-dispatch.test.ts`, `planner-worker-context-isolation.test.ts`, `planner-worker-tool-result-scope.test.ts`                                                                              |
+| Capability authority is validated against the frozen policy and bound to the exact authorized call and activation: Worker for the default policy, canonical root for the direct policy. Both use the same binding and adapter engine.                                                                                                                                                                                                                                       | `src/runtime/orchestration/role-calls/`, `src/runtime/orchestration/worker-capabilities/`, `src/runtime/request/root-execution-kernel.ts`                                                                                                              | `root-execution-kernel-policy-mechanics.test.ts`, `worker-capability-binding.test.ts`, `execution-agent-request-runner.test.ts`                                                                                                              |
+| Worker and root payloads use the same `tool_payload.raw` author; principal, controls, runtime-issued direct-Planner-item receipt, and admitted evidence are mechanically bounded before model invocation. Root and non-Planner Worker payloads retain the exact request source; a canonically bound Planner item omits it. Work-result receipts and derived lineage are stripped before Worker raw payload and result authoring while optional semantic checkpoints remain. | `src/runtime/orchestration/worker-capabilities/payload-author.ts`, `src/runtime/request/worker-capability-payload.ts`, `src/runtime/steps/worker-decision/`                                                                                            | `planner-worker-context-isolation.test.ts`, `registered-tool-worker-assignment-provenance.test.ts`, `worker-capability-payload-author.test.ts`, `worker-payload-dependency-projection-pr1.test.ts`, `execution-agent-request-runner.test.ts` |
+| Direct capability continuations use strict provider-native assistant tool calls followed by their exact linked tool results; linkage, order, names, content, and token accounting are validated.                                                                                                                                                                                                                                                                            | `src/model-gateway/message-contract.ts`, `src/runtime/steps/execution-agent/state-context.ts`                                                                                                                                                          | `tool-interaction.test.ts`, `tool-interaction-token-estimator.test.ts`, `execution-agent-context.test.ts`                                                                                                                                    |
+| Exhausted direct controls structured-output validation commits `reconsider_capability_selection` without executing an adapter. Its passive projection records the exact selection fingerprint but makes no semantic judgment, chooses no replacement, and suppresses no later selection.                                                                                                                                                                                    | `src/runtime/orchestration/role-calls/`, `src/runtime/orchestration/role-calls/capability-selection-reconsideration.ts`, `src/runtime/steps/execution-agent/`                                                                                          | `role-call-ledger.test.ts`, `execution-agent-context.test.ts`, `execution-agent-request-runner.test.ts`                                                                                                                                      |
+| Delegated Worker control decisions remain strict JSON while its substantive result uses the existing raw authoring boundary. Only `execution-agent-v1` opts into byte-exact terminal text; default finalization remains normalized.                                                                                                                                                                                                                                         | `src/runtime/steps/worker-decision/`, `src/runtime/steps/execution-agent/`, `src/runtime/lifecycle/request-finalizer.ts`                                                                                                                               | `worker-decision.test.ts`, `execution-agent-request-runner.test.ts`, `request-finalization.test.ts`                                                                                                                                          |
+| Capability adapters report bounded operation outcomes and never decide semantic completion.                                                                                                                                                                                                                                                                                                                                                                                 | `src/runtime/adapters/registered-tool-worker-capabilities.ts`, `src/capabilities/tool-executor.ts`                                                                                                                                                     | `registered-tool-worker-capabilities.test.ts`, `tool-executor.test.ts`, `normal-invocation.test.ts`                                                                                                                                          |
+| Every capability settlement, whether produced by a delegated Worker or the direct root, atomically persists exactly one validated canonical `CapabilityAdapterResult`. Running executions cannot carry a result; invalid, non-JSON-safe, cyclic, or oversized evidence cannot settle and is never silently truncated.                                                                                                                                                       | `src/runtime/orchestration/capability-adapters/result.ts`, `src/runtime/orchestration/worker-capabilities/execution.ts`, `src/runtime/orchestration/role-calls/`                                                                                       | `registered-tool-worker-capabilities.test.ts`, `worker-capability-binding.test.ts`, `role-call-ledger.test.ts`                                                                                                                               |
+| The complete canonical result is projected only to the exact producing call and its later same-call payload author. Direct native tool linkage is not duplicated; cross-call provenance moves only through compact runtime-owned receipts and ledger-derived lineage on explicit dependency or supervision lanes. A Planner-item Worker receives no sibling execution summaries; callers, siblings and unrelated requests receive no implicit evidence.                     | `src/runtime/orchestration/worker-capabilities/settled-results.ts`, `src/runtime/context/request-tool-results.ts`, `src/runtime/orchestration/role-calls/`, `src/runtime/steps/worker-decision/`, `src/runtime/steps/execution-agent/state-context.ts` | `planner-worker-tool-result-scope.test.ts`, `role-call-dependency-work-receipt-pr1.test.ts`, `role-call-work-receipt-continuation-pr1.test.ts`, `worker-decision.test.ts`, `execution-agent-context.test.ts`                                 |
+| Delegated Planner client events project committed canonical plan state and never write progress. Planner Graph advisories do not create canonical plan items.                                                                                                                                                                                                                                                                                                               | `src/runtime/request/role-call-planner-events.ts`, `src/runtime/request/planner-plan-events.ts`, `src/runtime/steps/planner-graph/`                                                                                                                    | `role-call-planner-events.test.ts`, `execution-agent-advisory-executors.test.ts`                                                                                                                                                             |
+| Final response persistence and terminal request completion remain one shared request-finalizer boundary for both policies.                                                                                                                                                                                                                                                                                                                                                  | `src/runtime/lifecycle/request-finalizer.ts`                                                                                                                                                                                                           | `request-finalization.test.ts`, `execution-agent-request-runner.test.ts`                                                                                                                                                                     |
 
 ## Client Compatibility
 

package/docs/runtime-prompt-policy-contracts.md

@@ -7,20 +7,20 @@ contracts without selecting a fixed workflow.
 
 ## Structured Model Boundaries
 
-| Boundary                   | Instructions and schema                                                                                               | Executable validation                                                                                                                       | Primary coverage                                                                                   |
-| -------------------------- | --------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
-| Supervisor decision        | `src/runtime/steps/supervisor-decision/`                                                                              | strict parser, default-policy child contracts, exact canonical root                                                                         | `supervisor-decision.test.ts`, `supervisor-request-runner.test.ts`                                 |
-| Supervisor response        | `src/runtime/steps/supervisor-response/`                                                                              | exact active root and bounded returned-child context; legacy normalized terminal mode                                                       | `supervisor-response.test.ts`, `supervisor-request-runner.test.ts`, `request-finalization.test.ts` |
-| Execution Agent decision   | `src/runtime/steps/execution-agent/`                                                                                  | strict parser, direct-policy actions and root capability authority, exact canonical state                                                   | `execution-agent-decision.test.ts`, `execution-agent-request-runner.test.ts`                       |
-| Execution Agent response   | `src/runtime/steps/execution-agent/response-*`                                                                        | raw non-empty bounded text from the exact accepted response state; direct-policy exact terminal mode only                                   | `execution-agent-request-runner.test.ts`, `request-finalization.test.ts`                           |
-| Delegated Planner decision | `src/runtime/steps/planner-decision/`                                                                                 | strict parser, exact Planner caller, registered delegated child contracts                                                                   | `planner-decision.test.ts`, `role-call-planner-events.test.ts`                                     |
-| Planner Graph advisory     | `src/runtime/steps/planner-graph/`                                                                                    | bounded acyclic proposal or decline from the exact advisory objective; no execution authority                                               | `execution-agent-advisory-executors.test.ts`, `execution-agent-request-runner.test.ts`             |
-| Worker decision            | `src/runtime/steps/worker-decision/`                                                                                  | strict parser, exact Worker activation, offered capability catalog                                                                          | `worker-decision.test.ts`, `worker-capability-decision.test.ts`                                    |
-| Worker result              | `src/runtime/steps/worker-decision/result-author.ts`                                                                  | raw text from the exact projected Worker assignment and evidence                                                                            | `worker-decision.test.ts`, `supervisor-request-runner.test.ts`                                     |
-| Reviewer decision          | `src/runtime/steps/reviewer-decision/`                                                                                | strict parser and bounded supplied-work projection                                                                                          | `reviewer-decision.test.ts`, `supervisor-request-runner.test.ts`                                   |
-| Auditor advisory           | `src/runtime/steps/auditor-decision/`                                                                                 | typed criteria, whole canonical evidence entries, and omission-gated pass                                                                   | `execution-agent-advisory-executors.test.ts`, `execution-agent-request-runner.test.ts`             |
-| Capability payload         | `src/runtime/orchestration/worker-capabilities/payload-author.ts`, `src/runtime/request/worker-capability-payload.ts` | frozen-policy Worker or root principal, selected operation, accepted intent, immutable controls, exact request source, and payload contract | `worker-capability-payload-author.test.ts`, `execution-agent-request-runner.test.ts`               |
-| Degraded finalization      | `src/runtime/steps/degraded-finalization/`                                                                            | bounded failure rendering only                                                                                                              | `degraded-finalization.test.ts`, `request-finalization.test.ts`                                    |
+| Boundary                   | Instructions and schema                                                                                               | Executable validation                                                                                                                                                                                                                     | Primary coverage                                                                                                                                                                                         |
+| -------------------------- | --------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Supervisor decision        | `src/runtime/steps/supervisor-decision/`                                                                              | strict parser, default-policy child contracts, exact canonical root, and runtime-owned receipt plus verified lineage for returned Planner/Worker results                                                                                  | `supervisor-decision.test.ts`, `role-call-work-receipt-continuation-pr1.test.ts`, `supervisor-request-runner.test.ts`                                                                                    |
+| Supervisor response        | `src/runtime/steps/supervisor-response/`                                                                              | exact active root and bounded returned-child context; legacy normalized terminal mode                                                                                                                                                     | `supervisor-response.test.ts`, `supervisor-request-runner.test.ts`, `request-finalization.test.ts`                                                                                                       |
+| Execution Agent decision   | `src/runtime/steps/execution-agent/`                                                                                  | strict parser, direct-policy actions and root capability authority, exact canonical state                                                                                                                                                 | `execution-agent-decision.test.ts`, `execution-agent-request-runner.test.ts`                                                                                                                             |
+| Execution Agent response   | `src/runtime/steps/execution-agent/response-*`                                                                        | raw non-empty bounded text from the exact accepted response state; direct-policy exact terminal mode only                                                                                                                                 | `execution-agent-request-runner.test.ts`, `request-finalization.test.ts`                                                                                                                                 |
+| Delegated Planner decision | `src/runtime/steps/planner-decision/`                                                                                 | strict parser, exact Planner caller, registered delegated child contracts, complete known plan declaration, one-Worker-item dispatch, and runtime-owned receipt plus verified lineage for the returned Worker                             | `planner-decision.test.ts`, `planner-plan-contract.test.ts`, `role-call-work-receipt-continuation-pr1.test.ts`, `role-call-planner-events.test.ts`                                                       |
+| Planner Graph advisory     | `src/runtime/steps/planner-graph/`                                                                                    | bounded acyclic proposal or decline from the exact advisory objective; no execution authority                                                                                                                                             | `execution-agent-advisory-executors.test.ts`, `execution-agent-request-runner.test.ts`                                                                                                                   |
+| Worker decision            | `src/runtime/steps/worker-decision/`                                                                                  | strict parser, exact Worker activation, offered capability catalog, and compact receipts for explicit dependency results; a directly bound Planner item excludes the broader request, Planner objective, and sibling tool-result lane     | `worker-decision.test.ts`, `worker-capability-decision.test.ts`, `role-call-dependency-work-receipt-pr1.test.ts`, `planner-worker-context-isolation.test.ts`, `planner-worker-tool-result-scope.test.ts` |
+| Worker result              | `src/runtime/steps/worker-decision/result-author.ts`                                                                  | raw text from the exact projected Worker assignment and evidence; Planner-item results retain the same narrowed boundary                                                                                                                  | `worker-decision.test.ts`, `planner-worker-context-isolation.test.ts`, `supervisor-request-runner.test.ts`                                                                                               |
+| Reviewer decision          | `src/runtime/steps/reviewer-decision/`                                                                                | strict parser and bounded supplied-work projection                                                                                                                                                                                        | `reviewer-decision.test.ts`, `supervisor-request-runner.test.ts`                                                                                                                                         |
+| Auditor advisory           | `src/runtime/steps/auditor-decision/`                                                                                 | typed criteria, whole canonical evidence entries, and omission-gated pass                                                                                                                                                                 | `execution-agent-advisory-executors.test.ts`, `execution-agent-request-runner.test.ts`                                                                                                                   |
+| Capability payload         | `src/runtime/orchestration/worker-capabilities/payload-author.ts`, `src/runtime/request/worker-capability-payload.ts` | frozen-policy Worker or root principal, selected operation, immutable controls and payload contract; only a runtime-issued direct-Planner-item receipt can omit source; work-result receipts and lineage are removed before raw authoring | `planner-worker-context-isolation.test.ts`, `worker-capability-payload-author.test.ts`, `worker-payload-dependency-projection-pr1.test.ts`, `execution-agent-request-runner.test.ts`                     |
+| Degraded finalization      | `src/runtime/steps/degraded-finalization/`                                                                            | bounded failure rendering only                                                                                                                                                                                                            | `degraded-finalization.test.ts`, `request-finalization.test.ts`                                                                                                                                          |
 
 Instructions explain semantic choices. Parsers validate exact output shapes.
 The RoleCall ledger and shared capability binding remain the executable
@@ -44,14 +44,24 @@ or completion authority.
   contract. A configured profile may explicitly select `execution-agent-v1`;
   there is no prompt-based selection or mid-request fallback.
 - An active role model alone chooses its next semantic action.
-- The delegated Planner coordinates a bounded sub-process. `planner.graph` is
-  a distinct direct-policy advisory that only proposes or declines a bounded
-  graph; neither gains root response authority.
+- The delegated Planner coordinates a bounded sub-process. Before its first
+  child dispatch it declares every currently known execution outcome, then
+  binds exactly one independently completable production item whenever it
+  dispatches Worker. A later activation may select the next pending production
+  item after consuming the bound Worker result. Other registered child-role
+  contracts are unchanged. `planner.graph` is a distinct direct-policy advisory that only
+  proposes or declines a bounded graph; neither gains root response authority.
 - Worker owns capability selection under `supervisor-worker-v1`; the canonical
   root owns it under `execution-agent-v1`. Both use the same binding, payload
   author, adapter execution, and settlement mechanics.
 - Reviewer returns advisory findings to its exact caller. Runtime code does not
   automatically remediate or finalize from a verdict.
+- Under `supervisor-worker-v1`, the runtime alone issues `work_result_v1` for a
+  terminal Planner or Worker result. The exact caller may receive the compact
+  receipt and a fingerprint-verified lineage projection derived from the
+  canonical ledger. They establish provenance only; the active model still
+  owns the semantic next action and must not treat them as proof of correctness.
+  Model-supplied receipts are rejected and `execution-agent-v1` is unchanged.
 - Auditor returns a passive verdict over explicitly supplied criteria and whole
   evidence entries. Missing or omitted evidence cannot produce pass.
 - `reconsider_capability_selection` is a canonical mechanical transition after

package/package.json

@@ -10,6 +10,7 @@
     "@types/ws": "^8.18.1",
     "@vscode/ripgrep": "1.18.0",
     "dotenv": "^17.4.1",
+    "htmlparser2": "10.0.0",
     "jszip": "^3.10.1",
     "pdf-parse": "2.4.5",
     "postcss": "^8.5.26",
@@ -18,9 +19,9 @@
   "description": "Open runtime for local AI agents.",
   "devDependencies": {
     "@types/node": "^25.5.2",
-    "esbuild": "^0.27.7",
+    "esbuild": "^0.28.2",
     "prettier": "^3.8.1",
-    "tsx": "^4.21.0",
+    "tsx": "^4.23.13",
     "typescript": "^6.0.2",
     "vitest": "^4.1.11"
   },
@@ -171,5 +172,5 @@
   },
   "type": "module",
   "types": "./dist/src/runtime/index.d.ts",
-  "version": "1.1.0"
+  "version": "1.2.0"
 }