acstack 0.50.3 → 0.51.0

package/pi/agents/task-checker.md

@@ -20,7 +20,7 @@ A fixed agent sequence is not a prerequisite.
 
 ## Project configuration
 
-Read `acstack/project.yaml` for project-specific settings:
+Read `.acstack/project.yaml` for project-specific settings:
 
 - `commands.test` – how to run tests
 - `commands.test_collect` – how to count tests (for baseline)
@@ -84,7 +84,7 @@ If ANY pre-existing test fails -> FAIL immediately.
 
 ### 4.6 Test count baseline
 
-If `project.yaml` configures `commands.test_collect`, compare the current test count against `.test-baseline`:
+If `project.yaml` configures `commands.test_collect`, compare the current test count against `.acstack/.test-baseline`:
 
 If CURRENT < BASELINE, investigate the removed coverage and report any unmet project baseline requirement.
 A count alone neither proves adequacy nor establishes who removed a test.
@@ -160,6 +160,11 @@ This is where most failures hide. Verify the complete chain:
 
 - Dependent tasks actually work together
 - Existing functionality has no breaking changes
+- Apply the shared communication standard to code design, not only explanations
+- Read connected callers and dependencies to verify coherent responsibility boundaries and peer components at comparable abstraction levels
+- Check that small, useful interfaces hide real complexity without exposing internals or adding pass-through layers
+- Check that names match meaning and structure follows responsibility rather than folder layout
+- Judge concrete effects on callers, not line count or indirection; do not require nesting or wrappers
 
 ### 7. Spec accuracy
 
@@ -216,3 +221,79 @@ This is where most failures hide. Verify the complete chain:
 - **Be specific**: Always include file paths and line numbers for issues.
 - **Binary decisions**: PASS or FAIL
 - **Verify, don't trust**: Check actual code, not documentation claims.
+
+Use the fewest clear words that preserve all necessary information.
+
+## Answer the reader's question
+
+- Lead with the answer, recommendation, or result the reader needs
+- Give enough context for the reader to understand and act
+    - A short reply can be a direct sentence or a few bullets
+    - Add context, a problem statement, or a solution section only when the reader needs it
+- Match detail to the audience
+    - A human needs the facts that change a decision or next action
+    - An agent handoff needs every constraint required to continue correctly
+    - A durable document must make sense to someone outside the original conversation
+- Preserve necessary qualifications, evidence, errors, security warnings, accessibility requirements, and destructive-action confirmations
+- Separate the current answer from decision history
+    - State what applies now before explaining how the decision changed
+
+## Let the ideas determine the structure
+
+- Use only the structure needed to explain the ideas and their relationships
+    - Use prose for a connected explanation, bullets for distinct points, numbered steps for a sequence, and tables for comparisons
+    - Use a diagram when it makes relationships easier to understand
+    - Short replies need no prescribed sections, diagram, or bullet quota
+- Make each parent summarize its children
+    - A heading or parent bullet states the point supported by the detail below it
+    - Add a takeaway line only when the heading leaves a useful conclusion unstated
+- Keep siblings at the same conceptual level, answering the same question
+    - Separate mixed questions, merge overlapping points, and fill gaps in the parent's claim
+    - Order points by sequence, importance, or another relationship the reader can follow
+- Keep names consistent from overview to detail
+    - Reuse the same name for the same thing across prose, diagrams, headings, and code references
+    - Make the link explicit when a human-readable name differs from an identifier
+- Orient the reader before introducing detail
+    - Define unfamiliar terms before relying on them
+    - Name the subject when a pronoun would be ambiguous
+    - Show dependencies and crosscutting relationships as links, not invented parent-child relationships
+- In code and design, use coherent responsibilities and small, useful interfaces
+    - A deep module hides substantial implementation behind a small interface
+    - Keep peer components at comparable levels of abstraction
+    - Keep implementation details behind the interface callers need
+    - Add a layer only when it hides real complexity or owns a distinct responsibility
+    - Do not force relationships across modules into a containment tree
+
+## Write in plain language
+
+- Prefer common, concrete words and natural word order
+    - Keep necessary technical terms and define unfamiliar abbreviations
+    - Cut grand claims, filler, repeated points, and metaphors the reader must decode
+    - Use examples when they explain a point faster than an abstract description
+- Keep sentences focused and paragraphs easy to scan
+    - Split a sentence when its clauses compete for attention
+    - Keep a cause, condition, contrast, or consequence together when splitting would obscure the relationship
+    - Sentence, paragraph, and noun-string lengths are review signals, not correctness limits
+- Name the actor when it helps the reader understand responsibility
+    - Prefer active voice, present-tense descriptions, and direct instructions
+    - Keep passive voice when the actor is unknown or irrelevant
+- State claims at the strength supported by evidence
+    - Name sources, checks run, results, and remaining uncertainty
+    - Explain an important distinction, including what something does not do, when the reader needs it
+- Use sentence-case headings and restrained emphasis
+- Use straight quotes, the Oxford comma, and three periods for an ellipsis
+- Use a period, parentheses, or a spaced en dash instead of an em dash
+- Carry meaning in words, not emoji or color alone
+- Format Markdown so the reader sees the intended grouping
+    - Indent nested bullets four spaces per level and leave a blank line before a list
+    - Use parallel grammar and consistent punctuation within a list
+    - Short bullet fragments need no final period
+
+## Before you send
+
+- Can the reader find the answer without reading every detail?
+- Does every level summarize the detail below it?
+- Do siblings answer the same question at the same level?
+- Can the reader follow the same names from overview to detail?
+- Can you remove words or structure without losing meaning, necessary context, or safeguards?
+- Have you separated evidence from assumptions and the current answer from its history?

package/pi/agents/task-executor.md

@@ -19,10 +19,11 @@ Implement the assigned requirements under the shared Implementation discipline i
 - Work directly on source and tests unless the task assigns separate ownership
 - Honor stronger user process requests
 - Read `test-conventions` before writing tests
+- Apply the shared communication standard to code design as well as explanations
 
 ## Project configuration
 
-Read `acstack/project.yaml` for project-specific settings:
+Read `.acstack/project.yaml` for project-specific settings:
 
 - `directories.source` – where to write source code
 - `directories.tests` – test directory, subject to assigned ownership
@@ -45,12 +46,17 @@ Read `acstack/project.yaml` for project-specific settings:
 
 3. **Implementation Planning**: Before coding, briefly outline your approach:
     - Identify files to create or modify
+    - Identify the coherent responsibility this change serves, its callers, and its dependencies
     - Note dependencies or prerequisites
     - Consider the testing strategy defined in the task
 
 4. **Focused Execution**:
     - Implement one subtask at a time
     - Follow the project's coding standards
+    - Keep peer components at comparable abstraction levels, organized by responsibility rather than folder layout
+    - Hide real complexity behind small, useful interfaces (deep modules); keep implementation details out of callers
+    - Make names match responsibilities; avoid pass-through layers that add no useful boundary
+    - Do not force nesting or wrappers; neither line count nor indirection measures design quality
     - Prefer editing existing files over creating new ones
     - Only create files essential for task completion
 
@@ -90,3 +96,79 @@ Say what stopped you.
 - Report a requirement you could not build, and the question that settles it
 - Consider edge cases and error handling
 - Report verification evidence and blockers to the completion owner
+
+Use the fewest clear words that preserve all necessary information.
+
+## Answer the reader's question
+
+- Lead with the answer, recommendation, or result the reader needs
+- Give enough context for the reader to understand and act
+    - A short reply can be a direct sentence or a few bullets
+    - Add context, a problem statement, or a solution section only when the reader needs it
+- Match detail to the audience
+    - A human needs the facts that change a decision or next action
+    - An agent handoff needs every constraint required to continue correctly
+    - A durable document must make sense to someone outside the original conversation
+- Preserve necessary qualifications, evidence, errors, security warnings, accessibility requirements, and destructive-action confirmations
+- Separate the current answer from decision history
+    - State what applies now before explaining how the decision changed
+
+## Let the ideas determine the structure
+
+- Use only the structure needed to explain the ideas and their relationships
+    - Use prose for a connected explanation, bullets for distinct points, numbered steps for a sequence, and tables for comparisons
+    - Use a diagram when it makes relationships easier to understand
+    - Short replies need no prescribed sections, diagram, or bullet quota
+- Make each parent summarize its children
+    - A heading or parent bullet states the point supported by the detail below it
+    - Add a takeaway line only when the heading leaves a useful conclusion unstated
+- Keep siblings at the same conceptual level, answering the same question
+    - Separate mixed questions, merge overlapping points, and fill gaps in the parent's claim
+    - Order points by sequence, importance, or another relationship the reader can follow
+- Keep names consistent from overview to detail
+    - Reuse the same name for the same thing across prose, diagrams, headings, and code references
+    - Make the link explicit when a human-readable name differs from an identifier
+- Orient the reader before introducing detail
+    - Define unfamiliar terms before relying on them
+    - Name the subject when a pronoun would be ambiguous
+    - Show dependencies and crosscutting relationships as links, not invented parent-child relationships
+- In code and design, use coherent responsibilities and small, useful interfaces
+    - A deep module hides substantial implementation behind a small interface
+    - Keep peer components at comparable levels of abstraction
+    - Keep implementation details behind the interface callers need
+    - Add a layer only when it hides real complexity or owns a distinct responsibility
+    - Do not force relationships across modules into a containment tree
+
+## Write in plain language
+
+- Prefer common, concrete words and natural word order
+    - Keep necessary technical terms and define unfamiliar abbreviations
+    - Cut grand claims, filler, repeated points, and metaphors the reader must decode
+    - Use examples when they explain a point faster than an abstract description
+- Keep sentences focused and paragraphs easy to scan
+    - Split a sentence when its clauses compete for attention
+    - Keep a cause, condition, contrast, or consequence together when splitting would obscure the relationship
+    - Sentence, paragraph, and noun-string lengths are review signals, not correctness limits
+- Name the actor when it helps the reader understand responsibility
+    - Prefer active voice, present-tense descriptions, and direct instructions
+    - Keep passive voice when the actor is unknown or irrelevant
+- State claims at the strength supported by evidence
+    - Name sources, checks run, results, and remaining uncertainty
+    - Explain an important distinction, including what something does not do, when the reader needs it
+- Use sentence-case headings and restrained emphasis
+- Use straight quotes, the Oxford comma, and three periods for an ellipsis
+- Use a period, parentheses, or a spaced en dash instead of an em dash
+- Carry meaning in words, not emoji or color alone
+- Format Markdown so the reader sees the intended grouping
+    - Indent nested bullets four spaces per level and leave a blank line before a list
+    - Use parallel grammar and consistent punctuation within a list
+    - Short bullet fragments need no final period
+
+## Before you send
+
+- Can the reader find the answer without reading every detail?
+- Does every level summarize the detail below it?
+- Do siblings answer the same question at the same level?
+- Can the reader follow the same names from overview to detail?
+- Can you remove words or structure without losing meaning, necessary context, or safeguards?
+- Have you separated evidence from assumptions and the current answer from its history?

package/pi/agents/test-writer.md

@@ -29,7 +29,7 @@ You write tests from requirements and application programming interface (API) co
 
 ## Project configuration
 
-Read `acstack/project.yaml` for project-specific settings:
+Read `.acstack/project.yaml` for project-specific settings:
 
 - `directories.tests` – where to create test files
 - `directories.source` – source code root (for mirroring structure)
@@ -144,3 +144,79 @@ When complete, report:
 - Commands and results, including available failing-first evidence and any tests-first departure
 - Any criterion you could not test without picking an answer, and the question that settles it
 - Any criterion you could not test for another reason, and what stopped you
+
+Use the fewest clear words that preserve all necessary information.
+
+## Answer the reader's question
+
+- Lead with the answer, recommendation, or result the reader needs
+- Give enough context for the reader to understand and act
+    - A short reply can be a direct sentence or a few bullets
+    - Add context, a problem statement, or a solution section only when the reader needs it
+- Match detail to the audience
+    - A human needs the facts that change a decision or next action
+    - An agent handoff needs every constraint required to continue correctly
+    - A durable document must make sense to someone outside the original conversation
+- Preserve necessary qualifications, evidence, errors, security warnings, accessibility requirements, and destructive-action confirmations
+- Separate the current answer from decision history
+    - State what applies now before explaining how the decision changed
+
+## Let the ideas determine the structure
+
+- Use only the structure needed to explain the ideas and their relationships
+    - Use prose for a connected explanation, bullets for distinct points, numbered steps for a sequence, and tables for comparisons
+    - Use a diagram when it makes relationships easier to understand
+    - Short replies need no prescribed sections, diagram, or bullet quota
+- Make each parent summarize its children
+    - A heading or parent bullet states the point supported by the detail below it
+    - Add a takeaway line only when the heading leaves a useful conclusion unstated
+- Keep siblings at the same conceptual level, answering the same question
+    - Separate mixed questions, merge overlapping points, and fill gaps in the parent's claim
+    - Order points by sequence, importance, or another relationship the reader can follow
+- Keep names consistent from overview to detail
+    - Reuse the same name for the same thing across prose, diagrams, headings, and code references
+    - Make the link explicit when a human-readable name differs from an identifier
+- Orient the reader before introducing detail
+    - Define unfamiliar terms before relying on them
+    - Name the subject when a pronoun would be ambiguous
+    - Show dependencies and crosscutting relationships as links, not invented parent-child relationships
+- In code and design, use coherent responsibilities and small, useful interfaces
+    - A deep module hides substantial implementation behind a small interface
+    - Keep peer components at comparable levels of abstraction
+    - Keep implementation details behind the interface callers need
+    - Add a layer only when it hides real complexity or owns a distinct responsibility
+    - Do not force relationships across modules into a containment tree
+
+## Write in plain language
+
+- Prefer common, concrete words and natural word order
+    - Keep necessary technical terms and define unfamiliar abbreviations
+    - Cut grand claims, filler, repeated points, and metaphors the reader must decode
+    - Use examples when they explain a point faster than an abstract description
+- Keep sentences focused and paragraphs easy to scan
+    - Split a sentence when its clauses compete for attention
+    - Keep a cause, condition, contrast, or consequence together when splitting would obscure the relationship
+    - Sentence, paragraph, and noun-string lengths are review signals, not correctness limits
+- Name the actor when it helps the reader understand responsibility
+    - Prefer active voice, present-tense descriptions, and direct instructions
+    - Keep passive voice when the actor is unknown or irrelevant
+- State claims at the strength supported by evidence
+    - Name sources, checks run, results, and remaining uncertainty
+    - Explain an important distinction, including what something does not do, when the reader needs it
+- Use sentence-case headings and restrained emphasis
+- Use straight quotes, the Oxford comma, and three periods for an ellipsis
+- Use a period, parentheses, or a spaced en dash instead of an em dash
+- Carry meaning in words, not emoji or color alone
+- Format Markdown so the reader sees the intended grouping
+    - Indent nested bullets four spaces per level and leave a blank line before a list
+    - Use parallel grammar and consistent punctuation within a list
+    - Short bullet fragments need no final period
+
+## Before you send
+
+- Can the reader find the answer without reading every detail?
+- Does every level summarize the detail below it?
+- Do siblings answer the same question at the same level?
+- Can the reader follow the same names from overview to detail?
+- Can you remove words or structure without losing meaning, necessary context, or safeguards?
+- Have you separated evidence from assumptions and the current answer from its history?

package/pi/extension.ts

@@ -14,7 +14,7 @@
  *                        from the SSOT style file   (hooks/ac-writing-style-reminder.sh)
  *   agent_before_settle  nudge with a continuity-versus-freshness checkpoint
  *                        as context fills          (hooks/context-pressure.sh)
- *   session_compact      re-inject acstack/HANDOFF.md after a compaction, and
+ *   session_compact      re-inject .acstack/HANDOFF.md after a compaction, and
  *                        restart the nudge ladder   (hooks/session-start-handoff.sh,
  *                                                    hooks/context-pressure.sh)
  *
@@ -31,11 +31,51 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
+import { execFileSync } from "node:child_process";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const troubleshoot = path.join(packageRoot, "TROUBLESHOOTING.md");
 
+function hasLegacyProjectData(root: string): boolean {
+	if (!fs.lstatSync(path.join(root, "acstack"), { throwIfNoEntry: false })?.isDirectory()) return false;
+	return ["project.yaml", "domain-map.yaml"].some(name => {
+		const entry = fs.lstatSync(path.join(root, "acstack", name), { throwIfNoEntry: false });
+		return entry?.isFile() || entry?.isSymbolicLink();
+	}) || ["alignment-packs", "design-reviews", "maps", "specs", "changes", "archive", "decision-logs"].some(name => {
+		const entry = fs.lstatSync(path.join(root, "acstack", name), { throwIfNoEntry: false });
+		return entry?.isDirectory() || entry?.isSymbolicLink();
+	});
+}
+
+function projectRoot(cwd: string): string {
+	let root = path.resolve(cwd);
+	while (true) {
+		if (fs.existsSync(path.join(root, ".acstack")) || hasLegacyProjectData(root)) return root;
+		const parent = path.dirname(root);
+		if (parent === root) break;
+		root = parent;
+	}
+	try {
+		return execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+	} catch {
+		return path.resolve(cwd);
+	}
+}
+
+function ensureProjectData(ctx: ExtensionContext, root: string): boolean {
+	if (hasLegacyProjectData(root)) {
+		report(ctx, "acstack: legacy project data found; run ~/.claude/acstack/bin/acstack project-data migrate before using it.", "warning");
+	}
+	try {
+		execFileSync(process.execPath, [path.join(packageRoot, "cli", "bin", "acstack.js"), "project-data", "ensure"], { cwd: root, stdio: ["ignore", "pipe", "pipe"] });
+		return !hasLegacyProjectData(root);
+	} catch (error) {
+		report(ctx, `acstack: project-data ensure failed; ignore policy is not confirmed installed. Skipping project activation and private writes. ${error instanceof Error ? error.message : String(error)}`, "error");
+		return false;
+	}
+}
+
 /** pi-subagents' background runner sets this in every child process. */
 const SUBAGENT_CHILD_ENV = "PI_SUBAGENT_CHILD";
 /** pi-subagents sets this instead in a child it places in its own herdr pane. */
@@ -213,11 +253,20 @@ function stripFrontmatter(text: string): string {
 
 /**
  * The per-turn reminder, extracted from the style file on every call so it
- * cannot drift. Mirrors the awk in hooks/ac-writing-style-reminder.sh line for
- * line: the top-level lines of "## Who you are", then "## Before you send" in
- * full. tests/test-pi-extension.sh checks the two produce the same text.
+ * cannot drift. The bundled style uses a complete marked communication block,
+ * matching hooks/ac-writing-style-reminder.sh. Keep the older heading-based
+ * extraction below for user-owned custom styles.
  */
 export function extractWritingReminder(style: string): string | undefined {
+	const start = "<!-- acstack:communication:start -->\n";
+	const end = "<!-- acstack:communication:end -->";
+	const startAt = style.indexOf(start);
+	if (startAt !== -1) {
+		const endAt = style.indexOf(end, startAt + start.length);
+		if (endAt === -1) return undefined;
+		const shared = style.slice(startAt + start.length, endAt);
+		return shared.trim() ? `ac-writing-style reminder\n\n${shared}` : undefined;
+	}
 	const out: string[] = [];
 	let persona = false;
 	let checklist = false;
@@ -294,7 +343,7 @@ function flowList(value: string): string[] {
 }
 
 /**
- * The workflow.handoff keys from acstack/project.yaml. A port of read_config
+ * The workflow.handoff keys from .acstack/project.yaml. A port of read_config
  * in hooks/context-pressure.sh, hand-rolled for the same reason: no YAML
  * library is guaranteed to be installed.
  */
@@ -441,12 +490,12 @@ const HANDOFF_PREAMBLE =
 	"wrong assumption taken after compaction is expensive to unwind.\n\n";
 
 /**
- * Consume acstack/HANDOFF.md the way hooks/session-start-handoff.sh does:
+ * Consume .acstack/HANDOFF.md the way hooks/session-start-handoff.sh does:
  * only a file carrying the acstack_handoff marker, moved into a per-map
  * archive so it is never injected twice. Returns the text to inject.
  */
 export function consumeHandoff(cwd: string, now: Date = new Date()): string | undefined {
-	const active = path.join(cwd, "acstack", "HANDOFF.md");
+	const active = path.join(cwd, ".acstack", "HANDOFF.md");
 	const raw = readText(active);
 	if (!raw?.trim()) return undefined;
 
@@ -467,11 +516,11 @@ export function consumeHandoff(cwd: string, now: Date = new Date()): string | un
 	let stamp = (meta.created || "").replace(/[^A-Za-z0-9._-]/g, "-");
 	if (!stamp) stamp = now.toISOString().replace(/\.\d+Z$/, "Z").replace(/:/g, "-");
 
-	const changeDir = path.join(cwd, "acstack", "changes", map);
+	const changeDir = path.join(cwd, ".acstack", "changes", map);
 	const archiveDir =
 		map !== "ad-hoc" && fs.existsSync(changeDir)
 			? path.join(changeDir, "handoffs")
-			: path.join(cwd, "acstack", "handoffs", map);
+			: path.join(cwd, ".acstack", "handoffs", map);
 	try {
 		fs.mkdirSync(archiveDir, { recursive: true });
 		let dest = path.join(archiveDir, `${stamp}.md`);
@@ -597,11 +646,18 @@ export default function acstack(pi: ExtensionAPI): void {
 
 	const orchestratorFile = path.join(packageRoot, "orchestrator", "AGENTS.md");
 	const styleFile = path.join(packageRoot, "output-styles", "ac-writing-style.md");
-	const isProject = (cwd: string) => fs.existsSync(path.join(cwd, "acstack", "project.yaml"));
+	const unsafeProjects = new Set<string>();
+	const isProject = (cwd: string) => !unsafeProjects.has(projectRoot(cwd)) && fs.existsSync(path.join(projectRoot(cwd), ".acstack", "project.yaml"));
 	let warnedSubagents = false;
 
 	pi.on("session_start", async (event, ctx) => {
 		linkClis(ctx);
+		const root = projectRoot(ctx.cwd);
+		if (ensureProjectData(ctx, root)) unsafeProjects.delete(root);
+		else {
+			unsafeProjects.add(root);
+			return;
+		}
 
 		if (!warnedSubagents && !pi.getAllTools().some((tool) => tool.name === "subagent" || tool.name === "Agent")) {
 			warnedSubagents = true;
@@ -662,7 +718,7 @@ export default function acstack(pi: ExtensionAPI): void {
 		const lastText = readText(lastFile)?.trim();
 		const lastRung = lastText && /^\d+$/.test(lastText) ? Number.parseInt(lastText, 10) : undefined;
 
-		const cfg = readHandoffConfig(readText(path.join(ctx.cwd, "acstack", "project.yaml")));
+		const cfg = readHandoffConfig(readText(path.join(projectRoot(ctx.cwd), ".acstack", "project.yaml")));
 		const nudge = contextNudge(usage.tokens, usage.contextWindow, cfg, lastRung, process.env.HERDR_ENV === "1");
 		if (!nudge) return;
 
@@ -693,7 +749,9 @@ export default function acstack(pi: ExtensionAPI): void {
 			}
 		}
 
-		const handoff = consumeHandoff(ctx.cwd);
+		const root = projectRoot(ctx.cwd);
+		if (!ensureProjectData(ctx, root)) return;
+		const handoff = consumeHandoff(root);
 		if (handoff) {
 			pi.sendMessage({ customType: "acstack-handoff", content: handoff, display: true }, { deliverAs: "nextTurn" });
 		}

package/profiles/fullstack-python.yaml

@@ -1,5 +1,5 @@
 # Fullstack Python (backend) + Node/TS (frontend) profile for acstack
-# Used by /acstack:setup to generate acstack/project.yaml
+# Used by /acstack:setup to generate .acstack/project.yaml
 
 commands:
   test: "pytest tests/ --tb=short -x"

package/profiles/node-typescript.yaml

@@ -1,5 +1,5 @@
 # Node/TypeScript project profile for acstack
-# Used by /acstack:setup to generate acstack/project.yaml
+# Used by /acstack:setup to generate .acstack/project.yaml
 
 commands:
   test: "npm test"

package/profiles/python.yaml

@@ -1,5 +1,5 @@
 # Python project profile for acstack
-# Used by /acstack:setup to generate acstack/project.yaml
+# Used by /acstack:setup to generate .acstack/project.yaml
 
 commands:
   test: "pytest tests/ --tb=short -x"