@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/skills/criar-pasta-obsidian/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: criar-pasta-obsidian
+description: Gere, atualize ou valide um vault Obsidian local e reconstruível com resumos e links de rastreabilidade ZAIP. Use quando for útil navegar Tasks e relações do lifecycle fora do dashboard, sem tornar o vault uma fonte canônica.
+---
+
+# Rastreabilidade Obsidian
+
+1. Ler `.agents/config/project.yaml`, a Rule core e o manifesto canônico `.agents/records/lifecycle/entity-snapshot.json`. Nunca varrer históricos normais nem gravar records canônicos.
+2. Gerar somente a projeção local resumida; ela contém IDs, estado, título, proveniência, relações e links para entidades presentes no lifecycle e nos artefatos formais permitidos (PRD, SPEC, Change, Task, Execution, Run, Decision, Evidence, Test, Check, Eval, Review, Requirement e Acceptance Criterion), nunca seus corpos completos:
+   `node .agents/skills/criar-pasta-obsidian/scripts/generate-obsidian-vault.mjs --task <TASK-ID>`
+3. As notas têm YAML Properties, locator canônico e arestas tipadas/direcionadas (`explicit` ou `derived`). Para consultas sem abrir o snapshot, use somente `zaip manifest neighbors|path|explain|gaps`, sempre com IDs e resultado limitado. O comando grava apenas em `.local/obsidian/vault/`, cria `.obsidian/` mínima, mantém hashes incrementais e remove somente arquivos que esse manifesto anterior listava.
+4. Validar uma projeção existente sem alterá-la:
+   `node .agents/skills/criar-pasta-obsidian/scripts/generate-obsidian-vault.mjs --check --task <TASK-ID>`
+5. Tratar o vault como opcional, local e descartável. Não instalar Obsidian, não adicionar configuração do aplicativo e não iniciar o aplicativo. Se a pessoa pedir explicitamente para abrir o diretório, informar o caminho gerado ou usar o abridor local autorizado pelo host.
+
+## Garantias
+
+- O snapshot do lifecycle e os artefatos formais referenciados continuam sendo fontes de verdade; as notas são índices derivados, não cópias. Categorias sem entidades não ganham notas vazias.
+- Reexecutar com a mesma entrada produz os mesmos arquivos; dados indisponíveis permanecem ausentes.
+- Parar e reportar se o snapshot não existir, for inválido, a Task pedida não estiver nele ou a saída sair de `.local/obsidian/vault/`.

package/templates/.agents/skills/criar-pasta-obsidian/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Criar pasta Obsidian"
+  short_description: "Gera e atualiza vault local do ZAIP"
+  default_prompt: "Use $criar-pasta-obsidian para gerar ou atualizar o vault local do lifecycle ZAIP."

package/templates/.agents/skills/criar-pasta-obsidian/scripts/generate-obsidian-vault.mjs

@@ -0,0 +1,414 @@
+import { createHash } from "node:crypto";
+import { mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { basename, relative, resolve, sep } from "node:path";
+
+const MAX_SOURCE_BYTES = 250_000;
+const TRACE_ID =
+  /\b(?:PRD|SPEC|CHG|TASK|EXEC|RUN|REQ|AC|EVD|EVIDENCE|TEST|CHECK|EVAL|REVIEW)-[A-Z0-9][A-Z0-9-]*\b/g;
+const VAULT_KINDS = [
+  ["prd", "PRDs", "#006b91", "#72f4fb"],
+  ["spec", "SPECs", "#075985", "#7dd3fc"],
+  ["change", "Changes", "#166534", "#86efac"],
+  ["task", "Tasks", "#006b91", "#72f4fb"],
+  ["execution", "Executions", "#92400e", "#fcd34d"],
+  ["run", "Runs", "#9d174d", "#f9a8d4"],
+  ["decision", "Decisions", "#5b21b6", "#c4b5fd"],
+  ["evidence", "Evidence", "#6d28d9", "#c4b5fd"],
+  ["test", "Tests", "#0f766e", "#5eead4"],
+  ["check", "Checks", "#0e7490", "#67e8f9"],
+  ["eval", "Evals", "#a16207", "#fde68a"],
+  ["review", "Reviews", "#be123c", "#fda4af"],
+  ["requirement", "Requirements", "#4338ca", "#a5b4fc"],
+  ["acceptance", "Acceptance-Criteria", "#9a3412", "#fdba74"],
+];
+const VAULT_KIND_BY_NAME = new Map(VAULT_KINDS.map(([kind, folder]) => [kind, folder]));
+
+const args = process.argv.slice(2);
+const check = args.includes("--check");
+const taskIndex = args.indexOf("--task");
+const taskId = taskIndex === -1 ? undefined : args[taskIndex + 1];
+if (taskIndex !== -1 && (!taskId || taskId.startsWith("--"))) fail("--task requires a TASK-ID");
+for (const arg of args) {
+  if (arg !== "--check" && arg !== "--task" && arg !== taskId) fail(`unknown argument: ${arg}`);
+}
+
+const root = resolve(process.cwd());
+const output = resolve(root, ".local/obsidian/vault");
+const snapshotPath = resolve(root, ".agents/records/lifecycle/entity-snapshot.json");
+if (!inside(resolve(root, ".local/obsidian/vault"), output)) {
+  fail("vault output must stay in .local/obsidian/vault");
+}
+
+let snapshot;
+try {
+  snapshot = JSON.parse(await readFile(snapshotPath, "utf8"));
+} catch (error) {
+  fail(`cannot read lifecycle snapshot: ${error instanceof Error ? error.message : String(error)}`);
+}
+
+const canonicalEntities = Object.values(snapshot.entities ?? {}).filter(isEntity);
+const supplementalEntities = await discoverSupplementalEntities();
+const entityMap = new Map();
+for (const entity of [...supplementalEntities, ...canonicalEntities])
+  entityMap.set(entity.id, entity);
+const entities = [...entityMap.values()];
+const tasks = entities.filter(
+  (entity) => entity.kind === "task" && (!taskId || entity.id === taskId),
+);
+if (taskId && tasks.length !== 1) fail(`task not found in lifecycle snapshot: ${taskId}`);
+
+const byId = new Map(entities.map((entity) => [entity.id, entity]));
+const selected = taskId
+  ? entities.filter(
+      (entity) =>
+        entity.id === taskId ||
+        tasks[0]?.relations?.includes(entity.id) ||
+        entity.relations?.includes(taskId),
+    )
+  : entities;
+const notes = new Map();
+for (const entity of selected) notes.set(portable(entity), "");
+for (const entity of selected) notes.set(portable(entity), renderEntity(entity, byId, notes));
+notes.set("00-Vault.md", renderIndex(tasks, snapshotPath, selected));
+notes.set(".obsidian/app.json", "{}\n");
+notes.set(
+  ".obsidian/appearance.json",
+  `${JSON.stringify({ enabledCssSnippets: ["zaip-vault"] }, null, 2)}\n`,
+);
+notes.set(".obsidian/snippets/zaip-vault.css", renderVaultCss());
+const manifest = {
+  schema_version: 1,
+  generator: "criar-pasta-obsidian",
+  files: [...notes.keys()].sort(),
+  content_hashes: Object.fromEntries(
+    [...notes.entries()]
+      .map(([path, content]) => [path, sha256(content)])
+      .sort(([a], [b]) => a.localeCompare(b)),
+  ),
+};
+notes.set("generated-manifest.json", `${JSON.stringify(manifest, null, 2)}\n`);
+
+if (check) {
+  for (const [portablePath, expected] of notes) {
+    const actual = await readOptional(resolve(output, portablePath));
+    if (actual !== expected) fail(`projection differs: ${portablePath}`);
+  }
+  process.stdout.write(`Validated ${notes.size} Obsidian projection files.\n`);
+} else {
+  const previous = await readManifest(resolve(output, "generated-manifest.json"));
+  for (const portablePath of previous.files) {
+    if (!notes.has(portablePath)) await rm(safeOutput(portablePath), { force: true });
+  }
+  for (const [portablePath, content] of notes) {
+    const destination = safeOutput(portablePath);
+    await mkdir(resolve(destination, ".."), { recursive: true });
+    if ((await readOptional(destination)) !== content)
+      await writeFile(destination, content, "utf8");
+  }
+  process.stdout.write(
+    `Generated ${notes.size} Obsidian projection files at .local/obsidian/vault.\n`,
+  );
+}
+
+function renderIndex(indexTasks, source, projectionEntities) {
+  const links = indexTasks.map((task) => `- [[Tasks/${task.id}|${task.id}]] — ${text(task.title)}`);
+  const counts = [
+    ...projectionEntities.reduce(
+      (result, entity) => result.set(entity.kind, (result.get(entity.kind) ?? 0) + 1),
+      new Map(),
+    ),
+  ]
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([kind, count]) => `- ${kind}: ${count}`);
+  const legend = VAULT_KINDS.map(
+    ([kind, folder]) => `- <span class="zaip-kind zaip-kind-${kind}">${kind}</span> \`${folder}/\``,
+  );
+  return `---\ncssclasses:\n  - zaip-vault-index\n---\n\n# ZAIP lifecycle projection\n\n> Local, optional and rebuildable. Source: \`${relative(root, source).replaceAll("\\", "/")}\`.\n\n## Legend\n\n${legend.join("\n")}\n\n## Coverage\n\n${counts.join("\n")}\n\n## Tasks\n\n${links.join("\n") || "No task selected."}\n`;
+}
+
+function renderEntity(entity, entityById, availableNotes) {
+  const edges =
+    entity.relation_edges ??
+    (entity.relations ?? []).map((target_id) => ({
+      target_id,
+      type: "references",
+      direction: "outbound",
+      provenance: "derived",
+      source_locator: null,
+    }));
+  const relations = edges.map((edge) => {
+    const related = entityById.get(edge.target_id);
+    const note = related ? portable(related).slice(0, -".md".length) : undefined;
+    const target =
+      note && availableNotes.has(`${note}.md`)
+        ? `[[${note}|${edge.target_id}]]`
+        : `\`${edge.target_id}\``;
+    return `${target} — ${edge.direction ?? "outbound"}/${edge.type ?? "references"}; ${edge.provenance ?? "derived"}${edge.source_locator ? `; locator: \`${edge.source_locator}\`` : ""}`;
+  });
+  const locator =
+    typeof entity.source_path === "string" ? entity.source_path : `lifecycle:${entity.id}`;
+  const properties = [
+    "---",
+    `id: ${yaml(entity.id)}`,
+    `kind: ${yaml(entity.kind)}`,
+    `status: ${yaml(entity.status ?? "unavailable")}`,
+    `canonical_locator: ${yaml(locator)}`,
+    "cssclasses:",
+    `  - zaip-kind-${cssToken(entity.kind)}`,
+    `  - zaip-folder-${cssToken(portable(entity).split("/")[0])}`,
+    "---",
+  ].join("\n");
+  const source = `\n- Canonical locator: \`${locator}\``;
+  const provenance =
+    typeof entity.provenance === "string" ? `\n- Provenance: \`${entity.provenance}\`` : "";
+  return `${properties}\n\n# ${text(entity.title ?? entity.id)}\n\n- ID: \`${entity.id}\`\n- Kind: \`${entity.kind}\`\n- Status: \`${entity.status ?? "unavailable"}\`\n- Updated: \`${entity.updated_at ?? "unavailable"}\`${source}${provenance}\n\n## Relations\n\n${relations.map((item) => `- ${item}`).join("\n") || "- None recorded."}\n`;
+}
+
+function renderVaultCss() {
+  const light = VAULT_KINDS.map(([kind, , color]) => `--zaip-${kind}: ${color};`).join(" ");
+  const dark = VAULT_KINDS.map(([kind, , , color]) => `--zaip-${kind}: ${color};`).join(" ");
+  const noteMarkers = VAULT_KINDS.map(
+    ([kind]) =>
+      `.zaip-kind-${kind}, .zaip-kind-${kind} .inline-title { color: var(--zaip-${kind}); }`,
+  ).join("\n");
+  const explorerMarkers = VAULT_KINDS.map(
+    ([kind, folder]) =>
+      `.workspace-leaf-content .nav-folder-title[data-path="${folder}"], .workspace-leaf-content .nav-file-title[data-path^="${folder}/"] { color: var(--zaip-${kind}); font-weight: 700; }`,
+  ).join("\n");
+  return `/* Local ZAIP vault markers; no plugin or external asset required. */
+:root { ${light} }
+.zaip-kind { display: inline-block; border: 1px solid currentColor; border-radius: 999px; padding: 0.1rem 0.45rem; font-size: 0.75rem; font-weight: 700; line-height: 1.3; }
+${noteMarkers}
+${explorerMarkers}
+@media (prefers-color-scheme: dark) { :root { ${dark} } }
+@media (prefers-reduced-motion: reduce) { .zaip-kind { transition: none; } }
+`;
+}
+
+function safeOutput(portablePath) {
+  const destination = resolve(output, portablePath);
+  if (!inside(output, destination)) fail(`unsafe generated path: ${portablePath}`);
+  return destination;
+}
+
+function portable(entity) {
+  return `${VAULT_KIND_BY_NAME.get(entity.kind) ?? "Entities"}/${entity.id}.md`;
+}
+
+async function discoverSupplementalEntities() {
+  const result = new Map();
+  for (const entity of await discoverRequirements()) result.set(entity.id, entity);
+  for (const entity of await discoverArtifacts()) result.set(entity.id, entity);
+  return [...result.values()];
+}
+
+async function discoverRequirements() {
+  const directory = resolve(root, ".agents/requirements");
+  const result = [];
+  for (const path of await filesUnder(directory)) {
+    if (!path.toLowerCase().endsWith(".md")) continue;
+    const content = await boundedText(path);
+    if (content === null) continue;
+    const sourcePath = relative(root, path).replaceAll("\\", "/");
+    let currentRequirement = null;
+    for (const line of content.split(/\r?\n/)) {
+      const requirementIds = [...line.matchAll(/\bREQ-[A-Z0-9][A-Z0-9-]*\b/g)].map(
+        (match) => match[0],
+      );
+      if (requirementIds[0]) currentRequirement = requirementIds[0];
+      for (const id of requirementIds) {
+        result.push(
+          supplementalEntity(id, "requirement", titleFromLine(line, id), [], sourcePath, content),
+        );
+      }
+      for (const match of line.matchAll(/\bAC-[A-Z0-9][A-Z0-9-]*\b/g)) {
+        const id = match[0];
+        result.push(
+          supplementalEntity(
+            id,
+            "acceptance",
+            titleFromLine(line, id),
+            currentRequirement === null ? [] : [currentRequirement],
+            sourcePath,
+            content,
+          ),
+        );
+      }
+    }
+  }
+  return result;
+}
+
+async function discoverArtifacts() {
+  const directories = [
+    resolve(root, ".agents/records/changes"),
+    resolve(root, ".agents/records/executions"),
+  ];
+  const result = [];
+  for (const directory of directories) {
+    for (const path of await filesUnder(directory)) {
+      const sourcePath = relative(root, path).replaceAll("\\", "/");
+      const match = /\/artifacts\/(evidence|tests|checks|evals|reviews)\//.exec(sourcePath);
+      if (match?.[1] === undefined) continue;
+      const kind = {
+        evidence: "evidence",
+        tests: "test",
+        checks: "check",
+        evals: "eval",
+        reviews: "review",
+      }[match[1]];
+      const content = await boundedText(path);
+      const fallbackId = basename(path).replace(/\.[^.]+$/, "");
+      const parsed = content === null ? null : jsonObject(content);
+      const id =
+        (typeof parsed?.id === "string" && parsed.id) ||
+        content?.match(/^id:\s*["']?([^\s"']+)/m)?.[1] ||
+        fallbackId;
+      if (!/^[A-Z][A-Z0-9-]+$/.test(id)) continue;
+      const relationSource = `${sourcePath}\n${content ?? ""}`;
+      const relations = [...new Set(relationSource.match(TRACE_ID) ?? [])].filter(
+        (candidate) => candidate !== id,
+      );
+      const heading = content?.match(/^#\s+(.+)$/m)?.[1]?.trim();
+      const status =
+        (typeof parsed?.status === "string" && parsed.status) ||
+        content?.match(/^status:\s*["']?([^\s"']+)/m)?.[1] ||
+        (typeof parsed?.report === "object" && parsed.report !== null && "passed" in parsed.report
+          ? parsed.report.passed === true
+            ? "passed"
+            : "failed"
+          : null);
+      result.push({
+        kind,
+        id,
+        title: heading ?? id,
+        status,
+        updated_at: firstTimestamp(content),
+        relations,
+        source_path: sourcePath,
+        provenance: "formal-artifact",
+      });
+    }
+  }
+  return result;
+}
+
+function supplementalEntity(id, kind, title, relations, sourcePath, content) {
+  return {
+    kind,
+    id,
+    title,
+    status: "recorded",
+    updated_at: firstTimestamp(content),
+    relations,
+    source_path: sourcePath,
+    provenance: "formal-requirement",
+  };
+}
+
+async function filesUnder(directory) {
+  try {
+    const entries = await readdir(directory, { recursive: true, withFileTypes: true });
+    return entries
+      .filter((entry) => entry.isFile())
+      .map((entry) => resolve(entry.parentPath, entry.name))
+      .sort();
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+}
+
+async function boundedText(path) {
+  const info = await stat(path);
+  if (info.size > MAX_SOURCE_BYTES) return null;
+  return readFile(path, "utf8");
+}
+
+function jsonObject(content) {
+  try {
+    const value = JSON.parse(content);
+    return value && typeof value === "object" ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function firstTimestamp(content) {
+  if (content === null || content === undefined) return null;
+  return (
+    content.match(/\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})\b/)?.[0] ??
+    null
+  );
+}
+
+function titleFromLine(line, id) {
+  return (
+    line
+      .replace(/^[-#*\s]+/, "")
+      .replace(id, "")
+      .replace(/^\s*[—:=-]+\s*/, "")
+      .trim() || id
+  );
+}
+
+async function readManifest(path) {
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    return Array.isArray(value.files) && value.files.every((file) => typeof file === "string")
+      ? value
+      : { files: [] };
+  } catch (error) {
+    if (error?.code === "ENOENT") return { files: [] };
+    fail(
+      `cannot read generated manifest: ${error instanceof Error ? error.message : String(error)}`,
+    );
+  }
+}
+
+async function readOptional(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return undefined;
+    throw error;
+  }
+}
+
+function inside(parent, candidate) {
+  const path = relative(parent, candidate);
+  return path === "" || (!path.startsWith("..") && !path.startsWith(`..${sep}`));
+}
+
+function isEntity(value) {
+  return (
+    value &&
+    typeof value === "object" &&
+    typeof value.id === "string" &&
+    typeof value.kind === "string"
+  );
+}
+
+function text(value) {
+  return String(value ?? "unavailable")
+    .replaceAll("\n", " ")
+    .replaceAll("\r", " ");
+}
+
+function yaml(value) {
+  return JSON.stringify(String(value ?? "unavailable"));
+}
+
+function cssToken(value) {
+  return String(value ?? "entity")
+    .toLowerCase()
+    .replaceAll(/[^a-z0-9-]/g, "-");
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+}

package/templates/.agents/skills/criar-pasta-obsidian/scripts/generate-obsidian-vault.test.mjs

@@ -0,0 +1,144 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+
+const root = await mkdtemp(resolve(tmpdir(), "zaip-obsidian-test-"));
+const records = resolve(root, ".agents/records/lifecycle");
+await mkdir(records, { recursive: true });
+await writeFile(
+  resolve(records, "entity-snapshot.json"),
+  JSON.stringify({
+    entities: {
+      "task:TASK-1": {
+        kind: "task",
+        id: "TASK-1",
+        title: "Task summary",
+        status: "completed",
+        updated_at: "2026-08-01T00:00:00Z",
+        relations: ["CHG-1"],
+        relation_edges: [
+          {
+            target_id: "CHG-1",
+            type: "references",
+            direction: "outbound",
+            provenance: "explicit",
+            source_locator: "record:TASK-1",
+          },
+        ],
+      },
+      "change:CHG-1": {
+        kind: "change",
+        id: "CHG-1",
+        title: "Change summary",
+        status: "completed",
+        updated_at: "2026-08-01T00:00:00Z",
+        relations: [],
+      },
+      "prd:PRD-1": {
+        kind: "prd",
+        id: "PRD-1",
+        title: "PRD summary",
+        status: "draft",
+        updated_at: "2026-08-01T00:00:00Z",
+        relations: [],
+      },
+    },
+  }),
+  "utf8",
+);
+await mkdir(resolve(root, ".agents/requirements"), { recursive: true });
+await writeFile(
+  resolve(root, ".agents/requirements/work.md"),
+  "# Work requirements\n\n## REQ-WORK-001 — Traceability\n\n- AC-WORK-001-09: Preserve evidence links.\n",
+  "utf8",
+);
+const artifacts = resolve(root, ".agents/records/changes/2026/08/CHG-1/artifacts");
+await mkdir(resolve(artifacts, "evidence"), { recursive: true });
+await mkdir(resolve(artifacts, "tests"), { recursive: true });
+await writeFile(
+  resolve(artifacts, "evidence/EVD-1.md"),
+  "---\nid: EVD-1\nstatus: approved\ntask_id: TASK-1\nacceptance_ids:\n  - AC-WORK-001-09\n---\n\n# Evidence summary\n",
+  "utf8",
+);
+await writeFile(
+  resolve(artifacts, "tests/TEST-1.md"),
+  "---\nid: TEST-1\nstatus: passed\ntask_id: TASK-1\n---\n\n# Test summary\n",
+  "utf8",
+);
+
+const script = resolve(import.meta.dirname, "generate-obsidian-vault.mjs");
+for (const scriptArgs of [[], [], ["--check"]]) {
+  const result = spawnSync(process.execPath, [script, ...scriptArgs], {
+    cwd: root,
+    encoding: "utf8",
+  });
+  assert.equal(result.status, 0, result.stderr);
+}
+
+const vault = resolve(root, ".local/obsidian/vault");
+const task = await readFile(resolve(vault, "Tasks/TASK-1.md"), "utf8");
+assert.match(task, /Task summary/);
+assert.match(task, /canonical_locator: "lifecycle:TASK-1"/);
+assert.match(task, /zaip-kind-task/);
+assert.match(task, /zaip-folder-tasks/);
+assert.match(task, /outbound\/references; explicit; locator: `record:TASK-1`/);
+assert.doesNotMatch(task, /entity-snapshot\.json.*\{\s*entities/s);
+assert.equal(await readFile(resolve(vault, ".obsidian/app.json"), "utf8"), "{}\n");
+assert.match(await readFile(resolve(vault, ".obsidian/appearance.json"), "utf8"), /zaip-vault/);
+const css = await readFile(resolve(vault, ".obsidian/snippets/zaip-vault.css"), "utf8");
+const index = await readFile(resolve(vault, "00-Vault.md"), "utf8");
+assert.match(css, /prefers-color-scheme: dark/);
+assert.match(index, /## Legend/);
+for (const [kind, folder] of [
+  ["prd", "PRDs"],
+  ["spec", "SPECs"],
+  ["change", "Changes"],
+  ["task", "Tasks"],
+  ["execution", "Executions"],
+  ["run", "Runs"],
+  ["decision", "Decisions"],
+  ["evidence", "Evidence"],
+  ["test", "Tests"],
+  ["check", "Checks"],
+  ["eval", "Evals"],
+  ["review", "Reviews"],
+  ["requirement", "Requirements"],
+  ["acceptance", "Acceptance-Criteria"],
+]) {
+  assert.match(css, new RegExp(`--zaip-${kind}:`));
+  assert.match(css, new RegExp(`data-path="${folder}"`));
+  assert.match(index, new RegExp(`zaip-kind-${kind}`));
+}
+assert.equal(
+  await readFile(
+    resolve(
+      process.cwd(),
+      ".agents/skills/criar-pasta-obsidian/scripts/generate-obsidian-vault.mjs",
+    ),
+    "utf8",
+  ),
+  await readFile(
+    resolve(
+      process.cwd(),
+      "public-cli/packages/cli/templates/.agents/skills/criar-pasta-obsidian/scripts/generate-obsidian-vault.mjs",
+    ),
+    "utf8",
+  ),
+);
+assert.match(await readFile(resolve(vault, "PRDs/PRD-1.md"), "utf8"), /PRD summary/);
+
+const evidence = await readFile(resolve(vault, "Evidence/EVD-1.md"), "utf8");
+assert.match(evidence, /Evidence summary/);
+assert.match(evidence, /\[\[Tasks\/TASK-1\|TASK-1\]\]/);
+assert.match(await readFile(resolve(vault, "Tests/TEST-1.md"), "utf8"), /Test summary/);
+assert.match(await readFile(resolve(vault, "generated-manifest.json"), "utf8"), /content_hashes/);
+assert.match(
+  await readFile(resolve(vault, "Requirements/REQ-WORK-001.md"), "utf8"),
+  /Traceability/,
+);
+assert.match(
+  await readFile(resolve(vault, "Acceptance-Criteria/AC-WORK-001-09.md"), "utf8"),
+  /\[\[Requirements\/REQ-WORK-001\|REQ-WORK-001\]\]/,
+);

package/templates/.agents/skills/zaip-aios/SKILL.md

@@ -1,9 +1,9 @@
-<!-- zaip-managed generated-do-not-edit source=discovery-skill version=1.0.0 sha256=75c2fcb5043d4a9d360caee0ca49dda016d4c7bad4eb2f86a5957dbe4429d7af -->
 ---
+# zaip-managed generated-do-not-edit source=discovery-skill version=1.0.0 sha256=72e09e90f33f9ed2543daf8dfc09ee5b10fca74d7fa077db030b8b048301d806
 name: zaip-aios
 description: Discover and apply the repository-local ZAIP-AIOS framework.
 ---
 
 # ZAIP-AIOS adapter
 
-Read `.agents/config/project.yaml` first. If `zaip.enabled` is `false`, do not apply the ZAIP workflow or load its context; only help with status, maintenance or explicit reactivation through `node .zaip-aios/bin/zaip.mjs enable`. If the field is `true` or absent, classify and capture the exact current turn before substantive work: question, read-only analysis, or uncertainty uses `conversation start --intent conversation`; answer, approval, continuation, refinement, or rework uses `--intent continue|refine|rework` and reuses same-thread focus; repository edits, independent outcomes, or an explicit new Task use `--intent new-work` with an AI-authored semantic `--title` of 4-10 words, `--short-name`, and synthesized `--objective`. Never copy or truncate the prompt into a title, and fall back to conversation when uncertain. Pure deploy, push, or publication is git-only. Then read `.agents/rules/zaip/core.md`, select only matching Rules, Requirements and skills, discover active work through local projections, then point-read lifecycle records by explicit ID. Capture is idempotent for an exact client turn. Do not scan `.agents/records/` or legacy `.agents/data/`. The framework lock is operational metadata, not prompt context.
+Read `.agents/config/project.yaml` first. Apply ZAIP only for literal boolean `zaip.enabled: true`; otherwise ignore it except maintenance or `zaip enable`. Read `.agents/rules/core.md`, then only matching `.agents/requirements/`, `.agents/rules/`, and `.agents/skills/`; discover via lifecycle manifests and explicit records only—never normal history. Root uses `zaip-agent-orchestrator`, which selects a capability-eligible executor captured with observed host metadata; after descendants and gates, `zaip-agent-finalizer` is last. Terminal outcome requires lifecycle/evidence/tests/manifest refresh; publication is Git-only.

package/templates/.agents/skills/zaip-aios/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "ZAIP-AIOS"
+  short_description: "Discover and apply repository-local ZAIP-AIOS."
+  default_prompt: "Use $zaip-aios to discover and apply this repository's ZAIP-AIOS framework safely."

package/templates/.agents/skills/zaip-skill-adapters/SKILL.md

@@ -7,7 +7,7 @@ description: Generate and verify Codex and Claude guidance adapters from canonic
 
 Um `.codex/config.toml` existente sem cabeçalho `zaip-managed` é um overlay local: `adapters build` deve preservá-lo e `adapters check` não deve reportá-lo como drift. Arquivos ausentes ou gerenciados continuam sujeitos à projeção canônica; nenhum outro adapter recebe essa exceção.
 
-1. Trate `.agents/config`, `rules/zaip`, `rules/project` e skills como fontes; `AGENTS.md`, `CLAUDE.md` e wrappers são projeções geradas mínimas.
+1. Trate `.agents/config`, `rules/` e skills como fontes; `AGENTS.md`, `CLAUDE.md` e wrappers são projeções geradas mínimas. A propriedade de cada Rule é definida pela presença no `framework.lock.yaml`.
 2. Oriente o agente a começar por `project.yaml` e Rules críticas, depois carregar trabalho, Requirements e skills relevantes sob demanda.
 3. Não instrua a carregar todo o histórico, Runs JSONL ou raízes V1 por padrão.
 4. Gere com cabeçalho managed, versão, checksum e allowlist determinísticos; execute `adapters build` e depois `adapters check`.

package/templates/.agents/skills/zaip-skill-backend/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: zaip-skill-backend
+description: Implement backend APIs, persistence, and integration boundaries inside declared scopes. Use for apps/backend or modules work that requires validated contracts and regression evidence.
+---
+
+# Entregar backend
+
+1. Confirmar contrato de entrada e saída, limites de persistência e dependências antes da alteração.
+2. Preservar a direção de dependências e manter detalhes de infraestrutura atrás da fronteira do módulo.
+3. Aplicar arquitetura e CQRS proporcionalmente ao contrato alterado: não introduzir camadas, migrações ou gates pesados quando a mudança local não os exige. Cobrir o comportamento alterado com testes focados e registrar incompatibilidades, migrações ou riscos de integração.

package/templates/.agents/skills/zaip-skill-backend/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "ZAIP Backend Delivery"
+  short_description: "Implement backend contracts and integrations safely."
+  default_prompt: "Use $zaip-skill-backend to implement a backend change with validated contracts."

package/templates/.agents/skills/zaip-skill-cloud-engineering/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: zaip-skill-cloud-engineering
+description: Design, provision, and validate infrastructure as code inside declared scopes. Use for Terraform, Docker, environment provisioning, or cloud observability changes with reversible rollout evidence.
+---
+
+# Engenharia de cloud
+
+1. Delimitar ambiente, recurso, provider, estado atual e rollback antes da mudança.
+2. Preferir infraestrutura declarativa e revisável; não aplicar deploy, credenciais ou mudança externa sem autorização explícita.
+3. Validar sintaxe, plano ou build aplicável e registrar impacto, dependências e caminho de reversão.

package/templates/.agents/skills/zaip-skill-cloud-engineering/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "ZAIP Cloud Engineering"
+  short_description: "Design and validate infrastructure as code safely."
+  default_prompt: "Use $zaip-skill-cloud-engineering to design and validate a declared infrastructure change."