@splinterzzz/ouro 0.1.5 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splinterzzz/ouro",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Loop engineering CLI: repo-rooted kanban + agent loop, powered by Claude Code / Codex headless mode (no API key required).",
   "type": "module",
   "keywords": [

package/src/lib/config.js

@@ -30,6 +30,8 @@ const DEFAULTS = {
   // preview is expected to listen (used to build the clickable URL).
   staging: {
     testCommand: null,
+    lintCommand: null,
+    buildCommand: null,
     previewCommand: null,
     previewPort: null,
   },
@@ -108,6 +110,8 @@ export function getStaging() {
   const s = readConfig().staging ?? {};
   return {
     testCommand: s.testCommand ?? null,
+    lintCommand: s.lintCommand ?? null,
+    buildCommand: s.buildCommand ?? null,
     previewCommand: s.previewCommand ?? null,
     previewPort: s.previewPort ?? null,
   };

package/src/lib/preview.js

@@ -45,7 +45,7 @@ function killTree(proc) {
   if (!proc?.pid) return;
   try {
     if (process.platform === "win32") {
-      spawn("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { stdio: "ignore" });
+      spawn("taskkill", ["/pid", String(proc.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     } else {
       proc.kill("SIGTERM");
     }
@@ -112,7 +112,7 @@ export async function startPreview(ticketId, { cwd, signal } = {}) {
 
   let proc;
   try {
-    proc = spawn(command, { cwd, shell: true });
+    proc = spawn(command, { cwd, shell: true, windowsHide: true });
   } catch (err) {
     return { started: false, reason: `spawn failed: ${err.message || err}`, source };
   }

package/src/lib/staging.js

@@ -2,37 +2,57 @@ import { spawn } from "node:child_process";
 import { getStaging } from "./config.js";
 import { askJson } from "./agentBackend.js";
 
-// Staging test execution. ouro runs the tests (deterministic capture) and the
-// QA agent judges the result — so the test command has to be resolved and run
-// here, not left to the agent's Bash tool.
+// Staging checks. ouro runs the deterministic checks (test, lint, build) and the
+// QA agent judges the result — so the commands have to be resolved and run here,
+// not left to the agent's Bash tool (QA is read-only by design).
 //
-// Resolution order: config.staging.testCommand if set, else a cheap read-only
-// agent inference from the repo (package.json scripts, CLAUDE.md, etc.). If
-// nothing resolves, the stage proceeds tests-only-absent — never a hard failure.
+// Resolution order per check: config.staging.<kind>Command if set, else a cheap
+// read-only agent inference from the repo. If nothing resolves, that check is
+// reported as not-run — the QA gate treats a check with no command in the repo
+// as N/A, never a failure, so a repo without a linter or build step still ships.
+
+// One entry per deterministic check. `configKey` is the config.staging field
+// that pins the command; `infer` is the read-only prompt used when it isn't set.
+const CHECKS = [
+  {
+    kind: "test",
+    configKey: "testCommand",
+    infer:
+      "Infer the single shell command that runs this project's automated tests, from its config (package.json scripts, Makefile, pyproject, etc.). " +
+      'Respond with ONLY JSON: {"command": string|null}. Use null if the repo has no test setup. No prose, no fences.',
+  },
+  {
+    kind: "lint",
+    configKey: "lintCommand",
+    infer:
+      'Infer the single shell command that lints this project, from its config (a package.json "lint" script, eslint/ruff/flake8 config, etc.). ' +
+      'Respond with ONLY JSON: {"command": string|null}. Use null if the repo has no linter. No prose, no fences.',
+  },
+  {
+    kind: "build",
+    configKey: "buildCommand",
+    infer:
+      'Infer the single shell command that builds or compiles this project, from its config (a package.json "build" script, tsc, a bundler config, etc.). ' +
+      'Respond with ONLY JSON: {"command": string|null}. Use null if the repo has no build step. No prose, no fences.',
+  },
+];
 
 /**
- * Resolve the test command. Returns { command, source } where source is
+ * Resolve one check's command. Returns { command, source } where source is
  * "config" | "inferred" | "none".
  */
-export async function resolveTestCommand({ cwd, signal }) {
-  const configured = getStaging().testCommand;
+async function resolveCommand({ configKey, infer, cwd, signal }) {
+  const configured = getStaging()[configKey];
   if (configured) return { command: String(configured), source: "config" };
 
-  const inferred = await askJson({
-    prompt:
-      "Infer the single shell command that runs this project's automated tests, from its config (package.json scripts, Makefile, pyproject, etc.). " +
-      'Respond with ONLY JSON: {"command": string|null}. Use null if the repo has no test setup. No prose, no fences.',
-    cwd,
-    signal,
-  }).catch(() => null);
-
+  const inferred = await askJson({ prompt: infer, cwd, signal }).catch(() => null);
   const command = typeof inferred?.command === "string" ? inferred.command.trim() : "";
   return { command: command || null, source: command ? "inferred" : "none" };
 }
 
 /**
  * Run a shell command, capturing output. Bounded by a timeout so a hanging
- * suite can't wedge the stage. Never rejects — a spawn error resolves as a
+ * check can't wedge the stage. Never rejects — a spawn error resolves as a
  * failed result the QA agent can read.
  */
 export function runShell(command, { cwd, signal, timeoutMs = 10 * 60 * 1000 } = {}) {
@@ -40,7 +60,9 @@ export function runShell(command, { cwd, signal, timeoutMs = 10 * 60 * 1000 } =
     let stdout = "";
     let stderr = "";
     // shell:true so a full command string ("npm test", "pytest -q") runs as-is.
-    const proc = spawn(command, { cwd, shell: true, signal });
+    // windowsHide: the shell child is cmd.exe on win32 — without it every check
+    // run (and every QA loop-back retry) flashes a console window.
+    const proc = spawn(command, { cwd, shell: true, signal, windowsHide: true });
 
     const timer = setTimeout(() => {
       try {
@@ -75,18 +97,18 @@ function tail(text, lines = 40) {
 }
 
 /**
- * Resolve + run the tests. Returns a structured result for the card and the QA
- * agent. `ran: false` means no command resolved — the stage goes on tests-only-
- * absent, never failing on the absence itself.
+ * Resolve + run one check. `ran: false` means no command resolved — the QA gate
+ * reads that as N/A for this repo, never a failure.
  */
-export async function runTests({ cwd, signal }) {
-  const { command, source } = await resolveTestCommand({ cwd, signal });
+async function runOne(check, { cwd, signal }) {
+  const { command, source } = await resolveCommand({ ...check, cwd, signal });
   if (!command) {
-    return { ran: false, command: null, source, passed: null, output: "No test command resolved for this repo." };
+    return { kind: check.kind, ran: false, command: null, source, passed: null, output: `No ${check.kind} command resolved for this repo.` };
   }
 
   const res = await runShell(command, { cwd, signal });
   return {
+    kind: check.kind,
     ran: true,
     command,
     source,
@@ -95,3 +117,19 @@ export async function runTests({ cwd, signal }) {
     output: tail(`${res.stdout}\n${res.stderr}`),
   };
 }
+
+/**
+ * Run every deterministic check (test, lint, build), in order. Sequential so
+ * build and test don't race on the same worktree. Returns { test, lint, build },
+ * each a structured result for the card and the QA agent. Honors `signal` —
+ * once aborted, remaining checks are skipped as not-run.
+ */
+export async function runChecks({ cwd, signal }) {
+  const out = {};
+  for (const check of CHECKS) {
+    out[check.kind] = signal?.aborted
+      ? { kind: check.kind, ran: false, command: null, source: "none", passed: null, output: "cancelled" }
+      : await runOne(check, { cwd, signal });
+  }
+  return out;
+}

package/src/lib/store.js

@@ -126,7 +126,8 @@ class TicketStore extends EventEmitter {
       acceptanceCriteria: [],
       analyzing: false, // transient: the read-only Analyze pass is in flight
       // Staging stage (Feature 9).
-      testResult: null, // { ran, command, source, passed, code, output }
+      testResult: null, // { ran, command, source, passed, code, output } — the test check
+      checks: null, // { test, lint, build } — every deterministic check ouro ran for QA
       previewUrl: null, // clickable local-preview link while one is running
       previewNote: null, // why there's no preview, when there isn't
       qaVerdict: null, // { ready, summary, reasons, uiChange, visualMethod, questions }
@@ -210,6 +211,7 @@ class TicketStore extends EventEmitter {
       awaitingQa: false,
       escalated: false,
       testResult: null,
+      checks: null,
       qaVerdict: null,
       qaAttempts: 0,
       previewUrl: null,

package/src/server/index.js

@@ -8,7 +8,7 @@ import { analyze, runAgent, planTicket, executeTicket, qaReview, getBackendName,
 import { createTicketWorktree, diffWorktree } from "../lib/worktree.js";
 import { contextManifest, listContextFiles, listReferencedFiles } from "../lib/artifacts.js";
 import { appendRunLog, readRunLog } from "../lib/ouroLog.js";
-import { runTests } from "../lib/staging.js";
+import { runChecks } from "../lib/staging.js";
 import { startPreview, stopPreview, previewInfo } from "../lib/preview.js";
 import { readConfig, writeConfig, getDefaultMode, setDefaultMode, getAutoShip, getMaxQaAttempts, telegramTokenVar } from "../lib/config.js";
 import { readEnvVars, writeEnvVars } from "../lib/env.js";
@@ -60,7 +60,7 @@ export function shipOutcome(result) {
 
 // The full context the Senior QA Engineer agent judges against. ouro has already
 // run the tests; the agent validates the running result and the visual review.
-export function qaPrompt(ticket, testResult, preview) {
+export function qaPrompt(ticket, checks, preview) {
   const parts = [
     `You are the QA gate validating ticket [#${ticket.id}] in its git worktree, after it was implemented. You have READ-ONLY tools (Read/Grep/Glob) — you validate, you never modify or execute.`,
     "",
@@ -78,16 +78,19 @@ export function qaPrompt(ticket, testResult, preview) {
     parts.push("", "No explicit acceptance criteria were recorded — validate against the ticket intent above.");
   }
 
-  parts.push("", "Tests (ouro already ran these — you cannot and need not re-run them):");
-  if (testResult?.ran) {
-    parts.push(
-      `- command: ${testResult.command}`,
-      `- result: ${testResult.passed ? "PASSED" : "FAILED"} (exit ${testResult.code})`,
-      "- output tail:",
-      testResult.output || "(no output)"
-    );
-  } else {
-    parts.push(`- none run (${testResult?.output || "no test command resolved"})`);
+  parts.push("", "Checks (ouro already ran these — you cannot and need not re-run them):");
+  for (const [label, r] of [
+    ["Tests", checks?.test],
+    ["Lint", checks?.lint],
+    ["Build", checks?.build],
+  ]) {
+    if (r?.ran) {
+      parts.push(`- ${label}: ${r.passed ? "PASSED" : "FAILED"} (exit ${r.code}) — ${r.command}`);
+      // Only the failing output earns space in the prompt; a PASSED line is enough.
+      if (!r.passed) parts.push("  output tail:", r.output || "(no output)");
+    } else {
+      parts.push(`- ${label}: not run — no such command in this repo (N/A, not a failure).`);
+    }
   }
 
   parts.push("", "Change under review (git diff of the worktree):");
@@ -102,7 +105,7 @@ export function qaPrompt(ticket, testResult, preview) {
     "2. So if it IS a UI change, read the changed UI files and any rendered/built HTML with your Read tool and assess visually from those — do NOT silently skip UI validation.",
     "3. If it is not a UI change, tests-only is fine.",
     "",
-    "Judge the running result against the acceptance criteria and the test results. Never call something ready just because it was asked for.",
+    "Judge the running result against the acceptance criteria and the check results above. A check that RAN and FAILED is grounds to send this back. A check listed as not run (no such command in this repo) is N/A — never block, and never raise a question, solely because a check was not run or could not be verified; ouro runs every check it can and you cannot run more. Never call something ready just because it was asked for.",
     'Respond with ONLY a JSON object, no prose and no fences: {"ready": boolean, "summary": string, "reasons": string[], "ui_change": boolean, "visual_method": "screenshot"|"html"|"none", "questions": string[]}. When not ready, `reasons` must be concrete and actionable. `questions` are open items to resolve before shipping — in an agent loop the engineer answers them itself, in human-in-loop the person does.'
   );
   return parts.join("\n");
@@ -320,21 +323,22 @@ export function createServer() {
     while (!signal.aborted) {
       const ticket = store.get(ticketId);
 
-      // 1. Tests — ouro runs them, deterministically.
-      const testResult = await runTests({ cwd: ticket.worktree, signal });
-      store.update(ticketId, { testResult });
+      // 1. Checks — ouro runs test, lint, and build deterministically. testResult
+      // stays the test result (the card renders it); checks carries all three.
+      const checks = await runChecks({ cwd: ticket.worktree, signal });
+      store.update(ticketId, { testResult: checks.test, checks });
       if (signal.aborted) return;
 
       // 2. QA agent judges the running result against the acceptance criteria.
       const verdict = normalizeVerdict(
         await qaReview({
-          prompt: qaPrompt(ticket, testResult, previewInfo(ticketId)),
+          prompt: qaPrompt(ticket, checks, previewInfo(ticketId)),
           cwd: ticket.worktree,
           signal,
           onEvent,
           agent: getAgent("senior-qa-engineer"),
         }).catch(() => null),
-        testResult
+        checks.test
       );
       if (signal.aborted) return;
       const attempt = (store.get(ticketId).qaAttempts ?? 0) + 1;