@code-yeongyu/senpi 2026.11.6-3 → 2026.11.9

package/dist/core/egress/ledger.js

@@ -0,0 +1,159 @@
+import { callKey, cancelledKey, decodeCallRow, decodeVariant, encodeCallRow, encodeVariant, isStoredMessage, requestChunkKey, resultChunkKey, splitUtf8, stepIndexKey, stepIndexPrefix, variantKey, variantPrefix, } from "./ledger-schema.js";
+const putRow = (row) => ({ op: "put", key: callKey(row.callId), data: encodeCallRow(row) });
+const deletes = (count, key) => Array.from({ length: count }, (_, index) => ({ op: "delete", key: key(index) }));
+/** Every stored chunk of `row`: its request and, once `ended` with a message, the assembled message. */
+const chunkDeletes = (row) => [
+    ...deletes(row.requestChunks, (index) => requestChunkKey(row.callId, index)),
+    ...deletes(row.result?.kind === "message" ? row.result.chunks : 0, (index) => resultChunkKey(row.callId, index)),
+];
+/** A cancelled row keeps its identity and an error result, never pointers to chunks W14 deleted. */
+function cancelledRow(row) {
+    const { result, ...fields } = row;
+    return { ...fields, state: "cancelled", requestChunks: 0, ...(result?.kind === "error" ? { result } : {}) };
+}
+/**
+ * W14 on the step's live row. A dispatched or ended row becomes `cancelled`; a superseded row (the abort came while its
+ * reissue waited: the pacer backoff or the user's choice) stays superseded. Either way its chunks are deleted, because a
+ * cancelled step is never dialed again, so no later W4 retires them.
+ */
+function cancelWrites(row) {
+    if (row.state === "closed" || row.state === "cancelled")
+        return [];
+    const kept = row.state === "superseded" ? { ...row, requestChunks: 0 } : cancelledRow(row);
+    return [putRow(kept), ...chunkDeletes(row)];
+}
+/** The W9 part the ledger owns: the step's row becomes `closed` and its request chunks are deleted (4.5 retention). */
+export function closeCallWrites(row) {
+    return [putRow({ ...row, state: "closed" }), ...chunkDeletes(row)];
+}
+export function createEgressLedger(options) {
+    const { store, mutate } = options;
+    const withRequest = (row, requestJson) => {
+        const chunks = splitUtf8(requestJson);
+        const next = { ...row, requestChunks: chunks.length };
+        const writes = chunks.map((data, index) => ({
+            op: "put",
+            key: requestChunkKey(row.callId, index),
+            data,
+        }));
+        return { row: next, writes: [...writes, putRow(next)] };
+    };
+    const variantWrite = async (variant) => {
+        const key = variantKey(variant.providerId, variant.deviceId);
+        const prior = decodeVariant(await store.getDocument(key));
+        const sameRun = prior !== undefined && prior.headDigest === variant.headDigest && prior.stepId === variant.stepId;
+        const mismatches = sameRun ? prior.mismatches + 1 : 1;
+        const { headDigest, liveAtMismatch, stepId } = variant;
+        return { op: "put", key, data: encodeVariant({ headDigest, liveAtMismatch, mismatches, stepId }) };
+    };
+    const stepOf = (row) => {
+        if (row.call.kind !== "step")
+            throw new Error("the device-route ledger indexes loop steps only");
+        return row.call;
+    };
+    const readRow = async (callId) => decodeCallRow(await store.getDocument(callKey(callId)));
+    const readChunks = async (row, what, count, key) => {
+        const chunks = await Promise.all(Array.from({ length: count }, (_, index) => store.getDocument(key(index))));
+        if (!chunks.every((chunk) => typeof chunk === "string"))
+            throw new Error(`egress_call ${row.callId}: stored ${what} is incomplete`);
+        return chunks.join("");
+    };
+    return {
+        async rowsForStep(stepId) {
+            const index = await store.scanDocuments(stepIndexPrefix(stepId));
+            const rows = await Promise.all(index.map((entry) => (typeof entry.data === "string" ? readRow(entry.data) : undefined)));
+            return rows.filter((row) => row !== undefined);
+        },
+        readRequest: (row) => readChunks(row, "request", row.requestChunks, (index) => requestChunkKey(row.callId, index)),
+        async readMessage(row) {
+            if (row.result?.kind !== "message")
+                throw new Error(`egress_call ${row.callId} has no stored message`);
+            const key = (index) => resultChunkKey(row.callId, index);
+            const parsed = JSON.parse(await readChunks(row, "message", row.result.chunks, key));
+            if (!isStoredMessage(parsed))
+                throw new Error(`egress_call ${row.callId}: stored message is malformed`);
+            return parsed;
+        },
+        async dispatch(next, requestJson, previous) {
+            const { stepId, attempt } = stepOf(next);
+            const created = withRequest({ ...next, state: "dispatched", requestChunks: 0 }, requestJson);
+            const retire = previous
+                ? [
+                    putRow({ ...previous, state: previous.state === "ended" ? "closed" : previous.state }),
+                    ...chunkDeletes(previous),
+                ]
+                : [];
+            const index = { op: "put", key: stepIndexKey(stepId, attempt), data: next.callId };
+            await mutate(async () => [...retire, ...created.writes, index]);
+            return created.row;
+        },
+        async recordHooked(row, requestJson) {
+            const updated = withRequest({ ...row, hooksApplied: true }, requestJson);
+            await mutate(async () => [...chunkDeletes(row), ...updated.writes]);
+            return updated.row;
+        },
+        async end(row, result) {
+            if (result.kind === "error") {
+                const failed = { ...row, state: "ended", result };
+                await mutate(async () => [putRow(failed)]);
+                return failed;
+            }
+            const chunks = splitUtf8(JSON.stringify(result.message));
+            const { stopReason, usage } = result.message;
+            const ended = {
+                ...row,
+                state: "ended",
+                result: { kind: "message", stopReason, usage, chunks: chunks.length },
+            };
+            const writes = chunks.map((data, index) => ({
+                op: "put",
+                key: resultChunkKey(row.callId, index),
+                data,
+            }));
+            await mutate(async () => [...writes, putRow(ended)]);
+            return ended;
+        },
+        async replaceRefused(row, callId) {
+            const { stepId, attempt } = stepOf(row);
+            const requestJson = await readChunks(row, "request", row.requestChunks, (i) => requestChunkKey(row.callId, i));
+            const created = withRequest({ ...row, callId, state: "dispatched", requestChunks: 0 }, requestJson);
+            const index = { op: "put", key: stepIndexKey(stepId, attempt), data: callId };
+            const dropped = { op: "delete", key: callKey(row.callId) };
+            await mutate(async () => [dropped, ...chunkDeletes(row), ...created.writes, index]);
+            return created.row;
+        },
+        async supersede(row, variant) {
+            const superseded = { ...row, state: "superseded" };
+            await mutate(async () => [putRow(superseded), ...(variant ? [await variantWrite(variant)] : [])]);
+            return superseded;
+        },
+        async cancelStep(stepId, row) {
+            const live = row ? cancelWrites(row) : [];
+            await mutate(async () => [{ op: "put", key: cancelledKey(stepId), data: stepId }, ...live]);
+        },
+        async isCancelled(stepId) {
+            return (await store.getDocument(cancelledKey(stepId))) !== undefined;
+        },
+        async recordVariant(variant) {
+            await mutate(async () => [await variantWrite(variant)]);
+        },
+        async variants(providerId) {
+            const prefix = variantPrefix(providerId);
+            const entries = await store.scanDocuments(prefix);
+            const variants = new Map();
+            for (const entry of entries) {
+                const stored = decodeVariant(entry.data);
+                if (!stored)
+                    continue;
+                const { headDigest, liveAtMismatch, mismatches } = stored;
+                variants.set(decodeURIComponent(entry.key.slice(prefix.length)), {
+                    headDigest,
+                    liveAtMismatch,
+                    mismatches,
+                });
+            }
+            return variants;
+        },
+    };
+}
+//# sourceMappingURL=ledger.js.map

package/dist/core/egress/pinned-infra.d.ts

@@ -1,5 +1,5 @@
 import { type KeyFactsAnswer } from "./key-facts-client.ts";
-import { type CustodyRoleArns, type KeyPolicyTemplate } from "./key-policy-template.ts";
+import { type CustodyRoleArns, type KeyPolicyKind, type KeyPolicyTemplate } from "./key-policy-template.ts";
 import type { ServiceKeyEntry } from "./roster-entries.ts";
 import type { VerifierKeyPin } from "./signed-statement.ts";
 export type CustodyRole = keyof CustodyRoleArns;
@@ -14,7 +14,28 @@ export interface PinnedCustodyInfra {
     /** The verifier signing keys this release trusts (three consecutive generations once minted, 15.15 M-2). */
     readonly keyFactsVerifierKeys: readonly VerifierKeyPin[];
 }
-export declare const PINNED_CUSTODY_INFRA: PinnedCustodyInfra;
+export declare const PINNED_CUSTODY_INFRA: {
+    readonly custodyAccountIds: readonly [];
+    readonly arnNamespace: "arn:aws:kms:us-east-1:";
+    readonly roleNames: {
+        readonly runtime: readonly ["custody-runtime"];
+        readonly registrySigner: readonly ["registry-signer"];
+        readonly provisioning: readonly ["custody-provisioning"];
+        readonly reader: readonly ["key-facts-reader"];
+        readonly breakglass: readonly ["custody-breakglass"];
+    };
+    readonly templates: {
+        readonly 1: {
+            readonly render: ({ keyKind, roles }: {
+                readonly accountId: string;
+                readonly keyKind: KeyPolicyKind;
+                readonly roles: CustodyRoleArns;
+            }) => string;
+        };
+    };
+    readonly keyFactsEndpoint: undefined;
+    readonly keyFactsVerifierKeys: readonly [];
+};
 export type ServiceKeyCheckReason = "ok" | "template-unknown" | "facts-unknown" | "facts-stale" | "shape" | "arn" | "arn-namespace" | "account-not-pinned" | "key-usage" | "key-property" | "spki" | "principal-id" | "role-outside-pins" | "policy";
 export interface ServiceKeyCheck {
     readonly result: "ok" | "mismatch" | "unknown";

package/dist/core/egress/pinned-infra.js

@@ -29,7 +29,13 @@ const SERVICE_KEY_NOTICES = {
     "principal-id": "the custody key's access policy no longer matches; cloud custody for this key is unavailable",
 };
 const KMS_KEY_ARN = /^(arn:[a-z0-9-]+:kms:[a-z0-9-]+:)(\d{12}):key\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-const ROLE_ORDER = ["runtime", "registrySigner", "provisioning", "reader", "breakglass"];
+const ROLE_ORDER = [
+    "runtime",
+    "registrySigner",
+    "provisioning",
+    "reader",
+    "breakglass",
+];
 export function roleArn(accountId, roleName) {
     return `arn:aws:iam::${accountId}:role/${roleName}`;
 }
@@ -117,7 +123,8 @@ function isFresh(facts, now) {
     return now - facts.readAt <= MAX_FACTS_AGE_MS && facts.readAt - now <= MAX_FACTS_FUTURE_SKEW_MS;
 }
 function outcome(result, reason) {
-    const notice = SERVICE_KEY_NOTICES[reason];
+    const notices = SERVICE_KEY_NOTICES;
+    const notice = notices[reason];
     return notice === undefined ? { result, reason } : { result, reason, notice };
 }
 /** `facts` maps each of `entry.kmsKeyArns` to the verifier's answer for exactly that ARN. */

package/dist/core/egress/redact.d.ts

@@ -0,0 +1,10 @@
+export declare const REDACTED = "<redacted>";
+export interface RedactorOptions {
+    readonly secrets: readonly string[];
+    readonly publicPrefixes: readonly string[];
+}
+export interface Redactor {
+    redact(text: string): string;
+}
+export declare function createRedactor(options: RedactorOptions): Redactor;
+//# sourceMappingURL=redact.d.ts.map

package/dist/core/egress/redact.js

@@ -0,0 +1,134 @@
+export const REDACTED = "<redacted>";
+const MIN_FRAGMENT = 8;
+const NO_NODE = -1;
+function newNode() {
+    return { next: new Map(), fail: 0, pattern: undefined, dictionary: NO_NODE };
+}
+function dedupe(patterns) {
+    const byText = new Map();
+    for (const pattern of patterns) {
+        const seen = byText.get(pattern.text);
+        if (seen === undefined || (seen.wholeToken && !pattern.wholeToken))
+            byText.set(pattern.text, pattern);
+    }
+    return [...byText.values()];
+}
+function isTokenChar(char) {
+    return char !== undefined && /[A-Za-z0-9]/.test(char);
+}
+/**
+ * Base64 characters that depend only on the secret's bytes when the secret starts `offset` bytes into a longer
+ * stream: character i covers bits [6i, 6i + 6), and it is kept only when that range lies inside the secret's bits.
+ */
+function alignedBase64Core(secret, offset, alphabet) {
+    const encoded = Buffer.concat([Buffer.alloc(offset), secret])
+        .toString(alphabet)
+        .replace(/=+$/, "");
+    const firstBit = offset * 8;
+    const lastBit = firstBit + secret.length * 8;
+    let core = "";
+    for (let i = 0; i < encoded.length; i++) {
+        if (i * 6 >= firstBit && i * 6 + 6 <= lastBit)
+            core += encoded[i];
+    }
+    return core;
+}
+function patternsFor(secret, publicPrefixes) {
+    const bytes = Buffer.from(secret, "utf8");
+    const patterns = [{ text: secret, wholeToken: true }];
+    const urlEncoded = encodeURIComponent(secret);
+    if (urlEncoded !== secret)
+        patterns.push({ text: urlEncoded, wholeToken: true });
+    for (const alphabet of ["base64", "base64url"]) {
+        patterns.push({ text: bytes.toString(alphabet), wholeToken: true });
+        for (const offset of [0, 1, 2]) {
+            const core = alignedBase64Core(bytes, offset, alphabet);
+            if (core.length >= MIN_FRAGMENT)
+                patterns.push({ text: core, wholeToken: false });
+        }
+    }
+    for (let i = 0; i + MIN_FRAGMENT <= secret.length; i++) {
+        const gram = secret.slice(i, i + MIN_FRAGMENT);
+        if (!publicPrefixes.some((prefix) => prefix.includes(gram)))
+            patterns.push({ text: gram, wholeToken: false });
+    }
+    return patterns;
+}
+function buildAutomaton(patterns) {
+    const nodes = [newNode()];
+    patterns.forEach((pattern, index) => {
+        let state = 0;
+        for (const char of pattern.text) {
+            let target = nodes[state].next.get(char);
+            if (target === undefined) {
+                target = nodes.length;
+                nodes.push(newNode());
+                nodes[state].next.set(char, target);
+            }
+            state = target;
+        }
+        nodes[state].pattern = index;
+    });
+    const queue = [...nodes[0].next.values()];
+    for (let head = 0; head < queue.length; head++) {
+        const state = queue[head];
+        for (const [char, target] of nodes[state].next) {
+            let fallback = nodes[state].fail;
+            while (fallback !== 0 && !nodes[fallback].next.has(char))
+                fallback = nodes[fallback].fail;
+            const candidate = nodes[fallback].next.get(char);
+            nodes[target].fail = candidate !== undefined && candidate !== target ? candidate : 0;
+            const fail = nodes[nodes[target].fail];
+            nodes[target].dictionary = fail.pattern !== undefined ? nodes[target].fail : fail.dictionary;
+            queue.push(target);
+        }
+    }
+    return nodes;
+}
+export function createRedactor(options) {
+    const patterns = dedupe(options.secrets
+        .filter((secret) => secret.length > 0)
+        .flatMap((secret) => patternsFor(secret, options.publicPrefixes)));
+    if (patterns.length === 0)
+        return { redact: (text) => text };
+    const nodes = buildAutomaton(patterns);
+    const lengths = patterns.map((pattern) => [...pattern.text].length);
+    return {
+        redact(text) {
+            const chars = [...text];
+            const spans = [];
+            let state = 0;
+            for (let end = 0; end < chars.length; end++) {
+                const char = chars[end];
+                while (state !== 0 && !nodes[state].next.has(char))
+                    state = nodes[state].fail;
+                state = nodes[state].next.get(char) ?? 0;
+                for (let match = nodes[state].pattern !== undefined ? state : nodes[state].dictionary; match !== NO_NODE; match = nodes[match].dictionary) {
+                    const index = nodes[match].pattern;
+                    const start = end - lengths[index] + 1;
+                    if (patterns[index].wholeToken && (isTokenChar(chars[start - 1]) || isTokenChar(chars[end + 1])))
+                        continue;
+                    spans.push([start, end + 1]);
+                }
+            }
+            if (spans.length === 0)
+                return text;
+            spans.sort((a, b) => a[0] - b[0]);
+            let out = "";
+            let cursor = 0;
+            let current = spans[0];
+            for (const span of spans.slice(1)) {
+                if (span[0] <= current[1]) {
+                    current = [current[0], Math.max(current[1], span[1])];
+                    continue;
+                }
+                out += chars.slice(cursor, current[0]).join("") + REDACTED;
+                cursor = current[1];
+                current = span;
+            }
+            out += chars.slice(cursor, current[0]).join("") + REDACTED + chars.slice(current[1]).join("");
+            return out;
+        },
+    };
+}
+//# sourceMappingURL=redact.js.map

package/dist/core/egress/sealed-source.d.ts

@@ -0,0 +1,35 @@
+import { type CredentialSource, type EpochLeaseToken, type ReleaseScope, type SecretField, type SecretLease, type Unsealer } from "./credentials.ts";
+import type { HpkeWrap, ProviderId } from "./sealed-format.ts";
+export interface ReleasedItemPosition {
+    readonly accountId: string;
+    readonly providerId: ProviderId;
+    readonly entryDigest: string;
+    readonly field: SecretField;
+    /** The lease this release was made under: the opener rebuilds epoch and placementId from it (r11.2 C.5). */
+    readonly lease: EpochLeaseToken;
+}
+export interface SealedSourceDeps {
+    readonly accountId: string;
+    readonly unsealer: Unsealer;
+    readonly lease: () => Promise<EpochLeaseToken>;
+    readonly recipientPk: Uint8Array;
+    readonly reloadEntryDigest: (providerId: ProviderId) => Promise<string>;
+    readonly readHead: () => Promise<string>;
+    /** Rejects with the signal's reason once the step aborts. */
+    readonly sleep: (ms: number, signal: AbortSignal) => Promise<void>;
+    /** The abort signal of the step this release serves; it bounds the churn wait (custody design L844, C.3). */
+    readonly stepSignal: (scope: ReleaseScope) => AbortSignal;
+    /** Called once per step when the step enters the config-churn wait (C.3), so the caller can show one notice. */
+    readonly onChurnNotice: (scope: ReleaseScope) => void;
+    /** Opens one released item with this instance's recipient key; its HPKE info/AAD binding is fixed by r11.1. */
+    readonly openItem: (item: HpkeWrap, position: ReleasedItemPosition) => Promise<Uint8Array>;
+}
+/** Per egress instance (custody design 3.4): its leases live on the instance, never in module scope. */
+export declare class SealedCredentialSource implements CredentialSource {
+    #private;
+    constructor(deps: SealedSourceDeps);
+    resolve(providerId: ProviderId, entryDigest: string, fields: readonly SecretField[], scope: ReleaseScope): Promise<SecretLease>;
+    /** Disposes every live lease, and voids any lease still being resolved when the bump lands. */
+    bumpGeneration(): void;
+}
+//# sourceMappingURL=sealed-source.d.ts.map

package/dist/core/egress/sealed-source.js

@@ -0,0 +1,140 @@
+import { CredentialWait, SecretNotLeased, } from "./credentials.js";
+const RELOADS_PER_STEP = 3;
+const STABLE_HEAD_MS = 5000;
+const REDACTED = "<redacted>";
+const RETRYABLE = [
+    "stale_snapshot",
+    "epoch_mismatch",
+    "unresolved_field",
+    "wrap_missing",
+    "unavailable",
+];
+class SealedLease {
+    #values;
+    #onDispose;
+    constructor(values, onDispose) {
+        this.#values = values;
+        this.#onDispose = onDispose;
+    }
+    value(field) {
+        const bytes = this.#values?.get(field);
+        if (bytes === undefined)
+            throw new SecretNotLeased(field);
+        return new TextDecoder().decode(bytes);
+    }
+    [Symbol.dispose]() {
+        const values = this.#values;
+        if (values === undefined)
+            return;
+        this.#values = undefined;
+        for (const bytes of values.values())
+            bytes.fill(0);
+        this.#onDispose(this);
+    }
+    toJSON() {
+        return REDACTED;
+    }
+    toString() {
+        return REDACTED;
+    }
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return REDACTED;
+    }
+}
+/** Per egress instance (custody design 3.4): its leases live on the instance, never in module scope. */
+export class SealedCredentialSource {
+    #deps;
+    #live = new Set();
+    #generation = 0;
+    constructor(deps) {
+        this.#deps = deps;
+    }
+    async resolve(providerId, entryDigest, fields, scope) {
+        if (new Set(fields).size !== fields.length)
+            throw new TypeError("a sealed release names each field at most once");
+        const step = { digest: entryDigest, reloads: 0, noticed: false };
+        for (let attempt = 0; attempt < 2; attempt++) {
+            const generation = this.#generation;
+            const values = await this.#resolveValues(providerId, step, fields, scope);
+            if (generation === this.#generation) {
+                const lease = new SealedLease(values, (disposed) => this.#live.delete(disposed));
+                this.#live.add(lease);
+                return lease;
+            }
+            for (const bytes of values.values())
+                bytes.fill(0);
+        }
+        throw new CredentialWait("config-churn", true);
+    }
+    /** Disposes every live lease, and voids any lease still being resolved when the bump lands. */
+    bumpGeneration() {
+        this.#generation++;
+        for (const lease of [...this.#live])
+            lease[Symbol.dispose]();
+    }
+    /** One release attempt; `step` carries the reload count, notice latch and digest across bump retries (C.3). */
+    async #resolveValues(providerId, step, fields, scope) {
+        const signal = this.#deps.stepSignal(scope);
+        for (;;) {
+            signal.throwIfAborted();
+            const lease = await this.#deps.lease();
+            const result = await this.#release(providerId, step.digest, fields, scope, lease);
+            if (result.ok)
+                return this.#open(providerId, step.digest, fields, result.items, lease);
+            if (result.code !== "stale_snapshot")
+                throw new CredentialWait(result.code, RETRYABLE.some((code) => code === result.code));
+            if (step.reloads < RELOADS_PER_STEP) {
+                step.reloads++;
+            }
+            else {
+                // config-churn (C.3): every further stale retry re-enters the stable-head wait, never the immediate reloads.
+                if (!step.noticed) {
+                    step.noticed = true;
+                    this.#deps.onChurnNotice(scope);
+                }
+                await this.#waitForStableHead(signal);
+            }
+            step.digest = await this.#deps.reloadEntryDigest(providerId);
+        }
+    }
+    async #release(providerId, entryDigest, fields, scope, lease) {
+        return this.#deps.unsealer.release({
+            accountId: this.#deps.accountId,
+            providerId,
+            entryDigest,
+            fields,
+            lease,
+            recipientPk: this.#deps.recipientPk,
+            scope,
+        });
+    }
+    /** Returns once the head held still for STABLE_HEAD_MS; rejects when the step aborts first. */
+    async #waitForStableHead(signal) {
+        let previous = await this.#deps.readHead();
+        for (;;) {
+            await this.#deps.sleep(STABLE_HEAD_MS, signal);
+            const current = await this.#deps.readHead();
+            if (current === previous)
+                return;
+            previous = current;
+        }
+    }
+    async #open(providerId, entryDigest, fields, items, epochLease) {
+        if (items.length !== fields.length)
+            throw new CredentialWait("denied", false);
+        const values = new Map();
+        try {
+            for (const [index, field] of fields.entries()) {
+                const position = { accountId: this.#deps.accountId, providerId, entryDigest, field, lease: epochLease };
+                values.set(field, await this.#deps.openItem(items[index], position));
+            }
+        }
+        catch (error) {
+            for (const bytes of values.values())
+                bytes.fill(0);
+            throw error;
+        }
+        return values;
+    }
+}
+//# sourceMappingURL=sealed-source.js.map

package/dist/core/egress/verified-keys.js

@@ -39,7 +39,7 @@ function parseRecord(value) {
     if (!isRecord(value))
         return undefined;
     const raw = value;
-    if (!Object.keys(raw).every((key) => RECORD_KEYS.includes(key)))
+    if (!Object.keys(raw).every((key) => RECORD_KEYS.some((known) => known === key)))
         return undefined;
     const { kind, accountId, generation, sigKeyId, sigPkSha256, kemKeyId, kemPkSha256, kmsKeyArns, templateVersion, verifierKeyId, vouchedAt, supersedes, checkedAt, } = raw;
     if (kind !== "custody" && kind !== "placement-registry")

package/dist/core/egress/wire.d.ts

@@ -14,9 +14,11 @@ import type { ServiceKeyEntry } from "./roster-entries.ts";
 /**
  * The stream options a brain may send a hand: serializable request shaping only. Never secrets or headers, callbacks,
  * signals or live objects, or the loop-only `commitStep` (4.3, 2.3 options hygiene). `env` stays hand-local because
- * provider adapters resolve the model `baseUrl` from it: a brain-supplied `env` could redirect the hand's dial, with
- * the hand's own API key, to a gateway of the brain's choosing. `cwd` stays hand-local because the start message's
- * `cwd` is the one source the hand interprets.
+ * some adapters derive the dial target from it: the Cloudflare providers of `anthropic-messages` and `openai-responses`
+ * fill the account and gateway of the model `baseUrl` from it (`resolveCloudflareBaseUrl`), `azure-openai-responses`
+ * reads its base URL or resource name from it, and `bedrock-converse-stream` its HTTP proxy. A brain-supplied `env`
+ * could therefore redirect the hand's dial, with the hand's own credential, to a host of the brain's choosing. `cwd`
+ * stays hand-local because the start message's `cwd` is the one source the hand interprets.
  */
 export declare const WIRE_STREAM_OPTION_KEYS: readonly ["abortServerSideFallback", "affinitySessionId", "cacheRetention", "deferred", "extraBody", "maxRetries", "maxRetryDelayMs", "maxTokens", "metadata", "reasoning", "refusalFallbacks", "samplingParams", "serviceTier", "sessionAffinityKey", "sessionId", "streamKind", "temperature", "thinkingBudgets", "thinkingSelection", "timeoutMs", "toolChoice", "transport", "websocketConnectTimeoutMs"];
 export type WireStreamOptions = Pick<SimpleStreamOptions, (typeof WIRE_STREAM_OPTION_KEYS)[number]>;

package/dist/core/egress/wire.js

@@ -1,9 +1,11 @@
 /**
  * The stream options a brain may send a hand: serializable request shaping only. Never secrets or headers, callbacks,
  * signals or live objects, or the loop-only `commitStep` (4.3, 2.3 options hygiene). `env` stays hand-local because
- * provider adapters resolve the model `baseUrl` from it: a brain-supplied `env` could redirect the hand's dial, with
- * the hand's own API key, to a gateway of the brain's choosing. `cwd` stays hand-local because the start message's
- * `cwd` is the one source the hand interprets.
+ * some adapters derive the dial target from it: the Cloudflare providers of `anthropic-messages` and `openai-responses`
+ * fill the account and gateway of the model `baseUrl` from it (`resolveCloudflareBaseUrl`), `azure-openai-responses`
+ * reads its base URL or resource name from it, and `bedrock-converse-stream` its HTTP proxy. A brain-supplied `env`
+ * could therefore redirect the hand's dial, with the hand's own credential, to a host of the brain's choosing. `cwd`
+ * stays hand-local because the start message's `cwd` is the one source the hand interprets.
  */
 export const WIRE_STREAM_OPTION_KEYS = [
     "abortServerSideFallback",

package/dist/core/extensions/builtin/monitor-state-event.d.ts

@@ -5,6 +5,32 @@ export declare const CONTINUATION_HOLD_STATE_EVENT = "continuation_hold_state";
 /** Live widgets of a session's long background jobs; payload `JobWidgetState` (job-widgets/view-types.ts). */
 export declare const JOB_WIDGET_STATE_EVENT = "job_widget_state";
 export declare const MONITOR_NOTIFICATION_CUSTOM_TYPE = "senpi-monitor:notification";
+/** A background terminal session's age notice or auto-reap; payload `TerminalBackgroundAgeEvent` (senpi#6201). */
+export declare const TERMINAL_BACKGROUND_AGE_EVENT = "terminal_background_age";
+/**
+ * `running`: the session is still running at `ageMinutes` (first at 10 minutes, then every 30). `reaped`: the opt-in
+ * auto-reap stopped it at `autoReapMinutes`. `reap_failed`: the auto-reap's one stop at `autoReapMinutes` did not end
+ * it, for `reason`; it keeps running and keeps reporting. `stop` is the call that stops it; `autoReapMinutes` is null
+ * when nothing will stop it automatically.
+ */
+export interface TerminalBackgroundAgeEvent {
+    readonly kind: "running" | "reaped" | "reap_failed";
+    readonly id: string;
+    readonly description: string;
+    readonly command?: string;
+    readonly startedAtMs: number;
+    readonly ageMs: number;
+    readonly ageMinutes: number;
+    readonly autoReapMinutes: number | null;
+    /** Why the auto-reap failed; set on `reap_failed` only. */
+    readonly reason?: string;
+    readonly stop: {
+        readonly tool: "kill_bash";
+        readonly args: {
+            readonly bash_id: string;
+        };
+    };
+}
 /** Per-monitor entry in a monitor notification's `details.monitors`. */
 export interface MonitorNotificationDetail {
     readonly id: string;

package/dist/core/extensions/builtin/monitor-state-event.js

@@ -5,6 +5,8 @@ export const CONTINUATION_HOLD_STATE_EVENT = "continuation_hold_state";
 /** Live widgets of a session's long background jobs; payload `JobWidgetState` (job-widgets/view-types.ts). */
 export const JOB_WIDGET_STATE_EVENT = "job_widget_state";
 export const MONITOR_NOTIFICATION_CUSTOM_TYPE = "senpi-monitor:notification";
+/** A background terminal session's age notice or auto-reap; payload `TerminalBackgroundAgeEvent` (senpi#6201). */
+export const TERMINAL_BACKGROUND_AGE_EVENT = "terminal_background_age";
 /** True for a delivered monitor notification that carries a person's words (omo#10280). */
 export function isHumanInputMonitorNotification(message) {
     if (typeof message !== "object" || message === null)

package/dist/core/extensions/builtin/terminal/background-age.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Age notices of still-running background sessions (senpi#6201): one at 10 minutes, then one every 30 minutes (10, 40,
+ * 70, ...). One schedule per session bundle serves every session with ONE unref'd timer armed for the earliest due
+ * notice, so it never keeps the process alive and costs nothing per session; it is cleared when the last session
+ * leaves and on dispose. A late timer (the machine slept) or a session registered after it started reports at most
+ * once for the milestones it missed, never a burst.
+ */
+import type { TerminalBackgroundAgeEvent } from "../monitor-state-event.ts";
+export interface BackgroundAgeSubject {
+    readonly id: string;
+    readonly description: string;
+    readonly command?: string;
+    readonly startedAtMs: number;
+    readonly autoReapMinutes?: number;
+}
+export declare function backgroundAgeEvent(kind: TerminalBackgroundAgeEvent["kind"], subject: BackgroundAgeSubject, nowMs: number): TerminalBackgroundAgeEvent;
+export declare class BackgroundAgeSchedule {
+    #private;
+    constructor(onDue: (event: TerminalBackgroundAgeEvent) => void);
+    add(subject: BackgroundAgeSubject): void;
+    get(id: string): BackgroundAgeSubject | undefined;
+    remove(id: string): BackgroundAgeSubject | undefined;
+    dispose(): void;
+}
+//# sourceMappingURL=background-age.d.ts.map