@zaip-ai/cli 0.1.0 → 1.0.1

package/templates/.agents/design/packages/local-runtime/runtime.mjs

@@ -0,0 +1,238 @@
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { appendFileSync, mkdirSync } from "node:fs";
+import { access, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { dirname, extname, join, resolve, sep } from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+export const host = "127.0.0.1";
+export const defaultPort = 5174;
+export const maxPortAttempts = 25;
+export const packageRoot = dirname(fileURLToPath(import.meta.url));
+export const workspaceRoot = resolve(packageRoot, "../../../..");
+export const uiRoot = resolve(workspaceRoot, ".agents/design/apps/catalog/dist");
+export const workspaceKey = createHash("sha256").update(workspaceRoot).digest("hex").slice(0, 16);
+export const sessionDirectory = join(tmpdir(), "zaip-aios", workspaceKey);
+export const sessionPath = join(sessionDirectory, "design-session.json");
+export const lockPath = join(sessionDirectory, "design-launcher.lock");
+export const launcherLogPath = join(sessionDirectory, "design-launcher.log");
+
+const healthPath = "/.zaip-design/health";
+const lockTimeoutMs = 10_000;
+const staleLockMs = 30_000;
+const mimeTypes = new Map([
+  [".css", "text/css; charset=utf-8"],
+  [".html", "text/html; charset=utf-8"],
+  [".ico", "image/x-icon"],
+  [".js", "text/javascript; charset=utf-8"],
+  [".json", "application/json; charset=utf-8"],
+  [".mjs", "text/javascript; charset=utf-8"],
+  [".png", "image/png"],
+  [".svg", "image/svg+xml"],
+  [".woff2", "font/woff2"],
+]);
+
+export function preferredPort(value = process.env.ZAIP_DESIGN_PORT) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isInteger(parsed) && parsed > 0 && parsed <= 65_535 ? parsed : defaultPort;
+}
+
+export function designUrl(port) {
+  return `http://${host}:${port}/#/design-system`;
+}
+
+export function designHealthUrl(port) {
+  return `http://${host}:${port}${healthPath}`;
+}
+
+export function appendLauncherLog(message) {
+  try {
+    mkdirSync(sessionDirectory, { recursive: true });
+    appendFileSync(launcherLogPath, `[${new Date().toISOString()}] ${message}\n`, "utf8");
+  } catch {
+    // Best-effort diagnostics must not hide the launcher failure.
+  }
+}
+
+export async function assertRuntimeReady() {
+  await access(resolve(uiRoot, "index.html"));
+}
+
+export async function readDesignSession() {
+  try {
+    return JSON.parse(await readFile(sessionPath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+export async function writeDesignSession(port) {
+  await mkdir(sessionDirectory, { recursive: true });
+  await writeFile(
+    sessionPath,
+    `${JSON.stringify(
+      {
+        kind: "zaip-design-local-runtime",
+        workspace: workspaceRoot,
+        workspaceKey,
+        rootPid: process.pid,
+        port,
+        createdAt: new Date().toISOString(),
+      },
+      null,
+      2,
+    )}\n`,
+    "utf8",
+  );
+}
+
+export async function clearOwnedDesignSession() {
+  const session = await readDesignSession();
+  if (session?.rootPid === process.pid) await rm(sessionPath, { force: true });
+}
+
+export async function probeDesignPort(port, fetchImpl = fetch) {
+  try {
+    const response = await fetchImpl(designHealthUrl(port), {
+      signal: AbortSignal.timeout(400),
+    });
+    if (!response.ok) return false;
+    const payload = await response.json();
+    return payload?.kind === "zaip-design-local-runtime" && payload.workspaceKey === workspaceKey;
+  } catch {
+    return false;
+  }
+}
+
+export async function findReusableDesignPort(startPort = preferredPort(), fetchImpl = fetch) {
+  const session = await readDesignSession();
+  if (Number.isInteger(session?.port) && (await probeDesignPort(session.port, fetchImpl))) {
+    return session.port;
+  }
+  const ports = Array.from({ length: maxPortAttempts }, (_, index) => startPort + index).filter(
+    (port) => port <= 65_535 && port !== session?.port,
+  );
+  const matches = await Promise.all(
+    ports.map(async (port) => ((await probeDesignPort(port, fetchImpl)) ? port : null)),
+  );
+  return matches.find((port) => port !== null) ?? null;
+}
+
+export async function withLauncherLock(action) {
+  await mkdir(sessionDirectory, { recursive: true });
+  const deadline = Date.now() + lockTimeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      await mkdir(lockPath);
+      try {
+        return await action();
+      } finally {
+        await rm(lockPath, { recursive: true, force: true });
+      }
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      const lockStat = await stat(lockPath).catch(() => null);
+      if (lockStat !== null && Date.now() - lockStat.mtimeMs > staleLockMs) {
+        await rm(lockPath, { recursive: true, force: true });
+        continue;
+      }
+      await delay(100);
+    }
+  }
+  throw new Error("Timed out waiting for the ZAIP design launcher lock");
+}
+
+export function resolveAssetPath(pathname, root = uiRoot) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(pathname);
+  } catch {
+    return null;
+  }
+  const relativePath = decoded === "/" ? "index.html" : decoded.replace(/^\/+/, "");
+  const withIndex = relativePath.endsWith("/") ? `${relativePath}index.html` : relativePath;
+  const absolute = resolve(root, withIndex);
+  return absolute === root || absolute.startsWith(`${resolve(root)}${sep}`) ? absolute : null;
+}
+
+export function createDesignServer(root = uiRoot) {
+  return createServer(async (request, response) => {
+    const url = new URL(request.url ?? "/", `http://${host}`);
+    if (url.pathname === healthPath) {
+      const body = `${JSON.stringify({ kind: "zaip-design-local-runtime", workspaceKey })}\n`;
+      response.writeHead(200, {
+        "cache-control": "no-store",
+        "content-type": "application/json; charset=utf-8",
+      });
+      response.end(request.method === "HEAD" ? undefined : body);
+      return;
+    }
+    const assetPath = resolveAssetPath(url.pathname, root);
+    if (assetPath === null) {
+      response.writeHead(400).end();
+      return;
+    }
+    try {
+      const content = await readFile(assetPath);
+      response.writeHead(200, {
+        "cache-control": "no-cache",
+        "content-type":
+          mimeTypes.get(extname(assetPath).toLowerCase()) ?? "application/octet-stream",
+      });
+      response.end(request.method === "HEAD" ? undefined : content);
+    } catch (error) {
+      response.writeHead(error?.code === "ENOENT" ? 404 : 500).end();
+    }
+  });
+}
+
+export async function startDesignServer(startPort = preferredPort(), root = uiRoot) {
+  for (let port = startPort; port < Math.min(startPort + maxPortAttempts, 65_536); port += 1) {
+    const server = createDesignServer(root);
+    const listening = await listen(server, port);
+    if (listening) return { server, port };
+  }
+  throw new Error(
+    `No free design port found between ${startPort} and ${startPort + maxPortAttempts - 1}`,
+  );
+}
+
+export function openBrowser(url) {
+  if (process.env.ZAIP_DESIGN_NO_BROWSER === "1") return;
+  const command =
+    process.platform === "win32"
+      ? resolve(process.env.SystemRoot ?? "C:\\Windows", "explorer.exe")
+      : process.platform === "darwin"
+        ? "open"
+        : "xdg-open";
+  const child = spawn(command, [url], {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+  });
+  child.unref();
+}
+
+function listen(server, port) {
+  return new Promise((resolveListen, rejectListen) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      if (error?.code === "EADDRINUSE" || error?.code === "EACCES") resolveListen(false);
+      else rejectListen(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolveListen(true);
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen({ host, port });
+  });
+}
+
+function delay(milliseconds) {
+  return new Promise((resolveDelay) => setTimeout(resolveDelay, milliseconds));
+}

package/templates/.agents/design/packages/local-runtime/runtime.test.mjs

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, utimes, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { after, before, describe, it } from "node:test";
+import {
+  createDesignServer,
+  designHealthUrl,
+  host,
+  lockPath,
+  resolveAssetPath,
+  startDesignServer,
+  withLauncherLock,
+  workspaceKey,
+} from "./runtime.mjs";
+
+let root;
+let server;
+let port;
+
+before(async () => {
+  root = await mkdtemp(join(tmpdir(), "zaip-design-runtime-"));
+  await writeFile(join(root, "index.html"), "<title>ZAIP Design System</title>", "utf8");
+  server = createDesignServer(root);
+  await new Promise((resolveListen) => server.listen({ host, port: 0 }, resolveListen));
+  port = server.address().port;
+});
+
+after(async () => {
+  await new Promise((resolveClose) => server.close(resolveClose));
+  await rm(root, { recursive: true, force: true });
+});
+
+describe("design local runtime", () => {
+  it("serves the catalog and identifies the workspace", async () => {
+    const page = await fetch(`http://${host}:${port}/`);
+    assert.equal(page.status, 200);
+    assert.match(await page.text(), /ZAIP Design System/);
+    const health = await fetch(designHealthUrl(port));
+    assert.deepEqual(await health.json(), { kind: "zaip-design-local-runtime", workspaceKey });
+  });
+
+  it("rejects paths outside the catalog root", () => {
+    assert.equal(resolveAssetPath("/%2e%2e/secret.txt", root), null);
+    assert.equal(resolveAssetPath("/index.html", root), join(root, "index.html"));
+  });
+
+  it("skips an occupied preferred port without stopping its owner", async () => {
+    const blocker = createDesignServer(root);
+    await new Promise((resolveListen) => blocker.listen({ host, port: 0 }, resolveListen));
+    const blockedPort = blocker.address().port;
+    const started = await startDesignServer(blockedPort, root);
+    assert.notEqual(started.port, blockedPort);
+    assert.equal(blocker.listening, true);
+    await new Promise((resolveClose) => started.server.close(resolveClose));
+    await new Promise((resolveClose) => blocker.close(resolveClose));
+  });
+
+  it("recovers an abandoned launcher lock", async () => {
+    await mkdir(lockPath, { recursive: true });
+    const old = new Date(Date.now() - 31_000);
+    await utimes(lockPath, old, old);
+    const result = await withLauncherLock(async () => "recovered");
+    assert.equal(result, "recovered");
+  });
+});

package/templates/.agents/design/packages/local-runtime/start-design.mjs

@@ -0,0 +1,46 @@
+import process from "node:process";
+import {
+  appendLauncherLog,
+  assertRuntimeReady,
+  clearOwnedDesignSession,
+  designUrl,
+  findReusableDesignPort,
+  openBrowser,
+  preferredPort,
+  startDesignServer,
+  withLauncherLock,
+  writeDesignSession,
+} from "./runtime.mjs";
+
+let ownedServer = null;
+
+async function main() {
+  await assertRuntimeReady();
+  await withLauncherLock(async () => {
+    const reusablePort = await findReusableDesignPort();
+    if (reusablePort !== null) {
+      openBrowser(designUrl(reusablePort));
+      return;
+    }
+    const started = await startDesignServer(preferredPort());
+    ownedServer = started.server;
+    await writeDesignSession(started.port);
+    openBrowser(designUrl(started.port));
+  });
+
+  if (ownedServer === null) return;
+  const stop = async () => {
+    const server = ownedServer;
+    ownedServer = null;
+    if (server !== null) await new Promise((resolveClose) => server.close(resolveClose));
+    await clearOwnedDesignSession();
+  };
+  process.once("SIGINT", () => void stop().finally(() => process.exit(0)));
+  process.once("SIGTERM", () => void stop().finally(() => process.exit(0)));
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+  appendLauncherLog(message);
+  process.exitCode = 1;
+});

package/templates/.agents/design/packages/windows-launcher/Program.cs

@@ -0,0 +1,110 @@
+using System;
+using System.Diagnostics;
+using System.IO;
+
+namespace ZaipDesignLauncher
+{
+    internal static class Program
+    {
+        [STAThread]
+        private static int Main()
+        {
+            try
+            {
+                var workspaceRoot = ResolveWorkspaceRoot();
+                var nodePath = ResolveNodeExecutable();
+                if (workspaceRoot == null || nodePath == null)
+                {
+                    LogFailure("Could not find the ZAIP workspace or node.exe.");
+                    return 1;
+                }
+
+                var scriptPath = Path.Combine(
+                    workspaceRoot,
+                    ".agents",
+                    "design",
+                    "packages",
+                    "local-runtime",
+                    "start-design.mjs"
+                );
+                var startInfo = new ProcessStartInfo(nodePath, string.Format("\"{0}\"", scriptPath))
+                {
+                    WorkingDirectory = workspaceRoot,
+                    UseShellExecute = false,
+                    CreateNoWindow = true,
+                    WindowStyle = ProcessWindowStyle.Hidden,
+                };
+                var process = Process.Start(startInfo);
+                if (process == null)
+                {
+                    LogFailure("Failed to start the ZAIP design runtime.");
+                    return 1;
+                }
+                return 0;
+            }
+            catch (Exception exception)
+            {
+                LogFailure(string.Format("Unhandled launcher exception: {0}", exception));
+                return 1;
+            }
+        }
+
+        private static string ResolveNodeExecutable()
+        {
+            var path = Environment.GetEnvironmentVariable("PATH") ?? string.Empty;
+            foreach (var folder in path.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
+            {
+                try
+                {
+                    var candidate = Path.Combine(folder.Trim(), "node.exe");
+                    if (File.Exists(candidate)) return candidate;
+                }
+                catch
+                {
+                    // Ignore malformed PATH entries.
+                }
+            }
+            var fallback = Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles),
+                "nodejs",
+                "node.exe"
+            );
+            return File.Exists(fallback) ? fallback : null;
+        }
+
+        private static string ResolveWorkspaceRoot()
+        {
+            var current = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
+            while (current != null)
+            {
+                var script = Path.Combine(
+                    current.FullName,
+                    ".agents",
+                    "design",
+                    "packages",
+                    "local-runtime",
+                    "start-design.mjs"
+                );
+                if (File.Exists(script)) return current.FullName;
+                current = current.Parent;
+            }
+            return null;
+        }
+
+        private static void LogFailure(string message)
+        {
+            try
+            {
+                var path = Path.Combine(Path.GetTempPath(), "zaip-design-launcher.log");
+                File.AppendAllText(
+                    path,
+                    string.Format("[{0}] {1}{2}", DateTime.UtcNow.ToString("O"), message, Environment.NewLine)
+                );
+            }
+            catch
+            {
+                // Best-effort logging only.
+            }
+        }
+    }
+}

package/templates/.agents/design/packages/windows-launcher/build-design-launcher.ps1

@@ -0,0 +1,107 @@
+param(
+  [string]$OutputPath = ".agents/design/zaip-design.exe",
+  [string]$IconSourcePath = ".agents/config/src/icon_zaip.png"
+)
+
+$ErrorActionPreference = "Stop"
+$repoRoot = (Resolve-Path (Join-Path $PSScriptRoot "../../../..")).Path
+$sourcePath = Join-Path $PSScriptRoot "Program.cs"
+$targetPath = Join-Path $repoRoot $OutputPath
+$targetDirectory = Split-Path -Parent $targetPath
+$resolvedIconSourcePath = if ([IO.Path]::IsPathRooted($IconSourcePath)) {
+  $IconSourcePath
+} else {
+  Join-Path $repoRoot $IconSourcePath
+}
+
+if (-not (Test-Path $targetDirectory)) {
+  New-Item -ItemType Directory -Path $targetDirectory -Force | Out-Null
+}
+
+$compiler = @(
+  "C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe",
+  "C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe"
+) | Where-Object { Test-Path $_ } | Select-Object -First 1
+
+if (-not $compiler) {
+  throw "Nenhum compilador C# local encontrado para gerar o launcher Windows."
+}
+
+if (-not (Test-Path -LiteralPath $resolvedIconSourcePath -PathType Leaf)) {
+  throw "Fonte canonica do icone nao encontrada: $IconSourcePath"
+}
+
+function Convert-PngToIco {
+  param(
+    [Parameter(Mandatory = $true)][string]$PngPath,
+    [Parameter(Mandatory = $true)][string]$IcoPath
+  )
+
+  $png = [IO.File]::ReadAllBytes($PngPath)
+  $signature = [byte[]](137, 80, 78, 71, 13, 10, 26, 10)
+  if ($png.Length -lt 24) {
+    throw "Fonte de icone PNG invalida: $PngPath"
+  }
+  for ($index = 0; $index -lt $signature.Length; $index += 1) {
+    if ($png[$index] -ne $signature[$index]) {
+      throw "Fonte de icone PNG invalida: $PngPath"
+    }
+  }
+
+  $width = [uint32](
+    ($png[16] -shl 24) -bor ($png[17] -shl 16) -bor ($png[18] -shl 8) -bor $png[19]
+  )
+  $height = [uint32](
+    ($png[20] -shl 24) -bor ($png[21] -shl 16) -bor ($png[22] -shl 8) -bor $png[23]
+  )
+  if ($width -ne $height -or $width -lt 16 -or $width -gt 256) {
+    throw "O icone deve ser quadrado e medir entre 16 e 256 pixels: ${width}x${height}."
+  }
+
+  $dimension = if ($width -eq 256) { [byte]0 } else { [byte]$width }
+  $stream = [IO.File]::Create($IcoPath)
+  $writer = [IO.BinaryWriter]::new($stream)
+  try {
+    $writer.Write([uint16]0)
+    $writer.Write([uint16]1)
+    $writer.Write([uint16]1)
+    $writer.Write($dimension)
+    $writer.Write($dimension)
+    $writer.Write([byte]0)
+    $writer.Write([byte]0)
+    $writer.Write([uint16]1)
+    $writer.Write([uint16]32)
+    $writer.Write([uint32]$png.Length)
+    $writer.Write([uint32]22)
+    $writer.Write($png)
+  } finally {
+    $writer.Dispose()
+  }
+}
+
+$temporaryIconPath = $null
+try {
+  $extension = [IO.Path]::GetExtension($resolvedIconSourcePath).ToLowerInvariant()
+  if ($extension -eq ".ico") {
+    $compilerIconPath = $resolvedIconSourcePath
+  } elseif ($extension -eq ".png") {
+    $temporaryIconPath = Join-Path ([IO.Path]::GetTempPath()) (
+      "zaip-launcher-{0}.ico" -f [guid]::NewGuid().ToString("N")
+    )
+    Convert-PngToIco -PngPath $resolvedIconSourcePath -IcoPath $temporaryIconPath
+    $compilerIconPath = $temporaryIconPath
+  } else {
+    throw "A fonte do icone deve usar formato PNG ou ICO: $IconSourcePath"
+  }
+
+  & $compiler /nologo /target:winexe "/win32icon:$compilerIconPath" "/out:$targetPath" $sourcePath
+  if ($LASTEXITCODE -ne 0) {
+    throw "Falha ao compilar $OutputPath"
+  }
+} finally {
+  if ($temporaryIconPath -and (Test-Path -LiteralPath $temporaryIconPath)) {
+    Remove-Item -LiteralPath $temporaryIconPath -Force
+  }
+}
+
+Write-Output $targetPath

package/templates/.agents/design/tokens.json

@@ -0,0 +1,52 @@
+{
+  "schema_version": 1,
+  "name": "ZAIP",
+  "colors": {
+    "primary": "#00B0F0",
+    "primary-strong": "#018abb",
+    "primary-ink": "#006b91",
+    "secondary": "#0a0e17",
+    "surface": "#ffffff",
+    "surface-muted": "#f5f7fb",
+    "text": "#0f172a",
+    "text-muted": "#526176",
+    "border": "#dbe4ef",
+    "success": "#16a34a",
+    "success-ink": "#166534",
+    "warning": "#d97706",
+    "warning-ink": "#92400e",
+    "error": "#dc2626",
+    "error-ink": "#b91c1c",
+    "focus": "#00B0F0"
+  },
+  "dark": {
+    "surface": "#0a0e17",
+    "surface-muted": "#111827",
+    "text": "#f1f5f9",
+    "text-muted": "#94a3b8",
+    "border": "rgba(255,255,255,0.12)"
+  },
+  "neutral": {
+    "text-primary": "#0f172a",
+    "text-secondary": "#475569",
+    "text-muted": "#94a3b8",
+    "border": "#e2e8f0",
+    "surface-muted": "#f8fafc",
+    "canvas": "#f5f7fb",
+    "white": "#ffffff"
+  },
+  "rounded": {
+    "sm": "8px",
+    "md": "16px",
+    "lg": "24px",
+    "pill": "999px"
+  },
+  "spacing": {
+    "xs": "4px",
+    "sm": "8px",
+    "md": "16px",
+    "lg": "24px",
+    "xl": "40px",
+    "xxl": "64px"
+  }
+}

package/templates/.agents/requirements/autonomous-assurance.md

@@ -0,0 +1,63 @@
+---
+schema_version: 2
+id: REQUIREMENTS-AUTONOMOUS-ASSURANCE
+area: autonomous-assurance
+title: Garantia adaptativa e execução autônoma
+status: active
+version: 1
+source_change: null
+source_release: "1.0.1"
+---
+
+# Garantia adaptativa e execução autônoma
+
+## REQ-ASSURE-001 — Garantia proporcional para Tasks standalone
+
+Uma Task avulsa deve provar todos os Acceptance Criteria com profundidade proporcional ao risco, sem criar validação cerimonial.
+
+- `AC-ASSURE-001-01`: risco `lite` exige exatamente uma validação tipada aprovada e uma Evidence tipada aprovada; ambas podem cobrir vários ACs, mas a união precisa cobrir todos os ACs da Task.
+- `AC-ASSURE-001-02`: risco `standard` exige exatamente duas validações e duas Evidences no perfil base ou exatamente três de cada no perfil elevado; os artefatos usam modalidades distintas e incluem teste executado.
+- `AC-ASSURE-001-03`: `standard_depth: auto` seleciona o perfil elevado quando a Task possui mais de um write scope; `base` e `elevated` permitem configuração explícita.
+- `AC-ASSURE-001-04`: risco `critical` exige no mínimo três validações, Evidence dedicada por AC, teste, quality review independente, discriminação por mutação, rollback comprovado e artefatos frescos no commit final.
+- `AC-ASSURE-001-05`: uma Task sensível a segurança, migração, irreversibilidade ou múltiplos domínios não pode usar `lite` para contornar controles críticos.
+
+## REQ-ASSURE-002 — Garantia parental para SPEC e PRD
+
+Entregar uma SPEC ou PRD deve exigir prova no nível do produto planejado, além da soma dos testes das Tasks descendentes.
+
+- `AC-ASSURE-002-01`: SPEC e PRD exigem matriz completa de ACs, pelo menos três validações parentais e pelo menos três Evidences parentais aprovadas.
+- `AC-ASSURE-002-02`: SPEC exige integração, spec review e quality review; PRD exige cross-SPEC E2E, spec review e quality review.
+- `AC-ASSURE-002-03`: a revisão parental é feita por verificador diferente do autor e por Run diferente.
+- `AC-ASSURE-002-04`: todas as validações e Evidences parentais referenciam o commit final esperado; artefato de commit anterior não prova a entrega atual.
+- `AC-ASSURE-002-05`: PRD exige Evidence para cada outcome declarado, e descendants aprovados não substituem Evidence de integração ou outcome no nível parental.
+
+## REQ-AUTO-001 — Runtime autônomo opt-in e seguro
+
+O framework deve preservar execução manual como padrão e permitir autonomia somente por configuração explícita.
+
+- `AC-AUTO-001-01`: ausência de `execution` ou `execution.runtime: manual` materializa o trabalho sem invocar provider; `autonomous` exige provider, modelo, lease e paralelismo limitados.
+- `AC-AUTO-001-02`: o paralelismo efetivo é o menor limite entre projeto, plano, provider e squad; locks de DAG e write scopes continuam soberanos.
+- `AC-AUTO-001-03`: cada Task autônoma executa em Git worktree registrada, parte de raiz limpa, produz commit final, altera somente write scopes autorizados e aborta merge conflitante sem deixar merge parcial.
+- `AC-AUTO-001-04`: processos usam command allowlist, `shell: false`, diretório validado, ambiente mínimo allowlisted, limite de linha/stderr, timeout, cancelamento e budget de ferramentas/output.
+- `AC-AUTO-001-05`: checkpoints opacos de Codex ou Claude ficam somente em `.zaip-aios/local-data`, são retomáveis e removidos ao terminar; estado governado usa compare-and-swap.
+- `AC-AUTO-001-06`: Tasks `lite` têm uma tentativa; `standard` e `critical` têm no máximo três tentativas de desenvolvimento/reparo, sem loops ilimitados.
+- `AC-AUTO-001-07`: trabalho `critical` usa contexto fresco por Task e verificador independente; SPEC/PRD também exigem verificador independente mesmo quando suas Tasks são `lite`.
+
+## REQ-EVOL-001 — Delta, lições e maturidade derivada
+
+Aprendizado e alegações de maturidade devem ser derivados de fatos verificáveis do candidato atual.
+
+- `AC-EVOL-001-01`: rework recebe delta explícito de AC, write scopes, findings e baseline; contexto antigo não é copiado sem relevância observável.
+- `AC-EVOL-001-02`: lesson exige finding e locator verificável; opinião isolada não promove Rule, Requirement ou skill.
+- `AC-EVOL-001-03`: maturidade progride sequencialmente por `declared`, `implemented`, `locally_evidenced`, `cleanroom_validated`, `representative_validated` e `production_observed`.
+- `AC-EVOL-001-04`: Evidence de validação referencia o hash exato do candidato; cleanroom e estados posteriores exigem verificador independente, e produção exige Run observado.
+
+## REQ-QUALITY-001 — Gates de release e cobertura sem regressão
+
+O release deve falhar de modo discriminante quando código, distribuição ou evidência não atingirem o contrato publicado.
+
+- `AC-QUALITY-001-01`: release crítico inclui unit, E2E, arquitetura, CQRS, módulos, profile, segurança e testes negativos.
+- `AC-QUALITY-001-02`: cobertura usa baseline versionada e ratchet `max(piso, baseline anterior)` com pisos de 80% para lines/functions/statements e 75% para branches.
+- `AC-QUALITY-001-03`: baseline observada abaixo do piso pode ser registrada para transparência, mas não reduz o gate nem torna a release aprovada.
+- `AC-QUALITY-001-04`: release verifica paridade entre fonte canônica, template público e artefato distribuído, além de smoke/cleanroom sobre o candidato exato.
+