@hydraharness/harness-client-runtime 0.0.0-stage → 0.1.1-rc.7

package/lib/types/client/contract/settings-scope.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The settings-namespace scope contract. The type lives here, in the common
+ * dependency of every feature that owns a preference, while the implementation
+ * and its Host transport live with the Settings surface
+ * (`@hydraharness/harness-client-ui-settings`): a feature service accepts a scope through
+ * `attachSettings` without depending on the surface that binds it, which would
+ * otherwise close a reference cycle.
+ */
+/** Client-side sync state of one settings namespace. */
+export interface SettingsScopeSnapshot<T> {
+    /**
+     * `loading` until the first accepted section, `ready` while one stands, and
+     * `unavailable` when the namespace is not exposed to this client or the
+     * connection keeps preferences process-local (memory mode).
+     */
+    status: 'loading' | 'ready' | 'unavailable';
+    /** Last accepted schema-resolved section; undefined before the first acceptance. */
+    value: T | undefined;
+    /**
+     * Composition layer the Host resolved {@link value} over, when the owning
+     * plugin declared one. What a field reverts to once cleared.
+     */
+    base: unknown;
+    /**
+     * Raw user layer as stored, when one exists. A field's PRESENCE here is what
+     * marks it overridden — an override whose value equals the composition
+     * default is still an override, and comparing values could not see it.
+     */
+    user: unknown;
+    /** Namespace revision fencing the next write; undefined before the first Host view. */
+    revision: number | undefined;
+    /** Whether the Host document accepts writes; memory mode never does. */
+    writable: boolean;
+    /** `host` syncs with the Host document; `memory` keeps a remote browser process-local. */
+    mode: 'host' | 'memory';
+}
+/** Domain-owned description of one settings namespace consumed by a browser plugin. */
+export interface SettingsScopeSpec<T> {
+    /** Settings namespace registered by the owning Host plugin. */
+    namespace: string;
+    /**
+     * Narrow one wire section; undefined keeps the last accepted value. The
+     * default validates the section against the namespace's own serialized wire
+     * schema, so domains add a decoder only to narrow beyond that schema.
+     */
+    decode?: (section: unknown) => T | undefined;
+}
+/**
+ * Reactive owner handle over one namespace's durable section — the browser
+ * mirror of the Host-side `SettingsScope` owner seam. Domain services read
+ * and observe the snapshot and route explicit user choices through `set`.
+ */
+export interface SettingsScope<T> {
+    /** @returns the current sync snapshot (stable reference until the next change). */
+    getSnapshot(): SettingsScopeSnapshot<T>;
+    /**
+     * Observe snapshot replacements.
+     * @param listener - invoked after each snapshot change.
+     * @returns the disposer removing this listener.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Queue one field write. Rapid writes preserve mutation order, each carries
+     * the latest known namespace revision, and only the latest settlement may
+     * publish; a rejected or failed latest write reloads Host state instead.
+     * @param field - scalar field inside the namespace section.
+     * @param value - JSON-shaped value selected by the user.
+     * @returns settlement after the write and any latest-write recovery read.
+     */
+    set(field: string, value: unknown): Promise<void>;
+    /**
+     * Queue one field clear, so the field re-inherits the composition layer.
+     * Shares {@link set}'s ordering, revision, and recovery contract.
+     * @param field - scalar field inside the namespace section.
+     * @returns settlement after the clear and any latest-write recovery read.
+     */
+    unset(field: string): Promise<void>;
+}
+//# sourceMappingURL=settings-scope.d.ts.map

package/lib/types/client/contract/store.d.ts

@@ -0,0 +1,90 @@
+import type { ActionsDecl, StoreHandle, StoreInstance, StoreSpec } from '@hydraharness/harness-client-ui-slots';
+export type { ActionsDecl, BakedActions, BoundActions, StoreFactory, StoreHandle, StoreInstance, StoreSpec, } from '@hydraharness/harness-client-ui-slots';
+/** Minimal observable snapshot source: Session objects and snapshot stores both satisfy it. */
+export interface ObservableSnapshot<T> {
+    getSnapshot(): T;
+    subscribe(fn: () => void): () => void;
+}
+/** Writable snapshot store (bare data face; React selector hooks are synthesized in ui-renderer). */
+export interface SnapshotStore<T> extends ObservableSnapshot<T> {
+    /**
+     * Mutate the state through an immer draft.
+     * @param mutator - draft mutator.
+     */
+    update(mutator: (draft: T) => void): void;
+    /**
+     * Replace the state wholesale.
+     * @param next - next state.
+     */
+    set(next: T): void;
+}
+/**
+ * Shallow equality for selector slices (zustand/shallow semantics; travels
+ * with the engine so hook consumers need no zustand dependency).
+ * @param a - left value.
+ * @param b - right value.
+ * @returns whether the values are shallowly equal.
+ */
+export declare function shallowEqual(a: unknown, b: unknown): boolean;
+/**
+ * Create a snapshot store.
+ *
+ * Flush default is 'sync' (controlled inputs need same-tick echo); frame-driven
+ * stores opt into 'raf', where a frame's worth of updates coalesces into one
+ * notification. Known raf-mode tradeoff: a component mounting mid-frame reads
+ * fresh state while existing subscribers hear it next flush — transient
+ * frame-level skew, same nature as the object layer's microtask batching.
+ *
+ * @param init - initial state.
+ * @param opts - flush mode and opt-in persistence (localStorage, keyed by name).
+ * @returns the store.
+ */
+export declare function createSnapshotStore<T>(init: T, opts?: {
+    flush?: 'raf' | 'sync';
+    persist?: {
+        name: string;
+    };
+}): SnapshotStore<T>;
+/** A live engine instance: the contract instance plus the raw engine store. */
+export interface EngineStoreInstance<T, A extends ActionsDecl<T>> extends StoreInstance<T, A> {
+    /** The underlying engine store (framework/test API; components never see it). */
+    readonly store: SnapshotStore<T>;
+}
+/** The engine-backed handle: create() narrowed to the engine instance. */
+export interface EngineStoreHandle<T, A extends ActionsDecl<T>> extends StoreHandle<T, A> {
+    /**
+     * Construct a live engine instance (see the contract JSDoc on
+     * {@link StoreHandle.create} for scopeKey/persist semantics).
+     *
+     * Known boundary: the persist key is the storage identity, so multiple live
+     * instances created under the same resolved key share (and cross-pollute)
+     * one localStorage entry. Instance uniqueness per key is the caller's
+     * responsibility — production is safe because the framework caches one
+     * instance per handle x scope key; tests wanting isolation use distinct
+     * scope keys or persist-free declarations (multi-create freedom is a
+     * feature there, so create() deliberately does not dedupe or throw).
+     * @param scopeKey - session id for session-scope instances; omitted for root scope.
+     * @returns the engine instance.
+     */
+    create(scopeKey?: string): EngineStoreInstance<T, A>;
+}
+/**
+ * Declare a store: initial state, optional persistence, and the full write
+ * set as pure draft mutators. The returned handle is the registration
+ * currency of the store seat — its identity keys instance sharing. Satisfies
+ * ui-slots' DefineStore contract (the handle/instance are the engine-extended
+ * subtypes).
+ *
+ * The `A & ActionsDecl<T>` actions position is load-bearing: T resolves from
+ * `init` in the first inference round, and the intersection then contextually
+ * types each mutator's draft parameter (context-sensitive functions defer),
+ * so call sites write `(d, x: X) => { ... }` with no draft annotation. If a
+ * future TS version breaks this single-literal inference, the design's
+ * documented fallback is currying (`defineStore(init).actions({...})`).
+ * @param decl - init lambda (fresh state per instance), optional persist key, actions table.
+ * @returns the store handle.
+ */
+export declare function defineStore<T, A extends ActionsDecl<T>>(decl: StoreSpec<T, A> & {
+    actions: A & ActionsDecl<T>;
+}): EngineStoreHandle<T, A>;
+//# sourceMappingURL=store.d.ts.map

package/lib/types/client/contract/workspaces.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The outward workspaces-service face — what `ctx.workspaces` exposes to
+ * feature packages and the renderer host, and therefore exactly what the
+ * test runtime's workspaces double must implement. Wire-pump entry points
+ * (handleHostEnvelope/handleConnected/refresh/startInitialSelection) stay on
+ * the concrete class. Widening this interface is the explicit act of
+ * widening what features may do to the workspaces domain.
+ */
+import type { DirectoryListing, SessionId, WorkspaceId, WorkspaceView } from '@hydraharness/harness-api-remotes/client';
+import type { WorkspaceListState } from '../workspaces/service.ts';
+import type { ObservableSnapshot } from './store.ts';
+/** The workspaces-service face injected as `ctx.workspaces`. */
+export interface IWorkspaces {
+    /** The useWorkspaces standard feed (read face — writes stay inside the domain). */
+    readonly list: ObservableSnapshot<WorkspaceListState>;
+    /**
+     * Connect a Workspace to its reusable or freshly created blank session.
+     * @param workspaceId - target workspace.
+     * @returns the connected session id.
+     */
+    connectWorkspace(workspaceId: WorkspaceId): Promise<SessionId>;
+    /**
+     * The New Session flow: connect the explicit, current-Session, or recent
+     * Workspace and open the resulting session; failures surface on the session
+     * list state.
+     * @param workspaceId - explicit target; omitted inherits the current
+     * Session's Workspace before falling back to the recency projection.
+     */
+    startSession(workspaceId?: WorkspaceId): void;
+    /**
+     * Register an existing path as a Workspace.
+     * @param input - the Host create payload.
+     * @returns the created or idempotently resolved Workspace.
+     */
+    create(input: {
+        path: string;
+    }): Promise<WorkspaceView>;
+    /**
+     * Open the Host's native directory picker.
+     * @returns the selected path, or null when the user cancelled.
+     */
+    pickDirectory(): Promise<string | null>;
+    /**
+     * List one directory level through the Host's `browse` capability.
+     * @param path - absolute directory to list; absent lists the Host home directory.
+     * @param signal - aborts the wire request (and the Host's scan) when the caller supersedes it.
+     * @returns the level's listing with breadcrumb ancestry.
+     */
+    listDirectory(path?: string, signal?: AbortSignal): Promise<DirectoryListing>;
+    /**
+     * Create one child directory through the Host's `browse` capability.
+     * @param path - absolute existing parent directory.
+     * @param name - single non-blank path segment.
+     * @returns the created directory's absolute path.
+     */
+    createDirectory(path: string, name: string): Promise<string>;
+    /**
+     * Open a filesystem path with the Host operating system's default application.
+     * @param path - absolute or host-resolvable path.
+     */
+    openPath(path: string): Promise<void>;
+    /**
+     * Rename a Workspace.
+     * @param workspaceId - target workspace.
+     * @param title - the new display title.
+     * @returns the updated Workspace view.
+     */
+    rename(workspaceId: WorkspaceId, title: string): Promise<WorkspaceView>;
+    /**
+     * Delete a Workspace (its sessions fall back to the unaccounted group).
+     * @param workspaceId - target workspace.
+     */
+    delete(workspaceId: WorkspaceId): Promise<void>;
+    /**
+     * Move a Workspace within the registry display order.
+     * @param workspaceId - Workspace to move.
+     * @param beforeWorkspaceId - Anchor workspace; omitted appends.
+     */
+    insertBefore(workspaceId: WorkspaceId, beforeWorkspaceId?: WorkspaceId): Promise<void>;
+    /**
+     * Move an accounted session within/into a Workspace's ordered list.
+     * @param workspaceId - target workspace.
+     * @param sessionId - accounted session to move.
+     * @param beforeSessionId - accounted anchor to insert before; omitted appends.
+     * @returns the updated Workspace view.
+     */
+    insertSessionBefore(workspaceId: WorkspaceId, sessionId: SessionId, beforeSessionId?: SessionId): Promise<WorkspaceView>;
+    /**
+     * Archive a session into the registry-global set (hidden from grouping
+     * surfaces; session log and accounting slot remain). Archiving the current
+     * session clears the selection into the New Session view state.
+     * @param sessionId - session to archive.
+     */
+    archiveSession(sessionId: SessionId): Promise<void>;
+    /**
+     * Restore one session from the registry-global archive set. Its retained
+     * Workspace account then makes it visible in the same Workspace again.
+     * @param sessionId - session to restore.
+     */
+    unarchiveSession(sessionId: SessionId): Promise<void>;
+}
+//# sourceMappingURL=workspaces.d.ts.map

package/lib/types/client/conversation/definition-registry.d.ts

@@ -0,0 +1,30 @@
+import { Service } from '@hydraharness/cordis';
+/** Shared lifecycle and stable-entry storage for one Conversation Definition registry. */
+export declare abstract class ConversationDefinitionRegistry<Definition> extends Service {
+    protected readonly definitions: Map<string, Definition>;
+    private listeners;
+    private cached;
+    /**
+     * Return reference-stable Definitions in registration order.
+     * @returns current Definitions.
+     */
+    entries(): readonly Definition[];
+    /**
+     * Observe low-frequency registry changes.
+     * @param listener - synchronous invalidation callback.
+     * @returns unsubscribe callback.
+     */
+    subscribe(listener: () => void): () => void;
+    /**
+     * Register one uniquely keyed Definition for the caller's lifetime.
+     * @param key - registry-local unique key.
+     * @param definition - contributed Definition.
+     * @param duplicateMessage - error raised when the key is already owned.
+     * @param effectName - Cordis effect diagnostic label.
+     * @returns idempotent disposer.
+     */
+    protected registerDefinition(key: string, definition: Definition, duplicateMessage: string, effectName: string): () => void;
+    /** Refresh cached entries and synchronously invalidate subscribers. */
+    protected refresh(): void;
+}
+//# sourceMappingURL=definition-registry.d.ts.map

package/lib/types/client/conversation/event-registry.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ConversationNodeDefinition } from '../contract/conversation.ts';
+import { ConversationDefinitionRegistry } from './definition-registry.ts';
+/** Runtime registry of independently owned Conversation business Definitions. */
+export declare class ConversationEventRegistry extends ConversationDefinitionRegistry<ConversationNodeDefinition> {
+    private fallback;
+    /** @param ctx - owning Client Runtime context. */
+    constructor(ctx: Context);
+    /**
+     * Register a uniquely named business Definition for the caller's lifetime.
+     * @param definition - Definition contribution.
+     * @returns idempotent disposer.
+     */
+    register(definition: ConversationNodeDefinition): () => void;
+    /**
+     * Register the sole fallback used only when no ordinary Definition matches.
+     * @param definition - fallback Definition.
+     * @returns idempotent disposer.
+     */
+    registerFallback(definition: ConversationNodeDefinition): () => void;
+    /**
+     * Return the current unmatched-event fallback.
+     * @returns installed fallback, when present.
+     */
+    fallbackEntry(): ConversationNodeDefinition | undefined;
+}
+//# sourceMappingURL=event-registry.d.ts.map

package/lib/types/client/conversation/view-registry.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from '@hydraharness/cordis';
+import type { ConversationViewDefinition } from '../contract/conversation.ts';
+import { ConversationDefinitionRegistry } from './definition-registry.ts';
+/** Runtime registry of per-target Conversation snapshot builders. */
+export declare class ConversationViewRegistry extends ConversationDefinitionRegistry<ConversationViewDefinition> {
+    /** @param ctx - owning Client Runtime context. */
+    constructor(ctx: Context);
+    /**
+     * Register a uniquely named view builder factory for the caller's lifetime.
+     * @param definition - target builder contribution.
+     * @returns idempotent disposer.
+     */
+    register(definition: ConversationViewDefinition): () => void;
+}
+//# sourceMappingURL=view-registry.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,128 @@
+/** Browser runtime services for slots, sessions, workspaces, and connection-stream delivery. */
+import type { Context } from '@hydraharness/cordis';
+import type { SessionId } from '@hydraharness/harness-api-remotes/client';
+import type { TypertContext } from '@hydraharness/harness-typert-protocol';
+import type { MaybeSnapshotSelectorHook, SnapshotSelectorHook } from '@hydraharness/harness-client-ui-slots';
+import type { SessionListState } from './sessions/service.ts';
+import type { ConversationSnapshot } from './sessions/conversation.ts';
+import type { UseProjection } from './sessions/projection-store.ts';
+export { isAppendSurfaceEvent, isReplacementSurfaceEvent } from '@hydraharness/harness-session/surface';
+export { SlotRegistry } from './slots.ts';
+export { ConversationEventRegistry } from './conversation/event-registry.ts';
+export { ConversationViewRegistry } from './conversation/view-registry.ts';
+export { ConversationNodeAssembler } from './sessions/conversation-assembler.ts';
+export { ConversationLocationIndex } from './sessions/conversation-location-index.ts';
+export { conversationContextKey } from './contract/conversation.ts';
+export type { ChatConversationViewNode, ConversationContextReader, ConversationEventInput, ConversationLocationData, ConversationLocationDataScope, ConversationLocationDataStore, ConversationStepDataMap, ConversationLocation, ConversationMatch, ConversationMatchResult, ConversationNodeContext, ConversationNodeDefinition, ConversationPreviousContext, ConversationPublication, ConversationTimelineSnapshot, ConversationTurnDataMap, ConversationViewBuilder, ConversationViewDefinition, ConversationViewNode, ConversationViewSnapshotMap, ConversationViewSnapshotStore, StepLocation, TurnLocation, } from './contract/conversation.ts';
+export type { ConversationRuntime } from './sessions/conversation-assembler.ts';
+export type { RootOwnerProps } from './slots.ts';
+export { SessionCreateError, SessionRuntime, scopeOf, workspaceTitleOf } from './sessions/service.ts';
+export { indexSubagentDescendants } from './sessions/subagent-lineage.ts';
+export { conversationVersions, conversationRepresentatives } from './sessions/conversation-versions.ts';
+export type { ConversationVersion } from './sessions/conversation-versions.ts';
+export type { SubagentDescendantSummary } from './sessions/subagent-lineage.ts';
+export { SessionProvideChannel } from './sessions/provide.ts';
+export type { SessionProvideChannelHost } from './sessions/provide.ts';
+export { createScope } from './agents/scope.ts';
+export type { AgentScopeHandle } from './agents/scope.ts';
+export { DirectoryBrowseError, WorkspaceCreateError, WorkspaceRuntime } from './workspaces/service.ts';
+export { abbreviateHomePath, resolveWorkspacePath } from './workspaces/path.ts';
+export type { SettingsScope, SettingsScopeSnapshot, SettingsScopeSpec, } from './contract/settings-scope.ts';
+export type { Session } from './sessions/session.ts';
+export type { ISession, ProjectionsFace, SessionFace } from './contract/session.ts';
+export type { AgentContext, ISessions } from './contract/sessions.ts';
+export type { IWorkspaces } from './contract/workspaces.ts';
+export type { SessionBinding, SessionListState, SessionProvideContribution, SessionProvideDescriptor, SessionSummary, } from './sessions/service.ts';
+export type { SessionListPhase, SessionSearchResultItem, SubagentCatalogSnapshot } from './sessions/manager.ts';
+export type { SubagentAddress, JobView } from '@hydraharness/harness-client-connection/client';
+export type { WorkspaceListPhase } from './workspaces/manager.ts';
+export type { WorkspaceListState } from './workspaces/service.ts';
+export type { DirectoryEntry, DirectoryListing, WorkspaceId, WorkspaceView, } from '@hydraharness/harness-client-connection/client';
+export { createSnapshotStore, defineStore, shallowEqual } from './contract/store.ts';
+export type { EngineStoreHandle, EngineStoreInstance, ObservableSnapshot, SnapshotStore, } from './contract/store.ts';
+export type { AssistantBlock, AssistantMessageNode, AssistantProvenanceView, AssistantRequestConfig, AssistantTiming, ChatLocationNodeIndex, ChatNodeStore, ChatSnapshot, CommandNode, CompactionSummaryNode, ComposerPhase, ContextMessageNode, ConversationNode, ConversationSnapshot, ModelRetryNode, QueuedMessage, LegacyConversationSlice, PartialAssistant, RunningToolCall, SteeringMessageNode, TodoItem, ToolCallBlock, ToolResultNode, TurnErrorNode, TurnMaxTokensNode, UnknownSurfaceNode, UserMessageNode, } from './sessions/conversation.ts';
+export { EMPTY_CHAT_SNAPSHOT, EMPTY_CONVERSATION_VIEWS, toAssistantBlock, toAssistantBlocks, } from './sessions/conversation.ts';
+export { emptyAssistantBlock } from './sessions/partial.ts';
+export { isTokenDelta } from './sessions/assistant-timing.ts';
+export { contextForm, contextProvenance, sessionRecallLabels } from './sessions/context-provenance.ts';
+export { displayFailureMessage } from './sessions/failure-display.ts';
+export type { ConversationContext, ConversationContextOriginKind, } from './sessions/conversation-context.ts';
+export type { ContextProvenanceView, ContextRole, KnownContextForm, } from './sessions/context-provenance.ts';
+export type { ConversationPromptSnapshot, RequestInspectionSnapshot, RequestPromptChange, RequestView, } from './sessions/request-inspection.ts';
+export { PendingWait } from './sessions/pending.ts';
+export type { PendingInteraction, PendingInteractionStatus, PendingKind, PendingPayloads, } from './sessions/pending.ts';
+export type { ProjectionsBaseline, ProjectionValueStore, SessionProjectionMap, UseProjection, } from './sessions/projection-store.ts';
+export type { SessionId } from '@hydraharness/harness-client-connection/client';
+/** Client-side Cordis context after declaration merging. */
+export type ClientContext = Context;
+declare module '@hydraharness/harness-typert-protocol' {
+    interface TypertContextMap {
+        /** Client Agent scope identity; the agent and session share one wire id. */
+        agent: TypertContext<SessionId>;
+    }
+}
+/** The conversation-snapshot selector hook supplied to session-scoped UI entries. */
+export type UseConversationSession = SnapshotSelectorHook<ConversationSnapshot>;
+declare module '@hydraharness/harness-client-ui-slots' {
+    /**
+     * Session standard kit, real members (ui-slots declares the empty seat;
+     * the runtime — where the subjects live — merges the concrete types):
+     * every session-scope slot component receives these from the framework.
+     */
+    interface SessionStandardProps {
+        useSession: SnapshotSelectorHook<ConversationSnapshot>;
+        /** The framework-resolved session id (owners never pass it). */
+        sessionId: SessionId;
+        /** The fifth framework hook seat: key-addressed projection reader (undefined = capability absent). */
+        useProjection: UseProjection;
+    }
+    /** Standard kit for slots that remain mounted while current session changes. */
+    interface SessionMaybeStandardProps {
+        useSession: MaybeSnapshotSelectorHook<ConversationSnapshot>;
+        /** Current session id; absent in the no-session state. */
+        sessionId: SessionId | undefined;
+        /** Key-addressed projection reader; every key reads absent while no session is current. */
+        useProjection: UseProjection;
+    }
+    /** Props injected into every global slot component. */
+    interface GlobalStandardProps {
+        useSessions: SnapshotSelectorHook<SessionListState>;
+        /** Selector hook over real Workspaces and their independent baseline lifecycle. */
+        useWorkspaces: SnapshotSelectorHook<import('./workspaces/service.ts').WorkspaceListState>;
+    }
+}
+declare module '@hydraharness/cordis' {
+    interface Events {
+        /**
+         * A slot's definition or registration set changed.
+         * @mode emit
+         * @param key - the mutated SlotMap key.
+         */
+        'slots/changed'(key: string): void;
+        /**
+         * A connection generation was (re-)established. Wire-derived caches must
+         * treat their state as stale and repull (commands directory; the queue
+         * mirrors reset themselves through the session resync path).
+         * @mode emit
+         */
+        'connection/reset'(): void;
+    }
+    interface Context {
+        slots: import('./slots.ts').SlotRegistry;
+        /** Event-to-business-Context Definition registry. */
+        conversationEvents: import('./conversation/event-registry.ts').ConversationEventRegistry;
+        /** Per-target Conversation snapshot builder registry. */
+        conversationViews: import('./conversation/view-registry.ts').ConversationViewRegistry;
+        /** The outward face only; the concrete service stays inside the runtime. */
+        sessions: import('./contract/sessions.ts').ISessions;
+        /** The outward face only; the concrete service stays inside the runtime. */
+        workspaces: import('./contract/workspaces.ts').IWorkspaces;
+    }
+}
+/** Required services: the wire handle and Client Typert registry. */
+export declare const inject: string[];
+/** Mounts the browser runtime services and connection stream.
+ * @param ctx - Client Cordis context.
+ */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/ordered-baseline.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Merge an authoritative baseline without moving identities already visible to
+ * the client. Baseline-only identities are inserted relative to the nearest
+ * following known identity; identities absent from the baseline are removed.
+ *
+ * @param current - the established client order.
+ * @param baseline - the latest authoritative rows.
+ * @param keyOf - stable identity selector.
+ * @returns baseline-valued rows with the established relative order retained.
+ */
+export declare function mergeOrderedBaseline<T>(current: readonly T[], baseline: readonly T[], keyOf: (value: T) => unknown): T[];
+//# sourceMappingURL=ordered-baseline.d.ts.map

package/lib/types/client/sessions/assistant-timing.d.ts

@@ -0,0 +1,34 @@
+import type { SessionEvent } from '@hydraharness/harness-session/types';
+import type { AssistantTiming } from './conversation.ts';
+export { isTokenDelta } from '@hydraharness/harness-llm/message';
+/** Pre-finalize timing boundaries for one assistant step (start + first token). */
+export interface AssistantStepMetadata {
+    stepStartTime: number | null;
+    firstTokenTime: number | null;
+}
+/**
+ * Composite map key for one assistant step.
+ * @param turn - turn number from the event payload.
+ * @param step - step number from the event payload.
+ * @returns collision-free `turn`/`step` key (NUL separator).
+ */
+export declare function assistantStepKey(turn: number, step: number): string;
+/**
+ * Fold one event into the per-step timing index: step/start opens the entry,
+ * the first non-empty token delta stamps first-token time once. Other event
+ * types are no-ops.
+ * @param steps - the mutable per-step index, keyed by {@link assistantStepKey}.
+ * @param event - the raw window event.
+ */
+export declare function indexAssistantStepTiming(steps: Map<string, AssistantStepMetadata>, event: SessionEvent): void;
+/**
+ * Settle one finalized assistant message's timing from its step entry; a step
+ * whose start or first token fell outside the window yields null boundaries.
+ * @param steps - the per-step index built by {@link indexAssistantStepTiming}.
+ * @param turn - the assistant/message turn number.
+ * @param step - the assistant/message step number.
+ * @param completedTime - the assistant/message event timestamp (epoch ms).
+ * @returns the node-ready timing record.
+ */
+export declare function settledAssistantTiming(steps: ReadonlyMap<string, AssistantStepMetadata>, turn: number, step: number, completedTime: number): AssistantTiming;
+//# sourceMappingURL=assistant-timing.d.ts.map

package/lib/types/client/sessions/context-provenance.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Which model-facing role a logged non-user message plays.
+ *
+ * `recall` marks material lifted out of another session's log; `inject` marks
+ * every other producer-supplied context. Mid-turn steering is the third role
+ * the transcript distinguishes, but it has its own event and node kind
+ * (`steering/message` / `SteeringMessageNode`) and never reaches here.
+ */
+export type ContextRole = 'inject' | 'recall';
+/** Role and producer name presented for one logged non-user message. */
+export interface ContextProvenanceView {
+    /** The role this context plays in the model-facing conversation. */
+    role: ContextRole;
+    /**
+     * Producer name for the row header, taken from the durable source: the
+     * instruction paths, the referenced session titles, the plugin id, or the
+     * bare source kind for a producer this UI version does not know. Null only
+     * when the source carries no readable kind at all.
+     */
+    label: string | null;
+}
+/**
+ * The referenced-session labels of one durable `session-reference` recall
+ * source, in first-seen order; empty for every other source shape, including
+ * a foreign or older log whose reference entries carry no readable label.
+ * @param source - the logged `user/message` source, exactly as recorded.
+ * @returns distinct non-empty reference labels.
+ */
+export declare function sessionRecallLabels(source: unknown): string[];
+/**
+ * Project one durable message source onto its transcript role and producer name.
+ *
+ * The source arrives over the wire as opaque JSON (`MessageSource` is
+ * merge-extensible, so no client-side union can be exhaustive), and a durable
+ * log may predate or postdate this UI; every unreadable shape therefore
+ * degrades to `inject` with whatever name the record still carries.
+ * @param source - the logged `user/message` source, exactly as recorded.
+ * @returns the role and producer name to present for this context.
+ */
+export declare function contextProvenance(source: unknown): ContextProvenanceView;
+/**
+ * Context forms this UI version renders with a dedicated presentation. The
+ * durable vocabulary (`ContextForm` in `@hydraharness/harness-llm`) may already be wider — an
+ * unrecognized or absent value degrades to the opaque presentation rather than
+ * dropping the row, so a log written by a newer or foreign producer still
+ * renders.
+ */
+declare const KNOWN_FORMS: readonly ["instructions", "catalog", "snapshot", "notice", "relay", "recall"];
+/** One durable context form this UI version knows how to present. */
+export type KnownContextForm = typeof KNOWN_FORMS[number];
+/**
+ * Read the producer-declared form off one durable message source.
+ * @param source - the logged `user/message` source, exactly as recorded.
+ * @returns the form when this UI version presents it, otherwise null (opaque).
+ */
+export declare function contextForm(source: unknown): KnownContextForm | null;
+export {};
+//# sourceMappingURL=context-provenance.d.ts.map