v1.89.0.0 feat: add shared-code extraction audit (#2925)

* feat: bind shared-code review advice to source and branch * feat: add shared-code extraction audit and scoped review checks * test: recognize complete source reads and explicit coverage legends * chore: bump version and changelog (v1.88.0.0) Co-Authored-By: OpenAI Codex <noreply@openai.com> * test: capture native review questions and retain public evidence Capture the actual first public native question with strict ownership and display matching. Preserve terminal failures and raw evidence, and retain SDK completion checks. * test: recognize verified review evidence and complete fixtures Recognize complete source and diagram evidence, concrete design and developer-experience decisions, and the complete planted scenario contracts. Preserve negative controls and grading thresholds. * fix: preserve decision brief structure in native questions Keep the required pros-and-cons heading and final Net field in native question text. Regenerate host outputs and document the release and evaluation repairs. Co-Authored-By: OpenAI Codex <noreply@openai.com> * docs: update project documentation for v1.88.0.0 Co-Authored-By: OpenAI Codex <noreply@openai.com> * fix: correct eval retry accounting and ship workflow gates * fix: capture native eval evidence and stabilize CI fixtures * fix: keep shared-code eval skips read-only Choose explicit no-change answers instead of mixed fix/preservation options. Reuse the bounded revalidation prompt for path fixtures so required review metadata is available without repeated discovery. Preserve source checks, retry limits, and failed native terminal outcomes. Add captured-question and callback regressions, plus evaluation selection coverage for the affected fixtures. --------- Co-authored-by: OpenAI Codex <noreply@openai.com>
2026-09-27 15:11:47 +02:00 · 2026-09-24 01:53:58 -04:00
parent b9706f3635
commit 06ed920a97
177 changed files with 13244 additions and 2477 deletions
@@ -0,0 +1,396 @@
+/** Capture an actual public AskUserQuestion, without reading model transcripts. */
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { resolveEvalModel } from '../../lib/eval-model';
+import { launchClaudePty, capturePlanCountQuestion, parseNumberedOptions, type ClaudePtySession } from './claude-pty-runner';
+import { buildSeedConfig, isHermeticEnabled } from './hermetic-env';
+import { getProjectEvalDir } from './eval-store';
+import { readFirstPendingQuestionForDisplay, pendingQuestionRecorderStatus } from './plan-count-pending-question';
+import type { NativePlanQuestion, NativePlanQuestionCall } from './plan-count-transcript';
+
+export const NATIVE_AUQ_CAPTURE_MS = 240_000;
+// close() reserves at most two seconds for SIGINT and one for SIGKILL.
+const CLEANUP_MS = 3_000;
+
+export interface NativeAuqCaptureOptions {
+  planDir: string;
+  skillName: string;
+  scenario: string;
+  testName: string;
+  runId?: string;
+  model?: string;
+}
+
+export interface NativeAuqCapture {
+  outcome: 'question_captured';
+  workflowCompleted: false;
+  source: 'pre_tool_use';
+  sessionId: string;
+  toolUseId: string;
+  questionIndex: number;
+  question: NativePlanQuestion;
+  publicCall: NativePlanQuestionCall;
+  text: string;
+  artifactDir?: string;
+}
+
+/** Neutral separators only: every graded word must come from this one question. */
+export function serializeNativeAuq(question: NativePlanQuestion): string {
+  return [question.header, question.question,
+    ...question.options.map(option => [option.label, option.description].filter(value => value !== undefined).join('\n')),
+  ].join('\n\n');
+}
+
+/** Counting tolerates damaged labels; format capture must reject visible contradictions. */
+function nativeOptionLabelsAgree(screen: string, question: NativePlanQuestion): boolean {
+  const rows = screen.replace(/\r+\n?/g, '\n').split('\n');
+  const cursorRow = rows.findLastIndex(row => /❯\s*1\./.test(row));
+  if (cursorRow < 0) return false;
+  const menu = rows.slice(cursorRow);
+  const width = (text: string) => Bun.stringWidth(text);
+  const left = (text: string, columns: number) => {
+    let result = '', used = 0;
+    for (const char of text) {
+      const next = width(char);
+      if (used + next > columns || used >= columns) break;
+      result += char; used += next;
+    }
+    return result;
+  };
+  // Strip only an actual aligned preview box, not a literal bar inside a label.
+  let previewColumn: number | undefined;
+  for (let top = 0; top < menu.length; top++) {
+    const box = /┌─+┐\s*$/.exec(menu[top]!);
+    if (!box || box.index === 0) continue;
+    const column = width(menu[top]!.slice(0, box.index));
+    const bottom = menu.findIndex((row, i) => i > top &&
+      row.slice(left(row,column).length).trim() === box[0].trim().replace('┌','└').replace('┐','┘'));
+    if (bottom > top + 1 && menu.slice(top + 1,bottom).every(row =>
+      /^│[^\n]*│\s*$/.test(row.slice(left(row,column).length)))) {
+      previewColumn = column; break;
+    }
+  }
+  const labelRows = menu.map(row => {
+    if (previewColumn === undefined) return row;
+    const prefix = left(row,previewColumn), sidebar = row.slice(prefix.length);
+    return /^(?:[┌│└]|Notes: press n to add notes\s*$)/.test(sidebar) ? prefix.trimEnd() : row;
+  });
+  const options = parseNumberedOptions(labelRows.join('\n'));
+  const optionRow = /^[ \t]{0,3}(?:❯\s*)?([1-9])\.\s*(.*)$/;
+  // The shared parser requires two choices. A single remaining visible choice
+  // can still explicitly contradict its indexed native label.
+  for (const row of labelRows) {
+    const match = optionRow.exec(row);
+    if (match && !options.some(option => option.index === Number(match[1]))) {
+      options.push({index:Number(match[1]),label:match[2]!.trim()});
+    }
+  }
+  const compact = (text: string) => text.replace(/\s+/g,'');
+  const label = (text: string) => compact(question.multiSelect ? text.replace(/^\[[ ✓✔xX]\]\s*/,'') : text);
+  return options.every(option => {
+    const expected = question.options[option.index - 1];
+    if (!expected) return /^(?:Typesomething\.?|Chataboutthis)$/.test(compact(option.label));
+    let shown = label(option.label), wanted = compact(expected.label);
+    if (!shown || shown === wanted) return true;
+    if (/(?:…|\.\.\.)$/.test(shown)) {
+      const prefix = shown.replace(/(?:…|\.\.\.)$/,'');
+      return !prefix || wanted.startsWith(prefix);
+    }
+    if (!wanted.startsWith(shown)) return false;
+    const start = labelRows.findIndex(row => {
+      const match = optionRow.exec(row);
+      return match && Number(match[1]) === option.index;
+    });
+    if (start < 0) return false;
+    let last = start;
+    for (let i = start + 1; i < labelRows.length && /^[ \t]{4,}\S/.test(labelRows[i]!); i++) {
+      const next = compact(labelRows[i]!.trim());
+      if (!wanted.startsWith(shown + next)) return false;
+      shown += next; last = i;
+      if (shown === wanted) return true;
+    }
+    // Prefix-only equality requires visible clipping at the actual 120-column
+    // viewport edge; a shorter complete row such as Keep != Keep current fails.
+    return width(menu[last]!.trimEnd()) === 120 && wanted.startsWith(shown);
+  });
+}
+
+/** The native UI can clip a tall pane's top and elide its tail simultaneously. */
+function clippedElidedNativeAuqIdentity(screen: string, call: NativePlanQuestionCall):
+  {indices:number[]; packetBar:boolean} | undefined {
+  const visible = screen.replace(/\r+\n?/g, '\n');
+  const cursor = [...visible.matchAll(/^❯\s*1\./gm)].at(-1);
+  if (!cursor) return undefined;
+  // Native panes can leave blank outer margin rows when the header scrolls
+  // away. Remove only that margin; internal/unboxed rows remain evidence.
+  let before = visible.slice(0,cursor.index).replace(/^(?:[ \t]*\n)+/,'').trimEnd();
+  const bar = call.questions.length > 1
+    ? /^←[^\n]*[☐☒][^\n]*✔[ \t]*Submit[ \t]*→[ \t]*\n/.exec(before) : null;
+  if (bar) before = before.slice(bar[0].length).replace(/^(?:[ \t]*\n)+/,'');
+  const rows = before.split('\n');
+  // Only the actual viewport's boxed question body qualifies. Do not strip a
+  // foreign header, quoted output, or prose prefix to manufacture a match.
+  if (rows.length < 2 || !/^[ \t]*[│┃](?: |$)/.test(rows[0]!) || /[☐□❯]/.test(before)) return undefined;
+  // Once the clipped boxed body starts, every interior row belongs to it.
+  // Counting may normalize blank rows; capture cannot discard that contradiction.
+  if (rows.some(row => !/^[ \t]*[│┃](?: |$)/.test(row))) return {indices:[],packetBar:!!bar};
+  const body = rows.map(row => row.replace(/^[ \t]*[│┃] ?/,'')).join('\n').trimEnd();
+  if (!body.endsWith('…')) return undefined;
+  const compact = (value: string) => value.replace(/\s+/g,'');
+  const fragment = compact(body.slice(0,-1));
+  if (fragment.length < 160) return undefined;
+  const menu = visible.slice(cursor.index);
+  const footer = call.questions.length > 1
+    ? /(?:^|\n)Enter\s*to\s*select\s*·\s*Tab\/Arrow\s*keys\s*to\s*navigate\s*·\s*Esc\s*to\s*cancel[\s│┃─━└┘]*$/.exec(menu)
+    : /(?:^|\n)Enter\s*to\s*select\s*·\s*↑\/↓\s*to\s*navigate\s*·\s*(?:n\s*to\s*add\s*notes\s*·\s*)?Esc\s*to\s*cancel[\s│┃─━└┘]*$/.exec(menu);
+  // Once this boxed/elided shape is recognized, an incompatible
+  // footer is contradictory evidence, not permission to try another route.
+  if (!footer) return {indices:[],packetBar:!!bar};
+  // Inspect every displayed row, including an out-of-order control that the
+  // shared parser intentionally omits when its contiguous menu ends.
+  const options = [...menu.matchAll(/^[ \t]{0,3}(?:❯[ \t]*)?([0-9]+)\.[ \t]*(.*)$/gm)]
+    .map(match => ({index:Number(match[1]),label:match[2]!}));
+  const matches = call.questions.flatMap((question,questionIndex) => {
+    const offered = options.slice(0,question.options.length);
+    const controls = options.slice(question.options.length);
+    const exactMenu = offered.length === question.options.length && offered.every((option,index) =>
+      option.index === index + 1 && compact(option.label) === compact(question.options[index]!.label)) &&
+      controls.length <= 2 && controls.every((option,index) =>
+        option.index === question.options.length + index + 1 &&
+        (index === 0 ? /^Typesomething\.?$/ : /^Chataboutthis$/).test(compact(option.label)));
+    if (!exactMenu) return [];
+    const native = compact(question.question);
+    // A literal terminal ellipsis can also be complete-body/suffix evidence.
+    // Count that candidate alongside elided candidates, before either route
+    // can select a different member of the same packet.
+    if (bar ? native === compact(body) : native.endsWith(compact(body))) return [questionIndex];
+    const start = native.indexOf(fragment);
+    if (start < 0 || start + fragment.length >= native.length) return [];
+    // Repeated visible segments remain ambiguous, not an absent candidate
+    // that would let another packet member win by default.
+    return native.indexOf(fragment,start + 1) === -1 ? [questionIndex] : [questionIndex,questionIndex];
+  });
+  return {indices:matches,packetBar:!!bar};
+}
+
+/** Project a verified complete body; null rejects contradictory boxed evidence. */
+function unboxCompleteNativeAuqBody(screen: string, call: NativePlanQuestionCall): string | null | undefined {
+  // Packets already have their own body projection and unique-tab matching.
+  // A singleton header must never provide a new route into a packet.
+  if (call.questions.length !== 1) return undefined;
+  const visible=screen.replace(/\r+\n?/g,'\n');
+  const cursor=[...visible.matchAll(/^❯\s*1\./gm)].at(-1);
+  if (!cursor) return undefined;
+  const before=visible.slice(0,cursor.index);
+  const header=[...before.matchAll(/(?:^|\n)[ \t]*[☐□]([^\n│]*)\n/g)].at(-1);
+  if (!header) return undefined;
+  const compact=(value:string)=>value.replace(/\s+/g,'');
+  const question=call.questions[0]!;
+  const bodyStart=header.index+header[0].length;
+  const bodySpan=before.slice(bodyStart);
+  const rows=bodySpan.replace(/^(?:[ \t]*\n)+/,'').trimEnd().split('\n');
+  if (!/^[ \t]*[│┃](?: |$)/.test(rows[0]!)) return undefined;
+  if (compact(header[1]!)!==compact(question.header) || rows.some(row=>!/^[ \t]*[│┃](?: |$)/.test(row))) return null;
+  // A complete boxed pane must pass this capture-specific check before the
+  // broader counting parser. Only a genuinely elided body uses its other route.
+  const body=rows.map(row=>row.replace(/^[ \t]*[│┃] ?/,'')).join('\n');
+  if (!compact(body) || compact(body)!==compact(question.question)) return body.endsWith('…') ? undefined : null;
+  // Ordinary prior public output is outside the pane only when separated by
+  // the native horizontal rule. A quoted/fenced pane is not display evidence.
+  const prefix=before.slice(0,header.index).trimEnd();
+  if (prefix && (!/^[─━]{20,}$/.test(prefix.split('\n').at(-1)!) ||
+      /(?:^|\n)[ \t]*(?:>|```)/.test(prefix))) return null;
+  // Strip exactly one framing prefix, preserving literal box characters in
+  // the actual question. No size threshold: malformed short briefs need grades.
+  const menu=visible.slice(cursor.index);
+  if (!/(?:^|\n)Enter\s*to\s*select\s*·\s*↑\/↓\s*to\s*navigate\s*·\s*(?:n\s*to\s*add\s*notes\s*·\s*)?Esc\s*to\s*cancel[\s│┃─━└┘]*$/.test(menu)) return null;
+  const options=[...menu.matchAll(/^[ \t]{0,3}(?:❯[ \t]*)?([0-9]+)\.[ \t]*(.*)$/gm)]
+    .map(match=>({index:Number(match[1]),label:match[2]!}));
+  const offered=options.slice(0,question.options.length), controls=options.slice(question.options.length);
+  if (offered.length!==question.options.length || offered.some((option,index)=>option.index!==index+1 || !option.label.trim()) ||
+      controls.length>2 || controls.some((option,index)=>option.index!==question.options.length+index+1 ||
+        !(index===0?/^Typesomething\.?$/:/^Chataboutthis$/).test(compact(option.label))) ||
+      !nativeOptionLabelsAgree(visible,question)) return null;
+  return visible.slice(0,bodyStart)+bodySpan.replace(/^[ \t]*[│┃] ?/gm,'')+visible.slice(cursor.index);
+}
+
+/** A hook payload alone, screen prose, or a different packet is not a capture. */
+export function displayedNativeAuq(screen: string, call: NativePlanQuestionCall | undefined):
+  {question: NativePlanQuestion; questionIndex: number} | undefined {
+  if (!call || call.answered || call.failed) return undefined;
+  const clipped = clippedElidedNativeAuqIdentity(screen,call);
+  const uniqueFirst = clipped?.indices.length === 1 && clipped.indices[0] === 0;
+  // Question identity must be unique across complete and elided body routes;
+  // an early shared match must not bypass a contradictory second candidate.
+  if (clipped && !uniqueFirst) return undefined;
+  const unboxed=unboxCompleteNativeAuqBody(screen,call);
+  if (unboxed===null) return undefined;
+  const matched = capturePlanCountQuestion(unboxed ?? screen, new Set(), 0, false, call);
+  // Never use the screen-only fallback. The additional native-only branch
+  // proves the observed combined clipping mode from this same owned payload.
+  // A visible tab bar keeps its existing route; its parsed body above is only
+  // additional ambiguity rejection, never a new route to accept another tab.
+  if (!matched?.nativeCall && (!uniqueFirst || clipped?.packetBar)) return undefined;
+  const questionIndex = matched?.nativeCall ? matched.nativeQuestionIndex ?? 0 : 0;
+  if (questionIndex !== 0) return undefined; // A later tab cannot replace the first question.
+  const question = call.questions[questionIndex];
+  return question && nativeOptionLabelsAgree(screen, question) ? {question, questionIndex} : undefined;
+}
+
+/** Read only a public CLI error panel; never inspect private journal blocks. */
+export function nativeAuqPublicError(screen: string): string | undefined {
+  const match = /(?:^|\n)[\t │┃]*(?:[⎿●⏺]\s*)?API Error:[\s\S]*/i.exec(screen);
+  return match?.[0].trim().slice(0, 2000);
+}
+
+/** The current viewport only, never terminal history or a model transcript. */
+export function nativeAuqViewport(screen: string): {viewport:string; viewportTruncated:boolean} {
+  const limit = 16_384;
+  return {viewport:screen.slice(-limit), viewportTruncated:screen.length > limit};
+}
+
+export async function captureNativeFirstAuq(opts: NativeAuqCaptureOptions): Promise<NativeAuqCapture> {
+  const startedAt = Date.now();
+  const deadline = startedAt + NATIVE_AUQ_CAPTURE_MS - CLEANUP_MS;
+  const cwd = path.resolve(opts.planDir);
+  const model = resolveEvalModel('capture', opts.model);
+  const sessionId = randomUUID();
+  const runId = opts.runId || process.env.EVALS_RUN_ID || `local-${sessionId}`;
+  let session: ClaudePtySession | undefined;
+  let ownedRoot: string | undefined;
+  let artifactDir: string | undefined;
+  let artifactRoot: string | undefined;
+  let outcome = 'error';
+  let diagnostic: string | undefined;
+  let captured: NativeAuqCapture | undefined;
+  let pendingPublicCall: NativePlanQuestionCall | undefined;
+  let viewport: ReturnType<typeof nativeAuqViewport> | undefined;
+  let viewportAt: string | undefined;
+  let displayMatched = false;
+  let pendingRecorder: ReturnType<typeof pendingQuestionRecorderStatus> | undefined;
+
+  const observeViewport = async (): Promise<string> => {
+    const screen = await session!.currentScreen();
+    viewport = nativeAuqViewport(screen);
+    viewportAt = new Date().toISOString();
+    return screen;
+  };
+
+  const fail = (reason: string, detail?: string): never => {
+    outcome = reason;
+    diagnostic = detail;
+    throw new Error(`${opts.testName}: AUQ capture failed (${reason})${detail ? `: ${detail}` : ''}`);
+  };
+  try {
+    if (!isHermeticEnabled()) fail('hermetic_required');
+    if (process.env.GSTACK_EVAL_DIR || process.env.EVALS_RUN_ID || opts.runId) {
+      const segment = (value: string) => value.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 120) || 'run';
+      // Resolve the optional store inside the operation budget, before launch.
+      artifactRoot = path.resolve(process.env.GSTACK_EVAL_DIR || getProjectEvalDir(), 'native-auq', segment(runId));
+    }
+    // This invocation owns its session/config. Only this fresh recorder's exact
+    // public PreToolUse fields are read; its parent JSONL is never opened.
+    ownedRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-native-auq-'));
+    const configDir = path.join(ownedRoot, '.claude');
+    const stateDir = path.join(ownedRoot, 'gstack-home');
+    fs.mkdirSync(configDir);
+    fs.mkdirSync(stateDir);
+    fs.writeFileSync(path.join(configDir, '.claude.json'), JSON.stringify(buildSeedConfig({
+      apiKey: process.env.ANTHROPIC_API_KEY ?? process.env.GSTACK_ANTHROPIC_API_KEY,
+      trustedDirs: [cwd],
+    })), {mode:0o600});
+    const skillPath = path.join(cwd, opts.skillName, 'SKILL.md');
+    const prompt = `The ONLY skill file you may read is this absolute path: ${skillPath}. Do NOT search for, Glob, find, or read any other SKILL.md anywhere — especially nothing under ~/.claude or /Users.
+
+Read ${skillPath} and follow its workflow for this scenario:
+
+${opts.scenario}
+
+Skip any system-audit / environment-setup / codebase-exploration steps. At the first decision requiring user input, ask the user through the AskUserQuestion tool and wait for their answer.`;
+    session = await launchClaudePty({
+      // Explicit tool approvals suffice. Bypass mode introduces a separate
+      // safety-consent screen in a fresh CLI config; never accept that screen.
+      cwd, model, seedSkills: false, permissionMode: 'default',
+      observeScreen: true, observeSetupQuestions: true,
+      timeoutMs: Math.max(1, deadline - Date.now()),
+      // Explicit availability as well as approval: no Bash/Agent/Skill or MCP.
+      // The positional prompt starts a real interactive turn, without a boot
+      // sleep, hypothetical output request, or synthetic answer submission.
+      extraArgs: ['--tools', 'Read,Write,AskUserQuestion', '--allowed-tools', 'Read,Write,AskUserQuestion',
+        '--session-id', sessionId, prompt],
+      env: {CLAUDE_CONFIG_DIR: configDir, GSTACK_HOME: stateDir, GSTACK_HEADLESS: ''},
+    });
+    if (session.hermeticConfigDir !== configDir || !session.pendingQuestionFile) fail('missing_observer');
+    while (Date.now() < deadline) {
+      const screen = await observeViewport();
+      const call = readFirstPendingQuestionForDisplay(session.pendingQuestionFile, cwd, configDir, startedAt, sessionId);
+      if (call) pendingPublicCall = call;
+      pendingRecorder = pendingQuestionRecorderStatus(session.pendingQuestionFile, cwd, configDir);
+      const publicError = nativeAuqPublicError(screen);
+      if (publicError) fail('error_api', publicError);
+      if (session.exited()) fail(`exit_code_${session.exitCode() ?? 'unknown'}`);
+      if (pendingRecorder.status === 'invalid') fail('invalid_capture', pendingRecorder.reason);
+      const displayed = displayedNativeAuq(screen, call);
+      if (displayed && call) {
+        captured = {outcome:'question_captured', workflowCompleted:false, source:'pre_tool_use',
+          sessionId, toolUseId:call.toolUseId, ...displayed, publicCall:call,
+          text:serializeNativeAuq(displayed.question)};
+        displayMatched = true;
+        outcome = captured.outcome;
+        break;
+      }
+      await Bun.sleep(Math.min(50, Math.max(0, deadline - Date.now())));
+    }
+    if (!captured) {
+      // Refresh the final public frame before shutdown; a startup/permission
+      // screen is useful timeout evidence even when no AUQ hook ever fired.
+      const screen = await observeViewport();
+      const call = readFirstPendingQuestionForDisplay(session.pendingQuestionFile, cwd, configDir, startedAt, sessionId);
+      if (call) pendingPublicCall = call;
+      pendingRecorder = pendingQuestionRecorderStatus(session.pendingQuestionFile, cwd, configDir);
+      const publicError = nativeAuqPublicError(screen);
+      if (publicError) fail('error_api', publicError);
+      fail('timeout');
+    }
+  } catch (error) {
+    if (outcome === 'error') diagnostic = String(error);
+    throw error;
+  } finally {
+    // Deliberate cutoff after a displayed question is not workflow completion.
+    let cleanupError: string | undefined;
+    let artifactError: string | undefined;
+    try { await session?.close(); } catch (error) { cleanupError = String(error); }
+    try { if (ownedRoot) fs.rmSync(ownedRoot, {recursive:true, force:true}); }
+    catch (error) { cleanupError = [cleanupError, String(error)].filter(Boolean).join('; '); }
+    if (captured && cleanupError) outcome = 'cleanup_error';
+    // Persist only supported public fields. No terminal history or transcript
+    // is retained, and no partial artifact can supply a later invocation.
+    try {
+      if (artifactRoot) {
+        const segment = (value: string) => value.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 120) || 'run';
+        fs.mkdirSync(artifactRoot, {recursive:true, mode:0o700});
+        artifactDir = fs.mkdtempSync(path.join(artifactRoot, `${segment(opts.testName)}-`));
+        fs.writeFileSync(path.join(artifactDir, 'capture.json'), JSON.stringify({
+          ...captured, pendingPublicCall, ...viewport, viewportAt, displayMatched, pendingRecorder,
+          outcome, workflowCompleted:false, diagnostic, cleanupError, testName:opts.testName,
+          skillName:opts.skillName, model, runId, sessionId, cwd,
+          // Native display capture does not expose a terminal billing result.
+          billing:'unavailable',
+          elapsedMs:Date.now() - startedAt, at:new Date().toISOString(),
+        }, null, 2) + '\n', {mode:0o600});
+      }
+    } catch (error) { artifactError = String(error); }
+    if (captured && artifactError) outcome = 'artifact_error';
+    console.log(`[AUQ-native ${opts.testName}] outcome=${outcome} workflowCompleted=false`
+      + (artifactDir ? ` artifact=${artifactDir}` : '')
+      + (artifactError ? ` artifactError=${artifactError}` : '')
+      + (cleanupError ? ` cleanupError=${cleanupError}` : ''));
+    // Keep the original refusal/crash/timeout primary when diagnostics fail.
+    if (captured && (cleanupError || artifactError)) {
+      throw new Error(`${opts.testName}: AUQ capture failed (${outcome}): ${cleanupError || artifactError}`);
+    }
+  }
+  return {...captured!, artifactDir};
+}