@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.33

package/vendor/subagent-core/typert.remote-client.d.ts

@@ -0,0 +1,25 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */
+import type {
+  RemoteResult,
+  TypertRemoteContribution,
+} from '@deepseek-ai/dsh-typert-protocol'
+import type { SessionId } from '@deepseek-ai/dsh-session/types'
+import type { SubagentInterruptReceipt, SubagentPromptReceipt, SubagentPromptRequest } from '@deepseek-ai/dsh-subagent/client'
+
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface TypertRemoteNamespace$7375626167656e7473 {
+    interruptByParent: (childSessionId: SessionId, parentSessionId: SessionId, mode: 'continuable') => Promise<RemoteResult<SubagentInterruptReceipt>>
+    prompt: (request: SubagentPromptRequest, signal?: AbortSignal) => Promise<RemoteResult<SubagentPromptReceipt>>
+  }
+  interface TypertRemoteMap {
+    'subagents/interruptByParent': (childSessionId: SessionId, parentSessionId: SessionId, mode: 'continuable') => Promise<RemoteResult<SubagentInterruptReceipt>>
+    'subagents/prompt': (request: SubagentPromptRequest, signal?: AbortSignal) => Promise<RemoteResult<SubagentPromptReceipt>>
+  }
+  interface TypertRemoteNamespaceMap {
+    'subagents': TypertRemoteNamespace$7375626167656e7473
+  }
+}
+
+export declare const TYPERT_REMOTE: TypertRemoteContribution
+export default TYPERT_REMOTE
+//# sourceMappingURL=typert.remote-client.d.ts.map

package/vendor/subagent-core/typert.remote-client.js

@@ -0,0 +1,114 @@
+/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */
+import { z } from 'zod'
+
+let _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema$value
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema = () => (_deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema$value ??= z.intersection(z.string(), z.unknown()))
+let _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema$value
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema = () => (_deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema$value ??= z.intersection(z.string(), z.unknown()))
+let _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_2$schema$value
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_2$schema = () => (_deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_2$schema$value ??= z.literal("continuable"))
+let _deepseek_ai_dsh_subagent_subagents_interruptByParent_result$schema$value
+const _deepseek_ai_dsh_subagent_subagents_interruptByParent_result$schema = () => (_deepseek_ai_dsh_subagent_subagents_interruptByParent_result$schema$value ??= z.object({
+  'accepted': z.literal(true).readonly(),
+}))
+let _deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema$value
+const _deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema = () => (_deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema$value ??= z.object({
+  'requestId': z.intersection(z.string(), z.unknown()).readonly(),
+  'parentSessionId': z.intersection(z.string(), z.unknown()).readonly(),
+  'childSessionId': z.intersection(z.string(), z.unknown()).readonly(),
+  'mode': z.literal("continuable").readonly(),
+  'delivery': z.union([z.literal("queue"), z.literal("steer")]).readonly(),
+  'content': z.array(z.union([z.object({
+  'type': z.literal("text").readonly(),
+  'text': z.string().readonly(),
+}), z.object({
+  'type': z.literal("image").readonly(),
+  'mediaType': z.union([z.literal("image/png"), z.literal("image/jpeg"), z.literal("image/webp"), z.literal("image/gif")]).readonly(),
+  'data': z.string().readonly(),
+  'name': z.string().readonly().optional(),
+})])).readonly(),
+  'clientTimeZone': z.string().readonly().optional(),
+}))
+let _deepseek_ai_dsh_subagent_subagents_prompt_result$schema$value
+const _deepseek_ai_dsh_subagent_subagents_prompt_result$schema = () => (_deepseek_ai_dsh_subagent_subagents_prompt_result$schema$value ??= z.object({
+  'messageId': z.intersection(z.string(), z.unknown()).readonly(),
+}))
+
+export const TYPERT_REMOTE = {
+  package: '@deepseek-ai/dsh-subagent',
+  descriptors: [
+    {
+      id: '@deepseek-ai/dsh-subagent#subagents/interruptByParent',
+      service: 'subagents',
+      namespace: 'subagents',
+      method: 'interruptByParent',
+      invocation: { kind: 'direct' },
+      parameters: [
+        {
+          name: 'childSessionId',
+          wire: 'childSessionId',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            create: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_0$schema,
+          },
+        },
+        {
+          name: 'parentSessionId',
+          wire: 'parentSessionId',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-session/types#SessionId',
+            create: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_1$schema,
+          },
+        },
+        {
+          name: 'mode',
+          wire: 'mode',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-subagent#subagents/interruptByParent:mode',
+            create: _deepseek_ai_dsh_subagent_subagents_interruptByParent_parameter_2$schema,
+          },
+        },
+      ],
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-subagent/client#SubagentInterruptReceipt',
+        create: _deepseek_ai_dsh_subagent_subagents_interruptByParent_result$schema,
+      },
+      sourceLocation: {"file":"packages/subagent/subagent/src/index.ts","line":483,"column":3},
+    },
+    {
+      id: '@deepseek-ai/dsh-subagent#subagents/prompt',
+      service: 'subagents',
+      namespace: 'subagents',
+      method: 'prompt',
+      invocation: { kind: 'direct' },
+      parameters: [
+        {
+          name: 'request',
+          wire: 'request',
+          source: 'json',
+          codec: {
+            mode: 'strict',
+            typeSymbol: '@deepseek-ai/dsh-subagent/client#SubagentPromptRequest',
+            create: _deepseek_ai_dsh_subagent_subagents_prompt_parameter_0$schema,
+          },
+        },
+      ],
+      cancellation: { parameter: 'signal' },
+      result: {
+        mode: 'strict',
+        typeSymbol: '@deepseek-ai/dsh-subagent/client#SubagentPromptReceipt',
+        create: _deepseek_ai_dsh_subagent_subagents_prompt_result$schema,
+      },
+      sourceLocation: {"file":"packages/subagent/subagent/src/index.ts","line":416,"column":9},
+    },
+  ],
+}
+
+export default TYPERT_REMOTE

package/vendor/subagent-core/types/archive-admission.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The `subagent` family of the Workspace registry's archive admission: which
+ * subagent descendants of a Session are still inside a turn, and how they
+ * stop when the Session is archived with its work.
+ *
+ * @module @deepseek-ai/dsh-subagent
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Answer `workspace/session-activity` with the running subagent descendants of
+ * the asked Session, and `workspace/session-stop` by cancelling each of them
+ * as their parent would. Both listeners live as long as `ctx`'s fiber.
+ * @param ctx - context carrying the Agent registry; the Session query service is optional and only supplies labels.
+ */
+export declare function installSubagentArchiveAdmission(ctx: Context): void;
+//# sourceMappingURL=archive-admission.d.ts.map

package/vendor/subagent-core/types/archive-admission.js

@@ -0,0 +1,151 @@
+/**
+ * The `subagent` family of the Workspace registry's archive admission: which
+ * subagent descendants of a Session are still inside a turn, and how they
+ * stop when the Session is archived with its work.
+ *
+ * @module @deepseek-ai/dsh-subagent
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { foldSubagentDescriptor } from "./descriptor.js";
+/**
+ * Answer `workspace/session-activity` with the running subagent descendants of
+ * the asked Session, and `workspace/session-stop` by cancelling each of them
+ * as their parent would. Both listeners live as long as `ctx`'s fiber.
+ * @param ctx - context carrying the Agent registry; the Session query service is optional and only supplies labels.
+ */
+export function installSubagentArchiveAdmission(ctx) {
+    ctx.on('workspace/session-activity', async ({ sessionId }, next) => {
+        const running = runningDescendants(ctx, sessionId);
+        const rest = await next();
+        if (running.length === 0)
+            return rest;
+        const own = { kind: 'subagent', items: await Promise.all(running.map(child => describe(ctx, child))) };
+        return [own, ...rest];
+    });
+    ctx.on('workspace/session-stop', ({ sessionId }) => {
+        for (const child of runningDescendants(ctx, sessionId)) {
+            try {
+                child.cancel({ kind: 'parent' });
+            }
+            catch (error) {
+                // One child refusing its cancel must not keep its siblings running for an archived parent.
+                ctx.logger.warn(`subagent: cancelling "${child.id}" for an archived Session failed: ${String(error)}`);
+            }
+        }
+    });
+}
+/**
+ * Live subagent descendants inside a turn, by durable lineage: a child whose
+ * header names its parent and carries the subagent origin this package
+ * records, at any depth. A fork shares the lineage field without the origin
+ * and is an independent conversation, so it never holds its source. Lineage
+ * is read as data, so a damaged header chain that loops is visited once.
+ */
+function runningDescendants(ctx, rootId) {
+    const childrenOf = new Map();
+    for (const agent of ctx.agents.list()) {
+        const { parentSession, origin } = agent.session.header;
+        if (parentSession === undefined || origin !== 'subagent')
+            continue;
+        const siblings = childrenOf.get(parentSession) ?? [];
+        siblings.push(agent);
+        childrenOf.set(parentSession, siblings);
+    }
+    const running = [];
+    const pending = [rootId];
+    const visited = new Set();
+    while (pending.length > 0) {
+        const parentId = pending.shift();
+        if (visited.has(parentId))
+            continue;
+        visited.add(parentId);
+        for (const child of childrenOf.get(parentId) ?? []) {
+            if (child.status === 'running')
+                running.push(child);
+            pending.push(child.id);
+        }
+    }
+    return running;
+}
+/**
+ * The child's activity item: its id, plus the durable creation label its
+ * descriptor carries, read through a live Session observation. Without the
+ * Session query service, or with a descriptor that is absent or unreadable,
+ * the item names the child by id alone.
+ */
+async function describe(ctx, child) {
+    const query = ctx.get('sessionQuery');
+    if (query === undefined)
+        return { id: child.id };
+    try {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const observation = __addDisposableResource(env_1, await query.observeSession(child.id, { projectionMode: 'none' }), false);
+            const label = foldSubagentDescriptor(observation.events.slice(observation.inheritedEventCount))?.label;
+            return label === undefined ? { id: child.id } : { id: child.id, label };
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    catch {
+        // A damaged descriptor is data damage in the child; the report still names the child.
+        return { id: child.id };
+    }
+}
+//# sourceMappingURL=archive-admission.js.map

package/vendor/subagent-core/types/assistant-output.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Canonical selection of a child's final assistant output. Backend run results
+ * and `subagent/end.lastAssistantMessage` apply the same rule: select the last
+ * non-empty assistant message. An empty-content message records usage only
+ * when the loop appends it after a max-tokens step with no executable blocks,
+ * so it does not replace earlier output. If no non-empty message exists,
+ * select the accumulated assistant text. Selection is independent of the
+ * run's stop reason.
+ *
+ * @module @deepseek-ai/dsh-subagent/assistant-output
+ */
+import { type ContentBlock } from '@deepseek-ai/dsh-llm';
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+/**
+ * Incremental fold of the selection rule, for backends that observe a child's
+ * output as it streams: session-event backends {@link push} each event, and
+ * transports without session events (ACP content chunks) {@link pushText} raw
+ * text into the same streamed fallback.
+ */
+export declare class AssistantOutputFold {
+    private message;
+    private partial;
+    /**
+     * Fold one session event: a non-empty assistant message becomes the
+     * candidate final answer, while its embedded stream and any log-only attempt
+     * extend the streamed fallback; every other event contributes nothing.
+     * @param event - the next observed session event.
+     */
+    push(event: SessionEvent): void;
+    /**
+     * Extend the streamed fallback with text observed outside session events.
+     * @param text - the next streamed text piece (an empty piece is a no-op).
+     */
+    pushText(text: string): void;
+    /**
+     * Select the final output folded so far.
+     * @returns the last non-empty assistant message, else the accumulated
+     *   streamed text, or `undefined` when the child produced neither.
+     */
+    collect(): readonly ContentBlock[] | undefined;
+}
+/**
+ * Apply the selection rule to one complete child-owned event suffix.
+ * @param events - the child-owned events (after any seed or epoch boundary).
+ * @returns the selected output, or `undefined` when the child produced none.
+ */
+export declare function finalAssistantOutput(events: readonly SessionEvent[]): readonly ContentBlock[] | undefined;
+//# sourceMappingURL=assistant-output.d.ts.map

package/vendor/subagent-core/types/assistant-output.js

@@ -0,0 +1,73 @@
+/**
+ * Canonical selection of a child's final assistant output. Backend run results
+ * and `subagent/end.lastAssistantMessage` apply the same rule: select the last
+ * non-empty assistant message. An empty-content message records usage only
+ * when the loop appends it after a max-tokens step with no executable blocks,
+ * so it does not replace earlier output. If no non-empty message exists,
+ * select the accumulated assistant text. Selection is independent of the
+ * run's stop reason.
+ *
+ * @module @deepseek-ai/dsh-subagent/assistant-output
+ */
+import { joinAssistantStreamText } from '@deepseek-ai/dsh-llm';
+/**
+ * Incremental fold of the selection rule, for backends that observe a child's
+ * output as it streams: session-event backends {@link push} each event, and
+ * transports without session events (ACP content chunks) {@link pushText} raw
+ * text into the same streamed fallback.
+ */
+export class AssistantOutputFold {
+    message;
+    partial = [];
+    /**
+     * Fold one session event: a non-empty assistant message becomes the
+     * candidate final answer, while its embedded stream and any log-only attempt
+     * extend the streamed fallback; every other event contributes nothing.
+     * @param event - the next observed session event.
+     */
+    push(event) {
+        if (event.type === 'assistant/message') {
+            const content = event.data.message.content;
+            if (content.length > 0)
+                this.message = content;
+        }
+        if (event.type === 'assistant/message' || event.type === 'assistant/attempt') {
+            this.pushText(joinAssistantStreamText(event.data.stream));
+        }
+    }
+    /**
+     * Extend the streamed fallback with text observed outside session events.
+     * @param text - the next streamed text piece (an empty piece is a no-op).
+     */
+    pushText(text) {
+        if (text.length > 0)
+            this.partial.push(text);
+    }
+    /**
+     * Select the final output folded so far.
+     * @returns the last non-empty assistant message, else the accumulated
+     *   streamed text, or `undefined` when the child produced neither.
+     */
+    collect() {
+        if (this.message !== undefined)
+            return this.message;
+        const text = this.partial.join('');
+        return text.length > 0 ? [{ type: 'text', text }] : undefined;
+    }
+}
+/**
+ * Apply the selection rule to one complete child-owned event suffix.
+ * @param events - the child-owned events (after any seed or epoch boundary).
+ * @returns the selected output, or `undefined` when the child produced none.
+ */
+export function finalAssistantOutput(events) {
+    // TODO: this folds the complete suffix once per run/epoch settlement. If a
+    // long continuable epoch ever profiles hot here, scan backward with early
+    // exit for the last non-empty message and fold text deltas only on the
+    // no-message fallback.
+    const fold = new AssistantOutputFold();
+    for (const event of events)
+        fold.push(event);
+    return fold.collect();
+}
+//# sourceMappingURL=assistant-output.js.map

package/vendor/subagent-core/types/catalog.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Parent-owned durable subagent catalog events and their chunked projection.
+ *
+ * @module @deepseek-ai/dsh-subagent/catalog
+ */
+import { z } from 'zod';
+import type { ChunkedList } from '@deepseek-ai/dsh-chunked-list';
+import type { Session, SessionEvent, SessionHeader, SessionId, SessionLogOffset } from '@deepseek-ai/dsh-session';
+import type { SubagentCatalogEntry } from './projection-types.ts';
+/** Catalog payload version emitted by live child creation. */
+export declare const SUBAGENT_CATALOG_VERSION = 0;
+type KnownCatalogMode = {
+    readonly mode: 'one-shot';
+    readonly label?: string;
+} | {
+    readonly mode: 'continuable';
+    readonly label: string;
+};
+/** Parent catalog v0 records known modes; v1 also retains children with unknown mode. */
+export type SubagentCatalogEvent = {
+    readonly childId: SessionId;
+    readonly childCreatedAt: number;
+} & (({
+    readonly version: 0;
+} & KnownCatalogMode) | ({
+    readonly version: 1;
+} & (KnownCatalogMode | {
+    readonly mode: 'unknown';
+    readonly label?: string;
+})));
+declare module '@deepseek-ai/dsh-session/types' {
+    interface SessionEventMap {
+        /**
+         * A direct child's identity and available discovery fields.
+         * @param data - versioned parent-owned catalog entry.
+         */
+        'subagent/catalog': SubagentCatalogEvent;
+    }
+}
+/** Host fold state for one parent catalog. */
+export interface SubagentCatalogState {
+    readonly inheritedEventCount: SessionLogOffset;
+    readonly head?: ChunkedList<SubagentCatalogEvent> | undefined;
+}
+declare module '@deepseek-ai/dsh-session-projection/types' {
+    interface SessionProjectionStateMap {
+        subagentCatalog: SubagentCatalogState;
+    }
+}
+/**
+ * Materialize complete and unknown-mode child identities from parent catalog events.
+ * @param state - parent catalog fold state.
+ * @returns current direct-child rows in parent catalog event order.
+ */
+declare function subagentCatalogEntries(state: SubagentCatalogState): SubagentCatalogEntry[];
+/** Parent-owned direct-child catalog projection; invalid own facts reject restoration. */
+export declare const subagentCatalogProjectionDefinition: {
+    key: "subagentCatalog";
+    stateSchema: z.ZodType<SubagentCatalogState, unknown, z.core.$ZodTypeInternals<SubagentCatalogState, unknown>>;
+    init: (_header: SessionHeader, inheritedEventCount: SessionLogOffset) => {
+        inheritedEventCount: SessionLogOffset;
+    };
+    apply: (state: NoInfer<SubagentCatalogState>, event: SessionEvent) => SubagentCatalogState;
+    stateVersion: number;
+    wire: {
+        viewSchema: z.ZodType<SubagentCatalogEntry[], unknown, z.core.$ZodTypeInternals<SubagentCatalogEntry[], unknown>>;
+        view: typeof subagentCatalogEntries;
+    };
+};
+/**
+ * Append a complete direct-child discovery fact to its parent Session.
+ * @param parent - durable direct parent receiving the discovery fact.
+ * @param child - established child's immutable Session metadata.
+ * @param descriptor - mode-discriminated creation label frozen with the child.
+ */
+export declare function establishCatalogChild(parent: Session, child: SessionHeader, descriptor: {
+    readonly mode: 'one-shot';
+    readonly label?: string;
+} | {
+    readonly mode: 'continuable';
+    readonly label: string;
+}): void;
+export {};
+//# sourceMappingURL=catalog.d.ts.map

package/vendor/subagent-core/types/catalog.js

@@ -0,0 +1,109 @@
+/**
+ * Parent-owned durable subagent catalog events and their chunked projection.
+ *
+ * @module @deepseek-ai/dsh-subagent/catalog
+ */
+import { z } from 'zod';
+import { appendChunkedList, chunkedListSchema, iterateChunkedList } from '@deepseek-ai/dsh-chunked-list';
+/** Catalog payload version emitted by live child creation. */
+export const SUBAGENT_CATALOG_VERSION = 0;
+const sessionIdSchema = z.string();
+const oneShotCatalogSchema = z.object({
+    version: z.union([z.literal(0), z.literal(1)]),
+    childId: sessionIdSchema,
+    childCreatedAt: z.number().int().nonnegative(),
+    mode: z.literal('one-shot'),
+    label: z.string().optional(),
+}).strict();
+const continuableCatalogSchema = z.object({
+    version: z.union([z.literal(0), z.literal(1)]),
+    childId: sessionIdSchema,
+    childCreatedAt: z.number().int().nonnegative(),
+    mode: z.literal('continuable'),
+    label: z.string(),
+}).strict();
+const unknownCatalogSchema = oneShotCatalogSchema.extend({ version: z.literal(1), mode: z.literal('unknown') });
+const eventDataSchema = z.union([
+    oneShotCatalogSchema,
+    continuableCatalogSchema,
+    unknownCatalogSchema,
+]);
+const viewSchema = z.array(z.union([
+    oneShotCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+        id: sessionIdSchema,
+        createdAt: oneShotCatalogSchema.shape.childCreatedAt,
+    }),
+    continuableCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+        id: sessionIdSchema,
+        createdAt: continuableCatalogSchema.shape.childCreatedAt,
+    }),
+    unknownCatalogSchema.omit({ version: true, childId: true, childCreatedAt: true }).extend({
+        id: sessionIdSchema,
+        createdAt: unknownCatalogSchema.shape.childCreatedAt,
+    }),
+]));
+const stateSchema = z.object({
+    inheritedEventCount: z.number().int().nonnegative(),
+    head: chunkedListSchema(eventDataSchema).optional(),
+}).strict();
+/**
+ * Materialize complete and unknown-mode child identities from parent catalog events.
+ * @param state - parent catalog fold state.
+ * @returns current direct-child rows in parent catalog event order.
+ */
+function subagentCatalogEntries(state) {
+    const entries = [];
+    for (const data of iterateChunkedList(state.head)) {
+        entries.push(data.mode !== 'continuable'
+            ? {
+                id: data.childId,
+                createdAt: data.childCreatedAt,
+                mode: data.mode,
+                ...data.label === undefined ? {} : { label: data.label },
+            }
+            : {
+                id: data.childId,
+                createdAt: data.childCreatedAt,
+                mode: data.mode,
+                label: data.label,
+            });
+    }
+    return entries;
+}
+/** Parent-owned direct-child catalog projection; invalid own facts reject restoration. */
+export const subagentCatalogProjectionDefinition = {
+    key: 'subagentCatalog',
+    stateSchema,
+    init: (_header, inheritedEventCount) => ({ inheritedEventCount }),
+    apply: (state, event) => {
+        if (event.type !== 'subagent/catalog' || event.seq < state.inheritedEventCount)
+            return state;
+        return { ...state, head: appendChunkedList(state.head, eventDataSchema.parse(event.data)) };
+    },
+    stateVersion: 3,
+    wire: { viewSchema, view: subagentCatalogEntries },
+};
+/**
+ * Append a complete direct-child discovery fact to its parent Session.
+ * @param parent - durable direct parent receiving the discovery fact.
+ * @param child - established child's immutable Session metadata.
+ * @param descriptor - mode-discriminated creation label frozen with the child.
+ */
+export function establishCatalogChild(parent, child, descriptor) {
+    parent.append('subagent/catalog', descriptor.mode === 'one-shot'
+        ? {
+            version: SUBAGENT_CATALOG_VERSION,
+            childId: child.id,
+            childCreatedAt: child.createdAt,
+            mode: descriptor.mode,
+            ...descriptor.label === undefined ? {} : { label: descriptor.label },
+        }
+        : {
+            version: SUBAGENT_CATALOG_VERSION,
+            childId: child.id,
+            childCreatedAt: child.createdAt,
+            mode: descriptor.mode,
+            label: descriptor.label,
+        });
+}
+//# sourceMappingURL=catalog.js.map