arey-pi 0.2.0 → 0.4.0

package/docs/workflows.md

@@ -0,0 +1,213 @@
+# Arey Pi Workflows
+
+See `docs/workflow-diagram.md` for a visual overview of the framework workflow.
+
+Arey Pi workflows can be started with slash commands or natural language.
+
+The slash commands make the intended process explicit.
+Natural language should still follow the same rules when the user asks to work following Arey Pi.
+
+## Feature Workflow
+
+Command:
+
+```txt
+/arey-feature <feature request>
+```
+
+Expected flow:
+
+```txt
+parent tech lead → arey-pi.spec-author → arey-pi.tdd-implementer → arey-pi.spec-syncer → fresh reviewers → parent finalisation
+```
+
+For broad or risky changes,
+use builtin `scout`,
+`context-builder`,
+or `planner` before the Arey Pi delivery flow.
+
+Use this for new behaviour or meaningful behaviour changes.
+
+The workflow should:
+
+1. clarify scope and change mode;
+2. confirm or author canonical Gherkin specs;
+3. add a failing test in a dedicated test directory;
+4. implement the smallest high-quality production change;
+5. refactor while tests remain green;
+6. synchronise specs and documentation;
+7. review engineering quality when risk warrants it;
+8. report evidence and residual risks.
+
+## Bugfix Workflow
+
+Command:
+
+```txt
+/arey-bugfix <bug description>
+```
+
+Use this when behaviour is wrong.
+
+Expected flow:
+
+```txt
+reproduce with failing regression test → fix → validate → sync → review
+```
+
+Bug fixes require a regression test.
+The regression test should fail for the bug before the fix,
+and it should live outside production source directories by default.
+
+## Sync Workflow
+
+Command:
+
+```txt
+/arey-sync [scope]
+```
+
+Use this before completing non-trivial work or when drift is suspected.
+
+The sync check covers:
+
+- Gherkin specs;
+- tests;
+- code;
+- DBML;
+- ADRs;
+- glossary;
+- architecture docs;
+- README files;
+- `docs/`;
+- `AGENTS.md`;
+- skills,
+  prompts,
+  rules,
+  agents,
+  commands,
+  tooling instructions,
+  examples,
+  and templates.
+
+The final result should include both spec and documentation status:
+
+```txt
+Specs updated
+Docs updated
+```
+
+or justified unaffected statuses.
+
+## Review Workflow
+
+Command:
+
+```txt
+/arey-review [scope]
+```
+
+Use this for adversarial engineering review.
+
+Review should cover:
+
+- architecture and code quality;
+- test quality and test location;
+- tooling and validation evidence;
+- security and privacy;
+- reliability and operability;
+- maintainability;
+- generated-code quality;
+- spec,
+  ADR,
+  DBML,
+  glossary,
+  and documentation sync concerns.
+
+Findings should be classified by severity.
+
+## Assessment Workflow
+
+Command:
+
+```txt
+/arey-assess [scope]
+```
+
+Use this to assess project readiness.
+
+The assessment is read-only by default.
+It should produce scores,
+evidence,
+blockers,
+quick wins,
+and a prioritised improvement plan.
+
+## Bootstrap Workflow
+
+Command:
+
+```txt
+/arey-bootstrap
+```
+
+With no flags,
+bootstrap installs project-local Arey Pi agents and creates starter harness files where missing.
+
+Use selective flags only when needed:
+
+```txt
+/arey-bootstrap --agentsmd
+/arey-bootstrap --specs
+/arey-bootstrap --docs
+/arey-bootstrap --force
+```
+
+## Subagent Orchestration Pattern
+
+Keep orchestration in the parent Pi session.
+Child agents should receive bounded tasks and should not launch their own subagent workflows unless explicitly assigned a bounded fanout job.
+
+Use fresh-context reviewers for independent review.
+Use `oracle` when a decision needs a second opinion before implementation.
+Use one writer in the active worktree at a time.
+
+For long-running work,
+background subagents are appropriate.
+If the parent has no useful independent work,
+end the turn and wait for completion rather than polling repeatedly.
+
+See `docs/pi-subagents.md` for detailed guidance.
+
+## Natural Language Workflow
+
+Users do not need to memorise commands.
+
+This should work:
+
+```txt
+Implement password reset following Arey Pi.
+```
+
+The parent agent should act as tech lead,
+select the appropriate workflow,
+and use specialist subagents when available.
+
+## Evidence Standard
+
+Every non-trivial workflow should finish with:
+
+```txt
+Done summary:
+- Behaviour/spec impact:
+- Tests/TDD, including test location:
+- Validation:
+- Quality tooling:
+- Spec sync:
+- Documentation sync:
+- Architecture/code quality:
+- Architecture/ADR/glossary:
+- Database/DBML:
+- Commits:
+- Residual risks:
+```

package/extensions/arey-pi/core.ts

@@ -0,0 +1,121 @@
+export const requiredAgents = [
+  "tech-lead.md",
+  "spec-author.md",
+  "tdd-implementer.md",
+  "spec-syncer.md",
+  "engineering-reviewer.md",
+  "project-evaluator.md",
+] as const;
+
+export type ScaffoldFile = { template: string; target: string };
+
+export const specScaffoldFiles: ScaffoldFile[] = [
+  { template: "specs-readme.md", target: "specs/README.md" },
+  { template: "features-readme.md", target: "specs/features/README.md" },
+  { template: "feature.feature", target: "specs/features/example.feature" },
+  { template: "database-readme.md", target: "specs/database/README.md" },
+  { template: "database.dbml", target: "specs/database/schema.dbml" },
+  { template: "architecture-readme.md", target: "specs/architecture/README.md" },
+  { template: "decisions-readme.md", target: "specs/decisions/README.md" },
+  { template: "adr.md", target: "specs/decisions/0001-record-architecture-decision.md" },
+  { template: "glossary.md", target: "specs/glossary.md" },
+];
+
+export const docsScaffoldFiles: ScaffoldFile[] = [
+  { template: "docs-readme.md", target: "docs/README.md" },
+  { template: "project-readiness-report.md", target: "docs/project-readiness-report.md" },
+];
+
+const selectiveBootstrapFlags = ["--agentsmd", "--specs", "--docs", "--full"];
+
+export type BootstrapPlan = {
+  flags: string[];
+  force: boolean;
+  full: boolean;
+  defaultFullBootstrap: boolean;
+  createAgentsMd: boolean;
+  createSpecs: boolean;
+  createDocs: boolean;
+};
+
+export function parseBootstrapFlags(args: string): BootstrapPlan {
+  const flags = args.split(/\s+/).filter(Boolean);
+  const force = flags.includes("--force");
+  const full = flags.includes("--full");
+  const hasSelectiveScaffoldFlag = flags.some((flag) => selectiveBootstrapFlags.includes(flag));
+  const defaultFullBootstrap = !hasSelectiveScaffoldFlag;
+
+  return {
+    flags,
+    force,
+    full,
+    defaultFullBootstrap,
+    createAgentsMd: defaultFullBootstrap || flags.includes("--agentsmd") || full,
+    createSpecs: defaultFullBootstrap || flags.includes("--specs") || full,
+    createDocs: defaultFullBootstrap || flags.includes("--docs") || full,
+  };
+}
+
+export type WorkflowKind = "feature" | "bugfix" | "sync" | "review" | "assess" | string;
+
+export function workflowMessage(kind: WorkflowKind, args: string): string {
+  const target = args.trim() || "the current repository/task";
+  const common = `Act as the Arey Pi tech lead. Use pi-subagents when available and appropriate. Keep orchestration authority in the parent session, give child agents bounded tasks, and keep one writer in the active worktree at a time. Follow Arey Pi rules, preserve TDD, and report evidence clearly.`;
+
+  switch (kind) {
+    case "feature":
+      return `${common}\n\nRun the Arey Pi feature workflow for: ${target}\n\nExpected flow: arey-pi.spec-author for canonical specs, arey-pi.tdd-implementer for Red-Green-Refactor, arey-pi.spec-syncer for final alignment, and fresh reviewers or arey-pi.engineering-reviewer for adversarial quality review when risk warrants it. Use scout/context-builder/planner first if the codebase context is not clear.`;
+    case "bugfix":
+      return `${common}\n\nRun the Arey Pi bugfix workflow for: ${target}\n\nStart with a regression test that fails for the bug, keep tests outside production source directories by default, implement the minimal high-quality fix, synchronise specs and docs, and review engineering quality.`;
+    case "sync":
+      return `${common}\n\nRun Arey Pi spec and documentation sync for: ${target}\n\nVerify Gherkin, tests, code, DBML, ADRs, glossary, architecture docs, README files, docs, AGENTS.md, skills, prompts, rules, agents, commands, and tooling instructions. End with both a spec status and a documentation status.`;
+    case "review":
+      return `${common}\n\nRun an Arey Pi engineering review for: ${target}\n\nPrefer fresh-context review. Review architecture, code quality, test quality and location, quality tooling, security, privacy, operability, maintainability, and spec/ADR/DBML/documentation concerns. Classify findings by severity.`;
+    case "assess":
+      return `${common}\n\nAssess this repository against Arey Pi Project Readiness. Audit only by default. Produce scores, evidence, blockers, quick wins, and a prioritised improvement plan.`;
+    default:
+      return `${common}\n\nWork on: ${target}`;
+  }
+}
+
+export type DoctorReportInput = {
+  packageVersion: string;
+  cwd: string;
+  packageRulesPresent: boolean;
+  packageTemplatesPresent: boolean;
+  packageAgentsCount: number;
+  requiredAgentsCount: number;
+  hasSubagentsCommand: boolean;
+  installedAgentsCount: number;
+  hasRootAgentsMd: boolean;
+  hasPiSettings: boolean;
+  promptsCount: number;
+  skillsCount: number;
+  missingAgents: string[];
+};
+
+export function buildDoctorReport(input: DoctorReportInput): string {
+  return [
+    "# Arey Pi Doctor",
+    "",
+    `- Package: arey-pi@${input.packageVersion}`,
+    `- Project: ${input.cwd}`,
+    `- Package rules present: ${input.packageRulesPresent ? "yes" : "no"}`,
+    `- Package templates present: ${input.packageTemplatesPresent ? "yes" : "no"}`,
+    `- Package agents present: ${input.packageAgentsCount}/${input.requiredAgentsCount}`,
+    `- pi-subagents command detected: ${input.hasSubagentsCommand ? "yes" : "no"}`,
+    `- Project-local Arey Pi agents: ${input.installedAgentsCount}/${input.requiredAgentsCount}`,
+    `- Root AGENTS.md: ${input.hasRootAgentsMd ? "yes" : "no"}`,
+    `- .pi/settings.json: ${input.hasPiSettings ? "yes" : "no"}`,
+    `- Arey Pi prompts discovered: ${input.promptsCount}`,
+    `- Arey Pi skills discovered: ${input.skillsCount}`,
+    "",
+    "## Missing project agents",
+    input.missingAgents.length ? input.missingAgents.map((agent) => `- ${agent}`).join("\n") : "- none",
+    "",
+    "## Recommended next step",
+    input.installedAgentsCount === input.requiredAgentsCount
+      ? "- Project-local Arey Pi subagents are installed. Use `/arey-feature`, `/arey-bugfix`, `/arey-sync`, `/arey-review`, or natural language."
+      : "- Run `/arey-bootstrap` to install project-local Arey Pi subagents.",
+  ].join("\n");
+}

package/extensions/{arey-pi.ts → arey-pi/index.ts}

@@ -2,18 +2,20 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileS
 import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  buildDoctorReport,
+  docsScaffoldFiles,
+  parseBootstrapFlags,
+  requiredAgents,
+  specScaffoldFiles,
+  workflowMessage,
+  type ScaffoldFile,
+} from "./core.ts";
 
 const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 const agentSourceDir = join(packageRoot, "agents");
 const rulesDir = join(packageRoot, "rules");
-const requiredAgents = [
-  "tech-lead.md",
-  "spec-author.md",
-  "tdd-implementer.md",
-  "spec-syncer.md",
-  "engineering-reviewer.md",
-  "project-evaluator.md",
-];
+const templatesDir = join(packageRoot, "templates");
 
 function cwdFrom(ctx: unknown): string {
   const maybe = ctx as { cwd?: string };
@@ -64,52 +66,45 @@ function copyAgents(targetDir: string, force: boolean): { copied: string[]; skip
   return { copied, skipped, missing };
 }
 
-function starterAgentsMd(): string {
-  return `# Agent Instructions
+type ScaffoldResult = { created: string[]; skipped: string[] };
+
+function templateContent(name: string): string {
+  return readFileSync(join(templatesDir, name), "utf8");
+}
 
-This project uses Arey Pi.
+function writeTemplateIfMissing(file: ScaffoldFile, force: boolean, cwd: string, result: ScaffoldResult) {
+  const target = join(cwd, file.target);
+  mkdirSync(dirname(target), { recursive: true });
 
-## Delivery rules
+  if (fileExists(target) && !force) {
+    result.skipped.push(file.target);
+    return;
+  }
 
-- Treat canonical specs as the source of truth.
-- Use Gherkin for behaviour specs.
-- Use DBML for database specs when the project has persistence.
-- Follow TDD for production behaviour changes.
-- Keep specs, tests, code, DBML, ADRs, glossary, and architecture docs synchronised.
-- Capture significant technical decisions in high-quality ADRs.
-- Run formatter, lint/static analysis, typecheck, tests, and relevant dynamic analysis where available.
-- Use incremental Conventional Commits for meaningful steps.
+  writeFileSync(target, templateContent(file.template));
+  result.created.push(file.target);
+}
 
-## Subagents
+function scaffoldFiles(cwd: string, force: boolean, files: ScaffoldFile[]): ScaffoldResult {
+  const result: ScaffoldResult = { created: [], skipped: [] };
 
-Project-local Arey Pi subagents live in:
+  for (const file of files) {
+    writeTemplateIfMissing(file, force, cwd, result);
+  }
 
-\`\`\`txt
-.pi/agents/arey-pi/
-\`\`\`
+  return result;
+}
 
-Use them through pi-subagents when available.
-`;
+function scaffoldSpecs(cwd: string, force: boolean): ScaffoldResult {
+  return scaffoldFiles(cwd, force, specScaffoldFiles);
 }
 
-function workflowMessage(kind: string, args: string): string {
-  const target = args.trim() || "the current repository/task";
-  const common = `Act as the Arey Pi tech lead. Use pi-subagents when available and appropriate. Keep orchestration authority in the parent session. Follow Arey Pi rules, preserve TDD, and report evidence clearly.`;
-
-  switch (kind) {
-    case "feature":
-      return `${common}\n\nRun the Arey Pi feature workflow for: ${target}\n\nExpected flow: spec-author for canonical specs, tdd-implementer for Red-Green-Refactor, spec-syncer for final alignment, and engineering-reviewer for adversarial quality review when risk warrants it.`;
-    case "bugfix":
-      return `${common}\n\nRun the Arey Pi bugfix workflow for: ${target}\n\nStart with a regression test that fails for the bug, then implement the minimal high-quality fix, synchronise specs, and review engineering quality.`;
-    case "sync":
-      return `${common}\n\nRun Arey Pi spec and documentation sync for: ${target}\n\nVerify Gherkin, tests, code, DBML, ADRs, glossary, architecture docs, README files, docs, AGENTS.md, skills, prompts, rules, agents, commands, and tooling instructions. End with both a spec status and a documentation status.`;
-    case "review":
-      return `${common}\n\nRun an Arey Pi engineering review for: ${target}\n\nReview architecture, code quality, test quality, quality tooling, security, privacy, operability, maintainability, and spec/ADR/DBML concerns. Classify findings by severity.`;
-    case "assess":
-      return `${common}\n\nAssess this repository against Arey Pi Project Readiness. Audit only by default. Produce scores, evidence, blockers, quick wins, and a prioritised improvement plan.`;
-    default:
-      return `${common}\n\nWork on: ${target}`;
-  }
+function scaffoldDocs(cwd: string, force: boolean): ScaffoldResult {
+  return scaffoldFiles(cwd, force, docsScaffoldFiles);
+}
+
+function starterAgentsMd(): string {
+  return templateContent("AGENTS.md");
 }
 
 function sendWorkflow(
@@ -163,28 +158,21 @@ export default function areyPi(pi: ExtensionAPI) {
         (command) => command.source === "skill" && command.sourceInfo?.source?.includes("arey-pi"),
       );
 
-      const report = [
-        "# Arey Pi Doctor",
-        "",
-        `- Package: arey-pi@${packageVersion()}`,
-        `- Project: ${cwd}`,
-        `- Package rules present: ${dirExists(rulesDir) ? "yes" : "no"}`,
-        `- Package agents present: ${packageAgents.length}/${requiredAgents.length}`,
-        `- pi-subagents command detected: ${hasSubagentsCommand ? "yes" : "no"}`,
-        `- Project-local Arey Pi agents: ${installedAgents.length}/${requiredAgents.length}`,
-        `- Root AGENTS.md: ${fileExists(join(cwd, "AGENTS.md")) ? "yes" : "no"}`,
-        `- .pi/settings.json: ${fileExists(join(cwd, ".pi", "settings.json")) ? "yes" : "no"}`,
-        `- Arey Pi prompts discovered: ${prompts.length}`,
-        `- Arey Pi skills discovered: ${skills.length}`,
-        "",
-        "## Missing project agents",
-        missingAgents.length ? missingAgents.map((agent) => `- ${agent}`).join("\n") : "- none",
-        "",
-        "## Recommended next step",
-        installedAgents.length === requiredAgents.length
-          ? "- Project-local Arey Pi subagents are installed. Use `/arey-feature`, `/arey-bugfix`, `/arey-sync`, `/arey-review`, or natural language."
-          : "- Run `/arey-bootstrap` to install project-local Arey Pi subagents.",
-      ].join("\n");
+      const report = buildDoctorReport({
+        packageVersion: packageVersion(),
+        cwd,
+        packageRulesPresent: dirExists(rulesDir),
+        packageTemplatesPresent: dirExists(templatesDir),
+        packageAgentsCount: packageAgents.length,
+        requiredAgentsCount: requiredAgents.length,
+        hasSubagentsCommand,
+        installedAgentsCount: installedAgents.length,
+        hasRootAgentsMd: fileExists(join(cwd, "AGENTS.md")),
+        hasPiSettings: fileExists(join(cwd, ".pi", "settings.json")),
+        promptsCount: prompts.length,
+        skillsCount: skills.length,
+        missingAgents,
+      });
 
       pi.sendMessage({
         customType: "arey-pi-doctor",
@@ -196,19 +184,22 @@ export default function areyPi(pi: ExtensionAPI) {
   });
 
   pi.registerCommand("arey-bootstrap", {
-    description: "Install Arey Pi project-local subagents and optional starter AGENTS.md",
+    description: "Install Arey Pi subagents and optionally scaffold specs/docs",
     handler: async (args, ctx) => {
       const cwd = cwdFrom(ctx);
-      const force = args.split(/\s+/).includes("--force");
-      const createAgentsMd = args.split(/\s+/).includes("--agentsmd");
+      const { force, createAgentsMd, createSpecs, createDocs } = parseBootstrapFlags(args);
       const targetDir = join(cwd, ".pi", "agents", "arey-pi");
       const result = copyAgents(targetDir, force);
+      const specsResult = createSpecs ? scaffoldSpecs(cwd, force) : { created: [], skipped: [] };
+      const docsResult = createDocs ? scaffoldDocs(cwd, force) : { created: [], skipped: [] };
       const agentsMdPath = join(cwd, "AGENTS.md");
       let agentsMdStatus = "unchanged";
 
       if (!fileExists(agentsMdPath) && (createAgentsMd || force)) {
         writeFileSync(agentsMdPath, starterAgentsMd());
         agentsMdStatus = "created";
+      } else if (fileExists(agentsMdPath) && createAgentsMd && !force) {
+        agentsMdStatus = "skipped existing";
       }
 
       const report = [
@@ -219,13 +210,27 @@ export default function areyPi(pi: ExtensionAPI) {
         `- Skipped existing agents: ${result.skipped.length}`,
         `- Missing package agents: ${result.missing.length}`,
         `- AGENTS.md: ${agentsMdStatus}`,
+        `- Spec scaffold created: ${specsResult.created.length}`,
+        `- Spec scaffold skipped: ${specsResult.skipped.length}`,
+        `- Docs scaffold created: ${docsResult.created.length}`,
+        `- Docs scaffold skipped: ${docsResult.skipped.length}`,
         "",
-        "## Copied",
+        "## Copied agents",
         result.copied.length ? result.copied.map((agent) => `- ${agent}`).join("\n") : "- none",
         "",
-        "## Skipped",
+        "## Skipped agents",
         result.skipped.length ? result.skipped.map((agent) => `- ${agent}`).join("\n") : "- none",
         "",
+        "## Created scaffold files",
+        [...specsResult.created, ...docsResult.created].length
+          ? [...specsResult.created, ...docsResult.created].map((path) => `- ${path}`).join("\n")
+          : "- none",
+        "",
+        "## Skipped scaffold files",
+        [...specsResult.skipped, ...docsResult.skipped].length
+          ? [...specsResult.skipped, ...docsResult.skipped].map((path) => `- ${path}`).join("\n")
+          : "- none",
+        "",
         "Run `/arey-doctor` to verify setup.",
       ].join("\n");
 
@@ -233,7 +238,7 @@ export default function areyPi(pi: ExtensionAPI) {
         customType: "arey-pi-bootstrap",
         content: report,
         display: true,
-        details: result,
+        details: { agents: result, specs: specsResult, docs: docsResult, agentsMd: agentsMdStatus },
       });
     },
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arey-pi",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "A Pi package for canonical Gherkin specs, non-negotiable TDD, spec synchronisation, AI harness readiness, and senior-quality software delivery.",
   "license": "MIT",
   "author": "Alejandro Rey Leyva",
@@ -24,6 +24,7 @@
   ],
   "files": [
     "agents/",
+    "assets/",
     "extensions/",
     "docs/",
     "skills/",
@@ -35,20 +36,22 @@
   ],
   "pi": {
     "extensions": [
-      "./extensions/arey-pi.ts"
+      "./extensions/arey-pi/index.ts"
     ],
     "skills": [
       "./skills"
     ],
     "prompts": [
       "./prompts"
-    ]
+    ],
+    "image": "https://cdn.jsdelivr.net/gh/alereyleyva/arey-pi@main/assets/arey-pi-logo.png"
   },
   "scripts": {
     "format": "biome format --write .",
     "lint": "biome lint .",
     "typecheck": "tsc --noEmit",
-    "check": "bun run lint && bun run typecheck",
+    "test": "bun test",
+    "check": "bun run lint && bun run typecheck && bun run test",
     "prepublishOnly": "bun run check && npm pack --dry-run"
   },
   "peerDependencies": {
@@ -65,6 +68,7 @@
   "devDependencies": {
     "@biomejs/biome": "^2.4.16",
     "@earendil-works/pi-coding-agent": "^0.78.1",
+    "@types/bun": "^1.3.14",
     "@types/node": "^25.9.2",
     "typescript": "^6.0.3"
   }

package/rules/assessment/project-readiness.md

@@ -54,6 +54,7 @@ Check whether:
 - coverage is available or intentionally absent;
 - mutation testing is configured for critical code or proposed as an improvement;
 - tests assert behaviour rather than implementation mechanics;
+- tests are organised in a dedicated test/spec directory rather than colocated with production source files without justification;
 - edge cases and failure paths are covered for important behaviour;
 - surviving mutants or weak assertions are triaged when evidence exists.
 

package/rules/core/definition-of-done.md

@@ -12,6 +12,7 @@ A change is complete when:
 
 - relevant Gherkin specs exist or are explicitly confirmed unaffected;
 - production behaviour is covered by meaningful tests;
+- tests are placed in a dedicated test/spec directory outside production source trees, unless an explicit project or framework constraint justifies an exception;
 - test quality has been assessed with mutation testing, coverage, or explicit review appropriate to risk;
 - TDD was followed for production behaviour;
 - bug fixes include regression tests;
@@ -37,6 +38,7 @@ A change is not done if:
 
 - behaviour changed but Gherkin was not updated or justified unaffected;
 - tests were skipped silently;
+- new tests are colocated inside production source directories without a documented convention or approved exception;
 - production code was written without TDD evidence;
 - failing tests remain unresolved without explicit blocker status;
 - code contradicts canonical specs;
@@ -57,7 +59,7 @@ Agents should close with:
 ```txt
 Done summary:
 - Behaviour/spec impact:
-- Tests/TDD:
+- Tests/TDD, including test location:
 - Validation:
 - Quality tooling:
 - Spec sync: