@abot-ai/runtime 1.4.0 → 1.6.0

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

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,9 +137,11 @@ 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,

package/src/runtime/scheduler/README.md

@@ -21,6 +21,19 @@ settling into a restarted generation. Startup marks previously running requests
 Jobs to their next future occurrence. It never retries an interrupted or failed
 request or backfills missed occurrences.
 
+Automation session reconciliation runs after startup recovery under the same
+exclusive ownership, before dispatch is enabled; lazy service startup uses this
+boundary too. The file adapter retires only complete persisted `automationOrigin`
+records whose exact session ID has no issued active handle. Each pass scans at
+most 256 regular JSON records and retires at most 64 internal sessions, advancing
+a cursor through ordinary records and failed candidates. Attachments are removed
+before the transcript so failed cleanup keeps its durable ownership marker.
+Attempt deletion first installs its existing tombstone, blocking late transcript
+writes while attachment cleanup waits. Cleanup failures are reported without
+disabling scheduled work, and existing five-minute maintenance can try later.
+Ordinary conversations, canonical run results and source snapshots are untouched;
+injected adapters participate only through the optional trusted recovery hook.
+
 A session deletion reserves its start barrier synchronously, including while
 startup is queued. Passing the running-state check confirms deletion; a rejected
 lifecycle call releases only its own reservation. A storage failure after
@@ -45,6 +58,9 @@ is uncertain. The owned store rejects further cached reads, writes and cleanup
 until explicitly released and reacquired; it does not retry a mutation or dispatch
 an unconfirmed claim. Both old and new files remain available. Reacquisition validates
 and syncs the visible head and its directory dependencies before cleanup.
+Automation result files follow the same boundary: uncertain publication preserves
+their bytes, and existing retention maintenance reclaims unreferenced owned files
+only after reading a durable journal head. In-flight publications remain protected.
 These barriers rely on the filesystem and device honoring fsync; they are not a
 backup or repair mechanism for pre-existing corruption.
 
@@ -112,6 +128,17 @@ interval cannot block another Job or startup recovery. The Web editor retains
 the exact saved interval anchor when its displayed field is unchanged, including
 seconds, milliseconds and the selected occurrence of a repeated local time.
 
+Automation draft readiness uses the same next-occurrence and interval-range
+checks as scheduler admission, including the publication clock and time zone.
+New or changed elapsed one-shot dates produce a normal validation issue before
+publication; unchanged authored timing keeps its published timer deadline or
+implicit interval/folder polling anchor across title and graph edits. Actual
+duration, anchor or trigger-kind edits establish new timing. Time-zone metadata
+changes reschedule calendar forms only. The exact retained publication identifies
+unchanged timing, and a concurrent Job revision change rejects publication atomically.
+Manually replaying a frozen run validates its schedule shape without requiring
+a new future scheduled occurrence.
+
 Calendar conversion uses `Intl.DateTimeFormat` from the host's IANA time-zone data.
 Missing wall times/days are skipped; repeated local times select their first
 occurrence once. Intervals preserve elapsed-time cadence across DST.
@@ -128,8 +155,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.
@@ -164,3 +197,39 @@ admission and reject a deleted session before executing its request.
 
 The model and Web layers share this service. Natural-language interpretation,
 model choice, conversation projection, and UI rendering do not belong here.
+
+## Automation folder retention and capacity
+
+Folder input history, including baseline exclusions and consumed-version dedup
+records, is bounded to 32 MiB of metadata per automation across all of its source
+IDs and roots. Reaching that bound stops intake for that automation; changing a
+source ID does not reset it, and unrelated automations can continue. History is
+preserved rather than silently making old file versions eligible again. This
+does not promise indefinite intake for one automation without a capacity stop.
+Retained input snapshots additionally share environment limits of 1,000 records,
+32 MiB of snapshot-record metadata and 256 MiB of file bytes.
+
+Snapshots, including held failed/interrupted inputs, can retire after every
+referencing report expires at 90 days and no unresolved effect remains. Fulfilled
+late settlements (`succeeded` or `failed`) resolve that retention blocker while
+the original uncertain outcome remains historical evidence. Missing or rejected
+late settlements continue protecting the affected payloads. A newer
+replay or active execution keeps its input snapshot. Root-specific baseline
+exclusions preserve the original snapshot and replay identity when a source
+changes to an overlapping directory. A batch searches for a feasible minimum
+file count within its 32 MiB byte limit; oversized candidates remain pending.
+
+New source snapshots are preceded by a durable preparation marker. Existing
+scheduler maintenance and source preparation reconcile these markers: a committed
+input/run preserves its snapshots, an active preparation is protected, and a
+marker abandoned by a crashed process authorizes removal of only that candidate's
+attachments. Unmarked attachment owners are never inferred to be automation
+orphans; ordinary conversation attachments remain outside this cleanup.
+
+Automation run reads add a transient output summary from the frozen graph's
+terminal producers, including separate parallel tails. At most four saved
+outputs are previewed with an explicit omitted count and the existing 4,000
+character limit per text/data part; full step evidence remains a separate read.
+These previews preserve step status and distinguish available, expired and
+unavailable output. They neither infer a business outcome from model text nor
+extend retention by copying output into the persisted compact report.

package/dist/plugins/system/source/companion/native-supervisor.js

@@ -1,93 +0,0 @@
-import { setTimeout as delay } from "node:timers/promises";
-import { connectNativeHost, } from "./native-session.js";
-import { hasSameNativeConnection, } from "./native-state.js";
-function isTransientNativeLookupError(error) {
-    if (error === null)
-        return false;
-    if (typeof error !== "object")
-        return false;
-    if (!("code" in error))
-        return false;
-    if (error.code === "EAI_AGAIN")
-        return true;
-    return error.code === "ENOTFOUND";
-}
-export async function runNativeHostSupervisor(options) {
-    const initial = await options.state.read();
-    if (!initial)
-        return;
-    const controller = new AbortController();
-    const stop = () => controller.abort();
-    options.signal.addEventListener("abort", stop, { once: true });
-    let checking = false;
-    let connected = false;
-    const checkState = async () => {
-        if (checking || controller.signal.aborted)
-            return;
-        checking = true;
-        try {
-            const current = await options.state.read();
-            if (!current || !hasSameNativeConnection(initial, current)) {
-                stop();
-                return;
-            }
-            await options.state.setStatus(initial.hostId, connected);
-        }
-        catch {
-            stop();
-        }
-        finally {
-            checking = false;
-        }
-    };
-    const poll = setInterval(() => {
-        void checkState();
-    }, 1_000);
-    let reconnectDelay = options.reconnectDelayMs ?? 500;
-    try {
-        if (options.signal.aborted)
-            stop();
-        while (!controller.signal.aborted) {
-            const outcome = await (options.connect ?? connectNativeHost)({
-                url: initial.url,
-                authorization: initial.credential,
-                hostId: initial.hostId,
-                identity: options.identity,
-                signal: controller.signal,
-                onPaired: async () => {
-                    throw new Error("A saved native connection cannot pair again.");
-                },
-                onReady: async () => {
-                    connected = true;
-                    reconnectDelay = options.reconnectDelayMs ?? 500;
-                    await options.state.setStatus(initial.hostId, true);
-                },
-            }).catch((error) => {
-                if (controller.signal.aborted)
-                    return "stopped";
-                if (isTransientNativeLookupError(error))
-                    return "disconnected";
-                throw error;
-            });
-            connected = false;
-            await options.state.setStatus(initial.hostId, false);
-            if (outcome === "authorization_rejected") {
-                await options.state.remove(initial);
-                return;
-            }
-            if (outcome === "protocol_rejected" || outcome === "stopped")
-                return;
-            // Only the connection is restored. No operation survives this boundary.
-            await delay(reconnectDelay, undefined, {
-                signal: controller.signal,
-            }).catch(() => { });
-            reconnectDelay = Math.min(reconnectDelay * 2, 10_000);
-        }
-    }
-    finally {
-        clearInterval(poll);
-        stop();
-        options.signal.removeEventListener("abort", stop);
-        await options.state.setStatus(initial.hostId, false);
-    }
-}

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,
-    });
-}