@arnilo/prism 0.0.15 → 0.0.17

package/dist/redaction.js

@@ -1,4 +1,7 @@
 const REDACTED = "[REDACTED]";
+// Depth bound matching agent-run-state.ts; hostile deep structures yield a placeholder
+// instead of a stack overflow.
+const MAX_REDACT_DEPTH = 32;
 export function createSecretRedactor(secrets) {
     return { redact: (value) => redactSecrets(value, secrets) };
 }
@@ -17,6 +20,9 @@ export function redactProviderRequest(request, redactor) {
 export function redactRunLedgerRecord(record, redactor) {
     return redactor?.redact(record) ?? record;
 }
+export function resolveRedactor(redactor, secrets) {
+    return redactor ?? (secrets?.some((secret) => Boolean(secret)) ? createSecretRedactor(secrets) : undefined);
+}
 export function redactSecrets(value, secrets) {
     const needles = secrets.filter((secret) => Boolean(secret));
     if (needles.length === 0)
@@ -28,23 +34,25 @@ export function redactSecrets(value, secrets) {
         return String(key);
     };
     const assignKey = (target, key, value) => {
-        if (!Object.prototype.hasOwnProperty.call(target, key)) {
+        if (!Object.hasOwn(target, key)) {
             target[key] = value;
             return;
         }
         let suffix = 2;
-        while (Object.prototype.hasOwnProperty.call(target, `${key}__${suffix}`))
+        while (Object.hasOwn(target, `${key}__${suffix}`))
             suffix += 1;
         target[`${key}__${suffix}`] = value;
     };
     // ponytail: active-path WeakSet marks only ancestor cycles as [Circular]; shared
     // references (diamonds) are visited again on separate branches. Map/Set normalize
     // to JSON-shaped output; string keys are redacted like values.
-    const redact = (input, active = new WeakSet()) => {
+    const redact = (input, active = new WeakSet(), depth = 0) => {
         if (typeof input === "string")
             return redactString(input);
         if (input === null || typeof input !== "object")
             return input;
+        if (depth >= MAX_REDACT_DEPTH)
+            return "[MaxDepth]";
         if (input instanceof Date || input instanceof RegExp)
             return input;
         if (ArrayBuffer.isView(input) || input instanceof ArrayBuffer)
@@ -54,18 +62,18 @@ export function redactSecrets(value, secrets) {
         active.add(input);
         try {
             if (Array.isArray(input))
-                return input.map((item) => redact(item, active));
+                return input.map((item) => redact(item, active, depth + 1));
             if (input instanceof Map) {
                 const out = {};
                 for (const [key, item] of input)
-                    assignKey(out, redactKey(key), redact(item, active));
+                    assignKey(out, redactKey(key), redact(item, active, depth + 1));
                 return out;
             }
             if (input instanceof Set)
-                return [...input].map((item) => redact(item, active));
+                return [...input].map((item) => redact(item, active, depth + 1));
             const out = {};
             for (const [key, item] of Object.entries(input))
-                assignKey(out, redactKey(key), redact(item, active));
+                assignKey(out, redactKey(key), redact(item, active, depth + 1));
             return out;
         }
         finally {
@@ -76,18 +84,21 @@ export function redactSecrets(value, secrets) {
 }
 export function errorToErrorInfo(error, secrets = []) {
     const code = readErrorCode(error);
+    const retry = readRetryAfterMs(error);
+    const retryAfter = retry !== undefined ? { retryAfterMs: retry } : {};
     if (error instanceof Error) {
         return {
             name: error.name,
             message: redactSecrets(error.message, secrets),
             code,
+            ...retryAfter,
             cause: error.cause ? redactSecrets(String(error.cause), secrets) : undefined,
         };
     }
     if (error && typeof error === "object" && "message" in error) {
-        return { message: redactSecrets(String(error.message), secrets), code };
+        return { message: redactSecrets(String(error.message), secrets), code, ...retryAfter };
     }
-    return { message: redactSecrets(String(error), secrets), code };
+    return { message: redactSecrets(String(error), secrets), code, ...retryAfter };
 }
 function readErrorCode(error) {
     if (!error || typeof error !== "object" || !("code" in error))
@@ -95,4 +106,10 @@ function readErrorCode(error) {
     const code = error.code;
     return typeof code === "string" || typeof code === "number" ? code : undefined;
 }
+function readRetryAfterMs(error) {
+    if (!error || typeof error !== "object" || !("retryAfterMs" in error))
+        return undefined;
+    const value = error.retryAfterMs;
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
 //# sourceMappingURL=redaction.js.map

package/dist/resources.d.ts

@@ -1,6 +1,6 @@
-import { type PrismManifest } from "./manifests.js";
-import type { JsonObject, ResourceLoader, ResourceLoadContext } from "./contracts.js";
 import { type MediaContentBounds } from "./content.js";
+import type { JsonObject, ResourceLoadContext, ResourceLoader } from "./contracts.js";
+import { type PrismManifest } from "./manifests.js";
 export declare function loadTextResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<string>;
 export declare function loadJsonResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<JsonObject>;
 export declare function loadManifestResource(loader: ResourceLoader, uri: string, context?: ResourceLoadContext): Promise<PrismManifest>;

package/dist/resources.js

@@ -1,6 +1,6 @@
-import { parsePrismManifest } from "./manifests.js";
 import { assertJsonObject } from "./config.js";
-import { DEFAULT_MAX_MEDIA_ITEM_BYTES, loadBoundedBinaryResource, } from "./content.js";
+import { DEFAULT_MAX_MEDIA_ITEM_BYTES, loadBoundedBinaryResource } from "./content.js";
+import { parsePrismManifest } from "./manifests.js";
 import { assertPermission, assertTrusted } from "./security.js";
 export async function loadTextResource(loader, uri, context) {
     await assertTrusted(context?.trust, { kind: "resource", target: uri, capability: "load", metadata: context?.metadata });

package/dist/retry.d.ts

@@ -5,6 +5,11 @@ export interface DefaultRetryPolicyOptions {
     readonly baseDelayMs?: number;
     readonly maxDelayMs?: number;
     readonly transientCodes?: readonly (string | number)[];
+    /** Symmetric jitter fraction applied to computed delays (default 0.25 → ±25%).
+     *  Prevents thundering-herd retries under a shared outage. Set 0 to disable. */
+    readonly jitter?: number;
+    /** Random source for jitter (tests); defaults to Math.random. */
+    readonly random?: () => number;
 }
 export declare function createDefaultRetryPolicy(options?: DefaultRetryPolicyOptions): RetryPolicy;
 export declare function isTransientErrorInfo(error: ErrorInfo, transientCodes?: ReadonlySet<string | number>): boolean;

package/dist/retry.js

@@ -22,13 +22,20 @@ export function createDefaultRetryPolicy(options = {}) {
     const maxAttempts = Math.max(1, options.maxAttempts ?? 3);
     const baseDelayMs = Math.max(0, options.baseDelayMs ?? 100);
     const maxDelayMs = Math.max(baseDelayMs, options.maxDelayMs ?? 1000);
+    const jitter = Math.min(1, Math.max(0, options.jitter ?? 0.25));
+    const random = options.random ?? Math.random;
     const transientCodes = new Set([...TRANSIENT_CODES, ...(options.transientCodes ?? [])]);
     return {
         name: options.name ?? "default-retry",
         decide(context) {
             if (context.signal?.aborted || context.attempt >= maxAttempts || !isTransientErrorInfo(context.error, transientCodes))
                 return { retry: false };
-            return { retry: true, delayMs: Math.min(maxDelayMs, baseDelayMs * 2 ** Math.max(0, context.attempt - 1)) };
+            // Provider backpressure hint (Retry-After) wins over computed backoff, always
+            // capped at maxDelayMs so a hostile/huge hint cannot pin a run.
+            const hint = context.error.retryAfterMs;
+            const base = Math.min(hint !== undefined && Number.isFinite(hint) && hint >= 0 ? hint : baseDelayMs * 2 ** Math.max(0, context.attempt - 1), maxDelayMs);
+            const delayMs = jitter > 0 ? Math.round(base * (1 - jitter + random() * 2 * jitter)) : base;
+            return { retry: true, delayMs };
         },
     };
 }

package/dist/rpc.js

@@ -1,6 +1,6 @@
 import { createInterface } from "node:readline";
-import { errorToErrorInfo } from "./redaction.js";
 import { resolveInstructionInjectors } from "./instruction-injection.js";
+import { errorToErrorInfo } from "./redaction.js";
 export async function runRpcServer(options) {
     const first = options.createSession();
     const state = {
@@ -58,7 +58,11 @@ async function handleRequest(request, state, stdout, activeRuns) {
             const session = state.current;
             const existing = activeRuns.get(session.id);
             if (existing) {
-                write(stdout, { id: request.id, ok: false, error: errorToErrorInfo(new Error(`Session ${session.id} already has an active run for request ${existing.requestId}`)) });
+                write(stdout, {
+                    id: request.id,
+                    ok: false,
+                    error: errorToErrorInfo(new Error(`Session ${session.id} already has an active run for request ${existing.requestId}`)),
+                });
                 return;
             }
             // ponytail: Phase 30 — resolve run options (incl. instructionInjectors names) BEFORE opening the
@@ -74,9 +78,11 @@ async function handleRequest(request, state, stdout, activeRuns) {
                     await events;
                 }
                 write(stdout, { id: request.id, ok: true, result: { sessionId: session.id } });
-            })().catch((error) => {
+            })()
+                .catch((error) => {
                 write(stdout, { id: request.id, ok: false, error: errorToErrorInfo(error) });
-            }).finally(() => {
+            })
+                .finally(() => {
                 activeRuns.delete(session.id);
             });
             activeRuns.set(session.id, { requestId: request.id, promise });
@@ -100,16 +106,24 @@ async function handleRequest(request, state, stdout, activeRuns) {
             write(stdout, { id: request.id, ok: true, result: { sessionId: state.current.id } });
             break;
         case "state":
-            write(stdout, { id: request.id, ok: true, result: {
+            write(stdout, {
+                id: request.id,
+                ok: true,
+                result: {
                     sessionId: state.current.id,
                     leafId: state.current.leafId,
                     handleId: state.currentHandleId,
                     // ponytail: `sessions` kept as a backward-compatible handle-id string list (== sessionId
                     // for the initial session and clones); `handles` is the branch-handle detail view.
                     sessions: [...state.sessions.keys()],
-                    handles: [...state.sessions.entries()].map(([handleId, session]) => ({ handleId, sessionId: session.id, leafId: session.leafId })),
+                    handles: [...state.sessions.entries()].map(([handleId, session]) => ({
+                        handleId,
+                        sessionId: session.id,
+                        leafId: session.leafId,
+                    })),
                     model: state.model,
-                } });
+                },
+            });
             break;
         case "messages":
             write(stdout, { id: request.id, ok: true, result: { sessionId: state.current.id, entries: await state.current.entries() } });
@@ -152,7 +166,11 @@ async function handleRequest(request, state, stdout, activeRuns) {
             if (!leafId)
                 throw new Error("checkout requires params.leafId");
             await state.current.checkout(leafId);
-            write(stdout, { id: request.id, ok: true, result: { sessionId: state.current.id, leafId: state.current.leafId, handleId: state.currentHandleId } });
+            write(stdout, {
+                id: request.id,
+                ok: true,
+                result: { sessionId: state.current.id, leafId: state.current.leafId, handleId: state.currentHandleId },
+            });
             break;
         }
         case "command": {
@@ -245,7 +263,22 @@ function isObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isCommand(value) {
-    return typeof value === "string" && ["prompt", "steer", "followUp", "abort", "state", "messages", "setModel", "compact", "switchSession", "forkSession", "cloneSession", "checkout", "command"].includes(value);
+    return (typeof value === "string" &&
+        [
+            "prompt",
+            "steer",
+            "followUp",
+            "abort",
+            "state",
+            "messages",
+            "setModel",
+            "compact",
+            "switchSession",
+            "forkSession",
+            "cloneSession",
+            "checkout",
+            "command",
+        ].includes(value));
 }
 function readRequestId(value) {
     return isObject(value) && (typeof value.id === "string" || typeof value.id === "number") ? value.id : null;

package/dist/run-ledger.d.ts

@@ -6,9 +6,15 @@ export declare const HARD_LEDGER_BATCH_BYTES: number;
 export declare const DEFAULT_LEDGER_BATCH_DELAY_MS = 25;
 export declare const HARD_LEDGER_BATCH_DELAY_MS = 60000;
 export interface BatchedRunLedgerOptions {
+    /** Flush triggers, not write grouping: a pending flush fires once the buffer reaches
+     *  this many entries. Writes still go to the target one at a time (RunLedger has no
+     *  batch append); these bounds shape flush *timing*, not per-write coalescing. */
     readonly maxBatchEntries?: number;
+    /** Flush trigger: pending flush fires once buffered bytes reach this bound. */
     readonly maxBatchBytes?: number;
+    /** Backpressure bound: enqueue flushes synchronously before exceeding this. */
     readonly maxBufferedEntries?: number;
+    /** Backpressure bound (bytes): enqueue flushes synchronously before exceeding this. */
     readonly maxBufferedBytes?: number;
     readonly maxDelayMs?: number;
     readonly durability?: RunLedgerDurability;

package/dist/run-ledger.js

@@ -32,12 +32,18 @@ export function createBatchedRunLedger(target, options = {}) {
     let flushChain = Promise.resolve();
     let disposed = false;
     const status = () => ({ accepted, flushed, buffered: queue.length });
-    const cancelTimer = () => { if (timer)
-        clearTimeout(timer); timer = undefined; };
+    const cancelTimer = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = undefined;
+    };
     const schedule = () => {
         if (timer || disposed || queue.length === 0)
             return;
-        timer = setTimeout(() => { timer = undefined; void flush().catch(() => undefined); }, maxDelayMs);
+        timer = setTimeout(() => {
+            timer = undefined;
+            void flush().catch(() => undefined);
+        }, maxDelayMs);
         timer.unref?.();
     };
     const write = (item) => {
@@ -52,20 +58,14 @@ export function createBatchedRunLedger(target, options = {}) {
     const flush = () => {
         cancelTimer();
         const operation = flushChain.then(async () => {
-            let entries = 0;
-            let bytes = 0;
+            // One write per record — RunLedger has no batch append API. maxBatchEntries/
+            // maxBatchBytes only decide when a flush fires (see enqueue), never how writes group.
             while (queue.length) {
                 const item = queue[0];
-                if (entries && (entries >= maxBatchEntries || bytes + item.bytes > maxBatchBytes)) {
-                    entries = 0;
-                    bytes = 0;
-                }
-                await write(item);
+                await write(item); // shifts only after success — a failed write stays buffered for retry
                 queue.shift();
                 bufferedBytes -= item.bytes;
                 flushed += 1;
-                entries += 1;
-                bytes += item.bytes;
             }
             return status();
         });
@@ -83,7 +83,10 @@ export function createBatchedRunLedger(target, options = {}) {
         queue.push({ ...item, bytes });
         bufferedBytes += bytes;
         accepted += 1;
-        if (durability === "write_through" || queue.length >= maxBatchEntries || bufferedBytes >= maxBatchBytes || (item.kind === "run" && terminal(item.record) && durability === "flush_on_terminal"))
+        if (durability === "write_through" ||
+            queue.length >= maxBatchEntries ||
+            bufferedBytes >= maxBatchBytes ||
+            (item.kind === "run" && terminal(item.record) && durability === "flush_on_terminal"))
             await flush();
         else
             schedule();

package/dist/run-limits.js

@@ -58,9 +58,23 @@ export function resolveRunLimits(agent, run) {
             resolved[name] = base ? Math.min(resolved[name], override[name]) : override[name];
     }
     const maxCost = override?.maxCost ?? base?.maxCost;
-    return Object.freeze({ ...resolved, ...(maxCost ? { maxCost: base?.maxCost && override?.maxCost ? { amount: Math.min(base.maxCost.amount, override.maxCost.amount), currency: base.maxCost.currency === override.maxCost.currency ? base.maxCost.currency : failCurrency() } : maxCost } : {}) });
+    return Object.freeze({
+        ...resolved,
+        ...(maxCost
+            ? {
+                maxCost: base?.maxCost && override?.maxCost
+                    ? {
+                        amount: Math.min(base.maxCost.amount, override.maxCost.amount),
+                        currency: base.maxCost.currency === override.maxCost.currency ? base.maxCost.currency : failCurrency(),
+                    }
+                    : maxCost,
+            }
+            : {}),
+    });
+}
+function failCurrency() {
+    throw new TypeError("Run limit currencies must match when narrowed");
 }
-function failCurrency() { throw new TypeError("Run limit currencies must match when narrowed"); }
 function validateLimits(input) {
     for (const name of LIMIT_NAMES) {
         const value = input[name];
@@ -88,7 +102,20 @@ export class RunLimitTracker {
     constructor(limits, options = {}) {
         this.options = options;
         this.limits = limits;
-        this.counters = { turns: 0, providerAttempts: 0, toolRounds: 0, toolCalls: 0, wallTimeMs: 0, requestBytes: 0, responseBytes: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0, cost: 0, ...options.snapshot };
+        this.counters = {
+            turns: 0,
+            providerAttempts: 0,
+            toolRounds: 0,
+            toolCalls: 0,
+            wallTimeMs: 0,
+            requestBytes: 0,
+            responseBytes: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            totalTokens: 0,
+            cost: 0,
+            ...options.snapshot,
+        };
         for (const [key, value] of Object.entries(this.counters)) {
             if (!Number.isFinite(value) || value < 0 || (key !== "cost" && !Number.isSafeInteger(value))) {
                 throw new TypeError("Run limit snapshot must contain finite non-negative counters");
@@ -104,10 +131,17 @@ export class RunLimitTracker {
         if (remaining === 0)
             this.exceed("maxWallTimeMs", limits.maxWallTimeMs);
     }
-    get breach() { return this.exceeded; }
-    snapshot() { return { ...this.counters, wallTimeMs: Math.min(this.limits.maxWallTimeMs, Math.ceil(performance.now() - this.startedAt)) }; }
-    dispose() { if (this.timer)
-        clearTimeout(this.timer); this.timer = undefined; }
+    get breach() {
+        return this.exceeded;
+    }
+    snapshot() {
+        return { ...this.counters, wallTimeMs: Math.min(this.limits.maxWallTimeMs, Math.ceil(performance.now() - this.startedAt)) };
+    }
+    dispose() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+    }
     charge(limit, delta = 1) {
         if (!Number.isSafeInteger(delta) || delta < 0)
             throw new TypeError("Run limit delta must be a non-negative safe integer");
@@ -130,7 +164,7 @@ export class RunLimitTracker {
             if (value !== undefined && (!Number.isSafeInteger(value) || value < 0))
                 throw new TypeError(`Provider usage ${key} must be a non-negative safe integer`);
         }
-        const total = usage.totalTokens ?? ((usage.inputTokens ?? 0) + (usage.outputTokens ?? 0));
+        const total = usage.totalTokens ?? (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0);
         if (!Number.isSafeInteger(total))
             throw new TypeError("Provider usage totalTokens is invalid");
         this.charge("maxInputTokens", usage.inputTokens ?? 0);
@@ -149,8 +183,13 @@ export class RunLimitTracker {
     }
     exceed(limit, observed) {
         if (!this.exceeded) {
-            const maximum = limit === "maxCost" ? this.limits.maxCost?.amount ?? 0 : this.limits[limit];
-            this.exceeded = { limit, maximum, observed, ...(limit === "maxCost" && this.limits.maxCost ? { currency: this.limits.maxCost.currency } : {}) };
+            const maximum = limit === "maxCost" ? (this.limits.maxCost?.amount ?? 0) : this.limits[limit];
+            this.exceeded = {
+                limit,
+                maximum,
+                observed,
+                ...(limit === "maxCost" && this.limits.maxCost ? { currency: this.limits.maxCost.currency } : {}),
+            };
             this.options.onExceeded?.(this.exceeded);
         }
         if (limit !== "maxWallTimeMs")

package/dist/secure-agent.js

@@ -1,5 +1,5 @@
-import { createAgent } from "./agents.js";
 import { validateRunStateOptions } from "./agent-run-state.js";
+import { createAgent } from "./agents.js";
 import { assertIdentityActive, assertIdentityMatchesOwnership } from "./identity.js";
 import { resolveRunLimits } from "./run-limits.js";
 import { createToolParameterValidator, createToolRegistry } from "./tools.js";

package/dist/security.js

@@ -50,11 +50,16 @@ export function createStaticPermissionPolicy(options) {
             const key = `${request.kind}:${request.target}:${request.action}`;
             if (deny.has(key))
                 return { allowed: false, reason: `Permission denied: ${key}` };
-            return { allowed: allow.size === 0 || allow.has(key), reason: allow.size && !allow.has(key) ? `Permission not allowed: ${key}` : undefined };
+            return {
+                allowed: allow.size === 0 || allow.has(key),
+                reason: allow.size && !allow.has(key) ? `Permission not allowed: ${key}` : undefined,
+            };
         },
     };
 }
 export function denialToErrorInfo(error) {
-    return error instanceof Error ? { name: error.name, message: error.message, code: error.code } : { message: String(error) };
+    return error instanceof Error
+        ? { name: error.name, message: error.message, code: error.code }
+        : { message: String(error) };
 }
 //# sourceMappingURL=security.js.map

package/dist/session-stores.d.ts

@@ -1,4 +1,4 @@
-import { type Message, type SessionBranchRead, type BranchReader, type SessionEntry, type SessionStore } from "./contracts.js";
+import { type BranchReader, type Message, type SessionBranchRead, type SessionEntry, type SessionStore } from "./contracts.js";
 export interface CreateSessionEntryOptions extends Omit<SessionEntry, "id" | "timestamp"> {
     readonly id?: string;
     readonly timestamp?: string;

package/dist/session-stores.js

@@ -1,4 +1,4 @@
-import { DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_SESSIONS, DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES, SESSION_APPEND_CONFLICT_CODE, SESSION_SEARCH_WORKSPACE_METADATA_KEY, SessionAppendConflictError, SessionSearchUnsupportedError, resolveSessionSearchQuery, } from "./contracts.js";
+import { DEFAULT_MAX_SESSION_SEARCH_LINEAR_BYTES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_ENTRIES, DEFAULT_MAX_SESSION_SEARCH_LINEAR_SESSIONS, DEFAULT_MAX_SESSION_SEARCH_SNIPPET_BYTES, resolveSessionSearchQuery, SESSION_APPEND_CONFLICT_CODE, SESSION_SEARCH_WORKSPACE_METADATA_KEY, SessionAppendConflictError, SessionSearchUnsupportedError, } from "./contracts.js";
 import { createId } from "./ids.js";
 export function createSessionEntry(options) {
     const { createId, now, ...entry } = options;
@@ -13,7 +13,9 @@ export function createSessionEntry(options) {
 // this if a legitimate branch exceeds it.
 const MAX_BRANCH_PAGES = 64;
 export function getSessionBranchEntries(input, options = {}) {
-    return typeof input === "function" ? readBranchFromReader(input, options) : getSessionBranchEntriesCore(input, options);
+    return typeof input === "function"
+        ? readBranchFromReader(input, options)
+        : getSessionBranchEntriesCore(input, options);
 }
 async function readBranchFromReader(reader, query) {
     const items = [];
@@ -29,8 +31,7 @@ async function readBranchFromReader(reader, query) {
     // indexEntries + the parentId walk order it and still reject missing parents / dupes.
     return getSessionBranchEntriesCore(items, { leafId: query.leafId });
 }
-function getSessionBranchEntriesCore(entries, options = {}) {
-    const index = indexEntries(entries);
+function getSessionBranchEntriesCore(entries, options = {}, index = indexEntries(entries)) {
     const leafId = options.leafId ?? entries.at(-1)?.id;
     if (!leafId)
         return [];
@@ -50,7 +51,7 @@ export function listSessionBranches(entries) {
     const index = indexEntries(entries);
     return entries
         .filter((entry) => !index.parentIds.has(entry.id))
-        .map((entry) => ({ leafId: entry.id, entries: getSessionBranchEntries(entries, { leafId: entry.id }) }));
+        .map((entry) => ({ leafId: entry.id, entries: getSessionBranchEntriesCore(entries, { leafId: entry.id }, index) }));
 }
 export function rebuildSessionContext(input, options = {}) {
     if (typeof input === "function") {
@@ -66,13 +67,15 @@ async function rebuildSessionContextFromReader(reader, query) {
 }
 function rebuildSessionContextCore(entries, options = {}) {
     const branch = getSessionBranchEntriesCore(entries, options);
-    const compaction = [...branch].reverse().find((entry) => entry.kind === "compaction" && entry.summary && isCompactionEntryData(entry.data));
+    const compaction = [...branch]
+        .reverse()
+        .find((entry) => entry.kind === "compaction" && entry.summary && isCompactionEntryData(entry.data));
     if (!compaction || !isCompactionEntryData(compaction.data)) {
         return {
             leafId: branch.at(-1)?.id,
             entries: branch,
-            messages: branch.flatMap((entry) => entry.kind === "message" && entry.message ? [entry.message] : []),
-            summaries: branch.flatMap((entry) => entry.kind === "summary" && entry.summary ? [entry.summary] : []),
+            messages: branch.flatMap((entry) => (entry.kind === "message" && entry.message ? [entry.message] : [])),
+            summaries: branch.flatMap((entry) => (entry.kind === "summary" && entry.summary ? [entry.summary] : [])),
         };
     }
     const keepIds = new Set(compaction.data.keepEntryIds ?? []);
@@ -129,17 +132,22 @@ export function createMemorySessionStore(initialEntries = [], options = {}) {
         if (dedupKey !== undefined && idempotencySeen.has(dedupKey)) {
             throw new SessionAppendConflictError({ code: SESSION_APPEND_CONFLICT_CODE, idempotencyDuplicate: true });
         }
-        // expectedParentId is existence validation (the parent must already be in the
-        // store or be undefined for a root). Tip-CAS is intentionally NOT used: prism
+        // expectedParentId is same-session existence validation (the parent must already
+        // be in the store for THIS session, or be undefined for a root). A parent from
+        // another session is rejected: the write would be unreadable, since every branch
+        // walk is per-session. Tip-CAS is intentionally NOT used: prism
         // allows branching from any existing leaf (checkout + append), so a stale-but-
         // existing parent is a valid branch, not a conflict. DB adapters may layer
         // stricter tip-CAS via unique constraints for linear-only sessions.
-        if (options?.expectedParentId !== undefined && !byId.has(options.expectedParentId)) {
-            throw new SessionAppendConflictError({
-                code: SESSION_APPEND_CONFLICT_CODE,
-                expectedParentId: options.expectedParentId,
-                currentLeafId: leafBySession.get(entry.sessionId),
-            });
+        if (options?.expectedParentId !== undefined) {
+            const parent = byId.get(options.expectedParentId);
+            if (!parent || parent.sessionId !== entry.sessionId) {
+                throw new SessionAppendConflictError({
+                    code: SESSION_APPEND_CONFLICT_CODE,
+                    expectedParentId: options.expectedParentId,
+                    currentLeafId: leafBySession.get(entry.sessionId),
+                });
+            }
         }
         if (byId.has(entry.id))
             throw new Error(`Duplicate session entry id: ${entry.id}`);
@@ -257,16 +265,12 @@ function searchMemorySessionsLinear(bySession, leafBySession, query) {
     }
     matches.sort((a, b) => compareSearchHit(a, b, q.order));
     const afterCursor = q.cursor ? decodeSearchCursor(q.cursor) : undefined;
-    const filtered = afterCursor
-        ? matches.filter((hit) => isAfterSearchCursor(hit, afterCursor, q.order))
-        : matches;
+    const filtered = afterCursor ? matches.filter((hit) => isAfterSearchCursor(hit, afterCursor, q.order)) : matches;
     const page = filtered.slice(0, q.limit);
     const last = page.at(-1);
     return {
         items: page,
-        nextCursor: filtered.length > q.limit && last?.updatedAt
-            ? encodeSearchCursor(last.updatedAt, last.sessionId)
-            : undefined,
+        nextCursor: filtered.length > q.limit && last?.updatedAt ? encodeSearchCursor(last.updatedAt, last.sessionId) : undefined,
     };
 }
 function entrySearchText(entry) {
@@ -323,8 +327,8 @@ function isCompactionEntryData(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const data = value;
-    return (data.throughEntryId === undefined || typeof data.throughEntryId === "string")
-        && (data.keepEntryIds === undefined || (Array.isArray(data.keepEntryIds) && data.keepEntryIds.every((item) => typeof item === "string")));
+    return ((data.throughEntryId === undefined || typeof data.throughEntryId === "string") &&
+        (data.keepEntryIds === undefined || (Array.isArray(data.keepEntryIds) && data.keepEntryIds.every((item) => typeof item === "string"))));
 }
 function indexEntries(entries) {
     const byId = new Map();

package/dist/structured-output.js

@@ -38,8 +38,8 @@ export function assertStructuredOutputRequestSupported(model, options) {
         return;
     validateStructuredOutputOptions(options.structuredOutput);
     if (!modelSupportsStructuredOutput(model.capabilities)) {
-        throw new StructuredOutputError("unsupported_model", `Model ${model.provider}/${model.model} does not declare structuredOutput capability; `
-            + `set loop.structuredOutputMode to "artifact-loop" or choose a capable model`);
+        throw new StructuredOutputError("unsupported_model", `Model ${model.provider}/${model.model} does not declare structuredOutput capability; ` +
+            `set loop.structuredOutputMode to "artifact-loop" or choose a capable model`);
     }
 }
 function isGenerateValidateReviseLoopOptions(loop) {

package/dist/system-prompts.js

@@ -1,7 +1,12 @@
 // ponytail: Phase 31 — `source: "user"` is the global base layer; `source: "app"` sits above package.
 // Behavioral change from Phase 14: `source: "user"` is now the global base (rank 0), not a high-priority caller override.
 // Unknown custom sources sort after package but before app/run so they cannot override host/run layers.
-const sourceRank = new Map([["user", 0], ["package", 1], ["app", 2], ["run", 3]]);
+const sourceRank = new Map([
+    ["user", 0],
+    ["package", 1],
+    ["app", 2],
+    ["run", 3],
+]);
 const unknownSourceRank = 1.5;
 export function composeSystemPrompt(contributions = [], options = {}) {
     const parts = baseParts(options.base);
@@ -40,7 +45,7 @@ function isContributionArray(value) {
     return Array.isArray(value);
 }
 function baseParts(base) {
-    return (typeof base === "string" ? [base] : base ?? []).filter((text) => text.length > 0);
+    return (typeof base === "string" ? [base] : (base ?? [])).filter((text) => text.length > 0);
 }
 function rank(layer) {
     return sourceRank.get(layer.source ?? "") ?? unknownSourceRank;

package/dist/testing/compaction-conformance.js

@@ -16,7 +16,11 @@ import { createSessionEntry } from "../session-stores.js";
 export async function assertCompactionStrategyConforms(strategy, options = {}) {
     const secrets = options.secrets ?? [];
     const entries = [
-        createSessionEntry({ sessionId: "s", kind: "message", message: { role: "user", content: [{ type: "text", text: `old ${secrets[0] ?? "history"}` }] } }),
+        createSessionEntry({
+            sessionId: "s",
+            kind: "message",
+            message: { role: "user", content: [{ type: "text", text: `old ${secrets[0] ?? "history"}` }] },
+        }),
         createSessionEntry({ sessionId: "s", kind: "message", message: { role: "assistant", content: [{ type: "text", text: "recent" }] } }),
     ];
     const context = {