@sema-agent/client-core 0.110.0 → 0.112.0

package/dist/modelConfigGapNotice.d.ts

@@ -0,0 +1,20 @@
+import type { UiLanguage } from './env/uiLanguage.js';
+type ModelConfigPartTuple = readonly ['model', 'gateway-url', 'api-key'];
+export type ModelConfigPart = ModelConfigPartTuple[number];
+export type ModelConfigKeyChannel = 'anthropic';
+export interface ModelConfigGap {
+    readonly parts: readonly ModelConfigPart[];
+    readonly keyChannel?: ModelConfigKeyChannel;
+    readonly catalogEntries?: number;
+}
+export type ModelConfigGapNotice = {
+    readonly kind: 'gap';
+    readonly head: string;
+    readonly detail: string;
+} | {
+    readonly kind: 'none';
+} | {
+    readonly kind: 'malformed';
+};
+export declare function modelConfigGapNotice(missing: ModelConfigGap, lang?: UiLanguage): ModelConfigGapNotice;
+export {};

package/dist/modelConfigGapNotice.js

@@ -0,0 +1,102 @@
+import { msg, renderMessage } from './i18n/translate.js';
+import { guardedRead, ownDataField } from './ownKey.js';
+function partOrder() {
+    return ['model', 'gateway-url', 'api-key'];
+}
+function isPart(v) {
+    return v === 'model' || v === 'gateway-url' || v === 'api-key';
+}
+const MALFORMED = Object.freeze({ kind: 'malformed' });
+const NONE = Object.freeze({ kind: 'none' });
+function readGap(missing) {
+    try {
+        if (missing === null || typeof missing !== 'object' || Array.isArray(missing))
+            return undefined;
+        const raw = ownDataField(missing, 'parts');
+        if (!Array.isArray(raw))
+            return undefined;
+        const order = partOrder();
+        const length = ownDataField(raw, 'length');
+        if (typeof length !== 'number' || !Number.isSafeInteger(length) || length < 0 || length > order.length)
+            return undefined;
+        const present = new Set();
+        for (let i = 0; i < length; i++) {
+            const word = ownDataField(raw, String(i));
+            if (!isPart(word) || present.has(word))
+                return undefined;
+            present.add(word);
+        }
+        const parts = order.filter((p) => present.has(p));
+        const channel = guardedRead(() => ownDataField(missing, 'keyChannel'));
+        const count = guardedRead(() => ownDataField(missing, 'catalogEntries'));
+        return {
+            parts,
+            anthropicKey: channel === 'anthropic' && present.has('api-key'),
+            entries: typeof count === 'number' && Number.isSafeInteger(count) && count >= 1 ? count : undefined,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+const HEAD_KEYS = Object.freeze({
+    model: 'model.configGap.head.model',
+    gatewayUrl: 'model.configGap.head.gatewayUrl',
+    apiKey: 'model.configGap.head.apiKey',
+    anthropicKey: 'model.configGap.head.anthropicKey',
+    incomplete: 'model.configGap.head.incomplete',
+});
+function headKeyOf(r) {
+    if (r.parts.includes('model'))
+        return HEAD_KEYS.model;
+    if (r.parts.includes('gateway-url'))
+        return r.parts.includes('api-key') ? HEAD_KEYS.incomplete : HEAD_KEYS.gatewayUrl;
+    return r.anthropicKey ? HEAD_KEYS.anthropicKey : HEAD_KEYS.apiKey;
+}
+function itemRef(part, anthropicKey) {
+    switch (part) {
+        case 'model':
+            return msg('model.configGap.item.model');
+        case 'gateway-url':
+            return msg('model.configGap.item.gatewayUrl');
+        case 'api-key':
+            return msg(anthropicKey ? 'model.configGap.item.anthropicKey' : 'model.configGap.item.apiKey');
+    }
+}
+function leadRef(first, second, third, anthropicKey) {
+    const a = itemRef(first, anthropicKey);
+    if (second === undefined)
+        return msg('model.configGap.lead.one', { a });
+    const b = itemRef(second, anthropicKey);
+    if (third === undefined)
+        return msg('model.configGap.lead.two', { a, b });
+    return msg('model.configGap.lead.three', { a, b, c: itemRef(third, anthropicKey) });
+}
+function reasonRef(r) {
+    if (r.parts.includes('model'))
+        return msg('model.configGap.reason.noModel');
+    const n = r.entries;
+    if (n === undefined)
+        return undefined;
+    if (r.anthropicKey)
+        return n === 1 ? msg('model.configGap.reason.anthropicCatalog.one') : msg('model.configGap.reason.anthropicCatalog.other', { count: n });
+    if (r.parts.includes('gateway-url'))
+        return n === 1 ? msg('model.configGap.reason.gatewayCatalog.one') : msg('model.configGap.reason.gatewayCatalog.other', { count: n });
+    return undefined;
+}
+export function modelConfigGapNotice(missing, lang) {
+    const r = readGap(missing);
+    if (r === undefined)
+        return MALFORMED;
+    const [first, second, third] = r.parts;
+    if (first === undefined)
+        return NONE;
+    const lead = leadRef(first, second, third, r.anthropicKey);
+    const reason = reasonRef(r);
+    const detail = reason === undefined ? lead : msg('model.configGap.detail.withReason', { missing: lead, reason });
+    return Object.freeze({
+        kind: 'gap',
+        head: renderMessage(msg(headKeyOf(r)), lang),
+        detail: renderMessage(detail, lang),
+    });
+}

package/dist/modsKernelIdentity.js

@@ -1,4 +1,5 @@
 import { KERNEL_CONTRACT_VERSION, MOD_EVENT_TABLE } from '@sema-agent/mods-kernel';
+import { sha256BytesHex } from './sha256Bytes.js';
 const MAX_DEPTH = 16;
 const MAX_NODES = 100_000;
 function canonical(v, depth, budget) {
@@ -35,52 +36,6 @@ function canonical(v, depth, budget) {
     }
     throw new TypeError('modsKernelIdentity: the event table holds a value that is not plain data');
 }
-function sha256Hex(msg) {
-    const k = [
-        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
-    ];
-    const h = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
-    const len = msg.length;
-    const padded = new Uint8Array(((len + 8) >>> 6) * 64 + 64);
-    padded.set(msg);
-    padded[len] = 0x80;
-    const view = new DataView(padded.buffer);
-    view.setUint32(padded.length - 8, Math.floor(len / 0x20000000));
-    view.setUint32(padded.length - 4, (len << 3) >>> 0);
-    const w = new Array(64).fill(0);
-    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
-    for (let off = 0; off < padded.length; off += 64) {
-        for (let t = 0; t < 16; t++)
-            w[t] = view.getUint32(off + t * 4);
-        for (let t = 16; t < 64; t++) {
-            const x = w[t - 15] ?? 0;
-            const y = w[t - 2] ?? 0;
-            const s0 = rotr(x, 7) ^ rotr(x, 18) ^ (x >>> 3);
-            const s1 = rotr(y, 17) ^ rotr(y, 19) ^ (y >>> 10);
-            w[t] = ((w[t - 16] ?? 0) + s0 + (w[t - 7] ?? 0) + s1) | 0;
-        }
-        let [a, b, c, d, e, f, g, hh] = h;
-        for (let t = 0; t < 64; t++) {
-            const t1 = (hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + (k[t] ?? 0) + (w[t] ?? 0)) | 0;
-            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) | 0;
-            hh = g;
-            g = f;
-            f = e;
-            e = (d + t1) | 0;
-            d = c;
-            c = b;
-            b = a;
-            a = (t1 + t2) | 0;
-        }
-        const next = [a, b, c, d, e, f, g, hh];
-        for (let i = 0; i < 8; i++)
-            h[i] = ((h[i] ?? 0) + (next[i] ?? 0)) | 0;
-    }
-    return h.map((x) => (x >>> 0).toString(16).padStart(8, '0')).join('');
-}
 export function modsKernelIdentity(kernel = { KERNEL_CONTRACT_VERSION, MOD_EVENT_TABLE }) {
     try {
         if (typeof kernel !== 'object' || kernel === null)
@@ -93,7 +48,7 @@ export function modsKernelIdentity(kernel = { KERNEL_CONTRACT_VERSION, MOD_EVENT
         if (typeof table !== 'object' || table === null || Array.isArray(table)) {
             throw new TypeError('modsKernelIdentity: the source carries no readable event table');
         }
-        return { contractVersion, tableDigest: sha256Hex(new TextEncoder().encode(canonical(table, 0, { nodes: 0 }))) };
+        return { contractVersion, tableDigest: sha256BytesHex(new TextEncoder().encode(canonical(table, 0, { nodes: 0 }))) };
     }
     catch (e) {
         if (e instanceof TypeError)

package/dist/notifications.d.ts

@@ -1,4 +1,5 @@
 import type { PlanReviewOutcomeMeta } from './hitl/planReviewWire.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 import type { SubmissionKind } from './request/submissionIdentity.js';
 export interface TaskNotificationFields {
     taskId: string;
@@ -87,6 +88,19 @@ export declare function installNotificationQueuePort(port: NotificationQueuePort
 export declare function notificationQueuePortMisses(): number;
 export declare function _resetNotificationQueuePortForTest(): void;
 export declare function enqueuePlanReviewOutcome(value: string, meta?: PlanReviewOutcomeMeta): boolean;
+export type ResupplyTruncatedSource = 'task_notification' | 'workflow_complete';
+export declare function resupplyTruncatedSentence(facts: {
+    readonly bytes: number;
+    readonly droppedKeys: readonly string[];
+} | null | undefined, lang?: UiLanguage): string | undefined;
+export interface ResupplyTruncatedArmBody {
+    readonly source: ResupplyTruncatedSource;
+    readonly taskId: string;
+    readonly bytes: number;
+    readonly droppedKeys: readonly string[];
+    readonly text: string;
+}
+export declare function resupplyTruncatedArmBody(carrier: object | null | undefined, source: ResupplyTruncatedSource, taskId: string): ResupplyTruncatedArmBody | undefined;
 export declare function dropQueuedNotificationsForRun(taskId: string): number;
 export declare function markEngineWorkflowNotified(runId: string): void;
 export declare function isEngineWorkflowNotified(runId: string): boolean;
@@ -104,6 +118,7 @@ export type WorkflowRunTerminalReading = {
     readonly result?: string;
     readonly error?: string;
     readonly pointer: 'absent';
+    readonly truncated?: true;
 } | {
     readonly state: 'unknown';
     readonly why: 'body_unreadable' | 'status_unreadable' | 'status_unrecognized';
@@ -140,6 +155,7 @@ export interface EngineWorkflowCompletion {
     status: 'completed' | 'failed';
     summary: string;
     completionId?: string;
+    diagnostics?: string;
 }
 export declare function enqueueBgChildNotification(raw: {
     taskId: string;
@@ -149,6 +165,9 @@ export declare function enqueueBgChildNotification(raw: {
     completionId?: string;
 }): void;
 export declare function enqueueEngineWorkflowNotification(raw: EngineWorkflowCompletion): void;
+export declare function workflowRecordRefOf(diagnostics: string | undefined): string | undefined;
+export declare function takeWorkflowPointerSupplement(runId: string, status: string, diagnostics: string | undefined, completionId?: string): Readonly<TaskNotificationFields> | undefined;
+export declare function settleWorkflowPointerOwed(runId: string): void;
 export declare function _resetEngineTaskNotificationForTest(): void;
 export declare function _tickWatchOnceForTest(nowMs?: number): Promise<void>;
 export declare function _setWatcherTimingForTest(o: {

package/dist/notifications.js

@@ -5,8 +5,9 @@ import { panelEndFact } from './panelReduce.js';
 import { isCoreTaskNotificationTerminal, isCoreTaskNotificationTerminalNotSuccess, isCoreWorkflowRunParkedEnd, isCoreWorkflowRunTerminal } from './terminalStatuses.js';
 import { cycleSeqValue } from './cycleOrder.js';
 import { CORE_ENGINE_AUTHORITY_ENVELOPE_TAGS } from './generated/engineFactTables.js';
-import { guardedRead, ownSnapshot, ownSnapshotRecord, ownSnapshotTyped, readOwnDataValue, workflowCompletionExtrasOf } from './ownKey.js';
-import { displayUntrusted } from './displayUntrusted.js';
+import { guardedRead, ownSnapshot, ownSnapshotRecord, ownSnapshotTyped, readOwnDataNonEmptyString, readOwnDataValue, resupplyTruncatedFactsOf, resupplyTruncatedOf, workflowCompletionExtrasOf } from './ownKey.js';
+import { msg, renderMessage } from './i18n/translate.js';
+import { displayUntrustedCapped } from './displayUntrusted.js';
 function escapeXml(v) {
     return v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
@@ -213,6 +214,7 @@ export function normalizeTaskNotification(raw) {
         ? n.lines.filter((l) => typeof l === 'string')
         : [];
     const recentSteps = deriveNotificationResidualLines(n);
+    const failureReason = failureReasonOf(status, n.error);
     return {
         taskId,
         status,
@@ -230,6 +232,7 @@ export function normalizeTaskNotification(raw) {
             ? { diagnostics: n.diagnostics }
             : {}),
         ...(typeof n.result === 'string' && n.result.length > 0 ? { result: n.result } : {}),
+        ...(failureReason !== undefined ? { error: failureReason } : {}),
         ...(typeof n.stoppedBy === 'string' && n.stoppedBy.length > 0 ? { stoppedBy: n.stoppedBy } : {}),
         ...(n.partial === true ? { partial: true } : {}),
         ...(typeof n.exitCode === 'number' ? { exitCode: n.exitCode } : {}),
@@ -422,6 +425,7 @@ export function enqueuePlanReviewOutcome(value, meta) {
         queuePortMisses++;
         return false;
     }
+    const questionId = meta === undefined ? undefined : guardedRead(() => readOwnDataNonEmptyString(meta, 'questionId'));
     p.enqueueMetaPrompt({
         value,
         mode: 'prompt',
@@ -436,12 +440,34 @@ export function enqueuePlanReviewOutcome(value, meta) {
                     decision: meta.decision,
                     effect: meta.effect,
                     ...(meta.effect === 'still_parked' && meta.cause === 'stored_form_unsupported' ? { cause: meta.cause } : {}),
+                    ...(questionId !== undefined ? { questionId } : {}),
                 }),
             }
             : {}),
     });
     return true;
 }
+export function resupplyTruncatedSentence(facts, lang) {
+    try {
+        const f = resupplyTruncatedFactsOf(facts);
+        if (f === undefined)
+            return undefined;
+        const count = f.droppedKeys.length;
+        return renderMessage(msg(count === 1 ? 'notice.resupply.truncated.one' : 'notice.resupply.truncated.other', count === 1 ? { bytes: f.bytes } : { bytes: f.bytes, count }), lang);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resupplyTruncatedArmBody(carrier, source, taskId) {
+    const facts = resupplyTruncatedOf(carrier);
+    if (facts === undefined)
+        return undefined;
+    const text = resupplyTruncatedSentence(facts);
+    if (text === undefined)
+        return undefined;
+    return { source, taskId, bytes: facts.bytes, droppedKeys: facts.droppedKeys, text };
+}
 export function dropQueuedNotificationsForRun(taskId) {
     const needle = `<${TASK_ID_TAG}>${escapeXml(taskId)}</${TASK_ID_TAG}>`;
     const p = port();
@@ -494,20 +520,25 @@ export function workflowRunTerminalReadingOf(body) {
     if (isCoreWorkflowRunParkedEnd(status, guardedRead(() => readOwnDataValue(snap, 'errorCode'))))
         return Object.freeze({ state: 'awaiting approval' });
     const result = guardedRead(() => readOwnDataValue(snap, 'result'));
-    const error = status === 'failed' ? guardedRead(() => readOwnDataValue(snap, 'error')) : undefined;
-    const shownError = typeof error === 'string' && error.length > 0 ? shownRunError(error) : '';
+    const shownError = failureReasonOf(status, guardedRead(() => readOwnDataValue(snap, 'error')));
+    const resultFull = guardedRead(() => readOwnDataValue(snap, 'resultFull'));
     return Object.freeze({
         state: status,
         ...(typeof result === 'string' && result.length > 0 ? { result } : {}),
-        ...(shownError.length > 0 ? { error: shownError } : {}),
+        ...(shownError !== undefined ? { error: shownError } : {}),
         pointer: 'absent',
+        ...(typeof resultFull === 'string' && resultFull.length > 0 ? { truncated: true } : {}),
     });
 }
 const WORKFLOW_RUN_ERROR_MAX = 200;
 function shownRunError(raw) {
-    const opts = { foldLines: false, escapeBackslashes: 'auto' };
-    const whole = displayUntrusted(raw, opts);
-    return whole.length <= WORKFLOW_RUN_ERROR_MAX ? whole : `${displayUntrusted(raw, { ...opts, max: WORKFLOW_RUN_ERROR_MAX - 1 })}…`;
+    return displayUntrustedCapped(raw, WORKFLOW_RUN_ERROR_MAX, { foldLines: false, escapeBackslashes: 'auto' });
+}
+function failureReasonOf(status, raw) {
+    if (status !== 'failed' || typeof raw !== 'string' || raw.length === 0)
+        return undefined;
+    const shown = shownRunError(raw);
+    return shown.length > 0 ? shown : undefined;
 }
 function workflowPollDecisionOf(delivered, reading) {
     if (delivered)
@@ -518,7 +549,13 @@ function workflowPollDecisionOf(delivered, reading) {
         return { act: 'wait', why: 'awaiting approval' };
     if (reading.state === 'unknown')
         return { act: 'wait', why: 'unknown' };
-    return { act: 'emit', status: reading.state, ...(reading.result !== undefined ? { result: reading.result } : {}), ...(reading.error !== undefined ? { error: reading.error } : {}) };
+    return {
+        act: 'emit',
+        status: reading.state,
+        ...(reading.result !== undefined ? { result: reading.result } : {}),
+        ...(reading.error !== undefined ? { error: reading.error } : {}),
+        ...(reading.truncated === true ? { truncated: true } : {}),
+    };
 }
 function workflowPollCompletionSummary(status, error) {
     const head = `workflow ${status} (read from its run record; no handle to the full record is available)`;
@@ -826,7 +863,7 @@ async function tickWatchInner(now) {
             if (outstandingRuns.delete(runId))
                 notifyOutstanding();
             if (decision.act === 'emit') {
-                enqueueWorkflowCompletion({ runId, status: decision.status, summary: workflowPollCompletionSummary(decision.status, decision.error) }, { ...(decision.result !== undefined ? { result: decision.result } : {}), ...(decision.error !== undefined ? { error: decision.error } : {}) });
+                enqueueWorkflowCompletion({ runId, status: decision.status, summary: workflowPollCompletionSummary(decision.status, decision.error) }, { ...(decision.result !== undefined ? { result: decision.result } : {}), ...(decision.error !== undefined ? { error: decision.error } : {}) }, { truncated: decision.truncated === true });
             }
         }
         catch {
@@ -890,9 +927,17 @@ export function enqueueEngineWorkflowNotification(raw) {
         traceNotif('workflow-notification dropped:payload-unreadable');
         return;
     }
-    enqueueWorkflowCompletion(c, completionIdOnly(workflowCompletionExtrasOf(c)));
+    const extras = workflowCompletionExtrasOf(c);
+    if (notifiedRunIds.has(c.runId)) {
+        const supplement = takeWorkflowPointerSupplement(c.runId, c.status, extras.diagnostics, extras.completionId);
+        if (supplement !== undefined) {
+            port()?.enqueuePendingNotification(taskNotificationQueueCommand(supplement));
+            return;
+        }
+    }
+    enqueueWorkflowCompletion(c, completionIdOnly(extras));
 }
-function enqueueWorkflowCompletion(c, body) {
+function enqueueWorkflowCompletion(c, body, poll) {
     if (notifiedRunIds.has(c.runId)) {
         workflowDedupDropped++;
         traceNotif(`workflow notification suppressed (run already notified) runId=${c.runId} status=${c.status}`);
@@ -900,11 +945,68 @@ function enqueueWorkflowCompletion(c, body) {
     }
     markRunNotified(c.runId);
     cardEnqueuedRunIds.add(c.runId);
+    if (poll !== undefined)
+        notePointerOwed(c.runId, poll.truncated);
     port()?.enqueuePendingNotification(taskNotificationQueueCommand({ taskId: c.runId, taskType: 'workflow', status: c.status, summary: c.summary, ...body }));
 }
+const pointerOwedRuns = new Map();
+const POINTER_OWED_MAX = 512;
+function notePointerOwed(runId, truncated) {
+    pointerOwedRuns.delete(runId);
+    pointerOwedRuns.set(runId, { truncated });
+    while (pointerOwedRuns.size > POINTER_OWED_MAX) {
+        const oldest = pointerOwedRuns.keys().next();
+        if (oldest.done === true)
+            break;
+        pointerOwedRuns.delete(oldest.value);
+    }
+}
+const WORKFLOW_RECORD_REF_SENTENCE = /Full record \(the result and every agent's row\): read it with ReadToolResult \(ref "([A-Za-z0-9_.~-]{1,518})"\) before assuming an empty or unexpected result\./g;
+export function workflowRecordRefOf(diagnostics) {
+    if (typeof diagnostics !== 'string' || diagnostics.length === 0)
+        return undefined;
+    try {
+        let ref;
+        for (const m of diagnostics.matchAll(WORKFLOW_RECORD_REF_SENTENCE))
+            ref = m[1];
+        return ref;
+    }
+    catch {
+        return undefined;
+    }
+}
+function workflowPointerSupplementSummary(ref, truncated) {
+    const head = `Full record of this workflow run (the result and every agent's row): read it with ReadToolResult (ref "${ref}")`;
+    return truncated ? `${head} — the result delivered earlier was cut short; the full text is in this record.` : `${head}.`;
+}
+export function takeWorkflowPointerSupplement(runId, status, diagnostics, completionId) {
+    try {
+        const owed = pointerOwedRuns.get(runId);
+        if (owed === undefined)
+            return undefined;
+        const ref = workflowRecordRefOf(diagnostics);
+        if (ref === undefined)
+            return undefined;
+        pointerOwedRuns.delete(runId);
+        return freezeTaskNotificationFields({
+            taskId: runId,
+            taskType: 'workflow',
+            status,
+            summary: workflowPointerSupplementSummary(ref, owed.truncated),
+            ...(completionId !== undefined ? { completionId } : {}),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function settleWorkflowPointerOwed(runId) {
+    pointerOwedRuns.delete(runId);
+}
 export function _resetEngineTaskNotificationForTest() {
     notifiedRunIds.clear();
     notifiedBgCycleHigh.clear();
+    pointerOwedRuns.clear();
     cardEnqueuedRunIds.clear();
     outstandingRuns.clear();
     outstandingBgTasks.clear();

package/dist/ownKey.d.ts

@@ -75,7 +75,14 @@ export interface SampledRecord {
 export declare function ownSnapshotWhenTyped<V>(value: V, word: string): SampledJson;
 export declare function ownSnapshotTyped<T extends object>(value: T): T | undefined;
 export declare function ownSnapshotRecord<V>(value: V): SampledRecord | undefined;
+export declare function ownSnapshotRecordFaithful<V>(value: V): SampledRecord | undefined;
 export declare function workflowCompletionExtrasOf(c: object): {
     completionId?: string;
     diagnostics?: string;
 };
+export interface ResupplyTruncatedFacts {
+    readonly bytes: number;
+    readonly droppedKeys: readonly string[];
+}
+export declare function resupplyTruncatedFactsOf(slot: {} | null | undefined): ResupplyTruncatedFacts | undefined;
+export declare function resupplyTruncatedOf(carrier: object | null | undefined): ResupplyTruncatedFacts | undefined;

package/dist/ownKey.js

@@ -291,6 +291,7 @@ export function promptManifestIdentityOf(raw) {
     }
 }
 const SAMPLED = new WeakSet();
+const LOSSY = new WeakSet();
 const SAMPLE_MAX_DEPTH = 256;
 export function isOwnSnapshot(v) {
     return isBranded(v);
@@ -311,7 +312,7 @@ function snapshotOf(value) {
     if (typeof value === 'object' && value !== null) {
         if (SAMPLED.has(value))
             return value;
-        return sampleObject(value, 0, { done: new Map(), path: new Set(), seen: new Set(), rework: 0, depthCuts: 0 });
+        return sampleObject(value, 0, { done: new Map(), path: new Set(), seen: new Set(), rework: 0, depthCuts: 0, lost: 0 });
     }
     return samplePrimitive(value);
 }
@@ -342,6 +343,10 @@ export function ownSnapshotTyped(value) {
 export function ownSnapshotRecord(value) {
     return recordOf(value);
 }
+export function ownSnapshotRecordFaithful(value) {
+    const s = recordOf(value);
+    return s === undefined || LOSSY.has(s) ? undefined : s;
+}
 function recordOf(value) {
     const s = snapshotOf(value);
     return typeof s === 'object' && s !== null && !Array.isArray(s) ? s : undefined;
@@ -357,19 +362,29 @@ function sampleValue(v, depth, run) {
 }
 function sampleObject(src, depth, run) {
     const hit = run.done.get(src);
-    if (hit !== undefined)
+    if (hit !== undefined) {
+        if (hit === null || LOSSY.has(hit))
+            run.lost++;
         return hit ?? undefined;
-    if (SAMPLED.has(src))
+    }
+    if (SAMPLED.has(src)) {
+        if (LOSSY.has(src))
+            run.lost++;
         return src;
-    if (run.path.has(src))
+    }
+    if (run.path.has(src)) {
+        run.lost++;
         return undefined;
+    }
     if (depth >= SAMPLE_MAX_DEPTH) {
         run.depthCuts++;
+        run.lost++;
         return undefined;
     }
     if (run.seen.has(src)) {
         if (++run.rework > SAMPLE_MAX_REWORK) {
             run.depthCuts++;
+            run.lost++;
             return undefined;
         }
     }
@@ -384,10 +399,12 @@ function sampleObject(src, depth, run) {
     }
     catch {
         run.done.set(src, null);
+        run.lost++;
         return undefined;
     }
     run.path.add(src);
     const cutsBefore = run.depthCuts;
+    const lostBefore = run.lost;
     try {
         const rec = {};
         const arr = [];
@@ -409,18 +426,29 @@ function sampleObject(src, depth, run) {
             const index = isArray ? arrayIndexOfKey(k) : undefined;
             if (isArray && index === undefined)
                 continue;
-            if (index !== undefined && index >= SAMPLE_MAX_INDEX)
+            if (index !== undefined && index >= SAMPLE_MAX_INDEX) {
+                run.lost++;
                 continue;
+            }
             if (index !== undefined && index + 1 > tail)
                 tail = index + 1;
             const d = guardedRead(() => Object.getOwnPropertyDescriptor(src, k));
-            if (d === undefined)
+            if (d === undefined) {
+                run.lost++;
                 continue;
-            if (d.enumerable !== true || !Object.hasOwn(d, 'value'))
+            }
+            if (d.enumerable !== true)
                 continue;
+            if (!Object.hasOwn(d, 'value')) {
+                run.lost++;
+                continue;
+            }
             const child = sampleValue(d.value, depth + 1, run);
-            if (child === undefined)
+            if (child === undefined) {
+                if (typeof d.value === 'bigint')
+                    run.lost++;
                 continue;
+            }
             if (index !== undefined) {
                 Object.defineProperty(arr, index, { value: child, writable: true, enumerable: true, configurable: true });
                 if (index + 1 > good)
@@ -431,12 +459,16 @@ function sampleObject(src, depth, run) {
         }
         if (isArray) {
             const want = Math.max(good, Math.min(Math.max(tail, declared), good + SAMPLE_MAX_TRAILING_HOLES));
+            if (Math.max(tail, declared) > want)
+                run.lost++;
             if (arr.length < want)
                 arr.length = want;
         }
         const out = isArray ? arr : rec;
         Object.freeze(out);
         SAMPLED.add(out);
+        if (run.lost !== lostBefore)
+            LOSSY.add(out);
         if (run.depthCuts === cutsBefore)
             run.done.set(src, out);
         return out;
@@ -453,3 +485,34 @@ export function workflowCompletionExtrasOf(c) {
         ...(diagnostics !== undefined ? { diagnostics } : {}),
     };
 }
+const DROPPED_KEYS_MAX = 256;
+const DROPPED_KEY_NAME_MAX = 128;
+export function resupplyTruncatedFactsOf(slot) {
+    try {
+        if (typeof slot !== 'object' || slot === null || Array.isArray(slot))
+            return undefined;
+        const bytes = guardedRead(() => readOwnDataValue(slot, 'bytes'));
+        if (typeof bytes !== 'number' || !Number.isSafeInteger(bytes) || bytes <= 0)
+            return undefined;
+        const keys = guardedRead(() => readOwnDataValue(slot, 'droppedKeys'));
+        if (!Array.isArray(keys))
+            return undefined;
+        const length = guardedRead(() => keys.length);
+        if (typeof length !== 'number' || length < 1 || length > DROPPED_KEYS_MAX)
+            return undefined;
+        const names = [];
+        for (let i = 0; i < length; i++) {
+            const name = guardedRead(() => readOwnDataValue(keys, String(i)));
+            if (typeof name !== 'string' || name.length === 0 || name.length > DROPPED_KEY_NAME_MAX)
+                return undefined;
+            appendOwnElement(names, name);
+        }
+        return Object.freeze({ bytes, droppedKeys: Object.freeze(names) });
+    }
+    catch {
+        return undefined;
+    }
+}
+export function resupplyTruncatedOf(carrier) {
+    return resupplyTruncatedFactsOf(guardedRead(() => readOwnDataValue(carrier, 'payloadTruncated')));
+}

package/dist/pendingUserRow.d.ts

@@ -0,0 +1,4 @@
+export declare const PENDING_USER_ROW_ID_PREFIX = "pending-";
+export declare function pendingUserRowIdOf(uuid: string): string | undefined;
+export declare function pendingUserRowUuidOf(id: string | null | undefined): string | undefined;
+export declare function isPendingUserRowId(id: string | null | undefined): boolean;

package/dist/pendingUserRow.js

@@ -0,0 +1,16 @@
+export const PENDING_USER_ROW_ID_PREFIX = 'pending-';
+const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export function pendingUserRowIdOf(uuid) {
+    if (typeof uuid !== 'string' || !UUID_V4.test(uuid))
+        return undefined;
+    return PENDING_USER_ROW_ID_PREFIX + uuid;
+}
+export function pendingUserRowUuidOf(id) {
+    if (typeof id !== 'string' || !id.startsWith(PENDING_USER_ROW_ID_PREFIX))
+        return undefined;
+    const uuid = id.slice(PENDING_USER_ROW_ID_PREFIX.length);
+    return pendingUserRowIdOf(uuid) === id ? uuid : undefined;
+}
+export function isPendingUserRowId(id) {
+    return pendingUserRowUuidOf(id) !== undefined;
+}

package/dist/permissionsDeclaration.d.ts

@@ -1,5 +1,6 @@
 import { type CoreValuePortName } from './coreValuePorts.js';
 import { type PermissionsAllowGrantReading } from './permissionsAllowGrantCapability.js';
+import type { UiLanguage } from './env/uiLanguage.js';
 declare const SETTINGS_SOURCE_TIERS: Readonly<{
     readonly policySettings: "managed";
     readonly flagSettings: "global";
@@ -115,7 +116,8 @@ export declare function assembledRuleRows(input: PermissionsDeclarationInput, ca
 export interface PermissionsAllowKeptFacts {
     readonly problemCount?: number;
     readonly managedPolicyPending?: true;
+    readonly managedPolicyFetch?: 'in_progress' | 'failed' | 'unknown';
     readonly where?: string;
 }
-export declare function permissionsAllowKeptNotice(report: Pick<PermissionsDeclarationReport, 'kept'>, settingsRead: 'clean' | 'partial' | 'unreadable', facts?: PermissionsAllowKeptFacts): string | undefined;
+export declare function permissionsAllowKeptNotice(report: Pick<PermissionsDeclarationReport, 'kept'>, settingsRead: 'clean' | 'partial' | 'unreadable', facts?: PermissionsAllowKeptFacts, lang?: UiLanguage): string | undefined;
 export {};