@arnilo/prism 0.0.15 → 0.0.16

package/dist/node/session-store-jsonl.js

@@ -1,6 +1,6 @@
-import { mkdir, readFile, appendFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { SESSION_APPEND_CONFLICT_CODE, SessionAppendConflictError, SessionSearchUnsupportedError, isSessionEntryKind, SESSION_ENTRY_SCHEMA_VERSION, } from "../contracts.js";
+import { isSessionEntryKind, SESSION_APPEND_CONFLICT_CODE, SESSION_ENTRY_SCHEMA_VERSION, SessionAppendConflictError, SessionSearchUnsupportedError, } from "../contracts.js";
 import { isNodeErrorCode } from "./config.js";
 export function createJsonlSessionStore(pathOrOptions) {
     const options = typeof pathOrOptions === "string" ? { path: pathOrOptions, createDirectory: true } : pathOrOptions;
@@ -93,7 +93,10 @@ function parseEntry(line, lineNumber) {
 }
 function validateSessionEntry(value, lineNumber, raw) {
     if (!isBasicSessionEntry(value)) {
-        return { ok: false, error: { line: lineNumber, message: "Invalid session entry: expected object with id, sessionId, timestamp, and kind", raw } };
+        return {
+            ok: false,
+            error: { line: lineNumber, message: "Invalid session entry: expected object with id, sessionId, timestamp, and kind", raw },
+        };
     }
     const entry = value;
     if (entry.parentId !== undefined && typeof entry.parentId !== "string") {
@@ -149,10 +152,10 @@ function isBasicSessionEntry(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
     const entry = value;
-    return typeof entry.id === "string"
-        && typeof entry.sessionId === "string"
-        && typeof entry.timestamp === "string"
-        && typeof entry.kind === "string";
+    return (typeof entry.id === "string" &&
+        typeof entry.sessionId === "string" &&
+        typeof entry.timestamp === "string" &&
+        typeof entry.kind === "string");
 }
 function isMessage(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))

package/dist/node/settings.d.ts

@@ -1,6 +1,6 @@
 import { type ConfigLayer } from "../config.js";
-import { type NodeConfigFile } from "./config.js";
 import type { SettingsProvider } from "../contracts.js";
+import { type NodeConfigFile } from "./config.js";
 export type NodeSettingsFile = NodeConfigFile;
 export declare function defaultUserSettingsPath(appName?: string): string;
 export declare function readSettingsFile(path: string): Promise<ConfigLayer["config"]>;

package/dist/node/settings.js

@@ -1,8 +1,8 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { mergeConfigLayers } from "../config.js";
-import { readConfigFile, isNodeErrorCode } from "./config.js";
 import { createStaticSettingsProvider } from "../settings.js";
+import { isNodeErrorCode, readConfigFile } from "./config.js";
 export function defaultUserSettingsPath(appName = "prism") {
     return join(homedir(), ".config", appName, "settings.json");
 }

package/dist/node/system-project-prompts.js

@@ -14,10 +14,8 @@ import { readOptionalFile } from "./contribution-discovery.js";
  *  singletons don't fit `discoverContributions`' named-subdir scanner, so this is a
  *  sibling loader mirroring `src/node/instruction-injectors.ts`'s per-concern adapter shape. */
 export async function loadSystemPromptFiles(options) {
-    const agentsPath = options.agentsMdPath
-        ?? (options.workspaceRoot !== undefined ? join(options.workspaceRoot, "AGENTS.md") : undefined);
-    const systemPath = options.systemMdPath
-        ?? (options.globalRoot !== undefined ? join(options.globalRoot, ".prism", "agent", "SYSTEM.md") : undefined);
+    const agentsPath = options.agentsMdPath ?? (options.workspaceRoot !== undefined ? join(options.workspaceRoot, "AGENTS.md") : undefined);
+    const systemPath = options.systemMdPath ?? (options.globalRoot !== undefined ? join(options.globalRoot, ".prism", "agent", "SYSTEM.md") : undefined);
     const out = [];
     if (systemPath !== undefined) {
         const layer = await readSystemFile(systemPath, options.permission);

package/dist/node/trust.js

@@ -1,5 +1,5 @@
-import { isAbsolute, relative, resolve, dirname, basename, join } from "node:path";
 import { realpath } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { isNodeErrorCode } from "./config.js";
 export function isPathInside(root, target) {
     const from = resolve(root);

package/dist/persistence-lifecycle.js

@@ -64,9 +64,7 @@ export function createMemoryPersistenceLifecycle() {
         async applyRetention(input) {
             throwIfAborted(input.signal);
             assertOwnership(input);
-            const held = new Set([...holds.values()]
-                .filter((hold) => sameOwnership(input, hold) && hold.resourceKind === "session")
-                .map((hold) => hold.resourceId));
+            const held = new Set([...holds.values()].filter((hold) => sameOwnership(input, hold) && hold.resourceKind === "session").map((hold) => hold.resourceId));
             const candidates = input.candidates ?? [];
             const deletedIds = [];
             const skippedHeld = [];

package/dist/provider-events.js

@@ -35,7 +35,9 @@ export function reconstructToolCallDeltas(events) {
             partial.argumentsText += event.argumentsText;
         partials.set(event.index, partial);
     }
-    return [...partials.entries()].sort(([a], [b]) => a - b).map(([index, partial]) => {
+    return [...partials.entries()]
+        .sort(([a], [b]) => a - b)
+        .map(([index, partial]) => {
         if (!partial.id || !partial.name) {
             throw new ProviderTransportError("incomplete_delta", `Incomplete tool call delta at index ${index}`);
         }

package/dist/provider-request-policy.js

@@ -50,10 +50,9 @@ export function mergeProviderRequestOptions(base, patch) {
         cache: {
             ...base.cache,
             ...patch.cache,
-            breakpoints: base.cache?.breakpoints || patch.cache?.breakpoints ? [
-                ...(base.cache?.breakpoints ?? []),
-                ...(patch.cache?.breakpoints ?? []),
-            ] : undefined,
+            breakpoints: base.cache?.breakpoints || patch.cache?.breakpoints
+                ? [...(base.cache?.breakpoints ?? []), ...(patch.cache?.breakpoints ?? [])]
+                : undefined,
         },
     };
 }

package/dist/providers/media.d.ts

@@ -1,5 +1,5 @@
+import { type MediaContentBlock, type ModelInputCapability, type ResolvedMediaContent, type ResolveMediaContentOptions } from "../content.js";
 import type { AudioContent, ContentBlock, DocumentContent, FileContent, JsonObject, Message, ModelCapabilities, ModelConfig } from "../contracts.js";
-import { type MediaContentBlock, type ModelInputCapability, type ResolveMediaContentOptions, type ResolvedMediaContent } from "../content.js";
 /** Default upload-cache entry cap per provider media session. */
 export declare const DEFAULT_PROVIDER_UPLOAD_CACHE_ENTRIES = 32;
 /** Inline OpenAI file_data ceiling before preferring Files API upload. */

package/dist/providers/openai-compatible.js

@@ -1,8 +1,8 @@
 import { resolveCredentialValue } from "../credentials.js";
 import { providerDone, providerError, providerTextDelta, providerThinkingDelta, providerToolCall, providerToolCallDelta, providerUsage, toolCallFromArgumentsText, } from "../provider-events.js";
-import { assertOpenAIChatMessage, applyOpenAIChatStructuredOutput, mapOpenAIChatUsage, serializeOpenAIChatMessage, serializeOpenAITool, } from "./openai-primitives.js";
-import { ProviderTransportError, readBoundedResponseText, readSseData, } from "./transport.js";
 import { assertStructuredOutputRequestSupported } from "../structured-output.js";
+import { applyOpenAIChatStructuredOutput, assertOpenAIChatMessage, mapOpenAIChatUsage, serializeOpenAIChatMessage, serializeOpenAITool, } from "./openai-primitives.js";
+import { ProviderTransportError, readBoundedResponseText, readSseData } from "./transport.js";
 export function createOpenAICompatibleProvider(options) {
     const providerId = options.id ?? "openai-compatible";
     return {
@@ -18,8 +18,7 @@ export function createOpenAICompatibleProvider(options) {
             try {
                 const url = typeof options.chatCompletionsUrl === "function"
                     ? options.chatCompletionsUrl(request)
-                    : options.chatCompletionsUrl
-                        ?? `${options.baseUrl.replace(/\/$/, "")}/chat/completions`;
+                    : (options.chatCompletionsUrl ?? `${options.baseUrl.replace(/\/$/, "")}/chat/completions`);
                 const authStyle = options.authStyle ?? "bearer";
                 const headers = {
                     ...Object.fromEntries(Object.entries(request.options?.headers ?? {}).filter((entry) => typeof entry[1] === "string")),

package/dist/providers/openai-primitives.js

@@ -110,13 +110,13 @@ export function mapOpenAIChatUsage(usage) {
     if (!usage || typeof usage !== "object" || Array.isArray(usage))
         return undefined;
     const wire = usage;
-    if (wire.prompt_tokens === undefined
-        && wire.completion_tokens === undefined
-        && wire.total_tokens === undefined
-        && wire.prompt_cache_hit_tokens === undefined
-        && wire.prompt_tokens_details?.cached_tokens === undefined
-        && wire.prompt_tokens_details?.cache_write_tokens === undefined
-        && wire.prompt_tokens_details?.cache_creation_input_tokens === undefined) {
+    if (wire.prompt_tokens === undefined &&
+        wire.completion_tokens === undefined &&
+        wire.total_tokens === undefined &&
+        wire.prompt_cache_hit_tokens === undefined &&
+        wire.prompt_tokens_details?.cached_tokens === undefined &&
+        wire.prompt_tokens_details?.cache_write_tokens === undefined &&
+        wire.prompt_tokens_details?.cache_creation_input_tokens === undefined) {
         return undefined;
     }
     return {

package/dist/redaction.d.ts

@@ -8,5 +8,6 @@ export declare function redactAgentEvent(event: AgentEvent, redactor?: SecretRed
 export declare function redactSessionEntry(entry: SessionEntry, redactor?: SecretRedactor): SessionEntry;
 export declare function redactProviderRequest(request: ProviderRequest, redactor?: SecretRedactor): ProviderRequest;
 export declare function redactRunLedgerRecord<T extends RunLedgerRecord>(record: T, redactor?: SecretRedactor): T;
+export declare function resolveRedactor(redactor?: SecretRedactor, secrets?: readonly (string | undefined)[]): SecretRedactor | undefined;
 export declare function redactSecrets<T>(value: T, secrets: readonly (string | undefined)[]): T;
 export declare function errorToErrorInfo(error: unknown, secrets?: readonly (string | undefined)[]): ErrorInfo;

package/dist/redaction.js

@@ -17,6 +17,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,12 +31,12 @@ 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;
     };

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/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.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) => {
@@ -83,7 +89,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 = [];
@@ -66,13 +68,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 ?? []);
@@ -257,16 +261,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 +323,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 = {