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

package/dist/core/lifecycle-wait-items.js

@@ -0,0 +1,72 @@
+/** Optional producer detail never determines custody. Lists are snapshots, bounded independently of activeCount. */
+export function normalizeWaitItems(value, omitted) {
+    const byId = new Map();
+    if (Array.isArray(value)) {
+        for (const entry of value) {
+            if (typeof entry !== "object" || entry === null || !("id" in entry))
+                continue;
+            if (typeof entry.id !== "string" || entry.id.trim().length === 0)
+                continue;
+            const item = {
+                id: entry.id,
+                ...("description" in entry && typeof entry.description === "string"
+                    ? { description: entry.description }
+                    : {}),
+                ...("startedAtMs" in entry &&
+                    typeof entry.startedAtMs === "number" &&
+                    Number.isFinite(entry.startedAtMs) &&
+                    Math.abs(entry.startedAtMs) <= 8.64e15
+                    ? { startedAtMs: entry.startedAtMs }
+                    : {}),
+            };
+            const previous = byId.get(item.id);
+            if (!previous || JSON.stringify(item) < JSON.stringify(previous))
+                byId.set(item.id, item);
+        }
+    }
+    const items = [...byId.values()].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    const omittedItems = Math.max(0, items.length - 32) +
+        (typeof omitted === "number" && Number.isSafeInteger(omitted) && omitted > 0 ? omitted : 0);
+    return {
+        ...(items.length ? { items: items.slice(0, 32) } : {}),
+        ...(omittedItems ? { omittedItems } : {}),
+    };
+}
+/** The one rule for a wake_source_state producer's item list: `items` when set, else the legacy `monitors`. */
+export function wakeSourceItems(data) {
+    return ("items" in data ? data.items : undefined) ?? ("monitors" in data ? data.monitors : undefined);
+}
+export function waitItemSignature(detail) {
+    return JSON.stringify([detail.items?.map((item) => [item.id, item.description]), detail.omittedItems]);
+}
+export function projectWaitItems(detail) {
+    return {
+        ...(detail.items
+            ? {
+                items: detail.items.map((item) => ({
+                    id: item.id,
+                    ...(item.description === undefined ? {} : { label: item.description }),
+                    ...(item.startedAtMs === undefined ? {} : { startedAt: new Date(item.startedAtMs).toISOString() }),
+                })),
+            }
+            : {}),
+        ...(detail.omittedItems ? { omittedItems: detail.omittedItems } : {}),
+    };
+}
+export function readWaitItems(value, omitted) {
+    const items = Array.isArray(value)
+        ? value.map((item) => {
+            if (typeof item !== "object" || item === null)
+                return item;
+            return {
+                ...("id" in item ? { id: item.id } : {}),
+                ...("label" in item ? { description: item.label } : {}),
+                ...("startedAt" in item && typeof item.startedAt === "string"
+                    ? { startedAtMs: Date.parse(item.startedAt) }
+                    : {}),
+            };
+        })
+        : undefined;
+    return projectWaitItems(normalizeWaitItems(items, omitted));
+}
+//# sourceMappingURL=lifecycle-wait-items.js.map

package/dist/core/model-runtime.js

@@ -245,7 +245,12 @@ export class ModelRuntime {
             return base;
         }
         try {
-            const provider = composeModelProvider(providerId, base, this.config, extension);
+            // The reader runs only inside ambient auth resolution; composition itself stays credential-free.
+            const storedProviderEnv = async (sourceId) => {
+                const credential = await this.credentials.read(sourceId);
+                return credential?.type === "api_key" && credential.env ? { ...credential.env } : undefined;
+            };
+            const provider = composeModelProvider(providerId, base, this.config, extension, { storedProviderEnv });
             this.compositionErrors.delete(providerId);
             return provider;
         }

package/dist/core/provider-api-key-auth.d.ts

@@ -1,11 +1,14 @@
 import { type ApiKeyAuth, type AuthContext, type AuthResult, type ModelAuth, type Provider, type ProviderHeaders } from "@earendil-works/pi-ai";
 import type { ConfigValue } from "@earendil-works/pi-ai/utils/config-reference";
 import type { ModelsJsonProvider } from "./model-config.ts";
+/** Reads another provider's stored credential env: routing metadata only, never keys. */
+export type StoredProviderEnvReader = (providerId: string) => Promise<Record<string, string> | undefined>;
 interface AmbientAuthExtensionInput {
     name?: string;
     resolve(input: {
         ctx: AuthContext;
         signal: AbortSignal;
+        storedProviderEnv?: StoredProviderEnvReader;
     }): Promise<AuthResult | undefined>;
 }
 interface ProviderAuthExtensionInput {
@@ -19,7 +22,9 @@ interface ProviderAuthExtensionInput {
     oauth?: unknown;
     ambientAuth?: AmbientAuthExtensionInput;
 }
-export declare function composeApiKeyAuth(providerId: string, base: Provider | undefined, config: ModelsJsonProvider | undefined, extension: ProviderAuthExtensionInput | undefined): ApiKeyAuth | undefined;
+export declare function composeApiKeyAuth(providerId: string, base: Provider | undefined, config: ModelsJsonProvider | undefined, extension: ProviderAuthExtensionInput | undefined, options?: {
+    storedProviderEnv?: StoredProviderEnvReader;
+}): ApiKeyAuth | undefined;
 export declare function configuredApiKey(config: ModelsJsonProvider | undefined, extension: ProviderAuthExtensionInput | undefined): ConfigValue | undefined;
 export declare function configuredHeaders(config: ModelsJsonProvider | undefined, extension: ProviderAuthExtensionInput | undefined): Record<string, ConfigValue> | undefined;
 export declare function withConfiguredAuth(auth: ModelAuth, headers: ProviderHeaders | undefined, authHeader: boolean): ModelAuth;

package/dist/core/provider-api-key-auth.js

@@ -2,7 +2,7 @@ import { hasCredentialHeaders, } from "@earendil-works/pi-ai";
 import { assertConfigReferenceAuthority } from "./config-reference-resolver.js";
 import { checkConfiguredHeaderAuth, headerAuthResolutionSource } from "./provider-header-auth.js";
 import { getConfigValueEnvVarNames, isCommandConfigValue, resolveConfigValueOrThrow, resolveHeadersOrThrow, } from "./resolve-config-value.js";
-export function composeApiKeyAuth(providerId, base, config, extension) {
+export function composeApiKeyAuth(providerId, base, config, extension, options) {
     const inherited = base?.auth.apiKey;
     const rawKey = configuredApiKey(config, extension);
     const oauth = extension?.oauth ?? base?.auth.oauth;
@@ -15,7 +15,7 @@ export function composeApiKeyAuth(providerId, base, config, extension) {
         // explicitly configured key, credential headers, or a base provider still
         // win, and a resolution marked ambient never outranks a configured
         // provider in automatic default selection (senpi#2327).
-        return ambientApiKeyAuth(providerId, ambient, rawHeaders, headerSource, authHeader);
+        return ambientApiKeyAuth(providerId, ambient, rawHeaders, headerSource, authHeader, options?.storedProviderEnv);
     }
     if (!inherited && rawKey === undefined && !headerSource && oauth) {
         // An OAuth provider with no key, no credential headers and no base normally
@@ -119,16 +119,23 @@ function ambientOnlyAuth(providerId, oauth, rawHeaders, headerSource, authHeader
  * is the only source — and `Models.checkAuth` resolves this auth, so the
  * `ambient` marker reaches the provider's auth status.
  */
-function ambientApiKeyAuth(providerId, ambient, rawHeaders, headerSource, authHeader) {
+function ambientApiKeyAuth(providerId, ambient, rawHeaders, headerSource, authHeader, storedProviderEnv) {
     const resolve = async (input) => {
-        const result = await ambient.resolve({ ctx: input.ctx, signal: input.signal });
+        const result = await ambient.resolve({
+            ctx: input.ctx,
+            signal: input.signal,
+            ...(storedProviderEnv ? { storedProviderEnv } : {}),
+        });
         if (!result)
             return undefined;
         const explicitEnv = { ...(input.credential?.env ?? {}), ...(result.env ?? {}) };
         const headerEnv = await configContextEnv(Object.values(rawHeaders ?? {}), input.ctx, explicitEnv);
         const headers = await resolveHeadersOrThrow(rawHeaders, `provider "${providerId}"`, headerEnv);
+        // Stored-then-env (helpers.ts invariant): the provider's own stored env wins over ambient-resolved env.
+        const env = result.env || input.credential?.env ? { ...(result.env ?? {}), ...(input.credential?.env ?? {}) } : undefined;
         return {
             ...result,
+            ...(env ? { env } : {}),
             auth: withConfiguredAuth(result.auth, headers, authHeader),
             source: result.source ?? headerSource,
         };

package/dist/core/provider-composer.d.ts

@@ -1,6 +1,7 @@
 import { type AnyModel, type Api, type AssistantMessageEventStream, type AuthCheck, type AuthContext, type AuthResult, type ClassifierApi, type ImageApi, type Model, type OAuthCredential, type OAuthCredentials, type OAuthLoginCallbacks, type Provider, type ProviderClassifier, type ProviderImages, type RefreshModelsContext, type SimpleStreamOptions, type TranscriptContext } from "@earendil-works/pi-ai";
 import type { RetryPolicyProfile } from "@earendil-works/pi-ai/utils/retry-profile/types";
 import type { ModelConfig, ModelsJsonProvider } from "./model-config.ts";
+import { type StoredProviderEnvReader } from "./provider-api-key-auth.ts";
 import type { HeaderAuthStatusSource } from "./provider-header-auth.ts";
 import { clearConfigValueCache } from "./resolve-config-value.ts";
 export interface ExtensionOAuthConfig {
@@ -120,6 +121,8 @@ export interface ProviderAmbientAuth {
     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>;
 }
 export type AuthStatus = {
@@ -133,7 +136,11 @@ export { configuredRequestAuthStatus, resolveCompatibilityRequestHeaders, resolv
 export declare const clearApiKeyCache: typeof clearConfigValueCache;
 export declare function validateExtensionProvider(providerId: string, base: Provider | undefined, modelsConfig: ModelsJsonProvider | undefined, extension: ProviderConfigInput): void;
 /** Compose built-in, models.json, and extension layers without reading credentials. */
-export declare function composeModelProvider(providerId: string, base: Provider | undefined, modelConfig: ModelConfig, extension: ProviderConfigInput | undefined): Provider;
+export declare function composeModelProvider(providerId: string, base: Provider | undefined, modelConfig: ModelConfig, extension: ProviderConfigInput | undefined, 
+/** Deferred ambient reads; the reader runs during auth resolution, never at composition. */
+options?: {
+    storedProviderEnv?: StoredProviderEnvReader;
+}): Provider;
 /**
  * Request shape a compatibility provider needs beside its credential. Headers are NOT
  * part of it: a configured header value can be a `!command`, and resolving one requires

package/dist/core/provider-composer.js

@@ -1,6 +1,6 @@
 import { getApiProvider, getCurrentTools, getProtocol, getToolCallFormat, isModelType, lazyStream, transformContext, wrapStreamWithToolCallMiddleware, } from "@earendil-works/pi-ai";
 import { classifierErrorResult, imageErrorResult } from "@earendil-works/pi-ai/utils/model-operations";
-import { composeApiKeyAuth, configuredHeaders, withConfiguredAuth } from "./provider-api-key-auth.js";
+import { composeApiKeyAuth, configuredHeaders, withConfiguredAuth, } from "./provider-api-key-auth.js";
 import { clearConfigValueCache, resolveHeadersOrThrow } from "./resolve-config-value.js";
 export { configuredRequestAuthStatus, resolveCompatibilityRequestHeaders, resolveConfiguredModelHeaders, } from "./provider-request-auth.js";
 export const clearApiKeyCache = clearConfigValueCache;
@@ -286,7 +286,9 @@ export function validateExtensionProvider(providerId, base, modelsConfig, extens
     applyExtension(providerId, applyModelsJson(providerId, getAllProviderModels(base), modelsConfig, extension), extension, new Set((modelsConfig?.models ?? []).map((definition) => definition.id)));
 }
 /** Compose built-in, models.json, and extension layers without reading credentials. */
-export function composeModelProvider(providerId, base, modelConfig, extension) {
+export function composeModelProvider(providerId, base, modelConfig, extension, 
+/** Deferred ambient reads; the reader runs during auth resolution, never at composition. */
+options) {
     const config = modelConfig.getProvider(providerId);
     let extensionOAuthCredential;
     let refreshedExtensionModels;
@@ -309,7 +311,9 @@ export function composeModelProvider(providerId, base, modelConfig, extension) {
     };
     // Validate eagerly so registration/reload reports structural errors immediately.
     getAllModels();
-    const apiKey = composeApiKeyAuth(providerId, base, config, extension);
+    const apiKey = composeApiKeyAuth(providerId, base, config, extension, {
+        storedProviderEnv: options?.storedProviderEnv,
+    });
     const oauth = composeOAuthAuth(providerId, base, config, extension);
     if (!apiKey && !oauth)
         throw new Error(`Provider ${providerId}: no authentication method configured.`);

package/dist/core/sdk.js

@@ -1,5 +1,5 @@
 import { join } from "node:path";
-import { Agent, setDefaultStreamFn } from "@earendil-works/pi-agent-core";
+import { Agent, createInternalAgentChannel, setDefaultStreamFn, } from "@earendil-works/pi-agent-core";
 import { modelsAreEqual, streamSimple } from "@earendil-works/pi-ai/compat";
 import { getAgentDir } from "../config.js";
 import { resolvePath } from "../utils/paths.js";
@@ -283,7 +283,9 @@ export async function createAgentSession(options = {}) {
             model: model.id,
         });
     };
+    const internalChannel = createInternalAgentChannel();
     agent = new Agent({
+        internalChannel,
         initialState: {
             systemPrompt: "",
             model,
@@ -382,6 +384,7 @@ export async function createAgentSession(options = {}) {
         : options.sessionStartEvent;
     const session = new AgentSession({
         agent,
+        internalChannel,
         serviceTier: options.serviceTier,
         sessionManager,
         settingsManager,

package/dist/core/session-activity.js

@@ -16,6 +16,7 @@
  * `AgentSession.isSessionBusy` instead of testing individual flags, so a source
  * added later cannot be silently missed by one call site.
  */
+import { normalizeWaitItems, wakeSourceItems } from "./lifecycle-wait-items.js";
 /** Live counts of extension-published wake sources, keyed by source name. */
 export class WakeSourceTracker {
     constructor() {
@@ -39,6 +40,7 @@ export class WakeSourceTracker {
             this.counts.set(source, {
                 activeCount,
                 kind: "kind" in data && data.kind === "children" ? "children" : "background",
+                ...normalizeWaitItems(wakeSourceItems(data)),
             });
         else
             this.counts.delete(source);

package/dist/core/session-lifecycle-types.d.ts

@@ -9,13 +9,26 @@ export interface HumanWait {
     readonly childLabel?: string;
     readonly since: string;
 }
+export interface LifecycleWaitItem {
+    readonly id: string;
+    readonly label?: string;
+    readonly startedAt?: string;
+}
+export interface LifecycleWaitSource {
+    readonly source: string;
+    readonly activeCount: number;
+    readonly items?: readonly LifecycleWaitItem[];
+    readonly omittedItems?: number;
+}
 export interface LifecycleWaits {
     readonly children: number;
-    readonly background: readonly {
-        readonly source: string;
-        readonly activeCount: number;
+    /** Named detail can be incomplete even without truncation: custody need not have a named report. */
+    readonly childSources?: readonly LifecycleWaitSource[];
+    readonly childReports?: readonly Pick<ChildLifecycleReport, "taskId" | "childSessionId" | "runEpoch" | "state" | "label" | "since">[];
+    readonly childReportsOmitted?: number;
+    readonly background: readonly (LifecycleWaitSource & {
         readonly retryAtMs?: number;
-    }[];
+    })[];
     readonly human: readonly HumanWait[];
 }
 export interface LifecycleHold {
@@ -83,6 +96,9 @@ export interface ChildLifecycleReport {
     readonly runEpoch: number;
     readonly generation: number;
     readonly state: SessionLifecycleState;
+    readonly label?: string;
+    /** The child's own state-entry time, not the parent's evaluation time. */
+    readonly since?: string;
     readonly waitingOn?: LifecycleWaits;
     readonly terminal?: "completed" | "error" | "lost" | "interrupted" | "cancelled";
 }

package/dist/core/session-lifecycle.js

@@ -1,6 +1,7 @@
 import { effectiveWakes } from "./extensions/builtin/goal/turn-end-liveness.js";
 import { LifecycleChildren } from "./lifecycle-children.js";
 import { LifecycleLedger } from "./lifecycle-ledger.js";
+import { projectWaitItems } from "./lifecycle-wait-items.js";
 import { sameStop, stopDetail } from "./lifecycle-stop.js";
 import { lifecycleState, lifecycleTerminal } from "./session-lifecycle-reducer.js";
 import { SessionWorkObligations } from "./work-obligations.js";
@@ -189,11 +190,34 @@ export class SessionLifecycleController {
     evaluate() {
         const runtime = this.options.readRuntime();
         const active = this.obligations.active;
-        const childRecords = this.children.reports.filter((report) => report.childSessionId !== this.options.sessionId && report.terminal === undefined).length;
+        const childRecords = this.children.reports
+            .filter((report) => report.childSessionId !== this.options.sessionId && report.terminal === undefined)
+            .sort((a, b) => (a.taskId < b.taskId ? -1 : a.taskId > b.taskId ? 1 : 0));
+        const childReports = childRecords
+            .slice(0, 32)
+            .map(({ taskId, childSessionId, runEpoch, state, label, since }) => ({
+            taskId,
+            childSessionId,
+            runEpoch,
+            state,
+            ...(label === undefined ? {} : { label }),
+            ...(since === undefined ? {} : { since }),
+        }));
+        const childSources = active
+            .filter((record) => record.kind === "children")
+            .map((record) => ({
+            source: record.source ?? record.key,
+            activeCount: record.activeCount ?? 1,
+            ...projectWaitItems(record),
+        }));
         const background = active
             .filter((record) => record.kind === "background")
-            .map((record) => ({ source: record.source ?? record.key, activeCount: record.activeCount ?? 1 }));
-        const children = Math.max(childRecords, active
+            .map((record) => ({
+            source: record.source ?? record.key,
+            activeCount: record.activeCount ?? 1,
+            ...projectWaitItems(record),
+        }));
+        const children = Math.max(childRecords.length, active
             .filter((record) => record.kind === "children")
             .reduce((sum, record) => sum + (record.activeCount ?? 1), 0));
         const input = this.liveness;
@@ -297,7 +321,14 @@ export class SessionLifecycleController {
                     runEpoch: this.ownTask.runEpoch,
                 }
                 : undefined;
-        const waits = { children, background, human };
+        const waits = {
+            children,
+            background,
+            human,
+            ...(childSources.length ? { childSources } : {}),
+            ...(childReports.length ? { childReports } : {}),
+            ...(childRecords.length > 32 ? { childReportsOmitted: childRecords.length - 32 } : {}),
+        };
         const lastStop = this.lastStop(input, synthetic.some((wait) => wait.kind === "stalled"));
         const state = lifecycleState({
             role: this.ledger.snapshot.role,

package/dist/core/structured-session-lane.d.ts

@@ -0,0 +1,33 @@
+import type { InternalAgentChannel } from "@earendil-works/pi-agent-core";
+import { type AssistantProgress } from "@earendil-works/pi-ai";
+import type { AgentSessionEvent } from "./agent-session.ts";
+/** One record of a session's internal structured lane: a session event or a block control, in session order. */
+export type AgentSessionStructuredRecord = AgentSessionEvent | AssistantProgress;
+type StructuredListener = (record: AgentSessionStructuredRecord) => void;
+export declare class StructuredLaneUnavailableError extends Error {
+    constructor();
+}
+/**
+ * The AgentSession end of the internal-only agent channel (senpi#4272, R3.C6.2). While a structured listener is
+ * attached, it holds the channel's capture subscription; block controls enter the session's own event queue, so they
+ * keep their position among the ordinary events. Extension listeners, `session.subscribe` and every legacy
+ * destination never see a control.
+ *
+ * The capture subscription is module-wide (`subscribeAssistantCapture`): while it is held, every capture-enabled
+ * provider stream in the process that first pushes afterwards builds capture records, including streams of sessions
+ * with no structured listener, which drop them at their public iterator.
+ */
+export declare class StructuredSessionLane {
+    #private;
+    private readonly listeners;
+    private releaseChannel;
+    constructor(channel: InternalAgentChannel | undefined, enqueue: (deliver: () => void) => void);
+    get active(): boolean;
+    subscribe(listener: StructuredListener): () => void;
+    /** Publishes a session event with the provider capture of its `source` agent event. */
+    emitEvent(event: AgentSessionEvent, source: object): void;
+    dispose(): void;
+    private emit;
+}
+export {};
+//# sourceMappingURL=structured-session-lane.d.ts.map

package/dist/core/structured-session-lane.js

@@ -0,0 +1,62 @@
+import { carryAssistantCapture } from "@earendil-works/pi-ai";
+export class StructuredLaneUnavailableError extends Error {
+    constructor() {
+        super("Structured lane unavailable: Agent was constructed outside the session layer");
+        this.name = "StructuredLaneUnavailableError";
+    }
+}
+/**
+ * The AgentSession end of the internal-only agent channel (senpi#4272, R3.C6.2). While a structured listener is
+ * attached, it holds the channel's capture subscription; block controls enter the session's own event queue, so they
+ * keep their position among the ordinary events. Extension listeners, `session.subscribe` and every legacy
+ * destination never see a control.
+ *
+ * The capture subscription is module-wide (`subscribeAssistantCapture`): while it is held, every capture-enabled
+ * provider stream in the process that first pushes afterwards builds capture records, including streams of sessions
+ * with no structured listener, which drop them at their public iterator.
+ */
+export class StructuredSessionLane {
+    #channel;
+    #enqueue;
+    constructor(channel, enqueue) {
+        this.listeners = new Set();
+        this.#channel = channel;
+        this.#enqueue = enqueue;
+    }
+    get active() {
+        return this.listeners.size > 0;
+    }
+    subscribe(listener) {
+        if (!this.#channel)
+            throw new StructuredLaneUnavailableError();
+        this.listeners.add(listener);
+        this.releaseChannel ??= this.#channel.subscribe((record) => {
+            if ("progress" in record)
+                this.#enqueue(() => this.emit(record.progress));
+        });
+        return () => {
+            this.listeners.delete(listener);
+            if (this.listeners.size === 0)
+                this.dispose();
+        };
+    }
+    /** Publishes a session event with the provider capture of its `source` agent event. */
+    emitEvent(event, source) {
+        const message = (event.type === "message_start" || event.type === "message_end") && event.message.role === "assistant"
+            ? event.message
+            : undefined;
+        // A user-facing description replaced the engine message, so the capture's frozen message must follow it.
+        const described = message && "message" in source && source.message !== message ? message : undefined;
+        this.emit(carryAssistantCapture(source, event, described));
+    }
+    dispose() {
+        this.listeners.clear();
+        this.releaseChannel?.();
+        this.releaseChannel = undefined;
+    }
+    emit(record) {
+        for (const listener of [...this.listeners])
+            listener(record);
+    }
+}
+//# sourceMappingURL=structured-session-lane.js.map

package/dist/core/work-custody-record.d.ts

@@ -1,4 +1,5 @@
 import type { CustomMessage } from "./messages.ts";
+import { type WaitSourceItems } from "./lifecycle-wait-items.ts";
 import type { ObligationKind } from "./session-lifecycle-types.ts";
 export interface CustodyPayload {
     readonly message: Pick<CustomMessage, "customType" | "content" | "display" | "details">;
@@ -7,7 +8,7 @@ export interface CustodyPayload {
     readonly itemIds?: readonly string[];
 }
 /** Mutable only by the registry; every replacement is appended before installation. */
-export interface WorkCustodyRecord {
+export interface WorkCustodyRecord extends WaitSourceItems {
     readonly id: string;
     readonly key: string;
     readonly kind: ObligationKind;

package/dist/core/work-custody-record.js

@@ -1,3 +1,4 @@
+import { normalizeWaitItems } from "./lifecycle-wait-items.js";
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -25,6 +26,7 @@ export function readWorkCustody(value) {
         key: value.key,
         kind: value.kind,
         state: value.state,
+        ...normalizeWaitItems(value.items, value.omittedItems),
         ...(typeof value.source === "string" ? { source: value.source } : {}),
         ...(typeof value.activeCount === "number" ? { activeCount: value.activeCount } : {}),
         ...(typeof value.detail === "string" ? { detail: value.detail } : {}),

package/dist/core/work-obligations.d.ts

@@ -36,7 +36,7 @@ export declare class SessionWorkObligations implements WorkObligations {
     get activeCount(): number;
     get persisted(): boolean;
     open(key: string, kind: ObligationKind, detail?: string): ObligationToken;
-    syncSource(source: string, kind: ObligationKind, activeCount: number): void;
+    syncSource(source: string, kind: ObligationKind, activeCount: number, items?: unknown): void;
     /** After a restart, a restored wake source stays open only if its producer published again. */
     retireRestoredSources(): void;
     /**

package/dist/core/work-obligations.js

@@ -1,3 +1,4 @@
+import { normalizeWaitItems, waitItemSignature } from "./lifecycle-wait-items.js";
 import { custodyIsOpen, readWorkCustody } from "./work-custody-record.js";
 /** Custody keys the engine opens itself (senpi#3986): queued deliveries and published wake sources. */
 export const ENGINE_DELIVERY_KEY_PREFIX = "delivery:";
@@ -59,7 +60,7 @@ export class SessionWorkObligations {
         this.store.changed();
         return this.token(record.id);
     }
-    syncSource(source, kind, activeCount) {
+    syncSource(source, kind, activeCount, items) {
         const key = `${WAKE_SOURCE_KEY_PREFIX}${source}`;
         this.publishedSources.add(key);
         const current = this.active.find((record) => record.key === key);
@@ -68,7 +69,10 @@ export class SessionWorkObligations {
                 this.close(current.id, "passive");
             return;
         }
-        if (current?.activeCount === activeCount && current.kind === kind)
+        const detail = normalizeWaitItems(items);
+        if (current?.activeCount === activeCount &&
+            current.kind === kind &&
+            waitItemSignature(current) === waitItemSignature(detail))
             return;
         this.install({
             ...current,
@@ -77,6 +81,8 @@ export class SessionWorkObligations {
             source,
             kind,
             activeCount,
+            items: detail.items,
+            omittedItems: detail.omittedItems,
             state: current?.state ?? "open",
         });
         this.store.changed();

package/dist/modes/json-event.d.ts

@@ -1,4 +1,4 @@
-import type { Usage } from "@earendil-works/pi-ai";
+import { type AssistantMessage, getAssistantCapture, type TextContent, type ThinkingContent, type ToolCall, type Usage } from "@earendil-works/pi-ai";
 import type { AgentSessionEvent } from "../core/agent-session.ts";
 type WithoutPartial<T> = T extends {
     partial: unknown;
@@ -13,6 +13,7 @@ type ToJsonAssistantMessageEvent<T> = T extends {
 type MessageUpdateEvent = Extract<AgentSessionEvent, {
     type: "message_update";
 }>;
+type AssistantCapture = NonNullable<ReturnType<typeof getAssistantCapture>>;
 type JsonMessageUpdateEvent = {
     type: "message_update";
     usage: Usage;
@@ -23,6 +24,82 @@ type JsonMessageUpdateEvent = {
 export type JsonAgentSessionEvent = Exclude<AgentSessionEvent, {
     type: "message_update";
 }> | JsonMessageUpdateEvent;
+/** The engine-staged block-seed projection (senpi#4272, R3.C6.2); no public destination selects it before S17. */
+export interface BlockSeedOptions {
+    readonly blockSeeds: 1;
+}
+type SeededAssistantEvent = {
+    type: "start";
+    seed: {
+        message: AssistantMessage;
+    };
+} | {
+    type: "text_start";
+    contentIndex: number;
+    seed: {
+        block: TextContent;
+        coveredCodeUnits: number;
+    };
+} | {
+    type: "thinking_start";
+    contentIndex: number;
+    seed: {
+        block: ThinkingContent;
+        coveredCodeUnits: number;
+    };
+} | {
+    type: "toolcall_start";
+    contentIndex: number;
+    id: string;
+    toolName: string;
+    seed: {
+        block: ToolCall;
+        rawArgumentPrefix: string;
+        parsedThrough: number;
+        coveredCodeUnits: number;
+    };
+} | {
+    type: "text_delta" | "thinking_delta";
+    contentIndex: number;
+    delta: string;
+    offset: number;
+} | {
+    type: "toolcall_delta";
+    contentIndex: number;
+    delta: string;
+    offset: number;
+    parsedThrough: number;
+} | {
+    type: "text_end";
+    contentIndex: number;
+    content: string;
+    block: TextContent;
+} | {
+    type: "thinking_end";
+    contentIndex: number;
+    content: string;
+    block: ThinkingContent;
+} | {
+    type: "toolcall_end";
+    contentIndex: number;
+    toolCall: ToolCall;
+} | {
+    type: "done";
+    reason: string;
+    message: AssistantMessage;
+} | {
+    type: "error";
+    reason: string;
+    error: AssistantMessage;
+};
+export type SeededJsonMessageUpdateEvent = Omit<MessageUpdateEvent, "message" | "assistantMessageEvent"> & {
+    usage: Usage;
+    messageMetadata?: AssistantCapture["metadata"];
+    assistantMessageEvent: SeededAssistantEvent;
+};
+export type SeededJsonAgentSessionEvent = Exclude<AgentSessionEvent, {
+    type: "message_update";
+}> | SeededJsonMessageUpdateEvent;
 /**
  * Remove cumulative assistant snapshots from streaming wire events.
  * `message_start` provides the initial message, deltas build it, and
@@ -31,5 +108,6 @@ export type JsonAgentSessionEvent = Exclude<AgentSessionEvent, {
  */
 export declare function toJsonEvent(event: MessageUpdateEvent): JsonMessageUpdateEvent;
 export declare function toJsonEvent(event: AgentSessionEvent): JsonAgentSessionEvent;
+export declare function toJsonEvent(event: AgentSessionEvent, options: BlockSeedOptions): SeededJsonAgentSessionEvent | undefined;
 export {};
 //# sourceMappingURL=json-event.d.ts.map