@nomix-ai/nomix-harness 0.2.5 → 0.2.6

package/dist/kernel/token-meter/lib/types/usage-projection.d.ts

@@ -1,32 +1,51 @@
 /**
  * Pure folds for durable provider-reported token usage and context occupancy.
  */
-import type { ProjectionDefinition } from '../../../session-projection/lib/index.js';
-import type { TokenUsageProjection } from './projection.ts';
-import type { ShadowPriceClaim } from './surface-projection.ts';
-interface UsageSample {
-    turn: number;
-    step: number;
-    buckets: TokenUsageProjection;
-}
-interface TokenUsageState {
-    totals: TokenUsageProjection;
-    last: UsageSample | null;
-}
+import { z } from 'zod';
+import type { SessionEvent } from '../../../session/lib/index.js';
+import type { ContextPressureProjection, TokenUsageProjection } from './projection.ts';
 /**
- * Context-occupancy state: the two independent last-wins records plus the
- * O(1) running surface total needed to carry the newest sample forward.
+ * The token-usage unit's state schema — the one definition of the state
+ * shape; the state type is inferred from it.
  */
-interface ContextPressureState {
-    contextWindow?: number;
-    pressureTokens?: number;
-    /** Running heuristic total over the current surface ({@link foldSurfaceProjection}). */
-    surfaceTokens: number;
-    /** {@link surfaceTokens} at the newest usage sample; absent until one lands. */
-    sampledSurfaceTokens?: number;
-    /** Shadow price armed by the immediately preceding metering event. */
-    claim?: ShadowPriceClaim;
+declare const tokenUsageStateSchema: z.ZodObject<{
+    totals: z.ZodObject<{
+        uncachedInputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        cacheReadTokens: z.ZodNumber;
+        cacheWriteTokens: z.ZodNumber;
+    }, z.core.$strict>;
+    last: z.ZodNullable<z.ZodObject<{
+        turn: z.ZodNumber;
+        step: z.ZodNumber;
+        buckets: z.ZodObject<{
+            uncachedInputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            cacheReadTokens: z.ZodNumber;
+            cacheWriteTokens: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+type TokenUsageState = z.infer<typeof tokenUsageStateSchema>;
+declare module '@nomix-ai/nomix-session-projection/types' {
+    interface SessionProjectionStateMap {
+        tokenUsage: TokenUsageState;
+        contextPressure: ContextPressureState;
+    }
 }
+/** The context-pressure state schema and source of its inferred type. */
+declare const contextPressureStateSchema: z.ZodObject<{
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    pressureTokens: z.ZodOptional<z.ZodNumber>;
+    surfaceTokens: z.ZodNumber;
+    sampledSurfaceTokens: z.ZodOptional<z.ZodNumber>;
+    claim: z.ZodOptional<z.ZodObject<{
+        start: z.ZodNumber;
+        end: z.ZodNumber;
+        tokens: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
+type ContextPressureState = z.infer<typeof contextPressureStateSchema>;
 /**
  * Token-meter's session projection unit.
  *
@@ -37,7 +56,98 @@ interface ContextPressureState {
  * that usage reports for one turn/step are adjacent: once a later step begins,
  * a legal log never reports usage for an earlier step again.
  */
-export declare const tokenUsageProjectionDefinition: ProjectionDefinition<'tokenUsage', TokenUsageState>;
+export declare const tokenUsageProjectionDefinition: {
+    key: "tokenUsage";
+    stateVersion: number;
+    stateSchema: z.ZodObject<{
+        totals: z.ZodObject<{
+            uncachedInputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            cacheReadTokens: z.ZodNumber;
+            cacheWriteTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        last: z.ZodNullable<z.ZodObject<{
+            turn: z.ZodNumber;
+            step: z.ZodNumber;
+            buckets: z.ZodObject<{
+                uncachedInputTokens: z.ZodNumber;
+                outputTokens: z.ZodNumber;
+                cacheReadTokens: z.ZodNumber;
+                cacheWriteTokens: z.ZodNumber;
+            }, z.core.$strict>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    init: () => {
+        totals: TokenUsageProjection;
+        last: null;
+    };
+    apply: (state: NoInfer<{
+        totals: {
+            uncachedInputTokens: number;
+            outputTokens: number;
+            cacheReadTokens: number;
+            cacheWriteTokens: number;
+        };
+        last: {
+            turn: number;
+            step: number;
+            buckets: {
+                uncachedInputTokens: number;
+                outputTokens: number;
+                cacheReadTokens: number;
+                cacheWriteTokens: number;
+            };
+        } | null;
+    }>, event: SessionEvent) => {
+        totals: {
+            uncachedInputTokens: number;
+            outputTokens: number;
+            cacheReadTokens: number;
+            cacheWriteTokens: number;
+        };
+        last: {
+            turn: number;
+            step: number;
+            buckets: {
+                uncachedInputTokens: number;
+                outputTokens: number;
+                cacheReadTokens: number;
+                cacheWriteTokens: number;
+            };
+        } | null;
+    };
+    wire: {
+        viewSchema: z.ZodObject<{
+            uncachedInputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            cacheReadTokens: z.ZodNumber;
+            cacheWriteTokens: z.ZodNumber;
+        }, z.core.$strict>;
+        view: (state: NoInfer<{
+            totals: {
+                uncachedInputTokens: number;
+                outputTokens: number;
+                cacheReadTokens: number;
+                cacheWriteTokens: number;
+            };
+            last: {
+                turn: number;
+                step: number;
+                buckets: {
+                    uncachedInputTokens: number;
+                    outputTokens: number;
+                    cacheReadTokens: number;
+                    cacheWriteTokens: number;
+                };
+            } | null;
+        }>) => {
+            uncachedInputTokens: number;
+            outputTokens: number;
+            cacheReadTokens: number;
+            cacheWriteTokens: number;
+        };
+    };
+};
 /**
  * Token-meter's context-occupancy projection unit.
  *
@@ -59,6 +169,57 @@ export declare const tokenUsageProjectionDefinition: ProjectionDefinition<'token
  * BEFORE the same event joins the surface, so an `assistant/message` anchors
  * against the surface its own request saw.
  */
-export declare const contextPressureProjectionDefinition: ProjectionDefinition<'contextPressure', ContextPressureState>;
+export declare const contextPressureProjectionDefinition: {
+    key: "contextPressure";
+    stateVersion: number;
+    stateSchema: z.ZodObject<{
+        contextWindow: z.ZodOptional<z.ZodNumber>;
+        pressureTokens: z.ZodOptional<z.ZodNumber>;
+        surfaceTokens: z.ZodNumber;
+        sampledSurfaceTokens: z.ZodOptional<z.ZodNumber>;
+        claim: z.ZodOptional<z.ZodObject<{
+            start: z.ZodNumber;
+            end: z.ZodNumber;
+            tokens: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    init: () => {
+        surfaceTokens: number;
+    };
+    apply: (state: NoInfer<{
+        surfaceTokens: number;
+        contextWindow?: number | undefined;
+        pressureTokens?: number | undefined;
+        sampledSurfaceTokens?: number | undefined;
+        claim?: {
+            start: number;
+            end: number;
+            tokens: number;
+        } | undefined;
+    }>, event: SessionEvent) => {
+        surfaceTokens: number;
+        contextWindow?: number | undefined;
+        pressureTokens?: number | undefined;
+        sampledSurfaceTokens?: number | undefined;
+    };
+    wire: {
+        viewSchema: z.ZodType<ContextPressureProjection, unknown, z.core.$ZodTypeInternals<ContextPressureProjection, unknown>>;
+        view: ({ contextWindow, pressureTokens, surfaceTokens, sampledSurfaceTokens }: NoInfer<{
+            surfaceTokens: number;
+            contextWindow?: number | undefined;
+            pressureTokens?: number | undefined;
+            sampledSurfaceTokens?: number | undefined;
+            claim?: {
+                start: number;
+                end: number;
+                tokens: number;
+            } | undefined;
+        }>) => {
+            projectedTokens?: number;
+            pressureTokens?: number;
+            contextWindow?: number;
+        };
+    };
+};
 export {};
 //# sourceMappingURL=usage-projection.d.ts.map

package/dist/kernel/token-meter/lib/types/usage-projection.js

@@ -31,13 +31,27 @@ const projectionSchema = z.object({
     cacheReadTokens: z.number().int().nonnegative(),
     cacheWriteTokens: z.number().int().nonnegative(),
 }).strict();
-// Cast for the optional values: under exactOptionalPropertyTypes zod infers
-// `number | undefined` where the interface declares absent-or-number fields.
+/**
+ * The token-usage unit's state schema — the one definition of the state
+ * shape; the state type is inferred from it.
+ */
+const tokenUsageStateSchema = z.object({
+    totals: projectionSchema,
+    last: z.object({
+        turn: z.number().int().nonnegative(),
+        step: z.number().int().nonnegative(),
+        buckets: projectionSchema,
+    }).nullable(),
+}).strict();
 const pressureSchema = z.object({
     pressureTokens: z.number().int().nonnegative().optional(),
     projectedTokens: z.number().int().nonnegative().optional(),
     contextWindow: z.number().int().positive().optional(),
-}).strict();
+}).strict().transform(({ pressureTokens, projectedTokens, contextWindow }) => ({
+    ...pressureTokens === undefined ? {} : { pressureTokens },
+    ...projectedTokens === undefined ? {} : { projectedTokens },
+    ...contextWindow === undefined ? {} : { contextWindow },
+}));
 /** Prompt-side pressure of one request: input plus cache traffic, no output. */
 const pressureFrom = (usage) => usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
 /** The usage a chunk or finalized message reports for its step, if any. */
@@ -46,6 +60,18 @@ const usageOf = (event) => event.type === 'assistant/chunk' && event.data.chunk.
     : event.type === 'assistant/message'
         ? event.data.usage
         : undefined;
+/** The context-pressure state schema and source of its inferred type. */
+const contextPressureStateSchema = z.object({
+    contextWindow: z.number().int().positive().optional(),
+    pressureTokens: z.number().int().nonnegative().optional(),
+    surfaceTokens: z.number().int().nonnegative(),
+    sampledSurfaceTokens: z.number().int().nonnegative().optional(),
+    claim: z.object({
+        start: z.number().int().nonnegative(),
+        end: z.number().int().nonnegative(),
+        tokens: z.number().int().nonnegative(),
+    }).optional(),
+}).strict();
 /**
  * Token-meter's session projection unit.
  *
@@ -58,7 +84,8 @@ const usageOf = (event) => event.type === 'assistant/chunk' && event.data.chunk.
  */
 export const tokenUsageProjectionDefinition = {
     key: 'tokenUsage',
-    schema: projectionSchema,
+    stateVersion: 1,
+    stateSchema: tokenUsageStateSchema,
     init: () => ({ totals: zeroBuckets(), last: null }),
     apply: (state, event) => {
         let turn;
@@ -89,8 +116,7 @@ export const tokenUsageProjectionDefinition = {
             last: { turn, step, buckets },
         };
     },
-    view: state => state.totals,
-    stateVersion: 1,
+    wire: { viewSchema: projectionSchema, view: state => state.totals },
 };
 /**
  * Token-meter's context-occupancy projection unit.
@@ -115,7 +141,8 @@ export const tokenUsageProjectionDefinition = {
  */
 export const contextPressureProjectionDefinition = {
     key: 'contextPressure',
-    schema: pressureSchema,
+    stateVersion: 4,
+    stateSchema: contextPressureStateSchema,
     init: () => ({ surfaceTokens: 0 }),
     apply: (state, event) => {
         const fold = foldSurfaceProjection(state.claim, event);
@@ -149,13 +176,15 @@ export const contextPressureProjectionDefinition = {
         const { claim: _expired, ...withoutClaim } = next;
         return fold.claim === undefined ? withoutClaim : { ...withoutClaim, claim: fold.claim };
     },
-    view: ({ contextWindow, pressureTokens, surfaceTokens, sampledSurfaceTokens }) => ({
-        ...contextWindow === undefined ? {} : { contextWindow },
-        ...pressureTokens === undefined ? {} : { pressureTokens },
-        ...pressureTokens === undefined || sampledSurfaceTokens === undefined
-            ? {}
-            : { projectedTokens: Math.max(0, pressureTokens + surfaceTokens - sampledSurfaceTokens) },
-    }),
-    stateVersion: 4,
+    wire: {
+        viewSchema: pressureSchema,
+        view: ({ contextWindow, pressureTokens, surfaceTokens, sampledSurfaceTokens }) => ({
+            ...contextWindow === undefined ? {} : { contextWindow },
+            ...pressureTokens === undefined ? {} : { pressureTokens },
+            ...pressureTokens === undefined || sampledSurfaceTokens === undefined
+                ? {}
+                : { projectedTokens: Math.max(0, pressureTokens + surfaceTokens - sampledSurfaceTokens) },
+        }),
+    },
 };
 //# sourceMappingURL=usage-projection.js.map

package/dist/kernel/token-meter/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-token-meter",
   "description": "Replay-aware token measurement service (ctx.tokenMeter) for the Nomix Harness",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/tool-ask-user/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-ask-user",
   "description": "Model-facing ask_user_question tool over the ctx.userQuestions seam",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/tool-bash/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-bash",
   "description": "Model-facing bash tool with optional generic background-job and sandbox-escalation support",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/tool-bash-persistent/lib/index.js

@@ -161,6 +161,18 @@ function appendStatusMarker(content, marker) {
 function renderShellExitStatus(content, exitCode, signal) {
 	return appendStatusMarker(content, signal !== null ? `[shell killed by signal: ${signal}]` : exitCode !== null ? `[shell exited: code ${exitCode}]` : "[shell exited]");
 }
+/**
+* Render the exited-session result, reset the owner's shell, and reset the
+* message that tells the model the next call starts fresh.
+* @param shells - the owner-scoped registry to reset.
+* @param status - the exited session status (exit code and signal).
+* @returns the complete model-facing result.
+*/
+async function respondToSessionExit(ctx, shells, owner, id, status, marker, fallback, fallbackTruncated, config) {
+	const snapshot = retainedScrollback(ctx, owner, id);
+	await shells.reset(owner, "persistent bash shell exited");
+	return [renderShellExitStatus(renderCaptured(partialOutput(snapshot, marker, fallback, fallbackTruncated), config.maxOutputChars), status.exitCode, status.signal), SHELL_RESET_MESSAGE].filter((part) => part.length > 0).join("\n");
+}
 function persistentShells(ctx, config) {
 	const pending = /* @__PURE__ */ new WeakMap();
 	const live = /* @__PURE__ */ new Map();
@@ -243,6 +255,8 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
 		let fallback = "";
 		let fallbackTruncated = false;
 		while (true) {
+			const status = ctx.terminals.list(owner).find((session) => session.sessionId === id)?.status;
+			if (status?.kind === "exited") return await respondToSessionExit(ctx, shells, owner, id, status, marker, fallback, fallbackTruncated, config);
 			let operation;
 			let result;
 			try {
@@ -282,11 +296,7 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
 				const complete = commandOutput(retainedScrollback(ctx, owner, id, latest), marker);
 				if (complete !== void 0) return renderCaptured(complete, config.maxOutputChars);
 			}
-			if (result.sessionStatus.kind === "exited") {
-				const snapshot = retainedScrollback(ctx, owner, id, latest);
-				await shells.reset(owner, "persistent bash shell exited");
-				return [renderShellExitStatus(renderCaptured(partialOutput(snapshot, marker, fallback, fallbackTruncated), config.maxOutputChars), result.sessionStatus.exitCode, result.sessionStatus.signal), SHELL_RESET_MESSAGE].filter((part) => part.length > 0).join("\n");
-			}
+			if (result.sessionStatus.kind === "exited") return await respondToSessionExit(ctx, shells, owner, id, result.sessionStatus, marker, fallback, fallbackTruncated, config);
 			if (result.waitReason === "stdin_read") return renderCaptured(partialOutput(retainedScrollback(ctx, owner, id, latest), marker, fallback, fallbackTruncated), config.maxOutputChars);
 			await pause();
 		}

package/dist/kernel/tool-bash-persistent/lib/types/index.js

@@ -180,6 +180,21 @@ function renderShellExitStatus(content, exitCode, signal) {
             : '[shell exited]';
     return appendStatusMarker(content, marker);
 }
+/**
+ * Render the exited-session result, reset the owner's shell, and reset the
+ * message that tells the model the next call starts fresh.
+ * @param shells - the owner-scoped registry to reset.
+ * @param status - the exited session status (exit code and signal).
+ * @returns the complete model-facing result.
+ */
+async function respondToSessionExit(ctx, shells, owner, id, status, marker, fallback, fallbackTruncated, config) {
+    const snapshot = retainedScrollback(ctx, owner, id);
+    await shells.reset(owner, 'persistent bash shell exited');
+    return [
+        renderShellExitStatus(renderCaptured(partialOutput(snapshot, marker, fallback, fallbackTruncated), config.maxOutputChars), status.exitCode, status.signal),
+        SHELL_RESET_MESSAGE,
+    ].filter(part => part.length > 0).join('\n');
+}
 function persistentShells(ctx, config) {
     const pending = new WeakMap();
     const live = new Map();
@@ -263,6 +278,13 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
         let fallback = '';
         let fallbackTruncated = false;
         while (true) {
+            // The shell may flip to exited between iterations (a fast `exit` can
+            // settle the previous send while its exit event is still in flight);
+            // re-observing status before the next send closes that gap.
+            const status = ctx.terminals.list(owner).find(session => session.sessionId === id)?.status;
+            if (status?.kind === 'exited') {
+                return await respondToSessionExit(ctx, shells, owner, id, status, marker, fallback, fallbackTruncated, config);
+            }
             let operation;
             let result;
             try {
@@ -304,12 +326,7 @@ async function executeCommand(ctx, shells, owner, command, config, upstream) {
                     return renderCaptured(complete, config.maxOutputChars);
             }
             if (result.sessionStatus.kind === 'exited') {
-                const snapshot = retainedScrollback(ctx, owner, id, latest);
-                await shells.reset(owner, 'persistent bash shell exited');
-                return [
-                    renderShellExitStatus(renderCaptured(partialOutput(snapshot, marker, fallback, fallbackTruncated), config.maxOutputChars), result.sessionStatus.exitCode, result.sessionStatus.signal),
-                    SHELL_RESET_MESSAGE,
-                ].filter(part => part.length > 0).join('\n');
+                return await respondToSessionExit(ctx, shells, owner, id, result.sessionStatus, marker, fallback, fallbackTruncated, config);
             }
             // The shell reads stdin again (its prompt, or a foreground child's own
             // read) without having printed the end marker — e.g. `exec`, an interrupt,

package/dist/kernel/tool-bash-persistent/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-bash-persistent",
   "description": "Model-facing owner-scoped persistent Bash tool backed by the Harness PTY service",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/tool-call-timeout-policy/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-tool-call-timeout-policy",
   "description": "Tool-call timeout policy: a tools/execute wrapper that arms a per-tool deadline on exec.signal and returns TOOL_TIMEOUT when it wins",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },