@enterpriseai/cli 3.19.0 → 3.19.2

package/resources/gofer/node-scripts/gofer-local-isolation.mjs

@@ -0,0 +1,175 @@
+/** Validate the EAI local-isolation contract for Gofer's new task worktree.
+ * This is preflight evidence only. Native host invocation must still prove
+ * that the effective sandbox remained enabled for the task. */
+import { execFile, spawnSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { accessSync, constants, existsSync, mkdtempSync, realpathSync, rmSync, rmdirSync, statSync } from 'node:fs';
+import { delimiter, dirname, isAbsolute, join, relative, sep } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+const text = value => typeof value === 'string' && value.trim().length > 0;
+// Observed on the local Codex CLI 0.154.0. A changed signing identity fails
+// closed until the host contract is reviewed.
+const CODEX_MACOS_SIGNATURE_REQUIREMENT =
+  '=anchor apple generic and certificate leaf[subject.OU] = "2DC432GLL2"';
+const CODEX_PROFILE = 'gofer-isolated';
+
+/** Build one policy for both the no-model probe and the native invocation. */
+export function codexIsolatedPermissionArgs(workspaceRoot) {
+  if (!text(workspaceRoot)) return null;
+  const git = spawnSync('/usr/bin/git', ['-C', workspaceRoot, 'rev-parse',
+    '--path-format=absolute', '--show-toplevel', '--git-dir', '--git-common-dir'],
+  { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000,
+    env: Object.fromEntries(Object.entries(process.env).filter(([name]) => !name.startsWith('GIT_'))) });
+  if (git.status !== 0 || !git.stdout?.trim()) return null;
+  const [topLevel, gitDirectory, commonDirectory] = git.stdout.trim().split('\n');
+  if (!topLevel || !gitDirectory || !commonDirectory) return null;
+  let common;
+  let workspace;
+  let gitDir;
+  let top;
+  try {
+    common = realpathSync(commonDirectory);
+    workspace = realpathSync(workspaceRoot);
+    gitDir = realpathSync(gitDirectory);
+    top = realpathSync(topLevel);
+  } catch { return null; }
+  const commonRelative = relative(workspace, common);
+  if (top !== workspace || gitDir === common || commonRelative === '' ||
+      (!commonRelative.startsWith(`..${sep}`) && commonRelative !== '..' && !isAbsolute(commonRelative))) return null;
+  return Object.freeze({ common,
+    config: Object.freeze([
+      `permissions.${CODEX_PROFILE}.extends=":workspace"`,
+      `permissions.${CODEX_PROFILE}.filesystem={ ":tmpdir" = "read", ":slash_tmp" = "read", ${JSON.stringify(common)} = "read" }`,
+      `default_permissions="${CODEX_PROFILE}"`,
+    ]) });
+}
+
+function signedCodexExecutable() {
+  if (process.platform !== 'darwin') return null;
+  for (const entry of (process.env.PATH ?? '').split(delimiter)) {
+    if (!entry || !isAbsolute(entry)) continue;
+    const candidate = join(entry, 'codex');
+    try {
+      accessSync(candidate, constants.X_OK);
+      const executable = realpathSync(candidate);
+      if (!statSync(executable).isFile()) return null;
+      const signature = spawnSync('/usr/bin/codesign', ['--verify', '--strict', '--requirement',
+        CODEX_MACOS_SIGNATURE_REQUIREMENT, executable], { stdio: 'ignore', timeout: 10000 });
+      const identity = spawnSync('/usr/bin/codesign', ['-dv', '--verbose=2', executable], {
+        encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 10000,
+      });
+      if (signature.status !== 0 || signature.error || identity.status !== 0 ||
+          !/\bTeamIdentifier=2DC432GLL2\b/.test(identity.stderr)) return null;
+      return executable;
+    } catch { /* Try the next PATH entry only when this one has no executable. */ }
+  }
+  return null;
+}
+
+/** A no-model boundary probe. A worker must not write the shared Git store. */
+export function probeMacCodexSandboxBoundary({ workspaceRoot, executable, runSandbox = spawnSync } = {}) {
+  if (!workspaceRoot || !executable || !existsSync('/usr/bin/touch') ||
+      typeof runSandbox !== 'function') return null;
+  const policy = codexIsolatedPermissionArgs(workspaceRoot);
+  if (!policy) return null;
+  let sibling;
+  try { sibling = mkdtempSync(join(dirname(workspaceRoot), '.gofer-isolation-probe-')); }
+  catch { return null; }
+  const inside = join(workspaceRoot, `.gofer-isolation-probe-${randomUUID()}`);
+  const outside = join(sibling, 'outside');
+  const sharedGit = join(policy.common, `.gofer-isolation-probe-${randomUUID()}`);
+  const probe = target => runSandbox(executable,
+    ['sandbox', '-P', CODEX_PROFILE, ...policy.config.flatMap(value => ['-c', value]),
+      '-C', workspaceRoot, '--', '/usr/bin/touch', target],
+    { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 15000, maxBuffer: 16384 });
+  const denied = result => result.status !== 0 && !result.error &&
+    /Operation not permitted|Permission denied/i.test(`${result.stderr}\n${result.stdout}`);
+  try {
+    for (const target of [outside, sharedGit]) {
+      const baseline = spawnSync('/usr/bin/touch', [target], { stdio: 'ignore', timeout: 5000 });
+      if (baseline.status !== 0 || !existsSync(target)) return null;
+      rmSync(target);
+    }
+    const allowed = probe(inside);
+    if (allowed.status !== 0 || !existsSync(inside)) return null;
+    const siblingResult = probe(outside);
+    if (!denied(siblingResult) || existsSync(outside)) return null;
+    const gitResult = probe(sharedGit);
+    return denied(gitResult) && !existsSync(sharedGit) ? executable : null;
+  } catch { return null; }
+  finally {
+    rmSync(inside, { force: true });
+    rmSync(outside, { force: true });
+    rmSync(sharedGit, { force: true });
+    try { rmdirSync(sibling); } catch { /* Preserve unexpected contents. */ }
+  }
+}
+
+/** An independent check of the signed executable Gofer will launch. */
+export function probeNativeCodexSandbox(workspaceRoot) {
+  const executable = signedCodexExecutable();
+  return executable ? probeMacCodexSandboxBoundary({ workspaceRoot, executable }) : null;
+}
+
+export const LOCAL_ISOLATION_CONTRACT = 'eai.local-isolation/v2';
+
+const HOST_SURFACES = Object.freeze({
+  codex: 'codex-cli',
+});
+
+function hasQualifiedHostArguments(host, workspaceRoot, args) {
+  if (host !== 'codex' || !Array.isArray(args)) return false;
+  const policy = codexIsolatedPermissionArgs(workspaceRoot);
+  if (!policy) return false;
+  const expected = ['--ask-for-approval', 'never', 'exec', '--ignore-user-config',
+    ...policy.config.flatMap(value => ['-c', value])];
+  return args.length === expected.length && args.every((value, index) => value === expected[index]);
+}
+
+export function verifyLocalIsolationReport(report, { host, workspaceRoot } = {}) {
+  const surfaceId = HOST_SURFACES[host];
+  if (!surfaceId || !text(workspaceRoot) || !report || report.contractVersion !== LOCAL_ISOLATION_CONTRACT ||
+      report.cloudExecution !== 'prohibited' || report.gitRepository !== true || !text(report.projectDirectory) ||
+      !Array.isArray(report.assessments)) return false;
+  const matchingAssessments = report.assessments.filter(item => item?.surfaceId === surfaceId);
+  if (matchingAssessments.length !== 1) return false;
+  const assessment = matchingAssessments[0];
+  if (!assessment || assessment.status !== 'ready' || assessment.localOnly !== true ||
+      assessment.requiresGitWorktree !== true || assessment.requiresOsSandbox !== true ||
+      !hasQualifiedHostArguments(host, workspaceRoot, assessment.hostArguments) ||
+      !Array.isArray(assessment.missing) || assessment.missing.length !== 0) return false;
+  const normalizedReportRoot = report.projectDirectory.replace(/\\/g, '/').replace(/\/+$/, '');
+  const normalizedWorkspace = workspaceRoot.replace(/\\/g, '/').replace(/\/+$/, '');
+  return normalizedReportRoot === normalizedWorkspace;
+}
+
+/** Query the installed local EAI CLI for the worktree Gofer actually created. */
+export async function inspectEaiLocalIsolation({ host, workspaceRoot, command = 'eai',
+  run = execFileAsync, verifyNativeSandbox = probeNativeCodexSandbox } = {}) {
+  const surfaceId = HOST_SURFACES[host];
+  if (!surfaceId || !text(workspaceRoot) || !text(command) ||
+      typeof run !== 'function' || typeof verifyNativeSandbox !== 'function') {
+    throw new Error('LOCAL_SANDBOX_REQUIRED');
+  }
+  let stdout;
+  try {
+    ({ stdout } = await run(command,
+      ['start', workspaceRoot, '--isolation-check', '--surface', surfaceId, '--format', 'json'],
+      { encoding: 'utf8', timeout: 15000, maxBuffer: 1024 * 1024, windowsHide: true }));
+  } catch {
+    throw new Error('LOCAL_SANDBOX_REQUIRED');
+  }
+  let report;
+  try { report = JSON.parse(stdout); }
+  catch { throw new Error('LOCAL_SANDBOX_REQUIRED'); }
+  if (!verifyLocalIsolationReport(report, { host, workspaceRoot })) {
+    throw new Error('LOCAL_SANDBOX_REQUIRED');
+  }
+  let nativeExecutable;
+  try { nativeExecutable = verifyNativeSandbox(workspaceRoot); }
+  catch { throw new Error('LOCAL_SANDBOX_REQUIRED'); }
+  if (!text(nativeExecutable) || !isAbsolute(nativeExecutable)) throw new Error('LOCAL_SANDBOX_REQUIRED');
+  return Object.freeze({ ...report, nativeExecutable });
+}

package/resources/gofer/node-scripts/gofer-local-settings-cleanup.mjs

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const STALE_GOFER_STEMS = [
+  '0_business_scenario',
+  '0a_problem_validation',
+  '0_gofer_start',
+  '1_gofer_research',
+  '2_gofer_specify',
+  '3_gofer_plan',
+  '4_gofer_tasks',
+  '5_gofer_implement',
+  '6_gofer_validate',
+  '6a_gofer_engineering_review',
+  '7_gofer_save',
+  '7a_stakeholder_comms',
+  '8_gofer_branding',
+  '8_gofer_resume',
+  '9_gofer_tests',
+  '10_gofer_cloud',
+  'gofer',
+  'gofer_bootstrap_workspace',
+  'gofer_check_workspace',
+  'gofer_constitution',
+  'gofer_diagnose',
+  'gofer_eai_first_run',
+  'gofer_hydrate',
+  'gofer_personality',
+  'gofer_plan',
+  'gofer_side',
+  'gofer_spec_summary',
+  'gofer_tdd',
+  'gofer_vocabulary',
+  'gofer_zoom_out',
+];
+
+const GOFER_CONTENT_MARKER =
+  /\b(Gofer|gofer|eai-gofer|EAI delivery pipeline|\.specify\/commands|gofer-workspace-check)\b/;
+
+const __filename = fileURLToPath(import.meta.url);
+
+function toPortablePath(value) {
+  return value.split(path.sep).join('/');
+}
+
+function buildArchiveStamp(now = new Date()) {
+  return now.toISOString().replace(/[:.]/g, '-');
+}
+
+function buildVisibleSurfaceRelatives(stem) {
+  return [
+    path.join('.claude', 'commands', `${stem}.md`),
+    path.join('.claude', 'skills', stem),
+    path.join('.github', 'prompts', `${stem}.prompt.md`),
+    path.join('.github', 'skills', stem),
+    path.join('.agents', 'skills', stem),
+    path.join('.system', 'skills', stem),
+    path.join('.gemini', 'commands', 'gofer', `${stem}.md`),
+    path.join('.gemini', 'commands', 'gofer', `${stem}.toml`),
+    path.join('.grok', 'skills', stem),
+  ];
+}
+
+function buildHomeRelatives(stem) {
+  return [
+    path.join('.claude', 'commands', `${stem}.md`),
+    path.join('.claude', 'skills', stem),
+    path.join('.codex', 'skills', stem),
+    path.join('.gemini', 'commands', 'gofer', `${stem}.md`),
+    path.join('.gemini', 'commands', 'gofer', `${stem}.toml`),
+    path.join('.grok', 'skills', stem),
+  ];
+}
+
+function buildBundleRelatives(stem) {
+  return [
+    path.join('commands', `${stem}.md`),
+    path.join('skills', stem),
+    path.join('plugin-skills', stem),
+    path.join('.claude', 'commands', `${stem}.md`),
+    path.join('.claude', 'skills', stem),
+    path.join('.github', 'prompts', `${stem}.prompt.md`),
+    path.join('.github', 'skills', stem),
+    path.join('.agents', 'skills', stem),
+    path.join('.system', 'skills', stem),
+    path.join('.gemini', 'commands', 'gofer', `${stem}.md`),
+    path.join('.gemini', 'commands', 'gofer', `${stem}.toml`),
+    path.join('.grok', 'skills', stem),
+  ];
+}
+
+async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readTextIfFile(targetPath) {
+  try {
+    return await fs.readFile(targetPath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+async function directoryHasGoferMarker(targetPath, limit = 40) {
+  let checked = 0;
+
+  async function visit(current) {
+    if (checked >= limit) return false;
+    let entries;
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        if (await visit(fullPath)) return true;
+      } else if (entry.isFile()) {
+        checked += 1;
+        const content = await readTextIfFile(fullPath);
+        if (content && GOFER_CONTENT_MARKER.test(content)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  return await visit(targetPath);
+}
+
+async function isGoferManagedTarget(targetPath) {
+  const content = await readTextIfFile(targetPath);
+  if (content !== null) {
+    return GOFER_CONTENT_MARKER.test(content);
+  }
+
+  try {
+    const stat = await fs.stat(targetPath);
+    if (!stat.isDirectory()) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+
+  return await directoryHasGoferMarker(targetPath);
+}
+
+function sanitizeArchivePart(value) {
+  return toPortablePath(value)
+    .replace(/^[A-Za-z]:/, (match) => match.replace(':', ''))
+    .replace(/[^A-Za-z0-9._/-]+/g, '_')
+    .replace(/^\/+/, '')
+    .replace(/\/+/g, '/');
+}
+
+async function moveToArchive(targetPath, archivePath) {
+  await fs.mkdir(path.dirname(archivePath), { recursive: true });
+  try {
+    await fs.rename(targetPath, archivePath);
+  } catch (error) {
+    if (error?.code !== 'EXDEV') {
+      throw error;
+    }
+    await fs.cp(targetPath, archivePath, { recursive: true, force: true });
+    await fs.rm(targetPath, { recursive: true, force: true });
+  }
+}
+
+function uniqueCandidates(candidates) {
+  const seen = new Set();
+  return candidates.filter((candidate) => {
+    const key = path.resolve(candidate.root, candidate.relativePath);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+async function discoverCodexCacheBundleRoots(home) {
+  const roots = [];
+  const base = path.join(home, '.codex', 'plugins', 'cache', 'eai-gofer', 'eai-gofer');
+  let entries;
+  try {
+    entries = await fs.readdir(base, { withFileTypes: true });
+  } catch {
+    return roots;
+  }
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      roots.push(path.join(base, entry.name));
+    }
+  }
+
+  return roots;
+}
+
+async function buildCleanupCandidates({ home, workspaces = [], bundleRoots = [] }) {
+  const candidates = [];
+
+  for (const stem of STALE_GOFER_STEMS) {
+    for (const relativePath of buildHomeRelatives(stem)) {
+      candidates.push({ scope: 'home', root: home, relativePath });
+    }
+  }
+
+  const defaultBundleRoots = [
+    path.join(home, 'plugins', 'eai-gofer'),
+    path.join(home, '.claude', 'plugins', 'marketplaces', 'eai-gofer', 'plugins', 'eai-gofer'),
+    path.join(home, '.gemini', 'extensions', 'eai-gofer'),
+    ...(await discoverCodexCacheBundleRoots(home)),
+    ...bundleRoots,
+  ];
+
+  for (const bundleRoot of defaultBundleRoots) {
+    for (const stem of STALE_GOFER_STEMS) {
+      for (const relativePath of buildBundleRelatives(stem)) {
+        candidates.push({ scope: 'bundle', root: bundleRoot, relativePath });
+      }
+    }
+    candidates.push({
+      scope: 'bundle',
+      root: bundleRoot,
+      relativePath: path.join('.specify', 'commands', '0_business_scenario.md'),
+    });
+  }
+
+  for (const workspaceRoot of workspaces) {
+    for (const stem of STALE_GOFER_STEMS) {
+      for (const relativePath of buildVisibleSurfaceRelatives(stem)) {
+        candidates.push({ scope: 'workspace', root: workspaceRoot, relativePath });
+      }
+    }
+    candidates.push({
+      scope: 'workspace',
+      root: workspaceRoot,
+      relativePath: path.join('.specify', 'commands', '0_business_scenario.md'),
+    });
+  }
+
+  return uniqueCandidates(candidates);
+}
+
+export async function cleanupLocalSettings({
+  home = os.homedir(),
+  workspaces = [],
+  bundleRoots = [],
+  apply = false,
+  now = new Date(),
+} = {}) {
+  const archiveStamp = buildArchiveStamp(now);
+  const archiveRoot = path.join(home, '.eai-gofer', 'legacy-settings-backups', archiveStamp);
+  const report = {
+    status: apply ? 'applied' : 'planned',
+    archiveRoot,
+    removed: [],
+    skipped: [],
+  };
+
+  for (const candidate of await buildCleanupCandidates({ home, workspaces, bundleRoots })) {
+    const targetPath = path.join(candidate.root, candidate.relativePath);
+    if (!(await pathExists(targetPath))) {
+      continue;
+    }
+
+    if (!(await isGoferManagedTarget(targetPath))) {
+      report.skipped.push({
+        scope: candidate.scope,
+        path: targetPath,
+        reason: 'no-gofer-marker',
+      });
+      continue;
+    }
+
+    const archivePath = path.join(
+      archiveRoot,
+      candidate.scope,
+      sanitizeArchivePart(candidate.root),
+      sanitizeArchivePart(candidate.relativePath)
+    );
+
+    report.removed.push({
+      scope: candidate.scope,
+      path: targetPath,
+      archivePath,
+    });
+
+    if (apply) {
+      await moveToArchive(targetPath, archivePath);
+    }
+  }
+
+  return report;
+}
+
+function parseArgs(argv) {
+  const options = {
+    home: os.homedir(),
+    workspaces: [],
+    bundleRoots: [],
+    apply: false,
+    json: false,
+    help: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const next = () => argv[++index];
+
+    if (arg === '--home') options.home = path.resolve(next());
+    else if (arg === '--workspace') options.workspaces.push(path.resolve(next()));
+    else if (arg === '--bundle') options.bundleRoots.push(path.resolve(next()));
+    else if (arg === '--apply') options.apply = true;
+    else if (arg === '--dry-run') options.apply = false;
+    else if (arg === '--json') options.json = true;
+    else if (arg === '--help' || arg === '-h') options.help = true;
+    else throw new Error(`Unknown option: ${arg}`);
+  }
+
+  return options;
+}
+
+function helpText() {
+  return `Gofer Local Settings Cleanup
+
+Archives stale Gofer command and skill entries from known Claude, Codex,
+Copilot, Gemini, Grok, VS Code, desktop, and CLI surface paths.
+
+Usage:
+  node .specify/scripts/node/gofer-local-settings-cleanup.mjs [options]
+
+Options:
+  --workspace <path>   Also clean repo-local visible command surfaces.
+  --bundle <path>      Also clean a downloaded eai-gofer plugin bundle.
+  --home <path>        Home directory to inspect. Defaults to current user.
+  --apply              Move stale entries to an archive. Default is dry-run.
+  --dry-run            Report planned cleanup only.
+  --json               Print machine-readable output.
+  --help               Show this help.
+`;
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    console.log(helpText());
+    return;
+  }
+
+  const report = await cleanupLocalSettings(options);
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+    return;
+  }
+
+  const verb = options.apply ? 'archived' : 'would archive';
+  console.log(`Gofer cleanup ${report.status}. ${report.removed.length} stale entries ${verb}.`);
+  if (report.removed.length > 0) {
+    console.log(`Archive root: ${report.archiveRoot}`);
+  }
+  for (const item of report.removed) {
+    console.log(`- ${item.path}`);
+  }
+  if (report.skipped.length > 0) {
+    console.log(`Skipped ${report.skipped.length} candidate(s) without Gofer markers.`);
+  }
+}
+
+if (path.resolve(process.argv[1] ?? '') === path.resolve(__filename)) {
+  main().catch((error) => {
+    console.error(error?.message ?? String(error));
+    process.exit(1);
+  });
+}

package/resources/gofer/node-scripts/gofer-loop-audit.mjs

@@ -2,6 +2,9 @@
 
 import { promises as fs } from 'fs';
 import path from 'path';
+import { reviewDelivery } from './gofer-delivery-check.mjs';
+import { inspectBlockers } from './gofer-blocker-control.mjs';
+import { reviewPriority } from './gofer-priority-check.mjs';
 
 const STAGE_ORDER = {
   '0_gofer_start': 0,
@@ -62,7 +65,10 @@ function parseArgs(argv) {
         args.featureDir = argv[++index] || '';
         break;
       case '--stage':
-        args.stage = argv[++index] || args.stage;
+        if (argv[index + 1] === undefined || argv[index + 1].startsWith('--')) {
+          throw new Error('--stage requires a value before the next option.');
+        }
+        args.stage = argv[++index];
         break;
       case '--init':
         args.init = true;
@@ -112,7 +118,11 @@ function parseArgs(argv) {
 }
 
 function normalizeStage(stage) {
-  return String(stage || '6_validate').trim();
+  const normalized = String(stage).trim();
+  if (!Object.hasOwn(STAGE_ORDER, normalized)) {
+    throw new Error(`Unknown stage: ${normalized}. Supported stages: ${Object.keys(STAGE_ORDER).join(', ')}`);
+  }
+  return normalized;
 }
 
 async function pathExists(targetPath) {
@@ -158,6 +168,8 @@ function createDefaultContract(featureDir) {
   const featureId = path.basename(featureDir);
   return {
     schemaVersion: 1,
+    requireDeliveryCheckpoint: true,
+    requirePriorityPlan: true,
     loopId: featureId,
     profile: 'standard',
     objective:
@@ -189,7 +201,7 @@ function createDefaultContract(featureDir) {
         id: 'closed-loop-audit',
         stage: '6_validate',
         command:
-          'node .specify/scripts/node/gofer-closed-loop-audit.mjs --feature-dir {FEATURE_DIR} --json --strict',
+          'node .specify/scripts/node/gofer-closed-loop-audit.mjs --feature-dir {FEATURE_DIR} --json --strict --completion',
         purpose: 'Verify goal, traceability, drift, and validation freshness before final scoring.',
         runWhen: 'before validation scoring',
       },
@@ -251,6 +263,12 @@ function validateContract(contract) {
   if (contract.schemaVersion !== 1) {
     findings.push('schemaVersion must be 1');
   }
+  if (contract.requireDeliveryCheckpoint !== undefined && typeof contract.requireDeliveryCheckpoint !== 'boolean') {
+    findings.push('requireDeliveryCheckpoint must be a boolean');
+  }
+  if (contract.requirePriorityPlan !== undefined && typeof contract.requirePriorityPlan !== 'boolean') {
+    findings.push('requirePriorityPlan must be a boolean');
+  }
   for (const field of ['loopId', 'profile', 'objective', 'entryStage']) {
     if (!hasMaterialText(contract[field])) {
       findings.push(`${field} must be material text`);
@@ -441,6 +459,10 @@ ${formatList(result.blockingFindings)}
 
 ${formatList(result.warnings)}
 
+## Coverage Notes
+
+${formatList(result.coverageNotes)}
+
 ## Last Ledger Entry
 
 \`\`\`json
@@ -462,6 +484,7 @@ async function analyze(args) {
     contractCreated: false,
     blockingFindings: [],
     warnings: [],
+    coverageNotes: [],
     ledgerEntries: 0,
     maxIterations: null,
     lastLedgerEntry: null,
@@ -506,6 +529,34 @@ async function analyze(args) {
     result.warnings.push(...validation.warnings);
   }
 
+  try {
+    result.blockerReview = await inspectBlockers(args.featureDir);
+    if (result.blockerReview.status === 'blocked') result.blockingFindings.push('Recorded blockers remain unresolved; inspect blocker-register.json before continuing affected work');
+    result.coverageNotes.push(result.blockerReview.coverage);
+  } catch {
+    result.blockingFindings.push('Blocker register or its evidence is invalid; stop affected work and review the local record');
+  }
+
+  if (STAGE_ORDER[args.stage] >= 4) {
+    if (contract?.requirePriorityPlan === true || await pathExists(path.join(args.featureDir, 'priority-plan.json'))) {
+      result.priorityReview = await reviewPriority(args.featureDir, { finish: STAGE_ORDER[args.stage] >= 6 });
+      result.blockingFindings.push(...result.priorityReview.findings);
+    } else {
+      result.coverageNotes.push('Legacy feature has no priority plan; priority and outcome receipts are unverified');
+    }
+    if (contract?.requireDeliveryCheckpoint === true || await pathExists(path.join(args.featureDir, 'delivery-checkpoint.json'))) {
+      try {
+        const delivery = await reviewDelivery(args.featureDir);
+        result.deliveryReview = delivery;
+        result.blockingFindings.push(...delivery.findings.map(item => `Delivery review: ${item}`));
+      } catch {
+        result.blockingFindings.push('Delivery review could not read the feature checkpoint');
+      }
+    } else {
+      result.coverageNotes.push('Delivery checkpoint not enabled for this legacy feature; task freshness is unverified');
+    }
+  }
+
   if (result.blockingFindings.length > 0) {
     result.status = 'fail';
   } else if (result.warnings.length > 0) {