oh-my-knowledge 1.0.0-beta.12 → 1.0.0-beta.13

package/dist/eval-workflows/hosts/local-task/diagnostics.d.ts

@@ -0,0 +1,27 @@
+import type { NodeCoreContentStore } from '../../artifact-store/node-content-store.js';
+import type { LocalTaskOutput } from '../../inputs/contracts/local-task.js';
+export interface TaskAttemptDiagnostic {
+    readonly stage: 'execution' | 'acceptance';
+    readonly status: string;
+    readonly output: LocalTaskOutput;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly processOutcome: {
+        readonly exitCode: number | null;
+        readonly signal: string | null;
+        readonly failureKind: string | null;
+    } | null;
+}
+/** Host-only diagnostics use the existing content envelope, never an Execution success record. */
+export declare function createTaskDiagnostics(store: NodeCoreContentStore, outputDirectory: string): {
+    capture(diagnostic: TaskAttemptDiagnostic): Promise<void>;
+    run<T>(runId: string, operation: () => Promise<T>): Promise<{
+        value: Awaited<T>;
+        references: {
+            mediaType: string;
+            digest: string;
+            size?: number | undefined;
+            uri?: string | undefined;
+        }[];
+    }>;
+};

package/dist/eval-workflows/hosts/local-task/diagnostics.js

@@ -0,0 +1,30 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { join } from 'node:path';
+import { digestCanonicalJson } from '../../../eval-core/contracts/index.js';
+import { publishPrivateJsonExclusive } from '../../artifact-store/private-json-file.js';
+/** Host-only diagnostics use the existing content envelope, never an Execution success record. */
+export function createTaskDiagnostics(store, outputDirectory) {
+    const context = new AsyncLocalStorage();
+    return {
+        async capture(diagnostic) {
+            const current = context.getStore();
+            if (!current)
+                throw new Error('TASK_DIAGNOSTIC_CONTEXT_MISSING');
+            const value = { diagnosticKind: 'local-task-attempt', diagnosticVersion: 1,
+                runId: current.runId, capturedAt: new Date().toISOString(), ...diagnostic };
+            const reference = await store.put({ value, digest: digestCanonicalJson(value),
+                mediaType: 'application/json', classification: 'sensitive' });
+            const source = diagnostic.output.source;
+            const key = digestCanonicalJson({ ...source, stage: diagnostic.stage }).slice('sha256:'.length);
+            const publication = await publishPrivateJsonExclusive(join(outputDirectory, 'task-diagnostics', current.runId, `${key}.json`), { runId: current.runId, ...source, stage: diagnostic.stage, status: diagnostic.status, reference });
+            if (publication !== 'published')
+                throw new Error('TASK_DIAGNOSTIC_INDEX_EXISTS');
+            current.references.push(reference);
+        },
+        async run(runId, operation) {
+            const state = { runId, references: [] };
+            const value = await context.run(state, operation);
+            return { value, references: state.references };
+        },
+    };
+}

package/dist/eval-workflows/hosts/local-task/executor.d.ts

@@ -0,0 +1,19 @@
+import { type JsonValue } from '../../../eval-core/contracts/index.js';
+import type { Executor } from '../../../eval-runtime/evaluation/contracts.js';
+import type { WorkspaceProvider } from '../../../eval-runtime/workspace.js';
+import { type LocalTaskDefinition, type LocalTaskOutput, type TaskFile } from '../../inputs/contracts/local-task.js';
+import type { TaskAttemptDiagnostic } from './diagnostics.js';
+import { type CapturedIdentityFile } from '../adapters/shared/content-identity.js';
+export declare function createTaskExecutor(input: {
+    definition: LocalTaskDefinition;
+    snapshot: readonly TaskFile[];
+    provider: WorkspaceProvider;
+    temporaryRoot: string;
+    executable: string;
+    executableDigest: string;
+    version: string;
+    identityFiles: readonly CapturedIdentityFile[];
+    fixtureSource?: string;
+    authenticationFile?: string;
+    captureDiagnostic: (diagnostic: TaskAttemptDiagnostic) => Promise<void>;
+}): Executor<JsonValue, undefined, LocalTaskOutput>;

package/dist/eval-workflows/hosts/local-task/executor.js

@@ -0,0 +1,135 @@
+import { chmod, copyFile, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { delimiter, dirname, join } from 'node:path';
+import { z } from 'zod';
+import { ExecutionPortFailure } from '../../../eval-core/execution/index.js';
+import { spawnWithSigintPropagation } from '../../../executors/core/subprocess.js';
+import { buildCodexExecArguments } from '../../../executors/openai/codex/cli-arguments.js';
+import { parseCodexCliStream } from '../adapters/codex/cli-protocol.js';
+import { LocalTaskOutputSchema } from '../../inputs/contracts/local-task.js';
+import { collectTaskArtifacts, taskTreeDigest } from './files.js';
+import { assertIdentityFilesUnchanged } from '../adapters/shared/content-identity.js';
+export function createTaskExecutor(input) {
+    const { definition } = input;
+    const snapshotDigest = taskTreeDigest(input.snapshot);
+    return {
+        executorId: 'omk.local-task-executor/v1', version: '1.1.0',
+        schemas: { input: z.json(), output: LocalTaskOutputSchema, trace: z.json() },
+        outputClassification: 'sensitive', traceClassification: 'sensitive',
+        outputMediaType: 'application/vnd.omk.local-task-output+json',
+        workspaceProvider: input.provider,
+        capabilities: {
+            determinism: definition.execution.runtimeKind === 'fixture' ? 'deterministic' : 'stochastic',
+            cancellation: 'best-effort', concurrency: { safety: 'serialized', maxInFlight: 1 },
+            seedControl: 'unsupported', telemetry: { trace: 'optional', usage: 'optional', providerCost: { reporting: 'unsupported' } },
+        },
+        fingerprintFacets: {
+            diagnosticsPolicy: 'attempt-snapshot/v1', maxStreamBytes: 10 * 1024 * 1024,
+            outputSchema: 'omk.local-task-output/v1', runtimeKind: definition.execution.runtimeKind,
+            implementationDigest: input.executableDigest, runtimeVersion: input.version,
+            dependencies: input.identityFiles.map(({ facetId, digest, size }) => ({ facetId, digest, size })),
+            platform: process.platform, architecture: process.arch, nodeVersion: process.version,
+            model: definition.execution.runtimeKind === 'codex' ? definition.execution.model : 'offline-fixture',
+            effort: definition.execution.runtimeKind === 'codex' ? definition.execution.effort : 'none',
+            timeoutMs: definition.execution.timeoutMs, artifacts: definition.artifacts,
+            knowledgeMode: 'provided-content', sandbox: 'trusted-local-workspace-write',
+            environment: { LANG: 'C', TZ: 'UTC', inheritance: 'none', home: 'attempt-private' },
+        },
+        async execute(invocation) {
+            if (invocation.workspace === undefined)
+                return { errorCode: 'TASK_WORKSPACE_MISSING' };
+            invocation.signal.throwIfAborted();
+            const privateRoot = await mkdtemp(join(input.temporaryRoot, 'executor-'));
+            let stdout = '';
+            let stderr = '';
+            let processOutcome = null;
+            let status = 'TASK_EXECUTION_FAILED';
+            let captured;
+            const collect = async (response) => ({
+                schemaVersion: 'omk.local-task-output/v1', response, snapshotDigest,
+                ...await collectTaskArtifacts({ root: invocation.workspace.root, paths: definition.artifacts.files,
+                    maxBytes: definition.artifacts.maxBytes, snapshot: input.snapshot }),
+                source: { sampleId: invocation.sampleId, variantId: invocation.variantId,
+                    trialIndex: invocation.trialIndex, attemptNumber: invocation.attemptNumber },
+            });
+            try {
+                await assertIdentityFilesUnchanged(input.identityFiles, { adapterLabel: 'Local task',
+                    cancellationCode: 'TASK_CANCELLED', identityChangedCode: 'TASK_EXECUTOR_CHANGED', signal: invocation.signal });
+                const env = { HOME: privateRoot, LANG: 'C', TZ: 'UTC', TMPDIR: privateRoot, PATH: [dirname(process.execPath), '/usr/bin', '/bin'].join(delimiter) };
+                const execution = definition.execution;
+                let args;
+                let command;
+                let stdin = '';
+                if (execution.runtimeKind === 'fixture') {
+                    const script = join(privateRoot, 'fixture.mjs');
+                    await writeFile(script, input.fixtureSource, { mode: 0o600 });
+                    command = process.execPath;
+                    args = [script];
+                    stdin = JSON.stringify({ input: invocation.input, knowledge: invocation.artifact.content });
+                }
+                else {
+                    const codexHome = join(privateRoot, 'codex');
+                    await mkdir(codexHome, { mode: 0o700 });
+                    if (input.authenticationFile !== undefined) {
+                        await copyFile(input.authenticationFile, join(codexHome, 'auth.json'));
+                        await chmod(join(codexHome, 'auth.json'), 0o600);
+                    }
+                    env.CODEX_HOME = codexHome;
+                    command = input.executable;
+                    args = buildCodexExecArguments({
+                        model: execution.model, effort: execution.effort, workingDirectory: invocation.workspace.root,
+                        prompt: `${invocation.artifact.content ?? ''}\n\n${String(invocation.input.text)}`,
+                        sandbox: 'workspace-write', strictConfig: true, color: 'never', shellEnvironmentInheritance: 'none',
+                    });
+                }
+                const { child, done } = spawnWithSigintPropagation(command, args, {
+                    cwd: invocation.workspace.root, env, abortSignal: invocation.signal,
+                    timeoutMs: execution.timeoutMs, maxBuffer: 10 * 1024 * 1024,
+                });
+                child.stdin?.on('error', () => { });
+                child.stdin?.end(stdin);
+                const completed = await done;
+                stdout = completed.stdout;
+                stderr = completed.stderr;
+                processOutcome = { exitCode: completed.code, signal: completed.signal, failureKind: null };
+                const parsed = execution.runtimeKind === 'codex' ? parseCodexCliStream(completed.stdout) : undefined;
+                if (parsed?.terminalStatus === 'failed')
+                    return { errorCode: 'TASK_EXECUTION_FAILED', ...(parsed.usage ? { usage: parsed.usage } : {}) };
+                const output = await collect(parsed?.output ?? completed.stdout);
+                captured = output;
+                status = 'completed';
+                return { output, ...(parsed?.trace === undefined ? {} : { trace: parsed.trace }),
+                    ...(parsed?.usage === undefined ? {} : { usage: parsed.usage }) };
+            }
+            catch (error) {
+                const failure = error;
+                stdout = failure.stdout ?? stdout;
+                stderr = failure.stderr ?? stderr;
+                if (failure.failureKind)
+                    processOutcome = { exitCode: failure.code ?? null, signal: failure.signal ?? null, failureKind: failure.failureKind };
+                status = failure.killedByTimeout || invocation.signal.reason === 'timeout' ? 'TASK_EXECUTION_TIMEOUT'
+                    : invocation.signal.aborted ? 'TASK_CANCELLED'
+                        : error instanceof ExecutionPortFailure ? error.evaluationError.code : 'TASK_EXECUTION_FAILED';
+                if (invocation.signal.aborted)
+                    throw invocation.signal.reason;
+                if (error instanceof ExecutionPortFailure)
+                    throw error;
+                return { errorCode: status };
+            }
+            finally {
+                try {
+                    if (invocation.signal.aborted)
+                        status = invocation.signal.reason === 'timeout' ? 'TASK_EXECUTION_TIMEOUT' : 'TASK_CANCELLED';
+                    await input.captureDiagnostic({ stage: 'execution', status, output: captured ?? await collect(''), stdout, stderr, processOutcome });
+                }
+                catch {
+                    throw new ExecutionPortFailure({ code: 'TASK_DIAGNOSTIC_WRITE_FAILED', stage: 'infrastructure',
+                        message: 'Local task diagnostic evidence could not be persisted.' });
+                }
+                finally {
+                    // Diagnostic persistence must not prevent private credential cleanup.
+                    await rm(privateRoot, { recursive: true, force: true });
+                }
+            }
+        },
+    };
+}

package/dist/eval-workflows/hosts/local-task/files.d.ts

@@ -0,0 +1,15 @@
+import { type Sha256Digest } from '../../../eval-core/contracts/index.js';
+import { type TaskFile, type LocalTaskOutput } from '../../inputs/contracts/local-task.js';
+export declare function fileDigest(bytes: Uint8Array): Sha256Digest;
+/** Explicit files only. A trusted local process is required; this is not a hostile-code sandbox. */
+export declare function readTaskFile(root: string, path: string, maxBytes: number): Promise<TaskFile>;
+export declare function captureTaskFiles(root: string, paths: readonly string[], maxBytes: number): Promise<readonly TaskFile[]>;
+export declare function taskTreeDigest(files: readonly TaskFile[]): Sha256Digest;
+/** Only used with a fresh host-owned directory, never an Agent's writable tree. */
+export declare function materializeTaskFiles(root: string, files: readonly TaskFile[]): Promise<void>;
+export declare function collectTaskArtifacts(input: {
+    root: string;
+    paths: readonly string[];
+    maxBytes: number;
+    snapshot: readonly TaskFile[];
+}): Promise<Pick<LocalTaskOutput, 'files' | 'missing' | 'collectionErrors'>>;

package/dist/eval-workflows/hosts/local-task/files.js

@@ -0,0 +1,88 @@
+import { constants } from 'node:fs';
+import { lstat, mkdir, open, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { createHash } from 'node:crypto';
+import { digestCanonicalJson } from '../../../eval-core/contracts/index.js';
+import { LocalTaskPathSchema } from '../../inputs/contracts/local-task.js';
+export function fileDigest(bytes) {
+    return `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+}
+/** Explicit files only. A trusted local process is required; this is not a hostile-code sandbox. */
+export async function readTaskFile(root, path, maxBytes) {
+    LocalTaskPathSchema.parse(path);
+    let parent = resolve(root);
+    for (const part of ['', ...path.split('/').slice(0, -1)]) {
+        parent = join(parent, part);
+        const metadata = await lstat(parent);
+        if (!metadata.isDirectory() || metadata.isSymbolicLink())
+            throw new Error('TASK_PATH_UNSAFE');
+    }
+    const handle = await open(join(root, path), constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const metadata = await handle.stat();
+        if (!metadata.isFile())
+            throw new Error('TASK_PATH_UNSAFE');
+        if (metadata.size > maxBytes)
+            throw new Error('TASK_FILE_LIMIT');
+        // Bound the actual read, including a file growing after stat().
+        const buffer = Buffer.alloc(maxBytes + 1);
+        let length = 0;
+        while (length < buffer.length) {
+            const { bytesRead } = await handle.read(buffer, length, buffer.length - length, length);
+            if (bytesRead === 0)
+                break;
+            length += bytesRead;
+        }
+        if (length > maxBytes)
+            throw new Error('TASK_FILE_LIMIT');
+        const bytes = buffer.subarray(0, length);
+        return { path, contentBase64: bytes.toString('base64'), digest: fileDigest(bytes), executable: (metadata.mode & 0o111) !== 0 };
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function captureTaskFiles(root, paths, maxBytes) {
+    const files = [];
+    let remaining = maxBytes;
+    for (const path of [...paths].sort()) {
+        const file = await readTaskFile(root, path, remaining);
+        remaining -= Buffer.from(file.contentBase64, 'base64').length;
+        files.push(file);
+    }
+    return Object.freeze(files.map((file) => Object.freeze(file)));
+}
+export function taskTreeDigest(files) {
+    return digestCanonicalJson([...files].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+}
+/** Only used with a fresh host-owned directory, never an Agent's writable tree. */
+export async function materializeTaskFiles(root, files) {
+    for (const file of files) {
+        LocalTaskPathSchema.parse(file.path);
+        const bytes = Buffer.from(file.contentBase64, 'base64');
+        if (bytes.toString('base64') !== file.contentBase64 || fileDigest(bytes) !== file.digest)
+            throw new Error('TASK_FILE_DIGEST_INVALID');
+        const destination = join(root, file.path);
+        await mkdir(dirname(destination), { recursive: true, mode: 0o700 });
+        await writeFile(destination, bytes, { flag: 'wx', mode: file.executable ? 0o700 : 0o600 });
+    }
+}
+export async function collectTaskArtifacts(input) {
+    const result = { files: [], missing: [], collectionErrors: [] };
+    let remaining = input.maxBytes;
+    for (const path of [...input.paths].sort()) {
+        try {
+            const file = await readTaskFile(input.root, path, remaining);
+            remaining -= Buffer.from(file.contentBase64, 'base64').length;
+            const before = input.snapshot.find((entry) => entry.path === path);
+            result.files.push({ ...file, change: before === undefined ? 'added' : before.digest === file.digest && before.executable === file.executable ? 'unchanged' : 'modified' });
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                result.missing.push(path);
+            else
+                result.collectionErrors.push({ path, code: error instanceof Error && error.message === 'TASK_FILE_LIMIT' ? 'TASK_FILE_LIMIT' : 'TASK_COLLECTION_FAILED' });
+        }
+    }
+    return result;
+}

package/dist/eval-workflows/hosts/local-task/workspace.d.ts

@@ -0,0 +1,6 @@
+import type { WorkspaceDescriptor, WorkspaceProvider } from '../../../eval-runtime/workspace.js';
+import type { TaskFile } from '../../inputs/contracts/local-task.js';
+export declare function createTaskWorkspace(files: readonly TaskFile[], temporaryRoot: string): {
+    descriptor: WorkspaceDescriptor;
+    provider: WorkspaceProvider;
+};

package/dist/eval-workflows/hosts/local-task/workspace.js

@@ -0,0 +1,32 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { materializeTaskFiles, taskTreeDigest } from './files.js';
+export function createTaskWorkspace(files, temporaryRoot) {
+    const digest = taskTreeDigest(files);
+    const descriptor = {
+        resourceId: 'local-task-snapshot', digest, mediaType: 'application/vnd.omk.local-task-tree',
+        classification: 'sensitive', size: files.reduce((size, file) => size + Buffer.from(file.contentBase64, 'base64').length, 0),
+    };
+    return {
+        descriptor,
+        provider: {
+            providerId: 'omk.local-task-workspace/v1', version: '1.0.0',
+            fingerprintFacets: { snapshotDigest: digest, retryState: 'shared-within-trial' },
+            async open(request) {
+                request.signal.throwIfAborted();
+                if (request.descriptor.digest !== digest)
+                    throw new Error('TASK_SNAPSHOT_MISMATCH');
+                const root = await mkdtemp(join(temporaryRoot, 'trial-'));
+                try {
+                    await materializeTaskFiles(root, files);
+                    request.signal.throwIfAborted();
+                    return { root, close: () => rm(root, { recursive: true, force: true }) };
+                }
+                catch (error) {
+                    await rm(root, { recursive: true, force: true });
+                    throw error;
+                }
+            },
+        },
+    };
+}

package/dist/eval-workflows/inputs/contracts/local-task-evidence.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const LocalTaskPathSchema: z.ZodString;
+export declare const TaskFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    contentBase64: z.ZodString;
+    digest: z.ZodString;
+    executable: z.ZodBoolean;
+}, z.core.$strict>;
+export type TaskFile = z.infer<typeof TaskFileSchema>;
+export declare const LocalTaskOutputSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"omk.local-task-output/v1">;
+    response: z.ZodString;
+    snapshotDigest: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        contentBase64: z.ZodString;
+        digest: z.ZodString;
+        executable: z.ZodBoolean;
+        change: z.ZodEnum<{
+            unchanged: "unchanged";
+            modified: "modified";
+            added: "added";
+        }>;
+    }, z.core.$strict>>;
+    missing: z.ZodArray<z.ZodString>;
+    collectionErrors: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        code: z.ZodString;
+    }, z.core.$strict>>;
+    source: z.ZodObject<{
+        sampleId: z.ZodString;
+        variantId: z.ZodString;
+        trialIndex: z.ZodNumber;
+        attemptNumber: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type LocalTaskOutput = z.infer<typeof LocalTaskOutputSchema>;
+export declare const LocalTaskAcceptanceSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"omk.local-task-acceptance/v1">;
+    passed: z.ZodBoolean;
+    checks: z.ZodArray<z.ZodObject<{
+        checkId: z.ZodString;
+        passed: z.ZodBoolean;
+        detail: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;

package/dist/eval-workflows/inputs/contracts/local-task-evidence.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { Sha256DigestSchema } from '../../../eval-core/contracts/index.js';
+export const LocalTaskPathSchema = z.string().min(1).max(1024).refine((path) => (!path.includes('\\') && !path.includes(':') && !/[\x00-\x1f]/.test(path)
+    && path.split('/').every((part) => part !== '' && part !== '.' && part !== '..'
+        && !/^(?:\.git|\.ssh|\.aws|\.azure|\.config|\.codex|\.claude|\.env(?:\..*)?|.*\.(?:pem|key)|credentials(?:\..*)?|auth\.json)$/i.test(part))), 'Expected a relative non-sensitive file path without traversal.');
+export const TaskFileSchema = z.strictObject({
+    path: LocalTaskPathSchema,
+    contentBase64: z.string(),
+    digest: Sha256DigestSchema,
+    executable: z.boolean(),
+});
+export const LocalTaskOutputSchema = z.strictObject({
+    schemaVersion: z.literal('omk.local-task-output/v1'),
+    response: z.string(),
+    snapshotDigest: Sha256DigestSchema,
+    files: z.array(TaskFileSchema.extend({ change: z.enum(['unchanged', 'modified', 'added']) })),
+    missing: z.array(LocalTaskPathSchema),
+    collectionErrors: z.array(z.strictObject({ path: LocalTaskPathSchema, code: z.string() })),
+    source: z.strictObject({ sampleId: z.string(), variantId: z.string(), trialIndex: z.number().int(), attemptNumber: z.number().int() }),
+});
+export const LocalTaskAcceptanceSchema = z.strictObject({
+    schemaVersion: z.literal('omk.local-task-acceptance/v1'),
+    passed: z.boolean(),
+    checks: z.array(z.strictObject({ checkId: z.string().min(1), passed: z.boolean(), detail: z.string().max(4000) })).min(1),
+}).refine((value) => value.passed === value.checks.every((check) => check.passed), 'Overall result must match checks.')
+    .refine((value) => new Set(value.checks.map((check) => check.checkId)).size === value.checks.length, 'Duplicate check IDs.');

package/dist/eval-workflows/inputs/contracts/local-task.d.ts

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+export * from './local-task-evidence.js';
+export declare const LocalTaskDefinitionSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"omk.local-task/v1">;
+    taskId: z.ZodString;
+    trust: z.ZodLiteral<"trusted-local">;
+    samples: z.ZodType<import("./sample.js").EvalSampleSetDocument, unknown, z.core.$ZodTypeInternals<import("./sample.js").EvalSampleSetDocument, unknown>>;
+    snapshot: z.ZodObject<{
+        root: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    artifacts: z.ZodObject<{
+        files: z.ZodArray<z.ZodString>;
+        maxBytes: z.ZodNumber;
+    }, z.core.$strict>;
+    variants: z.ZodObject<{
+        control: z.ZodString;
+        treatment: z.ZodString;
+    }, z.core.$strict>;
+    execution: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        runtimeKind: z.ZodLiteral<"codex">;
+        executable: z.ZodString;
+        model: z.ZodString;
+        effort: z.ZodEnum<{
+            max: "max";
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+        }>;
+        timeoutMs: z.ZodNumber;
+        identityFiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            facetId: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        runtimeKind: z.ZodLiteral<"fixture">;
+        script: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>], "runtimeKind">;
+    acceptance: z.ZodObject<{
+        root: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+        entrypoint: z.ZodString;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>;
+    trials: z.ZodDefault<z.ZodNumber>;
+    seed: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export type LocalTaskDefinition = z.infer<typeof LocalTaskDefinitionSchema>;

package/dist/eval-workflows/inputs/contracts/local-task.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { EvalSampleSetDocumentSchema } from '../schemas/sample-set.js';
+import { LocalTaskPathSchema } from './local-task-evidence.js';
+export * from './local-task-evidence.js';
+const FilesSchema = z.array(LocalTaskPathSchema).min(1).max(256)
+    .refine((paths) => new Set(paths).size === paths.length, 'Duplicate file paths.');
+export const LocalTaskDefinitionSchema = z.strictObject({
+    schemaVersion: z.literal('omk.local-task/v1'),
+    taskId: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/),
+    trust: z.literal('trusted-local'),
+    samples: EvalSampleSetDocumentSchema,
+    snapshot: z.strictObject({ root: z.string().min(1), files: FilesSchema }),
+    artifacts: z.strictObject({ files: FilesSchema, maxBytes: z.number().int().positive().max(16 * 1024 * 1024) }),
+    variants: z.strictObject({ control: z.string().min(1), treatment: z.string().min(1) }),
+    execution: z.discriminatedUnion('runtimeKind', [
+        z.strictObject({
+            runtimeKind: z.literal('codex'), executable: z.string().min(1), model: z.string().min(1),
+            effort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']),
+            timeoutMs: z.number().int().positive(),
+            identityFiles: z.array(z.strictObject({ facetId: z.string().min(1), path: z.string().min(1) })).default([]),
+        }),
+        z.strictObject({
+            runtimeKind: z.literal('fixture'), script: z.string().min(1),
+            timeoutMs: z.number().int().positive(),
+        }),
+    ]),
+    acceptance: z.strictObject({
+        root: z.string().min(1), files: FilesSchema, entrypoint: LocalTaskPathSchema,
+        timeoutMs: z.number().int().positive(),
+    }).refine((value) => value.files.includes(value.entrypoint), 'Entrypoint must be included in acceptance files.'),
+    trials: z.number().int().positive().max(100).default(1),
+    seed: z.string().min(1).default('local-task-v1'),
+});

package/dist/eval-workflows/projections/local-task.d.ts

@@ -0,0 +1,23 @@
+import type { CapturedContent } from '../../eval-core/contracts/index.js';
+/** Only declared file metadata reaches Studio; source bytes and Agent prose stay in raw evidence. */
+export declare function projectLocalTaskOutput(content: CapturedContent | undefined): {
+    snapshotDigest: string;
+    files: {
+        path: string;
+        digest: string;
+        change: "unchanged" | "modified" | "added";
+    }[];
+    missing: string[];
+    collectionErrors: {
+        path: string;
+        code: string;
+    }[];
+} | undefined;
+export declare function projectLocalTaskAcceptance(content: CapturedContent | undefined): {
+    acceptanceDigest: string;
+    passed: boolean;
+    checks: {
+        checkId: string;
+        passed: boolean;
+    }[];
+} | undefined;

package/dist/eval-workflows/projections/local-task.js

@@ -0,0 +1,25 @@
+import { LocalTaskAcceptanceSchema, LocalTaskOutputSchema } from '../inputs/contracts/local-task-evidence.js';
+/** Only declared file metadata reaches Studio; source bytes and Agent prose stay in raw evidence. */
+export function projectLocalTaskOutput(content) {
+    if (content?.contentKind !== 'inline' || content.classification === 'secret' || content.classification === 'gold')
+        return undefined;
+    const parsed = LocalTaskOutputSchema.safeParse(content.value);
+    if (!parsed.success)
+        return undefined;
+    return {
+        snapshotDigest: parsed.data.snapshotDigest,
+        files: parsed.data.files.map(({ path, digest, change }) => ({ path, digest, change })),
+        missing: parsed.data.missing,
+        collectionErrors: parsed.data.collectionErrors,
+    };
+}
+export function projectLocalTaskAcceptance(content) {
+    if (content?.contentKind !== 'inline' || content.classification === 'secret' || content.classification === 'gold'
+        || content.value === null || typeof content.value !== 'object' || Array.isArray(content.value))
+        return undefined;
+    const { acceptanceDigest, ...value } = content.value;
+    const parsed = LocalTaskAcceptanceSchema.safeParse(value);
+    if (!parsed.success || typeof acceptanceDigest !== 'string' || !/^sha256:[a-f0-9]{64}$/.test(acceptanceDigest))
+        return undefined;
+    return { acceptanceDigest, passed: parsed.data.passed, checks: parsed.data.checks.map(({ checkId, passed }) => ({ checkId, passed })) };
+}

package/dist/executors/openai/codex/protocol.js

@@ -89,7 +89,7 @@ export function extractCodexFinalOutput(events) {
 export function isCodexReconnectNotice(event) {
     if (event.type !== 'error' || typeof event.message !== 'string')
         return false;
-    const match = /^Reconnecting\.\.\. ([1-9]\d*)\/([1-9]\d*) \(stream disconnected before completion: .+\)$/.exec(event.message);
+    const match = /^Reconnecting\.\.\. ([1-9]\d*)\/([1-9]\d*) \((?:stream disconnected before completion: .+|request timed out)\)$/.exec(event.message);
     return match !== null && Number.isSafeInteger(Number(match[1]))
         && Number.isSafeInteger(Number(match[2])) && Number(match[1]) <= Number(match[2]);
 }

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 /** Canonical user-facing API. Advanced surfaces use explicit package subpaths. */
 export * from './eval-runtime/index.js';
 export * from './eval-workflows/hosts/reference-executors.js';
+export { prepareLocalTask, type LocalTaskOptions } from './eval-workflows/hosts/local-task/application.js';

package/dist/index.js

@@ -1,3 +1,4 @@
 /** Canonical user-facing API. Advanced surfaces use explicit package subpaths. */
 export * from './eval-runtime/index.js';
 export * from './eval-workflows/hosts/reference-executors.js';
+export { prepareLocalTask } from './eval-workflows/hosts/local-task/application.js';

package/dist/knowledge/contracts.d.ts

@@ -40,9 +40,9 @@ export declare const KnowledgeContentSchema: z.ZodObject<{
             entityId: z.ZodString;
         }, z.core.$strict>>;
         modality: z.ZodEnum<{
+            capability: "capability";
             descriptive: "descriptive";
             normative: "normative";
-            capability: "capability";
             permission: "permission";
         }>;
         polarity: z.ZodEnum<{
@@ -160,9 +160,9 @@ export declare const KnowledgeDraftSchema: z.ZodObject<{
                 entityId: z.ZodString;
             }, z.core.$strict>>;
             modality: z.ZodEnum<{
+                capability: "capability";
                 descriptive: "descriptive";
                 normative: "normative";
-                capability: "capability";
                 permission: "permission";
             }>;
             polarity: z.ZodEnum<{
@@ -294,9 +294,9 @@ export declare const KnowledgeRevisionSchema: z.ZodObject<{
                 entityId: z.ZodString;
             }, z.core.$strict>>;
             modality: z.ZodEnum<{
+                capability: "capability";
                 descriptive: "descriptive";
                 normative: "normative";
-                capability: "capability";
                 permission: "permission";
             }>;
             polarity: z.ZodEnum<{
@@ -469,8 +469,8 @@ export declare const EntityMentionSchema: z.ZodObject<{
         quote: z.ZodString;
     }, z.core.$strict>;
     basis: z.ZodEnum<{
-        inference: "inference";
         explicit: "explicit";
+        inference: "inference";
     }>;
     rationale: z.ZodString;
 }, z.core.$strict>;