@hizliemre/horse-code 0.1.0

package/dist/trace-ZMB7LT7W.js

@@ -0,0 +1,66 @@
+import {
+  GITIGNORE_MARKER,
+  MAX_TRACE_FILE_CHARS,
+  TRACEABLE_EXT,
+  TRACE_DIR,
+  TRACE_INDEX,
+  TRACE_OUTPUT_TOKENS,
+  discoverTraceRoot,
+  ensureGitignore,
+  everTraceable,
+  hashContent,
+  loadTraceIndex,
+  localOnly,
+  mergeTraceIndexes,
+  parseTraceIndex,
+  planTraces,
+  pruneTraces,
+  readTrace,
+  readTraceSync,
+  saveTrace,
+  saveTraceIndex,
+  serializeTraceIndex,
+  setTraceRoot,
+  sharedDerived,
+  traceCoverage,
+  traceDir,
+  tracePath,
+  tracePrompt,
+  traceRootRel,
+  traceState,
+  traceable
+} from "./chunk-FFYBY2NA.js";
+import "./chunk-SSDLHWSF.js";
+import "./chunk-B67BK5GQ.js";
+export {
+  GITIGNORE_MARKER,
+  MAX_TRACE_FILE_CHARS,
+  TRACEABLE_EXT,
+  TRACE_DIR,
+  TRACE_INDEX,
+  TRACE_OUTPUT_TOKENS,
+  discoverTraceRoot,
+  ensureGitignore,
+  everTraceable,
+  hashContent,
+  loadTraceIndex,
+  localOnly,
+  mergeTraceIndexes,
+  parseTraceIndex,
+  planTraces,
+  pruneTraces,
+  readTrace,
+  readTraceSync,
+  saveTrace,
+  saveTraceIndex,
+  serializeTraceIndex,
+  setTraceRoot,
+  sharedDerived,
+  traceCoverage,
+  traceDir,
+  tracePath,
+  tracePrompt,
+  traceRootRel,
+  traceState,
+  traceable
+};

package/dist/trace-adopt-C6TUWFJL.js

@@ -0,0 +1,79 @@
+import {
+  hashContent,
+  traceDir,
+  traceRootRel
+} from "./chunk-FFYBY2NA.js";
+import "./chunk-SSDLHWSF.js";
+import "./chunk-B67BK5GQ.js";
+
+// src/engine/trace-adopt.ts
+import { readFile, readdir } from "fs/promises";
+import { join, relative, sep } from "path";
+var REF = /(?:^|[\s`"'(\[])((?:src|tests?|libs?|apps?|packages?|toucan|integrators)\/[A-Za-z0-9_./-]+\.[A-Za-z]{1,5})(?=[\s`"')\].,;:]|$)/gm;
+function isPerFileTrace(rel, sourceFiles) {
+  return rel.endsWith(".md") && sourceFiles.has(rel.slice(0, -".md".length));
+}
+async function markdownUnder(dir, base = dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries) {
+    const abs = join(dir, e.name);
+    if (e.isDirectory()) out.push(...await markdownUnder(abs, base));
+    else if (e.name.toLowerCase().endsWith(".md")) out.push(relative(base, abs).split(sep).join("/"));
+  }
+  return out;
+}
+async function adoptDocs(cwd, sourceFiles) {
+  const root = traceDir(cwd);
+  const rootRel = traceRootRel().split(sep).join("/");
+  const covered = {};
+  const bare = [];
+  for (const rel of await markdownUnder(root)) {
+    if (isPerFileTrace(rel, sourceFiles)) continue;
+    let text;
+    try {
+      text = await readFile(join(root, rel), "utf8");
+    } catch {
+      continue;
+    }
+    const doc = `${rootRel}/${rel}`;
+    let hits = 0;
+    for (const m of text.matchAll(REF)) {
+      const file = m[1];
+      if (!sourceFiles.has(file)) continue;
+      hits++;
+      if (!covered[file]) covered[file] = doc;
+    }
+    if (!hits) bare.push(doc);
+  }
+  return { covered, bare };
+}
+async function indexAdoption(cwd, index, adoption, read) {
+  const traces = { ...index.traces };
+  let added = 0;
+  for (const [file, doc] of Object.entries(adoption.covered)) {
+    if (traces[file]) continue;
+    const text = await read(file);
+    if (text === void 0) continue;
+    traces[file] = { hash: hashContent(text), file, writtenAt: 0, doc };
+    added++;
+  }
+  return { index: { ...index, traces }, added };
+}
+function describeAdoption(a, added) {
+  const docs = new Set(Object.values(a.covered)).size;
+  if (!added) return "No project documents cited files this repository has \u2014 nothing to adopt.";
+  return `\u{1F4DA} Adopted **${added} file(s)** already described by ${docs} of the project's own document(s). \`/graph trace\` will skip them; \`graph_trace\` serves the document itself.` + (a.bare.length ? `
+
+_${a.bare.length} document(s) cited no source file and were left alone._` : "");
+}
+export {
+  adoptDocs,
+  describeAdoption,
+  indexAdoption
+};

package/dist/trace-run-F23MFTY4.js

@@ -0,0 +1,24 @@
+import {
+  TRACE_CONCURRENCY,
+  buildBrief,
+  coverageFor,
+  describePlan,
+  planFor,
+  runTraces,
+  traceableFiles
+} from "./chunk-NNTIACT4.js";
+import "./chunk-IW2KBAVZ.js";
+import "./chunk-DTWKSZXY.js";
+import "./chunk-FFYBY2NA.js";
+import "./chunk-PGOYDOI4.js";
+import "./chunk-SSDLHWSF.js";
+import "./chunk-B67BK5GQ.js";
+export {
+  TRACE_CONCURRENCY,
+  buildBrief,
+  coverageFor,
+  describePlan,
+  planFor,
+  runTraces,
+  traceableFiles
+};

package/dist/triage-2J3T5PVQ.js

@@ -0,0 +1,30 @@
+import {
+  RequestSizeSchema,
+  SIZE_ATTEMPT_MS,
+  SIZE_MAX_TURNS,
+  SIZE_TOTAL_MS,
+  TriageSchema,
+  describeEscalation,
+  describeSizeDoubt,
+  sizeRequest,
+  triageFinding
+} from "./chunk-7TBYMFMG.js";
+import "./chunk-TOPZL5SU.js";
+import "./chunk-2SVAHH5N.js";
+import "./chunk-YILDXPSI.js";
+import "./chunk-DTWKSZXY.js";
+import "./chunk-FFYBY2NA.js";
+import "./chunk-PGOYDOI4.js";
+import "./chunk-SSDLHWSF.js";
+import "./chunk-B67BK5GQ.js";
+export {
+  RequestSizeSchema,
+  SIZE_ATTEMPT_MS,
+  SIZE_MAX_TURNS,
+  SIZE_TOTAL_MS,
+  TriageSchema,
+  describeEscalation,
+  describeSizeDoubt,
+  sizeRequest,
+  triageFinding
+};

package/dist/verify-WQ3GHION.js

@@ -0,0 +1,479 @@
+import {
+  commitFix,
+  describeFix,
+  dirtyPaths,
+  runFix
+} from "./chunk-JWAEW7AJ.js";
+import {
+  buildAskUserTool,
+  respondIn
+} from "./chunk-F2IALVBU.js";
+import {
+  buildRememberTool,
+  buildSkillTool,
+  constitutionNote,
+  createWebFetchTool,
+  deferMcp,
+  editFileTool,
+  featureSlugFor,
+  gitTool,
+  refreshAfterChange,
+  shellTool,
+  specsDir,
+  verifyPaths,
+  writeFileTool
+} from "./chunk-3XVZXTB6.js";
+import {
+  askInUserLanguage,
+  inUserLanguage
+} from "./chunk-HBSC2HT2.js";
+import "./chunk-FGVJFMK5.js";
+import "./chunk-NNTIACT4.js";
+import {
+  defaultGitRunner
+} from "./chunk-IW2KBAVZ.js";
+import {
+  describeEscalation,
+  triageFinding
+} from "./chunk-7TBYMFMG.js";
+import {
+  BATCH_TOOLS_NOTE,
+  contextTools,
+  globTool,
+  grepTool,
+  memoryHints,
+  projectToolsNote,
+  readFileTool,
+  reinforceUsed
+} from "./chunk-TOPZL5SU.js";
+import "./chunk-2SVAHH5N.js";
+import {
+  ToolRegistry,
+  handedOver,
+  runToCompletion
+} from "./chunk-YILDXPSI.js";
+import "./chunk-DTWKSZXY.js";
+import "./chunk-FFYBY2NA.js";
+import {
+  loadGraphSync
+} from "./chunk-PGOYDOI4.js";
+import {
+  sessionBase
+} from "./chunk-SSDLHWSF.js";
+import "./chunk-B67BK5GQ.js";
+
+// src/engine/verify.ts
+import { existsSync, readFileSync } from "fs";
+import { relative, join, resolve } from "path";
+
+// src/engine/finding.ts
+import { z } from "zod";
+var FindingSchema = z.object({
+  title: z.string().describe(`Short, in the product's terms \u2014 e.g. "Summary screen omits the Product Description label".`),
+  detail: z.string().describe("What is wrong, where you saw it, and what should have happened instead."),
+  files: z.array(z.string()).default([]).describe("Repo-relative files this appears to involve, if you can name them."),
+  acceptance: z.array(z.string()).default([]).describe("What must be true for this to be settled. One checkable statement per line."),
+  scenario: z.string().optional().describe("The scenario id you were running when you noticed it, if any.")
+});
+var FindingQueue = class {
+  items = [];
+  taken = 0;
+  add(f) {
+    this.items.push(f);
+    return this.items.length;
+  }
+  /** The ones not yet handed to a fix — drained once, so a resumed loop does not re-fix what it fixed. */
+  drain() {
+    const out = this.items.slice(this.taken);
+    this.taken = this.items.length;
+    return out;
+  }
+  all() {
+    return [...this.items];
+  }
+  get length() {
+    return this.items.length;
+  }
+};
+function buildReportFindingTool(queue) {
+  return {
+    name: "report_finding",
+    description: "Report something the product does wrong, so that it gets FIXED. It is recorded, and a separate role fixes it \u2014 you never fix it yourself. Give the acceptance criteria: what must be true for it to be settled.\n\nUse it for BOTH: something that misbehaves in a way the current scenario was not asking about, and \u2014 above all \u2014 the reason a scenario does not pass. A scenario that fails is not a result to write down and walk away from; it is a defect, and reporting it here is the only thing that gets it fixed and the step re-run. One call per distinct defect, not one for the scenario.",
+    permissionLevel: "safe",
+    parameters: FindingSchema,
+    describe: (args) => ({
+      allowKey: "finding:report",
+      preview: `finding: ${String(args.title ?? "").slice(0, 80)}`
+    }),
+    async run(rawArgs) {
+      const parsed = FindingSchema.safeParse(rawArgs);
+      if (!parsed.success) {
+        return { content: `report_finding: ${parsed.error.issues.map((i) => i.message).join("; ")}`, isError: true };
+      }
+      const n = queue.add(parsed.data);
+      return {
+        content: `Finding #${n} recorded: "${parsed.data.title}". Write it into the report now, under a **Findings** section, as OPEN \u2014 with what you saw and where. It is queued to be triaged and fixed by another role, and you will be told the outcome so you can re-check it and update that same entry. Then carry on with the scenario you were running \u2014 do not fix it yourself, and do not mark the scenario failed because of it.`,
+        isError: false
+      };
+    }
+  };
+}
+
+// src/engine/verify.ts
+var VERIFY_MAX_TURNS = 300;
+function testerTools(deps, askUser, findings) {
+  const r = new ToolRegistry();
+  r.register(readFileTool);
+  r.register(writeFileTool);
+  r.register(editFileTool);
+  r.register(grepTool);
+  r.register(globTool);
+  r.register(shellTool);
+  r.register(gitTool);
+  r.register(createWebFetchTool());
+  r.register(buildSkillTool(deps.skillRegistry));
+  r.register(buildAskUserTool(askUser));
+  r.register(buildReportFindingTool(findings));
+  r.register(buildRememberTool(deps.rememberFact));
+  for (const t of contextTools(deps)) r.register(t);
+  deferMcp(r, deps.mcpTools?.() ?? []);
+  return r;
+}
+async function runTester(deps, workdir, tools, message, language, law = "", subject) {
+  const hints = memoryHints(deps, subject ?? message, { role: "tester", operations: true });
+  const { role: agentRole, model, fallbacks, onExhausted, onFallback } = deps.roleRegistry.fallbackOpts("tester");
+  const opts = {
+    provider: deps.provider,
+    role: agentRole,
+    model,
+    fallbacks,
+    onExhausted,
+    onFallback,
+    // `resolve` already appends the user's rules — adding them again put all 25 in twice.
+    systemPrompt: deps.roleRegistry.resolve("tester").systemPrompt + projectToolsNote(tools.list(), !!loadGraphSync(workdir)) + BATCH_TOOLS_NOTE + law + respondIn(language),
+    tools,
+    maxTurns: VERIFY_MAX_TURNS,
+    // A screenshot named in the request comes with it — the same way a mid-run note carries one.
+    messages: [
+      // What earlier runs learned about this area, ahead of the request — see runTester's own note.
+      ...hints?.message ? [{ role: "user", content: hints.message }] : [],
+      { role: "user", ...handedOver(message, workdir) }
+    ],
+    permission: deps.permission,
+    approve: deps.approve,
+    cwd: workdir,
+    signal: deps.signal,
+    // A verification is the longest interactive stretch there is: the tool cards ARE the record of what was
+    // observed, and everything the tester says is addressed to the developer sitting in front of it.
+    onActivity: deps.onActivity,
+    onLiveActivity: deps.onLiveActivity,
+    /** …and a correction — "skip that one, the data is gone" — must reach it mid-run, not after the report. */
+    inbox: deps.inbox,
+    ...deps.note ? { onSay: deps.note } : {}
+  };
+  const last = await runToCompletion(opts);
+  reinforceUsed(deps, hints.ids, last.content ?? "", "tester");
+}
+function testDocDirs(trackedFiles2) {
+  const count = /* @__PURE__ */ new Map();
+  for (const f of trackedFiles2) {
+    const p = f.replace(/\\/g, "/");
+    if (!/\.mdx?$/i.test(p)) continue;
+    if (!/(^|\/)(test-plans?|test-reports?)\//i.test(p) && !/(test-plan|test-report|-e2e)\.mdx?$/i.test(p)) continue;
+    const dir = p.slice(0, p.lastIndexOf("/"));
+    if (dir) count.set(dir, (count.get(dir) ?? 0) + 1);
+  }
+  return [...count.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, 4).map(([d]) => d);
+}
+var POINTER_MARK = /<!--\s*report:\s*(.+?)\s*-->/;
+var POINTER_HINT = "<!-- report: PATH -->";
+function readPointer(pointerPath) {
+  try {
+    const m = POINTER_MARK.exec(readFileSync(pointerPath, "utf8"));
+    return m?.[1]?.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function trackedFiles(cwd) {
+  try {
+    const { defaultGitRunner: defaultGitRunner2 } = await import("./git-VTSZALSR.js");
+    const r = await defaultGitRunner2(["ls-files"], cwd);
+    return r.code === 0 ? r.stdout.split("\n").filter(Boolean) : [];
+  } catch {
+    return [];
+  }
+}
+function planMessageFor(prompt, planRel, pointerRel, dirRel, docDirs) {
+  const where = docDirs.length ? `This project already keeps test documents in ${docDirs.map((d) => `\`${d}\``).join(", ")}. Search there FIRST \u2014 by the feature's name, by the pull request number, by the branch.` : `Search the repository for one anyway: a project can keep them anywhere.`;
+  return `${prompt}
+
+FIRST, find out whether a test document for this work already exists. ${where} Also check "${dirRel}".
+
+A document that already exists is CONTINUED, never replaced. It holds results someone established and evidence they gathered, and writing a second one beside it throws that away while leaving two documents that disagree. If you find one \u2014 even a partly finished one, even one that calls itself a plan \u2014 say so and record it by writing "${pointerRel}" containing one line:
+
+    ${POINTER_HINT.replace("PATH", "the path you found")}
+
+\u2026plus a sentence for a human saying which document this run continues. Then STOP.
+
+IF THERE IS NONE, look at what you were asked. When the request already names what to check and what the right answer looks like \u2014 "confirm from the screenshot that X renders as Y" \u2014 that IS the plan: write nothing, and say so in one line. A plan document is for "run the tests for this pull request", where what to check has to be worked out first.
+
+ONLY IF NEITHER: write a new plan to "${planRel}" \u2014 that exact path, and nowhere else. The directories above are where you LOOK for something that already exists; they are not where a new document goes. Everything a run produces belongs in its own folder, so that one piece of work has one account of itself instead of pieces in two places.
+
+Find out what is being verified before you write a scenario: read the pull request or work item if one is named (use the tools you have for it), read the spec and plan in "${dirRel}" if they are there, and read the code that changed. A scenario invented from a title tests nothing.
+
+The plan is a table of scenarios. Each row: an id, what the scenario does, what is expected, and WHERE the evidence for it will come from \u2014 which table and column, which log event, which screen. A row whose evidence source you cannot name is a row you cannot verify, so name it or drop the row.
+
+Also list, before the table: what the developer must have running, and the exact commands for it. You do not run them.
+
+Write at most one file, then stop. Do not run any scenario yet.`;
+}
+function directMessage(prompt, reportRel) {
+  return `${prompt}
+
+There is no test plan for this, and none is needed \u2014 what you have been asked to check is stated above. Verify exactly that, and nothing more.
+
+Record the result in "${reportRel}" with its evidence: what you did, what you observed, and where the evidence came from. Create the file if it is not there; if it is, append rather than replacing what is already recorded.
+
+If you cannot run the check \u2014 the environment is not up, the data does not exist \u2014 say which command the developer should run and ask them, then wait. Never start it yourself.
+
+When it needs an eye on the screen, describe exactly what to look at and ask what they see. Their answer is the evidence; record it as theirs.
+
+${handOffRule}
+
+${verdictRule}
+
+Whatever is wrong \u2014 the check you were given, or something you noticed beside it \u2014 goes to \`report_finding\`. You never fix anything yourself.`;
+}
+function directResumeMessage(prompt, reportRel, done) {
+  return `The findings you reported have been dealt with:
+${done.map((d) => `- ${d}`).join("\n")}
+
+Anything marked FIXED is in the working tree and committed. Check the original request again against the corrected product, with fresh evidence, and record the result.
+
+` + directMessage(prompt, reportRel);
+}
+function runMessage(prompt, planRel, reportRel, inPlace) {
+  const where = inPlace ? `The document is "${planRel}", and it is BOTH the plan and the report \u2014 record each result in it, in place, next to the scenario it belongs to. Do not create a second file.
+
+Read it first: some scenarios already have results, established by someone else with evidence they gathered. Do not re-run those and do not rewrite them. Continue from the first one with no result.
+
+` : `The test plan is "${planRel}". Work through its scenarios IN ORDER, and record each result in "${reportRel}" \u2014 with its evidence \u2014 before you start the next one.
+
+Create the report if it is not there. If it IS there, this is a resumed session: read it first and continue from the first scenario that has no result. Do not re-run what is already recorded, and do not rewrite results someone else established.
+
+`;
+  return `${prompt}
+
+` + where + `Before the first scenario, check what the plan says must be running. If it is not up, tell the developer which command to run and ask them to confirm \u2014 then wait. Never start it yourself.
+
+When a scenario needs an eye on the screen, describe exactly what to look at and ask the developer what they see. Their answer is the evidence; record it as theirs.
+
+${verdictRule}
+
+` + handOffRule;
+}
+var verdictRule = `A scenario ends in one of two ways: it PASSES, or it is still open. There is no third. Never record a scenario as failed and start the next one.
+
+When a step does not pass, call \`report_finding\` for EACH defect behind it \u2014 one call per distinct defect, with what you saw and what must be true for it to be settled \u2014 and leave the scenario's own entry open, saying what it is waiting on. The findings are fixed while you wait, and you are handed the corrected product to run that same step again; do not go on to another scenario until it passes.
+
+If the developer tells you to leave it and move on, that is their decision and it is fine \u2014 record it as blocked at their request, with their words, and carry on. Yours it is not.`;
+var handOffRule = `Staging, committing and branches are this tool's business, never the developer's: never ask them to \`git add\`, commit or tidy the tree. Ask them only for what nobody else can do \u2014 carry out a scenario, look at a screen, start an environment, decide something.
+
+The developer sees the chat and nothing else. The document you are writing is NOT on their screen, so a request that points at it \u2014 "the steps above", "the items listed" \u2014 asks them to follow something they cannot see. When you need them to carry out a scenario, pass the actions to \`ask_user\` in \`steps\`, one action per entry, and put in \`question\` what they should report back.`;
+var MAX_FIX_ROUNDS = 2;
+async function handleFindings(opts, found) {
+  const done = [];
+  for (const f of found) {
+    const t = await triageFinding(opts.deps, opts.workdir, f);
+    if (t.depth !== "task") {
+      const answer = await askInUserLanguage(
+        opts.deps,
+        opts.askUser,
+        opts.language,
+        `${describeEscalation(f, t)}
+
+Start that now, or leave it in the report and carry on testing?`,
+        [
+          { label: "Leave it \u2014 carry on testing", description: "It stays as an open finding; you can start it after the session." },
+          { label: "Start it now", description: "The test session pauses while it is designed and built." }
+        ]
+      );
+      if (!/start it now/i.test(answer.trim())) {
+        opts.note?.(`\u{1F4CC} Left open: **${f.title}** \u2014 ${t.reason}`);
+        done.push(`${f.title} \u2014 left open, to be handled separately (${t.reason})`);
+        continue;
+      }
+      opts.note?.(`\u{1F4CB} **${f.title}** needs ${t.depth === "brainstorm" ? "a design decision" : "a spec and a plan"}. Finish or stop this session, then ask for it as its own piece of work \u2014 the finding and its evidence are in the report.`);
+      done.push(`${f.title} \u2014 needs its own piece of work; not fixed in this session`);
+      continue;
+    }
+    opts.note?.(`\u{1F527} Fixing: **${f.title}** \u2014 ${t.reason}`);
+    const before = await dirtyPaths(defaultGitRunner, opts.workdir);
+    const res = await runFix(opts.deps, opts.workdir, f, `fix-${done.length + 1}`);
+    const changed = res.fixed ? await commitFix(opts.workdir, f, before) : [];
+    await refreshAfterChange({
+      cwd: opts.workdir,
+      files: changed,
+      provider: opts.deps.provider,
+      models: opts.deps.roleRegistry.chainFor("tracer", 0),
+      signal: opts.deps.signal,
+      ...opts.note ? { note: opts.note } : {}
+    });
+    opts.note?.(describeFix(res));
+    done.push(res.fixed ? `${f.title} \u2014 FIXED` : `${f.title} \u2014 NOT fixed (${res.notes.join("; ") || "see above"})`);
+  }
+  return done;
+}
+function resumeMessage(activeRel, reportRel, inPlace, done) {
+  return `The findings you reported have been dealt with:
+${done.map((d) => `- ${d}`).join("\n")}
+
+Anything marked FIXED has been changed in the working tree and committed. Re-check the scenarios those findings affected \u2014 against the corrected product, with fresh evidence \u2014 and record the result. Then carry on from where you were.
+
+Update each finding's OWN entry in the report as you re-check it: FIXED and verified, with the evidence you just gathered, or still OPEN and what you saw this time. A finding left reading OPEN after it was fixed is as wrong as one marked fixed that was not \u2014 the entry is what anyone reads later.
+
+Anything NOT fixed stays in the report as an open finding, and the scenario it holds up stays open with it. Do not fix it yourself, and do not close a scenario as failed to get past it \u2014 report what still happens, with the evidence from this attempt, so it goes round again.
+
+` + runMessage("", activeRel, reportRel, inPlace);
+}
+function fixBeforeHandOff(askUser, findings, fix, opts) {
+  return async (question, ask) => {
+    const found = findings.drain();
+    if (!found.length || opts.budget.left <= 0) {
+      if (found.length) {
+        opts.note?.(`\u26A0\uFE0F ${found.length} finding(s) left for the end of the session \u2014 the in-session fix budget is spent.`);
+        found.forEach((f) => findings.add(f));
+      }
+      return askUser(question, ask);
+    }
+    opts.budget.left--;
+    opts.note?.(`\u{1F527} ${found.length} finding(s) reported \u2014 fixing before handing over, so you test the corrected product.`);
+    const done = await fix(found);
+    const said = done.map((d) => `- ${d}`).join("\n");
+    const head = await inUserLanguage(
+      opts.deps,
+      "Before this: the finding(s) reported during the last step were dealt with.",
+      opts.language
+    );
+    const answer = await askUser(`${head}
+${said}
+
+${question}`, ask);
+    opts.budget.left = Math.max(opts.budget.left, opts.refill);
+    return `${answer}
+
+[The findings you reported were handled BEFORE this hand-off:
+${said}
+Anything marked FIXED is in the working tree now. Re-run the step you just handed over, against the corrected product, and do not move on until it passes \u2014 or until you can say precisely what still fails, with evidence. Update each finding's own entry in the report with what you saw this time.]`;
+  };
+}
+async function runVerify(opts) {
+  const { deps, workdir, prompt, title, askUser } = opts;
+  const slug = featureSlugFor(workdir, title);
+  const paths = verifyPaths(workdir, slug);
+  const findings = new FindingQueue();
+  const dirRel = relative(workdir, paths.dir);
+  const planRel = relative(workdir, paths.plan);
+  const reportRel = relative(workdir, paths.report);
+  const budget = { left: MAX_FIX_ROUNDS };
+  const handOff = fixBeforeHandOff(
+    askUser,
+    findings,
+    // The RAW askUser here: handleFindings may need to ask about an escalation, and routing that back through
+    // the wrapper would be asking a question about the findings it just drained.
+    (found) => handleFindings({
+      deps,
+      workdir,
+      askUser,
+      ...opts.note ? { note: opts.note } : {},
+      ...opts.language ? { language: opts.language } : {}
+    }, found),
+    {
+      ...opts.note ? { note: opts.note } : {},
+      budget,
+      refill: MAX_FIX_ROUNDS,
+      deps,
+      ...opts.language ? { language: opts.language } : {}
+    }
+  );
+  const tools = testerTools(deps, handOff, findings);
+  const law = deps.home ? await constitutionNote({ ...deps, home: deps.home, note: opts.note }, workdir, { role: "tester", title }) : "";
+  const settled = () => {
+    const pointed = readPointer(paths.report);
+    if (pointed && existsSync(join(workdir, pointed))) return pointed;
+    return existsSync(paths.plan) ? planRel : void 0;
+  };
+  let active = settled();
+  if (!active) {
+    const docDirs = testDocDirs(await trackedFiles(workdir));
+    opts.note?.(docDirs.length ? `\u{1F9EA} Looking for an existing test document \u2014 this project keeps them in ${docDirs.map((d) => `\`${d}\``).join(", ")}.` : `\u{1F9EA} Looking for an existing test document for this work.`);
+    await runTester(deps, workdir, tools, planMessageFor(prompt, planRel, reportRel, dirRel, docDirs), opts.language, law, prompt);
+    active = settled();
+  }
+  const direct = !active;
+  if (direct) opts.note?.(`\u{1F9EA} No test document, and none needed \u2014 the request names what to check. Verifying it directly.`);
+  const inPlace = !!active && active !== planRel;
+  opts.note?.(inPlace ? `\u{1F9EA} Continuing \`${active}\` in place \u2014 it already holds results, and a second document beside it would disagree with it.` : `\u{1F9EA} Verifying against \`${active}\`.`);
+  let round = 0;
+  let message = direct ? directMessage(prompt, reportRel) : runMessage(prompt, active, reportRel, inPlace);
+  for (; ; ) {
+    await runTester(deps, workdir, tools, message, opts.language, law, prompt);
+    const found = findings.drain();
+    if (!found.length || budget.left <= 0) {
+      if (found.length) opts.note?.(`\u26A0\uFE0F ${found.length} finding(s) left unfixed \u2014 ${MAX_FIX_ROUNDS} rounds of fixing is the limit for one session.`);
+      break;
+    }
+    budget.left--;
+    round++;
+    const done = await handleFindings(opts, found);
+    message = direct ? directResumeMessage(prompt, reportRel, done) : resumeMessage(active, reportRel, inPlace, done);
+  }
+  return {
+    dir: dirRel,
+    planPath: active ?? reportRel,
+    // In-place: the results are in the document itself, and the folder holds the pointer to it.
+    reportPath: inPlace ? active : reportRel,
+    planWritten: true,
+    reportWritten: inPlace || existsSync(paths.report)
+  };
+}
+function describeVerify(r, branch, workdir) {
+  if (!r.planWritten) {
+    return `\u26A0\uFE0F No test plan was found or written \u2014 nothing was verified.`;
+  }
+  const head = r.reportWritten ? `\u{1F9EA} Test report: \`${r.reportPath}\`` : `\u26A0\uFE0F The plan is at \`${r.planPath}\`, but no report was written \u2014 nothing was recorded.`;
+  const inPlace = r.reportPath !== `${r.dir}/test-report.md` && r.reportWritten;
+  const where = inPlace ? `Continued in place, where its history already was. \`${r.dir}\` holds a pointer to it.` : `Everything this run produced is in \`${r.dir}\`.`;
+  const base = sessionBase(workdir !== void 0 ? resolve(workdir, r.dir) : r.dir);
+  const seat = base === void 0 ? `On branch \`${branch}\` \u2014 uncommitted, in your working tree.` : `On branch \`${branch}\`, in the worktree at \`${base}\` \u2014 review it there, then merge it in.`;
+  return `${head}
+
+${where} ${seat}`;
+}
+async function currentBranchOf(cwd) {
+  const { defaultGitRunner: defaultGitRunner2 } = await import("./git-VTSZALSR.js");
+  const r = await defaultGitRunner2(["symbolic-ref", "--short", "HEAD"], cwd);
+  return r.code === 0 && r.stdout.trim() ? r.stdout.trim() : "(detached)";
+}
+function verifyDir(workdir, title) {
+  return relative(workdir, verifyPaths(workdir, featureSlugFor(workdir, title)).dir) || specsDir(workdir);
+}
+export {
+  MAX_FIX_ROUNDS,
+  POINTER_HINT,
+  POINTER_MARK,
+  VERIFY_MAX_TURNS,
+  currentBranchOf,
+  describeVerify,
+  directMessage,
+  fixBeforeHandOff,
+  planMessageFor,
+  readPointer,
+  resumeMessage,
+  runMessage,
+  runVerify,
+  testDocDirs,
+  verdictRule,
+  verifyDir
+};