@feng0531/dsh-code-review 0.85.13 → 0.86.1

package/src/group-primary.mjs

@@ -0,0 +1,40 @@
+import { preparePrimaryInput } from './primary-input.mjs';
+import { initialInputBudget } from './input-budget.mjs';
+import { INLINE_RISK_INSTRUCTIONS } from './prompts.mjs';
+import { validateRiskPlan } from './risk-plan.mjs';
+
+export const GROUP_PRIMARY_INSTRUCTIONS = '批准的group-primary输入包含多个完整主文件。逐个审核所有reviews成员的新旧正文，并结合组内其他文件分析；不能仅审核一个文件。返回 {"reviews":[{"fileId":"原成员身份","findings":[],"limitations":[]}],"limitations":[]}，每个成员恰好一项，包括没有发现的成员。各finding仍需原审查指令全部字段、精确原行anchor及该fileId本次变化归因；不能用其他成员的身份或坐标替代。缺证据写limitations，不声明跨文件综合已完成；专门交互阶段仍独立校验。可按批准检索协议先返回requests。';
+
+export function prepareGroupPrimary(snapshot, group, { instructions, scope, maxInputBytes, focusPrimaryContext = false, enableRiskPlanning = false } = {}) {
+  if (!scope || snapshot.projectScope || !Array.isArray(group?.fileIds) || group.fileIds.length < 2 || group.fileIds.length > 4 || new Set(group.fileIds).size !== group.fileIds.length) return null;
+  const members = group.fileIds.map(id => snapshot.files.find(file => file.id === id));
+  if (members.some(file => !file || file.eligibility !== 'reviewable')) return null;
+  const prepared = members.map(file => preparePrimaryInput(snapshot, file, { instructions, scope, maxInputBytes, focusPrimaryContext, riskPlanningMode: 'separate', enableRiskPlanning: false }));
+  if (prepared.some(p => p.batches || p.synthesis || p.metadata.sourceMode || p.changes.precision !== 'exact')) return null;
+  const reviews = prepared.map((p, i) => ({ ...JSON.parse(p.payload), fileId: members[i].id }));
+  const context = [...new Map(reviews.flatMap(r => r.context ?? []).map(item => [JSON.stringify(item), item])).values()];
+  for (const item of reviews) { delete item.context; delete item.rules; delete item.businessRequirement; delete item.requirementNotice; }
+  const value = { snapshotId: snapshot.id, sourceMode: 'group-primary', groupId: group.id, reviews, context, rules: snapshot.rules ?? [], ...(snapshot.businessRequirement !== undefined ? { businessRequirement: snapshot.businessRequirement } : {}) };
+  const payload = JSON.stringify(value), combined = instructions + '\n' + GROUP_PRIMARY_INSTRUCTIONS + (enableRiskPlanning ? '\n各成员可附带risks；组风险可引用所有成员精确编辑，仍只是假设，不增加规划调用。' + INLINE_RISK_INSTRUCTIONS.replace('Final JSON requires findings/limitations;', 'Each reviews member requires findings/limitations;') : '');
+  return initialInputBudget({ input: payload, instructions: combined }, scope, maxInputBytes).fits ? { payload, instructions: combined, fileIds: [...group.fileIds], inlineRisk: enableRiskPlanning, changes: new Map(members.map((f, i) => [f.id, prepared[i].changes])) } : null;
+}
+
+export function validateGroupPrimary(response, prepared, snapshot, validate, catalog = []) {
+  if (Buffer.byteLength(typeof response === 'string' ? response : JSON.stringify(response) ?? '') > 128 * 1024) throw new Error('Grouped primary response too large');
+  const value = typeof response === 'string' ? JSON.parse(response) : response;
+  if (!value || !Array.isArray(value.reviews) || value.reviews.length !== prepared.fileIds.length || !Array.isArray(value.limitations) || value.limitations.length > 50 || value.limitations.some(s => typeof s !== 'string' || !s.trim() || s.length > 8000)) throw new Error('Invalid grouped primary response');
+  const output = new Map();
+  for (const row of value.reviews) {
+    if (!prepared.fileIds.includes(row?.fileId) || output.has(row.fileId)) throw new Error('Unknown or duplicate grouped primary member');
+    const file = snapshot.files.find(f => f.id === row.fileId);
+    if (row.findings?.some(finding => finding.interaction !== undefined)) throw new Error('Grouped primary cannot bypass dedicated interaction evidence validation');
+    const generated = validate(row, file, prepared.changes.get(row.fileId));
+    generated.limitations = [...generated.limitations, ...value.limitations];
+    if (prepared.inlineRisk) {
+      try { generated.groupRisk = row.risks === undefined ? { status: 'absent', risks: [] } : { status: 'completed', risks: validateRiskPlan({ risks: row.risks }, prepared.fileIds.map(id => ({ fileId: id, edits: prepared.changes.get(id).edits })), catalog) }; }
+      catch { generated.groupRisk = { status: 'invalid', risks: [] }; }
+    }
+    output.set(row.fileId, generated);
+  }
+  return output;
+}

package/src/input-budget.mjs

@@ -1,10 +1,12 @@
 import { retrievalRequest } from './retrieval-loop.mjs';
+import { modelWireBudget, nativeWireEnabled } from './model-wire-budget.mjs';
 
 // Count the actual initial envelope, including instructions and retrieval catalog.
 // This is not a token/price estimate and does not reserve later retrieval rounds.
 export function initialInputBudget(request, scope, maxBytes) {
   if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw new Error('Invalid input budget');
   const actual = scope ? retrievalRequest(request, scope) : request;
+  if (nativeWireEnabled(request, scope)) return modelWireBudget({ ...actual, nativeOutputTools: true }, maxBytes);
   const bytes = Buffer.byteLength(actual.input) + Buffer.byteLength(actual.instructions);
   return { bytes, maxBytes, fits: bytes <= maxBytes };
 }

package/src/model-contract.mjs

@@ -12,6 +12,7 @@ function stageContract(p, instructions) {
   if (Array.isArray(p.candidates)) return VERDICT_CONTRACT;
   if (/返回\{groups:/.test(instructions)) return GROUPS_CONTRACT;
   if (/仅制定审查计划/.test(instructions)) return instructions.includes(RISK_PLAN_SCHEMA) ? '本阶段严格按上述risks schema返回，禁止requests/findings；身份逐项核对输入。' : RISK_CONTRACT;
+  if (p.sourceMode === 'group-primary') return '本阶段返回{reviews:[{fileId,findings:[],limitations:[],risks:可选数组}],limitations:[]}；每项fileId仅来自reviews[].file.id，按文件原始坐标审查，不将分组自动视为交互证据。可按批准检索协议单独返回requests。';
   if (p.sourceMode === 'file-interaction') return INTERACTION_CONTRACT;
   if (p.file) return FINDINGS_CONTRACT;
   return '';

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
@@ -64,13 +65,17 @@ export function primarySeeds(scope, request, { maxInputBytes = 96 * 1024, onRetr
     if (attempted.size >= MAX_READS) break;
     if (seeds.some(item => item.request.id === source.id && item.result.start <= coordinate && coordinate < item.result.start + item.result.count)) continue;
     const budget = scope.budget();
-    if (budget.remainingCalls <= RESERVE_CALLS || budget.remainingOutputBytes <= RESERVE_BYTES) break;
+    if (budget.remainingOutputBytes <= RESERVE_BYTES) break;
     const operation = { kind: 'read', id: source.id, start: Math.max(1, coordinate - 4), count: MAX_LINES };
     const key = JSON.stringify(operation);
     if (attempted.has(key)) continue;
     attempted.add(key);
     let item;
     try {
+      // A cached raw delivery costs no new materialization call, but still uses
+      // output bytes and must pass the exact operation's approved preflight.
+      const cached = budget.reusableResults === true && scope.preflight([operation])?.calls === 0 && scope.canServe?.([operation]) === true;
+      if (!cached && budget.remainingCalls <= RESERVE_CALLS) continue;
       item = scope.transaction(() => {
         checkSignal();
         scope.preflight([operation]);
@@ -78,7 +83,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 || (!cached && 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: 4096, 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: 4096, 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();
@@ -65,19 +66,20 @@ export async function retrievalLoop(model, request, scope, { correctProtocol = f
   };
   const checkExhausted = async round => {
     const budget = scope.budget?.();
-    if (!finalization && budget && (budget.remainingCalls === 0 || budget.remainingOutputBytes === 0)) {
+    if (!finalization && budget && ((budget.remainingCalls === 0 && !budget.reusableResults) || budget.remainingOutputBytes === 0)) {
       const error = new Error(budget.remainingCalls === 0 ? 'Reader call budget exceeded' : 'Reader output budget exceeded');
       error.code = budget.remainingCalls === 0 ? 'READER_CALL_BUDGET_EXCEEDED' : 'READER_OUTPUT_BUDGET_EXCEEDED';
       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 = 4096 } = {}) {
+  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) }));
+    },
+  };
+}