@brainervirus/workit-core 0.6.0 → 0.6.1

package/src/core/detector.ts

@@ -5,8 +5,7 @@ import { parseTasksFromPlan } from "./docs-validate";
 
 export type Detection = { choices: string[]; pattern: "alpha" | "numeric" } | null;
 
-export const detectConfigGapError = (text: string): boolean =>
-  text.includes(CONFIG_GAP_MARKER);
+export const detectConfigGapError = (text: string): boolean => text.includes(CONFIG_GAP_MARKER);
 
 // Enforcement-rail detectors: case-insensitive word-boundary heuristics.
 // Conservative bias (D-03): require 1+ signal word AND 0 evidence words;
@@ -86,20 +85,27 @@ export const detectInstructionOption = (questions: unknown): boolean => {
 // Labeled blocks are stripped first so their plain closing fence (```) can't match.
 export const detectRawDocDelivery = (text: string): boolean =>
   /^```\s*$/m.test(text.replace(/```\S[^\n]*\r?\n[\s\S]*?```/g, "")) &&
-  (text.includes("# Spec") || text.includes("# Plan") ||
-    text.includes("**Spec:**") || text.includes("**Branch:**"));
+  (text.includes("# Spec") ||
+    text.includes("# Plan") ||
+    text.includes("**Spec:**") ||
+    text.includes("**Branch:**"));
 
 // Interrogative gate: a literal question mark OR explicit interrogative phrases.
 // Plain "I want to confirm..." or "the script which runs" must NOT match.
-const INTERROGATIVE = /[?¿]|which\s+one|choose\s+(?:one|between|among)|do\s+you\s+(?:want|prefer)|want\s+me\s+to/i;
+const INTERROGATIVE =
+  /[?¿]|which\s+one|choose\s+(?:one|between|among)|do\s+you\s+(?:want|prefer)|want\s+me\s+to/i;
 
 export const detectProseChoices = (text: string): Detection => {
   if (!INTERROGATIVE.test(text)) return null;
 
-  const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+  const lines = text
+    .split("\n")
+    .map((l) => l.trim())
+    .filter(Boolean);
 
-  const alphaAll = [...text.matchAll(/([a-dA-D])[.)]\s+([^\n]*?)(?=\s+[a-dA-D][.)]\s|$)/g)]
-    .map((m) => ({ letter: m[1].toLowerCase(), choice: m[2].trim() }));
+  const alphaAll = [...text.matchAll(/([a-dA-D])[.)]\s+([^\n]*?)(?=\s+[a-dA-D][.)]\s|$)/g)].map(
+    (m) => ({ letter: m[1].toLowerCase(), choice: m[2].trim() }),
+  );
   const alphaLines = lines
     .map((l) => /^([a-dA-D])[.)]\s+(.+)$/.exec(l))
     .filter((m): m is RegExpExecArray => Boolean(m))
@@ -114,8 +120,10 @@ export const detectProseChoices = (text: string): Detection => {
     }
   }
 
-  const numericAll = [...text.matchAll(/(\d+)[.)]\s+([^\n]*?)(?=\s+\d+[.)]\s|$)/g)]
-    .map((m) => ({ num: Number(m[1]), choice: m[2].trim() }));
+  const numericAll = [...text.matchAll(/(\d+)[.)]\s+([^\n]*?)(?=\s+\d+[.)]\s|$)/g)].map((m) => ({
+    num: Number(m[1]),
+    choice: m[2].trim(),
+  }));
   const numericLines = lines
     .map((l) => /^(\d+)[.)]\s+(.+)$/.exec(l))
     .filter((m): m is RegExpExecArray => Boolean(m))
@@ -137,7 +145,10 @@ const stripFences = (text: string): string => {
   const out: string[] = [];
   let inFence = false;
   for (const line of lines) {
-    if (line.startsWith("```")) { inFence = !inFence; continue; }
+    if (line.startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
     if (!inFence) out.push(line);
   }
   return out.join("\n");

package/src/core/docs-repo.ts

@@ -4,8 +4,7 @@ import path from "node:path";
 import { configDir } from "./config";
 
 const configPath = () =>
-  process.env.WORKFLOW_DOCS_REPO_CONFIG
-  ?? path.join(configDir(), "docs-repo.json");
+  process.env.WORKFLOW_DOCS_REPO_CONFIG ?? path.join(configDir(), "docs-repo.json");
 
 export const readDocsRepoConfig = (): { path: string } | null => {
   try {
@@ -25,7 +24,8 @@ export const writeDocsRepoConfig = (docsPath: string): void => {
 export const docsRepoPath = (): string | null => readDocsRepoConfig()?.path ?? null;
 
 export const validateDocsRepo = (docsPath: string): { ok: true } | { ok: false; error: string } => {
-  if (!existsSync(docsPath)) return { ok: false, error: `docs repo path does not exist: ${docsPath}` };
+  if (!existsSync(docsPath))
+    return { ok: false, error: `docs repo path does not exist: ${docsPath}` };
   try {
     execFileSync("git", ["-C", docsPath, "rev-parse", "--is-inside-work-tree"], { stdio: "pipe" });
   } catch {
@@ -49,7 +49,10 @@ export const linkDocsRepo = (
 
 export const listSpecs = (
   workspaceRoot: string,
-): { docs_repo: string | null; specs: { slug: string; spec: string; promoted: boolean; target: string | null }[] } => {
+): {
+  docs_repo: string | null;
+  specs: { slug: string; spec: string; promoted: boolean; target: string | null }[];
+} => {
   const repoPath = docsRepoPath();
   const specs: { slug: string; spec: string; promoted: boolean; target: string | null }[] = [];
   const docsDir = path.join(workspaceRoot, "docs");
@@ -63,7 +66,9 @@ export const listSpecs = (
       if (repoPath) {
         const featuresDir = path.join(repoPath, "features");
         if (existsSync(featuresDir)) {
-          const match = readdirSync(featuresDir).find((d) => new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d));
+          const match = readdirSync(featuresDir).find((d) =>
+            new RegExp(`^20\\d{2}-\\d{2}-${slug}$`).test(d),
+          );
           if (match) {
             promoted = true;
             target = path.join(repoPath, "features", match);
@@ -84,13 +89,20 @@ const monthPrefix = () => {
 };
 
 const readSafe = (p: string): string | null => {
-  try { return readFileSync(p, "utf8"); } catch { return null; }
+  try {
+    return readFileSync(p, "utf8");
+  } catch {
+    return null;
+  }
 };
 
 const specSummary = (specText: string): string => {
-  const contextMatch = specText.match(/## Context\n\n([\s\S]*?)(?=\n## |\Z)/);
+  const contextMatch = specText.match(/## Context\n\n([\s\S]*?)(?=\n## |Z)/);
   if (!contextMatch) return "";
-  const first = contextMatch[1].trim().split("\n").find((l) => l.trim() && !l.startsWith("<!--"));
+  const first = contextMatch[1]
+    .trim()
+    .split("\n")
+    .find((l) => l.trim() && !l.startsWith("<!--"));
   return (first ?? "").trim();
 };
 
@@ -105,7 +117,8 @@ export const promoteSpec = (
   workspaceRoot: string,
   slug: string,
   opts: { confirmed: boolean; force?: boolean },
-): { ok: true; target_dir: string; files: string[]; index_updated: boolean }
+):
+  | { ok: true; target_dir: string; files: string[]; index_updated: boolean }
   | { ok: false; error: string; findings?: unknown[] } => {
   if (!opts.confirmed) return { ok: false, error: "confirmed: true required" };
   if (!SLUG_RE.test(slug)) return { ok: false, error: `invalid slug: ${JSON.stringify(slug)}` };
@@ -121,14 +134,22 @@ export const promoteSpec = (
 
   const planText = readSafe(path.join(workspaceRoot, planRel));
   if (planText !== null) {
-    const validated = docsValidate({ spec_path: specRel, plan_path: planRel, workspace_root: workspaceRoot });
+    const validated = docsValidate({
+      spec_path: specRel,
+      plan_path: planRel,
+      workspace_root: workspaceRoot,
+    });
     if (validated.ok === false) return { ok: false, error: validated.error };
   }
 
   const findings = qualitySpec(specText);
   const hardFindings = findings.filter((f) => f.severity === "hard");
   if (hardFindings.length > 0 && !opts.force) {
-    return { ok: false, error: "spec has hard quality findings; pass force: true to override", findings };
+    return {
+      ok: false,
+      error: "spec has hard quality findings; pass force: true to override",
+      findings,
+    };
   }
 
   // SDD working state must be gitignored before promotion
@@ -136,9 +157,21 @@ export const promoteSpec = (
     const sddDir = path.join(workspaceRoot, "docs", slug, "sdd");
     if (existsSync(sddDir)) {
       try {
-        execFileSync("git", ["-C", workspaceRoot, "check-ignore", path.posix.join("docs", slug, "sdd", "progress.md")], { stdio: "pipe" });
+        execFileSync(
+          "git",
+          [
+            "-C",
+            workspaceRoot,
+            "check-ignore",
+            path.posix.join("docs", slug, "sdd", "progress.md"),
+          ],
+          { stdio: "pipe" },
+        );
       } catch {
-        return { ok: false, error: `docs/${slug}/sdd/ is not gitignored — add 'docs/*/sdd/' to .gitignore or pass force: true` };
+        return {
+          ok: false,
+          error: `docs/${slug}/sdd/ is not gitignored — add 'docs/*/sdd/' to .gitignore or pass force: true`,
+        };
       }
     }
   }
@@ -179,7 +212,9 @@ ${planText !== null ? "| [plan.md](./plan.md) | Plan de implementación |\n" : "
   files.push("README.md");
 
   const indexPath = path.join(repoPath, "features", "README.md");
-  const indexText = readSafe(indexPath) ?? `# Features\n\nEspecificaciones y planes por feature.\n\n## Features documentadas\n\n| Feature | Repos afectados | Estado |\n| --- | --- | --- |\n`;
+  const indexText =
+    readSafe(indexPath) ??
+    `# Features\n\nEspecificaciones y planes por feature.\n\n## Features documentadas\n\n| Feature | Repos afectados | Estado |\n| --- | --- | --- |\n`;
   const row = `| [${slug}](./${prefix}-${slug}/) | ${specRepos(specText)} | Spec en revisión |`;
   const rowRe = new RegExp(`^\\| \\[${slug}\\]\\([^)]*\\) \\|.*$`, "m");
   let newIndex: string;

package/src/core/docs-validate.ts

@@ -15,17 +15,20 @@ const err = (code: string, message: string, path?: string): DocError => {
   return item;
 };
 
-const failValidate = (
-  errors: DocError[],
-): { ok: false; errors: DocError[]; error: string } => ({
+const failValidate = (errors: DocError[]): { ok: false; errors: DocError[]; error: string } => ({
   ok: false,
   errors,
-  error: errors.map((e) => e.message).filter(Boolean).join("; ") || "docs validation failed",
+  error:
+    errors
+      .map((e) => e.message)
+      .filter(Boolean)
+      .join("; ") || "docs validation failed",
 });
 
 const readBranch = (text: string, label: string): [string | null, DocError | null] => {
   const match = text.match(BRANCH_RE);
-  if (!match) return [null, err("missing_branch", `**Branch:** feature/* or bugfix/* required in ${label}`)];
+  if (!match)
+    return [null, err("missing_branch", `**Branch:** feature/* or bugfix/* required in ${label}`)];
   return [match[1].trim().replace(/`/g, ""), null];
 };
 
@@ -34,37 +37,55 @@ const scanTaskHeadings = (planText: string): [number[], string[], DocError | nul
   const titles: string[] = [];
   let inFence = false;
   for (const line of planText.split("\n")) {
-    if (line.startsWith("```")) { inFence = !inFence; continue; }
+    if (line.startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
     if (inFence) continue;
     const match = line.match(TASK_RE);
-    if (match) { ids.push(Number(match[1])); titles.push(match[2].trim()); }
+    if (match) {
+      ids.push(Number(match[1]));
+      titles.push(match[2].trim());
+    }
   }
-  if (ids.length === 0) return [ids, titles, err("task_order", "no ### Task N sections found outside fences")];
+  if (ids.length === 0)
+    return [ids, titles, err("task_order", "no ### Task N sections found outside fences")];
   const expected = ids.map((_, i) => i + 1);
   const sorted = [...ids].sort((a, b) => a - b);
   if (JSON.stringify(sorted) !== JSON.stringify(expected) || new Set(ids).size !== ids.length) {
-    return [ids, titles, err("task_order", `task headings must be contiguous from 1..${ids.length}; found ${ids}`)];
+    return [
+      ids,
+      titles,
+      err("task_order", `task headings must be contiguous from 1..${ids.length}; found ${ids}`),
+    ];
   }
   return [ids, titles, null];
 };
 
 // Port of scripts/lib/parse-plan-tasks.sh (JSON mode)
-export const parseTasksFromPlan = (planText: string): { id: number; title: string; section_text: string }[] => {
+export const parseTasksFromPlan = (
+  planText: string,
+): { id: number; title: string; section_text: string }[] => {
   const tasks: { id: number; title: string; section_text: string }[] = [];
   let current: { id: number; title: string; body: string[] } | null = null;
   let inFence = false;
   for (const line of planText.split("\n")) {
-    if (line.startsWith("```")) { inFence = !inFence; continue; }
+    if (line.startsWith("```")) {
+      inFence = !inFence;
+      continue;
+    }
     if (inFence) continue;
     const match = line.match(TASK_RE);
     if (match) {
-      if (current) tasks.push({ id: current.id, title: current.title, section_text: current.body.join("\n") });
+      if (current)
+        tasks.push({ id: current.id, title: current.title, section_text: current.body.join("\n") });
       current = { id: Number(match[1]), title: match[2].trim(), body: [] };
     } else if (current) {
       current.body.push(line);
     }
   }
-  if (current) tasks.push({ id: current.id, title: current.title, section_text: current.body.join("\n") });
+  if (current)
+    tasks.push({ id: current.id, title: current.title, section_text: current.body.join("\n") });
   return tasks;
 };
 
@@ -77,7 +98,14 @@ export const docsValidate = ({
   plan_path: string;
   workspace_root: string;
 }):
-  | { ok: true; spec: string; plan: string; branch: string; task_count: number; quality: QualityFinding[] }
+  | {
+      ok: true;
+      spec: string;
+      plan: string;
+      branch: string;
+      task_count: number;
+      quality: QualityFinding[];
+    }
   | { ok: false; errors: DocError[]; error: string } => {
   const cwd = path.resolve(workspace_root);
   const specAbs = path.isAbsolute(spec_path) ? spec_path : path.join(cwd, spec_path);
@@ -85,13 +113,19 @@ export const docsValidate = ({
   const errors: DocError[] = [];
 
   const read = (p: string): string | null => {
-    try { return readFileSync(p, "utf8"); } catch { return null; }
+    try {
+      return readFileSync(p, "utf8");
+    } catch {
+      return null;
+    }
   };
 
   const specText = read(specAbs);
   const planText = read(planAbs);
-  if (specText === null) errors.push(err("missing_file", `spec not found: ${spec_path}`, spec_path));
-  if (planText === null) errors.push(err("missing_file", `plan not found: ${plan_path}`, plan_path));
+  if (specText === null)
+    errors.push(err("missing_file", `spec not found: ${spec_path}`, spec_path));
+  if (planText === null)
+    errors.push(err("missing_file", `plan not found: ${plan_path}`, plan_path));
   if (errors.length) return failValidate(errors);
 
   const [specBranch, specErr] = readBranch(specText!, "spec");
@@ -106,12 +140,24 @@ export const docsValidate = ({
     const linked = (linkMatch[1] ?? linkMatch[2] ?? "").trim();
     const linkedAbs = path.isAbsolute(linked) ? linked : path.join(cwd, linked);
     if (path.resolve(linkedAbs) !== path.resolve(specAbs)) {
-      errors.push(err("spec_mismatch", `plan **Spec:** ${linked} does not match spec_path ${spec_path}`, plan_path));
+      errors.push(
+        err(
+          "spec_mismatch",
+          `plan **Spec:** ${linked} does not match spec_path ${spec_path}`,
+          plan_path,
+        ),
+      );
     }
   }
 
   if (specBranch && planBranch && specBranch !== planBranch) {
-    errors.push(err("branch_mismatch", `spec branch ${JSON.stringify(specBranch)} != plan branch ${JSON.stringify(planBranch)}`, plan_path));
+    errors.push(
+      err(
+        "branch_mismatch",
+        `spec branch ${JSON.stringify(specBranch)} != plan branch ${JSON.stringify(planBranch)}`,
+        plan_path,
+      ),
+    );
   }
 
   const [, , taskErr] = scanTaskHeadings(planText!);
@@ -123,10 +169,19 @@ export const docsValidate = ({
   const [headingIds, headingTitles, headingErr] = scanTaskHeadings(planText!);
   if (headingErr) return failValidate([headingErr]);
   if (tasks.length !== headingIds.length) {
-    return failValidate([err("task_order", `parse count ${tasks.length} != heading count ${headingIds.length}`, plan_path)]);
+    return failValidate([
+      err(
+        "task_order",
+        `parse count ${tasks.length} != heading count ${headingIds.length}`,
+        plan_path,
+      ),
+    ]);
   }
   for (let i = 0; i < tasks.length; i++) {
-    if (String(tasks[i].id) !== String(headingIds[i]) || tasks[i].title.trim() !== headingTitles[i]) {
+    if (
+      String(tasks[i].id) !== String(headingIds[i]) ||
+      tasks[i].title.trim() !== headingTitles[i]
+    ) {
       return failValidate([err("task_order", `task mismatch at position ${i + 1}`, plan_path)]);
     }
   }
@@ -144,13 +199,45 @@ export const docsValidate = ({
   }
   const hygiene = hygieneFiles(cwd);
   const hyState = hygiene.state;
-  if (hyState["CHANGELOG.md"] === "missing") quality.push({ code: "changelog_missing", message: "CHANGELOG.md missing — create it with Keep a Changelog format (run wk-init hygiene)", severity: "warning" });
-  if (hyState["CHANGELOG.md"] === "invalid") quality.push({ code: "changelog_invalid_format", message: "CHANGELOG.md lacks ## [Unreleased] — Keep a Changelog format required", severity: "warning" });
-  if (hyState["README.md"] === "missing") quality.push({ code: "readme_missing", message: "README.md missing", severity: "warning" });
-  if (hyState[".editorconfig"] === "missing") quality.push({ code: "editorconfig_missing", message: ".editorconfig missing", severity: "warning" });
-  if (hyState[".gitattributes"] === "missing") quality.push({ code: "gitattributes_missing", message: ".gitattributes missing", severity: "warning" });
-  if (hygiene.openSource && hyState.LICENSE === "missing") quality.push({ code: "license_missing", message: "LICENSE missing (open-source repo)", severity: "warning" });
-  if (hygiene.openSource && hyState["CONTRIBUTING.md"] === "missing") quality.push({ code: "contributing_missing", message: "CONTRIBUTING.md missing (open-source repo)", severity: "warning" });
+  if (hyState["CHANGELOG.md"] === "missing")
+    quality.push({
+      code: "changelog_missing",
+      message:
+        "CHANGELOG.md missing — create it with Keep a Changelog format (run wk-init hygiene)",
+      severity: "warning",
+    });
+  if (hyState["CHANGELOG.md"] === "invalid")
+    quality.push({
+      code: "changelog_invalid_format",
+      message: "CHANGELOG.md lacks ## [Unreleased] — Keep a Changelog format required",
+      severity: "warning",
+    });
+  if (hyState["README.md"] === "missing")
+    quality.push({ code: "readme_missing", message: "README.md missing", severity: "warning" });
+  if (hyState[".editorconfig"] === "missing")
+    quality.push({
+      code: "editorconfig_missing",
+      message: ".editorconfig missing",
+      severity: "warning",
+    });
+  if (hyState[".gitattributes"] === "missing")
+    quality.push({
+      code: "gitattributes_missing",
+      message: ".gitattributes missing",
+      severity: "warning",
+    });
+  if (hygiene.openSource && hyState.LICENSE === "missing")
+    quality.push({
+      code: "license_missing",
+      message: "LICENSE missing (open-source repo)",
+      severity: "warning",
+    });
+  if (hygiene.openSource && hyState["CONTRIBUTING.md"] === "missing")
+    quality.push({
+      code: "contributing_missing",
+      message: "CONTRIBUTING.md missing (open-source repo)",
+      severity: "warning",
+    });
   return {
     ok: true,
     spec: relSpec,
@@ -175,12 +262,22 @@ const REQUIRED_SECTIONS = [
   "## Acceptance criteria",
 ];
 
-const UI_KEYWORDS = [/\bui\b/, /\binterface\b/, /\bscreen\b/, /\bmodal\b/, /\bform\b/, /\bcomponent\b/];
+const UI_KEYWORDS = [
+  /\bui\b/,
+  /\binterface\b/,
+  /\bscreen\b/,
+  /\bmodal\b/,
+  /\bform\b/,
+  /\bcomponent\b/,
+];
 const FLOW_KEYWORDS = [/\bflow\b/, /\bpipeline\b/, /\bsequence\b/, /\bdiagram\b/];
 const GLOSSARY_KEYWORDS = [/\bglossary\b/, /\bcontracts?\b/, /\bscope\b/];
 
-const finding = (code: string, message: string, severity: "warning" | "hard"): QualityFinding =>
-  ({ code, message, severity });
+const finding = (code: string, message: string, severity: "warning" | "hard"): QualityFinding => ({
+  code,
+  message,
+  severity,
+});
 
 // Replace fenced code blocks with a single marker line so their content cannot
 // satisfy the checks, but the fence itself (and its language) stays detectable.
@@ -212,27 +309,52 @@ export const qualitySpec = (text: string): QualityFinding[] => {
 
   const hasCa = /^\s*(?:- CA-\d+|CA-\d+[.:])/m.test(body); // M1: ^ with /m covers line starts
   if (!hasCa) {
-    findings.push(finding("missing_acceptance_criteria", "no enumerable CA-XX acceptance criteria found", "hard"));
+    findings.push(
+      finding(
+        "missing_acceptance_criteria",
+        "no enumerable CA-XX acceptance criteria found",
+        "hard",
+      ),
+    );
   }
 
   const hasAsciiFence = /```(?:text|ascii)/.test(body);
   const mentionsUi = UI_KEYWORDS.some((k) => k.test(lower));
   if (mentionsUi && !hasAsciiFence) {
-    findings.push(finding("missing_ascii_for_ui", "spec mentions UI but has no ASCII wireframe fence", "warning"));
+    findings.push(
+      finding(
+        "missing_ascii_for_ui",
+        "spec mentions UI but has no ASCII wireframe fence",
+        "warning",
+      ),
+    );
   }
 
   const hasMermaid = /```mermaid/.test(body);
   const explicitlyNoFlow = /\bno (?:flow|pipeline|sequence|diagram)\b/.test(lower);
   const mentionsFlow = FLOW_KEYWORDS.some((k) => k.test(lower));
   if (mentionsFlow && !hasMermaid && !explicitlyNoFlow) {
-    findings.push(finding("missing_mermaid_for_flow", "spec describes a flow/pipeline/sequence but has no mermaid fence", "warning"));
+    findings.push(
+      finding(
+        "missing_mermaid_for_flow",
+        "spec describes a flow/pipeline/sequence but has no mermaid fence",
+        "warning",
+      ),
+    );
   }
 
   const hasTable = /^\s*\|.+\|.+\|/m.test(body);
   const mentionsGlossary = GLOSSARY_KEYWORDS.some((k) => k.test(lower));
-  const onlyOutOfScope = /\bout of scope\b/.test(lower) && !/\bglossary\b/.test(lower) && !/\bcontracts?\b/.test(lower);
+  const onlyOutOfScope =
+    /\bout of scope\b/.test(lower) && !/\bglossary\b/.test(lower) && !/\bcontracts?\b/.test(lower);
   if (mentionsGlossary && !hasTable && !onlyOutOfScope) {
-    findings.push(finding("missing_table", "spec has glossary/contract/scope content but no markdown table", "warning"));
+    findings.push(
+      finding(
+        "missing_table",
+        "spec has glossary/contract/scope content but no markdown table",
+        "warning",
+      ),
+    );
   }
 
   return findings;
@@ -247,7 +369,11 @@ const sddIgnored = (cwd: string, slug: string): boolean => {
     return true; // not a git repo — nothing to be unignored in; validation presupposes a repo
   }
   try {
-    execFileSync("git", ["-C", cwd, "check-ignore", path.posix.join("docs", slug, "sdd", "progress.md")], { stdio: "pipe" });
+    execFileSync(
+      "git",
+      ["-C", cwd, "check-ignore", path.posix.join("docs", slug, "sdd", "progress.md")],
+      { stdio: "pipe" },
+    );
     return true;
   } catch {
     return false;

package/src/core/flow-state.ts

@@ -104,7 +104,10 @@ export const transitionSpec = (
         ok: false,
         error:
           "spec self-review failed: " +
-          hard.map((f) => `${f.code} — ${f.message}`).concat(missing).join("; ") +
+          hard
+            .map((f) => `${f.code} — ${f.message}`)
+            .concat(missing)
+            .join("; ") +
           " — see templates/spec-template.md for the required structure",
       };
     }
@@ -150,7 +153,8 @@ export const transitionPlan = (
     }
     const missing: string[] = [];
     const stripped = stripFences(text);
-    if (parseTasksFromPlan(text).length === 0) missing.push("no ### Task N: sections outside fences");
+    if (parseTasksFromPlan(text).length === 0)
+      missing.push("no ### Task N: sections outside fences");
     if (!/^\s*\*+Spec:\*+/im.test(stripped)) missing.push("**Spec:** header missing");
     if (!/^\s*\*+Branch:\*+/im.test(stripped)) missing.push("**Branch:** header missing");
     if (missing.length > 0) {

package/src/core/gitignore.ts

@@ -25,7 +25,12 @@ export const ensureProjectGitignore = (
   if (!confirmed) return { ok: false, error: "confirmed: true required" };
   const file = path.join(workspaceRoot, ".gitignore");
   const existing = existsSync(file) ? readFileSync(file, "utf8") : "";
-  const existingLines = new Set(existing.split("\n").map((l) => l.trim()).filter(Boolean));
+  const existingLines = new Set(
+    existing
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean),
+  );
   const added: string[] = [];
   const append: string[] = [];
   for (const entry of GITIGNORE_ENTRIES) {
@@ -35,7 +40,11 @@ export const ensureProjectGitignore = (
   }
   if (append.length) {
     const separator = existing && !existing.endsWith("\n") ? "\n" : "";
-    writeFileSync(file, existing + separator + (existing ? "\n" : "") + append.join("\n") + "\n", "utf8");
+    writeFileSync(
+      file,
+      existing + separator + (existing ? "\n" : "") + append.join("\n") + "\n",
+      "utf8",
+    );
   } else if (!existsSync(file)) {
     writeFileSync(file, "", "utf8");
   }

package/src/core/handoff-context.ts

@@ -25,7 +25,8 @@ const resolveFromMessagePaths = (root: string, message: string): Resolved => {
   const paths = extractMessagePaths(message);
   if (paths.length === 0) return { error: "no paths" };
   const slugs = [...new Set(paths.map((p) => p.split("/")[1]))];
-  if (slugs.length !== 1) return { error: "multiple features in message — use exactly one docs/<slug>/ pair" };
+  if (slugs.length !== 1)
+    return { error: "multiple features in message — use exactly one docs/<slug>/ pair" };
   const slug = slugs[0];
   const plan = `docs/${slug}/plan.md`;
   const spec = `docs/${slug}/spec.md`;
@@ -49,8 +50,15 @@ const resolveActivePair = (root: string): Resolved => {
     const plan = path.join("docs", slug, "plan.md");
     const spec = path.join("docs", slug, "spec.md");
     if (!existsSync(path.join(root, plan)) || !existsSync(path.join(root, spec))) continue;
-    const score = Math.max(statSync(path.join(root, spec)).mtimeMs, statSync(path.join(root, plan)).mtimeMs);
-    if (best === null || score > best.score || (score === best.score && slug < best.spec.split("/")[1])) {
+    const score = Math.max(
+      statSync(path.join(root, spec)).mtimeMs,
+      statSync(path.join(root, plan)).mtimeMs,
+    );
+    if (
+      best === null ||
+      score > best.score ||
+      (score === best.score && slug < best.spec.split("/")[1])
+    ) {
       best = { score, spec, plan, source: "active_pair" };
     }
   }
@@ -69,7 +77,10 @@ export const resolveWorkflowPaths = (root: string, message: string): Resolved =>
   if (!existsSync(docsDir) || listMd(docsDir).length === 0) {
     return { error: "no docs/<slug>/ features found under docs/" };
   }
-  return { error: "could not resolve spec and plan — mention docs/<slug>/plan.md or create docs/<slug>/{spec.md,plan.md}" };
+  return {
+    error:
+      "could not resolve spec and plan — mention docs/<slug>/plan.md or create docs/<slug>/{spec.md,plan.md}",
+  };
 };
 
 export const buildHandoffContract = ({
@@ -85,7 +96,9 @@ export const buildHandoffContract = ({
 }): { prompt: string } | { error: string } => {
   const validated = docsValidate({ spec_path: spec, plan_path: plan, workspace_root: root });
   if (validated.ok === false) {
-    return { error: `docs validation failed\n${JSON.stringify({ ok: false, errors: validated.errors })}` };
+    return {
+      error: `docs validation failed\n${JSON.stringify({ ok: false, errors: validated.errors })}`,
+    };
   }
   const branchResolved = resolveBranch({ spec_path: spec, plan_path: plan, workspace_root: root });
   if ("error" in branchResolved) return { error: branchResolved.error as string };