@ccdd/project 4.3.0 → 5.1.0

package/dist/src/broker/index.js

@@ -1,26 +1,34 @@
+import { assertStateFormat, initializeStateFormat } from '../state-format.js';
+import { semanticResult, validateFinalResult } from '../response-schema.js';
+import { requesterRun, requesterRequest, resultView } from '../result-view.js';
 import { DatabaseSync } from 'node:sqlite';
 import { randomUUID } from 'node:crypto';
-import { execFileSync } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
 import fs from 'node:fs';
 import path from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { prepareReviewRequests } from '../requester/index.js';
 import { readWorkspaceConfig } from './config.js';
 import { createGraphDefinition } from './graph.js';
-import { tokenUsage } from '../executors/telemetry.js';
+import { createStatusPolling } from './polling.js';
+import { ownerAlive, ownProcessIdentity } from './ownership.js';
+import { coalescingEligibility, findCoalescibleRequest } from './coalescing.js';
+import { tokenUsage, toolResponseBytes } from '../executors/telemetry.js';
 import { finalResultEventData } from '../executors/final-result.js';
 import { normalizeReviewResult as validateResult, storedObservation } from '../review-result.js';
 import { createReviewTools } from '../tools/runner.js';
 import { createHumanClaims, HUMAN_PREPARATION_LEASE_MS } from './human-claims.js';
 import { prepareHumanReview } from '../executors/human-preparation.js';
 import { prepareWorkspace, reopenWorkspace } from '../workspaces/index.js';
-import { createProjectSnapshot } from '../project/identity.js';
+import { createProjectSnapshot, DEFAULT_IDENTITY_CONCURRENCY, positiveConcurrency } from '../project/identity.js';
 import { includedCritics, planProject } from '../project/query.js';
-import { readEvidence } from '../project/store.js';
+import { readEvidence, storedRun } from '../project/store.js';
+/** Internal instrumentation for deterministic scheduler regression tests. */
+export const brokerTestHooks = {};
 const object = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
 const errorCode = (error) => object(error) && typeof error.code === 'string' ? error.code : undefined;
 const parseStored = (value) => { if (typeof value !== 'string')
-    throw new Error('Broker store contains a non-text JSON record.'); return JSON.parse(value); };
+    throw new Error('Broker store contains a non-text JSON record.'); brokerTestHooks.onHydrate?.(Buffer.byteLength(value)); return JSON.parse(value); };
 const required = (value, label) => { if (value == null)
     throw new Error(`Unknown ${label}.`); return value; };
 const terminal = new Set(['GREEN', 'RED', 'ERROR', 'INCOMPLETE']);
@@ -28,37 +36,10 @@ const now = () => new Date().toISOString();
 const errorText = (error) => String(object(error) && typeof error.message === 'string' ? error.message : error).slice(0, 2000);
 const copy = (value) => JSON.parse(JSON.stringify(value));
 const codedError = (message, code) => Object.assign(new Error(message), { code });
-const MAX_CONCURRENT_EXECUTORS = 4;
 const fatalExecutionError = (error) => {
     const code = errorCode(error);
     return Boolean(code?.startsWith('WORKSPACE_') || ['RUN_OWNERSHIP_LOST', 'REVIEW_CANCELED', 'WORKER_STOPPED', 'WORKER_EXITED', 'REVIEW_GRAPH_INVALID'].includes(code ?? ''));
 };
-function processIdentity(pid) {
-    try {
-        if (process.platform === 'linux') {
-            const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
-            return `linux:${stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19]}`;
-        }
-        return `ps:${execFileSync('ps', ['-p', String(pid), '-o', 'lstart='], { encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'] }).trim()}`;
-    }
-    catch {
-        return null;
-    }
-}
-const ownProcessIdentity = processIdentity(process.pid);
-function ownerAlive(owner) {
-    if (!owner || !Number.isSafeInteger(owner.pid) || owner.pid <= 0)
-        return false;
-    try {
-        process.kill(owner.pid, 0);
-    }
-    catch (error) {
-        if (errorCode(error) === 'ESRCH')
-            return false;
-    }
-    const identity = owner.pid === process.pid ? ownProcessIdentity : processIdentity(owner.pid);
-    return !owner.process_identity || !identity || owner.process_identity === identity;
-}
 function canonicalFuturePath(value) {
     let existing = path.resolve(value);
     const missing = [];
@@ -82,6 +63,7 @@ export function readStateContext(stateDir) {
     // A worker closing the last WAL connection can briefly lock even read-only queries.
     const database = new DatabaseSync(filename, { readOnly: true, timeout: 5000 });
     try {
+        assertStateFormat(database);
         const row = database.prepare('SELECT value FROM metadata WHERE key = ?').get('registered-repo');
         const identity = row ? parseStored(row.value) : null;
         if (!object(identity) || typeof identity.repoPath !== 'string' || !path.isAbsolute(identity.repoPath) || typeof identity.repoId !== 'string')
@@ -104,7 +86,13 @@ function prepareStateDirectory(repoPath, stateDir) {
     return fs.realpathSync(canonical);
 }
 /** Durable broker operations. Merely opening the store never starts a worker. */
-export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, workspaceIntegrity = 'content', workspaceAdapter = { prepareWorkspace, reopenWorkspace } }) {
+export function createBroker({ detail, repoPath, stateDir, repoId = 'demo', coalescingGraceMs = 15_000, maxConcurrentExecutors = 4, identityConcurrency = DEFAULT_IDENTITY_CONCURRENCY, executors, workspaceIntegrity = 'content', workspaceAdapter = { prepareWorkspace, reopenWorkspace } }) {
+    positiveConcurrency(maxConcurrentExecutors, 'maxConcurrentExecutors');
+    positiveConcurrency(identityConcurrency, 'identityConcurrency');
+    if (!Number.isSafeInteger(coalescingGraceMs) || coalescingGraceMs < 0 || coalescingGraceMs > 300_000)
+        throw new Error('coalescingGraceMs must be an integer from 0 to 300000.');
+    if (detail !== undefined && detail !== 'compact' && detail !== 'full')
+        throw new Error('detail must be compact or full.');
     if (!['content', 'metadata'].includes(workspaceIntegrity))
         throw new Error('Workspace integrity must be content or metadata.');
     try {
@@ -126,7 +114,10 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
     let db;
     try {
         db = new DatabaseSync(path.join(stateDir, 'broker.sqlite'));
-        db.exec(`PRAGMA busy_timeout=5000; PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;
+        db.exec('PRAGMA busy_timeout=5000; BEGIN IMMEDIATE');
+        initializeStateFormat(db);
+        db.exec('COMMIT');
+        db.exec(`PRAGMA journal_mode=WAL; PRAGMA foreign_keys=ON;
       CREATE TABLE IF NOT EXISTS runs (id TEXT PRIMARY KEY, created_at TEXT NOT NULL, status TEXT NOT NULL, data TEXT NOT NULL);
       CREATE TABLE IF NOT EXISTS requests (id TEXT PRIMARY KEY, run_id TEXT NOT NULL REFERENCES runs(id), ordinal INTEGER NOT NULL, status TEXT NOT NULL, data TEXT NOT NULL);
       CREATE INDEX IF NOT EXISTS requests_run ON requests(run_id, ordinal);
@@ -147,12 +138,13 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
         db?.close();
         throw error;
     }
+    const polling = createStatusPolling(db);
     let closed = false;
     let closing = false;
     const active = new Map();
     const listeners = new Set();
     const ensureOpen = () => { if (closed || closing)
-        throw new Error('Broker is closed.'); };
+        throw new Error('Broker is closed.'); sweepSubmissionDeadlines(); };
     const requireExecutors = () => {
         if (!executors || typeof executors.canExecute !== 'function' || typeof executors.execute !== 'function')
             throw new Error('Review submission and execution require an executor registry.');
@@ -180,8 +172,27 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
     };
     const ownerData = (id) => db.prepare('SELECT * FROM run_owners WHERE run_id = ?').get(id);
     const runRequests = (id) => db.prepare('SELECT data FROM requests WHERE run_id = ? ORDER BY ordinal').all(id).map(row => parseStored(row.data));
+    const sharedRequests = (run) => (run.project?.coalescedRequestIds ?? []).map(id => required(requestData(id), 'Shared Request'));
+    const attemptsFor = (run) => [...runRequests(run.id), ...sharedRequests(run)];
+    const submissionDeadlines = new Map();
+    function sweepSubmissionDeadlines() {
+        for (const id of submissionDeadlines.keys()) {
+            const status = polling.runStatus(id);
+            // Retain expired unowned sources: dropping their monotonic tombstone could
+            // renew eligibility after a wall-clock rollback. Owned Runs cannot revert
+            // to an abandoned submission; worker exit is reconciled as terminal.
+            if (!status || terminal.has(status) || ownerData(id))
+                submissionDeadlines.delete(id);
+        }
+    }
+    const coalescing = { reconcile: reconcileWithin, deadlines: submissionDeadlines };
+    const shareable = (request) => coalescingEligibility(db, request, coalescing) !== null;
     const saveRequest = (request) => db.prepare('UPDATE requests SET status = ?, data = ? WHERE id = ?').run(request.status, JSON.stringify(request), request.id);
-    const saveRun = (run) => db.prepare('UPDATE runs SET status = ?, data = ? WHERE id = ?').run(run.status, JSON.stringify(run), run.id);
+    const saveRun = (run) => {
+        db.prepare('UPDATE runs SET status = ?, data = ? WHERE id = ?').run(run.status, JSON.stringify(run), run.id);
+        if (terminal.has(run.status))
+            submissionDeadlines.delete(run.id);
+    };
     const appendEvent = (runId, requestId, type, message, data = null) => {
         db.prepare('INSERT INTO events(run_id,request_id,created_at,type,message,data) VALUES (?,?,?,?,?,?)').run(runId, requestId, now(), type, message.slice(0, 4000), data === null ? null : JSON.stringify(data));
     };
@@ -196,7 +207,7 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
         assertWaiting: request => {
             ensureOpen();
             if (request.configManifest?.version !== 2)
-                throw new Error('Historical reviews are available for result lookup only.');
+                throw new Error('Invalid stored review configuration.');
             if (!request.notifiedAt)
                 throw new Error('Human alarm delivery is still pending.');
             if (!ownerAlive(ownerData(request.runId)))
@@ -204,12 +215,33 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
         },
     });
     function refreshReadinessWithin(runId) {
+        sweepSubmissionDeadlines();
         const run = required(runData(runId), 'Run'), requests = runRequests(runId);
-        if (run.project?.version === 2) {
+        if (run.project?.version === 3) {
             if (terminal.has(run.status))
                 return;
-            const plan = planProject(run.project.snapshot, readEvidence(db), { selection: run.project.selection, recursive: run.project.recursive, force: run.project.force, runId, attempts: requests });
+            for (const shared of sharedRequests(run))
+                reconcileWithin(shared.runId);
+            // Called in a write transaction: expire only unowned queued sources, then
+            // recheck all matching owned/leased requests before creating our own ticket.
+            const retained = sharedRequests(run).filter(request => terminal.has(request.status) || shareable(request));
+            if (retained.length !== (run.project.coalescedRequestIds ?? []).length) {
+                run.project.coalescedRequestIds = retained.map(request => request.id);
+                saveRun(run);
+                appendEvent(runId, null, 'request.uncoalesced', 'Unowned source submission lease expired; replanning this Run.');
+            }
+            brokerTestHooks.onPlan?.();
+            const plan = planProject(run.project.snapshot, readEvidence(db), { selection: run.project.selection, recursive: run.project.recursive, force: run.project.force, runId, coalescedRequestIds: run.project.coalescedRequestIds, attempts: [...requests, ...sharedRequests(run)] });
             for (const item of plan.items.filter(item => item.action === 'EXECUTE')) {
+                if (!run.project.force) {
+                    const shared = findCoalescibleRequest(db, item.id, item.input.key, coalescing)?.request;
+                    if (shared) {
+                        run.project.coalescedRequestIds = [...new Set([...(run.project.coalescedRequestIds ?? []), shared.id])];
+                        saveRun(run);
+                        appendEvent(runId, shared.id, 'request.coalesced', 'Waiting for an identical active review in another Run.', { sourceRunId: shared.runId });
+                        continue;
+                    }
+                }
                 const envelope = run.project.templates.find(template => template.criticId === item.id);
                 if (!envelope)
                     throw codedError(`Missing prepared Critic ${item.id}.`, 'REVIEW_GRAPH_INVALID');
@@ -222,17 +254,18 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
             }
             return;
         }
-        throw new Error('Historical Runs cannot be resumed; submit a new validation request.');
+        throw new Error('Invalid stored Run format; submit a new validation request.');
     }
     const updateRunStatus = (runId) => {
-        const states = runRequests(runId).map(request => request.status);
         const run = required(runData(runId), 'Run');
-        if (run.project?.version === 2) {
+        const states = attemptsFor(run).map(request => request.status);
+        if (run.project?.version === 3) {
             if (terminal.has(run.status))
                 return;
-            const plan = planProject(run.project.snapshot, readEvidence(db), { selection: run.project.selection, recursive: run.project.recursive, force: run.project.force, runId, attempts: runRequests(runId) });
+            brokerTestHooks.onPlan?.();
+            const plan = planProject(run.project.snapshot, readEvidence(db), { selection: run.project.selection, recursive: run.project.recursive, force: run.project.force, runId, coalescedRequestIds: run.project.coalescedRequestIds, attempts: attemptsFor(run) });
             const status = states.includes('RUNNING') ? 'RUNNING' : states.includes('QUEUED') ? 'QUEUED' : states.includes('WAITING_HUMAN') ? 'WAITING_HUMAN' :
-                states.includes('ERROR') ? 'ERROR' : states.includes('RED') ? 'RED' : plan.satisfied ? 'GREEN' : 'INCOMPLETE';
+                states.includes('ERROR') ? 'ERROR' : states.includes('RED') || plan.critics.some(critic => critic.status === 'RED') ? 'RED' : plan.satisfied ? 'GREEN' : 'INCOMPLETE';
             if (run.status !== status) {
                 run.status = status;
                 if (terminal.has(status)) {
@@ -244,7 +277,7 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
             }
             return;
         }
-        throw new Error('Historical Runs are available for result lookup only.');
+        throw new Error('Invalid stored Run format.');
     };
     function finishWithin(requestId, outcome, expectedStates = ['RUNNING', 'WAITING_HUMAN']) {
         const { result, error } = outcome, hasError = Object.hasOwn(outcome, 'error');
@@ -257,7 +290,7 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
         request.errorCode = errorCode(error) ?? null;
         request.completedAt = now();
         saveRequest(request);
-        appendEvent(request.runId, request.id, hasError ? 'request.error' : 'request.completed', hasError ? required(request.error, 'error message') : required(result, 'review result').summary, { status: request.status, ...(request.errorCode ? { code: request.errorCode } : {}) });
+        appendEvent(request.runId, request.id, hasError ? 'request.error' : 'request.completed', hasError ? required(request.error, 'error message') : `Review ${required(result, 'review result').verdict}.`, { status: request.status, ...(request.errorCode ? { code: request.errorCode } : {}) });
         refreshReadinessWithin(request.runId);
         updateRunStatus(request.runId);
         return true;
@@ -278,8 +311,9 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
             saveRequest(request);
             appendEvent(runId, request.id, 'request.error', request.error, { status: request.status, ...(request.errorCode ? { code: request.errorCode } : {}) });
         }
-        if (run.project?.version === 2) {
-            const plan = planProject(run.project.snapshot, readEvidence(db), { selection: run.project.selection, recursive: run.project.recursive, force: run.project.force, runId, attempts: runRequests(runId) });
+        if (run.project?.version === 3) {
+            brokerTestHooks.onPlan?.();
+            const plan = planProject(run.project.snapshot, readEvidence(db), { selection: run.project.selection, recursive: run.project.recursive, force: run.project.force, runId, coalescedRequestIds: run.project.coalescedRequestIds, attempts: attemptsFor(run) });
             run.project.evidenceRequestIds = [...new Set(plan.critics.flatMap(c => c.result ? [c.result.requestId] : []))];
         }
         run.status = 'ERROR';
@@ -392,6 +426,7 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
                         if (typeof event[key] === 'string')
                             safe[key] = event[key].slice(0, 1000);
                     if (event.type === 'artifact.tool.completed') {
+                        Object.assign(safe, toolResponseBytes(event));
                         if (typeof event.startedAt === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(event.startedAt) && Number.isFinite(Date.parse(event.startedAt)))
                             safe.startedAt = event.startedAt;
                         if (typeof event.durationMs === 'number' && Number.isFinite(event.durationMs) && event.durationMs >= 0)
@@ -421,6 +456,7 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
                     changed();
                 },
             }));
+            validateFinalResult(semanticResult(result), request);
             await workspace.assertUnchanged();
             signal.throwIfAborted();
             transaction(() => { if (ownerData(runId)?.token === token)
@@ -446,12 +482,12 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
             stored = runData(runId);
             if (!stored)
                 throw new Error('Unknown Run.');
-            if (stored.project?.version !== 2)
-                throw new Error('Historical Runs cannot be resumed; submit a new validation request.');
+            if (stored.project?.version !== 3)
+                throw new Error('Invalid stored Run format; submit a new validation request.');
             if (terminal.has(stored.status))
                 return false;
             if (!stored.workspace)
-                throw new Error('This legacy Run has no workspace descriptor; submit a new review.');
+                throw new Error('Invalid Run: no workspace descriptor.');
             if (ownerData(runId))
                 throw codedError('Another process already owns this review Run.', 'RUN_ALREADY_OWNED');
             db.prepare('INSERT INTO run_owners(run_id,pid,process_identity,token,claimed_at) VALUES (?,?,?,?,?)').run(runId, process.pid, ownProcessIdentity, token, now());
@@ -469,6 +505,10 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
             let workspace;
             let poll;
             const inFlight = new Map();
+            let plannedRevision = -1, leaseDeadline = Infinity;
+            let pendingSources = [];
+            const notified = new Set();
+            const kinds = new Map();
             try {
                 onStarted?.({ runId, pid: process.pid });
                 workspace = await workspaceAdapter.reopenWorkspace(ownedRun.workspace, { signal: executionSignal });
@@ -476,48 +516,70 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
                 poll = setInterval(() => {
                     if (ownerData(runId)?.token !== token)
                         abort.abort(codedError('Review ownership was lost.', 'RUN_OWNERSHIP_LOST'));
-                    else if (terminal.has(required(runData(runId), 'Run').status))
+                    else if (terminal.has(required(polling.runStatus(runId), 'Run')))
                         abort.abort(codedError('Review is already complete or canceled.', 'REVIEW_CANCELED'));
                 }, 100);
                 while (true) {
-                    const current = required(runData(runId), 'Run');
-                    if (terminal.has(current.status)) {
+                    const current = required(polling.runStatus(runId), 'Run');
+                    if (terminal.has(current)) {
                         if (inFlight.size)
                             abort.abort(codedError('Review is already complete or canceled.', 'REVIEW_CANCELED'));
                         break;
                     }
                     reviewSignal.throwIfAborted();
-                    transaction(() => { refreshReadinessWithin(runId); updateRunStatus(runId); });
-                    const requests = runRequests(runId);
+                    const sourceExited = pendingSources.some(id => { const owner = ownerData(id); return owner !== undefined && !ownerAlive(owner); });
+                    if (polling.revision() !== plannedRevision || performance.now() >= leaseDeadline || sourceExited)
+                        transaction(() => {
+                            refreshReadinessWithin(runId);
+                            updateRunStatus(runId);
+                            const pending = sharedRequests(required(runData(runId), 'Run')).filter(request => !terminal.has(request.status));
+                            pendingSources = [...new Set(pending.map(request => request.runId))];
+                            leaseDeadline = Math.min(Infinity, ...pendingSources.filter(id => !ownerData(id)).map(id => submissionDeadlines.get(id) ?? performance.now()));
+                            plannedRevision = polling.revision();
+                        });
+                    const requests = polling.requests(runId);
                     let executing = [...inFlight.values()].filter(item => item.kind !== 'human').length;
-                    for (const queued of requests.filter(request => request.status === 'QUEUED')) {
-                        if (queued.profile.kind !== 'human' && executing >= MAX_CONCURRENT_EXECUTORS)
+                    for (const row of requests.filter(request => request.status === 'QUEUED')) {
+                        const kind = kinds.get(row.id) ?? required(requestData(row.id), 'Request').profile.kind;
+                        kinds.set(row.id, kind);
+                        if (kind !== 'human' && executing >= maxConcurrentExecutors)
                             continue;
-                        if (queued.profile.kind !== 'human')
+                        if (kind !== 'human')
                             executing++;
-                        const promise = executeOne(queued.id, workspace, token, reviewSignal).catch(error => {
+                        const promise = executeOne(row.id, workspace, token, reviewSignal).catch(error => {
                             // A different task may win Promise.race before this rejection. Preserve fatal failure independently of that race.
                             abort.abort(error);
                             throw error;
-                        }).finally(() => { inFlight.delete(queued.id); });
-                        inFlight.set(queued.id, { kind: queued.profile.kind, promise });
+                        }).finally(() => { inFlight.delete(row.id); });
+                        inFlight.set(row.id, { kind, promise });
                     }
                     if (inFlight.size) {
                         // Human alarms and independent evaluations progress together.
                         await Promise.race([...inFlight.values()].map(item => item.promise).concat(delay(50, undefined, { signal: reviewSignal })));
                         continue;
                     }
+                    if (pendingSources.length) {
+                        brokerTestHooks.onIdleTick?.();
+                        await delay(Math.max(1, Math.min(100, leaseDeadline - performance.now())), undefined, { signal: reviewSignal });
+                        continue;
+                    }
                     const waiting = requests.filter(request => request.status === 'WAITING_HUMAN');
                     if (waiting.length) {
-                        if (waiting.some(request => !request.notifiedAt))
-                            throw new Error('Human notification did not complete; submit a new Run to retry.');
+                        for (const request of waiting) {
+                            if (notified.has(request.id))
+                                continue;
+                            if (!required(requestData(request.id), 'Request').notifiedAt)
+                                throw new Error('Human notification did not complete; submit a new Run to retry.');
+                            notified.add(request.id);
+                        }
                         // The workspace observer stays alive with filesystem events and metadata polls.
                         // Notification already crossed its final content boundary; idle waiting
                         // must not rehash the entire workspace on every scheduling iteration.
+                        brokerTestHooks.onIdleTick?.();
                         await delay(100, undefined, { signal: reviewSignal });
                         continue;
                     }
-                    if (terminal.has(required(runData(runId), 'Run').status))
+                    if (terminal.has(required(polling.runStatus(runId), 'Run')))
                         break;
                     throw codedError('Run has no executable request or pending Human review.', 'REVIEW_GRAPH_INVALID');
                 }
@@ -548,10 +610,11 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
         })();
         return entry.promise;
     }
-    return {
-        async submitProject({ requesterId = 'cli', selection, recursive = false, force = false, signal, ...removed }) {
+    const broker = {
+        async submitProject({ requesterId = 'cli', selection, recursive = false, force = false, signal, identityConcurrency: submissionIdentityConcurrency = identityConcurrency, ...removed }) {
             ensureOpen();
             requireExecutors();
+            positiveConcurrency(submissionIdentityConcurrency, 'identityConcurrency');
             if ('mode' in removed)
                 throw new Error('Workspace modes are no longer supported; supply an unchanged workspace.');
             if (!requesterId.trim() || requesterId.length > 200)
@@ -560,14 +623,14 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
             const workspace = await workspaceAdapter.prepareWorkspace({ repoPath, stateDir, integrity: workspaceIntegrity, signal });
             try {
                 const { config } = await readWorkspaceConfig(workspace.descriptor.path, workspace.signal);
-                const snapshot = await createProjectSnapshot(config, workspace.descriptor.path, workspace.descriptor.hash, workspace.signal, workspace.descriptor.integrity, selection);
+                const snapshot = await createProjectSnapshot(config, workspace.descriptor.path, workspace.descriptor.hash, workspace.signal, workspace.descriptor.integrity, selection, { identityConcurrency: submissionIdentityConcurrency });
                 const ids = includedCritics(snapshot, selection, recursive);
                 const templates = [];
                 for (const id of ids)
                     templates.push(...await prepareReviewRequests({ repoPath: workspace.descriptor.path, repoId, snapshotHash: workspace.descriptor.hash, criticId: id, preparedConfig: config }));
                 const id = randomUUID(), createdAt = now();
-                const record = { id, repoId, snapshotHash: workspace.descriptor.hash, workspace: workspace.descriptor, requesterId,
-                    scope: { kind: 'project' }, graph: createGraphDefinition(config), project: { version: 2, snapshot, selection, recursive, force, templates }, status: 'QUEUED', createdAt };
+                const record = { id, repoId, coalescingGraceMs, snapshotHash: workspace.descriptor.hash, workspace: workspace.descriptor, requesterId,
+                    scope: { kind: 'project' }, graph: createGraphDefinition(config), project: { version: 3, snapshot, selection, recursive, force, templates }, status: 'QUEUED', createdAt };
                 await workspace.assertUnchanged();
                 workspace.signal.throwIfAborted();
                 transaction(() => {
@@ -589,7 +652,7 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
             ensureOpen();
             return db.prepare('SELECT id FROM runs ORDER BY created_at DESC, rowid DESC').all().map(row => {
                 const record = required(getRun(String(row.id)), 'Run');
-                return { ...record, events: undefined, requests: record.requests.map(({ result, ...request }) => ({ ...request, result: result ? { verdict: result.verdict, summary: result.summary } : null })) };
+                return record;
             });
         },
         getRun,
@@ -618,7 +681,7 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
                 reconcile(existing.runId);
             const request = required(requestData(requestId), 'request');
             if (request.configManifest?.version !== 2)
-                throw new Error('Historical reviews are available for result lookup only.');
+                throw new Error('Invalid stored review configuration.');
             if (request.status === 'WAITING_HUMAN' && request.claimedBy === reviewerId)
                 return request;
             if (request.claimedBy)
@@ -661,7 +724,7 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
                 if (!current || current.profile.kind !== 'human' || current.status !== 'WAITING_HUMAN')
                     throw new Error('Request is not waiting for a human review.');
                 if (current.configManifest?.version !== 2)
-                    throw new Error('Historical reviews are available for result lookup only.');
+                    throw new Error('Invalid stored review configuration.');
                 if (!reviewerId || current.claimedBy !== reviewerId)
                     throw new Error('Only the reviewer who claimed this request can use its tools.');
                 if (!ownerAlive(ownerData(current.runId)))
@@ -731,9 +794,9 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
         },
         async completeHuman(requestId, { reviewerId, result }) {
             ensureOpen();
-            const validated = validateResult(result);
-            if (!validated.evidence.length || validated.evidence.some(item => !item.trim()))
-                throw new Error('Human review requires at least one nonempty evidence entry.');
+            const definition = required(requestData(requestId), 'Request');
+            validateFinalResult(result, definition);
+            const validated = validateResult(result, definition);
             const first = requestData(requestId);
             if (first)
                 reconcile(first.runId);
@@ -741,7 +804,7 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
             if (!request || request.profile.kind !== 'human' || request.status !== 'WAITING_HUMAN')
                 throw new Error('Request is not waiting for a human review.');
             if (request.configManifest?.version !== 2)
-                throw new Error('Historical reviews are available for result lookup only.');
+                throw new Error('Invalid stored review configuration.');
             if (!reviewerId || request.claimedBy !== reviewerId)
                 throw new Error('Only the reviewer who claimed this request can submit its result.');
             if (!request.notifiedAt)
@@ -822,10 +885,25 @@ export function createBroker({ repoPath, stateDir, repoId = 'demo', executors, w
             for (const entry of owned)
                 entry.abort.abort(codedError('The review worker stopped before completion.', 'WORKER_STOPPED'));
             await Promise.allSettled(owned.map(entry => entry.promise));
+            submissionDeadlines.clear();
             listeners.clear();
             db.close();
             closed = true;
         },
     };
+    const viewRun = (value) => resultView({ detail }, value, () => value ? requesterRun(storedRun(db, value.id) ?? value, stateDir) : null);
+    const viewRequest = (value) => resultView({ detail }, value, () => value ? requesterRequest(value, stateDir) : null);
+    return {
+        ...broker,
+        submitProject: async (...args) => viewRun(await broker.submitProject(...args)),
+        run: async (...args) => viewRun(await broker.run(...args)),
+        getRun: (id) => viewRun(broker.getRun(id)),
+        listRuns: () => broker.listRuns().map(value => viewRun(value)),
+        getRequest: (id) => viewRequest(broker.getRequest(id)),
+        claimHuman: async (...args) => viewRequest(await broker.claimHuman(...args)),
+        completeHuman: async (...args) => viewRequest(await broker.completeHuman(...args)),
+        failRun: (...args) => viewRun(broker.failRun(...args)),
+        cancel: (...args) => viewRun(broker.cancel(...args)),
+    };
 }
 //# sourceMappingURL=index.js.map