@jaimevalasek/aioson 1.30.2 → 1.36.0

package/src/commands/agent-epilogue.js

@@ -1,186 +1,251 @@
-'use strict';
-
-const path = require('node:path');
-const { runPulseUpdate } = require('./pulse-update');
-const { runDossierAddFinding } = require('./dossier');
-const { runGateApprove } = require('./gate-approve');
-const { runAgentDone } = require('./runtime');
-
-function resolveTargetDir(args) {
-  return path.resolve(process.cwd(), args[0] || '.');
-}
-
-function normalizeAgent(value) {
-  return String(value || '').trim().replace(/^@/, '');
-}
-
-function normalizeList(value) {
-  if (!value) return [];
-  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
-  return String(value).split(',').map((item) => item.trim()).filter(Boolean);
-}
-
-function makeSilentLogger() {
-  return { log() {}, error() {}, warn() {} };
-}
-
-function pushStep(steps, name, result) {
-  steps.push({
-    name,
-    ok: Boolean(result && result.ok),
-    skipped: Boolean(result && result.skipped),
-    reason: result && (result.reason || result.error || null)
-  });
-}
-
-function formatAutoAdvance(autoAdvance) {
-  if (!autoAdvance) return null;
-  if (autoAdvance.advanced) {
-    const nextStage = autoAdvance.result && (autoAdvance.result.next || autoAdvance.result.nextStage);
-    return `workflow auto-advanced${nextStage ? ` -> ${nextStage}` : ''}`;
-  }
-  return `workflow skip: ${autoAdvance.skipped || 'not_advanced'}`;
-}
-
-async function runAgentEpilogue({ args, options = {}, logger, t }) {
-  const targetDir = resolveTargetDir(args);
-  const agent = normalizeAgent(options.agent);
-  const summary = String(options.summary || options.message || '').trim();
-  const feature = options.feature ? String(options.feature).trim() : null;
-  const action = options.action ? String(options.action).trim() : summary;
-  const next = options.next ? String(options.next).trim() : null;
-  const gate = options.gate ? String(options.gate).trim() : null;
-  const approveGate = options['approve-gate'] || options.approveGate
-    ? String(options['approve-gate'] || options.approveGate).trim().toUpperCase()
-    : null;
-  const verdict = options.verdict ? String(options.verdict).trim().toUpperCase() : null;
-  const artifacts = normalizeList(options.artifacts);
-  const strict = Boolean(options.strict);
-  const steps = [];
-  const errors = [];
-  const silentLogger = makeSilentLogger();
-
-  if (!agent) {
-    const failure = { ok: false, reason: 'missing_agent' };
-    if (options.json) return failure;
-    logger.error('--agent=<agent> is required.');
-    return failure;
-  }
-
-  if (!summary) {
-    const failure = { ok: false, reason: 'missing_summary' };
-    if (options.json) return failure;
-    logger.error('--summary="<summary>" is required.');
-    return failure;
-  }
-
-  if (approveGate) {
-    const gateResult = await runGateApprove({
-      args: [targetDir],
-      options: {
-        feature,
-        gate: approveGate,
-        agent,
-        json: true
-      },
-      logger: silentLogger
-    });
-    pushStep(steps, 'gate:approve', gateResult);
-    if (!gateResult.ok) {
-      errors.push({ step: 'gate:approve', reason: gateResult.reason || 'gate_failed', result: gateResult });
-      if (strict) {
-        const failure = { ok: false, reason: 'gate_approve_failed', steps, errors };
-        if (options.json) return failure;
-        logger.error(`agent:epilogue blocked: gate ${approveGate} approval failed.`);
-        return failure;
-      }
-    }
-  }
-
-  if (!options['no-pulse'] && !options.noPulse) {
-    const pulseResult = await runPulseUpdate({
-      args: [targetDir],
-      options: {
-        agent,
-        ...(feature ? { feature } : {}),
-        ...(gate || approveGate ? { gate: gate || `Gate ${approveGate}: approved` } : {}),
-        ...(action ? { action } : {}),
-        ...(next ? { next } : {}),
-        ...(verdict ? { verdict } : {}),
-        json: true
-      },
-      logger: silentLogger
-    });
-    pushStep(steps, 'pulse:update', pulseResult);
-    if (!pulseResult.ok) {
-      errors.push({ step: 'pulse:update', reason: pulseResult.reason || 'pulse_failed', result: pulseResult });
-    }
-  } else {
-    pushStep(steps, 'pulse:update', { ok: true, skipped: true, reason: 'disabled' });
-  }
-
-  if (feature && !options['no-dossier'] && !options.noDossier) {
-    const dossierResult = await runDossierAddFinding({
-      args: [targetDir],
-      options: {
-        slug: feature,
-        agent,
-        section: options.section ? String(options.section) : 'Agent Trail',
-        content: options.content ? String(options.content) : summary,
-        json: true
-      },
-      logger: silentLogger
-    });
-    pushStep(steps, 'dossier:add-finding', dossierResult);
-    if (!dossierResult.ok) {
-      errors.push({ step: 'dossier:add-finding', reason: dossierResult.reason || 'dossier_failed', result: dossierResult });
-    }
-  } else {
-    pushStep(steps, 'dossier:add-finding', { ok: true, skipped: true, reason: feature ? 'disabled' : 'missing_feature' });
-  }
-
-  const doneResult = await runAgentDone({
-    args: [targetDir],
-    options: {
-      agent,
-      summary,
-      ...(feature ? { feature } : {}),
-      ...(verdict ? { verdict } : {}),
-      ...(artifacts.length > 0 ? { artifacts: artifacts.join(',') } : {}),
-      json: true
-    },
-    logger: silentLogger,
-    t
-  });
-  pushStep(steps, 'agent:done', doneResult);
-  if (!doneResult.ok) {
-    errors.push({ step: 'agent:done', reason: doneResult.reason || doneResult.error || 'agent_done_failed', result: doneResult });
-  }
-
-  const ok = doneResult.ok && (strict ? errors.length === 0 : !errors.some((error) => error.step === 'agent:done'));
-  const result = {
-    ok,
-    targetDir,
-    agent: `@${agent}`,
-    feature,
-    summary,
-    steps,
-    errors,
-    agent_done: doneResult
-  };
-
-  if (options.json) return result;
-
-  logger.log(`agent:epilogue — @${agent} (${ok ? 'ok' : 'issues'})`);
-  for (const step of steps) {
-    const marker = step.skipped ? 'skip' : step.ok ? 'ok' : 'fail';
-    logger.log(`  ${marker} ${step.name}${step.reason ? ` (${step.reason})` : ''}`);
-  }
-  const autoAdvanceMessage = formatAutoAdvance(doneResult.auto_advance);
-  if (autoAdvanceMessage) logger.log(`  ${autoAdvanceMessage}`);
-  return result;
-}
-
-module.exports = {
-  runAgentEpilogue
-};
+'use strict';
+
+const path = require('node:path');
+const { runPulseUpdate } = require('./pulse-update');
+const { runDossierAddFinding } = require('./dossier');
+const { runGateApprove } = require('./gate-approve');
+const { runAgentDone } = require('./runtime');
+
+function resolveTargetDir(args) {
+  return path.resolve(process.cwd(), args[0] || '.');
+}
+
+function normalizeAgent(value) {
+  return String(value || '').trim().replace(/^@/, '');
+}
+
+function normalizeList(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.map(String).map((item) => item.trim()).filter(Boolean);
+  return String(value).split(',').map((item) => item.trim()).filter(Boolean);
+}
+
+function makeSilentLogger() {
+  return { log() {}, error() {}, warn() {} };
+}
+
+function pushStep(steps, name, result) {
+  steps.push({
+    name,
+    ok: Boolean(result && result.ok),
+    skipped: Boolean(result && result.skipped),
+    reason: result && (result.reason || result.error || null)
+  });
+}
+
+function formatAutoAdvance(autoAdvance) {
+  if (!autoAdvance) return null;
+  if (autoAdvance.advanced) {
+    const nextStage = autoAdvance.result && (autoAdvance.result.next || autoAdvance.result.nextStage);
+    return `workflow auto-advanced${nextStage ? ` -> ${nextStage}` : ''}`;
+  }
+  return `workflow skip: ${autoAdvance.skipped || 'not_advanced'}`;
+}
+
+async function runAgentEpilogue({ args, options = {}, logger, t }) {
+  const targetDir = resolveTargetDir(args);
+  const agent = normalizeAgent(options.agent);
+  const summary = String(options.summary || options.message || '').trim();
+  const feature = options.feature ? String(options.feature).trim() : null;
+  const action = options.action ? String(options.action).trim() : summary;
+  const next = options.next ? String(options.next).trim() : null;
+  const gate = options.gate ? String(options.gate).trim() : null;
+  const approveGate = options['approve-gate'] || options.approveGate
+    ? String(options['approve-gate'] || options.approveGate).trim().toUpperCase()
+    : null;
+  const verdict = options.verdict ? String(options.verdict).trim().toUpperCase() : null;
+  const artifacts = normalizeList(options.artifacts);
+  const strict = Boolean(options.strict);
+  const steps = [];
+  const errors = [];
+  const silentLogger = makeSilentLogger();
+
+  if (!agent) {
+    const failure = { ok: false, reason: 'missing_agent' };
+    if (options.json) return failure;
+    logger.error('--agent=<agent> is required.');
+    return failure;
+  }
+
+  if (!summary) {
+    const failure = { ok: false, reason: 'missing_summary' };
+    if (options.json) return failure;
+    logger.error('--summary="<summary>" is required.');
+    return failure;
+  }
+
+  if (approveGate) {
+    const gateResult = await runGateApprove({
+      args: [targetDir],
+      options: {
+        feature,
+        gate: approveGate,
+        agent,
+        json: true
+      },
+      logger: silentLogger
+    });
+    pushStep(steps, 'gate:approve', gateResult);
+    if (!gateResult.ok) {
+      errors.push({ step: 'gate:approve', reason: gateResult.reason || 'gate_failed', result: gateResult });
+      if (strict) {
+        const failure = { ok: false, reason: 'gate_approve_failed', steps, errors };
+        if (options.json) return failure;
+        logger.error(`agent:epilogue blocked: gate ${approveGate} approval failed.`);
+        return failure;
+      }
+    }
+  }
+
+  if (!options['no-pulse'] && !options.noPulse) {
+    const pulseResult = await runPulseUpdate({
+      args: [targetDir],
+      options: {
+        agent,
+        ...(feature ? { feature } : {}),
+        ...(gate || approveGate ? { gate: gate || `Gate ${approveGate}: approved` } : {}),
+        ...(action ? { action } : {}),
+        ...(next ? { next } : {}),
+        ...(verdict ? { verdict } : {}),
+        json: true
+      },
+      logger: silentLogger
+    });
+    pushStep(steps, 'pulse:update', pulseResult);
+    if (!pulseResult.ok) {
+      errors.push({ step: 'pulse:update', reason: pulseResult.reason || 'pulse_failed', result: pulseResult });
+    }
+  } else {
+    pushStep(steps, 'pulse:update', { ok: true, skipped: true, reason: 'disabled' });
+  }
+
+  if (feature && !options['no-dossier'] && !options.noDossier) {
+    const dossierResult = await runDossierAddFinding({
+      args: [targetDir],
+      options: {
+        slug: feature,
+        agent,
+        section: options.section ? String(options.section) : 'Agent Trail',
+        content: options.content ? String(options.content) : summary,
+        json: true
+      },
+      logger: silentLogger
+    });
+    pushStep(steps, 'dossier:add-finding', dossierResult);
+    if (!dossierResult.ok) {
+      errors.push({ step: 'dossier:add-finding', reason: dossierResult.reason || 'dossier_failed', result: dossierResult });
+    }
+  } else {
+    pushStep(steps, 'dossier:add-finding', { ok: true, skipped: true, reason: feature ? 'disabled' : 'missing_feature' });
+  }
+
+  const doneResult = await runAgentDone({
+    args: [targetDir],
+    options: {
+      agent,
+      summary,
+      ...(feature ? { feature } : {}),
+      ...(verdict ? { verdict } : {}),
+      ...(artifacts.length > 0 ? { artifacts: artifacts.join(',') } : {}),
+      json: true
+    },
+    logger: silentLogger,
+    t
+  });
+  pushStep(steps, 'agent:done', doneResult);
+  if (!doneResult.ok) {
+    errors.push({ step: 'agent:done', reason: doneResult.reason || doneResult.error || 'agent_done_failed', result: doneResult });
+  }
+
+  // Surface the advisory artifact done-gate that agent:done resolved for this
+  // agent (peripheral artifact-producing agents only; null otherwise). Advisory:
+  // a skipped/failed check is shown but never added to `errors`, so it cannot
+  // flip `ok`.
+  if (doneResult && doneResult.verify_artifact) {
+    const va = doneResult.verify_artifact;
+    pushStep(steps, 'verify:artifact', { ok: va.skipped ? true : va.ok, skipped: va.skipped, reason: va.reason });
+  }
+
+  // Advisory contract-integrity signal for untracked (prompt-only) dev/qa
+  // completions. The tracked `workflow:next --complete` / `feature:close` paths
+  // enforce this as a HARD gate; a direct Claude Code session never calls them,
+  // so we surface the same signal here without blocking the best-effort
+  // epilogue (never added to `errors`, so it cannot flip `ok`).
+  if ((agent === 'dev' || agent === 'qa') && feature) {
+    let advisory = null;
+    try {
+      const { evaluateContractIntegrityGate } = require('../harness/contract-integrity-gate');
+      advisory = await evaluateContractIntegrityGate(targetDir, feature, { runChecks: false });
+    } catch {
+      advisory = null;
+    }
+    if (advisory && advisory.ok === false) {
+      pushStep(steps, 'contract:integrity', {
+        ok: false,
+        reason: `${advisory.errors.map((e) => e.code).join(', ')} — advisory only; the tracked workflow blocks on this. Run: aioson harness:check . --slug=${feature} --json`
+      });
+    } else if (advisory) {
+      pushStep(steps, 'contract:integrity', { ok: true });
+    }
+  }
+
+  // Advisory code-quality signal (audit:code) over the CHANGED files for dev/qa
+  // completions — the non-security categories (anti-patterns, TODOs, dead code,
+  // duplication). Scoped to the diff so it is about the work just done; advisory
+  // only (never added to `errors`, so it cannot flip `ok`). This is what makes the
+  // scan auto-fire in the flow instead of relying on the agent to remember to run
+  // it; @qa still treats a HIGH as a Gate-D blocker.
+  if (agent === 'dev' || agent === 'qa') {
+    let codeAudit = null;
+    try {
+      const { runAuditCode } = require('./audit-code');
+      codeAudit = await runAuditCode({
+        args: [targetDir],
+        options: { changed: true, json: true, suppressExitCode: true },
+        logger: silentLogger
+      });
+    } catch {
+      codeAudit = null;
+    }
+    if (codeAudit && codeAudit.by_severity && codeAudit.scanned_files > 0) {
+      const high = codeAudit.by_severity.HIGH || 0;
+      const med = codeAudit.by_severity.MED || 0;
+      if (high > 0) {
+        const cats = Object.keys(codeAudit.by_category || {}).join(', ');
+        pushStep(steps, 'audit:code', {
+          ok: false,
+          reason: `${high} HIGH${med ? ` / ${med} MED` : ''} in changed files (${cats}) — advisory; @qa treats HIGH as a Gate-D blocker. See .aioson/context/audit-code.json`
+        });
+      } else {
+        pushStep(steps, 'audit:code', { ok: true, reason: med ? `${med} MED advisory` : null });
+      }
+    }
+  }
+
+  const ok = doneResult.ok && (strict ? errors.length === 0 : !errors.some((error) => error.step === 'agent:done'));
+  const result = {
+    ok,
+    targetDir,
+    agent: `@${agent}`,
+    feature,
+    summary,
+    steps,
+    errors,
+    agent_done: doneResult
+  };
+
+  if (options.json) return result;
+
+  logger.log(`agent:epilogue — @${agent} (${ok ? 'ok' : 'issues'})`);
+  for (const step of steps) {
+    const marker = step.skipped ? 'skip' : step.ok ? 'ok' : 'fail';
+    logger.log(`  ${marker} ${step.name}${step.reason ? ` (${step.reason})` : ''}`);
+  }
+  const autoAdvanceMessage = formatAutoAdvance(doneResult.auto_advance);
+  if (autoAdvanceMessage) logger.log(`  ${autoAdvanceMessage}`);
+  return result;
+}
+
+module.exports = {
+  runAgentEpilogue
+};

package/src/commands/agents.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const path = require('node:path');
+const fsp = require('node:fs/promises');
 const {
   normalizeAgentName,
   listAgentDefinitions,
@@ -20,51 +21,102 @@ const { readAutonomyProtocol, resolveEffectiveMode } = require('../autonomy-poli
 const { readAgentManifest, buildAgentCapabilitySummary } = require('../agent-manifests');
 const { emitSecurityRuntimeEvent } = require('../lib/security/runtime-events');
 
-const WORKFLOW_AGENT_IDS = new Set([
-  'setup',
-  'product',
-  'analyst',
-  'scope-check',
-  'architect',
+const WORKFLOW_AGENT_IDS = new Set([
+  'setup',
+  'product',
+  'analyst',
+  'scope-check',
+  'architect',
   'ux-ui',
   'pm',
   'orchestrator',
   'dev',
-  'qa'
-]);
-const SCOPE_CHECK_MODES = new Set(['pre-dev', 'post-dev', 'post-fix', 'final']);
-
-function normalizeScopeCheckMode(input) {
-  const mode = String(input || '').trim().toLowerCase();
-  return SCOPE_CHECK_MODES.has(mode) ? mode : null;
-}
-
-function getScopeCheckModeOption(options = {}) {
-  return normalizeScopeCheckMode(
-    options.scopeMode ||
-    options['scope-mode'] ||
-    options.checkMode ||
-    options['check-mode'] ||
-    options.mode
-  );
-}
-
-function buildScopeCheckActivationContext(options = {}) {
-  const mode = getScopeCheckModeOption(options) || 'pre-dev';
-  const lines = [`Scope-check mode: ${mode}.`];
-  const featureSlug = String(options.feature || options.slug || '').trim();
-  if (featureSlug) lines.push(`Feature slug: ${featureSlug}.`);
-  if (mode === 'pre-dev') {
-    lines.push('Compare user intent against planning artifacts before implementation.');
-  } else if (mode === 'post-dev') {
-    lines.push('Compare the approved planning artifacts against the actual implementation diff and changed files before QA.');
-  } else if (mode === 'post-fix') {
-    lines.push('Compare approved scope, QA/tester/pentester findings, and correction diff; confirm the fix did not change product intent.');
-  } else if (mode === 'final') {
-    lines.push('Reconcile intent, plan, delivered behavior, and remaining exclusions before close/commit/release.');
-  }
-  return lines.join('\n');
-}
+  'qa'
+]);
+const SCOPE_CHECK_MODES = new Set(['pre-dev', 'post-dev', 'post-fix', 'final']);
+
+function normalizeScopeCheckMode(input) {
+  const mode = String(input || '').trim().toLowerCase();
+  return SCOPE_CHECK_MODES.has(mode) ? mode : null;
+}
+
+function getScopeCheckModeOption(options = {}) {
+  return normalizeScopeCheckMode(
+    options.scopeMode ||
+    options['scope-mode'] ||
+    options.checkMode ||
+    options['check-mode'] ||
+    options.mode
+  );
+}
+
+function buildScopeCheckActivationContext(options = {}) {
+  const mode = getScopeCheckModeOption(options) || 'pre-dev';
+  const lines = [`Scope-check mode: ${mode}.`];
+  const featureSlug = String(options.feature || options.slug || '').trim();
+  if (featureSlug) lines.push(`Feature slug: ${featureSlug}.`);
+  if (mode === 'pre-dev') {
+    lines.push('Compare user intent against planning artifacts before implementation.');
+  } else if (mode === 'post-dev') {
+    lines.push('Compare the approved planning artifacts against the actual implementation diff and changed files before QA.');
+  } else if (mode === 'post-fix') {
+    lines.push('Compare approved scope, QA/tester/pentester findings, and correction diff; confirm the fix did not change product intent.');
+  } else if (mode === 'final') {
+    lines.push('Reconcile intent, plan, delivered behavior, and remaining exclusions before close/commit/release.');
+  }
+  return lines.join('\n');
+}
+
+function buildTesterActivationContext(options = {}) {
+  // Lets `agent:prompt tester --feature=<slug>` pin the slug into the prompt.
+  // Without it, @tester resolves the slug via `feature:current`, which returns
+  // none once a feature is closed — so a standalone post-close test pass would
+  // wrongly fall back to project mode. An explicit slug keeps it feature-scoped.
+  const featureSlug = String(options.feature || options.slug || '').trim();
+  if (!featureSlug) return '';
+  return [
+    `Feature slug: ${featureSlug}.`,
+    `This is a standalone test pass over the already-implemented feature "${featureSlug}"; write test-plan-${featureSlug}.md and test-inventory-${featureSlug}.md.`,
+    'The feature may already be closed — do NOT fall back to project mode or pick a different slug.'
+  ].join('\n');
+}
+
+// True when the project's workflow.config.json routes @sheldon directly into
+// @dev in any sequence — i.e. the lean lane is active. Best-effort + read-only.
+async function detectLeanLaneFromConfig(targetDir) {
+  try {
+    const configPath = path.join(targetDir, '.aioson', 'context', 'workflow.config.json');
+    const config = JSON.parse(await fsp.readFile(configPath, 'utf8'));
+    const groups = [config.feature, config.project].filter((g) => g && typeof g === 'object');
+    for (const group of groups) {
+      for (const seq of Object.values(group)) {
+        if (!Array.isArray(seq)) continue;
+        const norm = seq.map((s) => String(s || '').trim().toLowerCase().replace(/^@/, ''));
+        const i = norm.indexOf('sheldon');
+        if (i !== -1 && norm[i + 1] === 'dev') return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+// Deterministic lane signal for a directly-activated @sheldon. When the project
+// opted into the lean lane (workflow.config.json routes @sheldon -> @dev) but the
+// session is started by hand (slash / agent:prompt, not workflow:next), nothing
+// otherwise tells @sheldon to run RF-LEAN — so it falls back to enrichment mode
+// and hands to @analyst. This pins the lane into the prompt so the LLM does not
+// have to infer it. Empty string ⇒ full chain (unchanged default behavior).
+async function buildSheldonActivationContext(targetDir, options) {
+  if (!(await detectLeanLaneFromConfig(targetDir))) return '';
+  const slug = String(options.feature || options.slug || '').trim() || '{slug}';
+  return [
+    'Active lane: LEAN (workflow.config.json routes @sheldon -> @dev).',
+    `Run RF-LEAN as the single spec authority — in this one pass produce requirements-${slug}.md, spec-${slug}.md (gates A/B/C marked approved), design-doc-${slug}.md, readiness-${slug}.md, implementation-plan-${slug}.md (status: approved), and the §2c RG-* harness-contract for a runtime feature.`,
+    'Hand off to @dev when done. Do NOT route to @analyst/@architect/@discovery-design-doc/@pm — they are collapsed into you in this lane.'
+  ].join('\n');
+}
 
 function normalizePentesterTargetMode(input) {
   const mode = String(input || '').trim().toLowerCase();
@@ -207,12 +259,16 @@ async function runAgentPrompt({ args, options, logger, t }) {
 
   if (!prompt) {
     instructionPath = await resolveExistingInstructionPath(targetDir, promptAgent, locale);
-    if (promptAgent.id === 'pentester') {
-      pentesterTargetMode = normalizePentesterTargetMode(options.mode);
-      activationContext = buildPentesterActivationContext(options, t);
-    } else if (promptAgent.id === 'scope-check') {
-      activationContext = buildScopeCheckActivationContext(options);
-    }
+    if (promptAgent.id === 'pentester') {
+      pentesterTargetMode = normalizePentesterTargetMode(options.mode);
+      activationContext = buildPentesterActivationContext(options, t);
+    } else if (promptAgent.id === 'scope-check') {
+      activationContext = buildScopeCheckActivationContext(options);
+    } else if (promptAgent.id === 'tester') {
+      activationContext = buildTesterActivationContext(options);
+    } else if (promptAgent.id === 'sheldon') {
+      activationContext = await buildSheldonActivationContext(targetDir, options);
+    }
     const autonomyProtocol = await readAutonomyProtocol(targetDir);
     const manifest = await readAgentManifest(targetDir, promptAgent.id);
     effectiveMode = resolveEffectiveMode({
@@ -220,7 +276,7 @@ async function runAgentPrompt({ args, options, logger, t }) {
       tool,
       agentId: promptAgent.id,
       manifest,
-      requestedMode: promptAgent.id === 'scope-check' && getScopeCheckModeOption(options) ? null : options.mode || null
+      requestedMode: promptAgent.id === 'scope-check' && getScopeCheckModeOption(options) ? null : options.mode || null
     });
     prompt = buildAgentPrompt(promptAgent, tool, {
       instructionPath,