scrumrun 2.0.0 → 2.1.1

package/lib/runtime/orchestrator.js

@@ -15,8 +15,13 @@ const {
   withArtifactLock
 } = require("../v2/artifacts");
 const { buildContextPackage } = require("./context");
+const { evaluatePolicy } = require("./policy-engine");
+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 { policyState, prepareCompletion, publicWorkspace, verifyWorkspaceIntegrity, workspaceState } = require("./mutation-gateway");
+const { recoverPendingTransactions, runKernelTransaction } = require("../v2/transaction");
 
 const TERMINAL = new Set(["completed", "failed", "cancelled", "resolved", "rejected", "deprecated", "invalidated", "archived", "passed"]);
 
@@ -39,40 +44,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 +87,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);
@@ -97,8 +102,14 @@ function approveRequestUnlocked(projectRoot, token, { failurePoint = null } = {}
   if (currentContext.fingerprint !== payload.fingerprint) {
     throw new Error("Project context changed after planning; run intake again before approval.");
   }
+  const workspace = workspaceState(projectRoot);
+  if (!payload.workspaceFingerprint || workspace.fingerprint !== payload.workspaceFingerprint) {
+    throw new Error("Project workspace changed after planning; run intake again before approval.");
+  }
 
   const created = date();
+  const enforceablePolicy = policyState(projectRoot);
+  const baseline = publicWorkspace(workspace);
   const taskId = nextId(repository, "task");
   const runId = nextId(repository, "run");
   const task = {
@@ -125,20 +136,29 @@ function approveRequestUnlocked(projectRoot, token, { failurePoint = null } = {}
     task: taskId,
     sprint: null,
     attempt: 1,
+    ledger: 1,
+    guardrails: 1,
+    workspace: 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,
+    obligations: payload.policy.obligations || [],
+    policyFingerprint: enforceablePolicy.fingerprint,
+    workspaceBaseline: baseline
+  }).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 +169,52 @@ 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 };
+  }
+  if (runArtifact.record.guardrails === 1 && runArtifact.record.workspace === 1 && ["validating", "learning"].includes(nextStatus)) {
+    verifyWorkspaceIntegrity(projectRoot, runArtifact);
+  }
   const taskStatuses = {
     validating: "validating",
     learning: "learning",
@@ -200,12 +227,19 @@ 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 prepared = nextStatus === "completed" ? prepareCompletion(projectRoot, runArtifact, { occurredAt }) : null;
+  const transitionSource = prepared ? serializeArtifact(prepared.record, prepared.body) : runPrevious;
+  const runNext = transitionedRunContent(transitionSource, 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,24 +250,41 @@ 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.`);
   }
   const attempts = repository.list("run")
     .filter((artifact) => artifact.record && artifact.record.task === taskId)
     .map((artifact) => Number(artifact.record.attempt) || 0);
+  const requestMatch = taskArtifact.body.match(/^## Request[ \t]*\r?\n\r?\n([\s\S]*?)(?=^## |(?![\s\S]))/m);
+  const request = requestMatch ? requestMatch[1].trim() : `Retry ${taskId}`;
+  const context = buildContextPackage(projectRoot, request);
+  const policy = evaluatePolicy(context);
+  if (policy.status !== "passed") throw new Error(`Retry is blocked by current policy: ${policy.violations.join("; ")}`);
+  const enforceablePolicy = policyState(projectRoot);
+  const baseline = publicWorkspace(workspaceState(projectRoot));
   const run = {
     id: nextId(repository, "run"),
     kind: "run",
@@ -244,23 +295,37 @@ 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,
+    guardrails: 1,
+    workspace: 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 }],
+    obligations: policy.obligations || [],
+    policyFingerprint: enforceablePolicy.fingerprint,
+    workspaceBaseline: baseline
+  }).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,267 @@
+"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:canonical-write",
+  "builtin:canonical-truth",
+  "builtin:memory-candidate",
+  "builtin:migration-integrity",
+  "builtin:review-gate"
+]);
+const SCOPES = new Set(["all", "intake", "execution", "mutation", "canonical", "memory", "migration", "validation", "learning", "completion", "commit", "release", "logs"]);
+
+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,
+      explicit: {
+        status: Object.prototype.hasOwnProperty.call(fields, "status"),
+        enforcement: Object.prototype.hasOwnProperty.call(fields, "enforcement"),
+        scope: Object.prototype.hasOwnProperty.call(fields, "scope"),
+        rule: Object.prototype.hasOwnProperty.call(fields, "rule")
+      }
+    };
+  });
+}
+
+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, scope: guardrail.scope, 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:canonical-write":
+      return evaluation(guardrail, "deferred", "CANONICAL_WRITE", "Canonical writes require the lossless transaction gateway and post-write validation.");
+    case "builtin:canonical-truth":
+      return evaluation(guardrail, "deferred", "CANONICAL_TRUTH", "Completion must prove that generated caches did not replace canonical Markdown truth.");
+    case "builtin:memory-candidate":
+      return evaluation(guardrail, "deferred", "MEMORY_CANDIDATE", "Learning and memory mutations must preserve candidate-first AI knowledge.");
+    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");
+  const postApprovalScopes = new Set(["all", "execution", "mutation", "canonical", "memory", "migration", "validation", "learning", "completion", "commit", "release", "logs"]);
+  const continuousEnforcement = new Set(["builtin:secret-boundary", "builtin:owner-work", "builtin:read-only-path", "builtin:canonical-write", "builtin:canonical-truth", "builtin:memory-candidate"]);
+  const obligations = evaluations
+    .filter((item) => item.status === "deferred" || (item.status === "passed" && continuousEnforcement.has(item.enforcement) && (item.scope || []).some((scope) => postApprovalScopes.has(scope))))
+    .map((item) => ({
+      guardrail: item.guardrail,
+      code: item.code,
+      enforcement: item.enforcement,
+      scope: item.scope,
+      gate: obligationGate(item)
+    }));
+  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))],
+    obligations,
+    evaluations,
+    violations: blocked.map((item) => `${item.guardrail} ${item.code}: ${item.message}`)
+  };
+}
+
+function obligationGate(evaluationResult) {
+  const scopes = evaluationResult.scope || [];
+  for (const gate of ["mutation", "migration", "validation", "learning", "completion", "commit", "release", "memory", "canonical"]) {
+    if (scopes.includes(gate)) return gate;
+  }
+  switch (evaluationResult.enforcement) {
+    case "builtin:owner-work":
+    case "builtin:read-only-path":
+    case "builtin:secret-boundary":
+      return "mutation";
+    case "builtin:migration-integrity":
+      return "migration";
+    case "builtin:memory-candidate":
+      return "learning";
+    case "builtin:review-gate":
+      return "commit";
+    default:
+      return "completion";
+  }
+}
+
+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}`);
+    if (!record.scope.length) errors.push(`${record.id} has no scope`);
+    for (const scope of record.scope) if (!SCOPES.has(scope)) errors.push(`${record.id} has unknown scope: ${scope}`);
+  }
+  return { records, errors };
+}
+
+function normalizeGuardrailDocument(content) {
+  const source = String(content || "");
+  const records = parseGuardrails(source);
+  const headings = [...source.matchAll(/^## (GR-\d{3,})\s*[-—:]\s*([^\r\n]+)$/gm)];
+  let next = source;
+  for (let index = headings.length - 1; index >= 0; index--) {
+    const heading = headings[index];
+    const record = records.find((item) => item.id === heading[1]);
+    if (!record) continue;
+    const missing = [];
+    if (!record.explicit.status) missing.push(`Status: ${record.status}`);
+    if (!record.explicit.enforcement) missing.push(`Enforcement: ${record.enforcement}`);
+    if (!record.explicit.scope) missing.push(`Scope: ${record.scope.join(", ") || "all"}`);
+    if (!record.explicit.rule) missing.push(`Rule: ${record.rule}`);
+    if (!missing.length) continue;
+    const lineEnd = next.indexOf("\n", heading.index);
+    const insertAt = lineEnd < 0 ? next.length : lineEnd + 1;
+    next = `${next.slice(0, insertAt)}\n${missing.join("\n")}\n${next.slice(insertAt)}`;
+  }
+  return next.endsWith("\n") ? next : `${next}\n`;
+}
+
+module.exports = {
+  configWeakeningAttempts,
+  evaluatePolicy,
+  inferEnforcement,
+  normalizeGuardrailDocument,
+  obligationGate,
+  normalized,
+  parseGuardrails,
+  readOnlyPaths,
+  validateGuardrailDocument
+};