@code-yeongyu/senpi 2026.10.26-1 → 2026.10.26-2

package/dist/core/extensions/builtin/mcp/auth/oauth.js

@@ -1,6 +1,7 @@
 import { loadMcpSdkAuth } from "../sdk.lazy.js";
 import { isInvalidGrant, OAuthFlowError } from "./oauth-errors.js";
 import { oauthFetch } from "./oauth-fetch.js";
+import { validatedAuthorizationServerIssuer } from "./oauth-issuer.js";
 import { assertS256Supported } from "./oauth-refresh.js";
 // Pre-flight: discover the authorization server and REFUSE (typed) if it does
 // not advertise PKCE S256. Runs before any authorize redirect.
@@ -20,7 +21,7 @@ export async function beginAuthorization(provider, options = {}) {
 }
 // Paste flow: validates single-use state itself, then exchanges the code.
 export async function completeAuthorization(provider, redirectInput, options = {}) {
-    const { code, state, iss } = parseRedirect(redirectInput, provider.serverName);
+    const { code, state, iss } = parseRedirect(redirectInput, provider);
     if (!provider.consumeState(state)) {
         throw new OAuthFlowError("state_mismatch", `MCP server ${provider.serverName} authorization state did not match (possible CSRF or a stale/replayed link); restart with /mcp auth-start.`, { serverName: provider.serverName });
     }
@@ -56,15 +57,19 @@ export async function finishAuthorization(provider, code, options = {}, iss) {
 // RFC 9207: an authorization response that names another authorization server, or that omits `iss`
 // although this server promises to send it, may have been injected by a mix-up attack; never exchange its code.
 function assertAuthorizationResponseIssuer(provider, iss) {
-    const metadata = provider.discoveryState()?.authorizationServerMetadata;
-    if (metadata === undefined)
-        return;
+    const discovery = provider.discoveryState();
+    if (discovery === undefined) {
+        throw new OAuthFlowError("needs_auth", `MCP server ${provider.serverName} has no trusted authorization discovery; restart with /mcp auth-start ${provider.serverName}.`, { serverName: provider.serverName });
+    }
+    const metadata = discovery.authorizationServerMetadata;
+    const issuer = validatedAuthorizationServerIssuer(discovery, provider.serverName);
     // The SDK keeps unknown metadata fields (loose schema) but does not type this RFC 9207 one.
-    const promised = metadata
-        .authorization_response_iss_parameter_supported === true;
+    const promised = metadata !== undefined &&
+        "authorization_response_iss_parameter_supported" in metadata &&
+        metadata.authorization_response_iss_parameter_supported === true;
     if (iss === undefined && !promised)
         return;
-    if (iss !== undefined && iss === metadata.issuer)
+    if (iss !== undefined && iss === issuer)
         return;
     throw new OAuthFlowError("needs_auth", iss === undefined
         ? `MCP server ${provider.serverName} authorization response has no issuer although its authorization server promises one; restart with /mcp auth-start ${provider.serverName}.`
@@ -111,19 +116,19 @@ export async function clientCredentialsGrant(provider, options = {}) {
         resource: new URL(provider.serverUrl),
         fetchFn: oauthFetch(options.fetchFn),
     });
-    await provider.saveTokens({ ...tokens, issuer: String(info.authorizationServerUrl) });
+    await provider.saveTokens({ ...tokens, issuer: validatedAuthorizationServerIssuer(info, provider.serverName) });
 }
 export async function logout(provider) {
     await provider.store.clear();
 }
 async function discover(provider, options) {
-    if (options.discover !== undefined)
-        return options.discover(provider.serverUrl);
     const cached = provider.discoveryState();
     if (cached !== undefined)
         return cached;
     const { discoverOAuthServerInfo } = await loadMcpSdkAuth();
-    const info = await discoverOAuthServerInfo(provider.serverUrl, { fetchFn: oauthFetch(options.fetchFn) });
+    const info = options.discover !== undefined
+        ? await options.discover(provider.serverUrl)
+        : await discoverOAuthServerInfo(provider.serverUrl, { fetchFn: oauthFetch(options.fetchFn) });
     await provider.saveDiscoveryState(toDiscoveryState(info));
     return info;
 }
@@ -134,7 +139,8 @@ function toDiscoveryState(info) {
         resourceMetadata: info.resourceMetadata,
     };
 }
-function parseRedirect(input, serverName) {
+function parseRedirect(input, provider) {
+    const serverName = provider.serverName;
     let url;
     try {
         url = new URL(input.trim());
@@ -142,6 +148,7 @@ function parseRedirect(input, serverName) {
     catch {
         throw new OAuthFlowError("needs_auth", `MCP server ${serverName} received a malformed redirect URL; paste the full http://127.0.0.1/... address from your browser.`, { serverName });
     }
+    assertAuthorizationResponseIssuer(provider, url.searchParams.get("iss") ?? undefined);
     const error = url.searchParams.get("error");
     if (error !== null) {
         throw new OAuthFlowError("needs_auth", `MCP server ${serverName} authorization failed: ${error}`, { serverName });

package/dist/core/extensions/builtin/mcp/modern/dispatch.js

@@ -39,6 +39,7 @@ export async function materializeNegotiatedTransport(options, serverName, timeou
                 clientInfo,
                 clientCapabilities: {},
                 protocolVersion: outcome.version,
+                logger,
             }), outcome.discovery, outcome.version);
             const version = outcome.version;
             logVersion(transport, () => version);

package/dist/core/extensions/builtin/mcp/modern/parameter-headers.d.ts

@@ -2,10 +2,13 @@
 export declare function encodeMcpHeaderValue(value: string): string;
 /** Configured headers must never supply parameter metadata absent from the request body. */
 export declare function clearMcpParameterHeaders(headers: Headers): void;
+/** A local argument error, not a failed transport or an untrusted server diagnostic. */
+export declare class ParameterHeaderValidationError extends Error {
+}
 /** Connection-local catalog: never shared with another server or transport generation. */
 export declare class ModernParameterHeaders {
     #private;
-    filterTools(tools: readonly unknown[], firstPage: boolean): unknown[];
+    filterTools(tools: readonly unknown[], firstPage: boolean, warn: (message: string) => void): unknown[];
     append(headers: Headers, name: unknown, args: unknown): void;
 }
 //# sourceMappingURL=parameter-headers.d.ts.map

package/dist/core/extensions/builtin/mcp/modern/parameter-headers.js

@@ -18,22 +18,31 @@ export function clearMcpParameterHeaders(headers) {
 function parseParameterHeaders(schema) {
     const headers = [];
     const names = new Set();
+    let reason = "";
     const visit = (node, path) => {
+        if (Array.isArray(node))
+            return node.every((child) => visit(child, undefined));
         if (!isRecord(node))
             return true;
         if (Object.hasOwn(node, "x-mcp-header")) {
             const name = node["x-mcp-header"];
             const type = node.type;
-            if (!path?.length ||
-                typeof name !== "string" ||
-                !/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name) ||
-                names.has(name.toLowerCase()) ||
-                (type !== "string" && type !== "integer" && type !== "boolean"))
+            if (!path?.length)
+                reason = "x-mcp-header must be on a properties-only path";
+            else if (typeof name !== "string" || !/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name))
+                reason = "x-mcp-header must be a nonempty HTTP field-name token";
+            else if (names.has(name.toLowerCase()))
+                reason = "x-mcp-header names must be case-insensitively unique";
+            else if (type !== "string" && type !== "integer" && type !== "boolean")
+                reason = "x-mcp-header type must be string, integer, or boolean";
+            else {
+                names.add(name.toLowerCase());
+                headers.push({ name, path, type });
+            }
+            if (reason)
                 return false;
-            names.add(name.toLowerCase());
-            headers.push({ name, path, type });
         }
-        // Only schema-valued keywords are traversed: examples/default/const are instance data.
+        // "Anywhere else" includes unknown keywords; instance-data keywords are not schemas.
         for (const [keyword, value] of Object.entries(node)) {
             if (["properties", "patternProperties", "$defs", "definitions", "dependentSchemas", "dependencies"].includes(keyword)) {
                 if (!isRecord(value))
@@ -44,46 +53,31 @@ function parseParameterHeaders(schema) {
                         return false;
                 }
             }
-            else if ([
-                "items",
-                "prefixItems",
-                "allOf",
-                "anyOf",
-                "oneOf",
-                "additionalItems",
-                "additionalProperties",
-                "unevaluatedItems",
-                "unevaluatedProperties",
-                "contains",
-                "propertyNames",
-                "not",
-                "if",
-                "then",
-                "else",
-                "contentSchema",
-            ].includes(keyword)) {
-                for (const child of Array.isArray(value) ? value : [value]) {
-                    if (!visit(child, undefined))
-                        return false;
-                }
+            else if (!["examples", "default", "const", "enum"].includes(keyword)) {
+                if (!visit(value, undefined))
+                    return false;
             }
         }
         return true;
     };
-    return visit(schema, []) ? headers : undefined;
+    return visit(schema, []) ? headers : reason;
+}
+/** A local argument error, not a failed transport or an untrusted server diagnostic. */
+export class ParameterHeaderValidationError extends Error {
 }
 /** Connection-local catalog: never shared with another server or transport generation. */
 export class ModernParameterHeaders {
     #tools = new Map();
-    filterTools(tools, firstPage) {
+    filterTools(tools, firstPage, warn) {
         if (firstPage)
             this.#tools.clear();
         return tools.filter((tool) => {
             if (!isRecord(tool) || typeof tool.name !== "string")
                 return true;
             const headers = parseParameterHeaders(tool.inputSchema);
-            if (headers === undefined) {
+            if (typeof headers === "string") {
                 this.#tools.delete(tool.name);
+                warn(`Rejected MCP tool ${JSON.stringify(tool.name)}: ${headers}`);
                 return false;
             }
             this.#tools.set(tool.name, headers);
@@ -98,11 +92,15 @@ export class ModernParameterHeaders {
             for (const key of parameter.path) {
                 value = isRecord(value) && Object.hasOwn(value, key) ? value[key] : undefined;
             }
+            if (value === undefined)
+                continue;
             const valid = (parameter.type === "string" && typeof value === "string") ||
                 (parameter.type === "boolean" && typeof value === "boolean") ||
                 (parameter.type === "integer" && typeof value === "number" && Number.isSafeInteger(value));
-            if (valid)
-                headers.set(`Mcp-Param-${parameter.name}`, encodeMcpHeaderValue(String(value)));
+            if (!valid) {
+                throw new ParameterHeaderValidationError(`MCP tool ${JSON.stringify(name)} argument ${JSON.stringify(parameter.path)} must be ${parameter.type === "integer" ? "a safe integer" : `a ${parameter.type}`}`);
+            }
+            headers.set(`Mcp-Param-${parameter.name}`, encodeMcpHeaderValue(String(value)));
         }
     }
 }

package/dist/core/extensions/builtin/mcp/modern/request.js

@@ -7,6 +7,7 @@ import { isRecord, validateMrtrForm } from "./form-schema.js";
 import { McpMrtrError } from "./errors.js";
 import { queuedForm } from "./consent-queue.js";
 import { parseInputs } from "./inputs.js";
+import { ParameterHeaderValidationError } from "./parameter-headers.js";
 export const MAX_MCP_MRTR_ROUNDS = 8;
 const capableMethods = new Set(["tools/call", "resources/read", "prompts/get"]);
 const capabilitiesKey = "io.modelcontextprotocol/clientCapabilities";
@@ -259,6 +260,8 @@ export function installModernRequestAdapter(client, protocol, clock = mcpElapsed
                 throw error;
             if (error instanceof AuthError)
                 throw error;
+            if (error instanceof ParameterHeaderValidationError)
+                throw error;
             const remoteCode = isRecord(error) && typeof error.code === "number" ? error.code : undefined;
             throw new McpMrtrError("MCP_MRTR_TRANSPORT_FAILED", remoteCode);
         }

package/dist/core/extensions/builtin/mcp/modern/transport.d.ts

@@ -1,6 +1,7 @@
 import type { FetchLike, Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import { type JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
 import { type ModernClientInfo } from "./wire.ts";
+import type { McpLogger } from "../log.ts";
 export type ModernHttpTransportOptions = {
     readonly url: string | URL;
     readonly fetch: FetchLike;
@@ -8,6 +9,7 @@ export type ModernHttpTransportOptions = {
     readonly clientCapabilities: Readonly<Record<string, unknown>>;
     readonly protocolVersion?: string;
     readonly headers?: RequestInit["headers"];
+    readonly logger?: Pick<McpLogger, "warn">;
 };
 export declare class ModernTransportError extends Error {
     constructor(message: string);

package/dist/core/extensions/builtin/mcp/modern/transport.js

@@ -4,7 +4,7 @@ import { AuthError } from "../errors.js";
 import { sanitizeModernMessage } from "./diagnostics.js";
 import { McpMrtrError } from "./errors.js";
 import { getModernDispatchGuard, modernDispatchGuard } from "./request.js";
-import { clearMcpParameterHeaders, ModernParameterHeaders } from "./parameter-headers.js";
+import { clearMcpParameterHeaders, ModernParameterHeaders, ParameterHeaderValidationError, } from "./parameter-headers.js";
 export class ModernTransportError extends Error {
     constructor(message) {
         super(message);
@@ -119,6 +119,8 @@ export class ModernHttpTransport {
             }
         }
         catch (error) {
+            if (error instanceof ParameterHeaderValidationError)
+                throw error;
             const failure = error instanceof McpMrtrError || error instanceof AuthError
                 ? error
                 : new McpMrtrError("MCP_MRTR_TRANSPORT_FAILED");
@@ -142,7 +144,7 @@ export class ModernHttpTransport {
                     ...incoming,
                     result: {
                         ...result,
-                        tools: this.#parameterHeaders.filterTools(result.tools, this.#toolLists.get(incoming.id) === true),
+                        tools: this.#parameterHeaders.filterTools(result.tools, this.#toolLists.get(incoming.id) === true, (message) => this.#options.logger?.warn(message)),
                     },
                 };
             }

package/dist/core/extensions/builtin/terminal/extension-state.js

@@ -58,8 +58,9 @@ export function bundleSinks(pi, state) {
             pi.events?.emit(WAKE_SOURCE_STATE_EVENT, {
                 source: "terminal-monitors",
                 activeCount: snapshot.length,
+                // The stable "mon_" id: runtime ids churn on restore, and item ids feed the custody signature.
                 monitors: snapshot.map((entry) => ({
-                    id: entry.id,
+                    id: entry.monitorId ?? entry.id,
                     description: entry.description,
                     startedAtMs: entry.startedAtMs,
                 })),

package/dist/core/extensions/builtin/vertex-model-garden/auth.d.ts

@@ -8,9 +8,18 @@ export declare const VERTEX_MODEL_GARDEN_ADC_SOURCE = "gcloud application defaul
  * gcloud tooling too, so the lane is selectable but never outranks a provider the
  * user configured, and it reports nothing while the chain is absent — the failure
  * belongs at selection time, not at the first request.
+ *
+ * The target project is resolved here so it rides the ambient auth result into
+ * the request env: process env first, then the sibling google-vertex profile,
+ * which shares this ADC chain and already names the project the user entered at
+ * its login. With neither source the lane stays available and the request-time
+ * ADC fallbacks (quota project, discovered project) decide, so a missing project
+ * remains a first-request failure with the actionable error, not a hidden lane.
  */
 export declare function resolveVertexModelGardenAmbient(input: {
     ctx: AuthContext;
     signal: AbortSignal;
+    /** Read-only env of another provider's stored credential; routing metadata only, never keys. */
+    storedProviderEnv?(providerId: string): Promise<Record<string, string> | undefined>;
 }): Promise<AuthResult | undefined>;
 //# sourceMappingURL=auth.d.ts.map

package/dist/core/extensions/builtin/vertex-model-garden/auth.js

@@ -7,6 +7,13 @@ export const VERTEX_MODEL_GARDEN_ADC_SOURCE = "gcloud application default creden
  * gcloud tooling too, so the lane is selectable but never outranks a provider the
  * user configured, and it reports nothing while the chain is absent — the failure
  * belongs at selection time, not at the first request.
+ *
+ * The target project is resolved here so it rides the ambient auth result into
+ * the request env: process env first, then the sibling google-vertex profile,
+ * which shares this ADC chain and already names the project the user entered at
+ * its login. With neither source the lane stays available and the request-time
+ * ADC fallbacks (quota project, discovered project) decide, so a missing project
+ * remains a first-request failure with the actionable error, not a hidden lane.
  */
 export async function resolveVertexModelGardenAmbient(input) {
     input.signal.throwIfAborted();
@@ -14,6 +21,15 @@ export async function resolveVertexModelGardenAmbient(input) {
     input.signal.throwIfAborted();
     if (!(await input.ctx.fileExists(path)))
         return undefined;
-    return { auth: {}, source: VERTEX_MODEL_GARDEN_ADC_SOURCE, ambient: true };
+    input.signal.throwIfAborted();
+    const project = (await input.ctx.env("GOOGLE_CLOUD_PROJECT")) ??
+        (await input.ctx.env("GCLOUD_PROJECT")) ??
+        (await input.storedProviderEnv?.("google-vertex"))?.GOOGLE_CLOUD_PROJECT;
+    return {
+        auth: {},
+        ...(project ? { env: { GOOGLE_CLOUD_PROJECT: project } } : {}),
+        source: VERTEX_MODEL_GARDEN_ADC_SOURCE,
+        ambient: true,
+    };
 }
 //# sourceMappingURL=auth.js.map

package/dist/core/extensions/builtin/websearch/websearch/providers/google.d.ts

@@ -1,3 +1,9 @@
 import type { ProviderModule } from "./shared.ts";
+/**
+ * Catalog GA flash alias: it tracks the current stable flash model, so the default
+ * cannot age into a retired generation (gemini-2.5-flash 404s for new accounts).
+ * An entry-level `model` still overrides it.
+ */
+export declare const DEFAULT_MODEL = "gemini-flash-latest";
 export declare const googleProvider: ProviderModule;
 //# sourceMappingURL=google.d.ts.map

package/dist/core/extensions/builtin/websearch/websearch/providers/google.js

@@ -1,6 +1,11 @@
 import { providerUrl } from "../provider-endpoints.js";
 import { appendDomainFilters, collect, contentHeaders, getArray, getNumber, getObject, getString, result, withConfigHeaders, } from "./shared.js";
-const DEFAULT_MODEL = "gemini-2.5-flash";
+/**
+ * Catalog GA flash alias: it tracks the current stable flash model, so the default
+ * cannot age into a retired generation (gemini-2.5-flash 404s for new accounts).
+ * An entry-level `model` still overrides it.
+ */
+export const DEFAULT_MODEL = "gemini-flash-latest";
 function generateContentUrl(config) {
     const root = providerUrl(config).replace(/\/+$/, "");
     if (root.endsWith(":generateContent"))

package/dist/core/extensions/types.d.ts

@@ -2369,6 +2369,8 @@ export interface ProviderConfig {
         resolve(input: {
             ctx: AuthContext;
             signal: AbortSignal;
+            /** Read-only env of another provider's stored credential; routing metadata only, never keys. */
+            storedProviderEnv?(providerId: string): Promise<Record<string, string> | undefined>;
         }): Promise<AuthResult | undefined>;
     };
     /** OAuth provider for /login support. The `id` is set automatically from the provider name. */

package/dist/core/lifecycle-children.d.ts

@@ -1,4 +1,4 @@
-import type { ChildLifecycleReport, SessionLifecycleState } from "./session-lifecycle-types.ts";
+import type { ChildLifecycleReport, LifecycleWaits, SessionLifecycleState } from "./session-lifecycle-types.ts";
 import type { SessionEntry } from "./session-manager.ts";
 export interface ChildLifecycleStore {
     readonly entries: readonly SessionEntry[];
@@ -15,4 +15,6 @@ export declare class LifecycleChildren {
     private accept;
 }
 export declare function readLifecycleState(value: unknown): SessionLifecycleState | undefined;
+/** The one reader of a durable or reported `waitingOn`; named detail never invalidates the counts. */
+export declare function readWaits(value: unknown): LifecycleWaits | undefined;
 //# sourceMappingURL=lifecycle-children.d.ts.map

package/dist/core/lifecycle-children.js

@@ -1,3 +1,5 @@
+import { readHumanWait } from "./lifecycle-attention.js";
+import { readWaitItems } from "./lifecycle-wait-items.js";
 import { isRecord } from "./work-custody-record.js";
 export class LifecycleChildren {
     constructor(store) {
@@ -60,6 +62,80 @@ export function readLifecycleState(value) {
             return undefined;
     }
 }
+/** The one reader of a durable or reported `waitingOn`; named detail never invalidates the counts. */
+export function readWaits(value) {
+    if (!isRecord(value) || typeof value.children !== "number")
+        return undefined;
+    const background = [];
+    if (Array.isArray(value.background)) {
+        for (const source of value.background) {
+            if (!isRecord(source) || typeof source.source !== "string" || typeof source.activeCount !== "number")
+                continue;
+            background.push({
+                source: source.source,
+                activeCount: source.activeCount,
+                ...readWaitItems(source.items, source.omittedItems),
+                ...(typeof source.retryAtMs === "number" ? { retryAtMs: source.retryAtMs } : {}),
+            });
+        }
+    }
+    const human = Array.isArray(value.human)
+        ? value.human.flatMap((request) => {
+            const wait = readHumanWait(request);
+            return wait ? [wait] : [];
+        })
+        : [];
+    const childSources = [];
+    if (Array.isArray(value.childSources))
+        for (const source of value.childSources) {
+            if (!isRecord(source) || typeof source.source !== "string" || typeof source.activeCount !== "number")
+                continue;
+            childSources.push({
+                source: source.source,
+                activeCount: source.activeCount,
+                ...readWaitItems(source.items, source.omittedItems),
+            });
+        }
+    const reports = [];
+    if (Array.isArray(value.childReports))
+        for (const report of value.childReports) {
+            if (!isRecord(report))
+                continue;
+            const state = readLifecycleState(report.state);
+            if (!state ||
+                typeof report.taskId !== "string" ||
+                typeof report.childSessionId !== "string" ||
+                typeof report.runEpoch !== "number" ||
+                !Number.isSafeInteger(report.runEpoch) ||
+                report.runEpoch < 0)
+                continue;
+            reports.push({
+                taskId: report.taskId,
+                childSessionId: report.childSessionId,
+                runEpoch: report.runEpoch,
+                state,
+                ...(typeof report.label === "string" ? { label: report.label } : {}),
+                ...(typeof report.since === "string" && Number.isFinite(Date.parse(report.since))
+                    ? { since: report.since }
+                    : {}),
+            });
+        }
+    reports.sort((a, b) => (a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0));
+    const childReportsOmitted = Math.max(0, reports.length - 32) +
+        (typeof value.childReportsOmitted === "number" &&
+            Number.isSafeInteger(value.childReportsOmitted) &&
+            value.childReportsOmitted > 0
+            ? value.childReportsOmitted
+            : 0);
+    return {
+        children: value.children,
+        background,
+        human,
+        ...(childSources.length ? { childSources } : {}),
+        ...(reports.length ? { childReports: reports.slice(0, 32) } : {}),
+        ...(childReportsOmitted ? { childReportsOmitted } : {}),
+    };
+}
 function readChildReport(value) {
     if (!isRecord(value))
         return undefined;
@@ -75,27 +151,15 @@ function readChildReport(value) {
         value.generation < 0)
         return undefined;
     const terminal = readTerminal(value.terminal);
-    let waitingOn;
-    if (isRecord(value.waitingOn) && typeof value.waitingOn.children === "number") {
-        const background = [];
-        if (Array.isArray(value.waitingOn.background))
-            for (const item of value.waitingOn.background) {
-                if (!isRecord(item) || typeof item.source !== "string" || typeof item.activeCount !== "number")
-                    continue;
-                background.push({
-                    source: item.source,
-                    activeCount: item.activeCount,
-                    ...(typeof item.retryAtMs === "number" ? { retryAtMs: item.retryAtMs } : {}),
-                });
-            }
-        waitingOn = { children: value.waitingOn.children, background, human: [] };
-    }
+    const waitingOn = readWaits(value.waitingOn);
     return {
         taskId: value.taskId,
         childSessionId: value.childSessionId,
         runEpoch: value.runEpoch,
         generation: value.generation,
         state,
+        ...(typeof value.label === "string" ? { label: value.label } : {}),
+        ...(typeof value.since === "string" && Number.isFinite(Date.parse(value.since)) ? { since: value.since } : {}),
         ...(waitingOn ? { waitingOn } : {}),
         ...(terminal === undefined ? {} : { terminal }),
     };

package/dist/core/lifecycle-record.js

@@ -1,5 +1,5 @@
 import { readHumanWait } from "./lifecycle-attention.js";
-import { readLifecycleState } from "./lifecycle-children.js";
+import { readLifecycleState, readWaits } from "./lifecycle-children.js";
 import { readLastStop } from "./lifecycle-stop.js";
 import { isRecord } from "./work-custody-record.js";
 /** Restore the wire snapshot and its private high-water marks from owned JSONL. */
@@ -97,29 +97,6 @@ function readTurnEnd(value) {
             return undefined;
     }
 }
-function readWaits(value) {
-    if (!isRecord(value) || typeof value.children !== "number")
-        return undefined;
-    const background = [];
-    if (Array.isArray(value.background)) {
-        for (const source of value.background) {
-            if (!isRecord(source) || typeof source.source !== "string" || typeof source.activeCount !== "number")
-                continue;
-            background.push({
-                source: source.source,
-                activeCount: source.activeCount,
-                ...(typeof source.retryAtMs === "number" ? { retryAtMs: source.retryAtMs } : {}),
-            });
-        }
-    }
-    const human = Array.isArray(value.human)
-        ? value.human.flatMap((request) => {
-            const wait = readHumanWait(request);
-            return wait ? [wait] : [];
-        })
-        : [];
-    return { children: value.children, background, human };
-}
 function readHolds(value) {
     if (!Array.isArray(value))
         return undefined;

package/dist/core/lifecycle-session-binding.js

@@ -9,6 +9,7 @@ import { lifecycleHistory } from "./lifecycle-history.js";
 import { bindLifecycleHumanInput } from "./lifecycle-human-input.js";
 import { readLifecycleRuntimeFacts } from "./lifecycle-runtime-facts.js";
 import { goalGuardAfter } from "./lifecycle-stop.js";
+import { wakeSourceItems } from "./lifecycle-wait-items.js";
 import { SessionLifecycleController } from "./session-lifecycle.js";
 import { isRecord } from "./work-custody-record.js";
 /** Attaches durable lifecycle to the real session event/admission boundaries. */
@@ -310,7 +311,7 @@ export class LifecycleSessionBinding {
             return;
         if (!Number.isFinite(data.activeCount))
             return;
-        this.controller.obligations.syncSource(data.source, data.kind === "children" ? "children" : "background", data.activeCount);
+        this.controller.obligations.syncSource(data.source, data.kind === "children" ? "children" : "background", data.activeCount, wakeSourceItems(data));
     }
     dispose() {
         this.disposed = true;

package/dist/core/lifecycle-wait-items.d.ts

@@ -0,0 +1,17 @@
+import type { WakeSourceStateItem } from "./extensions/builtin/monitor-state-event.ts";
+import type { LifecycleWaitItem } from "./session-lifecycle-types.ts";
+export interface WaitSourceItems {
+    readonly items?: readonly WakeSourceStateItem[];
+    readonly omittedItems?: number;
+}
+/** Optional producer detail never determines custody. Lists are snapshots, bounded independently of activeCount. */
+export declare function normalizeWaitItems(value: unknown, omitted?: unknown): WaitSourceItems;
+/** The one rule for a wake_source_state producer's item list: `items` when set, else the legacy `monitors`. */
+export declare function wakeSourceItems(data: object): unknown;
+export declare function waitItemSignature(detail: WaitSourceItems): string;
+export declare function projectWaitItems(detail: WaitSourceItems): {
+    readonly items?: readonly LifecycleWaitItem[];
+    readonly omittedItems?: number;
+};
+export declare function readWaitItems(value: unknown, omitted?: unknown): ReturnType<typeof projectWaitItems>;
+//# sourceMappingURL=lifecycle-wait-items.d.ts.map