@aiwg/cli 2026.10.4 → 2026.10.6

package/dist/src/sessions/adapters/factory.js

@@ -1,11 +1,12 @@
 import { opendir } from 'node:fs/promises';
 import { basename, extname, resolve } from 'node:path';
 import { z } from 'zod';
+import { number } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
 import { streamBoundedJsonLines, } from '../readers.js';
 export const FACTORY_ADAPTER_VERSION = '1.0.0';
 export const FACTORY_SOURCE_SCHEMA_VERSION = '1.0.0';
-const FactoryRecordSchema = z.object({
+const FactoryRecordSchema = z.looseObject({
     schemaVersion: z.string().optional(),
     type: z.string().min(1),
     subtype: z.string().optional(),
@@ -14,21 +15,21 @@ const FactoryRecordSchema = z.object({
     parentUuid: z.string().nullable().optional(),
     sessionId: z.string().min(1).optional(),
     session_id: z.string().min(1).optional(),
-    timestamp: z.union([z.string(), z.number()]).optional(),
-    createdAt: z.number().optional(),
-    updatedAt: z.number().optional(),
+    timestamp: z.union([z.string(), number()]).optional(),
+    createdAt: number().optional(),
+    updatedAt: number().optional(),
     cwd: z.string().optional(),
-    version: z.union([z.string(), z.number()]).optional(),
-    message: z.object({
+    version: z.union([z.string(), number()]).optional(),
+    message: z.looseObject({
         id: z.string().optional(),
         role: z.string().optional(),
         content: z.union([z.string(), z.array(z.unknown())]).optional(),
-    }).passthrough().optional(),
+    }).optional(),
     content: z.union([z.string(), z.array(z.unknown())]).optional(),
-    sessionSettings: z.record(z.unknown()).optional(),
-    settings: z.record(z.unknown()).optional(),
+    sessionSettings: z.record(z.string(), z.unknown()).optional(),
+    settings: z.record(z.string(), z.unknown()).optional(),
     status: z.string().optional(),
-}).passthrough();
+});
 export class FactorySessionAdapter {
     limits;
     transports;

package/dist/src/sessions/adapters/generic.js

@@ -1,11 +1,12 @@
 import { z } from 'zod';
+import { integer } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
 import { streamBoundedJsonLines } from '../readers.js';
 export const GENERIC_INTERCHANGE_KIND = 'aiwg.session-interchange';
 export const GENERIC_ADAPTER_VERSION = '1.0.0';
 const Rfc3339Schema = z.string().refine((value) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value)
     && !Number.isNaN(Date.parse(value)), 'timestamp must be RFC 3339 with an explicit UTC offset');
-export const GenericInterchangeHeaderSchema = z.object({
+export const GenericInterchangeHeaderSchema = z.looseObject({
     type: z.literal(GENERIC_INTERCHANGE_KIND),
     schemaVersion: z.string().regex(/^\d+\.\d+\.\d+$/),
     product: z.string().min(1),
@@ -14,24 +15,24 @@ export const GenericInterchangeHeaderSchema = z.object({
     exportedAt: Rfc3339Schema,
     consistency: z.enum(['provisional', 'consistent-snapshot', 'complete']),
     lifecycle: z.enum(['active', 'complete', 'archived']),
-    workspace: z.object({
+    workspace: z.looseObject({
         id: z.string().min(1),
         name: z.string().min(1).optional(),
         repository: z.string().min(1).optional(),
         branch: z.string().min(1).optional(),
-    }).passthrough(),
-    provenance: z.object({
+    }),
+    provenance: z.looseObject({
         exporter: z.string().min(1),
         exporterVersion: z.string().min(1),
         sourceClass: z.string().min(1),
-    }).passthrough(),
-    extensions: z.record(z.unknown()).default({}),
-}).passthrough();
-export const GenericInterchangeEventSchema = z.object({
+    }),
+    extensions: z.record(z.string(), z.unknown()).prefault({}),
+});
+export const GenericInterchangeEventSchema = z.looseObject({
     type: z.literal('event'),
     sessionId: z.string().min(1),
     eventId: z.string().min(1),
-    sequence: z.number().int().nonnegative(),
+    sequence: integer().nonnegative(),
     kind: z.string().min(1),
     role: z.string().min(1).optional(),
     participant: z.string().min(1).optional(),
@@ -43,8 +44,8 @@ export const GenericInterchangeEventSchema = z.object({
     occurredAt: Rfc3339Schema.optional(),
     text: z.string(),
     lifecycle: z.enum(['active', 'complete', 'archived']),
-    extensions: z.record(z.unknown()).default({}),
-}).passthrough();
+    extensions: z.record(z.string(), z.unknown()).prefault({}),
+});
 export class GenericSessionInterchangeAdapter {
     limits;
     provider = 'generic';
@@ -207,7 +208,7 @@ function parseHeader(value) {
     if (!isDeclaredInterchange(value)) {
         throw new SessionContractError('MALFORMED_SOURCE', 'input is not a declared AIWG generic session interchange', schemaRejectionDetail(result.error));
     }
-    throw new SessionContractError('MALFORMED_SOURCE', `generic interchange header ${describeIssue(result.error, true)}`, schemaRejectionDetail(result.error));
+    throw new SessionContractError('MALFORMED_SOURCE', `generic interchange header ${describeIssue(result.error, true, value)}`, schemaRejectionDetail(result.error));
 }
 function parseEvent(value) {
     const result = GenericInterchangeEventSchema.safeParse(value);
@@ -218,7 +219,7 @@ function parseEvent(value) {
     }
     // Event values can carry transcript content, so name the field and the
     // expected shape without echoing the received value.
-    throw new SessionContractError('MALFORMED_SOURCE', `generic interchange event is malformed: ${describeIssue(result.error, false)}`, schemaRejectionDetail(result.error));
+    throw new SessionContractError('MALFORMED_SOURCE', `generic interchange event is malformed: ${describeIssue(result.error, false, value)}`, schemaRejectionDetail(result.error));
 }
 function isDeclaredInterchange(value) {
     return typeof value === 'object' && value !== null
@@ -228,20 +229,28 @@ function quoteValue(value) {
     const text = typeof value === 'string' ? value : JSON.stringify(value) ?? String(value);
     return JSON.stringify(text.length > 64 ? `${text.slice(0, 64)}…` : text);
 }
-function describeIssue(error, echoReceived) {
+function describeIssue(error, echoReceived, value) {
     const issue = error.issues[0];
     const field = issue.path.length > 0 ? `field "${issue.path.join('.')}"` : 'record';
-    if (issue.code === z.ZodIssueCode.invalid_enum_value) {
-        const received = echoReceived ? ` (got ${quoteValue(issue.received)})` : '';
-        return `${field} must be one of ${issue.options.join('|')}${received}`;
+    // Read only the failing field, retaining the existing policy that header
+    // enums may echo values while event transcript values are never echoed.
+    let input = value;
+    for (const key of issue.path) {
+        input = input !== null && typeof input === 'object'
+            ? input[key] : undefined;
     }
-    if (issue.code === z.ZodIssueCode.invalid_type) {
-        return issue.received === 'undefined'
-            ? `${field} is required (${issue.expected})`
-            : `${field} must be ${issue.expected} (got ${issue.received})`;
+    if (issue.code === 'invalid_value') {
+        if (issue.values.length === 1)
+            return `${field} must be ${quoteValue(issue.values[0])}`;
+        const received = echoReceived ? ` (got ${quoteValue(input)})` : '';
+        return `${field} must be one of ${issue.values.join('|')}${received}`;
     }
-    if (issue.code === z.ZodIssueCode.invalid_literal) {
-        return `${field} must be ${quoteValue(issue.expected)}`;
+    if (issue.code === 'invalid_type') {
+        const received = input === null ? 'null' : Array.isArray(input) ? 'array' : typeof input;
+        const expected = issue.expected === 'int' ? 'integer' : issue.expected;
+        return received === 'undefined'
+            ? `${field} is required (${expected})`
+            : `${field} must be ${expected} (got ${received})`;
     }
     return `${field} is invalid: ${issue.message}`;
 }

package/dist/src/sessions/adapters/grokbot.js

@@ -55,6 +55,7 @@
 import { opendir } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { z } from 'zod';
+import { integer, number } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
 import { readBoundedJson } from '../readers.js';
 import { GenericSessionInterchangeAdapter, } from './generic.js';
@@ -65,60 +66,59 @@ export const GROKBOT_NATIVE_SCHEMA_VERSION = '1.0.0';
 export const GROKBOT_NATIVE_SCHEMA_MAJOR = 1;
 export const GROKBOT_LOCATOR_CLASS = 'manual-export';
 export const GROKBOT_NATIVE_REPLICA_LOCATOR_CLASS = 'grokbot-native-transcript-replica';
-const GrokbotEntryBaseSchema = z.object({
+const GrokbotEntryBaseSchema = z.looseObject({
     kind: z.string().min(1),
     id: z.string().min(1),
-    timestampMs: z.number().int().nonnegative(),
+    timestampMs: integer().nonnegative(),
     requestId: z.string().optional(),
-    seq: z.number().int().nonnegative(),
-}).passthrough();
+    seq: integer().nonnegative(),
+});
 const SendMessageEntrySchema = GrokbotEntryBaseSchema.extend({
     kind: z.literal('send-message'),
     respondedValue: z.unknown().optional(),
     secretProvided: z.boolean().optional(),
     message: z.discriminatedUnion('type', [
-        z.object({ type: z.literal('text'), content: z.string() }).passthrough(),
-        z.object({
+        z.looseObject({ type: z.literal('text'), content: z.string() }),
+        z.looseObject({
             type: z.literal('widget'),
-            widget: z.object({ prompt: z.string() }).passthrough(),
-        }).passthrough(),
-        z.object({
+            widget: z.looseObject({ prompt: z.string() }),
+        }),
+        z.looseObject({
             type: z.literal('email-draft'),
-            draft: z.object({ subject: z.string().optional(), body: z.string() }).passthrough(),
-        }).passthrough(),
-        z.object({
+            draft: z.looseObject({ subject: z.string().optional(), body: z.string() }),
+        }),
+        z.looseObject({
             type: z.literal('slack-draft'),
-            draft: z.object({ target: z.string().optional(), body: z.string() }).passthrough(),
-        }).passthrough(),
-        z.object({
+            draft: z.looseObject({ target: z.string().optional(), body: z.string() }),
+        }),
+        z.looseObject({
             type: z.literal('attachment'),
             url: z.string(),
             file_name: z.string(),
-        }).passthrough(),
-        z.object({
+        }),
+        z.looseObject({
             type: z.literal('user-form'),
-            formRequest: z.object({ title: z.string() }).passthrough(),
-        }).passthrough(),
-        z.object({
+            formRequest: z.looseObject({ title: z.string() }),
+        }),
+        z.looseObject({
             type: z.literal('secret-request'),
-            secretRequest: z.object({ label: z.string() }).passthrough(),
-        }).passthrough(),
+            secretRequest: z.looseObject({ label: z.string() }),
+        }),
     ]),
 });
 const MessageEntrySchema = GrokbotEntryBaseSchema.extend({
     kind: z.literal('message'),
     role: z.enum(['user', 'assistant']),
     content: z.string(),
-    fromAgent: z.object({ id: z.string().optional(), name: z.string().optional() })
-        .passthrough().optional(),
+    fromAgent: z.looseObject({ id: z.string().optional(), name: z.string().optional() }).optional(),
 });
 const UserAttachmentEntrySchema = GrokbotEntryBaseSchema.extend({
     kind: z.literal('user-attachment'),
     file_name: z.string(),
     file_path: z.string().optional(),
-    width: z.number().optional(),
-    height: z.number().optional(),
-    byteSize: z.number().optional(),
+    width: number().optional(),
+    height: number().optional(),
+    byteSize: number().optional(),
 });
 const EventEntrySchema = GrokbotEntryBaseSchema.extend({
     kind: z.literal('event'),
@@ -128,17 +128,17 @@ const NoticeEntrySchema = GrokbotEntryBaseSchema.extend({
     kind: z.literal('notice'),
     text: z.string(),
 });
-const GrokbotReplicaValueSchema = z.object({
+const GrokbotReplicaValueSchema = z.looseObject({
     entries: z.array(GrokbotEntryBaseSchema),
     epochHint: z.string().nullish(),
-    acceptedSequenceHint: z.number().int().nonnegative().nullish(),
-    persistedAt: z.number().int().nonnegative().nullish(),
-    precedingTimestampMs: z.number().int().nonnegative().nullish(),
-}).passthrough();
-const GrokbotReplicaDocumentSchema = z.object({
-    schemaVersion: z.number().int().nonnegative(),
+    acceptedSequenceHint: integer().nonnegative().nullish(),
+    persistedAt: integer().nonnegative().nullish(),
+    precedingTimestampMs: integer().nonnegative().nullish(),
+});
+const GrokbotReplicaDocumentSchema = z.looseObject({
+    schemaVersion: integer().nonnegative(),
     value: GrokbotReplicaValueSchema,
-}).passthrough();
+});
 export class GrokbotSessionAdapter {
     limits;
     maxFiles;

package/dist/src/sessions/adapters/hermes.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { number } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
 import { streamBoundedJsonLines, } from '../readers.js';
 export const HERMES_ADAPTER_VERSION = '1.0.0';
@@ -9,26 +10,26 @@ const sqliteBoolean = z.union([z.boolean(), z.literal(0), z.literal(1)])
 function nullableOptional(schema) {
     return z.preprocess((value) => value === null ? undefined : value, schema.optional());
 }
-const MessageSchema = z.object({
-    id: z.union([z.string(), z.number()]),
+const MessageSchema = z.looseObject({
+    id: z.union([z.string(), number()]),
     role: z.string().min(1),
     content: z.unknown().optional(),
     tool_call_id: nullableOptional(z.string()),
     tool_calls: z.unknown().optional(),
     tool_name: nullableOptional(z.string()),
-    timestamp: z.number().optional(),
-    token_count: nullableOptional(z.number()),
+    timestamp: number().optional(),
+    token_count: nullableOptional(number()),
     finish_reason: nullableOptional(z.string()),
     reasoning: nullableOptional(z.string()),
     reasoning_content: nullableOptional(z.string()),
     reasoning_details: z.unknown().optional(),
     codex_reasoning_items: z.unknown().optional(),
-}).passthrough();
-const ExportSchema = z.object({
+});
+const ExportSchema = z.looseObject({
     // Hermes CLI exports currently omit a schema marker. They use the same
     // schema-23 record shape that the adapter already validates; explicit
     // markers still pass through the major-version gate below.
-    schemaVersion: z.union([z.string(), z.number()]).default(HERMES_NATIVE_SCHEMA_VERSION),
+    schemaVersion: z.union([z.string(), number()]).default(HERMES_NATIVE_SCHEMA_VERSION),
     id: z.string().min(1),
     source: z.string().min(1),
     user_id: z.string().nullable().optional(),
@@ -36,27 +37,27 @@ const ExportSchema = z.object({
     model_config: z.unknown().optional(),
     parent_session_id: z.string().nullable().optional(),
     compressed_from_session_id: z.string().nullable().optional(),
-    started_at: z.number(),
-    ended_at: z.number().nullable().optional(),
+    started_at: number(),
+    ended_at: number().nullable().optional(),
     end_reason: z.string().nullable().optional(),
     archived: sqliteBoolean.optional(),
     inactive: sqliteBoolean.optional(),
     cwd: z.string().nullable().optional(),
     git_branch: z.string().nullable().optional(),
     routing_key: z.string().nullable().optional(),
-    input_tokens: z.number().optional(),
-    output_tokens: z.number().optional(),
-    cache_read_tokens: z.number().optional(),
-    cache_write_tokens: z.number().optional(),
-    reasoning_tokens: z.number().optional(),
-    estimated_cost_usd: z.number().nullable().optional(),
-    actual_cost_usd: z.number().nullable().optional(),
+    input_tokens: number().optional(),
+    output_tokens: number().optional(),
+    cache_read_tokens: number().optional(),
+    cache_write_tokens: number().optional(),
+    reasoning_tokens: number().optional(),
+    estimated_cost_usd: number().nullable().optional(),
+    actual_cost_usd: number().nullable().optional(),
     billing_provider: z.string().nullable().optional(),
     messages: z.array(MessageSchema),
-    export_deleted_at: z.number().nullable().optional(),
-    provider_deleted_at: z.number().nullable().optional(),
+    export_deleted_at: number().nullable().optional(),
+    provider_deleted_at: number().nullable().optional(),
     snapshotConsistency: z.enum(['sqlite-backup']).optional(),
-}).passthrough();
+});
 export class HermesSessionAdapter {
     limits;
     localApi;

package/dist/src/sessions/adapters/muse.js

@@ -42,6 +42,7 @@
 import { opendir } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { z } from 'zod';
+import { integer, number } from '../../schema/zod-validation.mjs';
 import { matchSessionWorkspace, WORKSPACE_MATCH_KINDS } from '../workspace-matching.js';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, SessionErrorCodeSchema, SessionRejectionDetailSchema, assertSupportedSchemaMajor, } from '../contracts.js';
 import { readBoundedJson, streamBoundedJsonLines, } from '../readers.js';
@@ -64,28 +65,28 @@ const Rfc3339Schema = z.string().refine((value) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{
  * `stream: {kind, id}` block on every record envelope; gap markers carry
  * `"envelope": null` instead.
  */
-const MuseStreamSchema = z.object({
+const MuseStreamSchema = z.looseObject({
     kind: z.string().optional(),
     id: z.string().optional(),
-}).passthrough();
-const MuseEnvelopeSchema = z.object({
-    sequence: z.number().int().nonnegative(),
+});
+const MuseEnvelopeSchema = z.looseObject({
+    sequence: integer().nonnegative(),
     id: z.string().optional(),
     causation_id: z.string().nullish(),
-    schema_version: z.union([z.number(), z.string()]).optional(),
-    payload_schema_version: z.union([z.number(), z.string()]).optional(),
+    schema_version: z.union([number(), z.string()]).optional(),
+    payload_schema_version: z.union([number(), z.string()]).optional(),
     stream: MuseStreamSchema.optional(),
     // Muse Code 1.4.0 exports epoch microseconds; RFC 3339 strings stay valid.
-    recorded_at: z.union([z.string(), z.number().int().nonnegative()]).optional(),
+    recorded_at: z.union([z.string(), integer().nonnegative()]).optional(),
     record_type: z.string().optional(),
     durability: z.string().optional(),
     payload_type: z.string().optional(),
-    payload: z.object({
+    payload: z.looseObject({
         // Muse Code 1.4.3 runtime.session mode records carry an event without a
         // kind; eventKindOf() falls back to payload_type for those.
-        event: z.object({ kind: z.string().min(1).optional() }).passthrough().optional(),
-    }).passthrough().optional(),
-}).passthrough();
+        event: z.looseObject({ kind: z.string().min(1).optional() }).optional(),
+    }).optional(),
+});
 /**
  * Record events carry a record envelope, validated strictly. Every other
  * event kind is an audit marker: `gap` carries `"envelope": null`, and
@@ -93,67 +94,67 @@ const MuseEnvelopeSchema = z.object({
  * (`children`, `transaction_id`, `content_sha256`) instead of a record.
  * Markers are never fabricated into provider records.
  */
-const MuseRecordEventSchema = z.object({
+const MuseRecordEventSchema = z.looseObject({
     kind: z.literal('record'),
     envelope: MuseEnvelopeSchema,
-}).passthrough();
-const MuseMarkerEventSchema = z.object({
+});
+const MuseMarkerEventSchema = z.looseObject({
     kind: z.string().min(1).refine((kind) => kind !== 'record'),
     envelope: z.record(z.string(), z.unknown()).nullish(),
-}).passthrough();
+});
 const MuseExportEventSchema = z.union([MuseRecordEventSchema, MuseMarkerEventSchema]);
-const MuseAcceptedSpawnSchema = z.object({
+const MuseAcceptedSpawnSchema = z.looseObject({
     subagent_id: z.string().optional(),
     agent_path: z.string().optional(),
     role: z.string().optional(),
     parent_session_id: z.string().optional(),
-}).passthrough();
-const MuseSessionSummarySchema = z.object({
+});
+const MuseSessionSummarySchema = z.looseObject({
     session_id: z.string().min(1),
-    turn_count: z.number().int().nonnegative().optional(),
-    step_count: z.number().int().nonnegative().optional(),
+    turn_count: integer().nonnegative().optional(),
+    step_count: integer().nonnegative().optional(),
     // Live evidence: one summary per exported parent session; subagents appear
     // only here, as spawn handles (subagent_id), never as extra summaries.
     accepted_spawns: z.array(MuseAcceptedSpawnSchema).optional(),
-    session_end: z.object({
+    session_end: z.looseObject({
         exit_reason: z.string().optional(),
-        uptime_ms: z.number().nonnegative().optional(),
-    }).passthrough().optional(),
-}).passthrough();
-const MuseDiagnosticsSchema = z.object({
-    unparseable_lines: z.number().int().nonnegative().optional(),
-    unknown_payload_kinds: z.number().int().nonnegative().optional(),
-    gaps: z.number().int().nonnegative().optional(),
-    omitted_live_only: z.number().int().nonnegative().optional(),
-    omitted_records: z.number().int().nonnegative().optional(),
-    duplicate_records: z.number().int().nonnegative().optional(),
-    retained_frames: z.number().int().nonnegative().optional(),
-    retained_frame_children: z.number().int().nonnegative().optional(),
-}).passthrough();
-const MuseTrajectorySchema = z.object({
-    export_schema_version: z.number().int().nonnegative(),
+        uptime_ms: number().check(z.gte(0)).meta({ type: 'number', minimum: 0 }).optional(),
+    }).optional(),
+});
+const MuseDiagnosticsSchema = z.looseObject({
+    unparseable_lines: integer().nonnegative().optional(),
+    unknown_payload_kinds: integer().nonnegative().optional(),
+    gaps: integer().nonnegative().optional(),
+    omitted_live_only: integer().nonnegative().optional(),
+    omitted_records: integer().nonnegative().optional(),
+    duplicate_records: integer().nonnegative().optional(),
+    retained_frames: integer().nonnegative().optional(),
+    retained_frame_children: integer().nonnegative().optional(),
+});
+const MuseTrajectorySchema = z.looseObject({
+    export_schema_version: integer().nonnegative(),
     redaction: z.string().optional(),
-    exporter_version: z.object({ display: z.string() }).passthrough().optional(),
-    session_build: z.object({ display: z.string() }).passthrough().optional(),
+    exporter_version: z.looseObject({ display: z.string() }).optional(),
+    session_build: z.looseObject({ display: z.string() }).optional(),
     session_terminated_abnormally: z.boolean().optional(),
     sessions: z.array(MuseSessionSummarySchema).min(1),
     events: z.array(MuseExportEventSchema),
     diagnostics: MuseDiagnosticsSchema.optional(),
-}).passthrough();
+});
 function isRecordEvent(event) {
     return event.kind === 'record';
 }
-const MuseRetainedFrameSchema = z.object({
+const MuseRetainedFrameSchema = z.looseObject({
     retained_frame: z.string().min(1),
-    frame_schema_version: z.number().int().nonnegative().optional(),
-    outer_log_ordinal: z.number().int().nonnegative().optional(),
+    frame_schema_version: integer().nonnegative().optional(),
+    outer_log_ordinal: integer().nonnegative().optional(),
     transaction_id: z.string().optional(),
     content_sha256: z.string().optional(),
-    children: z.array(z.object({
-        child_index: z.number().int().nonnegative().optional(),
+    children: z.array(z.looseObject({
+        child_index: integer().nonnegative().optional(),
         record_json: z.string().min(1),
-    }).passthrough()),
-}).passthrough();
+    })),
+});
 export class MuseSessionAdapter {
     limits;
     maxFiles;
@@ -513,12 +514,12 @@ export const MuseWorkspaceInspectionSchema = z.object({
     attribution: z.enum(['matched', 'mismatch', 'unattributed']),
     matchKind: z.enum(WORKSPACE_MATCH_KINDS).optional(),
     reasonCode: z.string().nullable(),
-    recordsInspected: z.number().int().nonnegative(),
-    bytesInspected: z.number().int().nonnegative(),
+    recordsInspected: integer().nonnegative(),
+    bytesInspected: integer().nonnegative(),
     completeInspection: z.boolean(),
     limit: z.object({
         name: z.enum(['maxRecords', 'maxRecordBytes', 'maxTotalBytes', 'maxNestingDepth']),
-        value: z.number().int().positive(),
+        value: integer().positive(),
     }).optional(),
     fallback: z.literal('bounded-tail').optional(),
     detail: SessionRejectionDetailSchema.optional(),

package/dist/src/sessions/adapters/omp.js

@@ -1,15 +1,16 @@
 import { opendir } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { z } from 'zod';
+import { integer, dateTime } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, } from '../contracts.js';
 import { streamBoundedJsonLines } from '../readers.js';
 export const OMP_ADAPTER_VERSION = '1.0.0';
 export const OMP_SOURCE_SCHEMA_VERSION = '3.0.0';
 const Title = z.object({ type: z.literal('title'), v: z.literal(1), title: z.string(), source: z.enum(['auto', 'user']).optional(), updatedAt: z.string(), pad: z.string() });
-const Header = z.object({ type: z.literal('session'), version: z.number().int(), id: z.string().min(1),
-    timestamp: z.string().datetime({ offset: true }), cwd: z.string(), parentSession: z.string().optional() }).passthrough();
-const Entry = z.object({ type: z.string().min(1), id: z.string().min(1),
-    parentId: z.string().nullable(), timestamp: z.string().datetime({ offset: true }) }).passthrough();
+const Header = z.looseObject({ type: z.literal('session'), version: integer(), id: z.string().min(1),
+    timestamp: dateTime({ offset: true }), cwd: z.string(), parentSession: z.string().optional() });
+const Entry = z.looseObject({ type: z.string().min(1), id: z.string().min(1),
+    parentId: z.string().nullable(), timestamp: dateTime({ offset: true }) });
 export class OmpSessionAdapter {
     limits;
     maxFiles;

package/dist/src/sessions/adapters/openclaw.js

@@ -1,69 +1,70 @@
 import { z } from 'zod';
+import { integer, number } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
 import { streamBoundedJsonLines, } from '../readers.js';
 export const OPENCLAW_ADAPTER_VERSION = '1.0.0';
 export const OPENCLAW_SOURCE_SCHEMA_VERSION = '1.0.0';
 export const OPENCLAW_NATIVE_SCHEMA_VERSION = '16.0.0';
 export const OPENCLAW_EVENT_VERSION = '3.0.0';
-const LineageSchema = z.object({
+const LineageSchema = z.looseObject({
     kind: z.enum(['reset', 'fork', 'rewind', 'compaction']),
     fromSessionId: z.string().optional(),
     checkpointId: z.string().optional(),
     reason: z.string().optional(),
-}).passthrough();
-const EventSchema = z.object({
+});
+const EventSchema = z.looseObject({
     id: z.string().min(1),
     parentId: z.string().nullable().optional(),
     type: z.string().min(1),
-    timestamp: z.union([z.string(), z.number()]).optional(),
+    timestamp: z.union([z.string(), number()]).optional(),
     role: z.string().optional(),
     text: z.string().optional(),
-    model: z.record(z.unknown()).optional(),
-    tool: z.record(z.unknown()).optional(),
-    media: z.record(z.unknown()).optional(),
-    usage: z.record(z.unknown()).optional(),
+    model: z.record(z.string(), z.unknown()).optional(),
+    tool: z.record(z.string(), z.unknown()).optional(),
+    media: z.record(z.string(), z.unknown()).optional(),
+    usage: z.record(z.string(), z.unknown()).optional(),
     lineage: LineageSchema.optional(),
     opaque: z.unknown().optional(),
     idempotencyKey: z.string().optional(),
-}).passthrough();
-const SessionSchema = z.object({
+});
+const SessionSchema = z.looseObject({
     id: z.string().min(1),
     sessionKey: z.string().min(1),
     conversationId: z.string().optional(),
     agentId: z.string().optional(),
     identityKey: z.string().optional(),
-    stateVersion: z.number().int().nonnegative().optional(),
-    startedAt: z.union([z.string(), z.number()]).optional(),
-    updatedAt: z.union([z.string(), z.number()]).optional(),
-    archivedAt: z.union([z.string(), z.number()]).nullable().optional(),
+    stateVersion: integer().nonnegative().optional(),
+    startedAt: z.union([z.string(), number()]).optional(),
+    updatedAt: z.union([z.string(), number()]).optional(),
+    archivedAt: z.union([z.string(), number()]).nullable().optional(),
     recovered: z.boolean().optional(),
     active: z.boolean().optional(),
-    window: z.object({
-        firstSequence: z.number().int().nonnegative().optional(),
-        lastSequence: z.number().int().nonnegative().optional(),
+    window: z.looseObject({
+        firstSequence: integer().nonnegative().optional(),
+        lastSequence: integer().nonnegative().optional(),
         historyGap: z.boolean().optional(),
-    }).passthrough().optional(),
+    }).optional(),
     events: z.array(EventSchema),
-}).passthrough();
-const SnapshotSchema = z.object({
-    schemaVersion: z.union([z.string(), z.number()]),
-    eventVersion: z.union([z.string(), z.number()]),
+});
+const SnapshotSchema = z.looseObject({
+    schemaVersion: z.union([z.string(), number()]),
+    eventVersion: z.union([z.string(), number()]),
     snapshotConsistency: z.enum(['sqlite-backup']).optional(),
-    gateway: z.object({
+    gateway: z.looseObject({
         mode: z.enum(['local', 'remote']).optional(),
         hostId: z.string().optional(),
         expectedHostId: z.string().optional(),
-    }).passthrough().optional(),
+    }).optional(),
     incognito: z.boolean().optional(),
-    projection: z.object({
+    projection: z.looseObject({
         kind: z.enum(['canonical', 'bounded-history', 'html', 'trajectory']),
         complete: z.boolean(),
-        omittedBefore: z.union([z.string(), z.number()]).optional(),
+        omittedBefore: z.union([z.string(), number()]).optional(),
         limitation: z.string().optional(),
-    }).passthrough().optional(),
+    }).optional(),
     sessions: z.array(SessionSchema),
-    providerDeletedAt: z.union([z.string(), z.number()]).nullable().optional(),
-}).passthrough();
+    providerDeletedAt: z.union([z.string(), number()]).nullable().optional(),
+});
 export class OpenClawSessionAdapter {
     limits;
     gateway;