ravensight-playtest 0.5.2 → 0.7.0

package/src/run/drivers/web.js

@@ -1429,6 +1429,8 @@ export function createWebDriver({ importer, headless = true, playtest = null, pl
   return {
     name: 'playwright_web',
     supportsRefs: true,
+    // A key action may hold its keys (hold_ms, with_keys).
+    supportsHold: true,
     editModifier,
     keepObservations: WEB_KEEP_OBSERVATIONS,
 
@@ -1613,6 +1615,22 @@ export function createWebDriver({ importer, headless = true, playtest = null, pl
       try {
         switch (action.kind) {
           case 'key':
+            if (action.holdMs > 0 || (Array.isArray(action.keys) && action.keys.length > 0)) {
+              // Held keys go down together and come up in reverse, even when
+              // one is refused, so nothing stays held for the rest of the run.
+              const keys = [action.key, ...(action.keys || [])].map(key => normalizeChord(key, editModifier));
+              const down = [];
+              try {
+                for (const key of keys) {
+                  await current.keyboard.down(key);
+                  down.push(key);
+                }
+                await current.waitForTimeout(Math.min(Math.max(Number(action.holdMs) || 0, 0), MAX_WAIT_MS));
+              } finally {
+                for (const key of down.reverse()) await current.keyboard.up(key).catch(() => {});
+              }
+              break;
+            }
             await current.keyboard.press(normalizeChord(action.key, editModifier), { timeout: ACTION_TIMEOUT_MS });
             break;
           case 'type':

package/src/run/evidence.js

@@ -0,0 +1,170 @@
+/**
+ * Fix v2's evidence report: the pull request body, followed by what was
+ * measured and what was judged, kept apart.
+ *
+ * "Verified facts" are things the CLI or git observed: which checks ran and
+ * what they printed, which files changed. "Model judgement" is everything a
+ * model wrote or scored: the hypothesis, the description, and the verify
+ * score, which is a judge's reading of a persona's report rather than a
+ * measurement. A reviewer should be able to tell the two apart at a glance.
+ */
+
+/** How a judged `reproduced` score reads; the same thresholds `fix` uses. */
+function scoreWords(verify, { fixedBelow, reproducedAbove }) {
+  if (!verify) return 'not run';
+  if (verify.failed === 'game_boot_failed') return 'not verified, the game did not boot';
+  if (verify.failed) return 'not verified, the verify run failed';
+  const score = verify.reproduced;
+  if (typeof score !== 'number' || !Number.isFinite(score)) return 'no verdict';
+  if (score < fixedBelow) return `fixed (reproduced ${score})`;
+  if (score > reproducedAbove) return `still reproduced (${score})`;
+  return `unknown (reproduced ${score})`;
+}
+
+function cell(value) {
+  return String(value ?? '').replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
+}
+
+/**
+ * The risks a reviewer should know about, computed from what happened rather
+ * than written by a model.
+ *
+ * @returns {Array<string>}
+ */
+export function remainingRisks({ checks = [], verifies = [], wantsVerify = true, budgetTouched = false, repairs = 0, thresholds }) {
+  const risks = [];
+  const latest = new Map();
+  for (const result of checks) latest.set(result.name, result);
+  for (const result of latest.values()) {
+    if (result.status === 'unavailable') risks.push(`${result.name} could not run: ${result.detail}.`);
+    if (result.status === 'failed') risks.push(`${result.name} still fails on the final change: ${result.detail}.`);
+    if (result.status === 'check_refused') risks.push(`${result.name} was refused on the final change: ${result.detail}.`);
+  }
+  if (!latest.has('godot_import')) risks.push('The project import check did not run on the final change.');
+  const last = verifies.at(-1) || null;
+  if (!wantsVerify) risks.push('The fix was not verified (--no-verify).');
+  else if (!last) risks.push('No verify run played the final change.');
+  else if (last.failed) risks.push('The last verify run did not play the change, so the fix is unverified.');
+  else {
+    const words = scoreWords(last, thresholds);
+    if (!words.startsWith('fixed')) risks.push(`The last verify reads ${words}.`);
+  }
+  if (verifies.length > 0) risks.push('Verify is a persona replaying the repro steps and a judge scoring its report: a probability, not a deterministic replay.');
+  if (repairs > 0) risks.push(`The change needed ${repairs} repair turn set(s) before this result; read the whole diff, not just the first edit.`);
+  if (budgetTouched) risks.push('The fix stopped early on its model budget, so the change may be incomplete.');
+  return risks;
+}
+
+/**
+ * The checks still failing on the final change, by name. A check that failed and
+ * then passed after a repair is not one of them.
+ *
+ * @param {Array<Object>} checks
+ * @returns {Array<string>}
+ */
+export function checksStillFailing(checks = []) {
+  const latest = new Map();
+  for (const result of checks) latest.set(result.name, result);
+  return [...latest.values()].filter(result => result.status === 'failed' || result.status === 'check_refused').map(result => result.name);
+}
+
+/**
+ * @param {Object} args
+ * @returns {string} markdown
+ */
+export function evidenceReport({
+  prBody,
+  summarySource = 'model',
+  acceptance,
+  finding,
+  sourceRunId = null,
+  plan = null,
+  files = [],
+  checks = [],
+  verifies = [],
+  repairs = 0,
+  maxRepairs = 2,
+  wantsVerify = true,
+  budgetTouched = false,
+  thresholds
+}) {
+  const label = finding.label || finding.finding_id;
+  // First, above anything a model wrote, so no summary and no clamp on the body
+  // can leave a reviewer thinking this change passed.
+  const stillFailing = checksStillFailing(checks);
+  const lines = [
+    ...(stillFailing.length > 0 ? [`**Checks failed on this change: ${stillFailing.join(', ')}.** Details are under Evidence below.`, ''] : []),
+    String(prBody || '').trimEnd(), '', '## Evidence', ''
+  ];
+
+  lines.push('### Acceptance contract', '', 'Frozen on the job before the first edit. The fix was judged against this alone.', '');
+  lines.push(`- Expected: ${acceptance.expected}`);
+  lines.push(`- Actual: ${acceptance.actual}`);
+  lines.push(`- Repro steps: ${acceptance.reproSteps.length > 0 ? acceptance.reproSteps.map((step, index) => `${index + 1}. ${step}`).join(' ') : 'none recorded'}`);
+  lines.push(`- Verify and regression personas: ${acceptance.regressionPersonas.join(', ') || 'none'}`, '');
+
+  lines.push('### Verified facts', '');
+  lines.push('Measured by this CLI and git, not judged by a model.', '');
+  if (checks.length > 0) {
+    lines.push('Checks, in the order they ran (each on a temporary copy of the project):', '');
+    lines.push('| Check | Result | Time | Detail |', '| --- | --- | --- | --- |');
+    for (const result of checks) {
+      lines.push(`| ${cell(result.name)} | ${cell(result.status)} | ${cell(`${Math.round((result.durationMs || 0) / 100) / 10} s`)} | ${cell(result.detail)} |`);
+    }
+    const failedErrors = checks.filter(result => result.status === 'failed' && result.errors && result.errors.length > 0).at(-1);
+    if (failedErrors) {
+      lines.push('', `Errors from the last failing check (${failedErrors.name}):`, '');
+      for (const error of failedErrors.errors.slice(0, 10)) lines.push(`- \`${error.replace(/`/g, '\'')}\``);
+    }
+  } else {
+    lines.push('No checks ran.');
+  }
+  lines.push('', 'Files changed:', '');
+  for (const file of files) lines.push(`- \`${file.path}\`: +${file.additions} -${file.deletions}`);
+  if (files.length === 0) lines.push('- none');
+  lines.push('', `Repair turn sets used: ${repairs} of ${maxRepairs}.`, '');
+
+  lines.push('### Before and after', '');
+  lines.push(`- Before: ${label} was filed${finding.persona ? ` by ${finding.persona}` : ''}${sourceRunId ? ` in run ${sourceRunId}` : ''}, which saw the actual behaviour above.`);
+  if (verifies.length === 0) lines.push(`- After: ${wantsVerify ? 'no verify run played the change' : 'not verified (--no-verify)'}.`);
+  verifies.forEach((verify, index) => {
+    lines.push(`- After, verify ${index + 1}${verify && verify.run_id ? ` (run ${verify.run_id})` : ''}: ${scoreWords(verify, thresholds)}.`);
+  });
+  lines.push('');
+
+  lines.push('### Model judgement', '');
+  lines.push('Written or scored by a model. Read the diff before trusting any of it.', '');
+  if (plan && plan.hypothesis) lines.push(`- Hypothesis: ${plan.hypothesis}`);
+  lines.push(`- The description at the top was written ${summarySource === 'model' ? 'by the model from the diff' : 'locally, because the model could not write it'}.`);
+  if (verifies.some(verify => verify && !verify.failed)) lines.push('- Each verify score is a judge model\'s probability, from 0 to 1, that the finding is still present, from reading the verify persona\'s report against the acceptance contract. It is not a percentage of actions or attempts.');
+  lines.push('');
+
+  lines.push('### Remaining risks', '');
+  const risks = remainingRisks({ checks, verifies, wantsVerify, budgetTouched, repairs, thresholds });
+  for (const risk of risks) lines.push(`- ${risk}`);
+  if (risks.length === 0) lines.push('- None found by the checks above.');
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * The report with the model's text fitted around the evidence rather than the other
+ * way round. Evidence comes after the model's description and the whole is cut at the
+ * changeset's limit, so a long enough description would cut every measured fact off
+ * the end, and could put its own "Verified facts" where they had been. So the
+ * measured part is sized first, and the headings only it may use are taken back.
+ *
+ * @param {(prBody: string) => string} render the report around a given description
+ * @param {string} prBody the model's text
+ * @param {number} [limit]
+ * @returns {string}
+ */
+export function withEvidenceIntact(render, prBody, limit = 20000) {
+  const text = String(prBody || '').replace(/^([ \t]{0,3}#{1,6}[ \t]*)(evidence|verified facts)\b/gim, '$1From the model: $2');
+  const note = '\n\n(the description was cut to keep the evidence below it whole)';
+  const room = Math.max(0, limit - render('').length - note.length);
+  const whole = render(text.length <= room ? text : `${text.slice(0, room)}${note}`);
+  return whole.length <= limit ? whole : `${whole.slice(0, limit - 40)}\n\n(cut at the changeset's size limit)\n`;
+}
+
+export default { evidenceReport, remainingRisks, checksStillFailing, withEvidenceIntact };

package/src/run/featureLoop.js

@@ -0,0 +1,288 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import { DIMENSION_3D } from './dimension.js';
+import { parseJsonObject } from './json.js';
+import { callStepWithRetry, ProxyError, STEPS } from './model.js';
+import { applyFix, bundleLines, clamp, planFix, SUMMARY_MAX_TOKENS } from './fixLoop.js';
+
+/**
+ * The `feature` module's model steps, and the words around them. The loops
+ * themselves are `planFix` and `applyFix`, with their guards and budget stops,
+ * because the safety of an edit loop is the same whatever it is editing. What
+ * differs is the instruction, the frozen specification it is held to, and the
+ * write cap the caller hands the repository tools.
+ *
+ * The specification is frozen on the job by the server. This file reads the copy
+ * the job came back with, and nothing here can change what counts as done.
+ */
+
+/** The feature module's own ceiling, and only this module's: the large size. */
+export const MAX_FEATURE_WRITES = 40;
+
+/**
+ * How many files each size was priced for. The same numbers as the server's
+ * `FILES_FOR_SIZE` (src/playtest/featureSpec.js), which refuses a changeset above
+ * them, and a test holds the two together when a server checkout is named.
+ */
+export const FILES_FOR_SIZE = Object.freeze({ small: 8, medium: 20, large: MAX_FEATURE_WRITES });
+
+/**
+ * The write cap for a job, from the size frozen on it. A size this CLI has never
+ * heard of gets the smallest, because a cap that is too low costs a refused write
+ * the model can read, and one that is too high costs a refused changeset.
+ *
+ * @param {string} size
+ * @returns {number}
+ */
+export function maxWritesForSize(size) {
+  return Object.hasOwn(FILES_FOR_SIZE, size) ? FILES_FOR_SIZE[size] : FILES_FOR_SIZE.small;
+}
+
+/** The hard ceiling on apply turns, whatever the developer asks for. */
+export const MAX_FEATURE_ACTIONS = 120;
+
+const applyInstructions = primitives => Object.freeze([
+  'Build the feature now. Read before you edit. Change an existing file with `edit_file` (old_text copied verbatim, new_text in its place); use `write_file` for a new file, because it replaces the whole file.',
+  `Keep the style of the code around you and stay inside the specification. Art and audio belong to the studio: use what the project has, otherwise a placeholder primitive such as ${primitives}, and never suggest a tool or service for them. If the feature is already there or cannot be built here, change nothing and say why in one line. When you are done, say in one line what you built and call no more tools.`
+]);
+
+const APPLY_INSTRUCTIONS = applyInstructions('a ColorRect, a Polygon2D or a Label');
+const APPLY_INSTRUCTIONS_3D = applyInstructions('a MeshInstance3D with a BoxMesh, a SphereMesh or a CapsuleMesh, or a Label');
+
+/** What the job says about the engine. 3D is the Alpha, and says so to the model. */
+export function engineLine(dimension) {
+  return dimension === DIMENSION_3D
+    ? 'engine: Godot, 3D (Alpha). Where the skill says 2D, read 3D: positions are Vector3 in world units, and a persona plays with keys and input actions, so build nothing a scenario needs mouse look for'
+    : 'engine: Godot, 2D';
+}
+
+/**
+ * The system prompt every feature step shares.
+ *
+ * @param {{skill: string, jobId: string, branch: string, baseCommit: string, maxWrites?: number, dimension?: string}} input
+ * @returns {Array<Object>}
+ */
+export function featureSystem({ skill, jobId, branch, baseCommit, maxWrites = MAX_FEATURE_WRITES, dimension = '2d' }) {
+  return [
+    { type: 'text', text: skill },
+    {
+      type: 'text',
+      text: [
+        `job_id: ${jobId}`,
+        engineLine(dimension),
+        'the paths you read and write are relative to the repository root; never absolute',
+        `branch: ${branch} (created for this attempt, from ${baseCommit || 'unknown'})`,
+        `at most ${maxWrites} files may be written`,
+        'you cannot run commands, reach the network, or commit anything, except the named checks the run_check tool offers. The developer reviews the branch.'
+      ].join('\n'),
+      cache_control: { type: 'ephemeral' }
+    }
+  ];
+}
+
+/** The frozen specification, as the data block both the plan and the apply read. */
+export function specBlock(spec) {
+  return `<spec>\n${JSON.stringify(spec, null, 2)}\n</spec>`;
+}
+
+/**
+ * The user message the plan step reads.
+ *
+ * @param {{spec: Object, codeBrief?: Object|null}} input
+ * @returns {Array<Object>} content blocks
+ */
+export function featurePlanContent({ spec, codeBrief = null, assetLines = [] }) {
+  return [{
+    type: 'text',
+    text: [
+      'A person approved this feature specification. Read the code it touches and plan how to build it.',
+      '',
+      specBlock(spec),
+      ...bundleLines(codeBrief, null),
+      ...assetLines,
+      '',
+      'Answer with this JSON object and nothing else:',
+      '{ "hypothesis": "one or two sentences on how you will build it", "files_to_change": ["repo/relative/path"], "out_of_scope": ["what you are deliberately not touching"], "placeholders": ["art or audio the project lacks, and the primitive that stands in for it"] }'
+    ].join('\n')
+  }];
+}
+
+/** The plan step, on this module's route. */
+export function planFeature(args) {
+  return planFix({ ...args, step: STEPS.featurePlan });
+}
+
+/** One apply turn set: the first, or a repair. */
+export function applyFeature({ spec, assetInstructions = [], dimension = '2d', ...args }) {
+  return applyFix({
+    ...args,
+    step: STEPS.featureApply,
+    instructions: [...(dimension === DIMENSION_3D ? APPLY_INSTRUCTIONS_3D : APPLY_INSTRUCTIONS), ...assetInstructions],
+    contract: specBlock(spec)
+  });
+}
+
+/**
+ * The pull request text, written from the diff that exists. `fallback` answers
+ * when the step cannot: no budget left, or no JSON in the reply.
+ *
+ * @returns {Promise<{prTitle: string, prBody: string, source: string}>}
+ */
+export async function summariseFeature({ client, jobId, runId, system, spec, plan, files, branch, fallback, ledger = null, log = () => {} }) {
+  const content = [{
+    type: 'text',
+    text: [
+      'Write the pull request text for the feature you just built. The reviewer owns this code. Never say it was verified: that part is added from the server\'s record.',
+      '',
+      specBlock(spec),
+      `<plan>\n${JSON.stringify(plan || {}, null, 2)}\n</plan>`,
+      `<diff_stat>\n${files.map(file => `${file.path}: +${file.additions} -${file.deletions}`).join('\n') || 'nothing'}\n</diff_stat>`,
+      `<branch>${branch}</branch>`,
+      '',
+      'Answer with this JSON object and nothing else:',
+      '{ "pr_title": "one line, at most 120 characters", "pr_body": "markdown: what was built, which requirements it meets, what the reviewer should check by hand, and what was not done" }'
+    ].join('\n')
+  }];
+  let answer;
+  try {
+    answer = await callStepWithRetry({ client, jobId, runId, step: STEPS.featureSummarize, system, messages: [{ role: 'user', content }], maxTokens: SUMMARY_MAX_TOKENS });
+  } catch (error) {
+    if (error instanceof ProxyError && error.isBudget) {
+      log('There was no budget left to write the pull request text, so it was written locally instead.');
+      return { ...fallback, source: 'local' };
+    }
+    // The feature exists and has been played. Prose is the one thing left, and
+    // losing it must not lose the changeset or fail a job that worked.
+    log(`The pull request text could not be written by the model (${String(error && error.message)}), so it was written locally instead.`);
+    return { ...fallback, source: 'local' };
+  }
+  if (ledger) ledger.record({ model: answer.model, usage: answer.usage });
+  const parsed = parseJsonObject(answer.text) || {};
+  const title = typeof parsed.pr_title === 'string' && parsed.pr_title.trim() ? parsed.pr_title.trim() : fallback.prTitle;
+  const body = typeof parsed.pr_body === 'string' && parsed.pr_body.trim() ? parsed.pr_body : fallback.prBody;
+  return { prTitle: clamp(title, 120), prBody: clamp(body, 20000), source: parsed.pr_title || parsed.pr_body ? 'model' : 'local' };
+}
+
+/**
+ * What the persona playing one scenario is asked to do. Built from the frozen
+ * specification only, in front of the brief a persona usually plays against, so
+ * the task is the first thing it reads and the game's goals stay beside it.
+ *
+ * @param {Object|null} base the game's expectations brief
+ * @param {Object} scenario from the frozen specification
+ * @param {Object} spec
+ * @returns {Object}
+ */
+export function scenarioBrief(base, scenario, spec, controls = null) {
+  return {
+    ...(base || {}),
+    fields: {
+      feature_under_test: `${spec.title}: ${spec.summary}`,
+      ...(controls ? { controls } : {}),
+      scenario_task: scenario.title,
+      scenario_steps: scenario.steps,
+      scenario_expected: scenario.expected,
+      scenario_instruction: 'Do these steps first. If what you see is not what is expected, file it as a major finding that says what you saw. Then stop.',
+      ...((base && base.fields) || {})
+    }
+  };
+}
+
+/**
+ * A plain local pull request body, when the model could not write one.
+ *
+ * @returns {{prTitle: string, prBody: string}}
+ */
+export function localFeatureSummary({ spec, plan, files, branch }) {
+  return {
+    prTitle: `Add ${spec.title}`.slice(0, 120),
+    prBody: [
+      `# ${spec.title}`,
+      '',
+      spec.summary,
+      '',
+      plan && plan.hypothesis ? `${plan.hypothesis}\n` : '',
+      '## What changed',
+      ...files.map(file => `- \`${file.path}\`: +${file.additions} -${file.deletions}`),
+      '',
+      'This summary was written locally rather than by the model, so read the diff before trusting it.',
+      '',
+      `Branch: ${branch}`,
+      ''
+    ].filter(line => line !== '').join('\n')
+  };
+}
+
+/**
+ * Whether each SDK event the specification lists is named in a changed file. A
+ * measurement, not a judgement: it reads the files, so "named" means the string
+ * is there, not that the game reports it at the right moment.
+ *
+ * @param {{spec: Object, files: Array<{path: string}>, repoRoot: string}} input
+ * @returns {Promise<Array<{name: string, found: boolean}>>}
+ */
+export async function eventsInChange({ spec, files, repoRoot }) {
+  const texts = await Promise.all(files.map(file => readFile(path.join(repoRoot, file.path), 'utf8').catch(() => '')));
+  return (spec.sdk_events || []).map(event => ({ name: event.name, found: texts.some(text => text.includes(event.name)) }));
+}
+
+function cell(value) {
+  return String(value ?? '').replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
+}
+
+/**
+ * The evidence report: the pull request body, then what was measured, kept apart
+ * from what a model wrote. The verdict is the server's words, and a placeholder
+ * is named so a reviewer knows what art or audio is still theirs to supply.
+ *
+ * @param {Object} input
+ * @returns {string} markdown
+ */
+export function featureEvidence({ prBody, summarySource, spec, report, files, checks, repairs, maxRepairs, placeholders, events, staleNotes = [], budgetTouched = false, wantedVerify = true, assetLines = [] }) {
+  const latest = new Map();
+  for (const result of checks) latest.set(result.name, result);
+  const out = [String(prBody || '').trimEnd(), '', '---', '', '## Evidence', ''];
+  out.push(report ? report.verification_note : 'The server\'s report could not be read, so this change reads as not verified.', '');
+
+  out.push('### Test scenarios (played by model personas, read from the server\'s own records)', '', '| Scenario | Answer | Why |', '|---|---|---|');
+  for (const scenario of (report ? report.scenarios : [])) {
+    out.push(`| ${cell(scenario.title)} | ${scenario.passed ? 'passed' : (scenario.played ? 'not passed' : 'not played')} | ${cell(scenario.reason || '')} |`);
+  }
+  if (!wantedVerify) out.push('', 'The scenarios were not played.');
+  for (const note of staleNotes) out.push('', note);
+
+  out.push('', '### Verified facts', '', '| Check | Result | Detail |', '|---|---|---|');
+  for (const result of latest.values()) out.push(`| ${cell(result.name)} | ${cell(result.status)} | ${cell(result.detail)} |`);
+  if (latest.size === 0) out.push('| none ran | | |');
+  out.push('', `${files.length} file(s) changed. ${repairs} of ${maxRepairs} repair(s) used.`, '');
+  out.push(...files.map(file => `- \`${file.path}\`: +${file.additions} -${file.deletions}`), '');
+  out.push('### SDK events the specification lists', '');
+  if (events.length === 0) out.push('None.');
+  else out.push(...events.map(event => `- \`${event.name}\`: ${event.found ? 'named in a changed file' : 'NOT named in any changed file'}`));
+
+  out.push('', ...assetLines);
+  out.push('', '### Placeholders', '');
+  if (placeholders.length === 0) out.push('None named. Studios supply their own art and audio.');
+  else out.push('These stand in for art or audio the project does not have. They are yours to replace with your own assets:', '', ...placeholders.map(item => `- ${item}`));
+
+  out.push('', '### Remaining risks', '');
+  const risks = [];
+  for (const result of latest.values()) {
+    if (result.status === 'unavailable') risks.push(`${result.name} could not run: ${result.detail}.`);
+    if (result.status === 'failed') risks.push(`${result.name} still fails on the final change: ${result.detail}.`);
+    if (result.status === 'check_refused') risks.push(`${result.name} was refused on the final change: ${result.detail}.`);
+  }
+  if (repairs > 0) risks.push(`The change needed ${repairs} repair turn set(s); read the whole diff, not just the first edit.`);
+  if (budgetTouched) risks.push('The feature stopped early on its model budget, so it may be incomplete.');
+  const missing = events.filter(event => !event.found).map(event => event.name);
+  if (missing.length) risks.push(`The specification lists SDK events no changed file names: ${missing.join(', ')}.`);
+  risks.push('A persona passing a scenario is a model playing the game, not a player. Play it yourself before you ship it.');
+  out.push(...risks.map(risk => `- ${risk}`), '');
+
+  out.push('### Model judgement', '', `The description above was written by ${summarySource === 'model' ? 'the model' : 'this CLI, because the model could not'}. The acceptance criteria below were approved by a person and frozen on the job; nothing above changes them.`, '');
+  out.push(...spec.acceptance_criteria.map(item => `- ${item}`), '');
+  return out.join('\n');
+}
+
+export default { featureSystem, featurePlanContent, planFeature, applyFeature, summariseFeature, scenarioBrief, localFeatureSummary, eventsInChange, featureEvidence, MAX_FEATURE_WRITES, MAX_FEATURE_ACTIONS };