@jaimevalasek/aioson 1.30.2 → 1.33.1

package/src/verification/ledger-store.js

@@ -0,0 +1,221 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const {
+  LEDGER_SCHEMA_VERSION,
+  validateImplementationLedger,
+  missingLedgerEvidence,
+  makeError
+} = require('./result');
+const {
+  featureContextDir,
+  verificationRunsDir,
+  resolveInsideRoot,
+  relativeFromRoot
+} = require('./path-policy');
+
+const REQUIRED_LEDGER_SECTIONS = [
+  { id: 'source_of_truth', heading: 'Source Of Truth' },
+  { id: 'intended_behavior_claims', heading: 'Intended Behavior Claims' },
+  { id: 'implementation_evidence', heading: 'Implementation Evidence' },
+  { id: 'verification_commands', heading: 'Verification Commands' },
+  { id: 'known_gaps', heading: 'Known Gaps' },
+  { id: 'handoff_notes', heading: 'Handoff Notes' },
+  { id: 'machine_ledger', heading: 'Machine Ledger' }
+];
+
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sectionPattern(heading) {
+  return new RegExp(`^##\\s+${heading.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'im');
+}
+
+function findMissingSections(content) {
+  return REQUIRED_LEDGER_SECTIONS
+    .filter((section) => !sectionPattern(section.heading).test(content))
+    .map((section) => section.id);
+}
+
+function extractJsonBlock(content, heading) {
+  const text = String(content || '');
+  const headingRe = new RegExp(`^##\\s+${heading}\\s*$`, 'im');
+  const headingMatch = headingRe.exec(text);
+  let scope = text;
+  if (headingMatch) {
+    const start = headingMatch.index + headingMatch[0].length;
+    const rest = text.slice(start);
+    const nextHeading = rest.search(/^##\s+/m);
+    scope = nextHeading === -1 ? rest : rest.slice(0, nextHeading);
+  }
+  const block = scope.match(/```json\s*([\s\S]*?)```/i);
+  return block ? block[1].trim() : null;
+}
+
+function createLedgerTemplate(slug, sourceArtifacts = []) {
+  const machine = {
+    schema_version: LEDGER_SCHEMA_VERSION,
+    feature_slug: slug,
+    source_artifacts: sourceArtifacts.map((artifact) => ({
+      type: artifact.type,
+      path: artifact.path,
+      role: artifact.role || 'source'
+    })),
+    claims: [],
+    known_gaps: [],
+    verification_commands: []
+  };
+
+  return `# Implementation Ledger - ${slug}
+
+## Source Of Truth
+
+List the PRD, requirements, spec, plan, prototype, harness, or source plan that defines this implementation.
+
+## Intended Behavior Claims
+
+List every behavior the implementation claims to satisfy. Use stable claim IDs such as \`CLAIM-001\`.
+
+## Implementation Evidence
+
+Link each claim to files, line ranges, tests, commands, or explicit N/A rationale.
+
+## Verification Commands
+
+Record commands that should be run by the developer or clean auditor. Include last known status only when actually run.
+
+## Known Gaps
+
+Record deferred, blocked, or not-applicable items with an owner and rationale.
+
+## Handoff Notes
+
+Notes for @scope-check, @qa, or a clean auditor. This ledger is evidence, not proof.
+
+## Machine Ledger
+
+\`\`\`json
+${JSON.stringify(machine, null, 2)}
+\`\`\`
+`;
+}
+
+async function prepareLedger(rootDir, slug, sourceArtifacts = []) {
+  const featureDir = featureContextDir(rootDir, slug);
+  const runsDir = verificationRunsDir(rootDir, slug);
+  const ledgerPath = path.join(featureDir, 'implementation-ledger.md');
+
+  await fs.mkdir(runsDir, { recursive: true });
+  const alreadyExists = await exists(ledgerPath);
+  if (!alreadyExists) {
+    await fs.writeFile(ledgerPath, createLedgerTemplate(slug, sourceArtifacts), 'utf8');
+  }
+
+  return {
+    ok: true,
+    feature_slug: slug,
+    ledger_path: relativeFromRoot(rootDir, ledgerPath),
+    created: !alreadyExists,
+    source_artifacts_found: sourceArtifacts.length > 0,
+    warnings: sourceArtifacts.length > 0 ? [] : ['source_artifacts_not_found']
+  };
+}
+
+async function readLedger(rootDir, slug) {
+  const ledgerPath = path.join(featureContextDir(rootDir, slug), 'implementation-ledger.md');
+  const resolved = resolveInsideRoot(rootDir, ledgerPath);
+  if (!resolved.ok) return resolved;
+  try {
+    const content = await fs.readFile(resolved.path, 'utf8');
+    return {
+      ok: true,
+      path: resolved.path,
+      relative_path: resolved.relative_path,
+      content
+    };
+  } catch {
+    return makeError('ledger_not_found', {
+      feature_slug: slug,
+      ledger_path: resolved.relative_path
+    });
+  }
+}
+
+function validateLedgerContent(content, rootDir, slug) {
+  const missingSections = findMissingSections(content);
+  if (missingSections.length > 0) {
+    return makeError('missing_ledger_sections', {
+      feature_slug: slug,
+      missing_sections: missingSections,
+      ready_for_prompt: false
+    });
+  }
+
+  const rawJson = extractJsonBlock(content, 'Machine Ledger');
+  if (!rawJson) {
+    return makeError('missing_machine_ledger', {
+      feature_slug: slug,
+      ready_for_prompt: false
+    });
+  }
+
+  let ledger;
+  try {
+    ledger = JSON.parse(rawJson);
+  } catch (error) {
+    return makeError('invalid_machine_ledger_json', {
+      feature_slug: slug,
+      detail: error.message,
+      ready_for_prompt: false
+    });
+  }
+
+  const errors = validateImplementationLedger(ledger, { rootDir, slug });
+  const claims = Array.isArray(ledger.claims) ? ledger.claims : [];
+  const missingEvidence = missingLedgerEvidence(ledger);
+
+  if (errors.length > 0) {
+    return makeError('invalid_machine_ledger', {
+      feature_slug: slug,
+      errors,
+      ready_for_prompt: false
+    });
+  }
+
+  return {
+    ok: true,
+    feature_slug: slug,
+    ledger,
+    missing_sections: [],
+    missing_evidence: missingEvidence,
+    ready_for_prompt: claims.length > 0 && missingEvidence.length === 0
+  };
+}
+
+async function checkLedger(rootDir, slug) {
+  const loaded = await readLedger(rootDir, slug);
+  if (!loaded.ok) return loaded;
+  const validation = validateLedgerContent(loaded.content, rootDir, slug);
+  return {
+    ...validation,
+    ledger_path: loaded.relative_path
+  };
+}
+
+module.exports = {
+  REQUIRED_LEDGER_SECTIONS,
+  createLedgerTemplate,
+  prepareLedger,
+  readLedger,
+  checkLedger,
+  validateLedgerContent,
+  extractJsonBlock
+};

package/src/verification/path-policy.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const path = require('node:path');
+
+const SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+function toPosixPath(value) {
+  return String(value || '').replace(/\\/g, '/');
+}
+
+function validateFeatureSlug(slug) {
+  const value = String(slug || '').trim();
+  if (!value) {
+    return { ok: false, reason: 'missing_feature' };
+  }
+  if (!SLUG_RE.test(value)) {
+    return { ok: false, reason: 'invalid_feature_slug', feature_slug: value };
+  }
+  return { ok: true, feature_slug: value };
+}
+
+function isInsideRoot(rootDir, candidatePath) {
+  const root = path.resolve(rootDir);
+  const candidate = path.resolve(candidatePath);
+  const relative = path.relative(root, candidate);
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function resolveProjectRoot(cwd, targetArg) {
+  return path.resolve(cwd || process.cwd(), targetArg || '.');
+}
+
+function resolveInsideRoot(rootDir, inputPath) {
+  if (!inputPath) {
+    return { ok: false, reason: 'missing_path' };
+  }
+  const root = path.resolve(rootDir);
+  const resolved = path.resolve(root, String(inputPath));
+  if (!isInsideRoot(root, resolved)) {
+    return {
+      ok: false,
+      reason: 'path_outside_root',
+      path: String(inputPath)
+    };
+  }
+  return {
+    ok: true,
+    path: resolved,
+    relative_path: toPosixPath(path.relative(root, resolved))
+  };
+}
+
+function relativeFromRoot(rootDir, absolutePath) {
+  return toPosixPath(path.relative(path.resolve(rootDir), path.resolve(absolutePath)));
+}
+
+function featureContextDir(rootDir, slug) {
+  return path.join(path.resolve(rootDir), '.aioson', 'context', 'features', slug);
+}
+
+function verificationRunsDir(rootDir, slug) {
+  return path.join(featureContextDir(rootDir, slug), 'verification-runs');
+}
+
+module.exports = {
+  validateFeatureSlug,
+  resolveProjectRoot,
+  resolveInsideRoot,
+  relativeFromRoot,
+  featureContextDir,
+  verificationRunsDir,
+  isInsideRoot,
+  toPosixPath
+};

package/src/verification/policy-engine.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const { normalizePolicy } = require('./result');
+
+function ownerRoute(owner) {
+  if (owner === 'product' || owner === 'scope-check') return 'product';
+  if (owner === 'sheldon') return 'sheldon';
+  if (owner === 'qa' || owner === 'tester') return 'qa';
+  if (owner === 'pentester') return 'pentester';
+  return owner || 'dev';
+}
+
+function routeForFinding(finding) {
+  const route = finding.recommended_route || ownerRoute(finding.owner);
+  if (finding.kind === 'scope_constraint' || route === 'product' || route === 'sheldon') {
+    return { verdict: 'NEEDS_SCOPE_DECISION', route: route === 'sheldon' ? 'sheldon' : 'product' };
+  }
+  if (finding.kind === 'test_coverage' || route === 'qa' || route === 'tester') {
+    return { verdict: 'NEEDS_QA_RECHECK', route: route === 'tester' ? 'tester' : 'qa' };
+  }
+  if (finding.kind === 'security_constraint' || route === 'pentester') {
+    return { verdict: 'NEEDS_SECURITY_REVIEW', route: 'pentester' };
+  }
+  return { verdict: 'NEEDS_DEV_FIX', route: route === 'deyvin' ? 'deyvin' : 'dev' };
+}
+
+function isBlockingFinding(finding, policy) {
+  if (!finding) return false;
+  if (finding.severity === 'blocking' || finding.blocks === true) return true;
+  if (policy !== 'strict') return false;
+  return ['DOES_NOT_CONFIRM', 'PARTIAL', 'NOT_VERIFIED'].includes(finding.status)
+    && [
+      'required_behavior',
+      'acceptance_criterion',
+      'prototype_contract',
+      'security_constraint'
+    ].includes(finding.kind);
+}
+
+function commandIsMissing(command) {
+  if (!command || !command.required) return false;
+  const status = String(command.status || command.last_status || '').toLowerCase();
+  return !status || ['missing', 'not_run', 'failed', 'error', 'unknown'].includes(status);
+}
+
+function applyPolicy(report, requestedPolicy) {
+  const policy = normalizePolicy(requestedPolicy || report.policy) || 'standard';
+  const findings = Array.isArray(report.findings) ? report.findings : [];
+  const commands = Array.isArray(report.commands_run) ? report.commands_run : [];
+
+  if (policy === 'strict' && commands.some(commandIsMissing)) {
+    return {
+      policy,
+      verdict: 'INCONCLUSIVE',
+      recommended_route: 'qa',
+      blocking_findings_count: findings.filter((f) => isBlockingFinding(f, policy)).length,
+      reason: 'missing_required_command'
+    };
+  }
+
+  const blockingFindings = findings.filter((finding) => isBlockingFinding(finding, policy));
+  if (blockingFindings.length > 0 && policy !== 'advisory') {
+    const routed = routeForFinding(blockingFindings[0]);
+    return {
+      policy,
+      verdict: routed.verdict,
+      recommended_route: routed.route,
+      blocking_findings_count: blockingFindings.length,
+      reason: 'blocking_findings'
+    };
+  }
+
+  if (report.verdict && report.verdict !== 'PASS') {
+    return {
+      policy,
+      verdict: report.verdict,
+      recommended_route: report.recommended_route || 'dev',
+      blocking_findings_count: blockingFindings.length,
+      reason: 'auditor_verdict'
+    };
+  }
+
+  return {
+    policy,
+    verdict: 'PASS',
+    recommended_route: report.recommended_route || 'qa',
+    blocking_findings_count: blockingFindings.length,
+    reason: 'no_blocking_findings'
+  };
+}
+
+module.exports = {
+  applyPolicy,
+  routeForFinding
+};

package/src/verification/prompt-package.js

@@ -0,0 +1,314 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const { machineReportSchemaExample } = require('./schema');
+const { verificationRunsDir, relativeFromRoot, resolveInsideRoot } = require('./path-policy');
+
+const DEFAULT_PROMPT_BUDGET_CHARS = 24000;
+
+function timestampForFile(date = new Date()) {
+  return date.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}Z$/, 'Z');
+}
+
+function asJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+function compactBundleForBudget(evidenceBundle) {
+  return {
+    ...evidenceBundle,
+    artifact_summaries: (evidenceBundle.artifact_summaries || []).map((artifact) => ({
+      type: artifact.type,
+      role: artifact.role,
+      path: artifact.path,
+      exists: artifact.exists,
+      size_bytes: artifact.size_bytes,
+      omitted_reason: artifact.omitted_reason || 'prompt_budget_compact_mode'
+    }))
+  };
+}
+
+function truncateText(value, maxChars) {
+  const text = String(value || '');
+  if (!maxChars || text.length <= maxChars) return text;
+  return `${text.slice(0, Math.max(0, maxChars - 3))}...`;
+}
+
+function compactCommandPlan(commands, limit = 25) {
+  const list = Array.isArray(commands) ? commands : [];
+  const selected = list.slice(0, limit).map((command) => ({
+    order: command.order,
+    command: command.command,
+    required: command.required,
+    source: command.source,
+    last_status: command.last_status || command.status
+  }));
+  if (list.length > selected.length) {
+    selected.push({
+      omitted_count: list.length - selected.length,
+      omitted_reason: 'prompt_budget_command_plan_limit'
+    });
+  }
+  return selected;
+}
+
+function minimalBundleForBudget(evidenceBundle, limits = {}) {
+  const sourceLimit = limits.sourceLimit || 40;
+  const claimLimit = limits.claimLimit || 80;
+  const gapLimit = limits.gapLimit || 20;
+  const commandLimit = limits.commandLimit || 25;
+  const summaryMax = limits.summaryMax || 220;
+  return {
+    ...compactBundleForBudget(evidenceBundle),
+    source_artifacts: (evidenceBundle.source_artifacts || []).slice(0, sourceLimit).map((artifact) => ({
+      type: artifact.type,
+      role: artifact.role,
+      path: artifact.path
+    })),
+    artifact_summaries: [],
+    ledger_claims: compactLedgerClaims(evidenceBundle.ledger_claims || [], { summaryMax }).slice(0, claimLimit),
+    known_gaps: (evidenceBundle.known_gaps || []).slice(0, gapLimit).map((gap) => ({
+      id: gap.id,
+      owner: gap.owner,
+      blocks: gap.blocks,
+      gap: truncateText(gap.gap, summaryMax)
+    })),
+    command_plan: compactCommandPlan(evidenceBundle.command_plan || [], commandLimit),
+    verification_commands: compactCommandPlan(evidenceBundle.verification_commands || [], commandLimit)
+  };
+}
+
+function compactLedgerClaims(claims, options = {}) {
+  const summaryMax = options.summaryMax || 220;
+  return (claims || []).map((claim) => ({
+    id: claim.id,
+    kind: claim.kind,
+    summary: truncateText(claim.summary, summaryMax),
+    owner: claim.owner,
+    status: claim.status,
+    evidence_count: Array.isArray(claim.evidence) ? claim.evidence.length : 0
+  }));
+}
+
+function buildPromptMarkdown({ slug, policy, ledger, evidenceBundle, promptBudget = {} }) {
+  const budget = {
+    max_chars: promptBudget.max_chars || DEFAULT_PROMPT_BUDGET_CHARS,
+    compact_mode: Boolean(promptBudget.compact_mode),
+    artifact_summary_mode: promptBudget.artifact_summary_mode || 'preview'
+  };
+  const claims = budget.compact_mode
+    ? compactLedgerClaims(evidenceBundle.ledger_claims || ledger.claims || [])
+    : (evidenceBundle.ledger_claims || ledger.claims || []);
+  return `# Clean Auditor Prompt - ${slug}
+
+You are an independent adversarial implementation auditor. Do not trust implementation summaries. Verify each claim against real files, git state, tests, and source artifacts.
+
+## Mission
+
+Judge whether the implementation evidence confirms the approved behavior for \`${slug}\`. Your job is not to be nice; your job is to find mismatches without inventing false positives.
+
+## Hard Rules
+
+- Read the ledger claims before judging.
+- Treat tests passed as evidence, not proof of full behavior.
+- Distinguish "not found" from "false".
+- Report exact \`file:line\` for divergences when available.
+- Respect explicit false-positive exceptions from source artifacts or the ledger.
+- Do not execute destructive commands.
+- Do not propose broad unrelated refactors.
+- No courtesy PASS.
+- Produce the \`Machine Report\` JSON block exactly.
+
+## PASS Criteria
+
+PASS only when every implemented or partial required claim is confirmed against files/tests/artifacts, required commands are passed or explicitly justified, scope gaps are owned, and no blocking finding remains. A green test suite alone is not enough.
+
+## Owner Routing
+
+- Implementation infidelity, missing behavior, broken wiring -> \`NEEDS_DEV_FIX\` / \`dev\`.
+- Product or scope contradiction -> \`NEEDS_SCOPE_DECISION\` / \`product\` or \`sheldon\`.
+- Tests not rerun, weak coverage, stale verification -> \`NEEDS_QA_RECHECK\` / \`qa\` or \`tester\`.
+- Security-sensitive finding -> \`NEEDS_SECURITY_REVIEW\` / \`pentester\`.
+- Missing required evidence -> \`INCONCLUSIVE\` with the missing command or artifact named.
+
+## Prompt Package Controls
+
+\`\`\`json
+${asJson({
+  prompt_budget: budget,
+  redactions: evidenceBundle.redactions || {},
+  preview_budget: evidenceBundle.preview_budget || {}
+})}
+\`\`\`
+
+## Policy
+
+\`${policy}\`
+
+## Source Artifacts
+
+\`\`\`json
+${asJson(evidenceBundle.source_artifacts || [])}
+\`\`\`
+
+## Artifact Summaries
+
+\`\`\`json
+${asJson(evidenceBundle.artifact_summaries || [])}
+\`\`\`
+
+## Git State
+
+\`\`\`json
+${asJson(evidenceBundle.git || {})}
+\`\`\`
+
+## Ledger Claims
+
+\`\`\`json
+${asJson(claims)}
+\`\`\`
+
+## Known Gaps
+
+\`\`\`json
+${asJson(evidenceBundle.known_gaps || ledger.known_gaps || [])}
+\`\`\`
+
+## Required Verification Command Plan
+
+\`\`\`json
+${asJson(evidenceBundle.command_plan || evidenceBundle.verification_commands || [])}
+\`\`\`
+
+## Required Output
+
+Return Markdown with these sections:
+
+## Verdict
+## Commands Run
+## Findings
+## Before And Now
+## Residual Risk
+## Recommended Route
+## Machine Report
+
+The \`Machine Report\` section must contain one fenced \`json\` block matching:
+
+\`\`\`json
+${asJson(machineReportSchemaExample(slug, policy))}
+\`\`\`
+`;
+}
+
+function buildWithinBudget({ slug, policy, ledger, evidenceBundle, maxChars = DEFAULT_PROMPT_BUDGET_CHARS }) {
+  let promptBudget = {
+    max_chars: maxChars,
+    compact_mode: false,
+    artifact_summary_mode: 'preview'
+  };
+  let markdown = buildPromptMarkdown({ slug, policy, ledger, evidenceBundle, promptBudget });
+  if (markdown.length <= maxChars) {
+    return { markdown, prompt_budget: { ...promptBudget, actual_chars: markdown.length, over_budget: false } };
+  }
+
+  const compactBundle = compactBundleForBudget(evidenceBundle);
+  promptBudget = {
+    max_chars: maxChars,
+    compact_mode: true,
+    artifact_summary_mode: 'path_only'
+  };
+  markdown = buildPromptMarkdown({ slug, policy, ledger, evidenceBundle: compactBundle, promptBudget });
+  if (markdown.length <= maxChars) {
+    return {
+      markdown,
+      prompt_budget: {
+        ...promptBudget,
+        actual_chars: markdown.length,
+        over_budget: false
+      }
+    };
+  }
+
+  const tiers = [
+    { artifactSummaryMode: 'minimal_path_only', sourceLimit: 40, claimLimit: 80, gapLimit: 20, commandLimit: 25, summaryMax: 220 },
+    { artifactSummaryMode: 'minimal_tight', sourceLimit: 30, claimLimit: 50, gapLimit: 12, commandLimit: 20, summaryMax: 140 },
+    { artifactSummaryMode: 'minimal_floor', sourceLimit: 20, claimLimit: 35, gapLimit: 8, commandLimit: 14, summaryMax: 100 },
+    { artifactSummaryMode: 'minimal_core', sourceLimit: 12, claimLimit: 24, gapLimit: 5, commandLimit: 10, summaryMax: 80 }
+  ];
+
+  for (const tier of tiers) {
+    const minimalBundle = minimalBundleForBudget(evidenceBundle, tier);
+    promptBudget = {
+      max_chars: maxChars,
+      compact_mode: true,
+      artifact_summary_mode: tier.artifactSummaryMode,
+      claim_summary_chars: tier.summaryMax
+    };
+    markdown = buildPromptMarkdown({ slug, policy, ledger, evidenceBundle: minimalBundle, promptBudget });
+    if (markdown.length <= maxChars) {
+      return {
+        markdown,
+        prompt_budget: {
+          ...promptBudget,
+          actual_chars: markdown.length,
+          over_budget: false
+        }
+      };
+    }
+  }
+
+  return {
+    markdown,
+    prompt_budget: {
+      ...promptBudget,
+      actual_chars: markdown.length,
+      over_budget: markdown.length > maxChars
+    }
+  };
+}
+
+async function writePromptPackage(rootDir, slug, markdown, outPath = null) {
+  let targetPath;
+  if (outPath) {
+    const safe = resolveInsideRoot(rootDir, outPath);
+    if (!safe.ok) return safe;
+    targetPath = safe.path;
+  } else {
+    const runsDir = verificationRunsDir(rootDir, slug);
+    await fs.mkdir(runsDir, { recursive: true });
+    targetPath = path.join(runsDir, `${timestampForFile()}-prompt.md`);
+  }
+  await fs.mkdir(path.dirname(targetPath), { recursive: true });
+  await fs.writeFile(targetPath, markdown, 'utf8');
+  return { ok: true, prompt_path: relativeFromRoot(rootDir, targetPath) };
+}
+
+async function buildAndWritePromptPackage({ rootDir, slug, policy, ledger, evidenceBundle, outPath }) {
+  const { markdown, prompt_budget: promptBudget } = buildWithinBudget({ slug, policy, ledger, evidenceBundle });
+  const written = await writePromptPackage(rootDir, slug, markdown, outPath);
+  if (!written.ok) return written;
+  return {
+    ok: true,
+    feature_slug: slug,
+    policy,
+    prompt_path: written.prompt_path,
+    prompt_chars: markdown.length,
+    prompt_budget: promptBudget,
+    redactions: evidenceBundle.redactions || {},
+    source_artifacts: evidenceBundle.source_artifacts,
+    artifact_summaries: evidenceBundle.artifact_summaries,
+    verification_commands: evidenceBundle.verification_commands,
+    command_plan: evidenceBundle.command_plan
+  };
+}
+
+module.exports = {
+  buildPromptMarkdown,
+  buildAndWritePromptPackage,
+  timestampForFile,
+  machineReportSchemaExample,
+  DEFAULT_PROMPT_BUDGET_CHARS
+};