@feng0531/dsh-code-review 0.85.13 → 0.86.0

package/src/model-json.mjs

@@ -2,7 +2,28 @@ import { jsonSyntaxDiagnostic } from './model-diagnostics.mjs';
 
 // Accept one complete JSON value, optionally inside one exact Markdown fence.
 // This parser never repairs bytes or invokes a model; orchestration owns corrections.
-export function modelJson(text) {
+// Accept only an unchanged leading JSON container followed by unmistakable prose.
+function balancedPrefix(text) {
+  if (!['{', '['].includes(text[0])) return undefined;
+  const stack = []; let quoted = false, escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    if (quoted) { if (escaped) escaped = false; else if (c === String.fromCharCode(92)) escaped = true; else if (c === '"') quoted = false; continue; }
+    if (c === '"') { quoted = true; continue; }
+    if (c === '{' || c === '[') stack.push(c);
+    else if (c === '}' || c === ']') {
+      if (stack.pop() !== (c === '}' ? '{' : '[')) return undefined;
+      if (!stack.length) {
+        const body = text.slice(0, i + 1), tail = text.slice(i + 1).trim();
+        if (!tail || /[{}\[\]\x60]/u.test(tail) || /^(?:true|false|null|-?\d|[,:;"'])/u.test(tail)) return undefined;
+        if (!/^[\p{L}]/u.test(tail)) return undefined;
+        try { JSON.parse(body); return body; } catch { return undefined; }
+      }
+    }
+  }
+  return undefined;
+}
+export function modelJson(text, { allowTrailingProse = false } = {}) {
   const bytes = Buffer.byteLength(text);
   const trimmed = text.trim();
   const fence = /^```(?:json)?\r?\n([\s\S]*)\r?\n```$/.exec(trimmed);
@@ -10,6 +31,7 @@ export function modelJson(text) {
   try {
     JSON.parse(body);
   } catch (parseError) {
+    if (allowTrailingProse && !fence) { const prefix = balancedPrefix(trimmed); if (prefix !== undefined) return prefix; }
     const envelope = fence ? 'json-fence' : 'plain';
     const shape = !trimmed ? 'empty' : trimmed.startsWith('```') && !fence ? 'non-exact-fence' : /^[{\[]/.test(body) ? 'json-like-invalid' : 'non-json-leading';
     const error = new Error('Model response is not complete JSON (bytes=' + bytes + ', envelope=' + envelope + ', shape=' + shape + '); no repair or retry performed by JSON parser');

package/src/model-tools.mjs

@@ -0,0 +1,58 @@
+// Installed dsh-llm ToolSchema: {name,description,parameters}; tool arguments are
+// strings, not parsed objects. This declares a data result, never an executable tool.
+export const RESULT_TOOL_NAME = 'submit_review_result';
+export const NATIVE_RESULT_INSTRUCTIONS = ' Prefer submit_review_result to submit the current stage JSON as tool arguments (data only, no execution). If tools are unavailable, return the same JSON as text in this response. Never submit multiple results or mix a result with prose.';
+const strings = { type: 'array', items: { type: 'string' } };
+const object = (properties, required = Object.keys(properties)) => ({ type: 'object', properties, required, additionalProperties: false });
+const array = items => ({ type: 'array', items });
+const text = { type: 'string' };
+const anchor = { oneOf: [object({ kind: { const: 'line' }, side: { enum: ['old', 'new'] }, start: { type: 'integer', minimum: 1 }, end: { type: 'integer', minimum: 1 }, snippet: text }), object({ kind: { const: 'property' }, name: text }), object({ kind: { const: 'file' } })] };
+const finding = { type: 'object', properties: { fileId: text, severity: { enum: ['critical', 'high', 'medium', 'low'] }, title: text,
+  evidence: text, trigger: text, impact: text, suggestion: text, anchor,
+  attribution: { type: 'object' }, interaction: { type: 'object' } },
+  required: ['fileId', 'severity', 'title', 'evidence', 'trigger', 'impact', 'suggestion', 'anchor'] };
+const findings = array(finding); // Existing validators still enforce exact evidence and identities.
+const risk = object({ id: { type: 'string' }, fileIds: strings,
+  editRefs: array(object({ fileId: { type: 'string' }, editId: { type: 'string' } })),
+  question: { type: 'string' }, trigger: { type: 'string' }, impact: { type: 'string' }, checks: strings, sourceIds: strings });
+const review = object({ findings, limitations: strings, risks: array(risk) }, ['findings', 'limitations']);
+const requests = object({ requests: { type: 'array', minItems: 1, maxItems: 8, items: { oneOf: [
+  object({ kind: { const: 'read' }, id: { type: 'string' }, start: { type: 'integer', minimum: 1 }, count: { type: 'integer', minimum: 1, maximum: 200 } }),
+  object({ kind: { const: 'search' }, query: { type: 'string' }, limit: { type: 'integer', minimum: 1, maximum: 100 }, sourceIds: strings }, ['kind', 'query']),
+  object({ kind: { const: 'find' }, query: { type: 'string' }, limit: { type: 'integer', minimum: 1, maximum: 100 } }, ['kind', 'query']),
+] } } });
+export function modelResultStage(input, instructions = '') {
+  let p; try { p = JSON.parse(input); } catch { return undefined; }
+  if (!p || typeof p !== 'object' || Array.isArray(p)) return undefined;
+  if (Array.isArray(p.candidates)) return 'verdicts';
+  if (/返回\{groups:/.test(instructions)) return 'groups';
+  if (/仅制定审查计划/.test(instructions)) return 'risks';
+  if (p.sourceMode === 'group-primary') return 'reviews';
+  if (p.file || p.sourceMode === 'file-interaction') return 'findings';
+  return undefined;
+}
+export function modelResultTools(input, instructions = '') {
+  const stage = modelResultStage(input, instructions);
+  if (!stage) return [];
+  const final = stage === 'findings' ? review : stage === 'risks' ? object({ risks: array(risk) }) :
+    stage === 'groups' ? object({ groups: array(object({ fileIds: strings, reason: { type: 'string' } })) }) :
+    stage === 'reviews' ? object({ reviews: array(object({ fileId: { type: 'string' }, findings, limitations: strings, risks: array(risk) }, ['fileId', 'findings', 'limitations'])), limitations: strings }) :
+    object({ verdicts: array(object({ candidateId: text, verdict: { enum: ['supported', 'refuted', 'uncertain'] }, reason: text, evidence: array({ type: 'object' }), regression: { type: 'object' } }, ['candidateId', 'verdict', 'reason', 'evidence'])) });
+  let p; try { p = JSON.parse(input); } catch { return []; }
+  const parameters = p.retrievalFinalization || stage === 'risks' || stage === 'groups' ? final : { type: 'object', oneOf: [final, requests] };
+  return [{ name: RESULT_TOOL_NAME, description: 'Submit only the current approved review stage result or approved retrieval requests as JSON data. Does not execute actions.', parameters }];
+}
+// Additional wire bytes beyond the ordinary text contract/input. No token estimate.
+export function nativeResultWireBytes(input, instructions = '') {
+  const tools = modelResultTools(input, instructions);
+  return tools.length ? Buffer.byteLength(JSON.stringify(tools)) + Buffer.byteLength(NATIVE_RESULT_INSTRUCTIONS) : 0;
+}
+export function validateNativeResult(text, input, instructions) {
+  const value = JSON.parse(text), stage = modelResultStage(input, instructions);
+  const p = JSON.parse(input);
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  if (Object.hasOwn(value, 'requests')) return !p.retrievalFinalization && !['risks', 'groups'].includes(stage) && Object.keys(value).length === 1 && Array.isArray(value.requests);
+  const allowed = stage === 'findings' ? ['findings', 'limitations', 'risks'] : stage === 'reviews' ? ['reviews', 'limitations'] : [stage];
+  const required = stage === 'findings' ? ['findings', 'limitations'] : stage === 'reviews' ? ['reviews', 'limitations'] : [stage];
+  return !!stage && Object.keys(value).every(k => allowed.includes(k)) && required.every(k => Array.isArray(value[k]));
+}

package/src/model-wire-budget.mjs

@@ -0,0 +1,32 @@
+import { modelContract } from './model-contract.mjs';
+import { nativeResultWireBytes } from './model-tools.mjs';
+
+// Same UTF-8 fields checked by the adapter immediately before transmission.
+// Does not estimate provider tokens or invent hidden slack for later corrections.
+export function modelWireBudget(request, maxBytes) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw new Error('Invalid model wire budget');
+  if (!request || typeof request.instructions !== 'string' || typeof request.input !== 'string') throw new Error('Invalid model wire request');
+  if (request.nativeOutputTools !== undefined && typeof request.nativeOutputTools !== 'boolean') throw new Error('nativeOutputTools must be boolean');
+  const bytes = Buffer.byteLength(request.input) + Buffer.byteLength(request.instructions + '\n' + modelContract(request.input, request.instructions)) +
+    (request.nativeOutputTools === true ? nativeResultWireBytes(request.input, request.instructions) : 0);
+  return { bytes, maxBytes, fits: bytes <= maxBytes };
+}
+
+// Local to one already captured scope. This is measurement policy only, never a
+// larger source authorization, reader budget, or cross-review/global default.
+const scopePolicies = new WeakMap();
+export function configureWireBudget(scope, { nativeOutputTools } = {}) {
+  if (!scope || (typeof scope !== 'object' && typeof scope !== 'function')) throw new Error('Invalid model wire scope');
+  if (typeof nativeOutputTools !== 'boolean') throw new Error('nativeOutputTools must be boolean');
+  const previous = scopePolicies.get(scope);
+  if (previous !== undefined && previous !== nativeOutputTools) throw new Error('Model wire policy already configured');
+  scopePolicies.set(scope, nativeOutputTools);
+  return scope;
+}
+export function nativeWireEnabled(request, scope) {
+  if (request?.nativeOutputTools !== undefined) {
+    if (typeof request.nativeOutputTools !== 'boolean') throw new Error('nativeOutputTools must be boolean');
+    return request.nativeOutputTools;
+  }
+  return scope ? scopePolicies.get(scope) === true : false;
+}

package/src/primary-seeds.mjs

@@ -1,4 +1,5 @@
 import { retrievalRequest } from './retrieval-loop.mjs';
+import { modelWireBudget } from './model-wire-budget.mjs';
 
 const MAX_READS = 4, MAX_LINES = 40;
 // Optional navigation must leave room for normal retrieval and exact evidence
@@ -78,7 +79,7 @@ export function primarySeeds(scope, request, { maxInputBytes = 96 * 1024, onRetr
         checkSignal();
         const next = retrievalRequest(request, scope, [...seeds, { request: operation, result }]);
         const remaining = scope.budget();
-        if (result.start + result.count <= coordinate || remaining.remainingCalls < RESERVE_CALLS || remaining.remainingOutputBytes < RESERVE_BYTES || Buffer.byteLength(next.input) + Buffer.byteLength(next.instructions) > maxInputBytes) throw optionalError();
+        if (result.start + result.count <= coordinate || remaining.remainingCalls < RESERVE_CALLS || remaining.remainingOutputBytes < RESERVE_BYTES || (request.nativeOutputTools === true ? !modelWireBudget(next, maxInputBytes).fits : Buffer.byteLength(next.input) + Buffer.byteLength(next.instructions) > maxInputBytes)) throw optionalError();
         return { request: operation, result };
       });
     } catch (error) {

package/src/project-execution.mjs

@@ -9,7 +9,7 @@ export function projectConcurrency(value = DEFAULT_PROJECT_CONCURRENCY) {
 
 // Parallelize independent approved snapshots, never dependent stages within a batch.
 // Admission and the shared call reservation are synchronous; completion order is not report order.
-export async function reviewProjectBatches(batches, model, { concurrency = DEFAULT_PROJECT_CONCURRENCY, remainingCalls, signal, onProgress, maxRetrievalRounds = 3 } = {}) {
+export async function reviewProjectBatches(batches, model, { concurrency = DEFAULT_PROJECT_CONCURRENCY, remainingCalls, signal, onProgress, maxRetrievalRounds = 3, resumeStates, onResumeCheckpoint, onModelArtifact, enableGroupPrimary = false, nativeOutputTools = false } = {}) {
   projectConcurrency(concurrency);
   retrievalRounds(maxRetrievalRounds);
   if (!Array.isArray(batches) || typeof remainingCalls !== 'function') throw new Error('Invalid project execution');
@@ -27,7 +27,8 @@ export async function reviewProjectBatches(batches, model, { concurrency = DEFAU
         if (batchSignal.aborted || remainingCalls() <= 0) { results[index] = unstarted(batch); continue; }
         results[index] = await reviewSnapshot(batch, model, {
           signal: batchSignal, maxCalls: remainingCalls(), remainingCalls, enableRetrieval: true, enableVerification: true,
-          enableAnchorCorrection: true, correctProtocol: true, maxRetrievalRounds,
+          enableGroupPrimary, nativeOutputTools, enableAnchorCorrection: true, correctProtocol: true, maxRetrievalRounds,
+          resumeState: resumeStates?.get(batch.id), onResumeCheckpoint: onResumeCheckpoint ? report => onResumeCheckpoint(batch, report) : undefined, onModelArtifact,
           onProgress: onProgress ? event => onProgress({ ...event, snapshotId: batch.id, batchIndex: index }) : undefined,
         });
       } catch (error) {

package/src/project-review-service.mjs

@@ -1,3 +1,5 @@
+import { REVIEW_RUNTIME } from './runtime-identity.mjs';
+import { buildResumeState, validateResumeState } from './review-resume.mjs';
 import { renderProjectReport } from './project-report.mjs';
 import { reviewDiagnostics } from './review-diagnostics.mjs';
 import { realpath } from 'node:fs/promises';
@@ -69,12 +71,15 @@ async function captureProject(cwd, args, signal) {
   return { ...result, id: hash(JSON.stringify(result)) };
 }
 
-export function createProjectReviewService(llm, { allowModelSending = false, authorize = async () => false, now = Date.now, ttlMs = 300000, maxPreviews = 8, projectMaxCalls = Number.MAX_SAFE_INTEGER, projectConcurrency = DEFAULT_PROJECT_CONCURRENCY, maxRetrievalRounds = 3 } = {}) {
+export function createProjectReviewService(llm, { allowModelSending = false, authorize = async () => false, now = Date.now, ttlMs = 300000, maxPreviews = 8, projectMaxCalls = Number.MAX_SAFE_INTEGER, projectConcurrency = DEFAULT_PROJECT_CONCURRENCY, maxRetrievalRounds = 3, nativeOutputTools = false, enableGroupPrimary = false } = {}) {
   for (const n of [ttlMs, maxPreviews]) if (!Number.isSafeInteger(n) || n < 1) throw new Error('Invalid project preview limit');
   if (!Number.isSafeInteger(projectMaxCalls) || projectMaxCalls < 1) throw new Error('Invalid project model call limit');
 
   validateProjectConcurrency(projectConcurrency);
   retrievalRounds(maxRetrievalRounds);
+  if (typeof nativeOutputTools !== 'boolean' || typeof enableGroupPrimary !== 'boolean') throw new Error('Invalid project execution options');
+  const resumeIdentity = (args, route) => ({ captureOptions: args, route, runtime: REVIEW_RUNTIME, execution: { projectMaxCalls, projectConcurrency, maxRetrievalRounds, nativeOutputTools, enableGroupPrimary, enableVerification: true, enableAnchorCorrection: true, correctProtocol: true } });
+  const projectBinding = snapshot => ({ ...snapshot, files: snapshot.batches.flatMap(batch => batch.files) });
   const previews = new Map();
   const lifetime = new AbortController();
   let busy = false;
@@ -87,21 +92,39 @@ export function createProjectReviewService(llm, { allowModelSending = false, aut
     async preview(args, exec) {
       if (busy) throw new Error('Review service busy');
       if (!args || typeof args !== 'object') throw new Error('Project preview parameters required');
-      if (Object.keys(args).some(k => !['reviewMode', 'repositoryPath', 'selectedPaths'].includes(k)) || args.reviewMode !== 'project') throw new Error('Project mode supports only reviewMode/repositoryPath/selectedPaths; change/history context parameters are not project parameters');
+      if (Object.keys(args).some(k => !['reviewMode', 'repositoryPath', 'selectedPaths', 'resumeFromJobId'].includes(k)) || args.reviewMode !== 'project') throw new Error('Project mode supports only reviewMode/repositoryPath/selectedPaths; change/history context parameters are not project parameters');
       const current = owner(exec);
       busy = true;
       try {
-        const s = await captureProject(current.cwd, args, signalFor(exec));
+        const captureArgs = structuredClone(args);
+        const sourceJobId = captureArgs.resumeFromJobId; delete captureArgs.resumeFromJobId;
+        if (sourceJobId !== undefined && (typeof sourceJobId !== 'string' || !/^[a-f0-9-]{36}$/.test(sourceJobId) || typeof exec.resolveReviewResume !== 'function')) throw new Error('Invalid or unavailable resume job');
+        const saved = sourceJobId === undefined ? undefined : await exec.resolveReviewResume(sourceJobId);
+        const s = await captureProject(current.cwd, captureArgs, signalFor(exec));
+        const identity = resumeIdentity(captureArgs, current.route);
+        let resumeStates;
+        if (saved !== undefined) {
+          if (saved?.schemaVersion !== 1 || saved.mode !== 'project' || !Array.isArray(saved.batches)) throw new Error('Invalid project resume checkpoint');
+          validateResumeState(saved.binding, projectBinding(s), identity);
+          if (saved.batches.length > s.batches.length || new Set(saved.batches.map(item => item?.snapshotId)).size !== saved.batches.length) throw new Error('Duplicate or excessive resume batches');
+          resumeStates = new Map(saved.batches.map(item => {
+            const batch = s.batches.find(batch => batch.id === item.snapshotId);
+            if (!batch) throw new Error('Project resume batch identity mismatch');
+            return [batch.id, validateResumeState(item, batch, identity)];
+          }));
+        }
         for (const [id, p] of previews) if (p.expires <= now()) previews.delete(id);
         while (previews.size >= maxPreviews) previews.delete(previews.keys().next().value);
         const previewId = randomUUID();
-        previews.set(previewId, { ...current, args: structuredClone(args), snapshotId: s.id, expires: now() + ttlMs });
+        previews.set(previewId, { ...current, args: captureArgs, snapshotId: s.id, resumeStates, sourceJobId, expires: now() + ttlMs });
         return {
+          ...(resumeStates ? { resume: { sourceJobId, reusableFiles: [...resumeStates.values()].reduce((sum, state) => sum + state.completed.length, 0) } } : {}),
           previewId, snapshotId: s.id, reviewMode: 'project', repositoryRoot: s.root, vcs: s.vcs,
           model: current.route, modelSendingEnabled: allowModelSending,
           totalTrackedNodes: s.totalTrackedNodes, selectedFiles: s.selectedFiles, selectionComplete: s.selectionComplete,
           inventoryComplete: s.inventoryComplete, inventoryScope: s.inventoryScope, inventoryNodes: s.inventoryNodes, batches: s.batches.length,
-          execution: { batchConcurrency: projectConcurrency, maxRetrievalRounds },
+          privateArtifacts: { enabled: typeof exec.onModelArtifact === 'function', sourceBearing: true, maxArtifactBytes: 1048576, maxJobBytes: 8388608, maxArtifacts: 64, notice: 'Bounded private untrusted model outputs; raw access requires explicit consent and is not review evidence.' },
+          execution: { nativeOutputTools, enableGroupPrimary, batchConcurrency: projectConcurrency, maxRetrievalRounds },
           files: s.batches.flatMap(b => b.files.map(f => ({ path: f.path, eligibility: f.eligibility, reason: f.reason }))),
           notice: s.notice + PREVIEW_NOTICE_SUFFIX + ' Each stage allows at most ' + maxRetrievalRounds + ' retrieval rounds; exhaustion requires a final-only response and explicit unfinished coverage.',
         };
@@ -130,8 +153,20 @@ export function createProjectReviewService(llm, { allowModelSending = false, aut
           files: s.batches.flatMap(b => b.files.map(f => ({ fileId: f.id, path: f.path, status: f.eligibility === 'reviewable' ? 'pending' : f.eligibility }))),
         });
 
+        const identity = resumeIdentity(p.args, p.route);
+        const states = new Map();
+        for (const [id, saved] of p.resumeStates ?? []) {
+          const batch = s.batches.find(batch => batch.id === id);
+          if (!batch) throw new Error('Project resume batch identity mismatch');
+          states.set(id, validateResumeState(saved, batch, identity));
+        }
+        const persist = async (batch, report) => {
+          if (!exec.reviewResumeCheckpoint) return;
+          states.set(batch.id, buildResumeState(batch, identity, report));
+          await exec.reviewResumeCheckpoint({ schemaVersion: 1, mode: 'project', binding: buildResumeState(projectBinding(s), identity, { files: [], findings: [] }), batches: [...states.values()] });
+        };
         let calls = 0;
-        const adapter = createDshModel(llm, p.route, { correctJson: true });
+        const adapter = createDshModel(llm, p.route, { correctJson: true, useNativeTools: nativeOutputTools });
         const model = request => {
           if (calls >= projectMaxCalls) throw Object.assign(new Error('Shared project model call limit exceeded'), { code: 'PROJECT_MODEL_CALL_LIMIT' });
           calls++;
@@ -143,10 +178,11 @@ export function createProjectReviewService(llm, { allowModelSending = false, aut
         };
 
         const results = await reviewProjectBatches(s.batches, model, {
-          concurrency: projectConcurrency, maxRetrievalRounds, signal, remainingCalls: () => projectMaxCalls - calls,
-          onProgress: exec.reviewCheckpoint,
+          concurrency: projectConcurrency, maxRetrievalRounds, enableGroupPrimary, nativeOutputTools, signal, remainingCalls: () => projectMaxCalls - calls,
+          onProgress: exec.reviewCheckpoint, resumeStates: states, onResumeCheckpoint: persist, onModelArtifact: exec.onModelArtifact,
         });
 
+        for (let i = 0; i < results.length; i++) await persist(s.batches[i], results[i]);
         const files = results.flatMap(r => r.files.map(f => ({ ...f, batchSnapshotId: r.snapshotId })));
         const coverage = {
           total: s.selectedFiles,
@@ -165,8 +201,9 @@ export function createProjectReviewService(llm, { allowModelSending = false, aut
             : 'partial',
           repositoryRoot: s.root, vcs: s.vcs, model: p.route, modelCalls: calls, maxModelCalls: projectMaxCalls,
           totalTrackedNodes: s.totalTrackedNodes, selectionComplete: s.selectionComplete, inventoryComplete: s.inventoryComplete, inventoryScope: s.inventoryScope, inventoryNodes: s.inventoryNodes,
-          coverage, files, findings, batches: results,
-          execution: { batchConcurrency: projectConcurrency, maxRetrievalRounds },
+          coverage, files, findings, artifacts: results.flatMap(result => result.artifacts ?? []), batches: results, resume: { reusedFiles: files.filter(file => file.reused).length },
+          privateArtifacts: { enabled: typeof exec.onModelArtifact === 'function', sourceBearing: true, maxArtifactBytes: 1048576, maxJobBytes: 8388608, maxArtifacts: 64, notice: 'Bounded private untrusted model outputs; raw access requires explicit consent and is not review evidence.' },
+          execution: { nativeOutputTools, enableGroupPrimary, batchConcurrency: projectConcurrency, maxRetrievalRounds },
           notice: s.notice + REPORT_NOTICE_SUFFIX,
         };
 

package/src/retrieval-loop.mjs

@@ -1,5 +1,6 @@
 import { RETRIEVAL_INSTRUCTIONS } from './prompts.mjs';
 import { searchSeeds } from './search-seeds.mjs';
+import { modelWireBudget } from './model-wire-budget.mjs';
 import { executeRetrievalBatch, parseRetrievalResponse } from './retrieval-protocol.mjs';
 
 export { RETRIEVAL_INSTRUCTIONS };
@@ -53,7 +54,7 @@ export async function retrievalLoop(model, request, scope, { correctProtocol = f
   const retrieved = structuredClone(initialRetrieved);
   if (retrieved.length) {
     const seeded = retrievalRequest(request, scope, retrieved);
-    if (Buffer.byteLength(seeded.input) + Buffer.byteLength(seeded.instructions) > maxInputBytes) throw new Error('Initial retrieval input budget exceeded');
+    if (request.nativeOutputTools === true ? !modelWireBudget(seeded, maxInputBytes).fits : Buffer.byteLength(seeded.input) + Buffer.byteLength(seeded.instructions) > maxInputBytes) throw new Error('Initial retrieval input budget exceeded');
     // Publish only fragments admitted to an actual outgoing prompt below.
   }
   const delivered = new Set();
@@ -71,13 +72,14 @@ export async function retrievalLoop(model, request, scope, { correctProtocol = f
       await finalize(error);
     } else if (!finalization && round >= maxRounds) await finalize(roundBudgetError());
   };
+  const fits = value => request.nativeOutputTools === true ? modelWireBudget(value, maxInputBytes).fits : Buffer.byteLength(value.input) + Buffer.byteLength(value.instructions) <= maxInputBytes;
   const nextRequest = records => {
     const next = retrievalRequest(request, scope, records);
     if (enableSearchSeeds) {
       const annotated = { input: JSON.stringify({ ...JSON.parse(next.input), retrievalRounds: { max: maxRounds, remaining: finalization ? 0 : Math.max(0, maxRounds - currentRound) } }),
         instructions: next.instructions + ' Batch independent exact reads/searches together (1..8). retrievalRounds is per-stage request turns, not reader calls or authority. Search-hit host reads may accompany results; supplied fragments are not complete coverage.' };
       // Optional guidance must not turn an otherwise admitted envelope into a block.
-      if (Buffer.byteLength(annotated.input) + Buffer.byteLength(annotated.instructions) <= maxInputBytes) Object.assign(next, annotated);
+      if (fits({ ...next, ...annotated })) Object.assign(next, annotated);
     }
     if (finalization) {
       // The live ledger is already present in retrievalBudget. Do not duplicate it
@@ -93,8 +95,8 @@ export async function retrievalLoop(model, request, scope, { correctProtocol = f
     request.signal?.throwIfAborted();
     if (round > 0 || !allowExhaustedInitial) await checkExhausted(round);
     let { input, instructions } = nextRequest(retrieved);
-    if (correctProtocol && retrieved.length && Buffer.byteLength(input) + Buffer.byteLength(instructions) > maxInputBytes) input = compactFollowup(input);
-    if (Buffer.byteLength(input) + Buffer.byteLength(instructions) > maxInputBytes) throw new Error('Retrieval input budget exceeded');
+    if (correctProtocol && retrieved.length && !fits({ ...request, input, instructions })) input = compactFollowup(input);
+    if (!fits({ ...request, input, instructions })) throw new Error('Retrieval input budget exceeded');
     request.signal?.throwIfAborted();
     beforeCall();
     request.signal?.throwIfAborted();
@@ -161,19 +163,19 @@ export async function retrievalLoop(model, request, scope, { correctProtocol = f
       let candidate = [...retrieved, item];
       let next = nextRequest(candidate);
       if (correctProtocol) {
-        while (retrieved.length && Buffer.byteLength(compactFollowup(next.input)) + Buffer.byteLength(next.instructions) > maxInputBytes) {
+        while (retrieved.length && !fits({ ...next, input: compactFollowup(next.input) })) {
           retrieved.shift();
           await request.onProtocolEvent?.({ action: 'prior-retrieval-deferred', notice: 'Prior returned fragment no longer in current prompt; reread approved source for evidence.' });
           candidate = [...retrieved, item];
           next = nextRequest(candidate);
         }
       }
-      let fits = Buffer.byteLength(next.input) + Buffer.byteLength(next.instructions) <= maxInputBytes;
-      if (correctProtocol && !fits) fits = Buffer.byteLength(compactFollowup(next.input)) + Buffer.byteLength(next.instructions) <= maxInputBytes;
-      if (correctProtocol && !fits) {
+      let admitted = fits(next);
+      if (correctProtocol && !admitted) admitted = fits({ ...next, input: compactFollowup(next.input) });
+      if (correctProtocol && !admitted) {
         const omitted = { request: item.request, result: { omitted: true, reason: 'Result omitted: request fewer lines/matches; no body or receipt provided.' } };
         const minimal = nextRequest([...retrieved, omitted]);
-        if (Buffer.byteLength(compactFollowup(minimal.input)) + Buffer.byteLength(minimal.instructions) > maxInputBytes) throw new Error('Retrieval input metadata exceeds model capacity');
+        if (!fits({ ...minimal, input: compactFollowup(minimal.input) })) throw new Error('Retrieval input metadata exceeds model capacity');
         retrieved.push(omitted);
         await request.onProtocolEvent?.({ action: 'oversized-retrieval-omitted', kind: item.request.kind });
       } else {

package/src/review-artifacts.mjs

@@ -0,0 +1,117 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { mkdir, open, lstat, realpath, rename, unlink, chmod } from 'node:fs/promises';
+import path from 'node:path';
+
+const queues = new Map();
+const UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+const STATUSES = new Set(['completed', 'failed', 'cancelled', 'incomplete', 'validated-draft', 'rejected']);
+const fail = code => Object.assign(new Error(code), { code });
+const within = (base, name) => { const r = path.relative(base, name); return r === '' || (!path.isAbsolute(r) && r !== '..' && !r.startsWith('..' + path.sep)); };
+function ownerIdentity(owner) {
+  if (!owner || !['sessionId', 'cwd', 'provider', 'model'].every(key => typeof owner[key] === 'string' && owner[key].length > 0 && owner[key].length <= 4096) || !path.isAbsolute(owner.cwd) || !(owner.reasoningEffort == null || typeof owner.reasoningEffort === 'string' && owner.reasoningEffort.length <= 256)) throw fail('INVALID_REVIEW_ARTIFACT_OWNER');
+  return { sessionId: owner.sessionId, cwd: owner.cwd, provider: owner.provider, model: owner.model, reasoningEffort: owner.reasoningEffort ?? null };
+}
+function snapshot(value, depth = 0) {
+  if (depth > 64) throw fail('INVALID_REVIEW_ARTIFACT');
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value !== 'object' || ![Object.prototype, Array.prototype, null].includes(Object.getPrototypeOf(value))) throw fail('INVALID_REVIEW_ARTIFACT');
+  const result = Array.isArray(value) ? [] : Object.create(null);
+  for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+    if (Array.isArray(value) && key === 'length') continue;
+    if (!descriptor.enumerable) continue;
+    if (!('value' in descriptor) || descriptor.value === undefined) throw fail('INVALID_REVIEW_ARTIFACT');
+    Object.defineProperty(result, key, { value: snapshot(descriptor.value, depth + 1), enumerable: true, configurable: true, writable: true });
+  }
+  return result;
+}
+async function projectedRealpath(name) {
+  let current = path.resolve(name); const suffix = [];
+  for (;;) {
+    try { return path.join(await realpath(current), ...suffix); }
+    catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+      try { if ((await lstat(current)).isSymbolicLink()) throw fail('UNSAFE_REVIEW_ARTIFACT'); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+      const parent = path.dirname(current); if (parent === current) throw error;
+      suffix.unshift(path.basename(current)); current = parent;
+    }
+  }
+}
+
+// Artifacts are untrusted private evidence, never approved source or confirmed findings.
+export function createReviewArtifacts({ directory, maxArtifactBytes = 1048576, maxJobBytes = 8388608, maxArtifacts = 64 } = {}) {
+  if (typeof directory !== 'string' || !path.isAbsolute(directory)) throw fail('INVALID_REVIEW_ARTIFACT_DIRECTORY');
+  if (![maxArtifactBytes, maxJobBytes, maxArtifacts].every(n => Number.isSafeInteger(n) && n > 0) || maxArtifactBytes > 16777216 || maxJobBytes > 268435456 || maxArtifacts > 10000) throw fail('INVALID_REVIEW_ARTIFACT_LIMIT');
+  let canonical;
+  async function safeDirectory(owner) {
+    const [workspace, resolved] = await Promise.all([projectedRealpath(owner.cwd), projectedRealpath(directory)]);
+    if (within(workspace, resolved) || canonical !== undefined && canonical !== resolved) throw fail('UNSAFE_REVIEW_ARTIFACT');
+    await mkdir(resolved, { recursive: true, mode: 0o700 });
+    const stat = await lstat(directory);
+    if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(directory) !== resolved) throw fail('UNSAFE_REVIEW_ARTIFACT');
+    await chmod(resolved, 0o700); canonical ??= resolved;
+    return resolved;
+  }
+  async function load(filename, jobId, owner) {
+    let handle;
+    try {
+      const stat = await lstat(filename);
+      if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > maxJobBytes + maxArtifacts * 1024 + 65536) throw fail('UNSAFE_REVIEW_ARTIFACT');
+      handle = await open(filename, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+      const actual = await handle.stat();
+      if (!actual.isFile() || stat.ino !== actual.ino || stat.dev !== actual.dev) throw fail('UNSAFE_REVIEW_ARTIFACT');
+      const record = JSON.parse(await handle.readFile('utf8'));
+      if (record.jobId !== jobId || JSON.stringify(record.owner) !== JSON.stringify(owner)) throw fail('FOREIGN_REVIEW_ARTIFACT');
+      if (!Array.isArray(record.artifacts) || record.artifacts.length > maxArtifacts || !Number.isSafeInteger(record.retainedBytes) || record.retainedBytes < 0 || record.retainedBytes > maxJobBytes) throw fail('UNSAFE_REVIEW_ARTIFACT');
+      return record;
+    } catch (error) { if (error.code === 'ENOENT') return { jobId, owner, retainedBytes: 0, artifacts: [] }; throw error; }
+    finally { await handle?.close(); }
+  }
+  async function transaction(jobId, owner, work) {
+    if (typeof jobId !== 'string' || !UUID.test(jobId)) throw fail('INVALID_REVIEW_ARTIFACT_JOB');
+    try {
+      const root = await safeDirectory(owner), filename = path.join(root, jobId + '.json');
+      const previous = queues.get(filename) ?? Promise.resolve();
+      const next = previous.catch(() => {}).then(async () => {
+        await safeDirectory(owner);
+        const record = await load(filename, jobId, owner);
+        return work(record, filename);
+      });
+      queues.set(filename, next);
+      try { return await next; } finally { if (queues.get(filename) === next) queues.delete(filename); }
+    } catch (error) {
+      if (['INVALID_REVIEW_ARTIFACT_JOB', 'UNSAFE_REVIEW_ARTIFACT', 'FOREIGN_REVIEW_ARTIFACT'].includes(error.code)) throw fail(error.code);
+      throw fail('ARTIFACT_STORE_FAILED');
+    }
+  }
+  return {
+    async record(jobId, owner, artifact) {
+      const who = ownerIdentity(owner), value = snapshot(artifact);
+      if (!value || Array.isArray(value) || typeof value !== 'object') throw fail('INVALID_REVIEW_ARTIFACT');
+      const serialized = JSON.stringify(value), bytes = Buffer.byteLength(serialized);
+      const summary = { artifactId: randomUUID(), hash: createHash('sha256').update(serialized).digest('hex'), bytes, status: STATUSES.has(value.status) ? value.status : 'unclassified', omitted: false, recorded: true };
+      return transaction(jobId, who, async (record, filename) => {
+        if (bytes > maxArtifactBytes || record.retainedBytes + bytes > maxJobBytes || record.artifacts.length >= maxArtifacts) {
+          summary.omitted = true; summary.diagnostic = 'REVIEW_ARTIFACT_LIMIT_EXCEEDED';
+          if (record.artifacts.length >= maxArtifacts) return { ...summary, recorded: false };
+        }
+        record.artifacts.push({ ...summary, ...(summary.omitted ? {} : { artifact: value }) });
+        if (!summary.omitted) record.retainedBytes += bytes;
+        const tmp = path.join(canonical, jobId + '.' + randomUUID() + '.tmp'); let handle;
+        try {
+          handle = await open(tmp, 'wx', 0o600); await handle.writeFile(JSON.stringify(record)); await handle.sync(); await handle.close(); handle = undefined;
+          await safeDirectory(who);
+          try { const stat = await lstat(filename); if (stat.isSymbolicLink() || !stat.isFile() || stat.nlink !== 1) throw fail('UNSAFE_REVIEW_ARTIFACT'); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+          await rename(tmp, filename);
+        } finally { await handle?.close(); await unlink(tmp).catch(() => {}); }
+        return { ...summary };
+      });
+    },
+    async read(jobId, owner, { offset = 0, limit = 20 } = {}) {
+      const who = ownerIdentity(owner);
+      if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw fail('INVALID_REVIEW_ARTIFACT_PAGE');
+      return transaction(jobId, who, async record => ({ jobId, totalArtifacts: record.artifacts.length, offset, limit, artifacts: record.artifacts.slice(offset, offset + limit) }));
+    },
+  };
+}

package/src/review-diagnostics.mjs

@@ -1,17 +1,20 @@
 import { REVIEW_RUNTIME } from './runtime-identity.mjs';
-const PHASES = ['business-grouping', 'risk-planning', 'primary', 'file-interaction', 'window-synthesis', 'verification'];
-const PURPOSES = ['primary-initial', 'retrieval-followup', 'budget-finalization', 'json-correction', 'business-grouping', 'risk-planning', 'window-synthesis', 'file-interaction', 'verification'];
+const PHASES = ['business-grouping', 'risk-planning', 'primary', 'group-primary', 'file-interaction', 'window-synthesis', 'verification'];
+const PURPOSES = ['primary-initial', 'retrieval-followup', 'budget-finalization', 'json-correction', 'business-grouping', 'risk-planning', 'group-primary', 'window-synthesis', 'file-interaction', 'verification'];
 const READER_FIELDS = ['calls', 'outputBytes', 'maxCalls', 'maxOutputBytes', 'remainingCalls', 'remainingOutputBytes', 'maxResultBytes'];
 const JSON_ISSUES = ['property-name', 'colon', 'separator', 'invalid-escape', 'control-character', 'unterminated-string', 'unexpected-end', 'trailing-content', 'syntax'];
 const CORRECTION_CODES = ['MODEL_INVALID_JSON', 'MODEL_INVALID_REVIEW_RESPONSE', 'MODEL_INVALID_FINDING_IDENTITY', 'MODEL_INVALID_FINDING_SEVERITY', 'MODEL_MISSING_FINDING_FIELD', 'MODEL_INVALID_ANCHOR', 'MODEL_ANCHOR_MISMATCH', 'RETRIEVAL_PROTOCOL_ERROR'];
 const LIMIT_CODES = ['READER_CALL_BUDGET_EXCEEDED', 'READER_OUTPUT_BUDGET_EXCEEDED', 'RETRIEVAL_ROUND_BUDGET_EXCEEDED'];
+const RECOVERY_KINDS = ['native-tool', 'text-compatible', 'trailing-prose'];
 const FALLBACK_REASONS = ['mode-notauto', 'smallchange', 'disabled', 'project', 'laterround', 'multi-batch', 'incomplete-edit-scope', 'input-budget'];
 const number = n => Number.isFinite(n) && n >= 0 ? Math.round(n) : null;
 // Source-free counters only; call walls overlap and include lifecycle observation.
 export function reviewDiagnostics(report, { reviewWallMs = null, executionWallMs = null } = {}) {
+  // Shared orchestration is one aggregator, not copied into each file's work.
+  const sources = [...(report.files ?? []), ...(report.orchestration ? [report.orchestration] : [])];
   const phases = [];
   for (const phase of PHASES) {
-    const rows = (report.files ?? []).map(f => f.modelMetrics?.[phase]).filter(Boolean);
+    const rows = sources.map(f => f.modelMetrics?.[phase]).filter(Boolean);
     if (!rows.length) continue;
     const sum = field => rows.every(r => number(r[field]) !== null) ? number(rows.reduce((n, r) => n + r[field], 0)) : null;
     phases.push({ phase, calls: sum('calls'), observedCallWallSumMs: sum('durationMs'), inputBytes: sum('inputBytes'), totalOutputBytes: sum('totalOutputBytes') });
@@ -19,24 +22,29 @@ export function reviewDiagnostics(report, { reviewWallMs = null, executionWallMs
   const plans = (report.files ?? []).flatMap(f => f.riskPlans ?? []);
   const observedModelCalls = phases.length && phases.every(p => p.calls !== null) ? phases.reduce((n, p) => n + p.calls, 0) : null;
   const modelCallPurposes = PURPOSES.flatMap(purpose => {
-    const values = (report.files ?? []).map(f => f.modelCallPurposes?.[purpose]).filter(value => value !== undefined);
+    const values = sources.map(f => f.modelCallPurposes?.[purpose]).filter(value => value !== undefined);
     if (!values.length) return [];
     return [{ purpose, calls: values.every(value => number(value) !== null) ? number(values.reduce((sum, value) => sum + value, 0)) : null }];
   });
   const readerBudget = Object.fromEntries(READER_FIELDS.map(field => [field, number(report.readerBudget?.[field])]));
   const correctionCounts = new Map();
-  for (const event of (report.files ?? []).flatMap(f => f.modelCorrections ?? [])) {
+  for (const event of sources.flatMap(f => f.modelCorrections ?? [])) {
     if (!['explicit-json-correction', 'retrieval-protocol-correction', 'review-format-correction'].includes(event?.action) || !CORRECTION_CODES.includes(event.code)) continue;
     const jsonIssue = JSON_ISSUES.includes(event.jsonIssue) ? event.jsonIssue : null;
     const key = JSON.stringify([event.code, jsonIssue]);
     correctionCounts.set(key, (correctionCounts.get(key) ?? 0) + 1);
   }
   const correctionReasons = [...correctionCounts].map(([key, calls]) => { const [code, jsonIssue] = JSON.parse(key); return { code, jsonIssue, calls }; }).sort((a, b) => a.code.localeCompare(b.code) || String(a.jsonIssue).localeCompare(String(b.jsonIssue)));
-  const limits = (report.files ?? []).flatMap(f => f.retrievalLimits ?? []);
+  const limits = sources.flatMap(f => f.retrievalLimits ?? []);
   const readerLimitReasons = LIMIT_CODES.flatMap(code => { const calls = limits.filter(row => row?.code === code).length; return calls ? [{ code, calls }] : []; });
   const readerLimits = { maxRounds: number(report.readerLimits?.maxRounds ?? report.maxRetrievalRounds) };
   const riskPlanningFallbackReasons = FALLBACK_REASONS.flatMap(reason => { const calls = (report.files ?? []).filter(f => f.riskPlanningFallbackReason === reason).length; return calls ? [{ reason, calls }] : []; });
-  return { schemaVersion: 2, pluginVersion: REVIEW_RUNTIME.version, reviewWallMs: number(reviewWallMs), executionWallMs: number(executionWallMs),
+  const recoveryEvents = sources.flatMap(source => source.modelRecoveries ?? []);
+  const transportRecoveries = RECOVERY_KINDS.flatMap(kind => { const calls = recoveryEvents.filter(event => event?.action === 'json-transport-recovery' && event.kind === kind).length; return calls ? [{ kind, calls }] : []; });
+  const resume = { reusedFiles: number(report.resume?.reusedFiles) };
+  const artifactRecords = Array.isArray(report.artifacts) ? report.artifacts : null;
+  const artifacts = { retained: artifactRecords ? artifactRecords.filter(record => record?.omitted === false && record.recorded === true).length : null, omitted: artifactRecords ? artifactRecords.filter(record => record?.omitted === true).length : null };
+  return { schemaVersion: 2, resume, artifacts, transportRecoveries, pluginVersion: REVIEW_RUNTIME.version, reviewWallMs: number(reviewWallMs), executionWallMs: number(executionWallMs),
     modelCalls: number(report.modelCalls), observedModelCalls, phases, modelCallPurposes, readerBudget, correctionReasons, readerLimitReasons, readerLimits, riskPlanningFallbackReasons,
     planning: { completed: plans.filter(p => p.status === 'completed' && p.method !== 'inline').length, inline: plans.filter(p => p.method === 'inline' && p.status === 'completed').length, inlineAbsent: plans.filter(p => p.method === 'inline' && p.status === 'absent').length, inlineInvalid: plans.filter(p => p.method === 'inline' && p.status === 'invalid').length, fallback: plans.filter(p => p.status === 'fallback').length, skipped: plans.filter(p => p.status === 'skipped').length },
     callPurposeNotice: 'primary-initial is the first call of a retrieval-enabled stage, not only primary review; phase identifies the stage. Correction reason counts include actual correction invocation records only, not both failures and completion notices.',
@@ -52,7 +60,7 @@ export function diagnosticsMarkdown(d) {
     output.push('', '累计调用墙钟可能并发重叠，且包含生命周期观察／初始检查点等待，不是纯提供方耗时，也不能从总耗时中相减当作本地开销。');
   } else output.push('- 逐阶段模型观测不可用（未产生或旧报告未记录），不按零耗时解释。');
   if (d.modelCallPurposes?.length) {
-    const labels = { 'primary-initial': '阶段初始', 'retrieval-followup': '检索后续', 'budget-finalization': '预算受限最终答复', 'json-correction': 'JSON纠正', 'business-grouping': '业务分组', 'risk-planning': '风险计划', 'window-synthesis': '窗口综合', 'file-interaction': '跨文件综合', verification: '复核' };
+    const labels = { 'primary-initial': '阶段初始', 'retrieval-followup': '检索后续', 'budget-finalization': '预算受限最终答复', 'json-correction': 'JSON纠正', 'business-grouping': '业务分组', 'risk-planning': '风险计划', 'group-primary': '分组主审', 'window-synthesis': '窗口综合', 'file-interaction': '跨文件综合', verification: '复核' };
     output.push('- 调用目的：' + d.modelCallPurposes.filter(row => PURPOSES.includes(row.purpose)).map(row => labels[row.purpose] + ' ' + (number(row.calls) ?? '不可用')).join('；') + '。');
   }
   if (d.readerBudget && READER_FIELDS.some(field => number(d.readerBudget[field]) !== null)) {
@@ -63,6 +71,9 @@ export function diagnosticsMarkdown(d) {
   if (d.readerLimitReasons?.length) output.push('- 读取限制原因：' + d.readerLimitReasons.filter(r => LIMIT_CODES.includes(r.code)).map(r => r.code + ' ' + (number(r.calls) ?? '不可用')).join('；') + '。');
   if (number(d.readerLimits?.maxRounds) !== null) output.push('- 每阶段最大检索轮次：' + number(d.readerLimits.maxRounds) + '；调用数／输出字节耗尽与轮次耗尽分别记录，不能混同。');
   if (d.riskPlanningFallbackReasons?.length) output.push('- 风险策略回退原因：' + d.riskPlanningFallbackReasons.filter(r => FALLBACK_REASONS.includes(r.reason)).map(r => r.reason + ' ' + (number(r.calls) ?? '不可用')).join('；') + '。');
+  if (d.transportRecoveries?.length) output.push('- 本地结果传输：' + d.transportRecoveries.filter(row => RECOVERY_KINDS.includes(row.kind)).map(row => row.kind + ' ' + (number(row.calls) ?? '不可用')).join('；') + '；仅计成功解析的传输事件，不表示额外模型调用或缺陷确认。');
+  if (number(d.resume?.reusedFiles) !== null) output.push('- 续审复用已完成文件：' + number(d.resume.reusedFiles) + '；复用成果不计为本次模型调用或新读取证据。');
+  if (number(d.artifacts?.retained) !== null || number(d.artifacts?.omitted) !== null) output.push('- 私有模型工件：已留存 ' + (number(d.artifacts.retained) ?? '不可用') + '，未留存 ' + (number(d.artifacts.omitted) ?? '不可用') + '；诊断仅含计数，不包含正文或访问标识。');
   output.push('- primary-initial 表示启用检索的某阶段初始调用，不仅是主审；具体阶段以阶段统计为准。');
   output.push('- 风险计划：完成 ' + d.planning.completed + '，回退 ' + d.planning.fallback + '，跳过 ' + d.planning.skipped + '；合并主审问题 ' + (d.planning.inline ?? 0) + '，缺失 ' + (d.planning.inlineAbsent ?? 0) + '，无效 ' + (d.planning.inlineInvalid ?? 0) + '（非独立规划）。');
   return output;

package/src/review-jobs.mjs

@@ -1,3 +1,4 @@
+import {createReviewArtifacts} from './review-artifacts.mjs';
 import {jobProgress} from './job-progress.mjs';
 import {recoveryCoverage} from './recovery-coverage.mjs';
 import {randomUUID} from 'node:crypto';
@@ -7,6 +8,7 @@ import path from 'node:path';
 // Report storage is host-owned, never inside a reviewed working copy.
 export function createReviewJobs({directory}={}){
  if(typeof directory!=='string'||!path.isAbsolute(directory))throw new Error('Absolute host report directory required');
+ const artifacts=createReviewArtifacts({directory:path.join(directory,'artifacts')});
  const jobs=new Map(),listeners=new Map();const changed=id=>{for(const fn of [...(listeners.get(id)??[])])fn();};let disposed=false,canonicalDirectory;
  const identity=exec=>{const a=exec?.agent,s=a?.session;if(!s||!a.options?.provider||!a.options?.model||!s.header?.cwd)throw new Error('Review job requires session identity');const id=s.header.id??s.id;if(typeof id!=='string'||!id)throw new Error('Durable session id required');return {sessionId:id,cwd:s.header.cwd,provider:a.options.provider,model:a.options.model,reasoningEffort:a.options.reasoningEffort??null};};
  const same=(a,b)=>JSON.stringify(a)===JSON.stringify(b);
@@ -59,7 +61,7 @@ export function createReviewJobs({directory}={}){
      controller.signal.throwIfAborted();
      job.record.status='running';await enqueue(()=>save(job));
      controller.signal.throwIfAborted();
-     const result=await work({signal:controller.signal,checkpoint:async value=>enqueue(async()=>{job.record.stage=value.stage??'reviewing';job.record.checkpoints.push(structuredClone(value));await save(job);})});
+     const result=await work({signal:controller.signal,artifact:async value=>{const ref=await artifacts.record(id,job.record.owner,value);await enqueue(async()=>{(job.record.artifacts??=[]).push(ref);await save(job);});return ref;},saveResumeState:async value=>enqueue(async()=>{job.record.resumeState=structuredClone(value);await save(job);}),checkpoint:async value=>enqueue(async()=>{job.record.stage=value.stage??'reviewing';job.record.checkpoints.push(structuredClone(value));await save(job);})});
      job.record.result=result;job.record.status=controller.signal.aborted?'cancelled':'completed';
     }catch(error){job.record.status=controller.signal.aborted?'cancelled':'failed';job.record.error=error?.message??String(error);}
     finally{
@@ -74,7 +76,9 @@ export function createReviewJobs({directory}={}){
    await startup;
    return {jobId:id,status:job.record.status,waitRevision:job.savedRevision,progress:jobProgress(job.record),nextAction:'Call code_review_wait with waitFor=terminal until terminal status; reuse the returned waitRevision as after without guessing increments. No code_review_status call is needed after each event. Do not finish the user request at start.',notice:'Background job accepted; start is not a completed review. Explicit cancel or plugin disposal stops it.'};
   },
-  async status(id,exec,page){const r=structuredClone(await owned(id,exec)),active=jobs.get(id);if(active&&!active.settled&&!['queued','running'].includes(r.status)){r.status='running';r.stage='finalizing';delete r.result;delete r.finishedAt;}r.recovery=recoveryCoverage(r);r.progress=jobProgress(r);r.waitRevision=jobs.get(id)?.savedRevision??r.checkpoints.length;r.nextAction=['queued','running'].includes(r.status)?'Call code_review_wait with waitFor=terminal; reuse the exact returned waitRevision as after, never guess increments. No code_review_status call is needed after each event. Do not end the user request while task runs.':r.result?.previewId?'Show preview and request user confirmation before execute.':'Collect final report and unfinished scope, then provide one final answer.';if(!page)return r;const {offset=0,limit=20,checkpointIndex}=page;if(!Number.isSafeInteger(offset)||offset<0||!Number.isSafeInteger(limit)||limit<1||limit>100)throw new Error('Invalid result page');if(checkpointIndex!==undefined){if(!Number.isSafeInteger(checkpointIndex)||checkpointIndex<0||checkpointIndex>=r.checkpoints.length)throw new Error('Invalid checkpoint index');return {jobId:r.jobId,status:r.status,waitRevision:r.waitRevision,progress:r.progress,nextAction:r.nextAction,checkpointIndex,checkpoint:pageCheckpoint(r.checkpoints[checkpointIndex],offset,limit),page:{offset,limit}};}const result=r.result;const report=result?.report;return {...r,result:undefined,recovery:{...r.recovery,unfinishedStages:r.recovery.unfinishedStages.slice(offset,offset+limit),files:r.recovery.files.slice(offset,offset+limit),windows:r.recovery.windows.slice(offset,offset+limit),suggestedPaths:r.recovery.suggestedPaths.slice(offset,offset+limit),totalObservedFiles:r.recovery.files.length},checkpoints:r.checkpoints.slice(offset,offset+limit).map(c=>pageCheckpoint(c,0,limit)),checkpointPage:{offset,limit,total:r.checkpoints.length},...(result?{resultSummary:report?{status:report.status,coverage:report.coverage,model:report.model,snapshotId:report.snapshotId,diagnostics:report.diagnostics,execution:report.execution,modelCalls:report.modelCalls}:({...result,files:result.files?.slice(offset,offset+limit),filePage:result.files?{offset,limit,total:result.files.length}:undefined}),resultPage:report?{files:report.files?.slice(offset,offset+limit),findings:report.findings?.slice(offset,offset+limit),totalFiles:report.files?.length,totalFindings:report.findings?.length}:undefined}: {})};},
+  async resume(id,exec){const r=await owned(id,exec);if(jobs.get(id)&&!jobs.get(id).settled||['queued','running'].includes(r.status)||!r.resumeState)throw new Error('No terminal completed-chain resume state available');return structuredClone(r.resumeState);},
+  async artifacts(id,exec,page){const r=await owned(id,exec);return artifacts.read(id,r.owner,page);},
+  async status(id,exec,page){const r=structuredClone(await owned(id,exec));delete r.resumeState;const active=jobs.get(id);if(active&&!active.settled&&!['queued','running'].includes(r.status)){r.status='running';r.stage='finalizing';delete r.result;delete r.finishedAt;}r.recovery=recoveryCoverage(r);r.progress=jobProgress(r);r.waitRevision=jobs.get(id)?.savedRevision??r.checkpoints.length;r.nextAction=['queued','running'].includes(r.status)?'Call code_review_wait with waitFor=terminal; reuse the exact returned waitRevision as after, never guess increments. No code_review_status call is needed after each event. Do not end the user request while task runs.':r.result?.previewId?'Show preview and request user confirmation before execute.':'Collect final report and unfinished scope, then provide one final answer.';if(!page)return r;const {offset=0,limit=20,checkpointIndex}=page;if(!Number.isSafeInteger(offset)||offset<0||!Number.isSafeInteger(limit)||limit<1||limit>100)throw new Error('Invalid result page');if(checkpointIndex!==undefined){if(!Number.isSafeInteger(checkpointIndex)||checkpointIndex<0||checkpointIndex>=r.checkpoints.length)throw new Error('Invalid checkpoint index');return {jobId:r.jobId,status:r.status,waitRevision:r.waitRevision,progress:r.progress,nextAction:r.nextAction,checkpointIndex,checkpoint:pageCheckpoint(r.checkpoints[checkpointIndex],offset,limit),page:{offset,limit}};}const result=r.result;const report=result?.report;return {...r,result:undefined,recovery:{...r.recovery,unfinishedStages:r.recovery.unfinishedStages.slice(offset,offset+limit),files:r.recovery.files.slice(offset,offset+limit),windows:r.recovery.windows.slice(offset,offset+limit),suggestedPaths:r.recovery.suggestedPaths.slice(offset,offset+limit),totalObservedFiles:r.recovery.files.length},checkpoints:r.checkpoints.slice(offset,offset+limit).map(c=>pageCheckpoint(c,0,limit)),checkpointPage:{offset,limit,total:r.checkpoints.length},...(result?{resultSummary:report?{status:report.status,coverage:report.coverage,model:report.model,snapshotId:report.snapshotId,diagnostics:report.diagnostics,execution:report.execution,modelCalls:report.modelCalls}:({...result,files:result.files?.slice(offset,offset+limit),filePage:result.files?{offset,limit,total:result.files.length}:undefined}),resultPage:report?{files:report.files?.slice(offset,offset+limit),findings:report.findings?.slice(offset,offset+limit),totalFiles:report.files?.length,totalFindings:report.findings?.length}:undefined}: {})};},
   async wait(id,exec,{after,waitFor='progress',timeoutMs=60000,signal}={}){
    const r=await owned(id,exec);
    if(!Number.isSafeInteger(timeoutMs)||timeoutMs<1||timeoutMs>60000)throw new Error('Invalid wait duration');