@aiwg/cli 2026.10.5 → 2026.10.6

package/dist/src/serve/worker-invocation.js

@@ -8,7 +8,7 @@ import { resolveWorkerPlan } from '../models/resolver.js';
 import { workerConfigDigest, validateWorkerHealthConfig } from '../config/aiwg-config.js';
 import { assertValidWorkerPayload } from '../mission-protocol/codecs.js';
 import { qualificationDigest } from '../models/qualification-digest.mjs';
-import { qualifyWorkerInvocationProfile, isOperatorQualifiedWorkerAdapter, assertOperatorWorkerNativeArgv, assertWorkerSelectionAllowed, requiredWorkerControls, requiresWorkerExternalBoundary, isCanonicalWorkerModelKey, assertWorkerHealthQualification, WorkerPolicyError, DEFAULT_WORKER_SELECTION } from '../models/provider-policy.js';
+import { qualifyWorkerInvocationProfile, isOperatorQualifiedWorkerAdapter, assertOperatorWorkerNativeArgv, assertWorkerSelectionAllowed, assertWorkerLaunchMode, WorkerRoleEffortError, requiredWorkerControls, requiresWorkerExternalBoundary, isCanonicalWorkerModelKey, assertWorkerHealthQualification, WorkerPolicyError, DEFAULT_WORKER_SELECTION } from '../models/provider-policy.js';
 /** Frozen per-attempt windows; parent/transport ceilings include time already spent. */
 export function resolveWorkerEffectiveHealth(config, input) {
     const roleDefaults = { efficiency: 1, coding: 1, reasoning: 2 };
@@ -101,6 +101,10 @@ export async function prepareWorkerInvocation(invocation, qualification) {
     if (qualification.adapter.id !== qualification.adapterId) {
         throw new Error('Worker invocation adapter identity mismatch');
     }
+    assertWorkerLaunchMode(qualification.adapter, qualification.permissions);
+    if (result.isolation !== undefined && result.isolation !== (qualification.permissions?.launchMode ?? 'systemd-unit')) {
+        throw new WorkerPolicyError('OG_PIN_MISMATCH', 'Worker launch mode differs from the execution policy');
+    }
     for (const [key, value] of Object.entries(qualification.expectedDigests ?? {})) {
         if (result[key] !== value)
             throw new WorkerPolicyError('OG_PIN_MISMATCH', `Worker invocation ${key} changed`);
@@ -225,6 +229,56 @@ export async function prepareWorkerInvocation(invocation, qualification) {
         model: result.selected.model, effort: result.selected.effort.value });
     return result;
 }
+const invocationChecks = {
+    invocation_build_failed: { pointer: '/invocation/buildInvocation',
+        message: 'Worker adapter could not build the invocation; check the selected model, effort, permissions and request paths.' },
+    native_argv_invalid: { pointer: '/invocation/argv',
+        message: 'Worker adapter arguments do not preserve the requested native controls; review the installed driver and qualify again.' },
+    invocation_prepare_failed: { pointer: '/invocation/prepareWorkerInvocation',
+        message: 'Worker invocation preparation failed; check installation evidence, policy, paths and environment, then qualify again.' },
+    installation_recheck_unavailable: { pointer: '/invocation/prepareWorkerInvocation',
+        message: 'The selected profile requires an installation recheck, but the installed driver has no preparation method. Restore the qualified driver and qualify again.' },
+    qualified_workspace_mismatch: { pointer: '/request/workdir',
+        message: 'Worker workdir differs from the qualified workspace. Use the qualified workspace or run aiwg doctor --probe-workers --qualify from the requested workdir.' },
+};
+/** Only fixed check identifiers, never adapter/filesystem error text, cross this boundary. */
+export class WorkerInvocationCheckError extends WorkerPolicyError {
+    reason;
+    constructor(code, reason) {
+        super(code, invocationChecks[reason].message);
+        this.reason = reason;
+    }
+}
+/** Nonlaunching build and native-control check shared by resolution and doctor. */
+export async function buildWorkerInvocationTransport(driver, input) {
+    assertWorkerLaunchMode(driver.qualification.adapter, input.permissions);
+    let transport;
+    try {
+        transport = await driver.buildInvocation(input);
+    }
+    catch (error) {
+        throw new WorkerInvocationCheckError(error instanceof WorkerPolicyError ? error.code : 'OG_ADAPTER_UNQUALIFIED', 'invocation_build_failed');
+    }
+    if (driver.qualification.adapter.invocationProfiles?.[input.selected.profileRef]?.transport === 'shell') {
+        try {
+            assertOperatorWorkerNativeArgv(driver.qualification.adapter, transport.argv, input.selected, input.permissions);
+        }
+        catch {
+            throw new WorkerInvocationCheckError('OG_ADAPTER_UNQUALIFIED', 'native_argv_invalid');
+        }
+    }
+    return transport;
+}
+/** Only fixed argument guidance is safe to expose in public request diagnostics. */
+class WorkerRequestArgumentError extends WorkerPolicyError {
+    pointer;
+    constructor(key) {
+        super('OG_CONFIG_REFERENCE', key === 'task'
+            ? `Missing required --task. Valid task classes: ${Object.keys(DEFAULT_WORKER_SELECTION.taskClasses).join(', ')}, plus classes configured in defaults.workerSelection.taskClasses.`
+            : `--${key.replace('_', '-')} must be an absolute path; relative paths are not resolved against cwd or --workdir.`);
+        this.pointer = `/request/${key}`;
+    }
+}
 /** Reject unsupported syntax before discovery or any path reads. */
 export function parseWorkerCommandArgs(args) {
     const names = { role: 'role', task: 'task', group: 'group', brief: 'brief',
@@ -254,6 +308,8 @@ export function parseWorkerCommandArgs(args) {
             throw new Error(`Duplicate --${match[1]}`);
         const value = match[2] ?? args[++i];
         if (!value || value.startsWith('--') && match[2] === undefined || value.includes('\0')) {
+            if (key === 'task' && !value?.includes('\0'))
+                throw new WorkerRequestArgumentError('task');
             throw new Error(`--${match[1]} requires a value`);
         }
         result[key] = value;
@@ -263,6 +319,8 @@ export function parseWorkerCommandArgs(args) {
     if (json)
         result.format = 'json';
     for (const key of ['role', 'task', 'group', 'brief', 'workdir', 'final_output']) {
+        if (key === 'task' && !result[key])
+            throw new WorkerRequestArgumentError('task');
         if (!result[key])
             throw new Error(`Missing ${key}`);
     }
@@ -342,7 +400,9 @@ export class WorkerPathScopeError extends WorkerPolicyError {
 }
 /** Re-resolve saved JSON through the same trusted owners; saved argv is never authority. */
 export async function revalidateWorkerInvocationPlan(saved, snapshot, drivers, now = new Date().toISOString()) {
-    if (!saved.request || saved.mode !== 'direct' || saved.status !== 'eligible'
+    const managed = saved.mode === 'managed' && snapshot.config.parallelism?.worker_mode === 'managed';
+    if (!saved.request || (saved.mode !== 'direct' && !managed) || saved.mode !== (snapshot.config.parallelism?.worker_mode ?? 'direct') || saved.status !== 'eligible'
+        || (managed && saved.invocation?.mode !== 'managed')
         || saved.invocation?.readiness !== 'launchable' || Date.parse(saved.invocation.expiresAt) <= Date.parse(now)) {
         throw new Error('A fresh launchable models resolve JSON plan is required');
     }
@@ -366,8 +426,18 @@ export async function resolveWorkerInvocation(snapshot, request, drivers, now =
     let failureCode = 'OG_CONFIG_REFERENCE';
     let plan;
     try {
-        if (!path.isAbsolute(request.brief))
-            throw new WorkerPolicyError('OG_CONFIG_REFERENCE', '--brief must be an absolute path; relative paths are not resolved against cwd or --workdir.');
+        const managedIntent = request.managedIntent;
+        if (managedIntent) {
+            assertValidWorkerPayload('workerSelectionIntent', managedIntent);
+            if (snapshot.config.parallelism?.worker_mode !== 'managed'
+                || managedIntent.role !== request.role || managedIntent.taskClass !== request.task || managedIntent.group !== request.group) {
+                throw new Error('Managed task authority differs from the worker request');
+            }
+        }
+        for (const key of ['brief', 'workdir', 'final_output']) {
+            if (!path.isAbsolute(request[key]))
+                throw new WorkerRequestArgumentError(key);
+        }
         const bytes = await readBrief(request.brief);
         const briefDigest = bytes === null ? null : bytesDigest(bytes);
         if (expected && expected.briefDigest !== briefDigest)
@@ -375,7 +445,10 @@ export async function resolveWorkerInvocation(snapshot, request, drivers, now =
         let brief;
         if (bytes?.toString('utf8').trimStart().startsWith('{')) {
             brief = JSON.parse(bytes.toString('utf8'));
-            assertValidWorkerPayload('workerDirectBrief', brief);
+            assertValidWorkerPayload(managedIntent ? 'workerBrief' : 'workerDirectBrief', brief);
+            if (managedIntent && workerConfigDigest(brief.intent) !== workerConfigDigest(managedIntent)) {
+                throw new Error('Managed brief differs from parent task authority');
+            }
             if (brief.intent.role !== request.role || brief.intent.taskClass !== request.task || brief.intent.group !== request.group
                 || brief.workspace.path !== request.workdir || brief.output.resultPath !== request.final_output) {
                 throw new WorkerPolicyError('OG_PIN_MISMATCH', 'Brief role/task/group/workspace/output differs from request');
@@ -387,6 +460,9 @@ export async function resolveWorkerInvocation(snapshot, request, drivers, now =
                 model: brief.intent.pins.model, effort: brief.intent.pins.effort?.value, ceilings: {
                     ...brief.intent.limits, costUsd: brief.intent.limits.costUsd ?? undefined
                 } } : {}),
+            ...(managedIntent ? { dataClass: managedIntent.dataClass, member: managedIntent.pins.member,
+                model: managedIntent.pins.model, effort: managedIntent.pins.effort?.value,
+                ceilings: { ...managedIntent.limits, costUsd: managedIntent.limits.costUsd ?? undefined } } : {}),
             context: { estimator: 'utf8-byte-upper-bound-v1', briefTokens: bytes?.length ?? 0,
                 inputTokens: 0, toolOutputAllowance: 1024, reservedOutput: 1024 },
             requiredControls: snapshot.config.parallelism?.health?.requireStepCap ? ['stepCap'] : [],
@@ -394,6 +470,11 @@ export async function resolveWorkerInvocation(snapshot, request, drivers, now =
         plan.request = structuredClone(request);
         if (!plan.selected)
             return plan;
+        if (plan.mode === 'managed' && !managedIntent) {
+            plan.diagnostics.push({ code: 'OG_CONFIG_REFERENCE', pointer: '/request/managedIntent',
+                message: 'Managed execution requires the parent task authority and shared admission.' });
+            return plan;
+        }
         const tuple = plan.selected;
         pointer = `/parallelism/clis/${tuple.cli}`;
         failureCode = 'OG_ADAPTER_UNQUALIFIED';
@@ -447,7 +528,7 @@ export async function resolveWorkerInvocation(snapshot, request, drivers, now =
             + (plan.policy?.freshness?.policyDays ?? DEFAULT_WORKER_SELECTION.freshness.policyDays) * 86400000)).toISOString();
         const healthConfig = snapshot.config.parallelism?.health;
         if (profile.installationQualification && !driver.prepareWorkerInvocation) {
-            throw new Error('Installation-scoped profile requires the #2885 adapter preparation/recheck method');
+            throw new WorkerInvocationCheckError('OG_ADAPTER_UNQUALIFIED', 'installation_recheck_unavailable');
         }
         if (tuple.transport === 'mcp') {
             const serverRef = profile.mcp.serverRef;
@@ -462,23 +543,25 @@ export async function resolveWorkerInvocation(snapshot, request, drivers, now =
         }
         const controls = isOperatorQualifiedWorkerAdapter(adapter) ? (healthConfig?.requireStepCap ? ['stepCap'] : []) : requiredWorkerControls({ policy: plan.policy, permissions: tuple.permissions, effort: tuple.effort,
             requiredControls: healthConfig?.requireStepCap ? ['stepCap'] : [] });
-        pointer = `/parallelism/clis/${tuple.cli}/invocationProfile`;
+        pointer = '/parallelism/health';
         failureCode = 'OG_ADAPTER_UNQUALIFIED';
         const healthInput = { role: request.role, effort: tuple.effort,
             modelKey: tuple.modelKey, profileRef: tuple.profile, wallSeconds: limits.wallSeconds,
             transportSeconds: adapter.invocation.kind === 'http' ? adapter.invocation.timeoutSeconds : undefined,
             stepEnforcement: controls.includes('stepCap') ? profile.controls.stepCap.support : 'unavailable' };
         let effectiveHealth = resolveWorkerEffectiveHealth(healthConfig, healthInput);
-        const transport = await driver.buildInvocation({ selected: structuredClone(selected), permissions: structuredClone(tuple.permissions),
+        const transport = await buildWorkerInvocationTransport(driver, { selected: structuredClone(selected), permissions: structuredClone(tuple.permissions),
             cwd: request.workdir, briefPath: request.brief, brief: bytes?.toString('utf8') ?? '', finalPath, limits: structuredClone(limits),
             health: structuredClone(effectiveHealth) });
+        pointer = '/invocation/buildInvocation';
         if (transport.stdin === 'adapter-frame' && typeof driver.buildWorkerStdinFrame !== 'function')
             throw new Error('Installed adapter stdin framer is required');
         if (transport.mcp?.timeoutSeconds !== undefined)
             effectiveHealth = resolveWorkerEffectiveHealth(healthConfig, { ...healthInput, transportSeconds: Math.min(healthInput.transportSeconds ?? Infinity, transport.mcp.timeoutSeconds) });
         if (workerConfigDigest(driver.qualification) !== qualificationDigest)
             throw new WorkerPolicyError('OG_PIN_MISMATCH', 'Installation profile digest changed during resolution');
-        const invocation = { version: 1, mode: 'direct', transport: tuple.transport, selected,
+        const invocation = { version: 1, mode: managedIntent ? 'managed' : 'direct', transport: tuple.transport, selected,
+            isolation: tuple.permissions.launchMode ?? 'systemd-unit',
             policyDigest, catalogDigest: plan.digests.catalogDigest, profileDigest: plan.digests.profileDigest,
             expiresAt, cwd: request.workdir, briefPath: request.brief, stdoutPath, stderrPath, finalPath,
             ...(transport.artifacts ? { artifacts: transport.artifacts } : {}),
@@ -493,13 +576,23 @@ export async function resolveWorkerInvocation(snapshot, request, drivers, now =
             policy: plan.policy, permissions: tuple.permissions, role: request.role, modelObservation: observation,
             expectedDigests: { policyDigest, catalogDigest: plan.digests.catalogDigest, profileDigest: plan.digests.profileDigest, briefDigest },
             requiredControls: controls };
-        const prepared = await (driver.prepareWorkerInvocation
-            ? driver.prepareWorkerInvocation(structuredClone(invocation), invocationQualification)
-            : prepareWorkerInvocation(invocation, invocationQualification));
+        let prepared;
+        pointer = '/invocation/prepareWorkerInvocation';
+        try {
+            prepared = await (driver.prepareWorkerInvocation
+                ? driver.prepareWorkerInvocation(structuredClone(invocation), invocationQualification)
+                : prepareWorkerInvocation(invocation, invocationQualification));
+        }
+        catch (error) {
+            if (error instanceof WorkerPathScopeError || error instanceof WorkerInvocationCheckError)
+                throw error;
+            throw new WorkerInvocationCheckError(error instanceof WorkerPolicyError ? error.code : 'OG_ADAPTER_UNQUALIFIED', 'invocation_prepare_failed');
+        }
         if (workerConfigDigest({ ...prepared, shellCommand: invocation.shellCommand }) !== workerConfigDigest(invocation)) {
             throw new WorkerPolicyError('OG_PIN_MISMATCH', 'Installation preparation changed the resolved invocation');
         }
         if (tuple.transport === 'mcp' && profile.installationQualification) {
+            pointer = '/invocation/mcp';
             const installation = qualification.installation;
             if (!installation?.mcpServerDigest || !driver.mcpRegistry?.assertWorkerQualified) {
                 throw new Error('MCP installation registration recheck is required');
@@ -539,10 +632,17 @@ export async function resolveWorkerInvocation(snapshot, request, drivers, now =
 }
 /** Public diagnostics contain fixed summaries or explicit typed request-path details. */
 export function workerInvocationDiagnostic(error, pointer, fallback = 'OG_CONFIG_REFERENCE') {
-    if (error instanceof WorkerPathScopeError)
+    if (error instanceof WorkerRoleEffortError)
+        return { code: error.code, pointer: error.pointer, message: error.message };
+    if (error instanceof WorkerPathScopeError || error instanceof WorkerRequestArgumentError) {
         return { code: error.code, pointer: error.pointer, message: error.message };
+    }
+    if (error instanceof WorkerInvocationCheckError)
+        return { code: error.code, reason: error.reason, ...invocationChecks[error.reason] };
     const code = error instanceof WorkerPolicyError ? error.code : fallback;
     const messages = {
+        OG_SANDBOX_EXTERNAL: "The CLI's own sandbox is disabled by explicit external policy; isolation relies on the per-task worktree and launcher resource scope.",
+        OG_NATIVE_SANDBOX_UNAVAILABLE: 'Native sandbox unavailable inside systemd user units; select policy launchMode native-sandbox or allow unprivileged user namespaces through host AppArmor policy.',
         OG_CONFIG_REFERENCE: 'Invalid request or configuration reference; check the paths and settings.',
         OG_PIN_MISMATCH: 'Worker selection or pinned evidence changed; resolve again.',
         OG_MODEL_UNAPPROVED: 'The selected model lacks current approved observation evidence.',
@@ -552,7 +652,6 @@ export function workerInvocationDiagnostic(error, pointer, fallback = 'OG_CONFIG
         OG_POLICY_RELAXATION: 'The request would relax the resolved worker policy.',
         OG_BUDGET_UNMEASURABLE: 'The requested worker budget cannot be enforced.',
     };
-    return { code, pointer, message: error instanceof WorkerPolicyError && error.message === '--brief must be an absolute path; relative paths are not resolved against cwd or --workdir.'
-            ? error.message : messages[code] };
+    return { code, pointer, message: messages[code] };
 }
 //# sourceMappingURL=worker-invocation.js.map

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

@@ -1,6 +1,7 @@
 import { opendir } from 'node:fs/promises';
 import { basename, extname, resolve } from 'node:path';
 import { z } from 'zod';
+import { dateTime, number } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, assertSupportedSchemaMajor, sha256, } from '../contracts.js';
 import { redactSourceLocator } from '../discovery.js';
 import { readBoundedJson, streamBoundedJsonLines, } from '../readers.js';
@@ -9,14 +10,14 @@ export const CLAUDE_TRANSCRIPT_SCHEMA_VERSION = '1.0.0';
 /** AIWG's own understanding of the layout it supports; Claude web/account
  *  exports carry no in-band schema version to read instead. */
 export const CLAUDE_WEB_EXPORT_SCHEMA_VERSION = '1.0.0';
-const ClaudeRecordSchema = z.object({
+const ClaudeRecordSchema = z.looseObject({
     type: z.string().min(1),
     subtype: z.string().optional(),
     uuid: z.string().min(1).optional(),
     parentUuid: z.string().min(1).nullable().optional(),
     sessionId: z.string().min(1).optional(),
     session_id: z.string().min(1).optional(),
-    timestamp: z.string().datetime({ offset: true }).optional(),
+    timestamp: dateTime({ offset: true }).optional(),
     cwd: z.string().optional(),
     gitBranch: z.string().optional(),
     parentSessionId: z.string().min(1).optional(),
@@ -25,13 +26,13 @@ const ClaudeRecordSchema = z.object({
     slug: z.string().min(1).optional(),
     version: z.string().optional(),
     schemaVersion: z.string().optional(),
-    message: z.object({
+    message: z.looseObject({
         id: z.string().min(1).optional(),
         role: z.string().min(1).optional(),
         content: z.union([z.string(), z.array(z.unknown())]).optional(),
-    }).passthrough().optional(),
-}).passthrough();
-const ClaudeHookSchema = z.object({
+    }).optional(),
+});
+const ClaudeHookSchema = z.looseObject({
     session_id: z.string().min(1),
     transcript_path: z.string().min(1),
     cwd: z.string().min(1),
@@ -41,8 +42,8 @@ const ClaudeHookSchema = z.object({
     model: z.string().optional(),
     reason: z.string().optional(),
     schemaVersion: z.string().optional(),
-    timestamp: z.string().datetime({ offset: true }).optional(),
-}).passthrough();
+    timestamp: dateTime({ offset: true }).optional(),
+});
 /**
  * Claude.ai web/account data export (`conversations.json`): a JSON array of
  * conversations, each carrying its own `chat_messages`. This is a distinct
@@ -51,17 +52,17 @@ const ClaudeHookSchema = z.object({
  * rather than dropped, and content the export marks as an attachment/file is
  * recorded as a reference (bytes are not embedded in this export format).
  */
-const ClaudeWebExportAttachmentSchema = z.object({
+const ClaudeWebExportAttachmentSchema = z.looseObject({
     file_name: z.string().optional(),
     file_type: z.string().optional(),
-    file_size: z.number().optional(),
+    file_size: number().optional(),
     extracted_content: z.string().optional(),
-}).passthrough();
-const ClaudeWebExportContentBlockSchema = z.object({
+});
+const ClaudeWebExportContentBlockSchema = z.looseObject({
     type: z.string().optional(),
     text: z.string().optional(),
-}).passthrough();
-const ClaudeWebExportMessageSchema = z.object({
+});
+const ClaudeWebExportMessageSchema = z.looseObject({
     uuid: z.string().min(1),
     text: z.string().optional(),
     sender: z.enum(['human', 'assistant']),
@@ -70,15 +71,15 @@ const ClaudeWebExportMessageSchema = z.object({
     content: z.array(ClaudeWebExportContentBlockSchema).optional(),
     attachments: z.array(ClaudeWebExportAttachmentSchema).optional(),
     files: z.array(ClaudeWebExportAttachmentSchema).optional(),
-}).passthrough();
-const ClaudeWebExportConversationSchema = z.object({
+});
+const ClaudeWebExportConversationSchema = z.looseObject({
     uuid: z.string().min(1),
     name: z.string().optional(),
     created_at: z.string().optional(),
     updated_at: z.string().optional(),
-    account: z.object({ uuid: z.string().optional() }).passthrough().optional(),
+    account: z.looseObject({ uuid: z.string().optional() }).optional(),
     chat_messages: z.array(ClaudeWebExportMessageSchema),
-}).passthrough();
+});
 const ClaudeWebExportSchema = z.array(ClaudeWebExportConversationSchema);
 export class ClaudeSessionAdapter {
     limits;

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

@@ -1,18 +1,19 @@
 import { opendir } from 'node:fs/promises';
 import { basename, resolve } from 'node:path';
 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 CODEX_ADAPTER_VERSION = '1.0.0';
 export const CODEX_SOURCE_SCHEMA_VERSION = '1.0.0';
-const AppServerEnvelopeSchema = z.object({
+const AppServerEnvelopeSchema = z.looseObject({
     schemaVersion: z.string().optional(),
     productVersion: z.string().optional(),
     method: z.string().min(1),
     result: z.unknown().optional(),
     params: z.unknown().optional(),
-}).passthrough();
-const ThreadSchema = z.object({
+});
+const ThreadSchema = z.looseObject({
     id: z.string().min(1),
     sessionId: z.string().min(1).optional(),
     parentThreadId: z.string().nullable().optional(),
@@ -21,8 +22,8 @@ const ThreadSchema = z.object({
     preview: z.string().optional(),
     modelProvider: z.string().optional(),
     cliVersion: z.string().optional(),
-    createdAt: z.number().int().optional(),
-    updatedAt: z.number().int().optional(),
+    createdAt: integer().optional(),
+    updatedAt: integer().optional(),
     cwd: z.string().optional(),
     path: z.string().nullable().optional(),
     ephemeral: z.boolean().optional(),
@@ -30,13 +31,13 @@ const ThreadSchema = z.object({
     source: z.unknown().optional(),
     gitInfo: z.unknown().optional(),
     turns: z.array(z.unknown()).optional(),
-}).passthrough();
-const RolloutEnvelopeSchema = z.object({
+});
+const RolloutEnvelopeSchema = z.looseObject({
     schemaVersion: z.string().optional(),
     timestamp: z.string().optional(),
     type: z.string().min(1),
-    payload: z.unknown(),
-}).passthrough();
+    payload: z.unknown().optional(),
+});
 export class CodexSessionAdapter {
     limits;
     discoveryLimits;

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

@@ -1,43 +1,44 @@
 import { basename, extname } 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';
 export const COPILOT_ADAPTER_VERSION = '1.0.0';
 export const COPILOT_EXPORT_SCHEMA_VERSION = '1.0.0';
-const ResponsePartSchema = z.object({
+const ResponsePartSchema = z.looseObject({
     value: z.string().optional(),
     kind: z.string().optional(),
-}).passthrough();
-const RequestSchema = z.object({
+});
+const RequestSchema = z.looseObject({
     requestId: z.string().min(1).optional(),
     message: z.union([
         z.string(),
-        z.object({ text: z.string() }).passthrough(),
+        z.looseObject({ text: z.string() }),
     ]),
     response: z.union([
         z.string(),
         z.array(ResponsePartSchema),
     ]).optional(),
-    timestamp: z.union([z.string(), z.number()]).optional(),
+    timestamp: z.union([z.string(), number()]).optional(),
     modelId: z.string().optional(),
-}).passthrough();
-const ExportSchema = z.object({
-    version: z.union([z.number().int().positive(), z.string()]),
+});
+const ExportSchema = z.looseObject({
+    version: z.union([integer().positive(), z.string()]),
     schemaVersion: z.string().optional(),
     sessionId: z.string().min(1).optional(),
-    creationDate: z.union([z.string(), z.number()]).optional(),
-    lastMessageDate: z.union([z.string(), z.number()]).optional(),
+    creationDate: z.union([z.string(), number()]).optional(),
+    lastMessageDate: z.union([z.string(), number()]).optional(),
     requests: z.array(RequestSchema),
     requesterUsername: z.string().optional(),
     responderUsername: z.string().optional(),
     state: z.string().optional(),
     isArchived: z.boolean().optional(),
     syncStatus: z.string().optional(),
-    workspace: z.object({
+    workspace: z.looseObject({
         id: z.string().optional(),
         repository: z.string().optional(),
-    }).passthrough().optional(),
-}).passthrough();
+    }).optional(),
+});
 export class CopilotSessionAdapter {
     limits;
     provider = 'copilot';

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

@@ -1,11 +1,12 @@
 import { opendir } from 'node:fs/promises';
 import { basename, dirname, extname, resolve, } from 'node:path';
 import { z } from 'zod';
+import { dateTime } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, assertSupportedSchemaMajor, } from '../contracts.js';
 import { readBoundedText, streamBoundedJsonLines, } from '../readers.js';
 export const CURSOR_ADAPTER_VERSION = '1.0.0';
 export const CURSOR_SOURCE_SCHEMA_VERSION = '1.0.0';
-const CliEventSchema = z.object({
+const CliEventSchema = z.looseObject({
     schemaVersion: z.string().optional(),
     cliVersion: z.string().optional(),
     version: z.string().optional(),
@@ -17,49 +18,49 @@ const CliEventSchema = z.object({
     cwd: z.string().optional(),
     model: z.string().optional(),
     permissionMode: z.string().optional(),
-    message: z.object({
+    message: z.looseObject({
         role: z.string().optional(),
-        content: z.array(z.object({
+        content: z.array(z.looseObject({
             type: z.string(),
             text: z.string().optional(),
-        }).passthrough()).optional(),
-    }).passthrough().optional(),
-    tool_call: z.record(z.unknown()).optional(),
+        })).optional(),
+    }).optional(),
+    tool_call: z.record(z.string(), z.unknown()).optional(),
     result: z.string().optional(),
     is_error: z.boolean().optional(),
-}).passthrough();
-const CloudEventSchema = z.object({
+});
+const CloudEventSchema = z.looseObject({
     schemaVersion: z.string().optional(),
     id: z.string().optional(),
     event_id: z.string().optional(),
     type: z.string().min(1),
-    agent: z.object({
+    agent: z.looseObject({
         id: z.string().min(1),
         status: z.string().optional(),
-    }).passthrough().optional(),
-    run: z.object({
+    }).optional(),
+    run: z.looseObject({
         id: z.string().min(1),
         status: z.string().optional(),
-    }).passthrough().optional(),
+    }).optional(),
     data: z.unknown().optional(),
-}).passthrough().refine((value) => value.agent?.id || value.run?.id, {
+}).refine((value) => value.agent?.id || value.run?.id, {
     message: 'cloud event requires an agent or run identity',
 });
-const AgentTranscriptEventSchema = z.object({
+const AgentTranscriptEventSchema = z.looseObject({
     schemaVersion: z.string().optional(),
     id: z.string().optional(),
     event_id: z.string().optional(),
     request_id: z.string().optional(),
-    timestamp: z.string().datetime({ offset: true }).optional(),
+    timestamp: dateTime({ offset: true }).optional(),
     type: z.string().min(1).optional(),
     status: z.string().min(1).optional(),
     role: z.string().min(1).optional(),
-    message: z.object({
+    message: z.looseObject({
         id: z.string().optional(),
         role: z.string().optional(),
         content: z.union([z.string(), z.array(z.unknown())]).optional(),
-    }).passthrough().optional(),
-}).passthrough().refine((value) => value.role || value.type, {
+    }).optional(),
+}).refine((value) => value.role || value.type, {
     message: 'agent transcript event requires role or type',
 });
 export class CursorSessionAdapter {

package/dist/src/sessions/adapters/deepseek-harness.js

@@ -1,20 +1,21 @@
 import { opendir } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { z } from 'zod';
+import { integer as integerSchema } from '../../schema/zod-validation.mjs';
 import { schemaRejectionDetail, schemaIssueDetail, SessionContractError, } from '../contracts.js';
 import { streamBoundedJsonLines } from '../readers.js';
 export const DEEPSEEK_HARNESS_ADAPTER_VERSION = '1.0.0';
 export const DEEPSEEK_HARNESS_SOURCE_SCHEMA_VERSION = '2.0.0';
-const Header = z.object({
-    type: z.literal('session'), version: z.number().int(), id: z.string().min(1),
+const Header = z.looseObject({
+    type: z.literal('session'), version: integerSchema(), id: z.string().min(1),
     createdAt: z.number().finite(), cwd: z.string().optional(), parentSession: z.string().optional(),
     isSeeded: z.boolean(), origin: z.literal('subagent').optional(),
-    delegationDepth: z.number().int().nonnegative(), agentPreset: z.string().optional(),
-}).passthrough();
-const Event = z.object({
-    type: z.string().min(1), seq: z.number().int().nonnegative(), time: z.number().finite(),
-    data: z.unknown(),
-}).passthrough();
+    delegationDepth: integerSchema().nonnegative(), agentPreset: z.string().optional(),
+});
+const Event = z.looseObject({
+    type: z.string().min(1), seq: integerSchema().nonnegative(), time: z.number().finite(),
+    data: z.unknown().optional(),
+});
 const KNOWN = new Set([
     'turn/start', 'user/message', 'step/start', 'assistant/message', 'tool/call',
     'tool/result', 'request/header', 'request/context', 'session/end-seed',

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;