@morlay/ui-conversation-manager 0.0.2-alpha.5 → 0.0.2-alpha.7

package/dist/client.d.cts

@@ -93,6 +93,30 @@ type Scoped<T extends object> = object & {
   readonly [ScopedBrand]: T;
 };
 //#endregion
+//#region ../../../vendor/deepseek-harness/packages/util/brand/lib/types/index.d.ts
+/**
+ * Duplicate-install-safe nominal primitive helpers.
+ *
+ * A brand makes structurally identical strings or numbers non-interchangeable
+ * at the type level: a `SessionId` cannot be passed where a `ToolCallId` is
+ * expected, and an event sequence cannot be passed as a log offset. Comparison,
+ * logging, and serialization retain the underlying primitive behavior.
+ *
+ * This package owns no concrete domain value and keeps no runtime identity or mutable
+ * state, so independently installed copies produce interchangeable values.
+ *
+ * @module @deepseek-ai/dsh-brand
+ */
+declare const BRAND: unique symbol;
+/** A string carrying a compile-time-only brand `B`. */
+type Branded<B extends string> = string & {
+  readonly [BRAND]: B;
+};
+/** A number carrying a compile-time-only brand `B`. */
+type BrandedNumber<B extends string> = number & {
+  readonly [BRAND]: B;
+};
+//#endregion
 //#region ../../../vendor/deepseek-harness/packages/typert/protocol/lib/types/owned-value.d.ts
 /** Generic invocation-owned values returned by synchronous Client Context resolvers. */
 /** Shared identity across independently bundled Context providers and Gateway. */
@@ -144,6 +168,19 @@ type TypertCodec = {
   readonly typeSymbol: string;
   /** Materialize and return the process-realm schema on first boundary use. */
   readonly create: () => TypertSchema;
+  /**
+   * Decode a unary result whose fields require type-specific handling.
+   * @param value - result reconstructed by the RPC carrier.
+   * @returns the validated result, retaining native byte views.
+   */
+  readonly decode?: (value: unknown) => unknown;
+  /**
+   * Project typed binary fields into RPC result attachments.
+   * @param value - native unary result.
+   * @param writeBytes - records a byte view at its result-relative path and returns its JSON placeholder.
+   * @returns JSON metadata with untouched JSON subtrees retained.
+   */
+  readonly encode?: (value: unknown, writeBytes: (bytes: Uint8Array, path: readonly (string | number)[]) => null) => unknown;
 } | {
   readonly mode: 'src-json';
 };
@@ -180,7 +217,7 @@ interface InvocationDescriptor {
   readonly method: string;
   /** Service member invoked when the exported method name is an alias. */
   readonly implementation?: string;
-  /** Absent for unary calls; stream calls validate and deliver every yielded item. */
+  /** Absent for unary calls; stream calls deliver every yielded item as the Host produced it. */
   readonly mode?: 'stream';
   /** Receiver selection mode. */
   readonly invocation: {
@@ -200,6 +237,16 @@ interface InvocationDescriptor {
   };
   /** Ordered business parameters. */
   readonly parameters: readonly InvocationParameterDescriptor[];
+  /**
+   * Client-to-Host items of the same logical stream, generated from the `In`
+   * type argument of the method's `RemoteStream<Out, In>` return type; absent
+   * when `In` is `never`. The method reads the items through
+   * `RemoteInvocation.uplink()`, so nothing enters the parameter list.
+   */
+  readonly uplink?: {
+    /** Codec validating every uplink item before `uplink()` delivers it. */
+    readonly codec: TypertCodec;
+  };
   /** Transport cancellation injected after business parameters instead of entering wire args. */
   readonly cancellation?: {
     /** Reserved final Host method parameter. */
@@ -210,6 +257,56 @@ interface InvocationDescriptor {
   /** Source declaration used only for diagnostics. */
   readonly sourceLocation?: InvocationSourceLocation;
 }
+/**
+ * Opaque identity of one Peer: a party admitted to this Host by the connection
+ * layer. "Peer" is a connection-layer word; the browser application keeps the
+ * word "Client".
+ */
+type PeerId = Branded<'PeerId'>;
+/**
+ * One Peer's session on this Host. Connection owns it: `ctx` is the Cordis
+ * scope that owns connection-lifetime registrations and is disposed with the
+ * Peer. Who the Peer is and what it may do are not recorded here.
+ */
+interface PeerScope {
+  readonly id: PeerId;
+  readonly ctx: Context;
+  /**
+   * Tear down every registration made through `ctx`.
+   * @returns settles once the scope has quiesced; racing calls share one completion.
+   */
+  dispose(): Promise<void>;
+}
+/**
+ * The context of one Remote call, reachable inside the receiving method as
+ * `this.ctx.invocation`. The Gateway derives the receiver from a Context that
+ * carries it, so no parameter is injected and nothing crosses the wire.
+ */
+interface RemoteInvocation {
+  readonly request: {
+    readonly namespace: string;
+    readonly method: string;
+    readonly args: Readonly<Record<string, unknown>>;
+  };
+  /** Cordis service key of the receiving Service. */
+  readonly service: string;
+  /** Peer the call speaks for; an in-process carrier speaks for the operator. */
+  readonly peer: PeerScope;
+  /** Carrier cancellation: Client cancel, socket close, or an uplink failure. */
+  readonly signal: AbortSignal;
+  /**
+   * The Client's uplink items for this call. Available once; a second call
+   * throws. With an uplink codec on the descriptor every item is decoded to
+   * `In`; without one items arrive as `unknown` after a JSON-safety check.
+   * Iteration ends when the Client ends its uplink; when the method finishes
+   * its downlink the Gateway calls the iterator's `return()` and unread items
+   * are dropped. `In` is the caller's assertion: the runtime decodes by the
+   * descriptor and does not cross-check it.
+   * @template In - item type the caller reads; the descriptor codec decides what arrives.
+   * @returns the single-consumer uplink iterable.
+   */
+  uplink<In = unknown>(): AsyncIterable<In>;
+}
 /** Generated Host contract selected explicitly by a Client assembly. */
 interface TypertRemoteContribution {
   /** npm package that owns the Remote methods. */
@@ -423,6 +520,12 @@ interface TypertRegistryContract {
 declare module '@deepseek-ai/cordis' {
   interface Context {
     typert: TypertRegistryContract;
+    /**
+     * The Remote call this Context was derived for, or `undefined` on a
+     * Context no Remote call derived. A Service method reads it as
+     * `this.ctx.invocation`.
+     */
+    readonly invocation: RemoteInvocation | undefined;
   }
 }
 //#endregion
@@ -451,30 +554,6 @@ declare abstract class TypertRemoteService<out T = never> extends Service<T> {
   protected constructor(ctx: Context, serviceKey: string, options?: TypertGatewayBindingOptions);
 }
 //#endregion
-//#region ../../../vendor/deepseek-harness/packages/util/brand/lib/types/index.d.ts
-/**
- * Duplicate-install-safe nominal primitive helpers.
- *
- * A brand makes structurally identical strings or numbers non-interchangeable
- * at the type level: a `SessionId` cannot be passed where a `ToolCallId` is
- * expected, and an event sequence cannot be passed as a log offset. Comparison,
- * logging, and serialization retain the underlying primitive behavior.
- *
- * This package owns no concrete domain value and keeps no runtime identity or mutable
- * state, so independently installed copies produce interchangeable values.
- *
- * @module @deepseek-ai/dsh-brand
- */
-declare const BRAND: unique symbol;
-/** A string carrying a compile-time-only brand `B`. */
-type Branded<B extends string> = string & {
-  readonly [BRAND]: B;
-};
-/** A number carrying a compile-time-only brand `B`. */
-type BrandedNumber<B extends string> = number & {
-  readonly [BRAND]: B;
-};
-//#endregion
 //#region ../../../vendor/deepseek-harness/packages/attachment/attachment/lib/types/error.d.ts
 declare const ATTACHMENT_ERROR_CODES: readonly ["TOO_MANY_IMAGES", "IMAGES_TOO_LARGE", "UNSUPPORTED_IMAGE_TYPE", "INVALID_IMAGE_BASE64", "INVALID_IMAGE", "IMAGE_TYPE_MISMATCH", "IMAGE_TOO_LARGE", "IMAGE_TOO_MANY_PIXELS", "IMAGE_DIMENSION_TOO_LARGE", "INVALID_FILE_BASE64", "INVALID_ATTACHMENT_REF", "ATTACHMENT_CORRUPT", "ATTACHMENT_WRITE_FAILED", "ATTACHMENT_NOT_FOUND", "ATTACHMENT_READ_FAILED", "ATTACHMENT_PROJECTION_UNSUPPORTED", "ATTACHMENT_FILES_UNSUPPORTED"];
 /** Stable attachment failure codes used for protocol error routing. */
@@ -837,98 +916,84 @@ interface AssistantProviderMetadata {
 interface ModelMessageSource extends AssistantProviderMetadata {
   kind: 'model';
 }
-/** Required source of a user-role message carrying one tool result. */
+/** Required source of a tool-role message carrying one tool result. */
 interface ToolMessageSource {
   kind: 'tool';
   callId: ToolCallId;
 }
-/** One named contribution to a `snapshot`-form context, in assembly order. */
-interface ContextSnapshotSection {
-  /** The contributing subsystem's name. */
-  readonly name: string;
-  /** That contribution's model-facing text, exactly as assembled. */
-  readonly text: string;
+/** Required source of a system-role message produced by the system-prompt plugin. */
+interface SystemPromptMessageSource {
+  kind: 'system-prompt';
 }
 /**
- * Producer-declared {@link ContextForm} and the fields that form requires,
- * mixed into the source types that carry one.
- *
- * Discriminated by `form` so a producer cannot select a form without the
- * fields needed to present it: a `notice` must record its one-line
- * account, a `snapshot` its sections. Omitting `form` stays valid — an
- * undeclared context is the documented default.
- */
-type ContextFormed = {
-  readonly form?: never;
-} | {
-  readonly form: 'instructions';
-} | {
-  readonly form: 'catalog';
-} | {
-  readonly form: 'snapshot';
-  /** The named contributions this snapshot assembled, in order. */
-  readonly sections: readonly ContextSnapshotSection[];
-} | {
-  readonly form: 'notice';
-  /** One-line account of what happened, shown without expanding the row. */
-  readonly summary: string;
-} | {
-  readonly form: 'relay';
-} | {
-  readonly form: 'recall';
-};
-/**
- * Where a message (or injected content) came from.
- * Merge-extensible sum type — plugins add their own `kind`s.
+ * Where a message (or injected content) came from, in the harness's own
+ * vocabulary. Merge-extensible sum type — each producer declares its own
+ * `kind` in its own module; there is no shared catch-all `plugin` kind.
+ * Model and tool sources answer their role messages; user messages carry any
+ * producer's kind, and consumers fall through unknown kinds.
  */
 interface MessageSourceMap {
   user: {
     kind: 'user';
   };
-  plugin: {
-    kind: 'plugin';
-    plugin: string;
-  } & ContextFormed;
   model: ModelMessageSource;
   tool: ToolMessageSource;
+  'system-prompt': SystemPromptMessageSource;
 }
 /** Any known message source, derived from {@link MessageSourceMap}; switch on `kind` and fall through unknowns (merge-extensible). */
 type MessageSource = MessageSourceMap[keyof MessageSourceMap];
-/** One immutable message representation shared by delivery, durable history, and model requests. */
-interface Message {
+/** Shared immutable fields of every conversation message. */
+interface MessageBase {
   /** Stable identity preserved across every representation boundary. */
   readonly id: MessageId;
-  /** Provider-neutral conversation role. */
-  readonly role: 'system' | 'user' | 'assistant';
   /** Exact model-facing blocks. */
-  readonly content: ContentBlock[];
-  /** Required source fields supplied by the producer. */
+  readonly content: readonly ContentBlock[];
+  /** Required source fields supplied by the producer.
+   * @persistenceSource user developer
+   */
   readonly source: MessageSource;
 }
-/** A user-role specialization of the one shared message representation. */
-interface UserMessage extends Message {
+/** A rendered system prompt attributed to the system-prompt producer; empty content sends no prompt. */
+interface SystemMessage extends MessageBase {
+  readonly role: 'system';
+  readonly source: MessageSourceMap['system-prompt'];
+}
+/** Incremental agent session changes in conversation order, currently tool additions and removals. */
+interface DeveloperMessage extends MessageBase {
+  readonly role: 'developer';
+}
+/** A user-role specialization of the shared message representation. */
+interface UserMessage extends MessageBase {
   readonly role: 'user';
 }
 /** A model-produced assistant specialization of the shared message representation. */
-interface AssistantMessage extends Message {
+interface AssistantMessage extends MessageBase {
   readonly role: 'assistant';
   readonly source: ModelMessageSource;
 }
-/**
- * A system-role specialization of the shared message representation: one
- * rendered system prompt attributed to the plugin that assembled it. Empty
- * `content` means "no system prompt" and projects to no wire message.
- */
-interface SystemMessage extends Message {
-  readonly role: 'system';
-  readonly source: MessageSourceMap['plugin'];
-}
-/** A tool-result specialization whose model-facing block retains call correlation. */
-interface ToolResultMessage extends Message {
-  readonly role: 'user';
-  readonly content: [ToolResultBlock];
+/** A first-class tool-role message carrying the result of one tool invocation. */
+interface ToolResultMessage extends MessageBase {
+  readonly role: 'tool';
   readonly source: ToolMessageSource;
+  /** Provider-issued id of the tool call this message answers. */
+  readonly toolCallId: ToolCallId;
+  /** Whether the tool invocation failed. */
+  readonly isError?: boolean;
 }
+/**
+ * The conversation messages persisted by Session, keyed by role. This map is
+ * closed because every model-visible role must have a durable Session event
+ * and an adapter projection.
+ */
+interface MessageRoleMap {
+  system: SystemMessage;
+  developer: DeveloperMessage;
+  user: UserMessage;
+  assistant: AssistantMessage;
+  tool: ToolResultMessage;
+}
+/** Any persisted conversation message, discriminated by its `role`. */
+type Message = MessageRoleMap[keyof MessageRoleMap];
 //#endregion
 //#region ../../../vendor/deepseek-harness/packages/llm/llm/lib/types/types.d.ts
 declare module '@deepseek-ai/cordis' {
@@ -1013,16 +1078,27 @@ interface ToolCallBlock {
   /** Raw JSON string as produced by the model. */
   arguments: string;
 }
-/** The result of a tool invocation, sent back to the model. */
-interface ToolResultBlock {
-  type: 'tool-result';
-  toolCallId: ToolCallId;
-  content: ContentBlock[];
-  isError?: boolean;
+/** Activates a tool definition from the developer event's referenced request header. */
+interface ToolAdditionBlock {
+  type: 'tool-addition';
+  /** Name of exactly one tool in the referenced historical header. */
+  toolName: string;
+  /**
+   * Reserved against inline definitions; the historical request header owns the schema.
+   * @persistenceReserved
+   */
+  tool?: never;
+}
+/** Records the dynamic removal of a tool identified by its session-local name. */
+interface ToolRemovalBlock {
+  type: 'tool-removal';
+  toolName: string;
 }
 /**
  * Merge-extensible content blocks keyed by `type`. New core blocks must land
- * with adapter, UI, and compaction support.
+ * with adapter, UI, and compaction support. Developer tool-change blocks are
+ * reserved for Session V4 persistence; providers and UI reject them until
+ * their producers and consumers are implemented together.
  */
 interface ContentBlockMap {
   'text': TextBlock;
@@ -1030,7 +1106,8 @@ interface ContentBlockMap {
   'image': ImageBlock;
   'file': FileBlock;
   'tool-call': ToolCallBlock;
-  'tool-result': ToolResultBlock;
+  'tool-addition': ToolAdditionBlock;
+  'tool-removal': ToolRemovalBlock;
 }
 /** The block `type` tag vocabulary; widens as plugins add entries to {@link ContentBlockMap}. */
 type ContentBlockType = keyof ContentBlockMap;
@@ -1329,11 +1406,26 @@ type StreamChunk = {
  * it from this package.
  */
 interface ToolSchema {
+  /**
+   * Requests deferred loading of the tool definition into model context,
+   * independently of whether a tool-addition block records the tool.
+   * Uses Anthropic's defer_loading terminology.
+   */
+  deferLoading?: true;
   name: string;
   description: string;
   /** JSON Schema object for the arguments. */
   parameters: Record<string, unknown>;
 }
+/** User input for one LLM request; it has no durable Session identity or source. */
+interface RequestUserInput {
+  readonly role: 'user';
+  readonly content: UserMessage['content'];
+  readonly id?: never;
+  readonly source?: never;
+}
+/** A durable conversation message or a user input used only for one request. */
+type RequestMessage = Message | RequestUserInput;
 /** A single model request, fully assembled. */
 interface GenerateOptions {
   /** Registered provider route selecting the adapter instance. */
@@ -1345,9 +1437,9 @@ interface GenerateOptions {
    * Ordered conversation messages, exactly as the provider sees them. A
    * loop-built request passes the derived history (dsh-agent-loop), whose
    * leading system-role message carries the system prompt; a hand-built
-   * one-shot passes any list.
+   * one-shot may include identity-free user inputs.
    */
-  messages: Message[];
+  messages: RequestMessage[];
   /**
    * System prompt text for one-shot callers; adapters map it to the provider's
    * system slot ahead of `messages`. Loop-built requests leave it undefined.
@@ -1396,6 +1488,16 @@ declare namespace Binary {
 /** String/symbol keyed dictionary type. */
 type Dict<T = any, K extends string | symbol = string> = { [key in K]: T; };
 //#endregion
+//#region ../../../vendor/deepseek-harness/vendor/cosmokit/lib/types/volatile.d.ts
+/** Shared config references used by schema validators and plugin runtimes. */
+/** Recursively readonly data returned by a volatile config reference. */
+type VolatileSnapshot<T> = T extends object ? { readonly [K in keyof T]: VolatileSnapshot<T[K]>; } : T;
+/** A stable reference; keep the reference, or capture its value for one operation only. */
+interface Volatile<T> {
+  /** @returns the current immutable snapshot, including undefined for an absent value. */
+  get(): VolatileSnapshot<T>;
+}
+//#endregion
 //#region ../../../node_modules/.pnpm/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec/dist/index.d.ts
 /** The Standard Typed interface. This is a base type extended by other specs. */
 interface StandardTypedV1<Input = unknown, Output = Input> {
@@ -1478,9 +1580,9 @@ declare const kSchema: unique symbol;
 declare global {
   namespace Schemastery {
     /** Convert primitive constructors, constants, and existing schemas into a schema type. */
-    type From<X> = X extends string | number | boolean ? Schema<X> : X extends Schema ? X : X extends typeof String ? Schema<string> : X extends typeof Number ? Schema<number> : X extends typeof Boolean ? Schema<boolean> : X extends typeof Function ? Schema<Function, (...args: any[]) => any> : X extends Constructor<infer S> ? Schema<S> : never;
-    type TypeS1<X> = X extends Schema<infer S, unknown> ? S : never;
-    type Inverse<X> = X extends Schema<any, infer Y> ? (arg: Y) => void : never;
+    type From<X> = X extends string | number | boolean ? Schema<X> : X extends Schema<any, any, SchemaMode> ? X : X extends typeof String ? Schema<string> : X extends typeof Number ? Schema<number> : X extends typeof Boolean ? Schema<boolean> : X extends typeof Function ? Schema<Function, (...args: any[]) => any> : X extends Constructor<infer S> ? Schema<S> : never;
+    type TypeS1<X> = X extends Schema<infer S, infer _T, infer _M> ? S : never;
+    type Inverse<X> = X extends Schema<infer _S, infer T, infer M> ? (arg: SchemaOutput<T, M>) => void : never;
     /** Input type accepted by a schema-like value. */
     type TypeS<X> = TypeS1<From<X>>;
     /** Output type returned by a schema-like value after validation. */
@@ -1488,7 +1590,7 @@ declare global {
     /** Resolver callback used by custom schema types registered with `Schema.extend()`. */
     type Resolve = (data: any, schema: Schema, options: Options, strict?: boolean) => [any, any?];
     /** Input type accepted by one schema in an intersection. */
-    type IntersectS<X> = From<X> extends Schema<infer S, unknown> ? S : never;
+    type IntersectS<X> = From<X> extends Schema<infer S, infer _T, infer _M> ? S : never;
     /** Output type returned by one schema in an intersection. */
     type IntersectT<X> = Inverse<From<X>> extends ((arg: infer T) => void) ? T : never;
     type TupleS<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeS<L>?, ...TupleS<R>] : any[];
@@ -1543,8 +1645,8 @@ declare global {
       dict<X, Y extends Schema<any, string> = Schema<string>>(inner: X, sKey?: Y): Schema<Dict<TypeS<X>, TypeS<Y>>, Dict<TypeT<X>, TypeT<Y>>>;
       /** Accept tuple arrays where each index matches the corresponding schema. */
       tuple<const X extends readonly any[]>(list: X): Schema<TupleS<X>, TupleT<X>>;
-      /** Accept plain objects whose declared properties match the schema dictionary. */
-      object<X extends Dict>(dict: X): Schema<ObjectS<X>, ObjectT<X>>;
+      /** Accept plain objects; infer fields from the dictionary, not the enclosing schema's output type. */
+      object<X extends Dict>(dict: X): Schema<ObjectS<NoInfer<X>>, ObjectT<NoInfer<X>>>;
       /** Accept values matching at least one schema in `list`. */
       union<const X>(list: readonly X[]): Schema<TypeS<X>, TypeT<X>>;
       /** Accept values matching every schema in `list`, merging object outputs. */
@@ -1552,7 +1654,7 @@ declare global {
       /** Validate with `inner`, then convert the result with `callback`. */
       transform<X, T>(inner: X, callback: (value: TypeS<X>, options: Schemastery.Options) => T, preserve?: boolean): Schema<TypeS<X>, T>;
       /** Defer construction of a recursive schema until validation or serialization. */
-      lazy<X extends Schema>(callback: () => X): X;
+      lazy<X extends Schema<any, any, SchemaMode>>(callback: () => X): X;
       ValidationError: typeof ValidationError;
     }
     /** Runtime validation options shared by all schema calls. */
@@ -1568,6 +1670,8 @@ declare global {
     interface Meta<T = any> {
       default?: T extends {} ? Partial<T> : T;
       required?: boolean;
+      /** Parse this node as a stable config reference; its type and UI metadata remain unchanged. */
+      volatile?: boolean;
       disabled?: boolean;
       collapse?: boolean;
       badges?: {
@@ -1591,9 +1695,9 @@ declare global {
     }
   }
   /** Callable schema instance that validates input and returns normalized output. */
-  interface Schemastery<S = any, T = S> {
-    (data?: S | null, options?: Schemastery.Options): T;
-    new (data?: S | null, options?: Schemastery.Options): T;
+  interface Schemastery<S = any, T = S, Mode extends SchemaMode = 'plain'> {
+    (data?: S | null, options?: Schemastery.Options): SchemaOutput<T, Mode>;
+    new (data?: S | null, options?: Schemastery.Options): SchemaOutput<T, Mode>;
     [kSchema]: true;
     uid: number;
     meta: Schemastery.Meta<T>;
@@ -1613,49 +1717,54 @@ declare global {
     /** Format this schema as a compact TypeScript-like type string. */
     toString(inline?: boolean): string;
     /** Serialize this schema, preserving shared and recursive references. */
-    toJSON(): Schema<S, T>;
+    toJSON(): Schema<S, T, Mode>;
     /** Mark nullable input as invalid unless a default supplies a fallback. */
-    required(value?: boolean): Schema<S, T>;
+    required<R extends boolean = true>(value?: R): Schema<S, T, SetRequired<Mode, R>>;
+    /**
+     * Parse this config field as a stable reference containing immutable data.
+     * @returns a schema whose output supports get(), including when the field is absent.
+     */
+    volatile(): Schema<NoInfer<S>, NoInfer<T>, Mode extends 'defined' | 'volatile-defined' ? 'volatile-defined' : 'volatile'>;
     /** Hide this schema node from UI renderers. */
-    hidden(value?: boolean): Schema<S, T>;
+    hidden(value?: boolean): Schema<S, T, Mode>;
     /** Return the default value instead of throwing when validation fails. */
-    loose(value?: boolean): Schema<S, T>;
+    loose(value?: boolean): Schema<S, T, Mode>;
     /** Attach a renderer role and optional role-specific metadata. */
-    role(text: string, extra?: any): Schema<S, T>;
+    role(text: string, extra?: any): Schema<S, T, Mode>;
     /** Attach an external documentation link. */
-    link(link: string): Schema<S, T>;
+    link(link: string): Schema<S, T, Mode>;
     /** Set the fallback value used for nullable input. */
-    default(value: T): Schema<S, T>;
+    default(value: T | NoInfer<Partial<S>>): Schema<S, T, SetRequired<Mode, true>>;
     /** Attach an auxiliary comment for documentation or form UIs. */
-    comment(text: string): Schema<S, T>;
+    comment(text: string): Schema<S, T, Mode>;
     /** Attach a localized or plain description for documentation or form UIs. */
-    description(text: string): Schema<S, T>;
+    description(text: string): Schema<S, T, Mode>;
     /** Mark this schema node as disabled for form UIs. */
-    disabled(value?: boolean): Schema<S, T>;
+    disabled(value?: boolean): Schema<S, T, Mode>;
     /** Request collapsed rendering for nested form UIs. */
-    collapse(value?: boolean): Schema<S, T>;
+    collapse(value?: boolean): Schema<S, T, Mode>;
     /** Add a deprecated badge to this schema node. */
-    deprecated(): Schema<S, T>;
+    deprecated(): Schema<S, T, Mode>;
     /** Add an experimental badge to this schema node. */
-    experimental(): Schema<S, T>;
+    experimental(): Schema<S, T, Mode>;
     /** Require strings to match a regular expression. */
-    pattern(regexp: RegExp): Schema<S, T>;
+    pattern(regexp: RegExp): Schema<S, T, Mode>;
     /** Set an inclusive maximum for numbers or collection lengths. */
-    max(value: number): Schema<S, T>;
+    max(value: number): Schema<S, T, Mode>;
     /** Set an inclusive minimum for numbers or collection lengths. */
-    min(value: number): Schema<S, T>;
+    min(value: number): Schema<S, T, Mode>;
     /** Set the numeric increment constraint. */
-    step(value: number): Schema<S, T>;
+    step(value: number): Schema<S, T, Mode>;
     /** Add or replace an object property schema. */
-    set(key: string, value: Schema): Schema<S, T>;
+    set(key: string, value: Schema): Schema<S, T, Mode>;
     /** Append a tuple, union, or intersection member schema. */
-    push(value: Schema): Schema<S, T>;
+    push(value: Schema): Schema<S, T, Mode>;
     /** Remove values equal to schema defaults from normalized output. */
     simplify(value?: any): any;
     /** Return a schema clone with descriptions merged from locale messages. */
-    i18n(messages: Dict): Schema<S, T>;
+    i18n(messages: Dict): Schema<S, T, Mode>;
     /** Attach arbitrary metadata consumed by form renderers and downstream tools. */
-    extra<K extends keyof Schemastery.Meta>(key: K, value: Schemastery.Meta[K]): Schema<S, T>;
+    extra<K extends keyof Schemastery.Meta>(key: K, value: Schemastery.Meta[K]): Schema<S, T, Mode>;
   }
 }
 declare class ValidationError extends TypeError {
@@ -1664,7 +1773,10 @@ declare class ValidationError extends TypeError {
   constructor(message: string, options: Schemastery.Options);
   static is(error: any): error is ValidationError;
 }
-type Schema<S = any, T = S> = Schemastery<S, T>;
+type SchemaMode = 'plain' | 'defined' | 'volatile' | 'volatile-defined';
+type SchemaOutput<T, M extends SchemaMode> = M extends 'volatile' ? Volatile<T | undefined> : M extends 'volatile-defined' ? Volatile<T> : T;
+type SetRequired<M extends SchemaMode, R extends boolean> = M extends 'volatile' | 'volatile-defined' ? R extends true ? 'volatile-defined' : 'volatile' : R extends true ? 'defined' : 'plain';
+type Schema<S = any, T = S, Mode extends SchemaMode = 'plain'> = Schemastery<S, T, Mode>;
 declare const Schema: Schemastery.Static;
 //#endregion
 //#region ../../../vendor/deepseek-harness/packages/llm/llm/lib/types/retry-policy.d.ts
@@ -1753,8 +1865,8 @@ declare module '@deepseek-ai/cordis' {
      *   process-local {@link markAgentLoopRequest} identity and arrives deep-frozen
      *   (mutation throws): its content is a pure function of the session log (the
      *   reconstructability Agent Note), so listeners read it, never rewrite it.
-     *   Hand-built calls do not carry that marker; their messages already obey
-     *   the immutable creation contract.
+     *   Hand-built calls do not carry that marker; callers own their request
+     *   inputs and must keep them unchanged until the stream settles.
      * @mode waterfall
      */
     'llm/stream'(this: LlmRuntime, options: GenerateOptions, next: () => AsyncIterable<StreamChunk>): AsyncIterable<StreamChunk>;
@@ -2134,7 +2246,7 @@ declare function SessionLogOffset(value: number): SessionLogOffset;
  * immutable prior-generation, and current fast-path rules are recorded in
  * `.agents/notes/implemented/architecture/2026-08-31-released-session-format-migrations.md`.
  */
-declare const SESSION_FORMAT_VERSION = 3;
+declare const SESSION_FORMAT_VERSION = 4;
 /**
  * Immutable validated storage metadata, kept outside the conversation event log.
  */
@@ -2186,8 +2298,8 @@ interface CreateSessionOptions {
   readonly seed?: readonly SessionEvent[];
   /**
    * Exact fork-inherited prefix length when `meta.isSeeded` is true. The
-   * constructor seed is exactly this inherited prefix; the constructor
-   * appends the child-owned tagged marker at the cut.
+   * constructor appends the child-owned tagged marker at the cut unless
+   * the seed already includes it followed by child-owned fork closers.
    */
   readonly inheritedEventCount?: SessionLogOffset;
   /**
@@ -2279,6 +2391,15 @@ interface TurnEndReasonMap {
   interrupted: {
     kind: 'interrupted';
   };
+  /**
+   * Fork-seed construction closed a turn that was still open at the fork
+   * boundary in the source session. Only fork seeds carry this marker — the
+   * loop never emits it — and the source events before the boundary remain
+   * intact in the child.
+   */
+  forked: {
+    kind: 'forked';
+  };
 }
 /** The union over {@link TurnEndReasonMap} — why a turn ended; plugins extend it by merging variants into the map. */
 type TurnEndReason = TurnEndReasonMap[keyof TurnEndReasonMap];
@@ -2295,6 +2416,10 @@ interface EpochHeader {
   adapterDefaults?: LlmCallConfigAdapterDefaults;
   /** Assembled tool schemas; absent for a tool-less request. */
   tools?: ToolSchema[];
+  /** Retired request text; system prompts belong to system/message events.
+   * @persistenceReserved
+   */
+  system?: never;
 }
 /** Registration-bound metadata for one resolved model route. */
 interface RequestContext {
@@ -2362,6 +2487,14 @@ interface SessionEventMap {
    * project their `content` verbatim; `source` tells them apart.
    */
   'user/message': UserMessage;
+  /** An incremental agent session change admitted at the named turn and step. */
+  'developer/message': {
+    turn: number;
+    step: number;
+    message: DeveloperMessage;
+    /** Earlier request/header defining every tool addition; required exactly when additions are present. */
+    headerSeq?: SessionSeq;
+  };
   /**
    * The rendered system prompt on the model-visible surface. The loop appends
    * the first one as surface node 0 before the step's first `user/message`.
@@ -2439,7 +2572,7 @@ interface SessionEventMap {
     message: ToolResultMessage;
     /**
      * Optional failure identity and raw user-facing reason, outside model content;
-     * allowed only when the tool-result block has `isError: true`.
+     * allowed only when the message has `isError: true`.
      */
     error?: {
       name: string;
@@ -2466,19 +2599,21 @@ interface SessionEventMap {
    */
   'request/context': RequestContext;
   /**
-   * Marks the end of a constructor seed. Events before it have smaller seq
-   * values and came from the seed (resume, fork, or replay); this lifecycle
-   * produced none of them. This log-only event is the durable projection of
-   * {@link Session.firstLiveSeq}.
+   * Separates inherited or restored history from later lifecycle-owned work.
+   * This log-only marker need not be at {@link Session.firstLiveSeq}: a fork
+   * seed can already contain its tagged marker and child-owned synthetic
+   * closers before construction.
    *
    * A fresh fork child owns one `{ inherited: true }` marker at its exact
    * inherited-prefix cut, even when that prefix ends in an ancestor marker.
-   * The last tagged marker is the current Session's cut; untagged markers keep
-   * ordinary restore and replay lifecycle boundaries.
+   * `buildForkSeed` appends that marker before any synthetic closers; the
+   * `Session` constructor supplies it when given only the inherited prefix.
+   * The last tagged marker is the current Session's cut; untagged markers
+   * keep ordinary restore and replay lifecycle boundaries.
    *
-   * `Session`'s constructor is the only legitimate writer. The invariant
-   * companion deliberately constrains nothing here, so a plugin appending one
-   * would silently classify every live bracket before it as seed history.
+   * Only the `Session` constructor and `buildForkSeed` may create this marker.
+   * The invariant companion deliberately constrains nothing here, so a plugin
+   * appending one would silently classify every live bracket before it as seed history.
    *
    * An owner of a standalone open/close bracket (`compaction/start` …
    * `compaction/end`) reads it because seed history and live work are otherwise
@@ -2499,7 +2634,7 @@ type SessionEventType = keyof SessionEventMap;
  * event types may carry {@link SurfaceOp}; system, user, and tool events may also cite
  * earlier sources through {@link SessionEvent.sourceEventSeqs}.
  */
-type SurfaceEventType = 'system/message' | 'user/message' | 'assistant/message' | 'tool/result';
+type SurfaceEventType = 'system/message' | 'developer/message' | 'user/message' | 'assistant/message' | 'tool/result';
 /**
  * How a session event entered the ordered surface. Only valid on
  * {@link SurfaceEventType} events.
@@ -2695,29 +2830,25 @@ declare class Session {
   /** The session identity, derived from its durable header's single copy. */
   get id(): SessionId;
   /**
-   * The first seq appended IN THIS PROCESS: the length of the constructor
-   * seed (0 without one). Events with smaller seq values entered through
-   * construction — replay, fork, or resume — and were never published on the
-   * `session/event` firehose (constructor seeds do not emit). This offset marks
-   * the constructor-input boundary for lifecycle ownership and persistence
-   * adoption; consumers that need complete canonical history still start at
-   * seq 0. Distinct from {@link inheritedEventCount}, the DURABLE
-   * fork-lineage cut: a resumed session's constructor seed is its full stored
-   * log, while the inherited count keeps the original fork value — this field is the
-   * in-process construction fact.
+   * The constructor seed length (0 without one), before any marker appended
+   * during construction. Seed events never publish on `session/event`. A
+   * marker appended before the store attaches occupies this seq without
+   * publishing either; otherwise this seq is available for the next append.
    *
-   * Not persisted itself: a seeded session projects it into the log as the
-   * `session/end-seed` event, which is what a consumer reading STORED history
-   * reads. Locate the LAST such event, not necessarily one at this seq — a
-   * seed already ending in one is not re-marked, so reopening an untouched
-   * session leaves that event at a smaller seq than `firstLiveSeq`. Prefer
-   * this field in-process: it is exact before the marker reaches storage.
-   *
-   * When this lifecycle appends the marker, it occupies this seq before the
-   * store attaches and therefore does not publish either. Otherwise this seq
-   * holds an ordinary published write.
+   * This in-process offset is not persisted. A fork seed can already contain
+   * the child's inherited marker and synthetic closers, so its child-owned
+   * history starts at {@link inheritedEventCount}, before this offset. A
+   * resumed Session's seed contains its full stored log, while its inherited
+   * count keeps the durable fork cut. Consumers needing complete canonical
+   * history start at seq 0.
    */
   readonly firstLiveSeq: SessionLogOffset;
+  /**
+   * First event produced for this object lifecycle. A new fork includes its
+   * child-owned seed marker and closers; a restored Session starts after its
+   * complete stored prefix. This in-process capture offset is not persisted.
+   */
+  readonly firstLifecycleSeq: SessionLogOffset;
   /**
    * Create a detached session by validating and snapshotting borrowed seed
    * events and storage metadata.
@@ -3005,10 +3136,12 @@ declare class SessionStore extends Service {
    */
   list(): Session[];
   /**
-   * Create a live child session from a stable prefix of a live source.
+   * Create a live child session from an exact prefix of a live source.
    * `boundary` is an inclusive source event seq; omitted means the source's
-   * current last event. The selected slice may end with a between-turn event
-   * but must not end inside an open turn.
+   * current last event. An open tail receives synthetic tool results and
+   * step/turn closers with the forked cause. Closed steps and turns remain
+   * unchanged, including any failed tool calls already missing results.
+   * `inheritedEventCount` counts only copied source events, excluding these closers.
    *
    * @param source - Live source session object or id.
    * @param boundary - Inclusive source event seq to fork through; omitted means
@@ -3019,11 +3152,36 @@ declare class SessionStore extends Service {
    * @returns The created live child session.
    */
   fork(source: SessionForkSource, boundary?: SessionSeq, childSessionId?: SessionId): Session;
-  private _forkSeed;
+  private _forkBoundary;
   private _resolveForkSource;
 }
 //#endregion
 //#region src/client/controller.d.ts
+/** 一行会话：标题、origin、最后活动时间、归档标记与工作区归属都由 host 给出。 */
+interface SessionRowRecord {
+  sessionId: string;
+  title: string | null;
+  origin: string | null;
+  cwd: string | null;
+  createdAt: number;
+  updatedAt: number;
+  archived: boolean;
+  workspace: string | null;
+}
+/** 列表请求：搜索、子代理过滤与分页都在后端做（前端分页等于每次拉全量）。 */
+interface SessionRowsQuery {
+  query?: string;
+  includeSubagents?: boolean;
+  page?: number;
+  pageSize?: number;
+}
+interface SessionRowsPage {
+  items: SessionRowRecord[];
+  /** 过滤后的总数（分页前），页面据此算页数。 */
+  total: number;
+  page: number;
+  pageSize: number;
+}
 /** 时间范围的语义键（与 session-rdb `./usage` 的 `UsageRangeKey` 镜像）。 */
 type UsageRangeKey = "all" | "day" | "week" | "7d" | "30d" | "90d";
 /** 活动计数（与 session-rdb `./usage` 的回报结构镜像）：轮次 / 步骤 / 用户输入 / 工具调用。 */
@@ -3083,6 +3241,8 @@ interface ConversationManagerGcResult {
 }
 /** 页面从注入面拿到的动作（属性语法：页面解构后直接调用，不绑 this）。 */
 interface ConversationManagerFace {
+  /** 管理面自己的列表：完整语料（含归档），标题与最后活动时间随行给出；搜索与分页都在后端。 */
+  listRows: (query?: SessionRowsQuery) => Promise<SessionRowsPage>;
   archive: (sessionId: SessionId) => Promise<void>;
   unarchive: (sessionId: SessionId) => Promise<void>;
   remove: (sessionId: SessionId) => Promise<void>;
@@ -3101,6 +3261,7 @@ declare class ConversationManagerController {
   private readonly ports;
   readonly face: ConversationManagerFace;
   constructor(ports: ConversationManagerPorts);
+  private loadRows;
   private remove;
   private exportZip;
   private importZip;