@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/session-reference/lib/types/index.js

@@ -4,12 +4,47 @@
  *
  * @module @nomix-ai/nomix-session-reference
  */
-import { Service } from '../../../cordis/lib/index.js';
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 import z from '../../../schemastery/lib/index.mjs';
-import { createUserMessage } from '../../../llm/lib/index.js';
+import { Remote, TypertRemoteService } from '../../../typert-protocol/lib/index.js';
+import { createUserMessage, freezeMessage } from '../../../llm/lib/index.js';
 import { DEFAULT_CANDIDATE_LIMIT, DEFAULT_MAX_REFERENCE_BYTES, MAX_REFERENCES, SessionReferenceError, } from "./config.js";
 import { retainReferencedSession } from "./projection.js";
 import { stringifyTagSafeJson } from "./serialization.js";
+import { formatSessionReferenceMention, parseSessionReferenceText } from "./uri.js";
 export { DEFAULT_CANDIDATE_LIMIT, DEFAULT_MAX_REFERENCE_BYTES, MAX_REFERENCES, SessionReferenceError, } from "./config.js";
 export { SESSION_REFERENCE_SCHEME, decodeSessionReferenceUri, encodeSessionReferenceUri, formatSessionReferenceMention, parseSessionReferenceText, } from "./uri.js";
 const PROMPT_PREFIX = `## Referenced sessions
@@ -23,139 +58,208 @@ user explicitly repeats them.
 `;
 const PROMPT_SUFFIX = '\n</referenced-sessions>';
 /** Exact-read consumer that prepares immutable cross-session message context. */
-export class SessionReferenceResolver extends Service {
-    static inject = ['sessionQuery'];
-    static Config = z.object({
-        maxReferences: z.number().step(1).min(1).max(MAX_REFERENCES).default(MAX_REFERENCES),
-        candidateLimit: z.number().step(1).min(1).default(DEFAULT_CANDIDATE_LIMIT),
-        maxReferenceBytes: z.number().step(1).min(1).default(DEFAULT_MAX_REFERENCE_BYTES),
-    });
-    config;
-    constructor(ctx, config = {}) {
-        super(ctx, 'sessionReferenceResolver');
-        this.config = {
-            maxReferences: config.maxReferences ?? MAX_REFERENCES,
-            candidateLimit: config.candidateLimit ?? DEFAULT_CANDIDATE_LIMIT,
-            maxReferenceBytes: config.maxReferenceBytes ?? DEFAULT_MAX_REFERENCE_BYTES,
-        };
-        for (const [name, value] of Object.entries(this.config)) {
-            if (!Number.isSafeInteger(value) || value <= 0) {
-                throw new SessionReferenceError(`session-reference: ${name} must be a positive safe integer`, 'SESSION_REFERENCE_INVALID_CONFIG');
-            }
+let SessionReferenceResolver = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _remoteExportCandidates_decorators;
+    return class SessionReferenceResolver extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _remoteExportCandidates_decorators = [Remote('candidates')];
+            __esDecorate(this, null, _remoteExportCandidates_decorators, { kind: "method", name: "remoteExportCandidates", static: false, private: false, access: { has: obj => "remoteExportCandidates" in obj, get: obj => obj.remoteExportCandidates }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        if (this.config.maxReferences > MAX_REFERENCES) {
-            throw new SessionReferenceError(`session-reference: maxReferences must not exceed ${MAX_REFERENCES}`, 'SESSION_REFERENCE_INVALID_CONFIG');
+        static inject = ['sessionQuery'];
+        static Config = z.object({
+            maxReferences: z.number().step(1).min(1).max(MAX_REFERENCES).default(MAX_REFERENCES),
+            candidateLimit: z.number().step(1).min(1).default(DEFAULT_CANDIDATE_LIMIT),
+            maxReferenceBytes: z.number().step(1).min(1).default(DEFAULT_MAX_REFERENCE_BYTES),
+        });
+        config = __runInitializers(this, _instanceExtraInitializers);
+        constructor(ctx, config = {}) {
+            super(ctx, 'sessionReferenceResolver');
+            this.config = {
+                maxReferences: config.maxReferences ?? MAX_REFERENCES,
+                candidateLimit: config.candidateLimit ?? DEFAULT_CANDIDATE_LIMIT,
+                maxReferenceBytes: config.maxReferenceBytes ?? DEFAULT_MAX_REFERENCE_BYTES,
+            };
+            for (const [name, value] of Object.entries(this.config)) {
+                if (!Number.isSafeInteger(value) || value <= 0) {
+                    throw new SessionReferenceError(`session-reference: ${name} must be a positive safe integer`, 'SESSION_REFERENCE_INVALID_CONFIG');
+                }
+            }
+            if (this.config.maxReferences > MAX_REFERENCES) {
+                throw new SessionReferenceError(`session-reference: maxReferences must not exceed ${MAX_REFERENCES}`, 'SESSION_REFERENCE_INVALID_CONFIG');
+            }
+            ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
+                const decision = await next();
+                if (decision.kind === 'reject')
+                    return decision;
+                return {
+                    kind: 'enter',
+                    messages: await this.prepareDirectMessages(agent, decision.messages, signal),
+                };
+            }, { prepend: true });
         }
-    }
-    /**
-     * List reference candidates, ranked by working-directory affinity.
-     * @param agent - target agent; self is excluded and its cwd drives ranking.
-     * @param query - optional case-insensitive session-id/cwd/title substring.
-     * @param limit - optional positive result cap.
-     * @param signal - optional cancellation boundary for host autocomplete teardown.
-     * @returns candidates labeled by latest title or, when absent, session id.
-     */
-    async listCandidates(agent, query = '', limit = this.config.candidateLimit, signal) {
-        if (!Number.isSafeInteger(limit) || limit <= 0) {
-            throw new SessionReferenceError('candidate limit must be a positive safe integer', 'SESSION_REFERENCE_INVALID_REFERENCE');
+        /**
+         * Replace canonical mentions in direct user messages and place each prepared
+         * snapshot immediately after the message that cited it.
+         * @param agent - agent entering the model step.
+         * @param messages - messages accepted by downstream pre-step listeners.
+         * @param signal - active turn cancellation.
+         * @returns direct messages followed by their session-reference context in citation order.
+         */
+        async prepareDirectMessages(agent, messages, signal) {
+            const prepared = await Promise.all(messages.map(async (message) => {
+                if (message.source.kind !== 'user')
+                    return [message];
+                const references = [];
+                const content = message.content.map((block) => {
+                    if (block.type !== 'text')
+                        return block;
+                    const parsed = parseSessionReferenceText(block.text);
+                    references.push(...parsed.references);
+                    return { type: 'text', text: parsed.text };
+                });
+                if (references.length === 0)
+                    return [message];
+                const resolved = await this.prepare(agent, content, references, signal);
+                const direct = freezeMessage({ ...message, content: resolved.content });
+                /* v8 ignore if -- a parsed canonical mention always leaves one normalized reference */
+                if (resolved.additionalContext === undefined) {
+                    throw new Error('session-reference preparation omitted context for a canonical mention');
+                }
+                return [direct, resolved.additionalContext];
+            }));
+            return prepared.flat();
         }
-        const needle = query.toLocaleLowerCase();
-        const targetCwd = agent.session.header.cwd;
-        assertNotCancelled(signal);
-        const records = (await settleWithCancellation(this.ctx.sessionQuery.listSessions(signal), signal))
-            .filter(record => record.header.id !== agent.id)
-            .map((record, index) => ({ record, index }));
-        const inspected = needle === ''
-            ? records
-                .sort((a, b) => candidateRank(a.record.header.cwd, targetCwd) - candidateRank(b.record.header.cwd, targetCwd)
+        /**
+         * List reference candidates, ranked by working-directory affinity.
+         * @param agent - target agent; self is excluded and its cwd drives ranking.
+         * @param query - optional case-insensitive session-id/cwd/title substring.
+         * @param limit - optional positive result cap.
+         * @param signal - optional cancellation boundary for host autocomplete teardown.
+         * @returns candidates labeled by latest title or, when absent, session id.
+         */
+        async listCandidates(agent, query = '', limit = this.config.candidateLimit, signal) {
+            if (!Number.isSafeInteger(limit) || limit <= 0) {
+                throw new SessionReferenceError('candidate limit must be a positive safe integer', 'SESSION_REFERENCE_INVALID_REFERENCE');
+            }
+            const needle = query.toLocaleLowerCase();
+            const targetCwd = agent.session.header.cwd;
+            assertNotCancelled(signal);
+            const records = (await settleWithCancellation(this.ctx.sessionQuery.listSessions(signal), signal))
+                .filter(record => record.header.id !== agent.id)
+                .map((record, index) => ({ record, index }));
+            const inspected = needle === ''
+                ? records
+                    .sort((a, b) => candidateRank(a.record.header.cwd, targetCwd) - candidateRank(b.record.header.cwd, targetCwd)
+                    || a.index - b.index)
+                    .slice(0, limit)
+                : records;
+            const observations = await settleWithCancellation(this.ctx.sessionQuery.readTitleSnapshots(inspected.map(({ record }) => record.header.id), signal), signal);
+            return inspected.map(({ record, index }, observationIndex) => {
+                const observation = observations[observationIndex];
+                return {
+                    record,
+                    index,
+                    label: observation.status === 'fulfilled'
+                        ? observation.value.title?.title ?? record.header.id
+                        : record.header.id,
+                };
+            }).filter(({ record, label }) => {
+                if (needle === '')
+                    return true;
+                return record.header.id.toLocaleLowerCase().includes(needle)
+                    || record.header.cwd?.toLocaleLowerCase().includes(needle) === true
+                    || label.toLocaleLowerCase().includes(needle);
+            }).sort((a, b) => candidateRank(a.record.header.cwd, targetCwd) - candidateRank(b.record.header.cwd, targetCwd)
                 || a.index - b.index)
                 .slice(0, limit)
-            : records;
-        const observations = await settleWithCancellation(this.ctx.sessionQuery.readTitleSnapshots(inspected.map(({ record }) => record.header.id), signal), signal);
-        return inspected.map(({ record, index }, observationIndex) => {
-            const observation = observations[observationIndex];
-            return {
-                record,
-                index,
-                label: observation.status === 'fulfilled'
-                    ? observation.value.title?.title ?? record.header.id
-                    : record.header.id,
-            };
-        }).filter(({ record, label }) => {
-            if (needle === '')
-                return true;
-            return record.header.id.toLocaleLowerCase().includes(needle)
-                || record.header.cwd?.toLocaleLowerCase().includes(needle) === true
-                || label.toLocaleLowerCase().includes(needle);
-        }).sort((a, b) => candidateRank(a.record.header.cwd, targetCwd) - candidateRank(b.record.header.cwd, targetCwd)
-            || a.index - b.index)
-            .slice(0, limit)
-            .map(({ record, label }) => ({
-            sessionId: record.header.id,
-            label,
-            ...record.header.cwd === undefined ? {} : { cwd: record.header.cwd },
-            createdAt: record.header.createdAt,
-        }));
-    }
-    /**
-     * Snapshot all references before enqueue and return one aggregated durable context.
-     * @param agent - target agent; references to it are rejected.
-     * @param content - already host-normalized readable message content.
-     * @param references - structured source sessions in mention order.
-     * @param signal - optional cancellation boundary for host request teardown.
-     * @returns detached content and optional referenced-session context.
-     */
-    async prepare(agent, content, references, signal) {
-        const acceptedContent = structuredClone(content);
-        const inputs = normalizeReferences(agent.id, references, this.config.maxReferences);
-        if (inputs.length === 0)
-            return { content: acceptedContent };
-        assertNotCancelled(signal);
-        let prepared;
-        try {
-            prepared = await settleWithCancellation(Promise.all(inputs.map(async (input) => ({
-                input,
-                snapshot: await this.ctx.sessionQuery.readSurface(input.sessionId),
-            }))), signal);
+                .map(({ record, label }) => ({
+                sessionId: record.header.id,
+                label,
+                ...record.header.cwd === undefined ? {} : { cwd: record.header.cwd },
+                createdAt: record.header.createdAt,
+            }));
         }
-        catch (error) {
-            if (signal?.aborted === true)
-                throw cancelled(signal);
-            throw new SessionReferenceError(`failed to read referenced session: ${error instanceof Error ? error.message : String(error)}`, 'SESSION_REFERENCE_READ_FAILED', { cause: error });
+        /**
+         * Remote face of {@link listCandidates}: the configured candidate limit
+         * applies, and every candidate carries the canonical mention a host inserts
+         * into the prompt draft.
+         * @param agent - target agent; self is excluded and its cwd drives ranking.
+         * @param query - optional case-insensitive session-id/cwd/title substring.
+         * @param signal - caller cancellation.
+         * @returns mention-carrying candidates in rank order.
+         */
+        async remoteExportCandidates(agent, query, signal) {
+            const candidates = await this.listCandidates(agent, query, this.config.candidateLimit, signal);
+            return candidates.map(candidate => ({
+                ...candidate,
+                mention: formatSessionReferenceMention({ sessionId: candidate.sessionId, label: candidate.label }),
+            }));
         }
-        assertNotCancelled(signal);
-        const rendered = this.renderSources(prepared);
-        const prompt = renderPrompt(rendered.map(source => source.data));
-        const source = {
-            kind: 'session-reference',
-            form: 'recall',
-            version: 1,
-            references: rendered.map((source, index) => ({
-                sessionId: source.data.sessionId,
-                label: source.data.label,
-                capturedThroughSeq: source.data.capturedThroughSeq,
-                ...source.stats,
-                inputIndex: index,
-            })),
-        };
-        const additionalContext = createUserMessage({
-            source,
-            content: [{ type: 'text', text: prompt }],
-        });
-        return { content: acceptedContent, additionalContext };
-    }
-    renderSources(sources) {
-        const rendered = [];
-        for (const source of sources) {
-            const retained = retainReferencedSession(source.snapshot, source.input.label, this.config.maxReferenceBytes);
-            if (retained === undefined) {
-                throw new SessionReferenceError('referenced session snapshot cannot fit the configured byte budget', 'SESSION_REFERENCE_BUDGET_EXCEEDED');
+        /**
+         * Snapshot all references for one accepted direct message and return one aggregated durable context.
+         * @param agent - target agent; references to it are rejected.
+         * @param content - already host-normalized readable message content.
+         * @param references - structured source sessions in mention order.
+         * @param signal - optional cancellation boundary for the active turn.
+         * @returns detached content and optional referenced-session context.
+         */
+        async prepare(agent, content, references, signal) {
+            const acceptedContent = structuredClone(content);
+            const inputs = normalizeReferences(agent.id, references, this.config.maxReferences);
+            if (inputs.length === 0)
+                return { content: acceptedContent };
+            assertNotCancelled(signal);
+            let prepared;
+            try {
+                prepared = await settleWithCancellation(Promise.all(inputs.map(async (input) => ({
+                    input,
+                    snapshot: await this.ctx.sessionQuery.readSurface(input.sessionId),
+                }))), signal);
+            }
+            catch (error) {
+                if (signal?.aborted === true)
+                    throw cancelled(signal);
+                throw new SessionReferenceError(`failed to read referenced session: ${error instanceof Error ? error.message : String(error)}`, 'SESSION_REFERENCE_READ_FAILED', { cause: error });
             }
-            rendered.push(retained);
+            assertNotCancelled(signal);
+            const rendered = this.renderSources(prepared);
+            const prompt = renderPrompt(rendered.map(source => source.data));
+            const source = {
+                kind: 'session-reference',
+                form: 'recall',
+                version: 1,
+                references: rendered.map((source, index) => ({
+                    sessionId: source.data.sessionId,
+                    label: source.data.label,
+                    capturedThroughSeq: source.data.capturedThroughSeq,
+                    ...source.stats,
+                    inputIndex: index,
+                })),
+            };
+            const additionalContext = createUserMessage({
+                source,
+                content: [{ type: 'text', text: prompt }],
+            });
+            return { content: acceptedContent, additionalContext };
         }
-        return rendered;
-    }
-}
+        renderSources(sources) {
+            const rendered = [];
+            for (const source of sources) {
+                const retained = retainReferencedSession(source.snapshot, source.input.label, this.config.maxReferenceBytes);
+                if (retained === undefined) {
+                    throw new SessionReferenceError('referenced session snapshot cannot fit the configured byte budget', 'SESSION_REFERENCE_BUDGET_EXCEEDED');
+                }
+                rendered.push(retained);
+            }
+            return rendered;
+        }
+    };
+})();
+export { SessionReferenceResolver };
 function normalizeReferences(targetId, references, maxReferences) {
     const seen = new Set();
     const normalized = [];

package/dist/kernel/session-reference/lib/types/types.d.ts

@@ -1,6 +1,12 @@
-/** Public session-reference request, candidate, and preparation records. */
-import type { ContentBlock } from '../../../llm/lib/index.js';
-import type { SessionId, UserMessage } from '../../../session/lib/index.js';
+/**
+ * Public session-reference request, candidate, and preparation records.
+ * Imports stay on type-only subpaths so generated Remote clients can consume
+ * this module without Host runtime code.
+ * @module @nomix-ai/nomix-session-reference/types
+ */
+import type { UserMessage } from '../../../llm/lib/types/message.js';
+import type { ContentBlock } from '../../../llm/lib/types/types.js';
+import type { SessionId } from '../../../session/lib/types/types.js';
 /** Durable source session, cited event seqs, and snapshot facts for prepared cross-session context. */
 export interface SessionReferenceSource {
     kind: 'session-reference';
@@ -43,6 +49,11 @@ export interface SessionReferenceCandidate {
     /** Source session creation time in Unix epoch milliseconds. */
     createdAt: number;
 }
+/** One discovery candidate carrying its canonical prompt mention. */
+export interface SessionReferenceMentionCandidate extends SessionReferenceCandidate {
+    /** Canonical `@[label](nomix-session:…)` mention serialized into the prompt draft. */
+    mention: string;
+}
 /** Direct message content and optional referenced-session context. */
 export interface PreparedReferencedMessage {
     /** Readable message content after host mention tokens are removed. */

package/dist/kernel/session-reference/lib/types/types.js

@@ -1,3 +1,8 @@
-/** Public session-reference request, candidate, and preparation records. */
+/**
+ * Public session-reference request, candidate, and preparation records.
+ * Imports stay on type-only subpaths so generated Remote clients can consume
+ * this module without Host runtime code.
+ * @module @nomix-ai/nomix-session-reference/types
+ */
 export {};
 //# sourceMappingURL=types.js.map

package/dist/kernel/session-reference/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-session-reference",
   "description": "Cross-session snapshot references and durable untrusted model context (ctx.sessionReferenceResolver)",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },
@@ -22,17 +22,35 @@
       "types": "./lib/types/invariant.d.ts",
       "default": "./lib/invariant.js"
     },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./typert": {
+      "types": "./lib/typert.host.d.ts",
+      "default": "./lib/typert.host.js"
+    },
+    "./remote": {
+      "types": "./lib/typert.remote-client.d.ts",
+      "default": "./lib/typert.remote-client.js"
+    },
     "./src/*": "./src/*",
     "./package.json": "./package.json"
   },
   "files": [
     "lib/index.js",
     "lib/invariant.js",
-    "lib/types/**/*.d.ts"
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts",
+    "lib/typert.host.js",
+    "lib/typert.host.d.ts",
+    "lib/typert.remote-client.js",
+    "lib/typert.remote-client.d.ts"
   ],
   "license": "MIT",
   "dependencies": {
-    "@nomix-ai/schemastery": "workspace:^"
+    "@nomix-ai/schemastery": "workspace:^",
+    "zod": "^4.4.3"
   },
   "peerDependencies": {
     "@nomix-ai/nomix-agent": "workspace:^",
@@ -42,6 +60,7 @@
     "@nomix-ai/nomix-output-retention": "workspace:^",
     "@nomix-ai/nomix-session": "workspace:^",
     "@nomix-ai/nomix-session-query": "workspace:^",
+    "@nomix-ai/nomix-typert-protocol": "workspace:^",
     "@nomix-ai/cordis": "workspace:^"
   },
   "devDependencies": {
@@ -52,6 +71,7 @@
     "@nomix-ai/nomix-output-retention": "workspace:^",
     "@nomix-ai/nomix-session": "workspace:^",
     "@nomix-ai/nomix-session-query": "workspace:^",
+    "@nomix-ai/nomix-typert-protocol": "workspace:^",
     "@nomix-ai/cordis": "workspace:^"
   }
 }

package/dist/kernel/session-stats/lib/index.js

@@ -36,6 +36,22 @@ const sessionStatsSchema = z.object({
 	decodeTokens: z.number().nonnegative()
 }).strict();
 /**
+* The fold state's shape (totals plus in-flight boundaries), validated on
+* persisted-cache rows after their `ver` gate — the unit's input boundary.
+* The view is a strict subset of the state, so this schema extends
+* `sessionStatsSchema` (the wire output boundary) with the boundary fields.
+*/
+const sessionStatsStateSchema = sessionStatsSchema.extend({
+	lastTurn: z.number().int().nonnegative().nullable(),
+	openStep: z.object({
+		turn: z.number().int().nonnegative(),
+		step: z.number().int().nonnegative(),
+		startTime: z.number().nonnegative(),
+		firstTokenTime: z.number().nonnegative().nullable()
+	}).nullable(),
+	pendingCalls: z.record(z.string(), z.number().nonnegative())
+});
+/**
 * Provider-reported completion tokens, guarded the way the window fold guards
 * node usage.
 * @param usage - the assistant/message event's optional usage record.
@@ -49,7 +65,8 @@ function usageOutputTokens(usage) {
 /** The `sessionStats` unit registered on `ctx.sessionProjections` (exported for the unit spec). */
 const sessionStatsProjectionDefinition = {
 	key: "sessionStats",
-	schema: sessionStatsSchema,
+	stateVersion: 1,
+	stateSchema: sessionStatsStateSchema,
 	init: () => ({
 		turns: 0,
 		steps: 0,
@@ -137,17 +154,19 @@ const sessionStatsProjectionDefinition = {
 			default: return state;
 		}
 	},
-	view: (state) => ({
-		turns: state.turns,
-		steps: state.steps,
-		llmMs: state.llmMs,
-		toolMs: state.toolMs,
-		ttftMs: state.ttftMs,
-		ttftSteps: state.ttftSteps,
-		decodeMs: state.decodeMs,
-		decodeTokens: state.decodeTokens
-	}),
-	stateVersion: 1
+	wire: {
+		viewSchema: sessionStatsSchema,
+		view: (state) => ({
+			turns: state.turns,
+			steps: state.steps,
+			llmMs: state.llmMs,
+			toolMs: state.toolMs,
+			ttftMs: state.ttftMs,
+			ttftSteps: state.ttftSteps,
+			decodeMs: state.decodeMs,
+			decodeTokens: state.decodeTokens
+		})
+	}
 };
 //#endregion
 //#region lib/types/index.js

package/dist/kernel/session-stats/lib/types/projection.d.ts

@@ -22,7 +22,7 @@
  *
  * @module @nomix-ai/nomix-session-stats/projection
  */
-import type { ProjectionDefinition } from '../../../session-projection/lib/index.js';
+import { z } from 'zod';
 /** Accumulated whole-log figures (the view is exactly these totals). */
 interface SessionStatsTotals {
     /** Distinct turns with at least one closed step so far. */
@@ -61,7 +61,69 @@ interface SessionStatsState extends SessionStatsTotals {
     /** Dispatch times of tool calls whose result has not landed, by callId. */
     pendingCalls: Record<string, number>;
 }
+declare module '@nomix-ai/nomix-session-projection/types' {
+    interface SessionProjectionStateMap {
+        sessionStats: SessionStatsState;
+    }
+}
 /** The `sessionStats` unit registered on `ctx.sessionProjections` (exported for the unit spec). */
-export declare const sessionStatsProjectionDefinition: ProjectionDefinition<'sessionStats', SessionStatsState>;
+export declare const sessionStatsProjectionDefinition: {
+    key: "sessionStats";
+    stateVersion: number;
+    stateSchema: z.ZodObject<{
+        turns: z.ZodNumber;
+        steps: z.ZodNumber;
+        llmMs: z.ZodNumber;
+        toolMs: z.ZodNumber;
+        ttftMs: z.ZodNumber;
+        ttftSteps: z.ZodNumber;
+        decodeMs: z.ZodNumber;
+        decodeTokens: z.ZodNumber;
+        lastTurn: z.ZodNullable<z.ZodNumber>;
+        openStep: z.ZodNullable<z.ZodObject<{
+            turn: z.ZodNumber;
+            step: z.ZodNumber;
+            startTime: z.ZodNumber;
+            firstTokenTime: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        pendingCalls: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strict>;
+    init: () => {
+        turns: number;
+        steps: number;
+        llmMs: number;
+        toolMs: number;
+        ttftMs: number;
+        ttftSteps: number;
+        decodeMs: number;
+        decodeTokens: number;
+        lastTurn: null;
+        openStep: null;
+        pendingCalls: {};
+    };
+    apply: (state: NoInfer<SessionStatsState>, event: import("../../../session/lib/index.js").SessionEvent) => SessionStatsState;
+    wire: {
+        viewSchema: z.ZodObject<{
+            turns: z.ZodNumber;
+            steps: z.ZodNumber;
+            llmMs: z.ZodNumber;
+            toolMs: z.ZodNumber;
+            ttftMs: z.ZodNumber;
+            ttftSteps: z.ZodNumber;
+            decodeMs: z.ZodNumber;
+            decodeTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        view: (state: NoInfer<SessionStatsState>) => {
+            turns: number;
+            steps: number;
+            llmMs: number;
+            toolMs: number;
+            ttftMs: number;
+            ttftSteps: number;
+            decodeMs: number;
+            decodeTokens: number;
+        };
+    };
+};
 export {};
 //# sourceMappingURL=projection.d.ts.map