sneakoscope 6.2.0 → 6.4.0

package/dist/core/agents/agent-command-surface.js

@@ -1,108 +0,0 @@
-import { DEFAULT_AGENT_COUNT } from './agent-schema.js';
-import { normalizeServiceTier } from './fast-mode-policy.js';
-export function parseAgentCommandArgs(command, args = []) {
-    const first = args[0] && !String(args[0]).startsWith('--') ? String(args[0]) : '';
-    const actions = new Set(['run', 'worker', 'status', 'plan', 'spawn', 'watch', 'dashboard', 'cockpit', 'lane', 'board', 'ledger', 'collect', 'consensus', 'close', 'cleanup', 'proof', 'explain', 'rollback-patches']);
-    const action = actions.has(first) ? first : 'run';
-    const rest = action === first ? args.slice(1) : args;
-    const json = hasFlag(args, '--json');
-    const agents = Number(readOption(args, '--agents', DEFAULT_AGENT_COUNT));
-    const targetActiveSlots = Number(readOption(args, '--target-active-slots', agents));
-    const desiredWorkItemCount = Number(readOption(args, '--work-items', targetActiveSlots));
-    const minimumWorkItems = Number(readOption(args, '--minimum-work-items', targetActiveSlots));
-    const maxQueueExpansion = Number(readOption(args, '--max-queue-expansion', 10));
-    const concurrency = Number(readOption(args, '--concurrency', Math.min(agents, 5)));
-    const useOllamaProtocol = hasFlag(args, '--ollama');
-    const useLocalModel = hasFlag(args, '--local-model');
-    const useOllama = useOllamaProtocol || useLocalModel;
-    const noOllama = hasFlag(args, '--no-ollama') || hasFlag(args, '--no-local-model');
-    const backendExplicit = hasOption(args, '--backend') || useOllamaProtocol || useLocalModel || noOllama;
-    const defaultBackend = hasFlag(args, '--mock')
-        ? 'fake'
-        : useLocalModel && !noOllama
-            ? 'local-llm'
-            : useOllamaProtocol && !noOllama
-                ? 'ollama'
-                : 'codex-sdk';
-    const backend = String(readOption(args, '--backend', defaultBackend));
-    const route = String(readOption(args, '--route', '$Agent'));
-    const mock = hasFlag(args, '--mock') || backend === 'fake';
-    const real = hasFlag(args, '--real');
-    const readonly = hasFlag(args, '--readonly') || hasFlag(args, '--read-only');
-    const profile = String(readOption(args, '--profile', '') || '') || null;
-    const writeMode = String(readOption(args, '--write-mode', hasFlag(args, '--parallel-write') ? 'parallel' : 'off'));
-    const applyPatches = hasFlag(args, '--apply-patches');
-    const dryRunPatches = hasFlag(args, '--dry-run-patches') || hasFlag(args, '--dryrun-patches');
-    const maxWriteAgents = Number(readOption(args, '--max-write-agents', Math.max(1, Math.min(concurrency, agents))));
-    const explicitServiceTier = String(readOption(args, '--service-tier', '') || '');
-    const serviceTier = normalizeServiceTier(explicitServiceTier, null) || undefined;
-    const fastMode = hasFlag(args, '--no-fast') || serviceTier === 'standard' ? false : hasFlag(args, '--fast') ? true : undefined;
-    const noFast = hasFlag(args, '--no-fast');
-    const ollamaModel = String(readOption(args, '--ollama-model', readOption(args, '--local-model-model', '')) || '') || null;
-    const ollamaBaseUrl = String(readOption(args, '--ollama-base-url', readOption(args, '--local-model-base-url', '')) || '') || null;
-    const zellijSessionName = String(readOption(args, '--zellij-session-name', '') || '') || null;
-    const zellijPaneWorker = hasFlag(args, '--no-zellij-pane-worker') ? false : hasFlag(args, '--zellij-pane-worker') ? true : undefined;
-    const workerPlacement = String(readOption(args, '--worker-placement', zellijPaneWorker === true ? 'zellij-pane' : '') || '') || undefined;
-    const zellijVisiblePaneCap = resolveZellijVisiblePaneCap(readOption(args, '--zellij-visible-pane-cap', process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP || ''), hasOption(args, '--zellij-visible-pane-cap') || Boolean(process.env.SKS_ZELLIJ_VISIBLE_PANE_CAP));
-    const apply = hasFlag(args, '--apply');
-    const dryRun = hasFlag(args, '--dry-run') || hasFlag(args, '--dryrun');
-    const drain = hasFlag(args, '--drain');
-    const staleMs = Number(readOption(args, '--stale-ms', 30 * 60 * 1000));
-    const graceMs = Number(readOption(args, '--grace-ms', 750));
-    const killEscalation = hasFlag(args, '--kill-escalation') || !hasFlag(args, '--no-kill-escalation');
-    const codexApp = hasFlag(args, '--codex-app');
-    const legacyNativeRuntime = hasFlag(args, '--legacy-native-runtime');
-    const positionals = positionalArgs(rest, new Set(['--agents', '--target-active-slots', '--work-items', '--minimum-work-items', '--max-queue-expansion', '--concurrency', '--backend', '--route', '--mission', '--mission-id', '--agent', '--lane', '--stale-ms', '--grace-ms', '--profile', '--write-mode', '--max-write-agents', '--patch-entry-id', '--patch-entry', '--service-tier', '--zellij-session-name', '--worker-placement', '--zellij-visible-pane-cap', '--intake', '--agent-root', '--artifact-dir', '--result-path', '--heartbeat-path', '--patch-envelope-path', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']));
-    const missionDefault = action === 'run' || action === 'spawn' || action === 'plan' ? '' : 'latest';
-    const positionalMission = action === 'run' || action === 'spawn' || action === 'plan' ? '' : (positionals[0] || '');
-    const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', positionalMission || missionDefault)));
-    const lane = String(readOption(args, '--agent', readOption(args, '--lane', '')));
-    const patchEntryId = String(readOption(args, '--patch-entry-id', readOption(args, '--patch-entry', '')));
-    const promptPositionals = positionalMission ? positionals.slice(1) : positionals;
-    const promptExplicit = promptPositionals.length > 0;
-    const prompt = promptPositionals.join(' ').trim() || 'Native agent run';
-    return { command, action, prompt, promptExplicit, route, agents, targetActiveSlots, desiredWorkItemCount, minimumWorkItems, maxQueueExpansion, concurrency, backend, backendExplicit, mock, real, readonly, profile, writeMode, applyPatches, dryRunPatches, maxWriteAgents, fastMode, serviceTier, noFast, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, zellijSessionName, zellijPaneWorker, workerPlacement, zellijVisiblePaneCap, apply, dryRun, drain, staleMs, graceMs, killEscalation, json, missionId, lane, codexApp, patchEntryId, legacyNativeRuntime };
-}
-export function resolveZellijVisiblePaneCap(value = '', explicit = false) {
-    const requested = Number(value);
-    if (explicit && Number.isFinite(requested) && requested >= 1)
-        return Math.max(1, Math.floor(requested));
-    const columns = Number(process.env.SKS_ZELLIJ_TERMINAL_COLUMNS || process.env.COLUMNS || process.stdout?.columns || 0);
-    const unknownFallback = Number(process.env.SKS_ZELLIJ_UNKNOWN_VISIBLE_PANE_CAP || 3);
-    if (!Number.isFinite(columns) || columns < 120) {
-        return Math.max(1, Math.floor(Number.isFinite(unknownFallback) ? unknownFallback : 3));
-    }
-    const reservedColumns = Number(process.env.SKS_ZELLIJ_RESERVED_COLUMNS || 108);
-    const minWorkerColumns = Number(process.env.SKS_ZELLIJ_MIN_WORKER_PANE_COLUMNS || 72);
-    const maxAutoVisible = Number(process.env.SKS_ZELLIJ_MAX_AUTO_VISIBLE_PANES || 8);
-    const available = Math.max(0, columns - Math.max(80, reservedColumns));
-    const computed = Math.floor(available / Math.max(40, minWorkerColumns));
-    return Math.max(1, Math.min(Math.max(1, Math.floor(maxAutoVisible || 8)), computed || Math.floor(unknownFallback) || 3));
-}
-function hasFlag(args, flag) {
-    return args.includes(flag);
-}
-function readOption(args, name, fallback) {
-    const index = args.indexOf(name);
-    if (index >= 0 && args[index + 1] && !String(args[index + 1]).startsWith('--'))
-        return args[index + 1];
-    const prefixed = args.find((arg) => String(arg).startsWith(name + '='));
-    return prefixed ? prefixed.slice(name.length + 1) : fallback;
-}
-function hasOption(args, name) {
-    return args.includes(name) || args.some((arg) => String(arg).startsWith(name + '='));
-}
-function positionalArgs(args, valueFlags) {
-    const out = [];
-    for (let i = 0; i < args.length; i += 1) {
-        const arg = String(args[i]);
-        if (arg.startsWith('--')) {
-            if (valueFlags.has(arg) && args[i + 1] && !String(args[i + 1]).startsWith('--'))
-                i += 1;
-            continue;
-        }
-        out.push(arg);
-    }
-    return out;
-}
-//# sourceMappingURL=agent-command-surface.js.map

package/dist/core/agents/agent-gate.js

@@ -1,70 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { AGENT_INTAKE_STAGE_ID, DEFAULT_AGENT_COUNT } from './agent-schema.js';
-async function exists(file) {
-    try {
-        await fs.access(file);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function readJson(file, fallback = null) {
-    try {
-        return JSON.parse(await fs.readFile(file, 'utf8'));
-    }
-    catch {
-        return fallback;
-    }
-}
-export async function readAgentGateStatus(root, missionId) {
-    const dir = path.join(root, '.sneakoscope', 'missions', missionId);
-    const proofPath = path.join(dir, 'agents', 'agent-proof-evidence.json');
-    const gatePath = path.join(dir, 'agent-gate.json');
-    const policyPath = path.join(dir, 'agents', 'agent-concurrency-policy.json');
-    const teamPlanPath = path.join(dir, 'team-plan.json');
-    const proof = await readJson(proofPath, null);
-    const gate = await readJson(gatePath, null);
-    const policy = await readJson(policyPath, null);
-    const teamPlan = await readJson(teamPlanPath, null);
-    const expectedAgentCount = Math.max(DEFAULT_AGENT_COUNT, Number(gate?.expected_agent_count ||
-        teamPlan?.bundle_size ||
-        policy?.agents ||
-        DEFAULT_AGENT_COUNT) || DEFAULT_AGENT_COUNT);
-    const missing = [];
-    if (!(await exists(proofPath)))
-        missing.push('agents/agent-proof-evidence.json');
-    const blockers = [...(Array.isArray(proof?.blockers) ? proof.blockers : []), ...(Array.isArray(gate?.blockers) ? gate.blockers : [])];
-    if (proof?.ok !== true)
-        blockers.push('agent_proof_not_ok');
-    if (proof?.status !== 'passed')
-        blockers.push('agent_proof_status_not_passed');
-    const agentCount = Number(proof?.agent_count || 0);
-    if (agentCount < DEFAULT_AGENT_COUNT)
-        blockers.push('agent_count_below_5');
-    if (agentCount < expectedAgentCount)
-        blockers.push('agent_count_below_expected');
-    if (proof?.no_overlap_ok !== true)
-        blockers.push('agent_no_overlap_not_ok');
-    if (proof?.ledger_hash_chain_ok !== true)
-        blockers.push('agent_ledger_hash_chain_not_ok');
-    if (proof?.consensus_ok !== true)
-        blockers.push('agent_consensus_not_ok');
-    if (proof?.janitor_ok !== true)
-        blockers.push('agent_janitor_missing_or_not_ok');
-    const sessionsClosed = proof?.all_sessions_closed === true && gate?.all_sessions_closed !== false;
-    const ok = missing.length === 0 && blockers.length === 0 && sessionsClosed && proof?.schema === 'sks.agent-proof-evidence.v1';
-    return {
-        id: AGENT_INTAKE_STAGE_ID,
-        ok,
-        missing,
-        blockers,
-        source: proofPath,
-        proof,
-        gate,
-        expected_agent_count: expectedAgentCount,
-        all_sessions_closed: sessionsClosed
-    };
-}
-//# sourceMappingURL=agent-gate.js.map

package/dist/core/agents/agent-ledger-schemas.js

@@ -1,194 +0,0 @@
-import { validateJsonSchemaRecursive } from '../json-schema-validator.js';
-const stringArray = { type: 'array', items: { type: 'string' } };
-const objectPayload = { type: 'object' };
-export const AGENT_CENTRAL_LEDGER_RUNTIME_SCHEMAS = {
-    'sks.agent-event.v1': {
-        type: 'object',
-        required: ['schema', 'sequence', 'timestamp', 'agent_id', 'session_id', 'event_type', 'previous_hash', 'current_hash', 'payload'],
-        properties: {
-            schema: { enum: ['sks.agent-event.v1', 'sks.agent-ledger-event.v1'] },
-            sequence: { type: 'integer', minimum: 1 },
-            timestamp: { type: 'string', minLength: 1 },
-            agent_id: { type: 'string', minLength: 1 },
-            session_id: { type: 'string', minLength: 1 },
-            event_type: { type: 'string', minLength: 1 },
-            previous_hash: { anyOf: [{ type: 'string' }, { type: 'null' }] },
-            current_hash: { type: 'string', minLength: 1 },
-            payload: objectPayload
-        },
-        additionalProperties: false
-    },
-    'sks.agent-message.v1': {
-        type: 'object',
-        required: ['schema', 'from', 'session_id', 'to', 'type', 'body'],
-        properties: {
-            schema: { const: 'sks.agent-message.v1' },
-            from: { type: 'string', minLength: 1 },
-            session_id: { type: 'string', minLength: 1 },
-            to: { type: 'string', minLength: 1 },
-            type: { type: 'string', minLength: 1 },
-            body: { type: 'string' }
-        },
-        additionalProperties: false
-    },
-    'sks.agent-task-board.v1': {
-        type: 'object',
-        required: ['schema', 'mission_id', 'route', 'prompt', 'slices'],
-        properties: {
-            schema: { const: 'sks.agent-task-board.v1' },
-            mission_id: { type: 'string', minLength: 1 },
-            route: { anyOf: [{ type: 'string' }, { type: 'null' }] },
-            prompt: { type: 'string' },
-            slices: { type: 'array', items: objectPayload }
-        },
-        additionalProperties: false
-    },
-    'sks.agent-session-record.v1': {
-        type: 'object',
-        required: ['schema', 'agent_id', 'session_id', 'status'],
-        properties: {
-            schema: { const: 'sks.agent-session-record.v1' },
-            agent_id: { type: 'string', minLength: 1 },
-            session_id: { type: 'string', minLength: 1 },
-            status: { type: 'string', minLength: 1 },
-            opened_at: { anyOf: [{ type: 'string' }, { type: 'null' }] },
-            heartbeat_at: { anyOf: [{ type: 'string' }, { type: 'null' }] },
-            closed_at: { anyOf: [{ type: 'string' }, { type: 'null' }] },
-            kill_reason: { type: 'string' }
-        },
-        additionalProperties: false
-    },
-    'sks.agent-lease-ledger.v1': {
-        type: 'object',
-        required: ['schema', 'leases'],
-        properties: {
-            schema: { const: 'sks.agent-leases.v1' },
-            leases: { type: 'array', items: objectPayload },
-            no_overlap_ok: { type: 'boolean' }
-        },
-        additionalProperties: false
-    },
-    'sks.agent-conflict-graph.v1': {
-        type: 'object',
-        required: ['schema', 'ok', 'nodes', 'conflicts', 'blockers'],
-        properties: {
-            schema: { const: 'sks.agent-conflict-graph.v1' },
-            ok: { type: 'boolean' },
-            nodes: { type: 'array', items: objectPayload },
-            conflicts: { type: 'array', items: objectPayload },
-            blockers: stringArray
-        },
-        additionalProperties: false
-    },
-    'sks.agent-consensus.v1': {
-        type: 'object',
-        required: ['schema', 'ok', 'status', 'agreements'],
-        properties: {
-            schema: { const: 'sks.agent-consensus.v1' },
-            ok: { type: 'boolean' },
-            status: { type: 'string', minLength: 1 },
-            agent_count: { type: 'integer', minimum: 0 },
-            agreements: { type: 'array', items: objectPayload },
-            blockers: stringArray
-        },
-        additionalProperties: false
-    },
-    'sks.agent-proof-evidence.v1': {
-        type: 'object',
-        required: ['schema', 'ok', 'status', 'mission_id', 'janitor_report', 'janitor_ok'],
-        properties: {
-            schema: { const: 'sks.agent-proof-evidence.v1' },
-            ok: { type: 'boolean' },
-            status: { type: 'string', minLength: 1 },
-            mission_id: { type: 'string' },
-            route: { type: 'string' },
-            generated_at: { type: 'string' },
-            backend: { type: 'string' },
-            execution_class: { enum: ['real', 'mock_fixture'] },
-            real_parallel_claim: { type: 'boolean' },
-            fake_backend_disclaimer: { anyOf: [{ type: 'string' }, { type: 'null' }] },
-            agent_count: { type: 'integer', minimum: 0 },
-            max_agents: { type: 'integer', minimum: 0 },
-            all_sessions_closed: { type: 'boolean' },
-            launched_count: { type: 'integer', minimum: 0 },
-            closed_session_count: { type: 'integer', minimum: 0 },
-            terminal_sessions_closed: { type: 'boolean' },
-            terminal_session_count: { type: 'integer', minimum: 0 },
-            terminal_generation_count: { type: 'integer', minimum: 0 },
-            terminal_close_report_count: { type: 'integer', minimum: 0 },
-            terminal_close_report: { type: 'string' },
-            session_generation_count: { type: 'integer', minimum: 0 },
-            all_generations_closed: { type: 'boolean' },
-            scheduler_state: { type: 'string' },
-            target_active_slots: { type: 'integer', minimum: 0 },
-            max_observed_active_slots: { type: 'integer', minimum: 0 },
-            pending_queue_drained: { type: 'boolean' },
-            backfill_count: { type: 'integer', minimum: 0 },
-            expected_backfill_count: { type: 'integer', minimum: 0 },
-            slot_count: { type: 'integer', minimum: 0 },
-            generation_count: { type: 'integer', minimum: 0 },
-            all_slots_closed_after_drain: { type: 'boolean' },
-            generated_work_item_count: { type: 'integer', minimum: 0 },
-            source_intelligence_generation_refs_ok: { type: 'boolean' },
-            goal_mode_generation_refs_ok: { type: 'boolean' },
-            tmux_lane_manifest: { type: 'string' },
-            tmux_lane_manifest_ok: { type: 'boolean' },
-            tmux_pane_launch_ledger: { type: 'string' },
-            tmux_pane_launch_count: { type: 'integer', minimum: 0 },
-            ledger_hash_chain_ok: { type: 'boolean' },
-            no_overlap_ok: { type: 'boolean' },
-            consensus_ok: { type: 'boolean' },
-            output_tail_report: { type: 'string' },
-            output_tail_records: { type: 'integer', minimum: 0 },
-            timeout_kill_report: { type: 'string' },
-            timeout_killed_sessions: stringArray,
-            cleanup_report: { type: 'string' },
-            janitor_report: { type: 'string' },
-            janitor_ok: { type: 'boolean' },
-            trust_report: { type: 'string' },
-            wrongness_records: { type: 'string' },
-            changed_files_lease_checked: { type: 'boolean' },
-            dependency_collision_risk: { type: 'array', items: { anyOf: [{ type: 'string' }, objectPayload] } },
-            blockers: stringArray
-        },
-        additionalProperties: false
-    },
-    'sks.agent-cleanup.v1': {
-        type: 'object',
-        required: ['schema', 'generated_at', 'total_sessions', 'all_sessions_closed'],
-        properties: {
-            schema: { const: 'sks.agent-cleanup.v1' },
-            generated_at: { type: 'string', minLength: 1 },
-            launched_count: { type: 'integer', minimum: 0 },
-            closed_session_count: { type: 'integer', minimum: 0 },
-            terminal_session_count: { type: 'integer', minimum: 0 },
-            total_sessions: { type: 'integer', minimum: 0 },
-            all_sessions_closed: { type: 'boolean' },
-            all_sessions_terminal: { type: 'boolean' },
-            killed_sessions: stringArray,
-            timed_out_sessions: stringArray
-        },
-        additionalProperties: false
-    },
-    'sks.agent-non-recursive-pipeline.v1': {
-        type: 'object',
-        required: ['schema', 'ok'],
-        properties: {
-            schema: { enum: ['sks.agent-non-recursive-pipeline.v1', 'sks.non-recursive-pipeline-report.v1'] },
-            ok: { type: 'boolean' },
-            status: { type: 'string' },
-            issues: { type: 'array', items: objectPayload }
-        },
-        additionalProperties: false
-    }
-};
-export function agentCentralLedgerSchemaEntries() {
-    return Object.entries(AGENT_CENTRAL_LEDGER_RUNTIME_SCHEMAS);
-}
-export function validateAgentCentralLedgerSchema(schemaId, value) {
-    const schema = AGENT_CENTRAL_LEDGER_RUNTIME_SCHEMAS[schemaId];
-    if (!schema)
-        return { ok: false, issues: [`unknown_agent_schema:${schemaId}`] };
-    return validateJsonSchemaRecursive(value, schema);
-}
-//# sourceMappingURL=agent-ledger-schemas.js.map

package/dist/core/agents/codex-exec-worker-adapter.js

@@ -1,147 +0,0 @@
-import path from 'node:path';
-import { exists, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
-import { runCodexExecAgent, buildCodexExecAgentArgs } from './agent-runner-codex-exec.js';
-import { normalizeAgentPatchEnvelope } from './agent-patch-schema.js';
-export const CODEX_EXEC_WORKER_ADAPTER_SCHEMA = 'sks.codex-exec-worker-adapter.v1';
-export async function runCodexExecWorkerAdapter(input) {
-    const root = path.resolve(input.agentRoot);
-    const workerDir = path.resolve(root, input.workerDirRel);
-    const codexResultFile = input.resultFile || path.join(workerDir, 'codex-output-last-message.json');
-    const command = buildCodexExecAgentArgs(input.agent, buildWorkerPrompt(input.slice), {
-        cwd: input.intake?.cwd || root,
-        agentRoot: root,
-        resultFile: codexResultFile,
-        schemaFile: input.outputSchemaFile,
-        profile: input.intake?.profile || null,
-        workspaceWrite: hasWriteLease(input.slice, input.intake),
-        fastMode: input.fastModePolicy.fast_mode,
-        serviceTier: input.fastModePolicy.service_tier
-    });
-    const startedAt = nowIso();
-    const result = await runCodexExecAgent(input.agent, input.slice, {
-        missionId: input.intake?.mission_id || input.intake?.parent_mission_id || '',
-        agentRoot: root,
-        cwd: input.intake?.cwd || root,
-        prompt: buildWorkerPrompt(input.slice),
-        resultFile: codexResultFile,
-        schemaFile: input.outputSchemaFile,
-        profile: input.intake?.profile || null,
-        workspaceWrite: hasWriteLease(input.slice, input.intake),
-        fastMode: input.fastModePolicy.fast_mode,
-        serviceTier: input.fastModePolicy.service_tier,
-        dryRun: input.real === true ? false : true,
-        env: {
-            SKS_AGENT_WORKER: '1',
-            SKS_PIPELINE_MODE: 'agent-worker',
-            SKS_DISABLE_ROUTE_RECURSION: '1'
-        }
-    });
-    const finishedAt = nowIso();
-    const reportRel = path.join(input.workerDirRel, 'codex-worker-process-report.json');
-    const outputTruthRel = path.join(input.workerDirRel, 'codex-worker-output-truth.json');
-    const rawReportRel = result.artifacts.find((artifact) => artifact.endsWith('agent-process-report.json')) || null;
-    const rawReport = rawReportRel ? await readJson(path.join(root, rawReportRel), null) : null;
-    const childPid = Number(rawReport?.pid);
-    const outputLastMessageExists = await exists(codexResultFile);
-    const outputJson = outputLastMessageExists ? await readJson(codexResultFile, null) : null;
-    const patchEnvelopes = normalizeModelAuthoredEnvelopes(result.patch_envelopes || [], input, Number.isFinite(childPid) ? childPid : undefined);
-    const syntheticFallback = result.unverified?.some((entry) => /stdout fallback/i.test(String(entry))) === true;
-    const processReport = {
-        schema: CODEX_EXEC_WORKER_ADAPTER_SCHEMA,
-        generated_at: nowIso(),
-        backend: 'codex-exec',
-        agent_id: input.agent.id,
-        session_id: input.agent.session_id,
-        command: [input.intake?.codex_bin || 'codex', ...command.args],
-        codex_child_pid: Number.isFinite(childPid) ? childPid : null,
-        codex_child_started_at: rawReport?.dry_run ? null : startedAt,
-        codex_child_finished_at: rawReport?.dry_run ? null : finishedAt,
-        output_last_message_path: codexResultFile,
-        output_schema_file: input.outputSchemaFile || null,
-        fast_mode: input.fastModePolicy.fast_mode,
-        service_tier: input.fastModePolicy.service_tier,
-        service_tier_passed_to_codex: command.args.includes('-c') && command.args.includes(`service_tier=${input.fastModePolicy.service_tier}`),
-        service_tier_cli_override_present: command.args.includes('-c') && command.args.includes(`service_tier=${input.fastModePolicy.service_tier}`),
-        managed_proxy_env_keys: rawReport?.managed_proxy_env_keys || [],
-        recursion_guard_env: rawReport?.recursion_guard_env === true,
-        dry_run: rawReport?.dry_run !== false,
-        exit_code: rawReport?.exit_code ?? null,
-        synthetic_stdout_fallback: syntheticFallback,
-        patch_envelope_count: patchEnvelopes.length,
-        model_authored_patch_envelopes: patchEnvelopes.length > 0,
-        blockers: [
-            ...(syntheticFallback ? ['codex_exec_synthetic_stdout_fallback'] : []),
-            ...(input.real === true && !outputLastMessageExists ? ['codex_exec_output_last_message_missing'] : [])
-        ]
-    };
-    const outputTruth = {
-        schema: 'sks.codex-worker-output-truth.v1',
-        generated_at: nowIso(),
-        ok: outputLastMessageExists && Boolean(outputJson) && !syntheticFallback,
-        output_last_message_path: codexResultFile,
-        output_last_message_exists: outputLastMessageExists,
-        output_last_message_json_parsed: Boolean(outputJson),
-        patch_envelope_count: patchEnvelopes.length,
-        model_authored_patch_envelopes: patchEnvelopes.length > 0,
-        synthetic_stdout_fallback: syntheticFallback,
-        blockers: processReport.blockers
-    };
-    await writeJsonAtomic(path.join(root, reportRel), processReport);
-    await writeJsonAtomic(path.join(root, outputTruthRel), outputTruth);
-    return {
-        result: {
-            ...result,
-            patch_envelopes: patchEnvelopes,
-            artifacts: [...new Set([...(result.artifacts || []), reportRel, outputTruthRel])],
-            codex_child_report: processReport,
-            model_authored_patch_envelopes: patchEnvelopes.length > 0,
-            fixture_patch_envelopes: false,
-            blockers: [...(result.blockers || []), ...processReport.blockers]
-        },
-        processReport,
-        outputTruth,
-        patchEnvelopes,
-        reportRel,
-        outputTruthRel
-    };
-}
-function buildWorkerPrompt(slice) {
-    const writePaths = Array.isArray(slice?.write_paths) ? slice.write_paths.map(String).filter(Boolean) : [];
-    const patchContract = writePaths.length
-        ? [
-            `Write-capable slice. write_paths=${JSON.stringify(writePaths)}.`,
-            'Return at least one patch_envelopes item with source "model_authored".',
-            `Use a write operation for ${JSON.stringify(writePaths[0])}, allowed_paths equal to write_paths, lease_proof.protected_path_check "passed", and non-empty verification_hint and rollback_hint.`,
-            'Impact-scan, machine-feedback, diff-quality, and compiled mistake rules run before queue acceptance; exported signature changes must include cochanged callers or a concrete cochange_acknowledged_reason.',
-            'For bugfix work, add a regression test first and include regression_proof with failed_before true and passed_after true. For repair work, include repair_hypothesis before patching.',
-            'For patch envelope runtime ids you cannot know yet, use numeric 0 or empty strings; SKS will bind actual worker and Codex child process ids from the process report.',
-            'Set changed_files and writes consistently with the patch envelope operation.'
-        ].join('\n')
-        : 'Read-only slice. Return patch_envelopes only if you are explicitly proposing a leased patch.';
-    return [
-        String(slice?.description || slice?.title || 'Complete the assigned worker task.'),
-        '',
-        patchContract,
-        '',
-        'Return only JSON matching the SKS agent result schema.',
-        'Set patch_queue_refs, applied_patch_refs, rollback_refs, follow_up_work_items, artifacts, blockers, and unverified to arrays.',
-        'Set backend_router_report, codex_child_report, process_child_report, tmux_child_report, and no_patch_reason to {} because SKS will bind runtime reports after your response.',
-        'Set model_authored_patch_envelopes true when patch_envelopes is non-empty, fixture_patch_envelopes false, worker_scout_evidence null when no worker Scout evidence exists, and use null for source_intelligence_refs or goal_mode_ref unless concrete artifacts are provided.'
-    ].join('\n');
-}
-function hasWriteLease(slice, intake) {
-    return Array.isArray(slice?.write_paths) && slice.write_paths.length > 0 || Array.isArray(intake?.write_paths) && intake.write_paths.length > 0;
-}
-function normalizeModelAuthoredEnvelopes(envelopes, input, childPid) {
-    return envelopes.map((envelope) => normalizeAgentPatchEnvelope({
-        ...envelope,
-        source: 'model_authored',
-        native_cli_worker_session_id: input.agent.session_id,
-        native_cli_process_id: process.pid,
-        worker_process_id: process.pid,
-        ...(childPid === undefined ? {} : { backend_child_process_id: childPid }),
-        fast_mode: input.fastModePolicy.fast_mode,
-        service_tier: input.fastModePolicy.service_tier
-    }));
-}
-//# sourceMappingURL=codex-exec-worker-adapter.js.map