@abot-ai/runtime 1.3.1 → 1.5.0

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

@@ -135,6 +135,7 @@ function enforcePluginResultByteBudget(result) {
 function successResult(input) {
   return enforcePluginResultByteBudget({
     ok: true,
+    ...input.media !== void 0 ? { media: input.media } : {},
     output: input.output,
     producedNewInformation: input.producedNewInformation ?? true,
     ...input.progress !== void 0 ? { progress: input.progress } : {},
@@ -148,6 +149,7 @@ function successResult(input) {
 function failureResult(input) {
   return enforcePluginResultByteBudget({
     ok: false,
+    ...input.media !== void 0 ? { media: input.media } : {},
     output: input.output ?? input.message,
     producedNewInformation: false,
     ...input.progress !== void 0 ? { progress: input.progress } : {},
@@ -172,6 +174,9 @@ function failureFromError(error, options) {
   });
 }
 
+// src/capabilities/tool-media.ts
+var TOOL_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+
 // plugins/system-probe/source/metrics.ts
 var import_node_os = __toESM(require("node:os"), 1);
 function bytesToGiB(bytes) {

package/plugins/web/src/index.cjs

@@ -209,6 +209,7 @@ function enforcePluginResultByteBudget(result) {
 function successResult(input) {
   return enforcePluginResultByteBudget({
     ok: true,
+    ...input.media !== void 0 ? { media: input.media } : {},
     output: input.output,
     producedNewInformation: input.producedNewInformation ?? true,
     ...input.progress !== void 0 ? { progress: input.progress } : {},
@@ -222,6 +223,7 @@ function successResult(input) {
 function failureResult(input) {
   return enforcePluginResultByteBudget({
     ok: false,
+    ...input.media !== void 0 ? { media: input.media } : {},
     output: input.output ?? input.message,
     producedNewInformation: false,
     ...input.progress !== void 0 ? { progress: input.progress } : {},
@@ -246,6 +248,9 @@ function failureFromError(error, options) {
   });
 }
 
+// src/capabilities/tool-media.ts
+var TOOL_IMAGE_MAX_BYTES = 10 * 1024 * 1024;
+
 // src/shared/public-http/errors.ts
 var PublicHttpError = class extends Error {
   code;

package/src/runtime/README.md

@@ -70,6 +70,16 @@ The bridge and Web UI backend call `handleRunRequest(...)` through this path.
 Do not add another runner, request classifier, profile router, or fallback
 semantic loop.
 
+On user cancellation, the request closes its tool resources and drains accepted
+steering before persisting an assistant acknowledgement with any already streamed
+answer text. This ordinary user/assistant pair enters existing session history
+and compaction for either root policy. No model is called to write the stop
+acknowledgement. The terminal event remains `failed` / `request_cancelled`, emitted
+after persistence, and carries the saved response for consistent live display.
+A persistence failure preserves cancellation and sets
+`details.stoppedResponsePersistenceFailed`; it does not claim that history was
+saved. Earlier cancelled requests without an assistant message are not migrated.
+
 ## Code Lifetimes and Composition
 
 `createRuntimeApplication(...)` is the primary composition root. It constructs
@@ -125,11 +135,16 @@ isolation boundaries.
   represents the completed sub-process to Supervisor, which separately owns
   Reviewer delegation and audit decisions. For a Worker child, Planner selects
   only the smallest complete set of offered catalog groups; the Worker still
-  owns capability and control selection.
+  owns capability and control selection. Worker and Planner result prose has no
+  fixed character ceiling; model context admission and compaction retain their
+  configured budgets. Result validation still requires non-empty text and exact
+  caller, dependency, and receipt bindings.
 - **Planner Graph advisory contract** may propose or decline one bounded
-  dependency graph for the Execution Agent. It is a terminal passive child
-  result: it cannot execute graph nodes, write canonical plan state, or commit
-  completion.
+  dependency graph for the Execution Agent, including sequential steps or
+  parallel components converging into one integrated deliverable. It is a
+  terminal passive child result: it cannot execute graph nodes, adopt a plan,
+  or commit completion. The root model may explicitly adopt its exact proposal
+  and report item progress alongside an existing decision.
 - **Worker** performs one bounded objective. It may return a substantive result
   from supplied knowledge or invoke one offered capability when an external
   observation or effect is required. Its structured decision selects the
@@ -138,9 +153,29 @@ isolation boundaries.
   policy and returns a human-readable summary plus a bounded, revision-bound
   `reviewer_verdict_v1` receipt to its exact caller. The receipt is passive
   canonical evidence; it does not choose remediation or finalization.
-- **Auditor** receives typed criteria and whole canonical evidence entries in
-  the direct policy. It returns a passive pass/gaps advisory; omitted evidence
-  makes pass unavailable and the root still owns the next action.
+- **Auditor** receives typed criteria and a complete canonical work inventory
+  in the direct policy. It independently selects whole original evidence,
+  then returns a passive pass/gaps/needs_evidence advisory. A request for more
+  evidence identifies the complete next bundle; the next root invocation of
+  the same criteria binds those exact records without rerunning tools. Pass
+  requires full inventory classification and all needed originals in the
+  current bundle. Previews and prior advisory summaries are not proof.
+  Exact evidence is never compacted or truncated to fit. The configured model
+  context budget controls admission, with no separate fixed evidence-count or
+  character ceiling. Exact duplicate receipt supplements use explicit paths
+  into the same unchanged original adapter result. Capacity failures return a
+  failed advisory instead of requesting repair of a valid evidence selection;
+  the root still owns the next action.
+
+Finished audits and already reviewed bundles are unavailable for unchanged
+work and steering. Canonical work results or new user steering can reopen an
+audit; plan progress, capability-scope changes and advisory returns alone
+cannot. These mechanics prevent repeated identical reviews without choosing
+evidence relevance or semantic completion for the models.
+The Execution Agent's policy favors completion review after implementation and
+available validation, with another review after addressing findings. An earlier
+targeted review remains available for user requests or decisions that benefit
+from it; the runtime never schedules reviews from tool settlement.
 
 A Planner Graph or Auditor structured-output validation failure settles as a
 failed passive child result and returns to the root; it does not write plan
@@ -441,8 +476,14 @@ Top-level delegated Planner calls that commit canonical plan state are
 projected as the existing `planner.plan.*` snapshot and item events. Their
 payload continues to use `stage=development_plan` for client compatibility.
 That stage is presentation metadata only: events are emitted after role-call
-commits and never select a role or advance canonical state. `planner.graph`
-advisories do not create canonical plan state or these events.
+commits and never select a role or advance canonical state. A `planner.graph`
+advisory alone creates no plan or event. The Execution Agent can attach an
+explicit plan adoption or progress report to an existing decision. The ledger
+binds its exact source and item identities on the root, and the same observer
+projects those committed reports into the existing events. This adds no model
+turns. The statuses are model reports, not tool evidence or completion gates;
+Planner/Auditor returns and tool settlement never auto-complete their items.
+The delegated policy keeps its existing Worker-bound plan semantics.
 
 Tool execution continues to use the existing `tool.*` lifecycle. A successful
 tool event establishes only that bounded capability outcome, not completion of

package/src/runtime/local-host/README.md

@@ -42,7 +42,67 @@ remain terminal.
 If initial startup fails before a connection is established, a later explicit
 `start()` or service call can start a fresh connection attempt. Concurrent callers
 share the current attempt. No attempt is repeated automatically, and an established
-connection loss never reconnects or replays a request with an uncertain outcome.
+connection loss never replays a request with an uncertain outcome. Ordinary service
+calls retain the failed connection. Explicit approval access may reconnect to the
+same captured owner endpoint; it never elects a replacement owner or resends a run.
+
+## Saved ASK approvals
+
+Web requests opt into `durableApprovals`. When approval is the only remaining
+work, the request saves an `awaiting_approval` interaction in its existing session
+record and returns. Its runner, request RPC, approval callbacks, timers and tool
+resources retire. Restart leaves this saved response pending. Startup interrupts
+previously running durable activations; it never replays them.
+
+The session record owns the lifecycle, approval descriptions, decision receipts
+and event sequence. Immutable content blobs beneath the session store hold the
+versioned continuation, including the role ledger, prepared actions, history and
+request resource data. These blobs cannot authorize execution on their own.
+Session replacement syncs file data and its directory on supported platforms;
+Windows power-loss durability remains dependent on filesystem guarantees.
+
+`application.approvals.list()` reads pending metadata without loading a
+continuation. Saved-wait `attach(...)` only acknowledges availability. A decision
+includes `generation`, `waitId`, `revision` and a stable `commandId`, in addition
+to session, request and approval IDs. Partial decisions remain saved. The final
+decision validates compatibility, atomically consumes the wait and claims a new
+activation, then resumes the same runner at the exact prepared action. Repeated
+decision commands return the saved receipt. A group dispatches only after all
+its decisions are recorded. No model decision or payload preparation is replayed.
+
+An incompatible or unreadable continuation stays pending and can still be
+cancelled. Explicit cancellation is distinct from tool rejection. A crash after
+the activation claim interrupts that activation even if dispatch has not started
+or its external effect is uncertain: the runtime does not promise exactly-once
+external effects or automatically repeat such work.
+
+While a saved wait exists, the Web composer is frozen and a new request or
+scheduled job in that session is not admitted. The user can cancel the waiting
+request and start another. Previously admitted requests and other sessions retain
+their existing concurrency. Active background tool work keeps its request live;
+the request parks when that work becomes quiescent.
+
+## Legacy approval clients
+
+Clients without `durableApprovals`, including existing Bridge and scheduler
+callers, retain live-owner approvals. Elapsed time and connection loss cannot
+become a user rejection. Their `attach(...)` restores delivery before a late
+decision; stale callbacks cannot decide after replacement. Scheduled requests
+keep their existing broadcast delivery. Saved approval events from older versions
+do not contain a continuation and cannot be migrated into resumable permission.
+
+If the connection closes before an approval notification arrives, an
+approval-capable client request remains unconfirmed until explicit approval
+access checks the same owner's state. An empty approval list is not completion:
+the client retains the request while the owner's exact request/session remains
+active. Older reads cannot replace newer callback or attachment observations.
+This reconciliation never runs a request again or elects a replacement owner.
+
+Legacy request timers exclude approval waits, including overlapping approvals.
+Durable requests preserve their remaining active-time budgets across saved waits;
+time with actual work still in flight continues to count. Owner shutdown aborts
+live execution with `request_interrupted`, without recording a rejection. Saved
+waits have no live execution to abort.
 
 The endpoint contains a random token and is private to the local user: Unix
 directories/files use 0700/0600 and ownership checks; Windows directories are
@@ -77,10 +137,19 @@ A client connection's `close()` only detaches that client.
 Detached passive-memory saves retain their existing background queue and
 independent repository locking; they are not part of request admission.
 Both are idempotent. `onClose` fires on local closure or connection loss and fires
-immediately when registered after loss. Pending calls reject on connection loss;
-the transport never reconnects or replays an uncertain request. A later explicit
-connection can acquire an abandoned PID lock and start a new application.
+immediately when registered after loss. Pending RPC calls reject on connection
+loss; the managed client retains an ordinary request waiting for approval until
+explicit attachment or local shutdown. The transport never replays an uncertain
+request. A later explicit new application can acquire an abandoned PID lock and
+start a new owner; approval reconnection is limited to the original owner.
 
 The application boundary must carry ordinary execution, session lifecycle and
 scheduler operations together. A scheduler-only proxy cannot protect admission,
 session deletion or canonical conversation persistence across processes.
+
+Managed applications expose an idle-only configuration lifecycle boundary:
+isOwnerIdle observes the owning connection's activity/admission fence, and
+stopIfIdle closes intake in the same JavaScript turn as that check. Busy owners
+and attached clients return false without stopping work. This allows a local
+host to explicitly replace its own idle application after a configuration edit
+without using a browser activity list as shutdown authority.

package/src/runtime/scheduler/README.md

@@ -128,8 +128,14 @@ removes its Jobs and run records; late completion cannot recreate them.
 Pausing again cancels a pending manual run even when the Job is already paused.
 It leaves an already-started run alone; a later explicit Run now is still allowed.
 
-Run records keep immutable prompt, title, model profile, agent mode, time zone,
-and Job revision snapshots. A non-timing edit replaces pending work with a fresh
+Jobs accept explicit `full_access` or `full_plus` tool permission. Omitted create
+input defaults to Full; edits preserve the saved permission unless explicitly
+changed. Unsupported values are rejected.
+
+Run records keep immutable prompt, title, model profile, agent mode, tool permission,
+time zone, and Job revision snapshots. Historical runs without tool permission
+retain Full authority. The Runtime adapter submits the captured run permission.
+Permission edits follow the same pending-run replacement rule as other metadata. A non-timing edit replaces pending work with a fresh
 snapshot while preserving its original due time and trigger. Timing edits
 reschedule it; empty and identical edits preserve its identity. Already-started
 and completed history is unchanged. Resume preserves manual pending work.

package/dist/src/runtime/long-term-memory/candidate-persistence.d.ts

@@ -1,16 +0,0 @@
-import type { LongTermMemoryEmbeddingClient, LongTermMemoryRepository, LongTermMemoryRequestContext, MemoryCandidate } from "./contracts.js";
-type EmbeddingBatch = Awaited<ReturnType<LongTermMemoryEmbeddingClient["embed"]>>;
-export type MemoryCandidatePersistenceResult = Readonly<{
-    acceptedCount: number;
-    duplicateCount: number;
-}>;
-export declare function persistMemoryCandidates(params: {
-    repository: LongTermMemoryRepository;
-    preparedCandidates: readonly MemoryCandidate[];
-    freshCandidates: readonly MemoryCandidate[];
-    embedded?: EmbeddingBatch;
-    context: LongTermMemoryRequestContext;
-    now?: () => Date;
-    createId?: () => string;
-}): Promise<MemoryCandidatePersistenceResult>;
-export {};

package/dist/src/runtime/long-term-memory/candidate-persistence.js

@@ -1,109 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { mergeMemoryTags, normalizeMemoryIdentifier, normalizeMemoryText, } from "./policies/normalization.js";
-import { reconcileMemoryCandidate } from "./policies/reconciliation.js";
-export async function persistMemoryCandidates(params) {
-    const vectorByContent = buildVectorMap(params.freshCandidates, params.embedded);
-    const now = (params.now ?? (() => new Date()))().toISOString();
-    const createId = params.createId ?? randomUUID;
-    let result;
-    await params.repository.update((current) => {
-        params.context.abortSignal.throwIfAborted();
-        const records = [...current.records];
-        const vectors = [...current.vectors];
-        let acceptedCount = 0;
-        let duplicateCount = 0;
-        for (const candidate of params.preparedCandidates) {
-            const existingIndex = findRecordIndex(records, candidate);
-            if (existingIndex >= 0) {
-                duplicateCount += 1;
-                records[existingIndex] = mergeDuplicateRecord(records[existingIndex], candidate, now);
-                continue;
-            }
-            const vector = vectorByContent.get(normalizeMemoryText(candidate.content));
-            if (!vector || !params.embedded) {
-                throw new Error("long_term_memory_candidate_embedding_missing");
-            }
-            const id = createAvailableMemoryId(createId, records, vectors);
-            const record = createMemoryRecord({
-                candidate,
-                context: params.context,
-                now,
-                id,
-            });
-            reconcileMemoryCandidate({
-                candidate,
-                vector,
-                existingVectors: compatibleVectors(vectors, params.embedded),
-            });
-            records.push(record);
-            acceptedCount += 1;
-            vectors.push(Object.freeze({
-                memoryId: record.id,
-                modelFingerprint: params.embedded.modelFingerprint,
-                dimensions: params.embedded.dimensions,
-                vector,
-            }));
-        }
-        result = Object.freeze({ acceptedCount, duplicateCount });
-        return { records: Object.freeze(records), vectors: Object.freeze(vectors) };
-    });
-    if (!result) {
-        throw new Error("long_term_memory_candidate_persistence_outcome_missing");
-    }
-    return result;
-}
-function createAvailableMemoryId(createId, records, vectors) {
-    const id = normalizeMemoryIdentifier(createId());
-    if (!id) {
-        throw new Error("long_term_memory_candidate_id_invalid");
-    }
-    const idInUse = records.some((record) => record.id === id) ||
-        vectors.some((entry) => entry.memoryId === id);
-    if (idInUse) {
-        throw new Error("long_term_memory_candidate_id_conflict");
-    }
-    return id;
-}
-function buildVectorMap(candidates, embedded) {
-    const validCount = embedded?.vectors.length === candidates.length;
-    if (!validCount && candidates.length > 0) {
-        throw new Error("long_term_memory_embedding_vector_count_invalid");
-    }
-    if (!embedded) {
-        return new Map();
-    }
-    return new Map(candidates.map((candidate, index) => [
-        normalizeMemoryText(candidate.content),
-        embedded.vectors[index],
-    ]));
-}
-function findRecordIndex(records, candidate) {
-    const candidateKey = normalizeMemoryText(candidate.content);
-    return records.findIndex((record) => normalizeMemoryText(record.content) === candidateKey);
-}
-function compatibleVectors(vectors, embedded) {
-    return vectors
-        .filter((entry) => entry.modelFingerprint === embedded.modelFingerprint &&
-        entry.dimensions === embedded.dimensions)
-        .map((entry) => ({ memoryId: entry.memoryId, vector: entry.vector }));
-}
-function mergeDuplicateRecord(record, candidate, updatedAt) {
-    const tags = mergeMemoryTags(record.tags, candidate.tags);
-    return tags.length === record.tags.length
-        ? record
-        : Object.freeze({ ...record, tags, updatedAt });
-}
-function createMemoryRecord(params) {
-    return Object.freeze({
-        id: params.id,
-        content: params.candidate.content,
-        tags: params.candidate.tags,
-        provenance: Object.freeze({
-            kind: "passive_response",
-            sourceSessionId: params.context.sessionId,
-            sourceRequestId: params.context.requestId,
-        }),
-        createdAt: params.now,
-        updatedAt: params.now,
-    });
-}

package/dist/src/runtime/steps/planner-decision/capability-catalog-context.d.ts

@@ -1,14 +0,0 @@
-import type { ChatMessage } from "../../../model-gateway/types.js";
-import type { RequestContextPinnedPart } from "../../context/request-context-contracts.js";
-import { type WorkerCapabilityCatalogGroup, type WorkerCapabilityDescriptor } from "../../orchestration/worker-capabilities/index.js";
-export declare const PLANNER_WORKER_CAPABILITY_CATALOG_KIND: "runtime_planner_worker_capability_catalog_v1";
-export type PlannerWorkerCapabilityCatalogGroup = Readonly<WorkerCapabilityCatalogGroup & {
-    description: string;
-}>;
-export declare function projectPlannerWorkerCapabilityCatalogGroups(descriptors: readonly WorkerCapabilityDescriptor[]): readonly PlannerWorkerCapabilityCatalogGroup[];
-export declare function buildPlannerReferenceParts(params: Readonly<{
-    callId: string;
-    invocationAttempt: number;
-    exactMessages: readonly ChatMessage[];
-    catalogGroups: readonly PlannerWorkerCapabilityCatalogGroup[];
-}>): readonly RequestContextPinnedPart[];

package/dist/src/runtime/steps/planner-decision/capability-catalog-context.js

@@ -1,87 +0,0 @@
-import { projectWorkerCapabilityCatalogGroups, } from "../../orchestration/worker-capabilities/index.js";
-export const PLANNER_WORKER_CAPABILITY_CATALOG_KIND = "runtime_planner_worker_capability_catalog_v1";
-export function projectPlannerWorkerCapabilityCatalogGroups(descriptors) {
-    const catalogGroups = projectWorkerCapabilityCatalogGroups(descriptors);
-    return Object.freeze(catalogGroups
-        .map((group) => Object.freeze({
-        ...group,
-        description: describeCatalogGroup(group.groupId, descriptors),
-    }))
-        .sort((left, right) => compareAscii(left.groupId, right.groupId)));
-}
-export function buildPlannerReferenceParts(params) {
-    const exactPart = Object.freeze({
-        sourceRef: `planner-reference:${params.callId}:${params.invocationAttempt}`,
-        category: "request_reference",
-        retention: "exact",
-        messages: params.exactMessages,
-    });
-    if (params.catalogGroups.length === 0)
-        return Object.freeze([exactPart]);
-    return Object.freeze([
-        exactPart,
-        Object.freeze({
-            sourceRef: [
-                "planner-worker-capability-catalog",
-                params.callId,
-                String(params.invocationAttempt),
-            ].join(":"),
-            category: "request_reference",
-            retention: "compactable",
-            messages: Object.freeze([
-                buildCatalogMessage("detailed", params.catalogGroups),
-            ]),
-            compactMessages: Object.freeze([
-                buildCatalogMessage("compact", params.catalogGroups),
-            ]),
-        }),
-    ]);
-}
-function buildCatalogMessage(projection, catalogGroups) {
-    const capsule = projection === "compact"
-        ? {
-            kind: PLANNER_WORKER_CAPABILITY_CATALOG_KIND,
-            authority: "runtime_registry",
-            presenceEffect: "passive_not_user_intent",
-            projection,
-            catalogGroups,
-        }
-        : {
-            kind: PLANNER_WORKER_CAPABILITY_CATALOG_KIND,
-            authority: "runtime_registry",
-            presenceEffect: "passive_worker_routing_metadata_not_user_intent_or_execution_authority",
-            applicability: "planner_worker_invoke_role_group_routing_only",
-            lifetime: "request_role_call_projection_only",
-            projection,
-            scopeSemantics: {
-                groupCombination: "or_union",
-                scopeEffect: "narrows_worker_catalog_only",
-                capabilitySelection: "worker_owned",
-            },
-            catalogGroups,
-        };
-    return Object.freeze({
-        role: "user",
-        content: JSON.stringify(capsule),
-    });
-}
-function describeCatalogGroup(groupId, descriptors) {
-    const members = descriptors.filter((descriptor) => (descriptor.catalogGroups ?? ["other"]).includes(groupId));
-    const routingCapabilities = [
-        ...new Set(members.flatMap(({ routingCapability }) => routingCapability ? [routingCapability] : [])),
-    ].sort(compareAscii);
-    const developmentRoles = [
-        ...new Set(members.flatMap(({ developmentRoles: roles }) => roles ?? [])),
-    ].sort(compareAscii);
-    return [
-        `routingCapabilities=${routingCapabilities.join(",")}`,
-        `developmentRoles=${developmentRoles.join(",")}`,
-    ].join("\n");
-}
-function compareAscii(left, right) {
-    if (left < right)
-        return -1;
-    if (left > right)
-        return 1;
-    return 0;
-}