sneakoscope 1.16.0 → 1.16.2

package/README.md

@@ -10,7 +10,7 @@ SKS does not try to clone every other harness. It focuses on one thing: making C
 
 ## Current Release
 
-SKS **1.16.0** closes the native multi-session agent kernel: `sks agent` and `sks --agent` create bounded agent rosters, non-overlapping leases, append-only ledgers, session lifecycle proof, recursion guards, dynamic per-agent effort routing, and native agent proof evidence. The old multi-agent command surface has been removed; native agents are the only release-supported route collaboration backend.
+SKS **1.16.2** carries forward the native multi-session agent kernel and adds Codex App prompt-side Team width control: `$Team 20:agents ...` / `$Team 20:agent ...` can request up to 20 native Team sessions. SKS **1.16.1** closed the kernel itself: `sks agent` and `sks --agent` create bounded agent rosters, non-overlapping leases, append-only ledgers, session lifecycle proof, recursion guards, dynamic per-agent effort routing, and native agent proof evidence. The old multi-agent command surface has been removed; native agents are the only release-supported route collaboration backend.
 
 ```bash
 sks mad-sks plan --target-root <path> --json

package/crates/sks-core/Cargo.lock

@@ -76,7 +76,7 @@ dependencies = [
 
 [[package]]
 name = "sks-core"
-version = "1.16.0"
+version = "1.16.2"
 dependencies = [
  "serde_json",
 ]

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.16.0"
+version = "1.16.2"
 edition = "2021"
 
 [dependencies]

package/crates/sks-core/src/main.rs

@@ -4,7 +4,7 @@ use std::io::{self, Read, Seek, SeekFrom};
 fn main() {
     let mut args = std::env::args().skip(1);
     match args.next().as_deref() {
-        Some("--version") => println!("sks-rs 1.16.0"),
+        Some("--version") => println!("sks-rs 1.16.2"),
         Some("compact-info") => {
             let mut input = String::new();
             let _ = io::stdin().read_to_string(&mut input);

package/dist/.sks-build-stamp.json

@@ -1,8 +1,8 @@
 {
   "schema": "sks.dist-build-stamp.v1",
   "package_name": "sneakoscope",
-  "package_version": "1.16.0",
-  "source_digest": "735d472d3801a0d3bfe4613c3be57bc7a3ff530b398d42871a98c63d77a424b4",
-  "source_file_count": 1542,
-  "built_at_source_time": 1779633764911
+  "package_version": "1.16.2",
+  "source_digest": "38a14936b463c4d5f6254412dbaa186a6f351f637dd5e5db82a6eb6b5eff43b9",
+  "source_file_count": 1475,
+  "built_at_source_time": 1779679969693
 }

package/dist/bin/sks.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const FAST_PACKAGE_VERSION = '1.16.0';
+const FAST_PACKAGE_VERSION = '1.16.2';
 const args = process.argv.slice(2);
 try {
     if (args[0] === '--version' || args[0] === '-v' || args[0] === 'version') {

package/dist/build-manifest.json

@@ -1,11 +1,11 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "1.16.0",
-  "package_version": "1.16.0",
+  "version": "1.16.2",
+  "package_version": "1.16.2",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "source_digest": "735d472d3801a0d3bfe4613c3be57bc7a3ff530b398d42871a98c63d77a424b4",
-  "source_file_count": 1542,
+  "source_digest": "38a14936b463c4d5f6254412dbaa186a6f351f637dd5e5db82a6eb6b5eff43b9",
+  "source_file_count": 1475,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
     "bin/sks.d.ts",

package/dist/commands/image-ux-review.d.ts

@@ -362,20 +362,9 @@ export declare function run(command: any, args?: any): Promise<void | {
                 agent_command: string;
                 team_prompt: string;
                 cap: number;
-                default: number;
-            };
-            dynamic_effort_assignment: {
-                schema: string;
-                policy_version: number;
-                dynamic: boolean;
-                service_tier: string;
-                allowed_efforts: string[];
-                max_agents: any;
-                agent_count: any;
-                concurrency: any;
-                decisions: any;
-                rule: string;
+                default: any;
             };
+            dynamic_effort_assignment: any;
             validation: {
                 route_runtime_legacy_multiagent_call_removed: boolean;
                 native_agent_plan_used: boolean;
@@ -399,6 +388,20 @@ export declare function run(command: any, args?: any): Promise<void | {
             backend: "tmux" | "fake" | "process" | "codex-exec";
             ledger_root: string;
             roster: {
+                schema: string;
+                default_agents: any;
+                max_agents: number;
+                agent_count: any;
+                concurrency: number;
+                batch_count: number;
+                personas: any;
+                persona_uniqueness: {
+                    ok: boolean;
+                    duplicate_ids: never[];
+                };
+                roster: any;
+                effort_policy: any;
+            } | {
                 effort_policy: {
                     schema: string;
                     policy_version: number;
@@ -433,38 +436,7 @@ export declare function run(command: any, args?: any): Promise<void | {
                 lease_count: number;
                 blockers: string[];
             };
-            results: (import("../core/agents/agent-schema.js").AgentRunnerResult | {
-                schema: string;
-                mission_id: string;
-                agent_id: any;
-                session_id: any;
-                persona_id: any;
-                task_slice_id: any;
-                status: string;
-                backend: string;
-                summary: string;
-                findings: never[];
-                proposed_changes: never[];
-                changed_files: never[];
-                lease_compliance: {
-                    ok: boolean;
-                    violations: never[];
-                };
-                artifacts: string[];
-                blockers: string[];
-                confidence: string;
-                handoff_notes: string;
-                unverified: never[];
-                writes: never[];
-                verification: {
-                    status: string;
-                    checks: never[];
-                };
-                recursion_guard: {
-                    ok: boolean;
-                    violations: never[];
-                };
-            })[];
+            results: any[];
             consensus: {
                 schema: string;
                 ok: boolean;
@@ -596,6 +568,8 @@ export declare function run(command: any, args?: any): Promise<void | {
                 cleanup_report: string;
                 trust_report: string;
                 wrongness_records: string;
+                changed_files_lease_checked: boolean;
+                dependency_collision_risk: any;
                 blockers: any[];
             };
         };

package/dist/commands/ppt.d.ts

@@ -214,20 +214,9 @@ export declare function run(command: any, args?: any): Promise<void | {
                 agent_command: string;
                 team_prompt: string;
                 cap: number;
-                default: number;
-            };
-            dynamic_effort_assignment: {
-                schema: string;
-                policy_version: number;
-                dynamic: boolean;
-                service_tier: string;
-                allowed_efforts: string[];
-                max_agents: any;
-                agent_count: any;
-                concurrency: any;
-                decisions: any;
-                rule: string;
+                default: any;
             };
+            dynamic_effort_assignment: any;
             validation: {
                 route_runtime_legacy_multiagent_call_removed: boolean;
                 native_agent_plan_used: boolean;
@@ -251,6 +240,20 @@ export declare function run(command: any, args?: any): Promise<void | {
             backend: "tmux" | "fake" | "process" | "codex-exec";
             ledger_root: string;
             roster: {
+                schema: string;
+                default_agents: any;
+                max_agents: number;
+                agent_count: any;
+                concurrency: number;
+                batch_count: number;
+                personas: any;
+                persona_uniqueness: {
+                    ok: boolean;
+                    duplicate_ids: never[];
+                };
+                roster: any;
+                effort_policy: any;
+            } | {
                 effort_policy: {
                     schema: string;
                     policy_version: number;
@@ -285,38 +288,7 @@ export declare function run(command: any, args?: any): Promise<void | {
                 lease_count: number;
                 blockers: string[];
             };
-            results: (import("../core/agents/agent-schema.js").AgentRunnerResult | {
-                schema: string;
-                mission_id: string;
-                agent_id: any;
-                session_id: any;
-                persona_id: any;
-                task_slice_id: any;
-                status: string;
-                backend: string;
-                summary: string;
-                findings: never[];
-                proposed_changes: never[];
-                changed_files: never[];
-                lease_compliance: {
-                    ok: boolean;
-                    violations: never[];
-                };
-                artifacts: string[];
-                blockers: string[];
-                confidence: string;
-                handoff_notes: string;
-                unverified: never[];
-                writes: never[];
-                verification: {
-                    status: string;
-                    checks: never[];
-                };
-                recursion_guard: {
-                    ok: boolean;
-                    violations: never[];
-                };
-            })[];
+            results: any[];
             consensus: {
                 schema: string;
                 ok: boolean;
@@ -448,6 +420,8 @@ export declare function run(command: any, args?: any): Promise<void | {
                 cleanup_report: string;
                 trust_report: string;
                 wrongness_records: string;
+                changed_files_lease_checked: boolean;
+                dependency_collision_risk: any;
                 blockers: any[];
             };
         };

package/dist/core/agents/agent-command-surface.d.ts

@@ -10,5 +10,7 @@ export declare function parseAgentCommandArgs(command: string, args?: string[]):
     real: boolean;
     readonly: boolean;
     json: boolean;
+    missionId: string;
+    lane: string;
 };
 //# sourceMappingURL=agent-command-surface.d.ts.map

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

@@ -1,7 +1,8 @@
 import { DEFAULT_AGENT_COUNT } from './agent-schema.js';
 export function parseAgentCommandArgs(command, args = []) {
     const first = args[0] && !String(args[0]).startsWith('--') ? String(args[0]) : '';
-    const action = first === 'run' || first === 'status' ? first : 'run';
+    const actions = new Set(['run', 'status', 'plan', 'spawn', 'watch', 'lane', 'board', 'ledger', 'collect', 'consensus', 'close', 'cleanup', 'proof', 'explain']);
+    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));
@@ -11,8 +12,11 @@ export function parseAgentCommandArgs(command, args = []) {
     const mock = hasFlag(args, '--mock') || backend === 'fake';
     const real = hasFlag(args, '--real');
     const readonly = hasFlag(args, '--readonly') || hasFlag(args, '--read-only');
-    const prompt = positionalArgs(rest, new Set(['--agents', '--concurrency', '--backend', '--route'])).join(' ').trim() || 'Native agent run';
-    return { command, action, prompt, route, agents, concurrency, backend, mock, real, readonly, json };
+    const missionDefault = action === 'run' || action === 'spawn' || action === 'plan' ? '' : 'latest';
+    const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', missionDefault)));
+    const lane = String(readOption(args, '--agent', readOption(args, '--lane', '')));
+    const prompt = positionalArgs(rest, new Set(['--agents', '--concurrency', '--backend', '--route', '--mission', '--mission-id', '--agent', '--lane'])).join(' ').trim() || 'Native agent run';
+    return { command, action, prompt, route, agents, concurrency, backend, mock, real, readonly, json, missionId, lane };
 }
 function hasFlag(args, flag) {
     return args.includes(flag);

package/dist/core/agents/agent-orchestrator.d.ts

@@ -7,6 +7,20 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
     backend: "tmux" | "fake" | "process" | "codex-exec";
     ledger_root: string;
     roster: {
+        schema: string;
+        default_agents: any;
+        max_agents: number;
+        agent_count: any;
+        concurrency: number;
+        batch_count: number;
+        personas: any;
+        persona_uniqueness: {
+            ok: boolean;
+            duplicate_ids: never[];
+        };
+        roster: any;
+        effort_policy: any;
+    } | {
         effort_policy: {
             schema: string;
             policy_version: number;
@@ -41,38 +55,7 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
         lease_count: number;
         blockers: string[];
     };
-    results: (import("./agent-schema.js").AgentRunnerResult | {
-        schema: string;
-        mission_id: string;
-        agent_id: any;
-        session_id: any;
-        persona_id: any;
-        task_slice_id: any;
-        status: string;
-        backend: string;
-        summary: string;
-        findings: never[];
-        proposed_changes: never[];
-        changed_files: never[];
-        lease_compliance: {
-            ok: boolean;
-            violations: never[];
-        };
-        artifacts: string[];
-        blockers: string[];
-        confidence: string;
-        handoff_notes: string;
-        unverified: never[];
-        writes: never[];
-        verification: {
-            status: string;
-            checks: never[];
-        };
-        recursion_guard: {
-            ok: boolean;
-            violations: never[];
-        };
-    })[];
+    results: any[];
     consensus: {
         schema: string;
         ok: boolean;
@@ -204,6 +187,8 @@ export declare function runNativeAgentOrchestrator(opts?: AgentRunOptions): Prom
         cleanup_report: string;
         trust_report: string;
         wrongness_records: string;
+        changed_files_lease_checked: boolean;
+        dependency_collision_risk: any;
         blockers: any[];
     };
 }>;

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

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { createMission, missionDir, setCurrent } from '../mission.js';
 import { nowIso, readJson, writeJsonAtomic } from '../fsx.js';
-import { buildAgentRoster } from './agent-roster.js';
+import { buildAgentRoster, normalizeAgentConcurrency } from './agent-roster.js';
 import { buildAgentWorkPartition } from './agent-work-partition.js';
 import { initializeAgentCentralLedger, appendAgentLedgerEvent, compactAgentLedger } from './agent-central-ledger.js';
 import { detectStaleAgentSessions, killTimedOutAgentSessions, openAgentSession, heartbeatAgentSession, collectAgentSession, completeAgentSession, closeAgentSession, writeAgentLifecycleAggregate, writeAgentLifecyclePolicy } from './agent-lifecycle.js';
@@ -26,7 +26,7 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         : await createMission(root, { mode: 'agent', prompt });
     const missionId = created.id;
     const dir = created.dir;
-    const roster = buildAgentRoster({ agents: opts.agents, concurrency: opts.concurrency, prompt, ...(opts.readonly === undefined ? {} : { readonly: opts.readonly }) });
+    const roster = buildProvidedAgentRoster(opts.roster, { concurrency: opts.concurrency, readonly: opts.readonly }) || buildAgentRoster({ agents: opts.agents, concurrency: opts.concurrency, prompt, ...(opts.readonly === undefined ? {} : { readonly: opts.readonly }) });
     const partition = await buildAgentWorkPartition(root, roster, prompt);
     const ledgerRoot = await initializeAgentCentralLedger(dir, { missionId, roster, partition, route, prompt });
     await writeJsonAtomic(path.join(ledgerRoot, 'agent-no-overlap-proof.json'), partition.no_overlap_proof || { schema: 'sks.agent-no-overlap-proof.v1', ok: false, blockers: ['missing_no_overlap_proof'] });
@@ -106,6 +106,48 @@ export async function runNativeAgentOrchestrator(opts = {}) {
         proof
     };
 }
+function buildProvidedAgentRoster(input, opts = {}) {
+    const sourceRows = Array.isArray(input?.roster) ? input.roster : Array.isArray(input?.personas) ? input.personas : [];
+    if (!sourceRows.length)
+        return null;
+    const agentCount = sourceRows.length;
+    const concurrency = normalizeAgentConcurrency(opts.concurrency ?? input?.concurrency ?? agentCount, agentCount);
+    const personas = Array.isArray(input?.personas) ? input.personas : sourceRows;
+    const roster = sourceRows.map((entry, index) => {
+        const readOnly = opts.readonly === true || entry.read_only === true;
+        const id = String(entry.id || entry.agent_id || `agent_${index + 1}`);
+        return {
+            id,
+            session_id: String(entry.session_id || `${id}-session-${String(index + 1).padStart(2, '0')}`),
+            persona_id: String(entry.persona_id || id),
+            role: String(entry.role || 'verifier'),
+            index: index + 1,
+            write_policy: String(entry.write_policy || (readOnly ? 'read-only' : 'route-local-artifact')),
+            status: 'pending',
+            reasoning_effort: entry.reasoning_effort || entry.model_reasoning_effort || (readOnly ? 'high' : 'medium'),
+            model_reasoning_effort: entry.model_reasoning_effort || entry.reasoning_effort || (readOnly ? 'high' : 'medium'),
+            reasoning_profile: entry.reasoning_profile || (readOnly ? 'sks-logic-high' : 'sks-logic-medium'),
+            service_tier: entry.service_tier,
+            reasoning_reason: entry.reasoning_reason || 'route_native_agent_plan',
+            dynamic_effort_policy: entry.dynamic_effort_policy || {
+                escalation_triggers: ['route_requires_native_agent_proof'],
+                downshift_triggers: []
+            }
+        };
+    });
+    return {
+        schema: 'sks.agent-roster.v1',
+        default_agents: agentCount,
+        max_agents: Math.max(agentCount, 20),
+        agent_count: agentCount,
+        concurrency,
+        batch_count: Math.ceil(agentCount / concurrency),
+        personas,
+        persona_uniqueness: { ok: true, duplicate_ids: [] },
+        roster,
+        effort_policy: input?.effort_policy || { schema: 'sks.agent-effort-policy.v1', dynamic: true, decisions: [] }
+    };
+}
 async function runAgentByBackend(backend, agent, slice, opts) {
     if (backend === 'process')
         return runProcessAgent(agent, slice, opts);

package/dist/core/agents/agent-proof-evidence.d.ts

@@ -35,6 +35,8 @@ export declare function writeAgentProofEvidence(root: string, input: {
     cleanup_report: string;
     trust_report: string;
     wrongness_records: string;
+    changed_files_lease_checked: boolean;
+    dependency_collision_risk: any;
     blockers: any[];
 }>;
 export declare function readAgentProofEvidence(root: string, missionId: string): Promise<any>;

package/dist/core/agents/agent-proof-evidence.js

@@ -11,7 +11,8 @@ export async function writeAgentProofEvidence(root, input) {
         ...(ledger.blockers || []),
         ...(input.partition?.blockers || []),
         ...(input.consensus?.blockers || []),
-        ...(input.results || []).flatMap((result) => result.blockers || [])
+        ...(input.results || []).flatMap((result) => result.blockers || []),
+        ...agentChangedFileLeaseViolations(input.results || [], input.partition?.leases || [])
     ];
     const evidence = {
         schema: AGENT_PROOF_EVIDENCE_SCHEMA,
@@ -37,6 +38,8 @@ export async function writeAgentProofEvidence(root, input) {
         cleanup_report: 'agent-cleanup.json',
         trust_report: 'agent-trust-report.json',
         wrongness_records: 'agent-wrongness-records.json',
+        changed_files_lease_checked: true,
+        dependency_collision_risk: input.partition?.no_overlap_proof?.dependency_collision_risk || [],
         blockers
     };
     await writeJsonAtomic(path.join(root, 'agent-proof-evidence.json'), evidence);
@@ -45,4 +48,23 @@ export async function writeAgentProofEvidence(root, input) {
 export async function readAgentProofEvidence(root, missionId) {
     return readJson(path.join(root, '.sneakoscope', 'missions', missionId, 'agents', 'agent-proof-evidence.json'), null);
 }
+function agentChangedFileLeaseViolations(results, leases) {
+    const activeWrites = leases.filter((lease) => lease.kind === 'write' && lease.status !== 'released');
+    const violations = [];
+    for (const result of results) {
+        const agentId = result.agent_id;
+        for (const file of result.changed_files || []) {
+            const normalized = String(file || '').replace(/\\/g, '/').replace(/^\.\//, '');
+            const allowed = activeWrites.some((lease) => lease.agent_id === agentId && pathWithin(normalized, lease.path));
+            if (!allowed)
+                violations.push('lease_changed_file_violation:' + agentId + ':' + normalized);
+        }
+    }
+    return violations;
+}
+function pathWithin(file, leasePath) {
+    const left = String(file || '').replace(/\\/g, '/').replace(/^\.\//, '');
+    const right = String(leasePath || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+    return left === right || left.startsWith(right + '/');
+}
 //# sourceMappingURL=agent-proof-evidence.js.map

package/dist/core/agents/agent-runner-codex-exec.d.ts

@@ -2,5 +2,36 @@ export declare function buildCodexExecAgentArgs(agent: any, prompt: string, opts
     resultFile: any;
     args: any[];
 };
-export declare function runCodexExecAgent(agent: any, slice: any, opts?: any): Promise<import("./agent-schema.js").AgentRunnerResult>;
+export declare function runCodexExecAgent(agent: any, slice: any, opts?: any): Promise<{
+    status: string;
+    blockers: string[];
+    schema: typeof import("./agent-schema.js").AGENT_RESULT_SCHEMA;
+    mission_id: string;
+    agent_id: string;
+    session_id: string;
+    persona_id: string;
+    task_slice_id: string;
+    backend: import("./agent-schema.js").AgentBackend;
+    summary: string;
+    findings: string[];
+    proposed_changes: string[];
+    changed_files: string[];
+    lease_compliance: {
+        ok: boolean;
+        violations: string[];
+    };
+    artifacts: string[];
+    confidence: string;
+    handoff_notes: string;
+    unverified: string[];
+    writes: string[];
+    recursion_guard: {
+        ok: boolean;
+        violations: string[];
+    };
+    verification: {
+        status: string;
+        checks: string[];
+    };
+}>;
 //# sourceMappingURL=agent-runner-codex-exec.d.ts.map

package/dist/core/agents/agent-runner-codex-exec.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
-import { runProcess, writeJsonAtomic } from '../fsx.js';
-import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
+import { readJson, runProcess, writeJsonAtomic } from '../fsx.js';
+import { agentWorkerEnv, validateAgentWorkerResult } from './agent-worker-pipeline.js';
 export function buildCodexExecAgentArgs(agent, prompt, opts = {}) {
     const resultFile = opts.resultFile || path.join(opts.cwd || process.cwd(), agent.session_id + '-agent-result.json');
     const sandbox = opts.workspaceWrite ? 'workspace-write' : 'read-only';
@@ -42,7 +42,9 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
     const logRoot = path.join(opts.agentRoot || opts.cwd || process.cwd(), 'sessions', agent.id);
     const stdoutFile = path.join(logRoot, 'codex-exec.stdout.log');
     const stderrFile = path.join(logRoot, 'codex-exec.stderr.log');
-    const result = await runProcess(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: opts.env, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile });
+    const allowedCommandsFile = path.join(opts.agentRoot || opts.cwd || process.cwd(), 'agent-allowed-commands.json');
+    const workerEnv = agentWorkerEnv(agent, allowedCommandsFile);
+    const result = await runProcess(opts.codexBin || 'codex', command.args, { cwd: opts.cwd || process.cwd(), env: { ...(opts.env || {}), ...workerEnv }, timeoutMs: opts.timeoutMs || 30 * 60 * 1000, maxOutputBytes: 256 * 1024, stdoutFile, stderrFile });
     const report = await writeCodexProcessReport(opts.agentRoot || opts.cwd || process.cwd(), agent, {
         command: [opts.codexBin || 'codex', ...command.args],
         pid: result.pid || null,
@@ -57,7 +59,16 @@ export async function runCodexExecAgent(agent, slice, opts = {}) {
         timed_out: result.timedOut,
         dry_run: false
     });
-    return validateAgentWorkerResult({ mission_id: opts.missionId || opts.mission_id || '', agent_id: agent.id, session_id: agent.session_id, persona_id: agent.persona_id || agent.id, task_slice_id: slice?.id || '', status: result.code === 0 ? 'done' : 'failed', backend: 'codex-exec', summary: result.stdout.slice(-1000) || result.stderr.slice(-1000), artifacts: [command.resultFile, report], blockers: result.code === 0 ? [] : ['codex_exec_exit_' + result.code], unverified: [], writes: [], verification: { status: result.code === 0 ? 'passed' : 'failed', checks: ['codex-exec-exit-code', 'codex-exec-process-report'] } });
+    if (result.code === 0) {
+        const parsed = await readJson(command.resultFile, null).catch(() => null);
+        if (parsed) {
+            const validated = validateAgentWorkerResult({ ...parsed, mission_id: parsed.mission_id || opts.missionId || opts.mission_id || '', agent_id: parsed.agent_id || agent.id, session_id: parsed.session_id || agent.session_id, persona_id: parsed.persona_id || agent.persona_id || agent.id, task_slice_id: parsed.task_slice_id || slice?.id || '', backend: 'codex-exec', artifacts: [...(Array.isArray(parsed.artifacts) ? parsed.artifacts : []), command.resultFile, report], verification: { status: parsed.verification?.status || 'passed', checks: [...(Array.isArray(parsed.verification?.checks) ? parsed.verification.checks : []), 'codex-exec-output-last-message', 'agent-result-schema'] } });
+            if (!validated.blockers.some((blocker) => blocker.startsWith('schema_invalid:')))
+                return validated;
+            return { ...validated, status: 'blocked', blockers: [...validated.blockers, 'codex_exec_result_schema_invalid'] };
+        }
+    }
+    return validateAgentWorkerResult({ mission_id: opts.missionId || opts.mission_id || '', agent_id: agent.id, session_id: agent.session_id, persona_id: agent.persona_id || agent.id, task_slice_id: slice?.id || '', status: result.code === 0 ? 'done' : 'failed', backend: 'codex-exec', summary: result.stdout.slice(-1000) || result.stderr.slice(-1000), artifacts: [command.resultFile, report], blockers: result.code === 0 ? ['codex_exec_output_last_message_missing_or_invalid'] : ['codex_exec_exit_' + result.code], confidence: 'verified_partial', unverified: result.code === 0 ? ['codex-exec stdout fallback; resultFile JSON missing or invalid'] : [], writes: [], verification: { status: result.code === 0 ? 'partial' : 'failed', checks: ['codex-exec-exit-code', 'codex-exec-process-report', 'codex-exec-output-last-message'] } });
 }
 async function writeCodexProcessReport(root, agent, report) {
     const rel = path.join('sessions', agent.id, 'agent-process-report.json');

package/dist/core/agents/agent-schema.d.ts

@@ -66,6 +66,7 @@ export interface AgentRunOptions {
     route?: string;
     agents?: number;
     concurrency?: number;
+    roster?: unknown;
     backend?: AgentBackend | string;
     json?: boolean;
     mock?: boolean;

package/dist/core/agents/agent-work-partition.d.ts

@@ -21,6 +21,7 @@ export declare function buildAgentWorkPartition(root: string, roster: any, promp
             from: string;
             imports: string[];
         }[];
+        parsed_import_edges: boolean;
         package_boundaries: (string | undefined)[];
         test_to_source_relations: {
             test: string;
@@ -29,8 +30,10 @@ export declare function buildAgentWorkPartition(root: string, roster: any, promp
     };
     semantic_domain_graph: {
         schema: string;
+        route_domain_ownership: boolean;
         domains: {
             id: string;
+            criticality: number;
             files: string[];
         }[];
         route_domains: string[];
@@ -69,6 +72,7 @@ export declare function buildAgentWorkPartition(root: string, roster: any, promp
         write_lease_count: number;
         read_lease_count: number;
         blockers: string[];
+        dependency_collision_risk: string[];
         rule: string;
     };
     blockers: string[];