@abot-ai/runtime 1.1.0 → 1.3.0

package/docs/long-term-memory.md

@@ -1,9 +1,10 @@
 # Passive Long-Term Memory
 
 ABot Runtime can retain selected user facts and preferences across sessions.
-This feature is passive: the model does not invoke a memory tool, and the
-Runtime core remains the only owner of retrieval, filtering, deduplication,
-storage, and deletion.
+Memory is stored in a Runtime-owned pool. The Runtime core owns retrieval,
+filtering, deduplication, storage, and deletion. The root model can request a
+focused recall through its built-in decision contract without invoking a plugin
+tool.
 
 Long-term memory is disabled by default. Enabling it is an explicit consumer
 choice because it may persist personal information between conversations.
@@ -47,8 +48,47 @@ reference context; it is never treated as a new user request or an instruction.
 
 Retrieval, candidate policy, filtering, deduplication, and persistence are
 shared by `supervisor.response` and `execution.response`; only their authoring
-contracts differ. Decision, planning, Worker, Reviewer, payload, and tool
-contexts do not receive the long-term memory projection.
+contracts differ. Automatic retrieval remains a terminal-response feature.
+Planner, Worker, Reviewer, payload, and tool contexts do not receive the memory
+projection.
+
+## Model-Requested Recall
+
+When memory is enabled, the Supervisor and Execution Agent root decisions may
+choose `recall_memory` with a concise query about a remembered fact or preference.
+This is an internal Runtime context request: it requires no plugin, capability
+selection, controls, payload generation, or delegated role.
+
+The existing memory service performs the search. The root receives a bounded
+passive result and then chooses its next action in the same request loop:
+
+- `found`: recalled records with their ids, provenance, and timestamps.
+- `empty`: the search returned no matching records.
+- `unavailable`: retrieval could not supply records; this does not mean the pool
+  contains no relevant memory.
+
+Queries have a 1,024-character limit. Results contain at most six whole records
+within a 6,000-character serialized budget; the combined root context uses the
+same bound and declares omitted records and recalls. The request's existing
+activation limit also applies to recall. `longTermMemory.maxRecallCallsPerRequest`
+sets the maximum number of explicit lookups per user request (default: 5, a
+positive integer). After that many calls, the model no longer receives the
+`recall_memory` action. The request continues normally, with earlier recall
+results still available. Changing the query or steering the active request does
+not reset this count; a new request starts fresh. No independent retry loop is
+introduced.
+The result is bound to the requesting root and current user steering version;
+superseded results are not projected into later decisions. Recalled facts are
+reference data, not new instructions or proof that work completed.
+
+The final response reuses explicit recall results without another automatic
+search. If the model does not request recall, the ordinary automatic terminal
+retrieval remains unchanged. Saving memory candidates keeps its existing
+background lifecycle in both execution policies.
+
+Recall still depends on the configured embedding provider. A stale vector index
+may be rebuilt during search, so the shorter orchestration path does not imply a
+fixed latency or offline lexical fallback.
 
 Both response paths also share the same configured response-experience
 methodology. It applies whether memory is enabled or disabled. Relevant memory
@@ -107,6 +147,7 @@ to it:
   "longTermMemory": {
     "enabled": true,
     "emitClientEvents": false,
+    "maxRecallCallsPerRequest": 5,
     "embeddingProfileId": "memory-embedding"
   }
 }

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 v18 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-library.md

@@ -41,12 +41,35 @@ const handle = runtime.host.start({
   toolRegistry: runtime.tools,
 });
 
+await handle.ready;
+
 process.on("SIGINT", async () => {
   await handle.stop();
   process.exit(0);
 });
 ```
 
+The default host starts the scheduler automatically, including persisted Jobs.
+Overlapping handles for the same scheduler share its lifetime: `stop()` closes
+that handle's Bridge, and only the last handle stops the scheduler. `start()` remains
+synchronous for compatibility; the optional `ready` promise exposes asynchronous
+startup errors and requests wait for readiness. A failed startup releases its own
+resources even when a consumer does not read `ready`. Custom injected hosts may
+keep the existing `{ stop }` handle.
+
+Supply adapter overrides before starting a host. A different session store,
+configuration, model client, attachment store, tool registry or memory service
+rebuilds the scheduler's request graph as well as ordinary requests. Session
+storage remains backed by the injected store, through the composed deletion
+guard. Use the host's effective graph consistently; do not start the original
+graph alongside its replacement against the same scheduler directory. An event
+observer override alone keeps the existing admission and scheduler lifetime.
+
+Session deletion finishes attachment cleanup before acknowledging the deletion
+receipt. An explicit repeat retries only failed cleanup, through the same owner
+for Web, Bridge and local clients. Web shutdown closes HTTP/WebSocket intake and
+prevents new environment initialization before awaiting pending startup work.
+
 ## Runtime Config
 
 The default host reads `runtime.config.json`, then lets environment variables

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/docs/runtime-public-contracts.md

@@ -131,7 +131,9 @@ not create `planner.plan.*` state or events.
 Runtime capabilities use the stable tool event envelope. Adapter-owned
 presentation metadata supplies the tool, operation and action type; target
 metadata contains only resolved logical paths. Physical
-roots, opaque subject identities and authored payload bodies are never exposed.
+roots and opaque subject identities are never exposed. A plugin may opt into
+bounded input or result excerpts through its declared event presentation.
+These excerpts are display data, not additional model instructions or evidence.
 These events describe capability execution only. Only `planner.plan.*` events
 report canonical item-status changes or semantic progress.
 
@@ -146,6 +148,31 @@ Tool events use the current tool execution boundary:
 A `tool.completed` event with `ok: true` proves only that the tool step
 succeeded. It does not prove the user request is complete.
 
+Registered-tool events may include an optional `executionId` shared by their
+payload, approval and execution stages. Clients correlate with
+`(requestId, executionId)` rather than matching tool names or arrival order.
+Payload publication still occurs after canonical admission. Older events without
+this field do not establish a lifecycle pairing.
+
+The same adapter boundary may include `executorRole` and `roleCallId` from the
+canonical role call. Clients can place the action under its executor even when
+the active role has changed before completion. These fields are display identity;
+they do not change runtime stages, tool parameters, approval inputs or evidence.
+The root role identifier remains `supervisor` regardless of its selected contract.
+
+`eventPresentation.resultMetadata` maps optional display keys to existing tool
+result fields through `{path, kind}` descriptors. Paths select `output` or an
+own-property path under `data` (at most four segments). Kinds are `preview`,
+`number` and `boolean`, with at most 16 mappings. A preview is limited to 1,200
+characters and 20 lines, with a 2,400-character total preview budget per event;
+its companion `<key>Truncated` flag describes preview clipping, independently
+of source-result truncation. Missing or mismatched fields are omitted. Valid
+declared values take precedence over generic metadata; omitted fields retain
+the existing fallback metadata. Projection
+does not mutate tool results, canonical evidence, action references or model
+context. The client renders excerpts as inert text and never reconstructs an
+old result by re-reading the current file or memory store.
+
 ## ToolRegistry
 
 `ToolRegistry` owns active tool capability discovery and execution:
@@ -177,6 +204,10 @@ retained for compatibility. They must not select a request path or role.
 Model-facing availability and controls come from the registered
 `normalInvocation` contract.
 
+A normal-invocation contract accepts at most 32 operations. This bounds the
+registered operation catalog; it does not limit invocation frequency or the
+number of user-created scheduled Jobs.
+
 Every plugin-handler return is normalized by `ToolRegistry` into one complete
 `ToolExecutionResult`, whether the operation succeeds or fails. The selected
 tool identity is Runtime-owned; plugins provide the operation result. The

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"
   },
@@ -82,6 +83,8 @@
     "dist/src/web-ui/",
     "runtime.config.schema.json",
     "src/runtime/README.md",
+    "src/runtime/scheduler/README.md",
+    "src/runtime/local-host/README.md",
     "LICENSE",
     "docs/architecture.md",
     "docs/bridge-compatibility.md",
@@ -171,5 +174,5 @@
   },
   "type": "module",
   "types": "./dist/src/runtime/index.d.ts",
-  "version": "1.1.0"
+  "version": "1.3.0"
 }

package/plugins/capability-brief/source/index.ts

@@ -1,16 +1,11 @@
 import {
-  boundCollection,
-  boundText,
+  buildToolAvailabilityBrief,
   defineRuntimePlugin,
   failureResult,
   successResult,
-  type ToolAvailabilityEntry,
   type ToolExecutionContext,
 } from "../../../src/plugin-sdk/index.js";
 
-const TOOL_COUNT_MAX = 64;
-const OUTPUT_CHARACTER_MAX = 16_000;
-
 export default defineRuntimePlugin(() => ({
   handlers: {
     async capability_brief(
@@ -25,32 +20,16 @@ export default defineRuntimePlugin(() => ({
         });
       }
 
-      const orderedTools = [...availableTools].sort(compareAvailableTools);
-      const boundedTools = boundCollection(orderedTools, {
-        maxItems: TOOL_COUNT_MAX,
-      });
-      const rawOutput = [
-        `Available tool operations: ${availableTools.length}`,
-        ...boundedTools.items.map(formatAvailableTool),
-        ...(boundedTools.metadata.truncated
-          ? [
-              `[${boundedTools.metadata.omittedItems} additional tool operations omitted]`,
-            ]
-          : []),
-      ].join("\n");
-      const boundedOutput = boundText(rawOutput, {
-        maxChars: OUTPUT_CHARACTER_MAX,
-        marker: "\n[available tool brief truncated]",
-      });
+      const brief = buildToolAvailabilityBrief(availableTools);
 
       return successResult({
-        output: boundedOutput.text,
+        output: brief.text,
         producedNewInformation: true,
         data: {
           source: "request_effective_tool_registry",
           toolOperationCount: availableTools.length,
-          collection: boundedTools.metadata,
-          output: boundedOutput.metadata,
+          collection: brief.collection,
+          output: brief.output,
           observationMeta: {
             kind: "stable_fact",
             carryPolicy: "never",
@@ -60,25 +39,3 @@ export default defineRuntimePlugin(() => ({
     },
   },
 }));
-
-function formatAvailableTool(tool: ToolAvailabilityEntry): string {
-  return [
-    `- ${tool.operationId}`,
-    `(tool=${tool.toolName}; effect=${tool.effect}; groups=${tool.catalogGroups.join(",")})`,
-    tool.summary,
-  ].join(" ");
-}
-
-function compareAvailableTools(
-  left: ToolAvailabilityEntry,
-  right: ToolAvailabilityEntry,
-): number {
-  const byOperation = compareAscii(left.operationId, right.operationId);
-  return byOperation !== 0
-    ? byOperation
-    : compareAscii(left.toolName, right.toolName);
-}
-
-function compareAscii(left: string, right: string): number {
-  return left < right ? -1 : left > right ? 1 : 0;
-}