scrumrun 2.0.0 → 2.1.0

package/lib/runtime/orchestrator.js

@@ -15,8 +15,11 @@ const {
   withArtifactLock
 } = require("../v2/artifacts");
 const { buildContextPackage } = require("./context");
+const { artifactSnapshot, canonicalFingerprint, canonicalWatchSnapshot } = require("./canonical-snapshot");
 const { decodeApproval } = require("./request-engine");
 const { extractLearningCandidates } = require("../code-intel/learning");
+const { appendRunEvent, createRunBody, instant } = require("./run-ledger");
+const { recoverPendingTransactions, runKernelTransaction } = require("../v2/transaction");
 
 const TERMINAL = new Set(["completed", "failed", "cancelled", "resolved", "rejected", "deprecated", "invalidated", "archived", "passed"]);
 
@@ -39,40 +42,39 @@ function titleFor(request) {
 }
 
 function stateFingerprint(repository) {
-  const hashes = [];
-  for (const kind of Object.keys(ARTIFACT_TYPES)) {
-    for (const artifact of repository.list(kind)) {
-      hashes.push(`${path.relative(repository.scrumDir, artifact.file)}\0${sha256(fs.readFileSync(artifact.file))}`);
-    }
-  }
-  for (const relative of ["guardrails.md", "config.md", "project.md", "method.json"]) {
-    const file = path.join(repository.scrumDir, relative);
-    hashes.push(`${relative}\0${fs.existsSync(file) ? sha256(fs.readFileSync(file)) : "missing"}`);
-  }
-  return sha256(hashes.sort().join("\n"));
+  return canonicalFingerprint(repository.scrumDir, artifactSnapshot(repository.scrumDir).hashes);
 }
 
-function renderState(repository) {
-  const linesFor = (kinds) => kinds.flatMap((kind) => repository.list(kind)
-    .filter((artifact) => artifact.record && !TERMINAL.has(artifact.record.status))
-    .map((artifact) => {
-      const title = ((artifact.body || "").match(/^# ([^\r\n]+)/m) || [])[1] || artifact.record.id;
-      return `- ${artifact.record.id} | ${kind} | ${artifact.record.status} | ${title}`;
-    }));
+function stateProjection(repository) {
+  const snapshot = artifactSnapshot(repository.scrumDir);
+  const linesFor = (kinds) => kinds.flatMap((kind) => (snapshot.records[kind] || [])
+    .filter((record) => record.id && !TERMINAL.has(record.status))
+    .map((record) => `- ${record.id} | ${kind} | ${record.status} | ${record.title || record.id}`));
   const work = linesFor(["feature", "task", "sprint", "run", "review"]);
   const memory = linesFor(["decision", "knowledge", "insight", "dossier"]);
-  return `# ScrumRun State\n\nGenerated: ${date()}\nSource fingerprint: ${stateFingerprint(repository)}\nAuthority: none; rebuild from canonical artifacts.\n\n## Active Work\n\n${work.length ? work.join("\n") : "- No active canonical work."}\n\n## Relevant Memory\n\n${memory.length ? memory.join("\n") : "- No active canonical memory."}\n`;
+  const sourceFingerprint = canonicalFingerprint(repository.scrumDir, snapshot.hashes);
+  const watch = canonicalWatchSnapshot(repository.scrumDir);
+  const content = `# ScrumRun State\n\nProjection schema: 1\nGenerated: ${new Date().toISOString()}\nSource fingerprint: ${sourceFingerprint}\nWatch fingerprint: ${watch.fingerprint}\nAuthority: none; rebuild from canonical artifacts.\n\n## Active Work\n\n${work.length ? work.join("\n") : "- No active canonical work."}\n\n## Relevant Memory\n\n${memory.length ? memory.join("\n") : "- No active canonical memory."}\n`;
+  return { content, sourceFingerprint, watchFingerprint: watch.fingerprint, sourceFiles: watch.files };
+}
+
+function renderState(repository) {
+  return stateProjection(repository).content;
 }
 
 function refreshState(scrumDir) {
   const repository = new ArtifactRepository(scrumDir);
-  atomicWrite(path.join(scrumDir, "state.md"), renderState(repository));
+  const projection = stateProjection(repository);
+  atomicWrite(path.join(scrumDir, "state.md"), projection.content);
+  return projection;
 }
 
 function stateIsStale(scrumDir) {
   const content = fs.existsSync(path.join(scrumDir, "state.md")) ? fs.readFileSync(path.join(scrumDir, "state.md"), "utf8") : "";
   const stored = (content.match(/^Source fingerprint:\s*([a-f0-9]{64})$/m) || [])[1];
   if (!stored) return true;
+  const watched = (content.match(/^Watch fingerprint:\s*([a-f0-9]{64})$/m) || [])[1];
+  if (watched && watched === canonicalWatchSnapshot(scrumDir).fingerprint) return false;
   return stored !== stateFingerprint(new ArtifactRepository(scrumDir));
 }
 
@@ -83,12 +85,13 @@ function approvalExisting(repository, approvalId) {
   return { task: task.record, run: run ? run.record : null };
 }
 
-function approveRequestUnlocked(projectRoot, token, { failurePoint = null } = {}) {
+function approveRequestUnlocked(projectRoot, token, { failurePoint = null, interruptPoint = null } = {}) {
   const payload = decodeApproval(token);
   if (payload.policy.status !== "passed" || payload.policy.violations.length) throw new Error("Blocked intake cannot be approved.");
   const issued = Date.parse(payload.issuedAt);
   if (!Number.isFinite(issued) || Date.now() - issued > 24 * 60 * 60 * 1000) throw new Error("Approval token expired; run intake again.");
   const scrumDir = path.join(projectRoot, ".scrumrun");
+  recoverPendingTransactions(scrumDir);
   const repository = new ArtifactRepository(scrumDir);
   const approvalId = sha256(token).slice(0, 20);
   const existing = approvalExisting(repository, approvalId);
@@ -125,20 +128,22 @@ function approveRequestUnlocked(projectRoot, token, { failurePoint = null } = {}
     task: taskId,
     sprint: null,
     attempt: 1,
+    ledger: 1,
     approval_id: approvalId
   };
   const taskBody = `# ${titleFor(payload.request)}\n\n## Request\n\n${payload.request}\n\n## Classification\n\n- Type: ${payload.classification.type}\n- Reason: ${payload.classification.reason}\n- Risk: ${payload.risk.level}\n\n## Approval\n\n- Explicit approval token: ${approvalId}\n- Context fingerprint: ${payload.fingerprint}`;
-  const runBody = `# Run for ${taskId}\n\n## Transition Log\n\n- ${created}: created → executing — explicit approval accepted.\n\n## Validation\n\n- Pending.\n\n## Learning\n\n- Pending.`;
-  let taskWritten = false;
-  let runWritten = false;
+  const runBody = createRunBody(run, { approvalId }).body;
   try {
-    taskWritten = repository.write(task, taskBody).status === "written";
-    if (failurePoint === "after-task") throw new Error("Injected approval failure after Task creation.");
-    runWritten = repository.write(run, runBody).status === "written";
-    if (failurePoint === "after-run") throw new Error("Injected approval failure after Run creation.");
+    runKernelTransaction(scrumDir, "approve-task-run", [
+      { file: repository.pathFor(task), previous: null, next: serializeArtifact(task, taskBody) },
+      { file: repository.pathFor(run), previous: null, next: serializeArtifact(run, runBody) }
+    ], {
+      failurePoint: failurePoint === "after-task" ? "after-1" : failurePoint === "after-run" ? "after-2" : null,
+      interruptPoint
+    });
   } catch (error) {
-    if (runWritten) fs.rmSync(repository.pathFor(run), { force: true });
-    if (taskWritten) fs.rmSync(repository.pathFor(task), { force: true });
+    if (failurePoint === "after-task") throw new Error(`Injected approval failure after Task creation: ${error.message}`);
+    if (failurePoint === "after-run") throw new Error(`Injected approval failure after Run creation: ${error.message}`);
     throw error;
   }
   refreshState(scrumDir);
@@ -149,45 +154,49 @@ function approveRequest(projectRoot, token, options = {}) {
   return withArtifactLock(path.join(projectRoot, ".scrumrun"), "approval", () => approveRequestUnlocked(projectRoot, token, options));
 }
 
-function transitionedContent(content, kind, nextStatus, note) {
+function transitionedArtifactContent(content, kind, nextStatus, updated) {
   const parsed = parseArtifact(content);
   const errors = [...parsed.errors, ...validateArtifact(parsed.record, kind)];
   if (errors.length) throw new Error(`Invalid ${kind} artifact: ${errors.join("; ")}`);
-  const nextRecord = transitionArtifact(parsed.record, nextStatus, date());
+  const nextRecord = transitionArtifact(parsed.record, nextStatus, updated);
   const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---([\s\S]*)$/);
   let frontmatter = frontmatterMatch[1]
     .replace(/^status:\s*.*$/m, `status: ${nextStatus}`)
     .replace(/^updated:\s*.*$/m, `updated: ${nextRecord.updated}`);
-  const transition = `\n\n## Transition ${date()} · ${parsed.record.status}-to-${nextStatus}\n\n- ${note || "State transition requested through ScrumRun."}\n`;
-  const next = `---\n${frontmatter}\n---${frontmatterMatch[2].trimEnd()}${transition}`;
+  const next = `---\n${frontmatter}\n---${frontmatterMatch[2]}`;
   const validated = parseArtifact(next);
   const nextErrors = [...validated.errors, ...validateArtifact(validated.record, kind)];
   if (nextErrors.length) throw new Error(`Transition validation failed: ${nextErrors.join("; ")}`);
   return { content: next, record: validated.record };
 }
 
-function writePairWithRollback(changes, failurePoint = null) {
-  const written = [];
-  try {
-    for (let index = 0; index < changes.length; index++) {
-      const change = changes[index];
-      atomicWrite(change.file, change.next);
-      written.push(change);
-      if (failurePoint === `after-${index + 1}`) throw new Error(`Injected transition failure after write ${index + 1}.`);
-    }
-  } catch (error) {
-    for (const change of written.reverse()) atomicWrite(change.file, change.previous);
-    throw error;
-  }
+function transitionedRunContent(content, nextStatus, options = {}) {
+  const parsed = parseArtifact(content);
+  const errors = [...parsed.errors, ...validateArtifact(parsed.record, "run")];
+  if (errors.length) throw new Error(`Invalid run artifact: ${errors.join("; ")}`);
+  const occurredAt = options.occurredAt ? instant(options.occurredAt) : instant();
+  const updated = occurredAt.slice(0, 10);
+  const nextRecord = transitionArtifact(parsed.record, nextStatus, updated);
+  const ledger = appendRunEvent(parsed.record, parsed.body, nextRecord, { ...options, occurredAt });
+  return {
+    content: serializeArtifact(nextRecord, ledger.body),
+    record: nextRecord,
+    event: ledger.event
+  };
 }
 
-function transitionRunUnlocked(projectRoot, runId, nextStatus, { note = null, failurePoint = null } = {}) {
+function transitionRunUnlocked(projectRoot, runId, nextStatus, { note = null, evidence = [], actor = "agent", occurredAt = null, failurePoint = null, interruptPoint = null } = {}) {
   const scrumDir = path.join(projectRoot, ".scrumrun");
+  const recovered = recoverPendingTransactions(scrumDir);
   const repository = new ArtifactRepository(scrumDir);
   const runArtifact = repository.read("run", runId);
   if (!runArtifact) throw new Error(`Run not found: ${runId}`);
   const taskArtifact = repository.read("task", runArtifact.record.task);
   if (!taskArtifact) throw new Error(`Task not found for ${runId}: ${runArtifact.record.task}`);
+  if (runArtifact.record.status === nextStatus && recovered.some((item) => item.action === "verified")) {
+    refreshState(scrumDir);
+    return { run: runArtifact.record, task: taskArtifact.record, learning: null, recovered };
+  }
   const taskStatuses = {
     validating: "validating",
     learning: "learning",
@@ -200,12 +209,17 @@ function transitionRunUnlocked(projectRoot, runId, nextStatus, { note = null, fa
   if (!nextTaskStatus) throw new Error(`Run status cannot synchronize a Task: ${nextStatus}`);
   const runPrevious = fs.readFileSync(runArtifact.file, "utf8");
   const taskPrevious = fs.readFileSync(taskArtifact.file, "utf8");
-  const runNext = transitionedContent(runPrevious, "run", nextStatus, note);
-  const taskNext = transitionedContent(taskPrevious, "task", nextTaskStatus, `Synchronized from ${runId}: ${note || nextStatus}.`);
-  writePairWithRollback([
-    { file: runArtifact.file, previous: runPrevious, next: runNext.content },
-    { file: taskArtifact.file, previous: taskPrevious, next: taskNext.content }
-  ], failurePoint);
+  const runNext = transitionedRunContent(runPrevious, nextStatus, { note, evidence, actor, occurredAt });
+  const taskNext = transitionedArtifactContent(taskPrevious, "task", nextTaskStatus, runNext.record.updated);
+  try {
+    runKernelTransaction(scrumDir, "transition-run-task", [
+      { file: runArtifact.file, previous: runPrevious, next: runNext.content },
+      { file: taskArtifact.file, previous: taskPrevious, next: taskNext.content }
+    ], { failurePoint, interruptPoint });
+  } catch (error) {
+    if (failurePoint) throw new Error(`Injected transition failure: ${error.message}`);
+    throw error;
+  }
   refreshState(scrumDir);
   let learning = null;
   if (nextStatus === "learning") {
@@ -216,18 +230,28 @@ function transitionRunUnlocked(projectRoot, runId, nextStatus, { note = null, fa
     }
     refreshState(scrumDir);
   }
-  return { run: runNext.record, task: taskNext.record, learning };
+  return { run: runNext.record, task: taskNext.record, learning, recovered };
 }
 
 function transitionRun(projectRoot, runId, nextStatus, options = {}) {
   return withArtifactLock(path.join(projectRoot, ".scrumrun"), `run-${String(runId).toLowerCase()}`, () => transitionRunUnlocked(projectRoot, runId, nextStatus, options));
 }
 
-function retryTaskUnlocked(projectRoot, taskId, { note = "Retry explicitly approved.", failurePoint = null } = {}) {
+function retryTaskUnlocked(projectRoot, taskId, { note = "Retry explicitly approved.", failurePoint = null, interruptPoint = null } = {}) {
   const scrumDir = path.join(projectRoot, ".scrumrun");
+  const recovered = recoverPendingTransactions(scrumDir);
   const repository = new ArtifactRepository(scrumDir);
   const taskArtifact = repository.read("task", taskId);
   if (!taskArtifact) throw new Error(`Task not found: ${taskId}`);
+  if (taskArtifact.record.status === "running" && recovered.some((item) => item.action === "verified")) {
+    const latest = repository.list("run")
+      .filter((artifact) => artifact.record && artifact.record.task === taskId)
+      .sort((left, right) => right.record.attempt - left.record.attempt)[0];
+    if (latest) {
+      refreshState(scrumDir);
+      return { run: latest.record, task: taskArtifact.record, content: fs.readFileSync(latest.file, "utf8"), recovered };
+    }
+  }
   if (!["failed", "blocked", "partial"].includes(taskArtifact.record.status)) {
     throw new Error(`Task ${taskId} is ${taskArtifact.record.status}; retry requires failed, blocked, or partial.`);
   }
@@ -244,23 +268,32 @@ function retryTaskUnlocked(projectRoot, taskId, { note = "Retry explicitly appro
     task: taskId,
     sprint: taskArtifact.record.sprint || null,
     attempt: attempts.length ? Math.max(...attempts) + 1 : 1,
+    ledger: 1,
     approval_id: taskArtifact.record.approval_id || null
   };
-  const runContent = serializeArtifact(run, `# Retry for ${taskId}\n\n## Transition Log\n\n- ${date()}: created → executing — ${note}`);
+  const runBody = createRunBody(run, {
+    title: `Retry for ${taskId}`,
+    actor: "owner",
+    reason: note,
+    evidence: [{ kind: "approval", summary: note }]
+  }).body;
+  const runContent = serializeArtifact(run, runBody);
   const taskPrevious = fs.readFileSync(taskArtifact.file, "utf8");
-  const taskNext = transitionedContent(taskPrevious, "task", "running", `${run.id} created: ${note}`);
-  let runWritten = false;
+  const taskNext = transitionedArtifactContent(taskPrevious, "task", "running", date());
   try {
-    runWritten = repository.write(run, `# Retry for ${taskId}\n\n## Transition Log\n\n- ${date()}: created → executing — ${note}`).status === "written";
-    if (failurePoint === "after-run") throw new Error("Injected retry failure after Run creation.");
-    atomicWrite(taskArtifact.file, taskNext.content);
+    runKernelTransaction(scrumDir, "retry-task-run", [
+      { file: repository.pathFor(run), previous: null, next: runContent },
+      { file: taskArtifact.file, previous: taskPrevious, next: taskNext.content }
+    ], {
+      failurePoint: failurePoint === "after-run" ? "after-1" : failurePoint,
+      interruptPoint
+    });
   } catch (error) {
-    if (runWritten) fs.rmSync(repository.pathFor(run), { force: true });
-    atomicWrite(taskArtifact.file, taskPrevious);
+    if (failurePoint === "after-run") throw new Error(`Injected retry failure after Run creation: ${error.message}`);
     throw error;
   }
   refreshState(scrumDir);
-  return { run, task: taskNext.record, content: runContent };
+  return { run, task: taskNext.record, content: runContent, recovered };
 }
 
 function retryTask(projectRoot, taskId, options = {}) {

package/lib/runtime/policy-engine.js

@@ -0,0 +1,184 @@
+"use strict";
+
+const { containsSecret } = require("../security/secrets");
+
+const GUARDRAIL_STATUSES = new Set(["active", "retired", "superseded"]);
+const ENFORCEMENTS = new Set([
+  "manual",
+  "builtin:secret-boundary",
+  "builtin:approval-gate",
+  "builtin:read-only-path",
+  "builtin:owner-work",
+  "builtin:migration-integrity",
+  "builtin:review-gate"
+]);
+
+function normalized(value) {
+  return String(value || "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
+}
+
+function capped(value, limit = 500) {
+  const text = String(value || "").trim();
+  return text.length <= limit ? text : `${text.slice(0, limit)}…`;
+}
+
+function fieldMap(block) {
+  const fields = {};
+  for (const match of block.matchAll(/^([A-Za-z][A-Za-z _-]*):\s*(.+)$/gm)) {
+    fields[normalized(match[1]).replace(/[ _-]+/g, "_")] = match[2].trim();
+  }
+  return fields;
+}
+
+function proseRule(block) {
+  const lines = block.split(/\r?\n/).slice(1);
+  const prose = [];
+  for (const line of lines) {
+    if (/^#{1,6}\s/.test(line)) break;
+    if (/^[A-Za-z][A-Za-z _-]*:\s*/.test(line)) continue;
+    if (!line.trim() && prose.length) break;
+    if (line.trim()) prose.push(line.trim());
+  }
+  return prose.join(" ");
+}
+
+function inferEnforcement(title, rule) {
+  const normalizedTitle = normalized(title);
+  const text = normalized(`${title} ${rule}`);
+  if (/secret|credential|vault|segredo|credencial/.test(text)) return "builtin:secret-boundary";
+  if (/intake|pre-approval|pre approval|recebimento/.test(text) && /approval|approve|aprov|consent/.test(text)) return "builtin:approval-gate";
+  if (/read.?only|somente leitura|path marked|caminho marcado/.test(text)) return "builtin:read-only-path";
+  if (/owner work|trabalho do dono/.test(text) || (/(owner|dono|user changes|mudancas do usuario)/.test(text) && /(preserv|overwrite|sobrescrev)/.test(text))) return "builtin:owner-work";
+  if (/migration|migracao|migrat|never guesses|nunca adivinha/.test(normalizedTitle)) return "builtin:migration-integrity";
+  if (/commit|release|publish|lancamento|publica/.test(normalizedTitle) || (/(review|revis)/.test(normalizedTitle) && /gate|bloque|obrigator/.test(normalizedTitle))) return "builtin:review-gate";
+  return "manual";
+}
+
+function parseGuardrails(content) {
+  const source = String(content || "");
+  const headings = [...source.matchAll(/^## (GR-\d{3,})\s*[-—:]\s*([^\r\n]+)$/gm)];
+  return headings.map((heading, index) => {
+    const end = index + 1 < headings.length ? headings[index + 1].index : source.length;
+    const block = source.slice(heading.index, end);
+    const fields = fieldMap(block);
+    const title = heading[2].trim();
+    const rule = capped(fields.rule || proseRule(block) || title);
+    const status = normalized(fields.status || "active").replace(/[._-]+$/, "");
+    const enforcement = normalized(fields.enforcement || inferEnforcement(title, rule));
+    const scope = (fields.scope || "all").split(/\s*,\s*/).map((value) => normalized(value)).filter(Boolean);
+    return { id: heading[1], title, rule, status, enforcement, scope, source: fields.source || null };
+  });
+}
+
+function configFields(content) {
+  return fieldMap(String(content || ""));
+}
+
+function readOnlyPaths(content) {
+  const value = configFields(content).read_only_paths;
+  if (!value) return [];
+  return value.split(/\s*,\s*/).map((entry) => entry.trim()).filter(Boolean);
+}
+
+function configWeakeningAttempts(content) {
+  const text = String(content || "");
+  const fields = configFields(text);
+  const violations = [];
+  if (/^(?:never|off|disabled|automatic|nunca|desativad[oa]|automatic[oa])$/i.test(normalized(fields.execution_approval || ""))) {
+    violations.push(`Execution Approval cannot be ${fields.execution_approval}.`);
+  }
+  if (/\b(?:disable|ignore|bypass|weaken|desativar|ignorar|contornar|enfraquecer)\s+(?:active\s+|ativ[oa]s?\s+)?(?:guardrail|policy|politica)/i.test(normalized(text))) {
+    violations.push("Configuration attempts to disable or bypass active Guardrails.");
+  }
+  for (const entry of readOnlyPaths(text)) {
+    if (entry.startsWith("/") || entry.includes("..") || entry === "." || entry === "~") violations.push(`Read-Only Paths contains an unsafe path: ${entry}`);
+  }
+  return violations;
+}
+
+function requestMentionsPath(request, configuredPath) {
+  const clean = normalized(configuredPath.replace(/^\.\//, ""));
+  const escaped = clean.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(^|[\\s"'\`:(])${escaped}(?=$|[/\\\\\\s"'\`:),])`).test(normalized(request));
+}
+
+function evaluation(guardrail, status, code, message, evidence = []) {
+  return { guardrail: guardrail.id, status, code, message, enforcement: guardrail.enforcement, evidence };
+}
+
+function evaluateGuardrail(guardrail, context) {
+  const request = context.request || "";
+  const requestText = normalized(request);
+  switch (guardrail.enforcement) {
+    case "builtin:secret-boundary": {
+      const unsafeRequest = containsSecret(request);
+      const unsafeContext = context.warnings.some((warning) => /secret-like/i.test(warning));
+      if (unsafeRequest || unsafeContext) {
+        return evaluation(guardrail, "blocked", "SECRET_BOUNDARY", "secret-like content must be removed or redacted before planning.", [unsafeRequest ? "request" : "canonical-context"]);
+      }
+      return evaluation(guardrail, "passed", "SECRET_BOUNDARY", "No secret-like request or canonical context was detected.");
+    }
+    case "builtin:approval-gate":
+      return evaluation(guardrail, "passed", "APPROVAL_GATE", "Intake remains read-only and execution still requires the emitted approval token.", ["pipeline:awaiting_approval"]);
+    case "builtin:read-only-path": {
+      const paths = readOnlyPaths(context.config);
+      const matched = paths.filter((entry) => requestMentionsPath(request, entry));
+      if (matched.length) return evaluation(guardrail, "blocked", "READ_ONLY_PATH", `Request targets configured read-only path(s): ${matched.join(", ")}.`, matched);
+      return evaluation(guardrail, paths.length ? "passed" : "deferred", "READ_ONLY_PATH", paths.length ? "Configured read-only paths were checked." : "No structured Read-Only Paths are configured; enforce owner path constraints during execution.", paths);
+    }
+    case "builtin:owner-work":
+      return evaluation(guardrail, "deferred", "OWNER_WORK", "Mutation-time hashes, scoped staging, and transaction preconditions enforce owner-work preservation.");
+    case "builtin:migration-integrity":
+      return evaluation(guardrail, /migrat|migrac/.test(requestText) ? "deferred" : "passed", "MIGRATION_INTEGRITY", /migrat|migrac/.test(requestText) ? "The explicit migration preflight/apply/rollback gate must enforce this Guardrail." : "Request does not invoke migration.");
+    case "builtin:review-gate":
+      return evaluation(guardrail, /commit|release|publish|publica|lanc|deploy/.test(requestText) ? "deferred" : "passed", "REVIEW_GATE", /commit|release|publish|publica|lanc|deploy/.test(requestText) ? "Configured reviews and the external owner gate must pass before the requested boundary." : "Request does not cross a commit or release gate.");
+    default:
+      return evaluation(guardrail, "deferred", "MANUAL_GUARDRAIL", "This Guardrail has no deterministic matcher and requires execution-time review.");
+  }
+}
+
+function evaluatePolicy(context) {
+  const activeGuardrails = context.guardrails.filter((guardrail) => guardrail.status === "active");
+  const evaluations = activeGuardrails.map((guardrail) => evaluateGuardrail(guardrail, context));
+  if (context.layout === "v1") evaluations.push({ guardrail: "I-15", status: "blocked", code: "V1_REQUIRES_MIGRATION", message: "Project must be explicitly migrated to v2 before approved execution.", enforcement: "builtin", evidence: [] });
+  if (!activeGuardrails.length) evaluations.push({ guardrail: "I-06", status: "blocked", code: "GUARDRAILS_MISSING", message: "No active canonical Guardrail could be loaded.", enforcement: "builtin", evidence: [] });
+  if (context.warnings.some((warning) => warning.includes("guardrails.md"))) evaluations.push({ guardrail: "I-06", status: "blocked", code: "GUARDRAILS_MISSING", message: "Canonical guardrails.md is missing.", enforcement: "builtin", evidence: [] });
+  for (const message of configWeakeningAttempts(context.config)) {
+    evaluations.push({ guardrail: "I-06", status: "blocked", code: "CONFIG_WEAKENS_POLICY", message, enforcement: "builtin", evidence: ["config.md"] });
+  }
+  if (containsSecret(context.request) && !evaluations.some((item) => item.code === "SECRET_BOUNDARY" && item.status === "blocked")) {
+    evaluations.push({ guardrail: "I-11", status: "blocked", code: "SECRET_BOUNDARY", message: "Request appears to contain a secret; remove or redact it.", enforcement: "builtin", evidence: ["request"] });
+  }
+  const blocked = evaluations.filter((item) => item.status === "blocked");
+  return {
+    status: blocked.length ? "blocked" : "passed",
+    checked: [...new Set(evaluations.map((item) => item.guardrail))],
+    deferred: [...new Set(evaluations.filter((item) => item.status === "deferred").map((item) => item.guardrail))],
+    evaluations,
+    violations: blocked.map((item) => `${item.guardrail} ${item.code}: ${item.message}`)
+  };
+}
+
+function validateGuardrailDocument(content) {
+  const records = parseGuardrails(content);
+  const errors = [];
+  const ids = new Set();
+  for (const record of records) {
+    if (ids.has(record.id)) errors.push(`Duplicate Guardrail id: ${record.id}`);
+    ids.add(record.id);
+    if (!GUARDRAIL_STATUSES.has(record.status)) errors.push(`${record.id} has invalid status: ${record.status || "missing"}`);
+    if (!record.rule.trim()) errors.push(`${record.id} has no rule content`);
+    if (!ENFORCEMENTS.has(record.enforcement)) errors.push(`${record.id} has unknown enforcement: ${record.enforcement}`);
+  }
+  return { records, errors };
+}
+
+module.exports = {
+  configWeakeningAttempts,
+  evaluatePolicy,
+  inferEnforcement,
+  normalized,
+  parseGuardrails,
+  readOnlyPaths,
+  validateGuardrailDocument
+};

package/lib/runtime/request-engine.js

@@ -3,51 +3,55 @@
 const { sha256 } = require("../v2/artifacts");
 const { buildContextPackage } = require("./context");
 const { containsSecret } = require("../security/secrets");
+const { evaluatePolicy, normalized } = require("./policy-engine");
 
 function assessRisk(request) {
-  const text = request.toLowerCase();
-  const high = ["delete", "drop ", "migration", "migrate", "payment", "pricing", "auth", "permission", "security", "secret", "production", "publish", "release", "deploy"];
-  const medium = ["database", "schema", "api", "cache", "performance", "refactor", "dependency", "upgrade", "rename", "move"];
-  const reasons = [];
-  for (const term of high) if (text.includes(term)) reasons.push(`high-impact term: ${term.trim()}`);
-  if (reasons.length) return { level: "high", reasons: [...new Set(reasons)].slice(0, 6) };
-  for (const term of medium) if (text.includes(term)) reasons.push(`cross-cutting term: ${term}`);
-  if (reasons.length) return { level: "medium", reasons: [...new Set(reasons)].slice(0, 6) };
+  const text = normalized(request);
+  const high = [
+    ["destructive", /\b(delete|drop|truncate|erase|wipe|apagar|excluir|remover tudo)\b/],
+    ["migration", /\b(migrat\w*|migrac\w*)\b/],
+    ["external-release", /\b(publish|release|deploy|publicar|lancar|implant|producao)\b/],
+    ["security-boundary", /\b(auth|authorization|permission|security|secret|credential|autentic|autoriz|permiss|seguranca|segredo|credencial)\b/],
+    ["money", /\b(payment|pricing|billing|pagamento|preco|faturamento)\b/]
+  ];
+  const medium = [
+    ["data-or-contract", /\b(database|schema|api|contract|banco|contrato)\b/],
+    ["runtime-kernel", /\b(runtime|kernel|transaction|journal|recovery|multi-file|transacion|recuperac|multi-arquivo)\b/],
+    ["performance-or-cache", /\b(cache|performance|latency|index|desempenho|latencia|indice)\b/],
+    ["dependency-or-upgrade", /\b(dependency|upgrade|package|version|dependencia|atualiz|versao)\b/],
+    ["cross-cutting-change", /\b(refactor|rename|move|architecture|cli|refator|renome|mover|arquitetura)\b/]
+  ];
+  const highSignals = high.filter(([, matcher]) => matcher.test(text)).map(([signal]) => `high-impact signal: ${signal}`);
+  if (highSignals.length) return { level: "high", reasons: highSignals.slice(0, 6) };
+  const mediumSignals = medium.filter(([, matcher]) => matcher.test(text)).map(([signal]) => `cross-cutting signal: ${signal}`);
+  if (mediumSignals.length) return { level: "medium", reasons: mediumSignals.slice(0, 6) };
   return { level: "low", reasons: ["no high-impact signals detected; validate scope before execution"] };
 }
 
 function classifyRequest(request) {
-  const text = request.toLowerCase();
+  const text = normalized(request);
   if (/\b(investigat|analy[sz]|study|discover|pesquis|analis|estud|descobr)/.test(text)) {
     return { type: "discovery", taskType: "discovery", reason: "request is primarily knowledge-seeking" };
   }
-  if (/\b(bug|fix|broken|regression|erro|falha|corrigir|consert)/.test(text)) {
+  if (/\b(bug|fix|broken|regression|erro|falha|corrigir|consertar)\b/.test(text)) {
     return { type: "fix", taskType: "fix", reason: "request describes corrective work" };
   }
-  if (/\b(feature|initiative|epic|iniciativa|funcionalidade)\b/.test(text)) {
+  if (/\b(initiative|epic|roadmap|program|iniciativa|programa)\b/.test(text)) {
     return { type: "feature", taskType: "feature", reason: "request describes a long-lived product initiative" };
   }
-  if (/\b(sprint|timebox|batch|release train|lote)\b/.test(text)) {
+  if (/\b(sprint|timebox|batch|release train|lote)\b/.test(text) && /\b(tasks?|tarefas?|entregas?)\b/.test(text)) {
     return { type: "sprint", taskType: "task", reason: "request explicitly asks for a timebox or delivery batch" };
   }
-  if (/\b(document|docs|readme|typo|texto|documenta)/.test(text)) {
+  const documentation = /\b(document|docs|readme|typo|texto|documenta)/.test(text);
+  const implementation = /\b(implement\w*|build\w*|creat\w*|add\w*|runtime|kernel|schema|migrat\w*|migrac\w*|transaction\w*|code|cli|criar|adicionar|construir|codigo|transacion\w*)\b/.test(text);
+  if (documentation && !implementation) {
     return { type: "task", taskType: "docs", reason: "request appears bounded to documentation" };
   }
   return { type: "task", taskType: "task", reason: "request is best represented as one atomic Task" };
 }
 
 function applyPolicy(context) {
-  const violations = [];
-  if (context.layout === "v1") violations.push("Project must be explicitly migrated to v2 before approved execution.");
-  if (containsSecret(context.request)) violations.push("Request appears to contain a secret; remove/redact it before planning or persistence.");
-  if (context.warnings.some((warning) => warning.includes("Secret-like content"))) violations.push("Canonical project context contains secret-like content; remove it before planning.");
-  if (!context.guardrails.length) violations.push("No active canonical guardrail could be loaded.");
-  if (context.warnings.some((warning) => warning.includes("guardrails.md"))) violations.push("Canonical guardrails are missing.");
-  return {
-    status: violations.length ? "blocked" : "passed",
-    checked: context.guardrails.map((guardrail) => guardrail.id),
-    violations
-  };
+  return evaluatePolicy(context);
 }
 
 function stableJson(value) {