@agilno-tech/rivet 0.1.0-alpha.0 → 0.1.0-alpha.2

package/src/quality/content-review.js

@@ -0,0 +1,225 @@
+const IDENTITY = ['phase', 'runId', 'requestDigest', 'planDigest', 'baseSha', 'headSha', 'diffDigest'];
+const DIGEST = /^(?:sha256:)?[a-f0-9]{64}$/;
+const SHA = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+const ID = /^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,127}$/;
+
+export class ContentReviewError extends Error {
+  constructor(reason) {
+    super(`Content review is invalid: ${reason}.`);
+    this.name = 'ContentReviewError';
+    this.code = 'ERR_CONTENT_REVIEW';
+    this.safeMessage = this.message;
+    this.details = Object.freeze({ reason });
+  }
+}
+const fail = reason => { throw new ContentReviewError(reason); };
+function object(value, keys, required = keys) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) fail('invalid-object');
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(descriptors).some(key => typeof key !== 'string' || !keys.includes(key)
+      || !descriptors[key].enumerable || !Object.hasOwn(descriptors[key], 'value'))
+      || required.some(key => !Object.hasOwn(descriptors, key))) fail('invalid-fields');
+  return Object.fromEntries(Object.entries(descriptors).map(([key, d]) => [key, d.value]));
+}
+function text(value, maximum = 4096) {
+  if (typeof value !== 'string' || !value.trim() || value.length > maximum || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(value)) fail('invalid-text');
+  return value;
+}
+function id(value) { if (typeof value !== 'string' || !ID.test(value)) fail('invalid-id'); return value; }
+function boolean(value) { if (typeof value !== 'boolean') fail('invalid-boolean'); return value; }
+function integer(value, minimum, maximum) {
+  if (!Number.isSafeInteger(value) || value < minimum || value > maximum) fail('invalid-integer');
+  return value;
+}
+function array(value, limit, convert) {
+  if (!Array.isArray(value) || value.length > limit || Reflect.ownKeys(value).length !== value.length + 1) fail('invalid-array');
+  return Array.from({ length: value.length }, (_, index) => {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (!descriptor || !Object.hasOwn(descriptor, 'value')) fail('invalid-array');
+    return convert(descriptor.value);
+  });
+}
+function unique(values) { if (new Set(values).size !== values.length) fail('duplicate-values'); return values; }
+function path(value, glob = false) {
+  text(value, 512);
+  if (/[\\:\x00-\x1f\x7f]/.test(value) || value.startsWith('/') || value.endsWith('/')
+      || value.split('/').some(part => !part || part === '.' || part === '..')
+      || (glob && value.split('/').some(part => part.includes('**') && part !== '**'))) fail('invalid-path');
+  return value;
+}
+function freeze(value) {
+  if (value && typeof value === 'object') { for (const child of Object.values(value)) freeze(child); Object.freeze(value); }
+  return value;
+}
+function identity(value) {
+  const result = {};
+  if (!['plan', 'final'].includes(value.phase)) fail('invalid-phase');
+  result.phase = value.phase; result.runId = id(value.runId);
+  for (const key of ['requestDigest', 'planDigest', 'diffDigest']) {
+    if (typeof value[key] !== 'string' || !DIGEST.test(value[key])) fail('invalid-digest'); result[key] = value[key];
+  }
+  for (const key of ['baseSha', 'headSha']) {
+    if (typeof value[key] !== 'string' || !SHA.test(value[key])) fail('invalid-sha'); result[key] = value[key];
+  }
+  return result;
+}
+function captureSubject(input) {
+  const required = [...IDENTITY, 'acceptanceCriteria', 'planNodeIds', 'changedPaths', 'workerActorIds'];
+  const value = object(input, [...required, 'criterionPlanNodeIds'], required);
+  const criteria = array(value.acceptanceCriteria, 256, value => text(value));
+  if (!criteria.length) fail('missing-criteria');
+  const planNodeIds = unique(array(value.planNodeIds, 512, id));
+  let criterionPlanNodeIds;
+  if (value.criterionPlanNodeIds !== undefined) {
+    criterionPlanNodeIds = array(value.criterionPlanNodeIds, 256, entries => {
+      const nodes = unique(array(entries, 512, id));
+      if (!nodes.length || nodes.some(node => !planNodeIds.includes(node))) fail('invalid-criterion-plan-map');
+      return nodes;
+    });
+    if (criterionPlanNodeIds.length !== criteria.length) fail('invalid-criterion-plan-map');
+  }
+  return { ...identity(value), acceptanceCriteria: criteria, planNodeIds,
+    ...(criterionPlanNodeIds === undefined ? {} : { criterionPlanNodeIds }),
+    changedPaths: unique(array(value.changedPaths, 2048, value => path(value))),
+    workerActorIds: unique(array(value.workerActorIds, 512, id)) };
+}
+export function normalizeReviewPolicy(input) {
+  const value = input === undefined ? {} : object(input, ['required', 'maxRounds', 'reviewers', 'strictCoverage'], []);
+  const reviewers = array(value.reviewers ?? [], 64, item => {
+    const reviewer = object(item, ['id', 'paths', 'required']);
+    const paths = unique(array(reviewer.paths, 128, value => path(value, true)));
+    if (!paths.length) fail('empty-reviewer-paths');
+    return { id: id(reviewer.id), paths, required: boolean(reviewer.required) };
+  });
+  unique(reviewers.map(reviewer => reviewer.id));
+  return freeze({ required: boolean(value.required ?? false), maxRounds: integer(value.maxRounds ?? 3, 1, 10),
+    reviewers, strictCoverage: boolean(value.strictCoverage ?? false) });
+}
+// Segment matching avoids compiling project-controlled globs into backtracking regular expressions.
+function matchSegment(pattern, value) {
+  let previous = new Array(value.length + 1).fill(false); previous[0] = true;
+  for (const token of pattern) {
+    const next = new Array(value.length + 1).fill(false);
+    if (token === '*') next[0] = previous[0];
+    for (let index = 1; index <= value.length; index += 1) {
+      next[index] = token === '*' ? previous[index] || next[index - 1]
+        : previous[index - 1] && (token === '?' || token === value[index - 1]);
+    }
+    previous = next;
+  }
+  return previous[value.length];
+}
+function matches(pattern, value) {
+  const segments = value.split('/');
+  let previous = new Array(segments.length + 1).fill(false); previous[0] = true;
+  for (const token of pattern.split('/')) {
+    const next = new Array(segments.length + 1).fill(false);
+    if (token === '**') next[0] = previous[0];
+    for (let index = 1; index <= segments.length; index += 1) {
+      next[index] = token === '**' ? previous[index] || next[index - 1]
+        : previous[index - 1] && matchSegment(token, segments[index - 1]);
+    }
+    previous = next;
+  }
+  return previous[segments.length];
+}
+function captureReport(subject, input, nowMs, requiredPaths) {
+  const value = object(input, [...IDENTITY, 'reviewerId', 'actorId', 'round', 'status', 'blocking', 'coverage',
+    'findings', 'filesReviewed', 'commandsExecuted', 'checkedAt']);
+  const boundIdentity = identity(value);
+  if (IDENTITY.some(key => boundIdentity[key] !== subject[key])) fail('stale-review');
+  const actorId = id(value.actorId);
+  if (subject.workerActorIds.includes(actorId)) fail('self-review');
+  if (!['PASS', 'FAIL'].includes(value.status) || boolean(value.blocking) !== (value.status === 'FAIL')) fail('inconsistent-verdict');
+  const paths = entries => unique(array(entries, 2048, value => {
+    const result = path(value); if (!subject.changedPaths.includes(result)) fail('unknown-reviewed-path'); return result;
+  }));
+  const criterionIndex = index => integer(index, 1, subject.acceptanceCriteria.length);
+  const coverage = array(value.coverage, 256, entry => {
+    const item = object(entry, ['criterionIndex', 'planNodeIds', 'paths', 'evidence']);
+    const nodes = unique(array(item.planNodeIds, 512, value => {
+      const node = id(value); if (!subject.planNodeIds.includes(node)) fail('unknown-plan-node'); return node;
+    }));
+    const evidence = array(item.evidence, 64, entry => {
+      const item = object(entry, ['kind', 'reference', 'summary']);
+      if (!['test', 'manual'].includes(item.kind)) fail('invalid-evidence-kind');
+      return { kind: item.kind, reference: text(item.reference, 1024), summary: text(item.summary) };
+    });
+    if (!nodes.length || !evidence.length) fail('missing-coverage-evidence');
+    const mappedNodes = subject.criterionPlanNodeIds?.[criterionIndex(item.criterionIndex) - 1];
+    if (mappedNodes && nodes.some(node => !mappedNodes.includes(node))) fail('criterion-plan-node-mismatch');
+    return { criterionIndex: criterionIndex(item.criterionIndex), planNodeIds: nodes, paths: paths(item.paths), evidence };
+  });
+  unique(coverage.map(item => item.criterionIndex));
+  const findings = array(value.findings, 256, entry => {
+    const item = object(entry, ['kind', 'summary', 'blocking', 'criterionIndexes', 'paths'], ['kind', 'summary', 'blocking']);
+    if (!['missing', 'unrequested', 'general'].includes(item.kind)) fail('invalid-finding-kind');
+    return { kind: item.kind, summary: text(item.summary), blocking: boolean(item.blocking),
+      ...(item.criterionIndexes === undefined ? {} : { criterionIndexes: unique(array(item.criterionIndexes, 256, criterionIndex)) }),
+      ...(item.paths === undefined ? {} : { paths: paths(item.paths) }) };
+  });
+  const filesReviewed = paths(value.filesReviewed);
+  if (coverage.some(item => item.paths.some(path => !filesReviewed.includes(path)))) fail('coverage-file-not-reviewed');
+  if (value.status === 'PASS' && (coverage.length !== subject.acceptanceCriteria.length
+      || requiredPaths.some(path => !filesReviewed.includes(path)) || findings.some(item => item.blocking))) fail('incomplete-pass');
+  const checkedAt = text(value.checkedAt, 32), checkedTime = Date.parse(checkedAt);
+  if (!Number.isSafeInteger(nowMs) || nowMs < 0 || !Number.isFinite(checkedTime)
+      || new Date(checkedTime).toISOString() !== checkedAt || checkedTime > nowMs) fail('invalid-review-time');
+  const result = { ...boundIdentity, reviewerId: id(value.reviewerId), actorId, round: integer(value.round, 1, 10),
+    status: value.status, blocking: value.blocking, coverage, findings, filesReviewed,
+    commandsExecuted: array(value.commandsExecuted, 128, value => text(value)), checkedAt };
+  if (Buffer.byteLength(JSON.stringify(result)) > 512 * 1024) fail('review-too-large');
+  return result;
+}
+// These contracts authenticate supplied identity and structure, not semantic truth or command execution.
+export function validateReviewReport(subjectInput, report, { nowMs = Date.now() } = {}) {
+  const subject = captureSubject(subjectInput);
+  return freeze(captureReport(subject, report, nowMs, subject.changedPaths));
+}
+export function evaluateReviewReports(policyInput, subjectInput, reportInputs, { nowMs = Date.now() } = {}) {
+  const policy = normalizeReviewPolicy(policyInput), subject = captureSubject(subjectInput);
+  const selected = new Map(), uncovered = [];
+  for (const changedPath of subject.changedPaths) {
+    const matchesPath = policy.reviewers.filter(reviewer => reviewer.paths.some(pattern => matches(pattern, changedPath)));
+    if (!matchesPath.length) {
+      if (policy.strictCoverage) uncovered.push(changedPath);
+      else {
+        if (!selected.has('general')) selected.set('general', { required: true, paths: [] });
+        selected.get('general').required = true;
+        selected.get('general').paths.push(changedPath);
+      }
+    }
+    for (const reviewer of matchesPath) {
+      if (!selected.has(reviewer.id)) selected.set(reviewer.id, { required: reviewer.required, paths: [] });
+      selected.get(reviewer.id).paths.push(changedPath);
+    }
+  }
+  if (!subject.changedPaths.length) selected.set('general', { required: true, paths: [] });
+  const requiredReviewerIds = policy.required ? [...selected].filter(([, value]) => value.required).map(([key]) => key).sort() : [];
+  const reports = array(reportInputs, 650, value => {
+    const reviewerId = Object.getOwnPropertyDescriptor(value ?? {}, 'reviewerId')?.value;
+    if (!selected.has(reviewerId)) fail('unknown-reviewer');
+    const report = captureReport(subject, value, nowMs, selected.get(reviewerId).paths);
+    if (report.round > policy.maxRounds) fail('round-limit');
+    return report;
+  });
+  unique(reports.map(report => `${report.reviewerId}:${report.round}`));
+  const rounds = Math.max(0, ...reports.map(report => report.round));
+  const latest = new Map();
+  for (const report of reports) if (!latest.has(report.reviewerId) || latest.get(report.reviewerId).round < report.round) latest.set(report.reviewerId, report);
+  const blockers = policy.required ? uncovered.map(path => ({ code: 'uncovered-path', path })) : [];
+  for (const reviewerId of requiredReviewerIds) {
+    const report = latest.get(reviewerId);
+    if (!report) blockers.push({ code: 'missing-review', reviewerId });
+    else if (report.blocking) blockers.push({ code: 'blocking-review', reviewerId, round: report.round });
+  }
+  if (policy.required) {
+    const reviewed = new Set([...latest.values()].filter(report => report.status === 'PASS').flatMap(report => report.filesReviewed));
+    for (const path of subject.changedPaths) if (!reviewed.has(path)) blockers.push({ code: 'unreviewed-path', path });
+  }
+  // An explicitly submitted blocking finding is never erased by marking its reviewer optional.
+  for (const [reviewerId, report] of latest) if (report.blocking && !requiredReviewerIds.includes(reviewerId)) blockers.push({ code: 'blocking-review', reviewerId, round: report.round });
+  return freeze({ valid: blockers.length === 0, requiredReviewerIds,
+    reviewerPaths: Object.fromEntries([...selected].map(([key, value]) => [key, unique(value.paths).sort()])), rounds,
+    humanEscalation: blockers.length > 0 && rounds >= policy.maxRounds, blockers, reports });
+}

package/src/quality/content-scan.js

@@ -0,0 +1,120 @@
+import { types } from 'node:util';
+import { containsSecretMaterial } from '../clients/contract.js';
+const RULES = ['private-key', 'github-token', 'npm-token', 'aws-access-key', 'unicode-bidi', 'unicode-mixed-identifier', 'type-suppression'];
+const DEFAULTS = { secrets: true, unicode: 'warn', maxFiles: 1000, maxBytes: 2097152, allowlist: [], shortcutRules: [] };
+function fail(code) { const error = new Error('Content scan input, policy or resource limit is invalid.'); error.code = code; throw error; }
+// Capture data properties only. Do not evaluate accessors or custom objects.
+function capture(input, code) {
+  const active = new WeakSet(); let nodes = 0, bytes = 0;
+  function clone(value, depth = 0) {
+    if (++nodes > 16000 || depth > 8) fail(code);
+    if (value === undefined || value === null || typeof value === 'boolean') return value;
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+    if (typeof value === 'string') {
+      if (value.length > 3 * 1024 * 1024) fail(code);
+      bytes += Buffer.byteLength(value, 'utf8');
+      if (bytes > 3 * 1024 * 1024) fail(code);
+      return value;
+    }
+    if (!value || typeof value !== 'object' || types.isProxy(value) || active.has(value)) fail(code);
+    const array = Array.isArray(value), prototype = Object.getPrototypeOf(value);
+    if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) fail(code);
+    active.add(value);
+    try {
+      const keys = Reflect.ownKeys(value);
+      const length = array ? Object.getOwnPropertyDescriptor(value, 'length')?.value : 0;
+      if (keys.length > 1001 || (array && (!Number.isInteger(length) || length > 1000 || keys.length !== length + 1))) fail(code);
+      const output = array ? [] : Object.create(null);
+      for (const key of keys) {
+        if (array && key === 'length') continue;
+        if (typeof key !== 'string' || (array && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= length))) fail(code);
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor?.enumerable || !Object.hasOwn(descriptor, 'value')) fail(code);
+        output[key] = clone(descriptor.value, depth + 1);
+      }
+      return Object.freeze(output);
+    } finally { active.delete(value); }
+  }
+  try { return clone(input); } catch { fail(code); }
+}
+function object(value, keys) { return value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).every(key => keys.includes(key)); }
+function pathValid(value) { return typeof value === 'string' && value.length > 0 && value.length <= 1024 && !/[\\*?\x00-\x1f\x7f]/.test(value) && !value.startsWith('/') && !value.split('/').some(part => !part || part === '.' || part === '..') && !/^[A-Za-z]:/.test(value); }
+function reasonValid(value) { return typeof value === 'string' && value.trim().length > 0 && value.length <= 500 && !/[\p{Cc}\p{Cf}]/u.test(value) && !containsSecretMaterial(value) && !/npm_[A-Za-z0-9]{36}|-----BEGIN .*PRIVATE KEY-----/.test(value); }
+export function validateContentScanPolicy(input = {}) {
+  input = capture(input, 'ERR_CONTENT_SCAN_POLICY');
+  const bad = () => fail('ERR_CONTENT_SCAN_POLICY');
+  if (!object(input, Object.keys(DEFAULTS))) bad();
+  const policy = { ...DEFAULTS, ...input };
+  if (typeof policy.secrets !== 'boolean' || !['warn', 'required', 'off'].includes(policy.unicode)) bad();
+  if (!Number.isInteger(policy.maxFiles) || policy.maxFiles < 1 || policy.maxFiles > 1000 || !Number.isInteger(policy.maxBytes) || policy.maxBytes < 1 || policy.maxBytes > 2097152) bad();
+  if (!Array.isArray(policy.allowlist) || policy.allowlist.length > 100 || !Array.isArray(policy.shortcutRules) || policy.shortcutRules.length > 100) bad();
+  const seen = new Set();
+  for (const entry of policy.allowlist) {
+    if (!object(entry, ['ruleId', 'path', 'reason']) || !RULES.includes(entry.ruleId) || !pathValid(entry.path) || !reasonValid(entry.reason)) bad();
+    const key = `${entry.ruleId}:${entry.path}`; if (seen.has(key)) bad(); seen.add(key);
+  }
+  for (const entry of policy.shortcutRules) {
+    if (!object(entry, ['ruleId', 'paths', 'reason', 'required']) || entry.ruleId !== 'type-suppression' || !reasonValid(entry.reason) || (entry.required !== undefined && typeof entry.required !== 'boolean') || !Array.isArray(entry.paths) || !entry.paths.length || entry.paths.length > 100 || !entry.paths.every(pathValid) || new Set(entry.paths).size !== entry.paths.length) bad();
+  }
+  return capture(policy, 'ERR_CONTENT_SCAN_POLICY');
+}
+
+// Mask ordinary strings and comments before examining code identifiers. This is a
+// conservative lexical heuristic, not a parser or a substitute for a compiler.
+function codeOnly(text) {
+  return text.replace(/"""[\s\S]*?(?:"""|$)|'''[\s\S]*?(?:'''|$)|\/\*[\s\S]*?(?:\*\/|$)|\/\/[^\n]*|#[^\n]*|"(?:\\[\s\S]|[^"\\])*(?:"|$)|'(?:\\[\s\S]|[^'\\])*(?:'|$)|`(?:\\[\s\S]|[^`\\])*(?:`|$)/g, match => match.replace(/[^\n]/g, ' '));
+}
+const CODE = /\.(?:[cm]?[jt]sx?|py|go|rs|java|kt|kts|c|h|cpp|hpp|cc|cs|swift|rb|php|scala)$/i;
+const SECRET_RULES = [
+  ['private-key', /-----BEGIN (?:RSA |EC |DSA |OPENSSH |ENCRYPTED )?PRIVATE KEY-----/g, 'Private key material detected.'],
+  ['github-token', /\b(?:gh[pousr]_[A-Za-z0-9]{36,255}|github_pat_[A-Za-z0-9_]{40,255})\b/g, 'GitHub token pattern detected.'],
+  ['npm-token', /\bnpm_[A-Za-z0-9]{36}\b/g, 'npm token pattern detected.'],
+  ['aws-access-key', /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g, 'AWS access key identifier detected.'],
+];
+export function scanChangedContent(input = {}) {
+  const captured = capture(input, 'ERR_CONTENT_SCAN_INPUT');
+  if (!object(captured, ['files', 'policy'])) fail('ERR_CONTENT_SCAN_INPUT');
+  const { files } = captured;
+  const policy = validateContentScanPolicy(captured.policy);
+  if (!Array.isArray(files)) fail('ERR_CONTENT_SCAN_INPUT');
+  if (files.length > policy.maxFiles) fail('ERR_CONTENT_SCAN_LIMIT');
+  let bytes = 0;
+  const paths = new Set();
+  for (const file of files) {
+    if (!object(file, ['path', 'content']) || !pathValid(file.path) || typeof file.content !== 'string' || paths.has(file.path)) fail('ERR_CONTENT_SCAN_INPUT');
+    paths.add(file.path); bytes += Buffer.byteLength(file.content, 'utf8');
+    if (bytes > policy.maxBytes) fail('ERR_CONTENT_SCAN_LIMIT');
+  }
+  const findings = [];
+  for (const file of files) {
+    const lineStarts = [0];
+    for (let index = 0; index < file.content.length; index += 1) if (file.content[index] === '\n') lineStarts.push(index + 1);
+    const lineAt = index => {
+      let low = 0, high = lineStarts.length;
+      while (low < high) { const middle = (low + high) >>> 1; if (lineStarts[middle] <= index) low = middle + 1; else high = middle; }
+      return low;
+    };
+    const add = (ruleId, index, severity, message) => {
+      if (policy.allowlist.some(entry => entry.path === file.path && entry.ruleId === ruleId)) return;
+      // Paths are the only source-derived string; suppress terminal control bytes.
+      const path = file.path.replace(/[\u202a-\u202e\u2066-\u2069]/g, char => `\\u${char.charCodeAt(0).toString(16)}`);
+      findings.push({ path, line: lineAt(index), ruleId, severity, message });
+      if (findings.length > 1000) fail('ERR_CONTENT_SCAN_LIMIT');
+    };
+    if (policy.secrets) for (const [rule, pattern, message] of SECRET_RULES) {
+      for (const match of file.content.matchAll(new RegExp(pattern.source, pattern.flags))) add(rule, match.index, 'error', message);
+    }
+    if (policy.unicode !== 'off') {
+      const severity = policy.unicode === 'required' ? 'error' : 'warning';
+      for (const match of file.content.matchAll(/[\u202a-\u202e\u2066-\u2069]/g)) add('unicode-bidi', match.index, severity, 'Bidirectional text control requires review.');
+      if (CODE.test(file.path)) for (const match of codeOnly(file.content).matchAll(/[\p{L}_$][\p{L}\p{M}\p{N}_$]*/gu)) {
+        const scripts = [/\p{Script=Latin}/u, /\p{Script=Cyrillic}/u, /\p{Script=Greek}/u].filter(pattern => pattern.test(match[0]));
+        if (scripts.length > 1) add('unicode-mixed-identifier', match.index, severity, 'Identifier mixes Latin, Cyrillic or Greek scripts; review for confusables.');
+      }
+    }
+    for (const rule of policy.shortcutRules) if (rule.paths.includes(file.path)) {
+      for (const match of file.content.matchAll(/@ts-(?:ignore|nocheck)\b/g)) add('type-suppression', match.index, rule.required ? 'error' : 'warning', 'Configured TypeScript suppression rule requires review.');
+    }
+  }
+  return capture({ status: findings.some(finding => finding.severity === 'error') ? 'failed' : 'passed', findings, scannedFiles: files.length, bytes }, 'ERR_CONTENT_SCAN_INPUT');
+}

package/src/state/paths.js

@@ -206,6 +206,16 @@ export async function resolveExistingStatePaths(projectRoot, instance, options =
   }));
 }
 
+export function governancePaths(featurePaths) {
+  assertResolvedStatePaths(featurePaths);
+  if (featurePaths.runDir !== featurePaths.instanceDir) throw new TypeError('Invalid feature run paths');
+  return registerPaths(Object.freeze({
+    ...featurePaths,
+    snapshotPath: join(featurePaths.runDir, 'governance.json'),
+    lockPath: join(featurePaths.runDir, 'governance.lock'),
+  }));
+}
+
 export function verificationReportPaths(featurePaths) {
   assertResolvedStatePaths(featurePaths);
   if (featurePaths.runDir !== featurePaths.instanceDir) throw new TypeError('Invalid feature run paths');

package/templates/github-actions/rivet-deploy.yml

@@ -1,4 +1,5 @@
 # Opt-in example: review and copy to your project's .github/workflows/rivet-deploy.yml.
+# JavaScript actions require Actions Runner 2.327.1 or newer (GitHub-hosted runners provide this).
 # Configure the staging environment's protection rules and implement trusted project
 # scripts `deploy` and `verify:deployment`. Verification must fail on unhealthy delivery.
 # Rivet creates deployments using a PAT or GitHub App token. Deployments created by
@@ -28,7 +29,7 @@ jobs:
     steps:
       - name: Validate deployment contract before executing project code
         id: validate
-        uses: actions/github-script@v7
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
           script: |
             const deployment = context.payload.deployment;
@@ -47,7 +48,7 @@ jobs:
             }
       - name: Record deployment started
         id: status-start
-        uses: actions/github-script@v7
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
           script: |
             await github.rest.repos.createDeploymentStatus({
@@ -57,13 +58,14 @@ jobs:
               log_url: `https://github.com/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`,
             });
       - name: Checkout the requested merge commit
-        uses: actions/checkout@v4
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           ref: ${{ github.event.deployment.sha }}
           persist-credentials: false
       - name: Set up Node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
         with:
+          package-manager-cache: false
           node-version: '22'
       - name: Install project dependencies
         run: npm ci
@@ -74,7 +76,7 @@ jobs:
       - name: Record verified deployment success
         id: status-success
         if: success()
-        uses: actions/github-script@v7
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
           script: |
             await github.rest.repos.createDeploymentStatus({
@@ -87,7 +89,7 @@ jobs:
       - name: Record deployment or verification failure
         id: status-failure
         if: failure() && steps.validate.outcome == 'success'
-        uses: actions/github-script@v7
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
           script: |
             await github.rest.repos.createDeploymentStatus({

package/templates/harness/SKILL.md

@@ -13,7 +13,7 @@ Use `rivet --help --advanced` to see the complete installed command reference. F
 
 ## Connect the application project
 
-Node.js 22 or 24 runs Rivet; the application can use Python, Django, Go, Rust, Node.js, or another language. Do not add a dummy `package.json` or npm scripts to make a non-Node project pass setup. Preview with `rivet setup --project=<path>` and review the proposed checks before `--write`. Setup proposes conventional checks for root Django `manage.py`, Python metadata identifying pytest, Go modules, and Cargo projects.
+Node.js 22 or 24 runs Rivet; the application can use Python, Django, Go, Rust, Node.js, or another language. Use the application’s native configuration and verification commands. Preview with `rivet setup --project=<path>` and review the proposed checks before `--write`. Setup proposes conventional checks for root Django `manage.py`, Python metadata identifying pytest, Go modules, and Cargo projects.
 
 If no checks are detected, determine the project's real verification command from its documentation and configuration. Interactive `rivet setup --write` can ask the user for that command. In a harness or noninteractive session, supply exact arguments, for example `--checks-json='{"test":["python3","-m","pytest"]}'`, with `--project=<path>` and, after review, `--write`. Do not invent a successful placeholder check. Schema 3 uses command groups with `steps` containing `cwd` and `argv`; quality policy must require at least one `test` or `check`, while `build` is optional. Arguments run directly without shell expansion or chaining. Existing valid project policy is preserved by setup; edit its project and quality files together when changing checks.
 
@@ -88,3 +88,11 @@ For Jira/Linear with harness-connected tools, inspect `rivet integrations list/c
 
 
 For troubleshooting, human-readable failures print a private diagnostic report path when saving succeeds. `rivet support --save` collects broader sanitized diagnostics. JSON automation keeps its existing response contract and does not save automatic failure reports; `support --save --json` is explicit. Ask the user to review a report before attaching it to an issue. Never upload reports, raw terminal logs, private state or source code without authorization.
+
+## Decisions, review and evidence
+
+Record material decisions and alternatives through `rivet task decide --input-json=<serialized-decision>` and inspect them with `rivet task decisions`. A pending human decision requires the user's interactive `rivet task approve-decision --decision=<id>`; do not simulate approval. Decisions never expand the sealed task authority. Inline JSON is bounded to 64 KiB. Alternatively use `--input` with an existing project-contained private/ignored JSON file up to 128 KiB; never combine the options or create ordinary untracked input files that dirty the approved baseline.
+
+Export current plan or final review context using `rivet task review --phase=plan|final`. Arrange the required independent review through the approved harness or team process, then submit the structured report using `rivet task review --input-json=<serialized-report>`. Rivet validates recorded review identity and configured coverage; it does not automatically launch or authenticate a separate reviewer. Re-review when the task, plan or accepted changes differ. Do not invent findings, reviewer identities or a passing judgment to bypass a required review or round limit.
+
+Preserve the provenance of every numerical claim: command or measurement method, source commit, environment, time, units and artifact. Distinguish observations from estimates and provider telemetry from model-reported usage. Demonstrate detection with safe known-bad fixtures and positive controls when practical. Include affected public documentation in the same pull request. Treat scan findings and unavailable evidence as work to resolve; do not broadly suppress rules or report unavailable context-window telemetry as measured fact.