@jaimevalasek/aioson 1.21.7 → 1.22.0

package/src/commands/feature-export.js

@@ -0,0 +1,242 @@
+'use strict';
+
+/**
+ * aioson feature:export — copy every artefact of a feature into a clean output
+ * directory, leaving the source tree untouched.
+ *
+ * Sibling of feature:archive, but COPY (not move) to an arbitrary --out. Turns
+ * AIOSON's markdown output into a portable deliverable: read/analyse the specs
+ * outside the project, hand them to a client, or use AIOSON purely as a spec
+ * generator. Works for both active features (artefacts in context/ root + slug
+ * dirs) and already-archived ones (context/done/{slug}).
+ *
+ * Usage:
+ *   aioson feature:export . --feature=checkout
+ *   aioson feature:export . --feature=checkout --out=../checkout-specs
+ *   aioson feature:export . --feature=checkout --flatten
+ *   aioson feature:export . --feature=checkout --no-index
+ *   aioson feature:export . --feature=checkout --dry-run --json
+ */
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { contextDir } = require('../preflight-engine');
+const { collectFeatureArtifacts } = require('./feature-archive');
+
+async function dirExists(dirPath) {
+  try {
+    return (await fs.stat(dirPath)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Recursively list every file under `dir`, returning paths relative to `base`.
+ */
+async function walkFiles(dir, base = dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const abs = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      // eslint-disable-next-line no-await-in-loop
+      out.push(...await walkFiles(abs, base));
+    } else if (entry.isFile()) {
+      out.push(path.relative(base, abs));
+    }
+  }
+  return out;
+}
+
+function toPosix(p) {
+  return p.split(path.sep).join('/');
+}
+
+/**
+ * Build the flat list of {srcAbs, relDest, group} to copy. relDest is the path
+ * relative to the output dir (mirrored structure). Caller may flatten later.
+ */
+async function buildEntries({ ctxDir, rootFiles, dirs, doneDir }) {
+  const entries = [];
+
+  for (const name of rootFiles) {
+    entries.push({ srcAbs: path.join(ctxDir, name), relDest: name, group: 'context' });
+  }
+
+  for (const d of dirs) {
+    // eslint-disable-next-line no-await-in-loop
+    const files = await walkFiles(d.sourceDir);
+    for (const rel of files) {
+      entries.push({
+        srcAbs: path.join(d.sourceDir, rel),
+        relDest: path.join(d.label, rel),
+        group: d.label
+      });
+    }
+  }
+
+  if (doneDir) {
+    const files = await walkFiles(doneDir);
+    for (const rel of files) {
+      entries.push({
+        srcAbs: path.join(doneDir, rel),
+        relDest: path.join('done', rel),
+        group: 'done'
+      });
+    }
+  }
+
+  return entries;
+}
+
+function applyFlatten(entries) {
+  // Collapse subdir structure into a single level. Root files (no separator)
+  // keep their name; nested files become `label-...-file.ext`, which is
+  // collision-free by construction since it encodes the full source path.
+  for (const e of entries) {
+    e.relDest = e.relDest.split(/[/\\]/).join('-');
+  }
+  return entries;
+}
+
+function renderIndex({ slug, entries, targetDir, exportedAt }) {
+  const lines = [
+    `# Feature Export — ${slug}`,
+    '',
+    `> ${entries.length} file(s) copied from AIOSON on ${exportedAt}.`,
+    '> Non-destructive snapshot — the original artefacts were left untouched.',
+    '',
+    '| group | file | source |',
+    '|-------|------|--------|'
+  ];
+  const sorted = [...entries].sort((a, b) => {
+    if (a.group !== b.group) return a.group.localeCompare(b.group);
+    return a.relDest.localeCompare(b.relDest);
+  });
+  for (const e of sorted) {
+    const source = toPosix(path.relative(targetDir, e.srcAbs));
+    lines.push(`| ${e.group} | ${toPosix(e.relDest)} | ${source} |`);
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+async function runFeatureExport({ args = [], options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = options.feature ? String(options.feature) : null;
+  const flatten = Boolean(options.flatten);
+  const noIndex = Boolean(options['no-index'] || options.noIndex);
+  const dryRun = Boolean(options['dry-run'] || options.dryRun);
+  const jsonOut = Boolean(options.json);
+
+  const log = (msg) => { if (logger && !jsonOut) logger.log(msg); };
+
+  if (!slug) {
+    if (jsonOut) return { ok: false, reason: 'missing_feature' };
+    log('--feature=<slug> is required.');
+    return { ok: false };
+  }
+
+  if (!/^[a-z][a-z0-9-]*$/i.test(slug)) {
+    if (jsonOut) return { ok: false, reason: 'invalid_slug' };
+    log(`Invalid slug "${slug}" — use lowercase letters, digits and hyphens only.`);
+    return { ok: false };
+  }
+
+  const ctxDir = contextDir(targetDir);
+  if (!(await dirExists(ctxDir))) {
+    if (jsonOut) return { ok: false, reason: 'no_context_dir' };
+    log(`.aioson/context/ not found at ${targetDir}. Run aioson setup first.`);
+    return { ok: false };
+  }
+
+  const outDir = options.out
+    ? path.resolve(process.cwd(), String(options.out))
+    : path.join(targetDir, `${slug}-export`);
+
+  const { rootFiles, dirs, doneDir } = await collectFeatureArtifacts({
+    ctxDir, targetDir, slug, includeDone: true
+  });
+
+  let entries = await buildEntries({ ctxDir, rootFiles, dirs, doneDir });
+  if (flatten) entries = applyFlatten(entries);
+
+  if (entries.length === 0) {
+    if (jsonOut) return { ok: true, slug, exported: [], noop: true };
+    log(`No artefacts matched "*-${slug}.{md,yaml,yml,json}" in .aioson/context/, no slug directories (features/plans/briefings), and nothing under context/done/${slug}/ — nothing to export.`);
+    return { ok: true, slug, noop: true };
+  }
+
+  const relOut = toPosix(path.relative(targetDir, outDir)) || outDir;
+
+  if (dryRun) {
+    const result = {
+      ok: true,
+      dryRun: true,
+      slug,
+      outDir: relOut,
+      flatten,
+      index: !noIndex,
+      count: entries.length,
+      files: entries.map((e) => toPosix(e.relDest))
+    };
+    if (jsonOut) return result;
+    log(`[dry-run] feature:export — ${slug}:`);
+    log(`  out: ${relOut}/  (${flatten ? 'flattened' : 'mirrored'})`);
+    log(`  would copy: ${entries.length} file(s)`);
+    for (const e of [...entries].sort((a, b) => a.relDest.localeCompare(b.relDest))) {
+      log(`    • ${toPosix(e.relDest)}`);
+    }
+    if (!noIndex) log('  would write: INDEX.md');
+    return result;
+  }
+
+  await fs.mkdir(outDir, { recursive: true });
+  const copied = [];
+  for (const e of entries) {
+    const dest = path.join(outDir, e.relDest);
+    // eslint-disable-next-line no-await-in-loop
+    await fs.mkdir(path.dirname(dest), { recursive: true });
+    // eslint-disable-next-line no-await-in-loop
+    await fs.copyFile(e.srcAbs, dest);
+    copied.push(toPosix(e.relDest));
+  }
+
+  let indexWritten = false;
+  if (!noIndex) {
+    const exportedAt = new Date().toISOString().slice(0, 10);
+    await fs.writeFile(
+      path.join(outDir, 'INDEX.md'),
+      renderIndex({ slug, entries, targetDir, exportedAt }),
+      'utf8'
+    );
+    indexWritten = true;
+  }
+
+  const result = {
+    ok: true,
+    slug,
+    outDir: relOut,
+    flatten,
+    count: copied.length,
+    copied,
+    index: indexWritten
+  };
+
+  if (jsonOut) return result;
+  log(`feature:export — ${slug}:`);
+  log(`  out: ${relOut}/  (${flatten ? 'flattened' : 'mirrored'})`);
+  log(`  copied: ${copied.length} file(s)`);
+  for (const f of [...copied].sort()) log(`    • ${f}`);
+  if (indexWritten) log(`  index: ${relOut}/INDEX.md`);
+  log('  source tree untouched (non-destructive copy).');
+  return result;
+}
+
+module.exports = { runFeatureExport };

package/src/commands/gate-check.js

@@ -36,7 +36,10 @@ const GATE_PREREQUISITES = {
 const GATE_REQUIRED_ARTIFACTS = {
   A: (slug) => [`requirements-${slug}.md`],
   B: (slug) => ['architecture.md'],
-  C: (slug) => [`implementation-plan-${slug}.md`],
+  // implementation-plan-{slug}.md is a MEDIUM-only artifact (@pm owns it,
+  // AC-SDLC-15/16). SMALL/MICRO sequences never route through @pm, so
+  // requiring it unconditionally dead-ends Gate C for those features.
+  C: (slug, classification) => (classification === 'MEDIUM' ? [`implementation-plan-${slug}.md`] : []),
   D: (slug) => [] // Gate D validated by QA sign-off in spec
 };
 
@@ -75,7 +78,7 @@ async function checkGate(targetDir, slug, gateLetter) {
   }
 
   // Check required artifacts
-  const requiredFiles = GATE_REQUIRED_ARTIFACTS[gateLetter](slug);
+  const requiredFiles = GATE_REQUIRED_ARTIFACTS[gateLetter](slug, classification);
   for (const fileName of requiredFiles) {
     const filePath = path.join(dir, fileName);
     const exists = await fileExists(filePath);
@@ -150,7 +153,9 @@ async function checkGate(targetDir, slug, gateLetter) {
     const fixAgents = {
       A: `activate @analyst to produce requirements-${slug}.md, then run: aioson gate:approve . --feature=${slug} --gate=A`,
       B: `activate @architect to produce architecture.md, then run: aioson gate:approve . --feature=${slug} --gate=B`,
-      C: `activate @pm to produce and approve implementation-plan-${slug}.md, then run: aioson gate:approve . --feature=${slug} --gate=C`,
+      C: classification === 'MEDIUM'
+        ? `activate @pm to produce and approve implementation-plan-${slug}.md, then run: aioson gate:approve . --feature=${slug} --gate=C`
+        : `approve Gates A and B first, then run: aioson gate:approve . --feature=${slug} --gate=C`,
       D: `activate @qa for final verification; if QA passes, run: aioson gate:approve . --feature=${slug} --gate=D`
     };
     recommendation = `BLOCKED — ${fixAgents[gateLetter] || 'resolve missing items'}`;

package/src/commands/git-guard.js

@@ -12,12 +12,64 @@
  */
 
 const path = require('node:path');
+const fs = require('node:fs');
 const {
   inspectStagedChanges,
   installPreCommitHook,
   uninstallPreCommitHook
 } = require('../lib/git-commit-guard');
 
+/**
+ * REQ-20 (loop-guardrails, should-have): mescla `forbidden_files` do contrato
+ * ATIVO (progress `in_progress`/`human_gate` mais recente) na verificação do
+ * guard em tempo de execução — camada 2 do scope guard no pre-commit.
+ * Best-effort: nunca quebra o guard; contrato inválido é ignorado (o preflight
+ * do self:loop já bloqueia o loop nesse caso). Paths `.aioson/**` ficam fora
+ * (estado do framework precisa ser commitável).
+ *
+ * C-03 (QA 2026-06-09): nesta camada aplicam-se apenas os globs DECLARADOS no
+ * contrato. Os defaults não-removíveis (lockfiles, node_modules, .env*, ...)
+ * existem para conter o LOOP do agente; no pre-commit pegariam mudanças
+ * humanas legítimas (ex.: package-lock.json após `npm install`). Segredos
+ * (.env*, *.pem, *.key, secrets/**) continuam bloqueados pela policy baseline
+ * do próprio git-guard.
+ */
+const { findActiveContract } = require('../harness/active-contract');
+
+function applyActiveContractPolicy(targetDir, result) {
+  const active = findActiveContract(targetDir);
+  if (!active) return null;
+  const { validateContract } = require('../harness/contract-schema');
+  const { matchGlob, matchAny } = require('../harness/glob-match');
+  const contract = JSON.parse(fs.readFileSync(active.contractPath, 'utf8'));
+  if (!validateContract(contract).ok) return null;
+  const declaredForbidden = Array.isArray(contract.forbidden_files) ? contract.forbidden_files : [];
+  if (!declaredForbidden.length) return { slug: active.slug, findings: 0 };
+
+  let added = 0;
+  for (const file of result.files) {
+    if (matchGlob('.aioson/**', file.path)) continue;
+    const matched = matchAny(declaredForbidden, file.path);
+    if (!matched) continue;
+    const finding = {
+      type: 'path',
+      severity: 'error',
+      id: 'contract_forbidden_file',
+      path: file.path,
+      reason: `matches forbidden glob "${matched}" from active harness contract "${active.slug}"`,
+      line: null
+    };
+    file.findings.push(finding);
+    result.errors.push(finding);
+    added += 1;
+  }
+  if (added > 0) {
+    result.ok = false;
+    result.summary.errorCount = result.errors.length;
+  }
+  return { slug: active.slug, findings: added };
+}
+
 function formatFinding(prefix, finding) {
   const line = finding.line ? `:${finding.line}` : '';
   return `${prefix} ${finding.path}${line} — ${finding.reason} [${finding.id}]`;
@@ -111,9 +163,15 @@ async function runGitGuard({ args, options = {}, logger }) {
     return failure;
   }
 
+  let contractPolicy = null;
+  try {
+    contractPolicy = applyActiveContractPolicy(targetDir, result);
+  } catch { /* best-effort: contrato ilegível nunca quebra o guard */ }
+
   const output = {
     ok: result.ok,
     projectDir: targetDir,
+    contractPolicy,
     gitRoot: result.gitRoot,
     strict: result.strict,
     policy: result.policy,

package/src/commands/harness-gate.js

@@ -0,0 +1,120 @@
+'use strict';
+
+/**
+ * aioson harness:approve / harness:reject — decisão humana de gates do
+ * self:loop (loop-guardrails REQ-14/15).
+ *
+ * - Exigem --slug e --gate; reject exige --reason.
+ * - Decisão persiste em `.aioson/plans/{slug}/gates/{id}.json`
+ *   (decided_at/decided_by/reason) e emite `human_gate_decision`.
+ * - Gate já decidido = no-op idempotente com aviso (REQ-14).
+ * - Gate inexistente = erro explícito sem efeito colateral (EC-8).
+ * - Sem pendências restantes → progress.status volta a `in_progress`;
+ *   re-executar `self:loop` retoma do ponto persistido (REQ-15).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const { decideGate, resolveGateState, pendingGates } = require('../harness/human-gate');
+const { emitGuardEvent } = require('../harness/guard-events');
+
+function gitUserName(targetDir) {
+  try {
+    return execFileSync('git', ['config', 'user.name'], {
+      cwd: targetDir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+async function runGateDecision(decision, { args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args?.[0] || '.');
+  const slug = String(options.slug || '').trim();
+  const gateId = String(options.gate || '').trim();
+  const reason = options.reason ? String(options.reason).trim() : null;
+  const decidedBy = options.by ? String(options.by).trim() : gitUserName(targetDir);
+
+  if (!slug) {
+    logger.error('Error: --slug is required');
+    return { ok: false, error: 'missing_slug' };
+  }
+  if (!gateId) {
+    logger.error('Error: --gate is required (gate id, e.g. payment_logic_change-1)');
+    return { ok: false, error: 'missing_gate' };
+  }
+
+  const planDir = path.join(targetDir, '.aioson', 'plans', slug);
+  if (!fs.existsSync(path.join(planDir, 'harness-contract.json'))) {
+    logger.error(`Contract not found for slug: ${slug}`);
+    return { ok: false, error: 'contract_not_found' };
+  }
+
+  const result = decideGate(planDir, gateId, { decision, by: decidedBy, reason });
+
+  if (!result.ok) {
+    const messages = {
+      gate_not_found: `Gate not found: ${gateId} — nothing to ${decision === 'approved' ? 'approve' : 'reject'} (no side effects)`,
+      reason_required_on_reject: 'Error: --reason is required when rejecting a gate',
+      gate_corrupted: `Gate file is corrupted: ${gateId}`,
+      invalid_decision: `Invalid decision: ${decision}`
+    };
+    logger.error(messages[result.error] || `Error: ${result.error}`);
+    return { ok: false, error: result.error, gateId };
+  }
+
+  if (result.idempotent) {
+    logger.log(`• Gate ${gateId} already decided (${result.gate.status} at ${result.gate.decided_at}) — no-op`);
+    return { ok: true, idempotent: true, gate: result.gate };
+  }
+
+  // reconcilia progress.json: remove decidido de pending_gates; sem pendências
+  // restantes → status volta a in_progress (retomada idempotente / auditoria)
+  const progressPath = path.join(planDir, 'progress.json');
+  let remaining = [];
+  try {
+    if (fs.existsSync(progressPath)) {
+      const progress = JSON.parse(fs.readFileSync(progressPath, 'utf8'));
+      resolveGateState(progress, planDir);
+      fs.writeFileSync(progressPath, JSON.stringify(progress, null, 2), 'utf8');
+      remaining = progress.pending_gates || [];
+    } else {
+      remaining = pendingGates(planDir).map((g) => g.id);
+    }
+  } catch { /* progress corrompido — decisão do gate já persistiu */ }
+
+  await emitGuardEvent(targetDir, {
+    eventType: 'human_gate_decision',
+    message: `gate ${gateId} ${decision} by ${decidedBy || 'unknown'}`,
+    payload: { slug, gate_id: gateId, theme: result.gate.theme, decision, decided_by: decidedBy, reason }
+  });
+
+  const mark = decision === 'approved' ? '✓' : '✗';
+  logger.log(`${mark} Gate ${gateId} ${decision}${decidedBy ? ` by ${decidedBy}` : ''}${reason ? ` — ${reason}` : ''}`);
+  if (remaining.length > 0) {
+    logger.log(`  Pending gates remaining: ${remaining.join(', ')}`);
+  } else if (decision === 'approved') {
+    logger.log(`  No pending gates — re-run self:loop to resume from the persisted state.`);
+  } else {
+    logger.log(`  Run ended. A new self:loop starts a fresh run (rejected gate is kept as audit).`);
+  }
+
+  return { ok: true, gate: result.gate, pending_gates: remaining };
+}
+
+async function runHarnessApprove(ctx) {
+  return runGateDecision('approved', ctx);
+}
+
+async function runHarnessReject(ctx) {
+  return runGateDecision('rejected', ctx);
+}
+
+module.exports = {
+  runHarnessApprove,
+  runHarnessReject
+};

package/src/commands/harness-status.js

@@ -0,0 +1,157 @@
+'use strict';
+
+/**
+ * aioson harness:status . --slug=X [--json] — visibilidade do estado do loop
+ * (loop-guardrails REQ-18).
+ *
+ * Agrega: circuito, iteração N/M, budget, checks da última tentativa,
+ * última falha, gates pendentes e a próxima ação. Escopo distinto de
+ * `spec:status` (planos+learnings) — referenciado no rodapé.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { resolveContract, validateContract } = require('../harness/contract-schema');
+const { pendingGates } = require('../harness/human-gate');
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/** Última tentativa = maior diretório numérico em attempts/. */
+function latestAttempt(planDir) {
+  const dir = path.join(planDir, 'attempts');
+  if (!fs.existsSync(dir)) return null;
+  const numbers = fs.readdirSync(dir)
+    .map((name) => Number(name))
+    .filter((n) => Number.isInteger(n) && n > 0);
+  return numbers.length ? Math.max(...numbers) : null;
+}
+
+/** Conta checks pass/fail da tentativa pelos logs `# exit_code:`. */
+function readChecks(planDir, attempt) {
+  const checksDir = path.join(planDir, 'attempts', String(attempt), 'checks');
+  if (!fs.existsSync(checksDir)) return { total: 0, passed: 0, failed: 0, failed_ids: [] };
+  const summary = { total: 0, passed: 0, failed: 0, failed_ids: [] };
+  for (const file of fs.readdirSync(checksDir)) {
+    if (!file.endsWith('.log')) continue;
+    summary.total += 1;
+    try {
+      const content = fs.readFileSync(path.join(checksDir, file), 'utf8');
+      const match = content.match(/^# exit_code: (.+)$/m);
+      if (match && match[1].trim() === '0') {
+        summary.passed += 1;
+      } else {
+        summary.failed += 1;
+        summary.failed_ids.push(file.replace(/\.log$/, ''));
+      }
+    } catch {
+      summary.failed += 1;
+    }
+  }
+  return summary;
+}
+
+function nextAction(progress, pending, slug) {
+  if (pending.length > 0) {
+    return `aioson harness:approve . --slug=${slug} --gate=${pending[0].id} (ou harness:reject --reason="...")`;
+  }
+  const status = progress?.status || 'unknown';
+  if (status === 'circuit_open' || progress?.circuit_state === 'OPEN') {
+    return 'circuito aberto — revisar last_error e corrigir antes de novo run';
+  }
+  if (status === 'waiting_validation') {
+    return `aioson harness:validate . --slug=${slug}`;
+  }
+  if (progress?.ready_for_done_gate) {
+    return `pronto para o done gate — aioson feature:close . --feature=${slug}`;
+  }
+  return `re-executar self:loop para continuar (iteração persiste em progress.json)`;
+}
+
+async function runHarnessStatus({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args?.[0] || '.');
+  const slug = String(options.slug || '').trim();
+
+  if (!slug) {
+    logger.error('Error: --slug is required');
+    return { ok: false, error: 'missing_slug' };
+  }
+
+  const planDir = path.join(targetDir, '.aioson', 'plans', slug);
+  const contract = readJson(path.join(planDir, 'harness-contract.json'));
+  if (!contract) {
+    logger.error(`Contract not found for slug: ${slug}`);
+    return { ok: false, error: 'contract_not_found' };
+  }
+
+  const progress = readJson(path.join(planDir, 'progress.json'));
+  const schema = validateContract(contract);
+  const resolved = schema.ok ? resolveContract(contract) : null;
+  const pending = pendingGates(planDir);
+  const attempt = latestAttempt(planDir);
+  const checks = attempt ? readChecks(planDir, attempt) : { total: 0, passed: 0, failed: 0, failed_ids: [] };
+
+  const maxSteps = resolved ? resolved.governor.max_steps : (contract.governor && contract.governor.max_steps) || null;
+  const ceiling = resolved ? (resolved.governor.cost_ceiling_tokens ?? null) : null;
+  const budget = progress?.budget || null;
+
+  const report = {
+    ok: true,
+    slug,
+    contract_mode: contract.contract_mode || 'BALANCED',
+    contract_schema_ok: schema.ok,
+    circuit_state: progress?.circuit_state || 'CLOSED',
+    status: progress?.status || 'unknown',
+    iterations: progress?.iterations ?? 0,
+    max_steps: maxSteps,
+    budget: budget ? {
+      tokens_estimated: budget.tokens_estimated || 0,
+      cost_ceiling_tokens: ceiling,
+      run_id: budget.run_id || null,
+      run_started_at: budget.run_started_at || null
+    } : null,
+    last_attempt: attempt,
+    checks,
+    last_error: progress?.last_error || null,
+    pending_gates: pending.map((g) => ({ id: g.id, theme: g.theme, attempt: g.attempt, requested_at: g.requested_at })),
+    next_action: nextAction(progress, pending, slug)
+  };
+
+  if (options.json) {
+    logger.log(JSON.stringify(report, null, 2));
+    return report;
+  }
+
+  logger.log(`Harness status — ${slug}`);
+  logger.log(`  Mode: ${report.contract_mode}${schema.ok ? '' : '  (⚠ contract schema invalid)'}`);
+  logger.log(`  Circuit: ${report.circuit_state} | status: ${report.status}`);
+  logger.log(`  Iteration: ${report.iterations}${maxSteps ? `/${maxSteps}` : ''}`);
+  if (budget) {
+    logger.log(`  Budget: ${report.budget.tokens_estimated} tokens estimados${ceiling ? ` / ${ceiling} (${Math.round((report.budget.tokens_estimated / ceiling) * 100)}%)` : ' (sem teto)'}`);
+  }
+  if (attempt) {
+    logger.log(`  Last attempt: ${attempt} — checks ${checks.passed}/${checks.total} pass${checks.failed ? ` (failed: ${checks.failed_ids.join(', ')})` : ''}`);
+  }
+  if (report.last_error) logger.log(`  Last error: ${report.last_error}`);
+  if (pending.length > 0) {
+    logger.log(`  ⛔ Pending gates (${pending.length}):`);
+    for (const gate of pending) {
+      logger.log(`    - ${gate.id} [${gate.theme}] attempt ${gate.attempt}`);
+    }
+  }
+  logger.log(`  Next: ${report.next_action}`);
+  logger.log('');
+  logger.log('  Planos e learnings: aioson spec:status');
+
+  return report;
+}
+
+module.exports = {
+  runHarnessStatus
+};

package/src/commands/harness.js

@@ -3,6 +3,7 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const { createCircuitBreaker } = require('../harness/circuit-breaker');
+const { validateContract } = require('../harness/contract-schema');
 
 /**
  * aioson harness:init — Inicializa o contrato e progresso da feature.
@@ -36,8 +37,17 @@ async function runHarnessInit({ args, options = {}, logger, t }) {
     governor: {
       max_steps: 50,
       error_streak_limit: 5,
-      cost_ceiling_tokens: null
+      cost_ceiling_tokens: null,
+      max_runtime_minutes: null,
+      max_changed_files: null,
+      max_diff_lines: null
     },
+    // Scope guard (loop-guardrails): allowed_files ausente = sem allowlist;
+    // forbidden_files é SEMPRE mesclado com os defaults embutidos (.env*, *.pem,
+    // *.key, secrets/**, .git/**, node_modules/**, lockfiles) — não-removíveis.
+    forbidden_files: [],
+    // human_gate ausente = nenhum gate (retrocompat). Exemplo:
+    // "human_gate": { "required_for": ["payment_logic_change", "publish"] }
     criteria: [
       {
         id: "C1",
@@ -48,6 +58,13 @@ async function runHarnessInit({ args, options = {}, logger, t }) {
     ]
   };
 
+  const schemaResult = validateContract(contract);
+  if (!schemaResult.ok) {
+    const first = schemaResult.errors[0];
+    logger.error(`Contract schema invalid: ${first.field} — ${first.reason}`);
+    return { ok: false, error: 'contract_schema_invalid', errors: schemaResult.errors };
+  }
+
   const cb = createCircuitBreaker(contractPath, progressPath);
   fs.writeFileSync(contractPath, JSON.stringify(contract, null, 2), 'utf8');
   await cb.load();