sneakoscope 1.18.8 → 1.18.9

package/README.md

@@ -16,7 +16,7 @@ Set up this agent project with Sneakoscope Codex. Use [[mandarange/Sneakoscope-C
 
 ## Current Release
 
-SKS **1.18.8** closes the Codex 0.134 ultra-stability loop: the release matrix now covers `--profile` as the primary selector, bounded local Codex history search, managed proxy propagation, MCP 0.134 environment/OAuth/schema/readOnlyHint policy, proof-safe parallel agent patches, runtime truth P6 rows, the 1.18.8 release gate audit, MAD-SKS as general scoped permission widening, gpt-image-2 imagegen as a core evidence capability, and retention cleanup that preserves durable learning while removing finished route scratch.
+SKS **1.18.9** closes the Patch Swarm runtime surface: Appshots evidence now records Codex thread attachment provenance without claiming CLI-created screenshots, MCP `readOnlyHint` gates require runtime overlap/serialization proof, Codex 0.134 runner truth covers profile, proxy, history, and process reports, and release gates expose these checks alongside the patch queue/apply/proof work.
 
 ```bash
 sks mad-sks plan --target-root <path> --json
@@ -44,8 +44,10 @@ npm run strategy:adhd-orchestrating-gate
 npm run strategy:parallel-modification-plan
 npm run appshots:evidence
 npm run appshots:source-intelligence
+npm run appshots:thread-attachment-discovery
 npm run mcp:0.134-modernization
-npm run mcp:readonly-concurrency
+npm run mcp:readonly-runtime-scheduler
+npm run codex:0.134-runner-truth
 npm run source-intelligence:codex-history-search
 npm run agent:parallel-write-kernel
 npm run release:gate-existence-audit
@@ -111,6 +113,8 @@ The cleanup contract is policy-backed in `.sneakoscope/policy.json`, but the def
 - ADHD orchestration gate: [docs/adhd-orchestrating-gate.md](docs/adhd-orchestrating-gate.md)
 - Strategy-first parallel write: [docs/strategy-first-parallel-write.md](docs/strategy-first-parallel-write.md)
 - Appshots pipeline: [docs/appshots-pipeline.md](docs/appshots-pipeline.md)
+- Appshots thread attachments: [docs/appshots-thread-attachments.md](docs/appshots-thread-attachments.md)
+- MCP readOnly scheduler: [docs/mcp-readonly-scheduler.md](docs/mcp-readonly-scheduler.md)
 - Parallel write agents: [docs/parallel-write-agents.md](docs/parallel-write-agents.md)
 - Agent patch queue: [docs/agent-patch-queue.md](docs/agent-patch-queue.md)
 - Migration 1.18.7 to 1.18.8: [docs/migration-1.18.7-to-1.18.8.md](docs/migration-1.18.7-to-1.18.8.md)

package/crates/sks-core/Cargo.lock

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

package/crates/sks-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sks-core"
-version = "1.18.8"
+version = "1.18.9"
 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.18.8"),
+        Some("--version") => println!("sks-rs 1.18.9"),
         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.18.8",
-  "source_digest": "f00f42e2af3a45681da126c20bfcd5d3345fd2ace666c76010660d39ca88cdc6",
-  "source_file_count": 1514,
-  "built_at_source_time": 1779887241763
+  "package_version": "1.18.9",
+  "source_digest": "6eee8ecc34d3c7ce9e86cabc59e92764287b996a5387f26f12ec3253fee6869e",
+  "source_file_count": 1537,
+  "built_at_source_time": 1779893098646
 }

package/dist/bin/sks.js

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

package/dist/build-manifest.json

@@ -1,16 +1,16 @@
 {
   "schema": "sks.dist-build.v2",
-  "version": "1.18.8",
-  "package_version": "1.18.8",
+  "version": "1.18.9",
+  "package_version": "1.18.9",
   "typescript": true,
   "mjs_runtime_files": 0,
-  "compiled_file_count": 908,
-  "compiled_js_count": 454,
-  "compiled_dts_count": 454,
-  "source_digest": "f00f42e2af3a45681da126c20bfcd5d3345fd2ace666c76010660d39ca88cdc6",
-  "source_file_count": 1514,
-  "source_files_hash": "617adc02ea5a7a6cf0ad7cfac691a817e9fb26380d5f21a249eaea89c0a7b8ea",
-  "source_list_hash": "617adc02ea5a7a6cf0ad7cfac691a817e9fb26380d5f21a249eaea89c0a7b8ea",
+  "compiled_file_count": 910,
+  "compiled_js_count": 455,
+  "compiled_dts_count": 455,
+  "source_digest": "6eee8ecc34d3c7ce9e86cabc59e92764287b996a5387f26f12ec3253fee6869e",
+  "source_file_count": 1537,
+  "source_files_hash": "3475322f249a9a6a5286d536a5e69dfe6f2b06ad2d64a1b0bd9c408b19257f10",
+  "source_list_hash": "3475322f249a9a6a5286d536a5e69dfe6f2b06ad2d64a1b0bd9c408b19257f10",
   "src_mjs_runtime_files": 0,
   "dist_stamp_schema": "sks.dist-build-stamp.v1",
   "files": [
@@ -226,6 +226,8 @@
     "core/agents/agent-patch-apply-worker.js",
     "core/agents/agent-patch-proof.d.ts",
     "core/agents/agent-patch-proof.js",
+    "core/agents/agent-patch-queue-store.d.ts",
+    "core/agents/agent-patch-queue-store.js",
     "core/agents/agent-patch-queue.d.ts",
     "core/agents/agent-patch-queue.js",
     "core/agents/agent-patch-schema.d.ts",

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

@@ -511,6 +511,7 @@ export declare function run(command: any, args?: any): Promise<void | {
                 status: string;
                 blockers: string[];
             };
+            patch_swarm?: never;
         } | {
             schema: string;
             ok: boolean;
@@ -781,6 +782,48 @@ export declare function run(command: any, args?: any): Promise<void | {
                     appshots_operator_action_required: boolean;
                 };
             };
+            patch_swarm: {
+                schema: string;
+                generated_at: string;
+                ok: boolean;
+                mission_id: string;
+                route: string;
+                route_command: string;
+                write_capable: boolean;
+                dry_run: boolean;
+                patch_envelope_count: number;
+                apply_started_at: string;
+                apply_finished_at: string;
+                apply_latency_ms: number;
+                parallel_apply_count: number;
+                parallel_apply_groups: {
+                    group_id: string;
+                    entry_ids: string[];
+                    agents: string[];
+                    expected_speedup: number;
+                }[];
+                serial_merge_groups: {
+                    group_id: string;
+                    entry_ids: string[];
+                    agents: string[];
+                    reason: string;
+                    file: string;
+                }[];
+                wall_clock_parallel_evidence: string[];
+                expected_speedup: number;
+                conflicted_agent_count: number;
+                artifacts: {
+                    queue: string;
+                    events: string;
+                    ownership: string;
+                    merge: string;
+                    apply_results: string;
+                    verification: string;
+                    rollback: string;
+                    proof: string;
+                };
+                blockers: string[];
+            };
             proof: {
                 schema: string;
                 ok: boolean;
@@ -801,6 +844,27 @@ export declare function run(command: any, args?: any): Promise<void | {
                 parallel_write_apply_patches: boolean;
                 parallel_write_dry_run_patches: boolean;
                 parallel_write_max_write_agents: number;
+                patch_swarm_runtime: string | null;
+                patch_queue: string | null;
+                patch_queue_events: string | null;
+                patch_queue_event_count: number;
+                patch_proof: string | null;
+                patch_queue_ok: boolean;
+                patch_apply_ok: any;
+                patch_verification_ok: any;
+                patch_rollback_ok: any;
+                parallel_patch_apply_verified: boolean;
+                patch_conflict_count: number;
+                serial_bottleneck_count: number;
+                changed_files_by_agent: Record<string, string[]>;
+                lease_compliance_by_patch: {
+                    patch_entry_id: any;
+                    agent_id: any;
+                    lease_id: any;
+                    ok: boolean;
+                    write_paths: any;
+                }[];
+                rollback_digest_count: any;
                 real_parallel_claim: boolean;
                 fake_backend_disclaimer: string | null;
                 agent_count: any;

package/dist/commands/ppt.d.ts

@@ -360,6 +360,7 @@ export declare function run(command: any, args?: any): Promise<void | {
                 status: string;
                 blockers: string[];
             };
+            patch_swarm?: never;
         } | {
             schema: string;
             ok: boolean;
@@ -630,6 +631,48 @@ export declare function run(command: any, args?: any): Promise<void | {
                     appshots_operator_action_required: boolean;
                 };
             };
+            patch_swarm: {
+                schema: string;
+                generated_at: string;
+                ok: boolean;
+                mission_id: string;
+                route: string;
+                route_command: string;
+                write_capable: boolean;
+                dry_run: boolean;
+                patch_envelope_count: number;
+                apply_started_at: string;
+                apply_finished_at: string;
+                apply_latency_ms: number;
+                parallel_apply_count: number;
+                parallel_apply_groups: {
+                    group_id: string;
+                    entry_ids: string[];
+                    agents: string[];
+                    expected_speedup: number;
+                }[];
+                serial_merge_groups: {
+                    group_id: string;
+                    entry_ids: string[];
+                    agents: string[];
+                    reason: string;
+                    file: string;
+                }[];
+                wall_clock_parallel_evidence: string[];
+                expected_speedup: number;
+                conflicted_agent_count: number;
+                artifacts: {
+                    queue: string;
+                    events: string;
+                    ownership: string;
+                    merge: string;
+                    apply_results: string;
+                    verification: string;
+                    rollback: string;
+                    proof: string;
+                };
+                blockers: string[];
+            };
             proof: {
                 schema: string;
                 ok: boolean;
@@ -650,6 +693,27 @@ export declare function run(command: any, args?: any): Promise<void | {
                 parallel_write_apply_patches: boolean;
                 parallel_write_dry_run_patches: boolean;
                 parallel_write_max_write_agents: number;
+                patch_swarm_runtime: string | null;
+                patch_queue: string | null;
+                patch_queue_events: string | null;
+                patch_queue_event_count: number;
+                patch_proof: string | null;
+                patch_queue_ok: boolean;
+                patch_apply_ok: any;
+                patch_verification_ok: any;
+                patch_rollback_ok: any;
+                parallel_patch_apply_verified: boolean;
+                patch_conflict_count: number;
+                serial_bottleneck_count: number;
+                changed_files_by_agent: Record<string, string[]>;
+                lease_compliance_by_patch: {
+                    patch_entry_id: any;
+                    agent_id: any;
+                    lease_id: any;
+                    ok: boolean;
+                    write_paths: any;
+                }[];
+                rollback_digest_count: any;
                 real_parallel_claim: boolean;
                 fake_backend_disclaimer: string | null;
                 agent_count: any;

package/dist/core/agents/agent-codex-cockpit.d.ts

@@ -43,6 +43,13 @@ export interface AgentCodexCockpitState {
     pending_queue_count: number | null;
     backfill_count: number | null;
     scheduler_status: string | null;
+    patch_swarm_phase: string | null;
+    patch_queue_depth: number | null;
+    patch_apply_groups: Array<Record<string, unknown>>;
+    patch_changed_files_by_agent: Record<string, unknown>;
+    patch_verification_status: Array<Record<string, unknown>>;
+    patch_rollback_status: Array<Record<string, unknown>>;
+    patch_micro_win_links: Array<Record<string, unknown>>;
     worker_slots: Array<Record<string, unknown>>;
     session_generations: Array<Record<string, unknown>>;
     blockers: string[];

package/dist/core/agents/agent-codex-cockpit.js

@@ -40,6 +40,12 @@ export async function buildAgentCodexCockpitState(missionDir, opts = {}) {
     const scheduler = await readJson(path.join(root, 'agent-scheduler-state.json'), null);
     const workerSlots = await readJson(path.join(root, 'agent-worker-slots.json'), null);
     const generations = await readJson(path.join(root, 'agent-session-generations.json'), null);
+    const patchSwarm = await readJson(path.join(root, 'agent-patch-swarm-runtime.json'), null);
+    const patchQueue = await readJson(path.join(root, 'agent-patch-queue.json'), null);
+    const patchMerge = await readJson(path.join(root, 'agent-merge-coordinator-report.json'), null);
+    const patchVerification = await readJson(path.join(root, 'agent-patch-verification-results.json'), null);
+    const patchRollback = await readJson(path.join(root, 'agent-patch-rollback-proof.json'), null);
+    const patchProof = await readJson(path.join(root, 'agent-patch-proof.json'), null);
     const terminalClosed = proof?.terminal_sessions_closed === true;
     const eventsTail = await readTailLines(path.join(root, 'agent-events.jsonl'), 8);
     const cockpitEventsTail = await readTailLines(path.join(root, AGENT_CODEX_COCKPIT_EVENTS), 8);
@@ -76,6 +82,13 @@ export async function buildAgentCodexCockpitState(missionDir, opts = {}) {
         pending_queue_count: scheduler?.pending_count ?? null,
         backfill_count: scheduler?.backfill_count ?? null,
         scheduler_status: scheduler?.status || null,
+        patch_swarm_phase: patchSwarm ? (patchSwarm.ok === true ? 'passed' : 'blocked') : null,
+        patch_queue_depth: patchQueue?.queued_count ?? null,
+        patch_apply_groups: Array.isArray(patchMerge?.parallel_apply_groups) ? patchMerge.parallel_apply_groups : [],
+        patch_changed_files_by_agent: patchProof?.changed_files_by_agent || {},
+        patch_verification_status: Array.isArray(patchVerification?.results) ? patchVerification.results : [],
+        patch_rollback_status: Array.isArray(patchRollback?.entries) ? patchRollback.entries : [],
+        patch_micro_win_links: buildPatchMicroWinLinks(patchQueue),
         worker_slots: Array.isArray(workerSlots?.slots) ? workerSlots.slots : [],
         session_generations: generations?.generations ? Object.values(generations.generations) : [],
         blockers,
@@ -109,6 +122,9 @@ export function renderAgentCodexDashboard(state) {
         `- tmux attach: ${state.tmux_attach_command || 'unknown'}`,
         `- All sessions closed: ${state.all_sessions_closed ?? 'unknown'}`,
         `- Scheduler: ${state.scheduler_status || 'unknown'}`,
+        `- Patch swarm: ${state.patch_swarm_phase || 'unknown'}`,
+        `- Patch queue depth: ${state.patch_queue_depth ?? 'unknown'}`,
+        `- Patch apply groups: ${state.patch_apply_groups.length}`,
         `- Target active slots: ${state.target_active_slots ?? 'unknown'}`,
         `- Active slots: ${state.active_slot_count ?? 'unknown'}`,
         `- Pending queue: ${state.pending_queue_count ?? 'unknown'}`,
@@ -168,6 +184,13 @@ function summarizeLiveState(state) {
         pending_queue_count: state.pending_queue_count,
         backfill_count: state.backfill_count,
         scheduler_status: state.scheduler_status,
+        patch_swarm_phase: state.patch_swarm_phase,
+        patch_queue_depth: state.patch_queue_depth,
+        patch_apply_groups: state.patch_apply_groups,
+        patch_changed_files_by_agent: state.patch_changed_files_by_agent,
+        patch_verification_status: state.patch_verification_status,
+        patch_rollback_status: state.patch_rollback_status,
+        patch_micro_win_links: state.patch_micro_win_links,
         worker_slot_count: state.worker_slots.length,
         session_generation_count: state.session_generations.length,
         proof_status: state.proof_status,
@@ -180,6 +203,16 @@ function summarizeLiveState(state) {
         blockers: state.blockers,
     };
 }
+function buildPatchMicroWinLinks(patchQueue) {
+    const entries = Array.isArray(patchQueue?.entries) ? patchQueue.entries : [];
+    return entries.map((entry) => ({
+        patch_entry_id: entry.id,
+        agent_id: entry.agent_id,
+        micro_win_id: entry.envelope?.lease_proof?.micro_win_id || null,
+        strategy_task_id: entry.envelope?.lease_proof?.strategy_task_id || null,
+        write_paths: entry.write_paths || []
+    }));
+}
 function mergeAgentRows(sessions, roster, leases, events) {
     const byId = new Map();
     for (const row of roster)

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

@@ -1,7 +1,7 @@
 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 actions = new Set(['run', 'status', 'plan', 'spawn', 'watch', 'dashboard', 'cockpit', 'lane', 'board', 'ledger', 'collect', 'consensus', 'close', 'cleanup', 'proof', 'explain']);
+    const actions = new Set(['run', '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');

package/dist/core/agents/agent-merge-coordinator.d.ts

@@ -1,23 +1,84 @@
 import type { AgentPatchEnvelope } from './agent-patch-schema.js';
+import type { AgentPatchQueueEntry } from './agent-patch-queue.js';
 export declare const AGENT_MERGE_COORDINATOR_SCHEMA = "sks.agent-merge-coordinator.v1";
-export declare function coordinateAgentPatchMerge(envelopes: AgentPatchEnvelope[]): {
+export type AgentPatchMergeInput = AgentPatchEnvelope | AgentPatchQueueEntry;
+export interface AgentPatchMergeCoordinatorOptions {
+    artifactsDir?: string;
+}
+export declare function coordinateAgentPatchMerge(inputs: AgentPatchMergeInput[], opts?: AgentPatchMergeCoordinatorOptions): {
     schema: string;
     ok: boolean;
     merge_order: string[];
+    apply_order: string[];
     touched_files: string[];
     conflicts: {
+        type: string;
         file: string;
+        entries: string[];
         agents: string[];
+        reason: string;
+    }[];
+    conflict_graph: {
+        nodes: {
+            entry_id: string;
+            agent_id: string;
+            lease_id: string | null;
+        }[];
+        edges: {
+            file: string;
+            entries: string[];
+            reason: string;
+        }[];
+    };
+    parallel_apply_groups: {
+        group_id: string;
+        entry_ids: string[];
+        agents: string[];
+        expected_speedup: number;
+    }[];
+    serial_merge_groups: {
+        group_id: string;
+        entry_ids: string[];
+        agents: string[];
+        reason: string;
+        file: string;
+    }[];
+    blocked_conflicts: {
+        type: string;
+        file: string;
+        entries: string[];
+        agents: string[];
+        reason: string;
     }[];
     parallel_batches: {
         batch_id: string;
         agents: string[];
     }[];
     serial_conflicts: {
+        type: string;
         file: string;
+        entries: string[];
         agents: string[];
+        reason: string;
     }[];
+    apply_plan: {
+        parallel_apply_groups: {
+            group_id: string;
+            entry_ids: string[];
+            agents: string[];
+            expected_speedup: number;
+        }[];
+        serial_merge_groups: {
+            group_id: string;
+            entry_ids: string[];
+            agents: string[];
+            reason: string;
+            file: string;
+        }[];
+        retry_policy: string;
+    };
     wall_clock_parallel_evidence: string[];
     blockers: string[];
 };
+export declare function writeAgentMergeCoordinatorArtifacts(artifactDir: string, report: ReturnType<typeof coordinateAgentPatchMerge>): Promise<void>;
 //# sourceMappingURL=agent-merge-coordinator.d.ts.map

package/dist/core/agents/agent-merge-coordinator.js

@@ -1,46 +1,146 @@
+import path from 'node:path';
+import { writeJsonAtomic } from '../fsx.js';
 export const AGENT_MERGE_COORDINATOR_SCHEMA = 'sks.agent-merge-coordinator.v1';
-export function coordinateAgentPatchMerge(envelopes) {
+export function coordinateAgentPatchMerge(inputs, opts = {}) {
+    const items = normalizeInputs(inputs);
     const writers = new Map();
-    for (const envelope of envelopes) {
-        for (const operation of envelope.operations || []) {
+    const blockedConflicts = [];
+    for (const item of items) {
+        if (item.status && item.status !== 'pending') {
+            blockedConflicts.push({ type: 'status', file: '.', entries: [item.entry_id], agents: [item.agent_id], reason: `entry_not_pending:${item.status}` });
+        }
+        for (const operation of item.envelope.operations || []) {
             const key = normalizePatchPath(operation.path || '');
             if (!writers.has(key))
                 writers.set(key, []);
-            writers.get(key)?.push(envelope.agent_id);
+            writers.get(key)?.push(item);
+            if (protectedPath(key)) {
+                blockedConflicts.push({ type: 'protected_path', file: key, entries: [item.entry_id], agents: [item.agent_id], reason: `protected_path:${key}` });
+            }
+            if (!pathAllowedByLease(key, item.envelope)) {
+                blockedConflicts.push({ type: 'lease', file: key, entries: [item.entry_id], agents: [item.agent_id], reason: `lease_path_not_allowed:${key}` });
+            }
         }
     }
+    for (const conflict of domainConflicts(items))
+        blockedConflicts.push(conflict);
     const conflicts = mergeConflicts(writers);
-    const serialConflictAgents = new Set(conflicts.flatMap((conflict) => conflict.agents));
-    const parallelBatch = envelopes.filter((envelope) => !serialConflictAgents.has(envelope.agent_id)).map((envelope) => envelope.agent_id);
-    return {
+    const allBlockedConflicts = [...blockedConflicts, ...conflicts];
+    const serialConflictEntries = new Set(allBlockedConflicts.flatMap((conflict) => conflict.entries));
+    const parallelEntries = items.filter((item) => !serialConflictEntries.has(item.entry_id));
+    const parallelApplyGroups = parallelEntries.length ? [{
+            group_id: 'parallel-001',
+            entry_ids: parallelEntries.map((item) => item.entry_id),
+            agents: parallelEntries.map((item) => item.agent_id),
+            expected_speedup: parallelEntries.length
+        }] : [];
+    const serialMergeGroups = allBlockedConflicts.map((conflict, index) => ({
+        group_id: `serial-${String(index + 1).padStart(3, '0')}`,
+        entry_ids: conflict.entries,
+        agents: conflict.agents,
+        reason: conflict.reason,
+        file: conflict.file
+    }));
+    const result = {
         schema: AGENT_MERGE_COORDINATOR_SCHEMA,
-        ok: conflicts.length === 0,
-        merge_order: envelopes.map((envelope) => envelope.agent_id),
+        ok: allBlockedConflicts.length === 0,
+        merge_order: items.map((item) => item.agent_id),
+        apply_order: [...parallelApplyGroups.map((group) => group.group_id), ...serialMergeGroups.map((group) => group.group_id)],
         touched_files: [...writers.keys()].sort(),
-        conflicts,
-        parallel_batches: parallelBatch.length ? [{ batch_id: 'batch-001', agents: parallelBatch }] : [],
-        serial_conflicts: conflicts,
-        wall_clock_parallel_evidence: parallelBatch.length ? [`batch-001:${parallelBatch.length}_agents_can_apply_without_overlapping_paths`] : [],
-        blockers: conflicts.map((conflict) => `parallel_write_conflict:${conflict.file}`)
+        conflicts: allBlockedConflicts,
+        conflict_graph: {
+            nodes: items.map((item) => ({ entry_id: item.entry_id, agent_id: item.agent_id, lease_id: item.lease_id })),
+            edges: allBlockedConflicts.map((conflict) => ({ file: conflict.file, entries: conflict.entries, reason: conflict.reason }))
+        },
+        parallel_apply_groups: parallelApplyGroups,
+        serial_merge_groups: serialMergeGroups,
+        blocked_conflicts: allBlockedConflicts,
+        parallel_batches: parallelApplyGroups.map((group) => ({ batch_id: group.group_id, agents: group.agents })),
+        serial_conflicts: allBlockedConflicts,
+        apply_plan: {
+            parallel_apply_groups: parallelApplyGroups,
+            serial_merge_groups: serialMergeGroups,
+            retry_policy: 'rebase_stale_context_then_requeue'
+        },
+        wall_clock_parallel_evidence: parallelApplyGroups.length ? [`parallel-001:${parallelEntries.length}_entries_can_apply_without_overlapping_paths`] : [],
+        blockers: allBlockedConflicts.map((conflict) => conflict.reason)
     };
+    if (opts.artifactsDir)
+        void writeAgentMergeCoordinatorArtifacts(opts.artifactsDir, result);
+    return result;
+}
+export async function writeAgentMergeCoordinatorArtifacts(artifactDir, report) {
+    await writeJsonAtomic(path.join(artifactDir, 'agent-merge-coordinator-report.json'), report);
+    await writeJsonAtomic(path.join(artifactDir, 'agent-patch-conflict-graph.json'), report.conflict_graph);
+    await writeJsonAtomic(path.join(artifactDir, 'agent-patch-apply-plan.json'), report.apply_plan);
+    await writeJsonAtomic(path.join(artifactDir, 'agent-patch-apply-order.json'), {
+        schema: 'sks.agent-patch-apply-order.v1',
+        order: report.apply_order
+    });
 }
 function mergeConflicts(writers) {
     const rows = [...writers.entries()].sort(([left], [right]) => left.localeCompare(right));
     const conflicts = [];
     for (let i = 0; i < rows.length; i += 1) {
-        const [leftFile, leftAgents] = rows[i];
+        const [leftFile, leftItems] = rows[i];
         for (let j = i; j < rows.length; j += 1) {
-            const [rightFile, rightAgents] = rows[j];
+            const [rightFile, rightItems] = rows[j];
             if (!pathsOverlap(leftFile, rightFile))
                 continue;
-            const agents = [...new Set([...leftAgents, ...rightAgents])];
-            if (agents.length <= 1)
+            const entries = [...new Set([...leftItems, ...rightItems].map((item) => item.entry_id))];
+            if (entries.length <= 1)
                 continue;
-            conflicts.push({ file: leftFile === rightFile ? leftFile : `${leftFile}<->${rightFile}`, agents });
+            const agents = [...new Set([...leftItems, ...rightItems].map((item) => item.agent_id))];
+            const file = leftFile === rightFile ? leftFile : `${leftFile}<->${rightFile}`;
+            const reason = leftFile === rightFile ? `parallel_write_conflict:${file}` : `subtree_write_conflict:${file}`;
+            conflicts.push({ type: leftFile === rightFile ? 'path' : 'subtree', file, entries, agents, reason });
         }
     }
     return conflicts;
 }
+function domainConflicts(items) {
+    const byPrediction = new Map();
+    for (const item of items) {
+        const prediction = item.envelope.lease_proof?.conflict_prediction_id;
+        if (!prediction)
+            continue;
+        const key = String(prediction);
+        if (!byPrediction.has(key))
+            byPrediction.set(key, []);
+        byPrediction.get(key)?.push(item);
+    }
+    return [...byPrediction.entries()].flatMap(([prediction, rows]) => {
+        const entries = [...new Set(rows.map((item) => item.entry_id))];
+        if (entries.length <= 1)
+            return [];
+        return [{
+                type: 'domain',
+                file: prediction,
+                entries,
+                agents: [...new Set(rows.map((item) => item.agent_id))],
+                reason: `domain_conflict:${prediction}`
+            }];
+    });
+}
+function normalizeInputs(inputs) {
+    return inputs.map((input, index) => {
+        if ('envelope' in input) {
+            return {
+                entry_id: input.id,
+                agent_id: input.agent_id,
+                lease_id: input.lease_id || input.envelope.lease_id || input.envelope.lease_proof?.lease_id || null,
+                status: input.status,
+                envelope: input.envelope
+            };
+        }
+        return {
+            entry_id: `${input.agent_id}-${String(index + 1).padStart(4, '0')}`,
+            agent_id: input.agent_id,
+            lease_id: input.lease_id || input.lease_proof?.lease_id || null,
+            envelope: input
+        };
+    });
+}
 function pathsOverlap(left, right) {
     return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
 }
@@ -49,4 +149,15 @@ function normalizePatchPath(value) {
     const compact = normalized.split('/').filter((part) => part && part !== '.').join('/');
     return compact || '.';
 }
+const PROTECTED_PATH_RE = /^(?:\.codex\/|\.agents\/skills\/|\.codex\/agents\/|AGENTS\.md$|node_modules\/sneakoscope\/|\.sneakoscope\/.*policy.*\.json$)/;
+function protectedPath(value) {
+    return PROTECTED_PATH_RE.test(value);
+}
+function pathAllowedByLease(operationPath, envelope) {
+    const allowedPaths = envelope.lease_proof?.allowed_paths;
+    if (!allowedPaths?.length)
+        return true;
+    const rel = normalizePatchPath(operationPath);
+    return allowedPaths.map(normalizePatchPath).some((allowed) => rel === allowed || rel.startsWith(`${allowed}/`));
+}
 //# sourceMappingURL=agent-merge-coordinator.js.map