@karajan-family/code 4.21.0

package/src/golden/runner.js

@@ -0,0 +1,92 @@
+/**
+ * Golden tasks subprocess runner (KJC-TSK-0374). Spawns `kj run` in
+ * a sandbox dir, reads back summary.md, evaluates the schema's
+ * filesystem-dependent assertions (expected_test_files, allowed_loc_range),
+ * and merges them with `assertFromSummary` into a single result.
+ *
+ * The kj subprocess + diff calls are injected so unit tests can drive
+ * the runner without spawning anything (real e2e is opt-in via PR-3b).
+ */
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { runCommand as defaultRun } from "../utils/process.js";
+import { parseSummary, assertFromSummary } from "./asserter.js";
+
+async function findLatestSummary(workDir) {
+  const journalRoot = path.join(workDir, ".karajan", "sessions");
+  const sessions = await fs.readdir(journalRoot).catch(() => []);
+  if (sessions.length === 0) return null;
+  const stats = await Promise.all(sessions.map(async (id) => {
+    const file = path.join(journalRoot, id, "summary.md");
+    const stat = await fs.stat(file).catch(() => null);
+    return stat ? { file, mtimeMs: stat.mtimeMs } : null;
+  }));
+  const valid = stats.filter(Boolean).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return valid[0]?.file ?? null;
+}
+
+async function findMissingTestFiles(workDir, paths) {
+  const checks = await Promise.all(paths.map(async (rel) =>
+    [rel, await fs.stat(path.join(workDir, rel)).then(() => true).catch(() => false)]));
+  return checks.filter(([, ok]) => !ok).map(([rel]) => rel);
+}
+
+async function totalLocSince(workDir, baseSha, run) {
+  const res = await run("git", ["diff", "--numstat", `${baseSha}..HEAD`], { cwd: workDir }).catch(() => null);
+  if (!res || res.exitCode !== 0) return null;
+  return String(res.stdout || "").split("\n").filter(Boolean)
+    .map((l) => l.split("\t")).filter(([a]) => a !== "-")
+    .reduce((sum, [a]) => sum + Number(a || 0), 0);
+}
+
+export async function runGoldenTask(task, opts = {}) {
+  const run = opts.run || defaultRun;
+  const fsApi = opts.fs || fs;
+  const workDir = opts.workDir;
+  if (!workDir) throw new Error("runGoldenTask requires opts.workDir");
+
+  const baseSha = opts.baseSha || null;
+  const kjResult = await run("kj", ["run", task.prompt, "-y"], {
+    cwd: workDir,
+    timeout: (task.timeout_minutes || 30) * 60_000,
+  });
+
+  const summaryPath = opts.summaryPath || await findLatestSummary(workDir);
+  if (!summaryPath) {
+    return { ok: false, kjExit: kjResult?.exitCode ?? -1, failures: [{
+      kind: "no_summary", expected: "summary.md", actual: null,
+      message: "kj run finished without producing a summary.md",
+    }] };
+  }
+  const content = await fsApi.readFile(summaryPath, "utf8");
+  const parsed = parseSummary(content);
+  const summaryAssertion = assertFromSummary(task, parsed);
+
+  const failures = [...summaryAssertion.failures];
+
+  if (Array.isArray(task.expected_test_files) && task.expected_test_files.length > 0) {
+    const missing = await findMissingTestFiles(workDir, task.expected_test_files);
+    if (missing.length > 0) {
+      failures.push({ kind: "test_files_missing", expected: task.expected_test_files, actual: missing,
+        message: `expected test files not produced: ${missing.join(", ")}` });
+    }
+  }
+
+  if (baseSha) {
+    const loc = await totalLocSince(workDir, baseSha, run);
+    const [min, max] = task.allowed_loc_range;
+    if (loc !== null && (loc < min || loc > max)) {
+      failures.push({ kind: "loc_out_of_range", expected: `${min}..${max}`, actual: loc,
+        message: `LOC added (${loc}) is outside the allowed range [${min}, ${max}]` });
+    }
+  }
+
+  return {
+    ok: failures.length === 0,
+    kjExit: kjResult?.exitCode ?? null,
+    summaryPath,
+    parsed,
+    failures,
+  };
+}

package/src/golden/schema.js

@@ -0,0 +1,41 @@
+/**
+ * Golden tasks regression suite — schema (KJC-TSK-0374). Pure data,
+ * no I/O. See docs/golden-tasks.md (PR-3) for the full spec.
+ */
+
+import * as v from "valibot";
+
+const NonEmptyString = v.pipe(v.string(), v.minLength(1));
+const Percent = v.pipe(v.number(), v.minValue(0), v.maxValue(100));
+
+const NonNegInt = v.pipe(v.number(), v.integer(), v.minValue(0));
+const LocRangeSchema = v.pipe(v.array(NonNegInt), v.length(2),
+  v.check((arr) => arr[0] <= arr[1], "allowed_loc_range: min must be <= max"));
+
+const GoldenTaskSchema = v.looseObject({
+  id: v.pipe(NonEmptyString, v.regex(/^[a-z0-9_-]+$/, "id must be lowercase a-z0-9_-")),
+  title: NonEmptyString,
+  prompt: NonEmptyString,
+  description: v.optional(v.string()),
+  timeout_minutes: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1)), 30),
+  expected_commits_min: NonNegInt,
+  expected_audit_status: v.picklist(["pass", "warning", "fail"]),
+  expected_test_files: v.array(NonEmptyString),
+  allowed_loc_range: LocRangeSchema,
+  expected_plan_adherence_min: v.optional(Percent),
+});
+
+/** @typedef {import("valibot").InferOutput<typeof GoldenTaskSchema>} GoldenTask */
+
+export function parseGoldenTask(raw) {
+  return v.parse(GoldenTaskSchema, raw);
+}
+
+export function safeParseGoldenTask(raw) {
+  const result = v.safeParse(GoldenTaskSchema, raw);
+  if (result.success) return { ok: true, task: result.output };
+  return { ok: false, issues: result.issues.map((iss) => ({
+    path: (iss.path || []).map((p) => p.key).join("."),
+    message: iss.message,
+  })) };
+}

package/src/guards/intent-guard.js

@@ -0,0 +1,161 @@
+import { VALID_TASK_TYPES } from "./policy-resolver.js";
+
+/**
+ * Built-in intent patterns for deterministic pre-triage classification.
+ * Each pattern maps keywords/regex to a taskType + complexity level.
+ * Evaluated top-down; first match with confidence >= threshold wins.
+ */
+const INTENT_PATTERNS = [
+  // No-code tasks (data analysis, document generation, SQL queries, CSV transforms)
+  // Placed before audit so specific multi-word patterns win over single-word "analizar"/"analyze"
+  {
+    id: "no-code",
+    keywords: [
+      "generate report", "create document", "analyze data", "transform csv",
+      "sql query", "sql queries", "generate queries", "data analysis", "process data",
+      "export to", "import from", "convert data", "parse file",
+      "generar informe", "crear documento", "analizar datos", "transformar csv",
+      "consulta sql", "generar consultas", "analisis de datos", "procesar datos",
+      "exportar a", "importar de", "convertir datos", "parsear fichero",
+    ],
+    taskType: "no-code",
+    level: "simple",
+    confidence: 0.9,
+    message: "No-code task detected — TDD and SonarQube disabled, coder generates non-code output",
+  },
+  // Audit / analysis tasks (no code changes, read-only analysis)
+  {
+    id: "audit",
+    keywords: ["audit", "review", "analyze", "check", "verify", "inspect", "scan", "auditar", "revisar", "analizar", "comprobar", "verificar", "inspeccionar"],
+    taskType: "audit",
+    level: "simple",
+    confidence: 0.9,
+    message: "Audit/analysis task detected — skipping coder and reviewer",
+  },
+  // Documentation-only tasks
+  {
+    id: "doc-readme",
+    keywords: ["readme", "docs", "documentation", "jsdoc", "typedoc", "changelog"],
+    taskType: "doc",
+    level: "trivial",
+    confidence: 0.95,
+    message: "Documentation-only task detected",
+  },
+  // Test-only tasks
+  {
+    id: "add-tests",
+    keywords: ["add test", "write test", "missing test", "test coverage", "add spec", "write spec", "unit test", "integration test"],
+    taskType: "add-tests",
+    level: "simple",
+    confidence: 0.9,
+    message: "Test-addition task detected",
+  },
+  // Refactoring tasks
+  {
+    id: "refactor",
+    keywords: ["refactor", "rename", "extract method", "extract function", "clean up", "cleanup", "reorganize", "restructure", "simplify"],
+    taskType: "refactor",
+    level: "simple",
+    confidence: 0.85,
+    message: "Refactoring task detected",
+  },
+  // Infrastructure / DevOps tasks
+  {
+    id: "infra-devops",
+    keywords: ["ci/cd", "pipeline", "dockerfile", "docker-compose", "kubernetes", "k8s", "terraform", "deploy", "nginx", "github actions", "gitlab ci"],
+    taskType: "infra",
+    level: "simple",
+    confidence: 0.85,
+    message: "Infrastructure/DevOps task detected",
+  },
+  // Trivial fixes (typos, comments, formatting)
+  {
+    id: "trivial-fix",
+    keywords: ["typo", "fix typo", "spelling", "comment", "fix comment", "formatting", "lint", "fix lint", "whitespace"],
+    taskType: "sw",
+    level: "trivial",
+    confidence: 0.9,
+    message: "Trivial fix detected",
+  },
+  // Frontend / UI tasks (sets hasFrontend flag for impeccable role activation)
+  {
+    id: "frontend-ui",
+    keywords: ["html", "css", "ui", "landing", "component", "responsive", "accessibility", "a11y", "frontend", "design", "layout", "styling", "dark mode", "animation"],
+    taskType: "sw",
+    level: "simple",
+    confidence: 0.8,
+    message: "Frontend/UI task detected",
+    hasFrontend: true,
+  },
+];
+
+/**
+ * Compile custom intent patterns from config.guards.intent.patterns
+ * Custom patterns are evaluated BEFORE built-in ones.
+ */
+export function compileIntentPatterns(configGuards) {
+  const custom = Array.isArray(configGuards?.intent?.patterns)
+    ? configGuards.intent.patterns.map(p => ({
+        id: p.id || "custom-intent",
+        keywords: Array.isArray(p.keywords) ? p.keywords : [],
+        taskType: VALID_TASK_TYPES.has(p.taskType) ? p.taskType : "sw",
+        level: p.level || "simple",
+        confidence: typeof p.confidence === "number" ? p.confidence : 0.85,
+        message: p.message || "Custom intent pattern matched",
+      }))
+    : [];
+
+  return [...custom, ...INTENT_PATTERNS];
+}
+
+/**
+ * Check if a task description matches any of the keywords.
+ * Returns true if at least one keyword (case-insensitive substring) appears in the task.
+ */
+function matchesKeywords(task, keywords) {
+  const lower = task.toLowerCase();
+  for (const kw of keywords) {
+    if (lower.includes(kw.toLowerCase())) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Classify a task description using deterministic keyword patterns.
+ *
+ * Returns:
+ *   { classified: true, taskType, level, confidence, patternId, message }
+ *   or { classified: false } if no pattern matches above threshold
+ */
+export function classifyIntent(task, config = {}) {
+  if (!task || typeof task !== "string") {
+    return { classified: false };
+  }
+
+  const configGuards = config?.guards || {};
+  const threshold = configGuards?.intent?.confidence_threshold ?? 0.85;
+  const patterns = compileIntentPatterns(configGuards);
+
+  for (const pattern of patterns) {
+    if (!matchesKeywords(task, pattern.keywords)) continue;
+
+    if (pattern.confidence >= threshold) {
+      const result = {
+        classified: true,
+        taskType: pattern.taskType,
+        level: pattern.level,
+        confidence: pattern.confidence,
+        patternId: pattern.id,
+        message: pattern.message,
+      };
+      if (pattern.hasFrontend) result.hasFrontend = true;
+      return result;
+    }
+  }
+
+  return { classified: false };
+}
+
+export { INTENT_PATTERNS };

package/src/guards/output-guard.js

@@ -0,0 +1,149 @@
+// Built-in destructive patterns
+const DESTRUCTIVE_PATTERNS = [
+  { id: "rm-rf", pattern: /rm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|--force\s+)*-[a-zA-Z]*r/, severity: "critical", message: "Recursive file deletion detected" },
+  { id: "drop-table", pattern: /DROP\s+(TABLE|DATABASE|SCHEMA)/i, severity: "critical", message: "SQL destructive operation detected" },
+  { id: "git-reset-hard", pattern: /git\s+reset\s+--hard/i, severity: "critical", message: "Hard git reset detected" },
+  { id: "git-push-force", pattern: /git\s+push\s+.*--force/i, severity: "critical", message: "Force push detected" },
+  { id: "truncate-table", pattern: /TRUNCATE\s+TABLE/i, severity: "critical", message: "SQL truncate detected" },
+  { id: "format-disk", pattern: /mkfs\.|fdisk|dd\s+if=/, severity: "critical", message: "Disk format operation detected" },
+];
+
+// Built-in credential patterns (ALL critical — secrets must NEVER be committed)
+const CREDENTIAL_PATTERNS = [
+  { id: "aws-key", pattern: /AKIA[0-9A-Z]{16}/, severity: "critical", message: "AWS access key exposed" },
+  { id: "private-key", pattern: /-----BEGIN\s+(RSA\s+)?PRIVATE\s+KEY-----/, severity: "critical", message: "Private key exposed" },
+  { id: "generic-secret", pattern: /(password|secret|token|api_key|apikey)\s*[:=]\s*["'][^"']{8,}["']/i, severity: "critical", message: "Hardcoded secret detected. Use .env file + process.env instead" },
+  { id: "github-token", pattern: /gh[pousr]_[A-Za-z0-9_]{36,}/, severity: "critical", message: "GitHub token exposed" },
+  { id: "npm-token", pattern: /npm_[A-Za-z0-9]{36,}/, severity: "critical", message: "npm token exposed" },
+  { id: "openai-key", pattern: /sk-[A-Za-z0-9]{20,}/, severity: "critical", message: "OpenAI API key exposed" },
+  { id: "anthropic-key", pattern: /sk-ant-[A-Za-z0-9_-]{20,}/, severity: "critical", message: "Anthropic API key exposed" },
+  { id: "stripe-key", pattern: /sk_live_[A-Za-z0-9]{20,}/, severity: "critical", message: "Stripe secret key exposed" },
+  { id: "stripe-test", pattern: /sk_test_[A-Za-z0-9]{20,}/, severity: "critical", message: "Stripe test key exposed. Use .env even for test keys" },
+  { id: "google-api-key", pattern: /AIza[A-Za-z0-9_-]{35}/, severity: "critical", message: "Google API key exposed" },
+  { id: "firebase-key", pattern: /"apiKey"\s*:\s*"AIza[A-Za-z0-9_-]{35}"/, severity: "critical", message: "Firebase API key hardcoded. Use .env file" },
+  { id: "slack-token", pattern: /xox[bpors]-[A-Za-z0-9-]{10,}/, severity: "critical", message: "Slack token exposed" },
+  { id: "jwt-secret", pattern: /jwt[_-]?secret\s*[:=]\s*["'][^"']{8,}["']/i, severity: "critical", message: "JWT secret hardcoded. Use .env file" },
+  { id: "database-url", pattern: /(mongodb|postgres|mysql|redis):\/\/[^"'\s]+:[^"'\s]+@/i, severity: "critical", message: "Database URL with credentials exposed. Use .env file" },
+  { id: "hardcoded-key-assignment", pattern: /(?:const|let|var)\s+\w*(?:key|secret|token|password)\w*\s*=\s*["'][A-Za-z0-9_-]{16,}["']/i, severity: "critical", message: "Hardcoded key in variable. Use process.env or .env file" },
+];
+
+// Default protected files (block if these appear in added/modified lines)
+const DEFAULT_PROTECTED_FILES = [
+  ".env",
+  ".env.local",
+  ".env.production",
+  "serviceAccountKey.json",
+  "credentials.json",
+];
+
+export function compilePatterns(configGuards) {
+  const customPatterns = Array.isArray(configGuards?.output?.patterns)
+    ? configGuards.output.patterns.map(p => ({
+        id: p.id || "custom",
+        pattern: typeof p.pattern === "string" ? new RegExp(p.pattern, p.flags || "") : p.pattern,
+        severity: p.severity || "warning",
+        message: p.message || "Custom pattern matched",
+      }))
+    : [];
+
+  return [...DESTRUCTIVE_PATTERNS, ...CREDENTIAL_PATTERNS, ...customPatterns];
+}
+
+export function compileProtectedFiles(configGuards) {
+  const custom = Array.isArray(configGuards?.output?.protected_files)
+    ? configGuards.output.protected_files
+    : [];
+  return [...new Set([...DEFAULT_PROTECTED_FILES, ...custom])];
+}
+
+/**
+ * Parse a unified diff to extract only added lines (lines starting with +, not ++)
+ */
+export function extractAddedLines(diff) {
+  if (!diff) return [];
+  const results = [];
+  let currentFile = null;
+  let lineNum = 0;
+
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++ b/")) {
+      currentFile = line.slice(6);
+      continue;
+    }
+    if (line.startsWith("@@ ")) {
+      const match = /@@ -\d+(?:,\d+)? \+(\d+)/.exec(line);
+      lineNum = match ? Number.parseInt(match[1], 10) - 1 : 0;
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      lineNum += 1;
+      results.push({ file: currentFile, line: lineNum, content: line.slice(1) });
+    } else if (!line.startsWith("-")) {
+      lineNum += 1;
+    }
+  }
+  return results;
+}
+
+/**
+ * Check if any modified files are in the protected list
+ */
+export function checkProtectedFiles(diff, protectedFiles) {
+  const violations = [];
+  const modifiedFiles = [];
+
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++ b/")) {
+      modifiedFiles.push(line.slice(6));
+    }
+  }
+
+  for (const file of modifiedFiles) {
+    const basename = file.split("/").pop();
+    if (protectedFiles.some(pf => file === pf || file.endsWith(`/${pf}`) || basename === pf)) {
+      violations.push({
+        id: "protected-file",
+        severity: "critical",
+        file,
+        line: 0,
+        message: `Protected file modified: ${file}`,
+        matchedContent: "",
+      });
+    }
+  }
+
+  return violations;
+}
+
+/**
+ * Scan a diff for pattern violations.
+ * Returns { pass: boolean, violations: Array<{id, severity, file, line, message, matchedContent}> }
+ */
+export function scanDiff(diff, config = {}) {
+  if (!diff || typeof diff !== "string") {
+    return { pass: true, violations: [] };
+  }
+
+  const configGuards = config?.guards || {};
+  const patterns = compilePatterns(configGuards);
+  const protectedFiles = compileProtectedFiles(configGuards);
+  const addedLines = extractAddedLines(diff);
+  const violations = [];
+
+  // Check patterns against added lines
+  for (const { file, line, content } of addedLines) {
+    for (const { id, pattern, severity, message } of patterns) {
+      if (pattern.test(content)) {
+        violations.push({ id, severity, file, line, message, matchedContent: content.trim().slice(0, 200) });
+      }
+    }
+  }
+
+  // Check protected files
+  violations.push(...checkProtectedFiles(diff, protectedFiles));
+
+  const hasCritical = violations.some(v => v.severity === "critical");
+  return { pass: !hasCritical, violations };
+}
+
+export { DESTRUCTIVE_PATTERNS, CREDENTIAL_PATTERNS, DEFAULT_PROTECTED_FILES };

package/src/guards/perf-guard.js

@@ -0,0 +1,126 @@
+const FRONTEND_EXTENSIONS = new Set([".html", ".htm", ".css", ".jsx", ".tsx", ".astro", ".vue", ".svelte"]);
+
+// Built-in perf anti-patterns (applied to added lines in frontend files)
+const PERF_PATTERNS = [
+  { id: "img-no-dimensions", pattern: /<img\b(?![^>]*\bwidth\b)(?![^>]*\bheight\b)[^>]*>/i, severity: "warning", message: "Image without width/height attributes (causes CLS)" },
+  { id: "img-no-lazy", pattern: /<img\b(?![^>]*\bloading\s*=)(?![^>]*\bfetchpriority\s*=)[^>]*>/i, severity: "info", message: "Image without loading=\"lazy\" or fetchpriority (consider lazy loading)" },
+  { id: "script-no-defer", pattern: /<script\b(?![^>]*\b(?:defer|async)\b)(?![^>]*type\s*=\s*["']module["'])[^>]*src\s*=/i, severity: "warning", message: "External script without defer/async (render-blocking)" },
+  { id: "font-no-display", pattern: /@font-face\s*\{(?![^}]*font-display)/i, severity: "warning", message: "@font-face without font-display (causes FOIT)" },
+  { id: "css-import", pattern: /@import\s+(?:url\()?["'](?!.*\.module\.)/i, severity: "info", message: "CSS @import (causes sequential loading, prefer <link>)" },
+  { id: "inline-style-large", pattern: /style\s*=\s*["'][^"']{200,}["']/i, severity: "warning", message: "Large inline style (>200 chars, consider external CSS)" },
+  { id: "document-write", pattern: /document\.write\s*\(/, severity: "warning", message: "document.write() blocks parsing and degrades performance" },
+];
+
+// Patterns for package.json changes (heavy dependencies added)
+const HEAVY_DEPS = [
+  { id: "heavy-moment", pattern: /"moment"/, severity: "info", message: "moment.js added (consider dayjs or date-fns for smaller bundle)" },
+  { id: "heavy-lodash", pattern: /"lodash"(?!\/)/, severity: "info", message: "Full lodash added (consider lodash-es or individual imports)" },
+  { id: "heavy-jquery", pattern: /"jquery"/, severity: "info", message: "jQuery added (consider native DOM APIs)" },
+];
+
+function getExtension(filePath) {
+  if (!filePath) return "";
+  const dot = filePath.lastIndexOf(".");
+  return dot >= 0 ? filePath.slice(dot).toLowerCase() : "";
+}
+
+/**
+ * Check if any modified file in the diff is a frontend file
+ */
+export function hasFrontendFiles(diff) {
+  if (!diff) return false;
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++ b/")) {
+      const ext = getExtension(line.slice(6));
+      if (FRONTEND_EXTENSIONS.has(ext)) return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Extract added lines grouped by file from a unified diff
+ */
+function extractAddedLinesByFile(diff) {
+  const results = [];
+  let currentFile = null;
+  let lineNum = 0;
+
+  for (const line of diff.split("\n")) {
+    if (line.startsWith("+++ b/")) {
+      currentFile = line.slice(6);
+      continue;
+    }
+    if (line.startsWith("@@ ")) {
+      const match = /@@ -\d+(?:,\d+)? \+(\d+)/.exec(line);
+      lineNum = match ? Number.parseInt(match[1], 10) - 1 : 0;
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) {
+      lineNum += 1;
+      results.push({ file: currentFile, line: lineNum, content: line.slice(1) });
+    } else if (!line.startsWith("-")) {
+      lineNum += 1;
+    }
+  }
+  return results;
+}
+
+/**
+ * Scan diff for frontend performance anti-patterns.
+ * Returns { pass: boolean, violations: [...], skipped: boolean }
+ */
+export function scanPerfDiff(diff, config = {}) {
+  if (!diff || typeof diff !== "string") {
+    return { pass: true, violations: [], skipped: true };
+  }
+
+  if (!hasFrontendFiles(diff)) {
+    return { pass: true, violations: [], skipped: true };
+  }
+
+  const customPatterns = Array.isArray(config?.guards?.perf?.patterns)
+    ? config.guards.perf.patterns.map(p => ({
+        id: p.id || "custom-perf",
+        pattern: typeof p.pattern === "string" ? new RegExp(p.pattern, p.flags || "i") : p.pattern,
+        severity: p.severity || "warning",
+        message: p.message || "Custom perf pattern matched",
+      }))
+    : [];
+
+  const allPatterns = [...PERF_PATTERNS, ...customPatterns];
+  const addedLines = extractAddedLinesByFile(diff);
+  const violations = [];
+
+  for (const { file, line, content } of addedLines) {
+    const ext = getExtension(file);
+    const isFrontend = FRONTEND_EXTENSIONS.has(ext);
+    const isPackageJson = file?.endsWith("package.json");
+
+    if (isFrontend) {
+      for (const { id, pattern, severity, message } of allPatterns) {
+        if (pattern.test(content)) {
+          violations.push({ id, severity, file, line, message, matchedContent: content.trim().slice(0, 200) });
+        }
+      }
+    }
+
+    if (isPackageJson) {
+      for (const { id, pattern, severity, message } of HEAVY_DEPS) {
+        if (pattern.test(content)) {
+          violations.push({ id, severity, file, line, message, matchedContent: content.trim().slice(0, 200) });
+        }
+      }
+    }
+  }
+
+  // perf-guard is advisory by default — only blocks on critical (none built-in are critical)
+  const blockOnWarning = Boolean(config?.guards?.perf?.block_on_warning);
+  const hasCritical = violations.some(v => v.severity === "critical");
+  const hasWarning = violations.some(v => v.severity === "warning");
+  const pass = !hasCritical && !(blockOnWarning && hasWarning);
+
+  return { pass, violations, skipped: false };
+}
+
+export { PERF_PATTERNS, HEAVY_DEPS, FRONTEND_EXTENSIONS };

package/src/guards/policy-guard.js

@@ -0,0 +1,90 @@
+/**
+ * Policy guard for kj_resume answers.
+ *
+ * Detects host-AI attempts to bypass pipeline policies (skip TDD, ignore
+ * reviewer, disable security, etc.) and rejects them with context-aware
+ * suggestions for valid alternatives.
+ */
+
+const BYPASS_PATTERNS = [
+  { regex: /\b(?:skip|omit|drop)\s+(?:the\s+)?(?:tests?|tdd|testing)\b/i, policy: "tdd" },
+  { regex: /\bdisable\s+(?:the\s+)?(?:tests?|tdd|testing)\b/i, policy: "tdd" },
+  { regex: /\b(?:don'?t|do\s+not|no\s+need\s+(?:for|to))\s+(?:run\s+)?tests?\b/i, policy: "tdd" },
+  { regex: /\bcontinue\s+without\s+test/i, policy: "tdd" },
+  { regex: /\bswitch\s+(?:to\s+)?(?:standard\s+)?methodology/i, policy: "tdd" },
+  { regex: /\bswitch\s+methodology/i, policy: "tdd" },
+  { regex: /\b(?:skip|ignore|bypass|disable)\s+(?:the\s+)?(?:review(?:er)?|code\s+review)\b/i, policy: "reviewer" },
+  { regex: /\b(?:approve|pass)\s+without\s+review/i, policy: "reviewer" },
+  { regex: /\bmark\s+as\s+approved\b/i, policy: "reviewer" },
+  { regex: /\bjust\s+ship\s+it/i, policy: "reviewer" },
+  { regex: /\bignore\s+(?:the\s+)?(?:review(?:er)?\s+)?feedback\b/i, policy: "reviewer" },
+  { regex: /\b(?:skip|ignore|bypass|disable)\s+(?:the\s+)?(?:sonar|sonarqube|quality\s+gate)/i, policy: "sonar" },
+  { regex: /\bignore\s+sonar\s+issues?\b/i, policy: "sonar" },
+  { regex: /\b(?:skip|ignore|bypass|disable)\s+(?:the\s+)?security(?:\s+checks?)?\b/i, policy: "security" },
+];
+
+const SUGGESTIONS_BY_POLICY = {
+  tdd: [
+    "Provide specific guidance for the coder on how to fix the failing tests",
+    "Describe the expected behavior so the coder can write correct tests",
+    "Suggest a different approach to implement the feature that is easier to test",
+  ],
+  reviewer: [
+    "Provide technical guidance to address the reviewer's feedback",
+    "Explain why the current approach is correct if you disagree with the review",
+    "Suggest alternative implementations that satisfy the reviewer's concerns",
+  ],
+  sonar: [
+    "Provide guidance on how to resolve the SonarQube issues",
+    "Explain the code changes needed to satisfy quality gate requirements",
+  ],
+  security: [
+    "Provide guidance on how to fix the security issues found",
+    "Explain the secure alternative for the flagged pattern",
+  ],
+};
+
+const CONTEXT_SUGGESTIONS = {
+  reviewer_fail_fast: [
+    "Provide specific technical guidance for the coder to address the reviewer's feedback",
+    "Suggest a different approach that resolves the reviewer's concerns",
+  ],
+  max_iterations: [
+    "Provide focused guidance to help the coder converge on a solution",
+    "Narrow the scope: specify exactly which file/function to change and how",
+    "Continue with additional iterations by choosing option 1 or 2",
+  ],
+  standby_exhausted: [
+    "Wait and retry — the provider may be temporarily overloaded",
+    "Continue to resume from where the pipeline left off",
+  ],
+};
+
+/**
+ * Validate a resume answer against pipeline policies.
+ *
+ * @param {string|null} answer - The resume answer from the host
+ * @param {string} [pauseContext] - The context of the pause (e.g. "reviewer_fail_fast")
+ * @returns {{ valid: boolean, reason?: string, suggestions?: string[] }}
+ */
+export function validatePolicyCompliance(answer, pauseContext) {
+  if (answer == null || answer === "") return { valid: true };
+  if (typeof answer !== "string") return { valid: true };
+
+  const text = answer.trim();
+  for (const { regex, policy } of BYPASS_PATTERNS) {
+    if (regex.test(text)) {
+      const suggestions = [
+        ...(CONTEXT_SUGGESTIONS[pauseContext] || []),
+        ...(SUGGESTIONS_BY_POLICY[policy] || []),
+      ];
+      return {
+        valid: false,
+        reason: `Pipeline policy "${policy}" cannot be bypassed. Provide technical guidance instead.`,
+        suggestions: [...new Set(suggestions)],
+      };
+    }
+  }
+
+  return { valid: true };
+}