scrumrun 1.5.2 → 2.1.0

package/lib/runtime/orchestrator.js

@@ -0,0 +1,303 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const {
+  ARTIFACT_TYPES,
+  ArtifactRepository,
+  METHOD_VERSION,
+  atomicWrite,
+  parseArtifact,
+  serializeArtifact,
+  sha256,
+  transitionArtifact,
+  validateArtifact,
+  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"]);
+
+function date() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function nextId(repository, kind) {
+  const type = ARTIFACT_TYPES[kind];
+  const max = repository.list(kind).reduce((highest, artifact) => {
+    const match = artifact.record && artifact.record.id.match(/-(\d+)$/);
+    return match ? Math.max(highest, Number(match[1])) : highest;
+  }, 0);
+  return `${type.prefix}-${String(max + 1).padStart(3, "0")}`;
+}
+
+function titleFor(request) {
+  const firstLine = request.split(/\r?\n/)[0].trim();
+  return firstLine.length > 100 ? `${firstLine.slice(0, 97)}...` : firstLine;
+}
+
+function stateFingerprint(repository) {
+  return canonicalFingerprint(repository.scrumDir, artifactSnapshot(repository.scrumDir).hashes);
+}
+
+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"]);
+  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);
+  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));
+}
+
+function approvalExisting(repository, approvalId) {
+  const task = repository.list("task").find((artifact) => artifact.record && artifact.record.approval_id === approvalId);
+  if (!task) return null;
+  const run = repository.list("run").find((artifact) => artifact.record && artifact.record.approval_id === approvalId);
+  return { task: task.record, run: run ? run.record : 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);
+  if (existing) return { status: "already-approved", ...existing };
+  const currentContext = buildContextPackage(projectRoot, payload.request);
+  if (currentContext.fingerprint !== payload.fingerprint) {
+    throw new Error("Project context changed after planning; run intake again before approval.");
+  }
+
+  const created = date();
+  const taskId = nextId(repository, "task");
+  const runId = nextId(repository, "run");
+  const task = {
+    id: taskId,
+    kind: "task",
+    type: payload.classification.taskType,
+    status: "running",
+    created,
+    updated: created,
+    method: METHOD_VERSION,
+    feature: null,
+    sprint: null,
+    approval_id: approvalId,
+    context_fingerprint: payload.fingerprint,
+    risk: payload.risk.level
+  };
+  const run = {
+    id: runId,
+    kind: "run",
+    status: "executing",
+    created,
+    updated: created,
+    method: METHOD_VERSION,
+    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 = createRunBody(run, { approvalId }).body;
+  try {
+    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 (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);
+  return { status: "approved", task, run };
+}
+
+function approveRequest(projectRoot, token, options = {}) {
+  return withArtifactLock(path.join(projectRoot, ".scrumrun"), "approval", () => approveRequestUnlocked(projectRoot, token, options));
+}
+
+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, 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 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 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, 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",
+    completed: "completed",
+    failed: "failed",
+    blocked: "blocked",
+    executing: "running"
+  };
+  const nextTaskStatus = taskStatuses[nextStatus];
+  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 = 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") {
+    try {
+      learning = extractLearningCandidates(projectRoot, runId);
+    } catch (error) {
+      learning = { created: [], warnings: [`Learning extraction did not block the Run: ${error.message}`] };
+    }
+    refreshState(scrumDir);
+  }
+  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, 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 run = {
+    id: nextId(repository, "run"),
+    kind: "run",
+    status: "executing",
+    created: date(),
+    updated: date(),
+    method: METHOD_VERSION,
+    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 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 = transitionedArtifactContent(taskPrevious, "task", "running", date());
+  try {
+    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 (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, recovered };
+}
+
+function retryTask(projectRoot, taskId, options = {}) {
+  return withArtifactLock(path.join(projectRoot, ".scrumrun"), `task-${String(taskId).toLowerCase()}`, () => retryTaskUnlocked(projectRoot, taskId, options));
+}
+
+module.exports = { approveRequest, nextId, refreshState, renderState, retryTask, stateFingerprint, stateIsStale, transitionRun };

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

@@ -0,0 +1,132 @@
+"use strict";
+
+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 = 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 = 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|consertar)\b/.test(text)) {
+    return { type: "fix", taskType: "fix", reason: "request describes corrective work" };
+  }
+  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) && /\b(tasks?|tarefas?|entregas?)\b/.test(text)) {
+    return { type: "sprint", taskType: "task", reason: "request explicitly asks for a timebox or delivery batch" };
+  }
+  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) {
+  return evaluatePolicy(context);
+}
+
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function encodeApproval(plan) {
+  const payload = {
+    schema: 1,
+    method: "2.0.0",
+    request: plan.request,
+    fingerprint: plan.context.fingerprint,
+    classification: plan.classification,
+    risk: plan.risk,
+    policy: plan.policy,
+    issuedAt: plan.issuedAt
+  };
+  const encoded = Buffer.from(stableJson(payload)).toString("base64url");
+  const checksum = sha256(`scrumrun-v2-approval\0${encoded}`);
+  return `${encoded}.${checksum}`;
+}
+
+function decodeApproval(token) {
+  const [encoded, checksum, extra] = String(token || "").split(".");
+  if (!encoded || !checksum || extra || sha256(`scrumrun-v2-approval\0${encoded}`) !== checksum) {
+    throw new Error("Approval token is malformed or was modified.");
+  }
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+  } catch {
+    throw new Error("Approval token payload is invalid.");
+  }
+  if (payload.schema !== 1 || payload.method !== "2.0.0") throw new Error("Approval token version is unsupported.");
+  return payload;
+}
+
+function planRequest(projectRoot, request) {
+  const normalized = String(request || "").trim();
+  if (!normalized) throw new Error("A non-empty request is required for intake.");
+  if (normalized.length > 10000) throw new Error("Request exceeds the 10,000 character intake limit.");
+  const context = buildContextPackage(projectRoot, normalized);
+  const policy = applyPolicy(context);
+  const risk = assessRisk(normalized);
+  const classification = classifyRequest(normalized);
+  const plan = {
+    state: policy.status === "passed" ? "awaiting_approval" : "blocked",
+    pipeline: ["received", "contextualizing", "policy", "risk", "classification", "planning", policy.status === "passed" ? "awaiting_approval" : "blocked"],
+    request: normalized,
+    context,
+    policy,
+    risk,
+    classification,
+    proposal: {
+      create: ["Task", "Run"],
+      sprint: classification.type === "sprint" ? "propose only after confirming real batch/timebox membership" : null,
+      validation: risk.level === "high" ? "targeted tests plus configured reviewers" : "targeted tests"
+    },
+    issuedAt: new Date().toISOString()
+  };
+  plan.approvalToken = policy.status === "passed" ? encodeApproval(plan) : null;
+  return plan;
+}
+
+module.exports = {
+  applyPolicy,
+  assessRisk,
+  classifyRequest,
+  containsSecret,
+  decodeApproval,
+  encodeApproval,
+  planRequest,
+  stableJson
+};