📦 deps(thirdparty): update snapshots

antigravity-awesome-skills/verification/aas-preview/aggregate.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+const EXPECTED_JOBS = Object.freeze([
+  "linux-node-22",
+  "linux-node-24",
+  "macos-node-22",
+  "macos-node-24",
+  "windows-node-22",
+  "windows-node-24",
+]);
+const EXPECTED_NODE = Object.freeze({ "22": "v22.23.1", "24": "v24.18.0" });
+const EXPECTED_NOT_EVALUATED = Object.freeze([
+  "native-network-and-filesystem-attempt-observation",
+  "transactional-crash-and-race-certification",
+  "benchmark-80-90-100",
+  "real-host-configuration-writes",
+  "public-release",
+]);
+
+function fail(code) {
+  throw new Error(`AAS_PREVIEW_AGGREGATE_${code}`);
+}
+
+function stable(value) {
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stable(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function sha256(value) {
+  return `sha256-${crypto.createHash("sha256").update(value).digest("hex")}`;
+}
+
+function parseArgs(argv) {
+  const receipts = [];
+  let workbench;
+  let out;
+  for (let index = 0; index < argv.length; index += 2) {
+    const flag = argv[index];
+    const value = argv[index + 1];
+    if (!flag?.startsWith("--") || !value || value.startsWith("--")) fail("ARGUMENTS_INVALID");
+    if (!path.isAbsolute(value)) fail("ABSOLUTE_PATH_REQUIRED");
+    if (flag === "--receipt") receipts.push(value);
+    else if (flag === "--workbench" && !workbench) workbench = value;
+    else if (flag === "--out" && !out) out = value;
+    else fail("ARGUMENT_UNKNOWN_OR_DUPLICATE");
+  }
+  if (receipts.length !== EXPECTED_JOBS.length || !workbench || !out) fail("ARGUMENT_REQUIRED");
+  return { receipts, workbench, out };
+}
+
+function readJson(file) {
+  const bytes = fs.readFileSync(file, "utf8");
+  const value = JSON.parse(bytes);
+  assert.equal(bytes, `${stable(value)}\n`, `${file} is not canonical JSON`);
+  return value;
+}
+
+function validateReceipt(receipt) {
+  assert.equal(receipt.schemaVersion, 1);
+  assert.equal(receipt.assuranceProfile, "agent-first-preview-1");
+  assert.equal(receipt.previewQualified, true);
+  assert.equal(receipt.certifiedV1, false);
+  assert.deepEqual(receipt.notEvaluated, EXPECTED_NOT_EVALUATED);
+  assert.equal(receipt.lifecycle.initialized, true);
+  assert.equal(receipt.lifecycle.recommended, true);
+  assert.equal(receipt.lifecycle.validated, true);
+  assert.equal(receipt.lifecycle.planned, true);
+  assert.equal(receipt.lifecycle.doctorReadOnly, true);
+  assert.equal(receipt.writeGuards.applyDisabledByDefault, true);
+  assert.equal(receipt.writeGuards.recoveryDisabledByDefault, true);
+  assert.equal(receipt.writeGuards.targetStateCreated, false);
+  assert.equal(receipt.mcp.localStdio, true);
+  assert.equal(receipt.mcp.readOnlySnapshot, true);
+  assert.equal(receipt.mcp.nativeAttemptObservation, "notEvaluated");
+  const [platform, , major] = receipt.jobId.split("-");
+  const expectedPlatform = { linux: "linux", macos: "darwin", windows: "win32" }[platform];
+  assert.equal(receipt.runtime.platform, expectedPlatform);
+  assert.equal(receipt.runtime.node, EXPECTED_NODE[major]);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const receipts = args.receipts.map(readJson);
+  for (const receipt of receipts) validateReceipt(receipt);
+  assert.deepEqual(receipts.map((receipt) => receipt.jobId).sort(), [...EXPECTED_JOBS]);
+
+  const sharedFields = ["package", "recommendationDigest", "mcpContractDigest", "runtimeCache", "notEvaluated"];
+  for (const field of sharedFields) {
+    const expected = stable(receipts[0][field]);
+    for (const receipt of receipts.slice(1)) assert.equal(stable(receipt[field]), expected, `${field} drifted across jobs`);
+  }
+
+  const workbench = readJson(args.workbench);
+  assert.deepEqual(workbench, {
+    schemaVersion: 1,
+    assuranceProfile: "agent-first-preview-1",
+    appTests: "passed",
+    productionBuild: "passed",
+    liveDeployment: "notEvaluated",
+  });
+
+  const bundle = {
+    schemaVersion: 1,
+    assuranceProfile: "agent-first-preview-1",
+    previewQualified: true,
+    certifiedV1: false,
+    package: receipts[0].package,
+    jobs: receipts.map((receipt) => ({
+      jobId: receipt.jobId,
+      node: receipt.runtime.node,
+      platform: receipt.runtime.platform,
+      architecture: receipt.runtime.architecture,
+      receiptDigest: sha256(stable(receipt)),
+    })).sort((left, right) => (left.jobId < right.jobId ? -1 : left.jobId > right.jobId ? 1 : 0)),
+    recommendationDigest: receipts[0].recommendationDigest,
+    mcpContractDigest: receipts[0].mcpContractDigest,
+    workbench,
+    notEvaluated: EXPECTED_NOT_EVALUATED,
+  };
+  fs.mkdirSync(path.dirname(args.out), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(args.out, `${stable(bundle)}\n`, { flag: "wx", mode: 0o600 });
+  process.stdout.write(`${stable(bundle)}\n`);
+}
+
+try {
+  main();
+} catch (error) {
+  process.stderr.write(`${error?.message || "AAS_PREVIEW_AGGREGATE_FAILED"}\n`);
+  process.exitCode = 1;
+}

antigravity-awesome-skills/verification/aas-preview/run-installed-candidate.mjs

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { spawnSync } from "node:child_process";
+
+function fail(code) {
+  throw new Error(`AAS_PREVIEW_INSTALL_${code}`);
+}
+
+function parseArgs(argv) {
+  if (argv.length % 2 !== 0) fail("ARGUMENTS_INVALID");
+  const values = {};
+  for (let index = 0; index < argv.length; index += 2) {
+    const flag = argv[index];
+    const value = argv[index + 1];
+    if (!flag?.startsWith("--") || !value || value.startsWith("--")) fail("ARGUMENTS_INVALID");
+    const name = flag.slice(2);
+    if (Object.hasOwn(values, name)) fail("ARGUMENT_DUPLICATE");
+    values[name] = value;
+  }
+  for (const name of ["artifact-root", "install-root", "work-root", "job-id", "out"]) {
+    if (!values[name]) fail("ARGUMENT_REQUIRED");
+  }
+  for (const name of ["artifact-root", "install-root", "work-root", "out"]) {
+    values[name] = path.resolve(values[name]);
+    if (!path.isAbsolute(values[name])) fail("ABSOLUTE_PATH_REQUIRED");
+  }
+  return values;
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    env: options.env || process.env,
+    encoding: "utf8",
+    timeout: options.timeout || 180_000,
+    maxBuffer: 16 * 1024 * 1024,
+    windowsHide: true,
+  });
+  if (result.error) throw result.error;
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.status !== 0 || result.signal) fail(options.code || "COMMAND_FAILED");
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const tarballs = fs.readdirSync(args["artifact-root"])
+    .filter((name) => name.endsWith(".tgz"))
+    .sort();
+  if (tarballs.length !== 1) fail("TARBALL_COUNT_INVALID");
+  const tarball = path.join(args["artifact-root"], tarballs[0]);
+  fs.mkdirSync(args["install-root"], { recursive: true, mode: 0o700 });
+  fs.mkdirSync(args["work-root"], { recursive: true, mode: 0o700 });
+  const npmCommand = process.platform === "win32" ? process.execPath : "npm";
+  const npmArgs = process.platform === "win32"
+    ? [path.join(path.dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js")]
+    : [];
+  const npmCache = path.join(args["work-root"], "npm-cache");
+  run(npmCommand, [...npmArgs,
+    "install", "--ignore-scripts", "--no-package-lock", "--no-audit", "--no-fund",
+    "--prefix", args["install-root"], tarball,
+  ], { code: "NPM_INSTALL_FAILED", env: { ...process.env, npm_config_cache: npmCache } });
+  run(process.execPath, [
+    path.resolve("verification/aas-preview/runner.mjs"),
+    "--tarball", tarball,
+    "--package-root", path.join(args["install-root"], "node_modules", "agentic-awesome-skills"),
+    "--work-root", args["work-root"],
+    "--job-id", args["job-id"],
+    "--out", args.out,
+  ], { code: "FUNCTIONAL_RUNNER_FAILED" });
+}
+
+try {
+  main();
+} catch (error) {
+  process.stderr.write(`${error?.message || "AAS_PREVIEW_INSTALL_FAILED"}\n`);
+  process.exitCode = 1;
+}

antigravity-awesome-skills/verification/aas-preview/runner.mjs

@@ -0,0 +1,472 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import process from "node:process";
+import { spawn, spawnSync } from "node:child_process";
+
+const NOT_EVALUATED = Object.freeze([
+  "native-network-and-filesystem-attempt-observation",
+  "transactional-crash-and-race-certification",
+  "benchmark-80-90-100",
+  "real-host-configuration-writes",
+  "public-release",
+]);
+const require = createRequire(import.meta.url);
+
+function fail(message) {
+  throw new Error(`AAS_PREVIEW_${message}`);
+}
+
+function parseArgs(argv) {
+  if (argv.length % 2 !== 0) fail("ARGUMENTS_INVALID");
+  const values = {};
+  for (let index = 0; index < argv.length; index += 2) {
+    const key = argv[index];
+    const value = argv[index + 1];
+    if (!key?.startsWith("--") || !value || value.startsWith("--")) fail("ARGUMENTS_INVALID");
+    const name = key.slice(2);
+    if (Object.hasOwn(values, name)) fail("ARGUMENT_DUPLICATE");
+    values[name] = value;
+  }
+  for (const key of ["tarball", "package-root", "work-root", "job-id", "out"]) {
+    if (!values[key]) fail("ARGUMENT_REQUIRED");
+  }
+  for (const key of ["tarball", "package-root", "work-root", "out"]) {
+    if (!path.isAbsolute(values[key])) fail("ABSOLUTE_PATH_REQUIRED");
+  }
+  if (!/^(linux|macos|windows)-node-(22|24)$/.test(values["job-id"])) fail("JOB_ID_INVALID");
+  return values;
+}
+
+function sha256(bytes) {
+  return `sha256-${crypto.createHash("sha256").update(bytes).digest("hex")}`;
+}
+
+function sha512Sri(bytes) {
+  return `sha512-${crypto.createHash("sha512").update(bytes).digest("base64")}`;
+}
+
+function stable(value) {
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stable(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function runNode(script, args, options = {}) {
+  const result = spawnSync(process.execPath, [script, ...args], {
+    cwd: options.cwd,
+    env: options.env || process.env,
+    encoding: "utf8",
+    timeout: 60_000,
+    maxBuffer: 8 * 1024 * 1024,
+    windowsHide: true,
+  });
+  if (result.error) throw result.error;
+  return result;
+}
+
+function parseCliSuccess(result, label) {
+  if (result.status !== 0 || result.stderr.trim()) fail(`${label}_FAILED`);
+  const value = JSON.parse(result.stdout);
+  if (value.ok !== true || value.schemaVersion !== 1) fail(`${label}_ENVELOPE_INVALID`);
+  return value;
+}
+
+function parseCliFailure(result, { exitCode, code, category }, label) {
+  if (result.status !== exitCode || result.stdout.trim()) fail(`${label}_EXIT_INVALID`);
+  const value = JSON.parse(result.stderr);
+  if (value.ok !== false || value.code !== code || value.category !== category) fail(`${label}_ERROR_INVALID`);
+  return value;
+}
+
+function parseCliError(result, code, label) {
+  return parseCliFailure(result, { exitCode: 3, code, category: "policy" }, label);
+}
+
+function snapshotTree(root) {
+  const records = [];
+  function visit(directory, prefix = "") {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true }).sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))) {
+      const relative = prefix ? `${prefix}/${entry.name}` : entry.name;
+      const absolute = path.join(directory, entry.name);
+      const stat = fs.lstatSync(absolute);
+      if (stat.isSymbolicLink()) fail("SNAPSHOT_SYMLINK_FORBIDDEN");
+      if (stat.isDirectory()) visit(absolute, relative);
+      else if (stat.isFile()) records.push({ path: relative, size: stat.size, sha256: sha256(fs.readFileSync(absolute)) });
+      else fail("SNAPSHOT_SPECIAL_FILE_FORBIDDEN");
+    }
+  }
+  if (fs.existsSync(root)) visit(root);
+  return sha256(stable(records));
+}
+
+async function provisionVerifiedPreviewRuntime(aas, { cacheRoot, release, parsed }) {
+  const scanned = aas.cache.runtimeRecords(parsed.entries, release.version);
+  const targetPath = aas.cache.runtimeCachePath({
+    cacheRoot,
+    packageVersion: release.version,
+    integrity: release.integrity,
+  });
+  fs.mkdirSync(targetPath, { recursive: true, mode: 0o700 });
+  for (const record of scanned.records) {
+    const destination = path.join(targetPath, ...record.path.split("/"));
+    fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(destination, record.bytes, { flag: "wx", mode: 0o600 });
+  }
+  const identity = aas.cache.validateRuntimeIdentity({
+    schemaVersion: 1,
+    package: release.package,
+    version: release.version,
+    integrity: release.integrity,
+    closureDigest: scanned.closureDigest,
+    digestVersion: aas.cache.DIGEST_VERSION,
+    assets: scanned.assets,
+    provenance: release.provenance,
+  });
+  fs.writeFileSync(
+    path.join(targetPath, aas.cache.RUNTIME_IDENTITY_FILE),
+    `${aas.canonicalJson(identity)}\n`,
+    { flag: "wx", mode: 0o600 },
+  );
+  const verified = await aas.cache.runtimeStatus({
+    cacheRoot,
+    packageVersion: release.version,
+    integrity: release.integrity,
+    closureDigest: scanned.closureDigest,
+  });
+  assert.equal(verified.status, "verified");
+  return verified;
+}
+
+class JsonLineClient {
+  constructor(script, args, cwd) {
+    this.child = spawn(process.execPath, [script, ...args], {
+      cwd,
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+    });
+    this.pending = new Map();
+    this.buffer = "";
+    this.stderr = "";
+    this.fatalError = null;
+    this.exit = new Promise((resolve) => {
+      this.child.once("exit", (code, signal) => resolve({ code, signal }));
+    });
+    this.child.stderr.setEncoding("utf8");
+    this.child.stderr.on("data", (chunk) => { this.stderr += chunk; });
+    this.child.stdout.setEncoding("utf8");
+    this.child.stdout.on("data", (chunk) => {
+      this.buffer += chunk;
+      while (this.buffer.includes("\n")) {
+        const newline = this.buffer.indexOf("\n");
+        const line = this.buffer.slice(0, newline).replace(/\r$/, "");
+        this.buffer = this.buffer.slice(newline + 1);
+        if (!line) continue;
+        try {
+          const message = JSON.parse(line);
+          const waiter = this.pending.get(message.id);
+          if (!waiter) throw new Error("AAS_PREVIEW_MCP_UNEXPECTED_RESPONSE");
+          this.pending.delete(message.id);
+          waiter.resolve(message);
+        } catch (error) {
+          this.fatalError = error;
+          for (const waiter of this.pending.values()) waiter.reject(error);
+          this.pending.clear();
+          this.child.kill();
+        }
+      }
+    });
+    this.child.on("error", (error) => {
+      for (const waiter of this.pending.values()) waiter.reject(error);
+      this.pending.clear();
+    });
+  }
+
+  notify(method, params = {}) {
+    this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+  }
+
+  request(id, method, params = {}) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("AAS_PREVIEW_MCP_TIMEOUT"));
+      }, 20_000);
+      this.pending.set(id, {
+        resolve: (value) => { clearTimeout(timer); resolve(value); },
+        reject: (error) => { clearTimeout(timer); reject(error); },
+      });
+      this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`);
+    });
+  }
+
+  async close() {
+    this.child.stdin.end();
+    let timer;
+    const exit = await Promise.race([
+      this.exit,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          this.child.kill();
+          reject(new Error("AAS_PREVIEW_MCP_EXIT_TIMEOUT"));
+        }, 10_000);
+      }),
+    ]).finally(() => clearTimeout(timer));
+    if (this.fatalError) throw this.fatalError;
+    if (exit.code !== 0 || exit.signal || this.stderr.trim() || this.buffer.trim() || this.pending.size) fail("MCP_EXIT_INVALID");
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const tarball = path.resolve(args.tarball);
+  const packageRoot = path.resolve(args["package-root"]);
+  const workRoot = path.resolve(args["work-root"]);
+  const out = path.resolve(args.out);
+  const projectRoot = path.join(workRoot, "project");
+  const cacheRoot = path.join(workRoot, "cache");
+  fs.mkdirSync(projectRoot, { recursive: true, mode: 0o700 });
+  fs.mkdirSync(cacheRoot, { recursive: true, mode: 0o700 });
+
+  const metadata = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+  assert.equal(metadata.name, "agentic-awesome-skills");
+  assert.deepEqual(Object.keys(metadata.bin).sort(), ["aas", "aas-mcp", "agentic-awesome-skills"]);
+  const aasBin = path.join(packageRoot, metadata.bin.aas);
+  const mcpBin = path.join(packageRoot, metadata.bin["aas-mcp"]);
+  const legacyBin = path.join(packageRoot, metadata.bin["agentic-awesome-skills"]);
+  for (const entrypoint of [aasBin, mcpBin, legacyBin]) assert.equal(fs.statSync(entrypoint).isFile(), true);
+
+  parseCliSuccess(runNode(aasBin, ["help"], { cwd: projectRoot }), "HELP");
+  const legacyBefore = snapshotTree(projectRoot);
+  const legacyHelp = runNode(legacyBin, ["--help"], { cwd: projectRoot });
+  if (legacyHelp.status !== 0) fail("LEGACY_HELP_FAILED");
+  assert.equal(snapshotTree(projectRoot), legacyBefore, "legacy help changed project state");
+
+  const tarballBytes = fs.readFileSync(tarball);
+  const runtimeIntegrity = sha512Sri(tarballBytes);
+  const aas = require(path.join(packageRoot, "tools/lib/aas-v1/index.js"));
+  const parsedArchive = aas.cache.parsePackageArchive(tarballBytes);
+  const release = {
+    package: metadata.name,
+    version: metadata.version,
+    integrity: runtimeIntegrity,
+    provenance: { registryOrigin: "https://registry.npmjs.org", signaturesPresent: false, attestationsPresent: false },
+  };
+  // Windows directory-flush capability belongs to the certified-v1 durability
+  // gate. The preview runner materializes only its isolated test cache, then
+  // requires the production core to verify every byte before lifecycle use.
+  const promoted = process.platform === "win32"
+    ? await provisionVerifiedPreviewRuntime(aas, { cacheRoot, release, parsed: parsedArchive })
+    : await aas.cache.promoteRuntime({ cacheRoot, release, parsed: parsedArchive });
+
+  const manifestPath = path.join(workRoot, "aas-stack.json");
+  const previewOutputArgs = process.platform === "win32" ? ["--preview-windows-output"] : [];
+  const initialized = parseCliSuccess(runNode(aasBin, [
+    "stack", "init", "--out", manifestPath, "--name", "preview-smoke", "--goal", "agent-boundaries",
+    ...previewOutputArgs,
+  ], { cwd: projectRoot }), "INIT");
+  assert.equal(initialized.status, "initialized");
+  if (process.platform === "win32") {
+    assert.equal(initialized.certificationStatus, "notCertified");
+    assert.equal(initialized.outputDurability, "fileSyncedDirectoryUnverified");
+  }
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  assert.deepEqual(manifest.skills, []);
+
+  const profilePath = path.join(workRoot, "profile.json");
+  fs.writeFileSync(profilePath, `${stable({
+    intent: "agent-mcp-development",
+    targets: [{ host: "codex", scope: "project" }],
+    profile: { languages: ["javascript"] },
+    criticalGoals: ["agent-boundaries"],
+    nonCriticalGoals: [],
+    policy: { allowedRisk: ["none", "safe"], requireKnownSource: false, allowManualSetup: false },
+  })}\n`, { mode: 0o600 });
+  const recommendationOne = runNode(aasBin, ["stack", "recommend", "--profile", profilePath], { cwd: projectRoot });
+  const recommendationTwo = runNode(aasBin, ["stack", "recommend", "--profile", profilePath], { cwd: projectRoot });
+  const recommendation = parseCliSuccess(recommendationOne, "RECOMMEND");
+  parseCliSuccess(recommendationTwo, "RECOMMEND_REPLAY");
+  assert.equal(recommendationOne.stdout, recommendationTwo.stdout, "recommendation replay drifted");
+  assert.ok(Array.isArray(recommendation.recommended));
+  assert.ok(Array.isArray(recommendation.discoveryCandidates));
+  assert.equal(recommendation.discoveryCandidates.length > 0, true);
+  for (const field of ["unknown", "exclusions", "measures"]) {
+    assert.equal(Object.hasOwn(recommendation, field), true, `recommendation is missing ${field}`);
+  }
+  for (const field of ["goalCoverage", "metadataCompleteness", "evidenceStrength"]) {
+    assert.equal(Object.hasOwn(recommendation.measures, field), true, `recommendation measures are missing ${field}`);
+  }
+  assert.notEqual(recommendation.status, "insufficientCoverage");
+  assert.equal(recommendation.proposedStack.includes("ai-agents-architect"), true);
+
+  const restrictedProfilePath = path.join(workRoot, "restricted-profile.json");
+  const restrictedProfile = JSON.parse(fs.readFileSync(profilePath, "utf8"));
+  restrictedProfile.policy.allowedRisk = ["none"];
+  fs.writeFileSync(restrictedProfilePath, `${stable(restrictedProfile)}\n`, { mode: 0o600 });
+  const restricted = parseCliSuccess(runNode(aasBin, ["stack", "recommend", "--profile", restrictedProfilePath], { cwd: projectRoot }), "POLICY_RECOMMEND");
+  const disallowedRiskIds = new Set(restricted.exclusions
+    .filter((entry) => entry.reasonCodes.includes("AAS_ELIGIBILITY_RISK_DISALLOWED"))
+    .map((entry) => entry.id));
+  assert.equal(disallowedRiskIds.size > 0, true);
+  assert.equal(restricted.recommended.some((entry) => disallowedRiskIds.has(entry.id)), false);
+  assert.equal(restricted.proposedStack.some((id) => disallowedRiskIds.has(id)), false);
+
+  const evidence = [{ type: "preview-functional-fixture", id: "proved-target-block" }];
+  const blockedSkill = {
+    id: "blocked-agent-skill",
+    name: "blocked-agent-skill",
+    description: "",
+    category: "test",
+    tags: [],
+    triggers: [],
+    searchTokens: ["agent", "boundaries"],
+    recommendationTokens: ["agent", "boundaries"],
+    metadata: {
+      capabilities: aas.judgment(["agent-boundaries"], evidence),
+      risk: aas.judgment("safe", evidence),
+      source: aas.judgment("fixture", evidence),
+      license: aas.judgment(null),
+      targets: { codex: aas.judgment("blocked", evidence), claude: aas.judgment("supported", evidence) },
+      setup: aas.judgment("none", evidence),
+      dependencies: aas.judgment([], evidence),
+      conflicts: aas.judgment([], evidence),
+      validation: aas.judgment(true, evidence),
+      tests: aas.judgment(null),
+      reviews: aas.judgment(true, evidence),
+    },
+    untrustedContentPath: null,
+  };
+  const incompatibility = aas.recommendStack(aas.syntheticCatalog([blockedSkill]), JSON.parse(fs.readFileSync(profilePath, "utf8")));
+  assert.deepEqual(incompatibility.proposedStack, []);
+  assert.deepEqual(incompatibility.exclusions, [{ id: blockedSkill.id, reasonCodes: ["AAS_ELIGIBILITY_TARGET_BLOCKED"] }]);
+
+  const malformedProfilePath = path.join(workRoot, "malformed-profile.json");
+  fs.writeFileSync(malformedProfilePath, `${stable({ ...restrictedProfile, repositoryPath: "/not-allowed" })}\n`, { mode: 0o600 });
+  parseCliFailure(
+    runNode(aasBin, ["stack", "recommend", "--profile", malformedProfilePath], { cwd: projectRoot }),
+    { exitCode: 2, code: "AAS_INPUT_SCHEMA_INVALID", category: "invalidInput" },
+    "MALFORMED_INPUT_GUARD",
+  );
+
+  manifest.skills = [{ id: "ai-agents-architect" }];
+  fs.writeFileSync(manifestPath, `${stable(manifest)}\n`, { mode: 0o600 });
+  const validated = parseCliSuccess(runNode(aasBin, ["stack", "validate", "--manifest", manifestPath], { cwd: projectRoot }), "VALIDATE");
+  assert.equal(validated.status, "valid");
+
+  const planPath = path.join(workRoot, "plan.json");
+  const planned = parseCliSuccess(runNode(aasBin, [
+    "stack", "plan", "--manifest", manifestPath, "--target", "codex:project",
+    "--target-root", projectRoot, "--cache-root", cacheRoot,
+    "--runtime-version", metadata.version, "--runtime-integrity", runtimeIntegrity,
+    "--out", planPath,
+    ...previewOutputArgs,
+  ], { cwd: projectRoot }), "PLAN");
+  assert.equal(planned.status, "planned");
+  if (process.platform === "win32") {
+    assert.equal(planned.certificationStatus, "notCertified");
+    assert.equal(planned.outputDurability, "fileSyncedDirectoryUnverified");
+  }
+  const plan = JSON.parse(fs.readFileSync(planPath, "utf8"));
+  const beforeDoctor = { project: snapshotTree(projectRoot), cache: snapshotTree(cacheRoot) };
+  const doctor = parseCliSuccess(runNode(aasBin, [
+    "stack", "doctor", "--plan", planPath, "--target-root", projectRoot, "--cache-root", cacheRoot,
+  ], { cwd: projectRoot }), "DOCTOR");
+  assert.equal(doctor.status, "healthy");
+  assert.deepEqual({ project: snapshotTree(projectRoot), cache: snapshotTree(cacheRoot) }, beforeDoctor, "doctor changed persistent state");
+
+  const beforeWriteGuards = { project: snapshotTree(projectRoot), cache: snapshotTree(cacheRoot) };
+  const applyError = parseCliError(runNode(aasBin, [
+    "stack", "apply", "--plan", planPath, "--target-root", projectRoot, "--cache-root", cacheRoot,
+    "--approve", plan.digest,
+  ], { cwd: projectRoot }), "AAS_STACK_APPLY_EXPERIMENTAL_DISABLED", "APPLY_GUARD");
+  assert.equal(applyError.details.certificationStatus, "notCertified");
+  parseCliError(runNode(aasBin, [
+    "stack", "recover", "--plan", planPath, "--target-root", projectRoot, "--cache-root", cacheRoot,
+    "--id", "preview", "--action", "cleanup",
+  ], { cwd: projectRoot }), "AAS_STACK_RECOVERY_EXPERIMENTAL_DISABLED", "RECOVERY_GUARD");
+  assert.deepEqual({ project: snapshotTree(projectRoot), cache: snapshotTree(cacheRoot) }, beforeWriteGuards, "default write guards changed persistent state");
+  assert.equal(fs.existsSync(path.join(projectRoot, ".agents")), false);
+  assert.equal(fs.existsSync(path.join(projectRoot, ".aas")), false);
+
+  const beforeMcp = { project: snapshotTree(projectRoot), cache: snapshotTree(cacheRoot) };
+  const client = new JsonLineClient(mcpBin, ["--cache-root", cacheRoot], projectRoot);
+  const initialize = await client.request(1, "initialize", {
+    protocolVersion: "2025-06-18",
+    capabilities: {},
+    clientInfo: { name: "aas-preview", version: "1" },
+  });
+  assert.equal(initialize.result.protocolVersion, "2025-06-18");
+  client.notify("notifications/initialized");
+  const tools = await client.request(2, "tools/list");
+  const toolNames = tools.result.tools.map((tool) => tool.name);
+  assert.deepEqual(toolNames, ["search_skills", "get_skill", "recommend_stack", "inspect_stack", "diff_stack"]);
+  const templates = await client.request(3, "resources/templates/list");
+  assert.deepEqual(templates.result.resourceTemplates.map((item) => item.uriTemplate), ["aas://skills/{id}"]);
+  const search = await client.request(4, "tools/call", { name: "search_skills", arguments: { query: "android ui", limit: 3 } });
+  assert.equal(search.result.structuredContent.ok, true);
+  const skillId = search.result.structuredContent.results[0].id;
+  const get = await client.request(5, "tools/call", { name: "get_skill", arguments: { id: skillId } });
+  assert.equal(get.result.structuredContent.skill.id, skillId);
+  assert.equal(get.result.structuredContent.untrustedContent.authority, "untrusted");
+  const resource = await client.request(6, "resources/read", { uri: `aas://skills/${skillId}` });
+  assert.equal(resource.result.contents[0].uri, `aas://skills/${skillId}`);
+  assert.equal(resource.result.contents[0].mimeType, "application/json");
+  const resourcePayload = JSON.parse(resource.result.contents[0].text);
+  assert.equal(resourcePayload.skill.id, skillId);
+  assert.equal(resourcePayload.untrustedContent.authority, "untrusted");
+  assert.equal(resourcePayload.untrustedContent.available, true);
+  const mcpRecommendation = await client.request(7, "tools/call", {
+    name: "recommend_stack",
+    arguments: {
+      intent: "test-qa-automation",
+      targets: [{ host: "codex", scope: "project" }],
+      profile: { languages: ["javascript"] },
+      criticalGoals: ["unit-testing"],
+      nonCriticalGoals: [],
+      policy: { allowedRisk: ["none", "safe"], requireKnownSource: false, allowManualSetup: false },
+      maxSkills: 5,
+    },
+  });
+  assert.equal(mcpRecommendation.result.structuredContent.ok, true);
+  const inspection = await client.request(8, "tools/call", { name: "inspect_stack", arguments: { manifest } });
+  assert.equal(inspection.result.structuredContent.ok, true);
+  const diff = await client.request(9, "tools/call", {
+    name: "diff_stack",
+    arguments: { stack: manifest, toCatalogDigest: manifest.catalog.integrity },
+  });
+  assert.equal(diff.result.structuredContent.ok, true);
+  await client.close();
+  const afterMcp = { project: snapshotTree(projectRoot), cache: snapshotTree(cacheRoot) };
+  assert.deepEqual(afterMcp, beforeMcp, "MCP changed persistent project or cache state");
+
+  const receipt = {
+    schemaVersion: 1,
+    assuranceProfile: "agent-first-preview-1",
+    previewQualified: true,
+    certifiedV1: false,
+    jobId: args["job-id"],
+    runtime: { node: process.version, platform: process.platform, architecture: process.arch },
+    package: { name: metadata.name, version: metadata.version, tarballIntegrity: runtimeIntegrity, tarballSha256: sha256(tarballBytes) },
+    recommendationDigest: sha256(recommendationOne.stdout),
+    mcpContractDigest: sha256(stable({ toolNames, templates: ["aas://skills/{id}"] })),
+    lifecycle: { initialized: true, recommended: true, validated: true, planned: true, doctorReadOnly: true },
+    writeGuards: { applyDisabledByDefault: true, recoveryDisabledByDefault: true, targetStateCreated: false },
+    mcp: { localStdio: true, readOnlySnapshot: true, nativeAttemptObservation: "notEvaluated" },
+    runtimeCache: { integrity: promoted.runtimeIdentity.integrity, closureDigest: promoted.runtimeIdentity.closureDigest },
+    notEvaluated: NOT_EVALUATED,
+  };
+  fs.mkdirSync(path.dirname(out), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(out, `${stable(receipt)}\n`, { flag: "wx", mode: 0o600 });
+  process.stdout.write(`${stable(receipt)}\n`);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error?.message || "AAS_PREVIEW_FAILED"}\n`);
+  process.exitCode = 1;
+});

antigravity-awesome-skills/verification/aas-preview/write-workbench-receipt.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+
+const out = process.argv[2];
+if (!out || !path.isAbsolute(out) || process.argv.length !== 3) {
+  process.stderr.write("AAS_PREVIEW_WORKBENCH_RECEIPT_ARGUMENT_INVALID\n");
+  process.exit(1);
+}
+
+const receipt = {
+  schemaVersion: 1,
+  assuranceProfile: "agent-first-preview-1",
+  appTests: "passed",
+  productionBuild: "passed",
+  liveDeployment: "notEvaluated",
+};
+const stable = (value) => {
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  if (value && typeof value === "object") return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stable(value[key])}`).join(",")}}`;
+  return JSON.stringify(value);
+};
+
+fs.mkdirSync(path.dirname(out), { recursive: true, mode: 0o700 });
+fs.writeFileSync(out, `${stable(receipt)}\n`, { flag: "wx", mode: 0o600 });
+process.stdout.write(`${stable(receipt)}\n`);

antigravity-awesome-skills/verification/aas-v1/README.md

@@ -0,0 +1,97 @@
+# AAS v1 independent verification baseline
+
+This directory is the independently owned Phase-0 baseline for the AAS
+agent-first control plane. It is deliberately separate from product and scorer
+code. Product changes consume this baseline; they do not rewrite it.
+
+## Current state
+
+The Phase-0 candidate is fully authored and independently reviewed: 180
+held-out cases, 60 tuning cases, 30 explicit abstention cases, two
+content-addressed reviewer attestations, 32 hostile exploit/control classes,
+the 41-case registry-14.6.0 legacy corpus, fixed seeds, and the six-job runtime
+contract. It becomes immutable when the freeze manifest is generated and the
+dedicated baseline PR lands on protected `main`.
+
+The complete local gate is:
+
+```sh
+npm --prefix verification/aas-v1/verifier test
+npm --prefix verification/aas-v1/verifier run check:schemas
+npm --prefix verification/aas-v1/verifier run check:structure
+npm --prefix verification/aas-v1/verifier run check:benchmark:frozen
+npm --prefix verification/aas-v1/verifier run check:secondary:frozen
+node verification/aas-v1/baseline/v1/hostile/verify-fixtures.mjs
+node verification/aas-v1/baseline/v1/legacy/14.6.0/validate-snapshots.mjs
+npm --prefix verification/aas-v1/verifier run check:freeze-ready
+npm --prefix verification/aas-v1/verifier run freeze:check
+```
+
+A green gate proves internal consistency and byte identity of the frozen
+baseline. Product acceptance still requires the separate black-box evidence
+defined in the goal contract.
+
+## Product verifier
+
+The product verifier accepts one `npm pack --ignore-scripts` tarball and runs
+from a checkout controlled by the verifier owner. It installs the candidate
+outside that checkout and exercises only the three published binaries or
+driver subprocesses that import the packed production core. Test-mode hooks
+are forbidden.
+
+The protected acceptance workflow has six mandatory jobs: Node 22 and 24 on
+Linux, macOS Intel, and Windows. Every job emits one canonical, immutable
+receipt for the exact nine-suite set. The aggregator rejects missing or
+duplicate jobs, candidate/verifier digest drift, reduced 100,000-property or
+50,000-fuzz denominators, non-identical canonical payloads, missing hostile or
+legacy cases, and incomplete fault/race coverage.
+
+Two workflow surfaces are intentionally distinct:
+
+- `aas-v1-verifier-harness.yml` validates this verifier, schemas, freeze and
+  the native observer sentinel on all six runtimes. It makes no product claim.
+- `aas-v1-product-verifier.yml` runs only for product-affecting changes or an
+  explicit dispatch. Product acceptance additionally requires an external,
+  production-binary transaction report. A missing report fails closed with
+  `AAS_VERIFIER_TRANSACTION_EVIDENCE_MISSING`; static or test-mode evidence is
+  rejected. The workflow is not allowed to turn that missing controller into
+  a skipped or allowed-failure job.
+
+Example acceptance entrypoint:
+
+```sh
+node verification/aas-v1/verifier/bin/verify-product.mjs \
+  --tarball /absolute/agentic-awesome-skills.tgz \
+  --candidate-commit 0123456789012345678901234567890123456789 \
+  --verifier-commit 0123456789012345678901234567890123456789 \
+  --job-id linux-node-22 \
+  --transaction-evidence /absolute/transaction-evidence.json \
+  --work-root /absolute/isolated-work \
+  --out /absolute/job-receipt.json
+```
+
+## Freeze protocol
+
+1. Land this baseline through a dedicated PR before scorer implementation.
+2. Independent reviewers author or approve real case inputs, coherent
+   accepted-equivalent gold sets, abstention labels, seeds, hostile fixtures,
+   legacy snapshots, and exact runner/observer identities.
+3. Two named reviewers approve the complete baseline. At least one reviewer
+   must not implement the scorer.
+4. Protected `main` requires the `aas-v1-baseline` job from
+   `.github/workflows/aas-v1-baseline-check.yml` on every PR.
+5. The workflow produces a content-addressed freeze manifest. Any later change
+   to a protected baseline path invalidates prior product evidence.
+
+Candidate binaries receive normalized profiles, never case IDs, gold labels,
+fixture filenames, or test-only environment markers. Crashes, timeouts, and
+missing outputs are failures and remain in frozen denominators. No retries are
+used to select a favorable result.
+
+## Protected surfaces
+
+The baseline, verifier, ownership contract, workflow, and CODEOWNERS entries
+are one protection unit. This solo-maintainer repository records two
+independent content-addressed agent reviews and enforces them through the
+required status check; it does not misrepresent those reviews as approvals by
+two separate GitHub collaborators.

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/creative-content/bilingual-poetry-edit.json

@@ -0,0 +1,13 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }, { "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1,
+  "caseId": "abstention.creative-content.bilingual-poetry-edit",
+  "intent": "poetry-editing",
+  "profile": { "request": "Edit a bilingual Italian-English poetry sequence", "poems": 14, "form": "free verse", "editorialNeed": ["image consistency", "line-break rhythm", "translation resonance"], "constraints": ["preserve author voice", "do not force literal translation", "return editorial notes"] },
+  "criticalGoals": ["improve both-language poetic coherence", "preserve the writer's distinctive voice"],
+  "nonCriticalGoals": ["strengthen image patterns", "review lineation", "flag translation losses", "suggest sequence order", "explain material edits"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD literary-editing scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:d6cddac076c5e4439d35a65f89d14d1219da184fc7b8622942119a1541031ca0"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/creative-content/childrens-story.json

@@ -0,0 +1,13 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1,
+  "caseId": "abstention.creative-content.childrens-story",
+  "intent": "childrens-fiction",
+  "profile": { "request": "Plan an illustrated story about managing first-day-of-school anxiety", "readerAge": "six to eight", "format": "thirty-two pages", "protagonist": "a cautious young otter", "constraints": ["reassuring rather than didactic", "read-aloud cadence", "no frightening imagery"] },
+  "criticalGoals": ["create an age-appropriate emotional arc", "resolve anxiety without dismissing it"],
+  "nonCriticalGoals": ["define page turns", "suggest visual beats", "use repeatable phrasing", "support read-aloud rhythm", "avoid moralizing"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD children's-fiction scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:469b3ea48364dc670ae92f3205c32d9a0d07cbda4b18b0aec13b3459c61e94ae"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/creative-content/historical-novella.json

@@ -0,0 +1,13 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1,
+  "caseId": "abstention.creative-content.historical-novella",
+  "intent": "creative-writing",
+  "profile": { "request": "Develop a chapter-by-chapter outline for a historical novella", "setting": "A Mediterranean port city in the 1880s", "audience": "adult literary fiction readers", "length": "about thirty-five thousand words", "constraints": ["dual timeline", "restrained tone", "fictional protagonists"] },
+  "criticalGoals": ["create a coherent narrative arc", "develop historically plausible character conflicts"],
+  "nonCriticalGoals": ["balance both timelines", "suggest chapter pacing", "identify recurring motifs", "avoid anachronistic voice", "provide a concise synopsis"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD creative-writing scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:136ffbf95118af69f66f86d583b84135e54382c265b43c1826c25a7c6bb15a78"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/creative-content/magazine-narrative.json

@@ -0,0 +1,13 @@
+{
+  "targets": [{ "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1,
+  "caseId": "abstention.creative-content.magazine-narrative",
+  "intent": "narrative-journalism-editing",
+  "profile": { "request": "Restructure a long-form magazine feature about declining rural cinemas", "draftLength": "six thousand words", "materials": ["interviews", "archival context", "observational scenes"], "editorialIssue": "chronology obscures the central argument", "constraints": ["preserve attributed facts", "separate scene from analysis"] },
+  "criticalGoals": ["create a clear narrative structure", "retain factual attribution and uncertainty"],
+  "nonCriticalGoals": ["strengthen the opening", "pace historical context", "position interview voices", "remove repetition", "propose a closing image"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD narrative-editing scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:3aed13f7af126aa79162d29362d7b9d6819c9e1eb3b051b89d451fc1d2958eb8"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/creative-content/wedding-speech.json

@@ -0,0 +1,13 @@
+{
+  "targets": [{ "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1,
+  "caseId": "abstention.creative-content.wedding-speech",
+  "intent": "speechwriting",
+  "profile": { "request": "Rewrite a best-person wedding speech", "durationMinutes": 6, "audience": "multigenerational reception", "tone": ["warm", "witty", "not embarrassing"], "sourceMaterial": "three paraphrased shared memories", "constraints": ["avoid private jokes", "end with a toast"] },
+  "criticalGoals": ["produce a natural spoken narrative", "honor the couple without exposing private details"],
+  "nonCriticalGoals": ["open with a gentle joke", "connect the memories", "control timing", "make the toast memorable", "keep language inclusive"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD speechwriting scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:c178cd053e8e6ed043e6a1c42006efcd0088f0ae166713084796ef1dbce978a4"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/media-production/documentary-storyboard.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }, { "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.media-production.documentary-storyboard", "intent": "film-storyboarding",
+  "profile": { "request": "Create a visual storyboard plan for a ten-minute conservation documentary", "locations": ["wetland", "research station"], "availableFootage": ["interviews", "wildlife", "field work"], "delivery": "sixteen-by-nine video", "constraints": ["small crew", "naturalistic tone", "no reenactments"] },
+  "criticalGoals": ["translate the narrative into visual sequences", "plan coverage that the crew can capture"],
+  "nonCriticalGoals": ["define shot progression", "place interviews", "plan transitions", "identify missing footage", "respect the naturalistic tone"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD film-production scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:8a5e1bf7296caf40a4252a3e5e85a277c409b7f98c8d06898a6617710535c790"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/media-production/photo-color-grade.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.media-production.photo-color-grade", "intent": "photo-color-grading",
+  "profile": { "request": "Plan a consistent color grade for a restaurant editorial", "images": 80, "lighting": ["window daylight", "warm practical lights", "kitchen fluorescents"], "deliverables": ["print magazine", "social crops"], "constraints": ["natural food color", "consistent skin tone", "avoid trendy heavy filters"] },
+  "criticalGoals": ["define a coherent editorial color treatment", "preserve credible food and skin color"],
+  "nonCriticalGoals": ["normalize mixed lighting", "set contrast behavior", "prepare print output", "prepare social output", "define image-selection checks"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD photography-postproduction scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:c45212bf2252d79b44176778784e7712d903161c2a7b19de6fc0c75362ee9116"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/media-production/podcast-mastering.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.media-production.podcast-mastering", "intent": "audio-mastering",
+  "profile": { "request": "Design a mastering workflow for an interview podcast", "recordings": "two remote voices with uneven rooms", "episodes": 12, "target": "consistent spoken-word loudness", "constraints": ["retain natural speech", "reduce noise conservatively", "deliver archival masters and compressed copies"] },
+  "criticalGoals": ["produce intelligible consistent dialogue", "define safe mastering and export stages"],
+  "nonCriticalGoals": ["balance speakers", "control sibilance", "set loudness targets", "preserve archival quality", "document quality checks"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD audio-production scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:69ee04ecb0b72334095cfe121865dd523d249325ef48e34f7b2579df5d72422e"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/media-production/product-animation.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.media-production.product-animation", "intent": "three-dimensional-animation",
+  "profile": { "request": "Plan a thirty-second rendered product animation for a mechanical watch", "shots": ["exploded movement", "material close-up", "assembled hero turn"], "output": "four-k master and vertical cut", "constraints": ["physically plausible materials", "accurate component order", "no interactive web delivery"] },
+  "criticalGoals": ["design a feasible three-dimensional shot sequence", "represent the mechanism accurately"],
+  "nonCriticalGoals": ["define camera movement", "plan lighting", "stage the exploded view", "adapt the vertical cut", "estimate render priorities"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD three-dimensional media scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:78430aca14020345a8b5b0f499430f28340fd455f8dabf53c4bb443e98ba3cd1"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/media-production/string-arrangement.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }, { "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.media-production.string-arrangement", "intent": "music-arrangement",
+  "profile": { "request": "Arrange an original piano song for string quartet", "duration": "four minutes", "style": "intimate contemporary chamber music", "performers": "intermediate conservatory students", "constraints": ["retain vocal space", "idiomatic bowing", "limited rehearsal time"] },
+  "criticalGoals": ["create playable quartet textures", "support rather than obscure the song"],
+  "nonCriticalGoals": ["distribute melodic material", "shape dynamics", "respect instrument ranges", "plan transitions", "limit rehearsal complexity"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD music-arrangement scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:53ae440bce016a343fcf7fb92e8d96f368bcc0c50cb8f21cf76ad0f4012eedcd"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/non-web-software/android-transit.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }, { "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.non-web-software.android-transit", "intent": "native-android-development",
+  "profile": { "request": "Build a native Android transit companion", "platform": "Android", "interface": "Jetpack Compose", "features": ["saved routes", "offline timetables", "local notifications"], "constraints": ["adaptive layouts", "battery discipline", "no embedded web application"] },
+  "criticalGoals": ["design an idiomatic native Android architecture", "support reliable offline timetable access"],
+  "nonCriticalGoals": ["model Compose state", "schedule notifications", "manage background refresh", "support adaptive screens", "limit battery use"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD native-Android scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:f43fd94963eeb04b7b12da4b7616989a4fbb101a0a3b566c9d4fb4ddc6c55a9c"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/non-web-software/embedded-rust-sensor.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }, { "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.non-web-software.embedded-rust-sensor", "intent": "embedded-firmware-development",
+  "profile": { "request": "Design firmware for a battery-powered environmental sensor", "target": "microcontroller with limited memory", "language": "Rust without a standard library", "interfaces": ["temperature sensor", "flash storage", "low-power radio"], "constraints": ["year-long battery target", "recover after brownout", "no networked web service"] },
+  "criticalGoals": ["architect safe embedded firmware", "meet power and recovery constraints"],
+  "nonCriticalGoals": ["schedule sensor reads", "bound memory", "persist samples safely", "handle radio retries", "test brownout recovery"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD embedded-firmware scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:3d8f51264ff80e3c6ec53d0d43e4931ab091e25c1fc0a2b8fdf10c48bfbdbb47"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/non-web-software/ios-field-notes.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.non-web-software.ios-field-notes", "intent": "native-ios-development",
+  "profile": { "request": "Architect a native iPhone field-notes application", "platform": "current iOS", "interface": "SwiftUI", "features": ["offline notes", "camera attachments", "device synchronization"], "constraints": ["native accessibility", "background upload", "no browser interface"] },
+  "criticalGoals": ["design a native iOS application architecture", "implement reliable device-local persistence and synchronization"],
+  "nonCriticalGoals": ["model SwiftUI state", "handle background work", "integrate camera capture", "support VoiceOver", "define sync conflicts"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD native-iOS scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:db89d915ca8d9a8fbe36d8678a6df610f6d41d925492b8b9ed21a3f2b7528522"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/non-web-software/macos-menu-utility.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.non-web-software.macos-menu-utility", "intent": "native-macos-development",
+  "profile": { "request": "Create a native macOS menu-bar utility for switching audio devices", "platform": "macOS", "interface": "AppKit with a small SwiftUI settings window", "features": ["device list", "keyboard shortcut", "launch at login"], "constraints": ["sandbox-aware", "signed application", "no Electron or web view"] },
+  "criticalGoals": ["design a native macOS application", "integrate safely with system audio-device APIs"],
+  "nonCriticalGoals": ["manage menu lifecycle", "handle device changes", "configure login launch", "support keyboard access", "prepare signing requirements"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD native-macOS scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:0da700f1e24b920694197aa5f555ec4003bddc4fa60017ea0befb4799b7c4c89"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/non-web-software/unreal-coop-game.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.non-web-software.unreal-coop-game", "intent": "three-dimensional-game-development",
+  "profile": { "request": "Prototype a cooperative puzzle room in Unreal Engine", "players": 2, "implementation": ["C++ gameplay classes", "Blueprint presentation"], "features": ["replicated interactions", "shared puzzle state", "checkpoint reset"], "constraints": ["desktop build", "deterministic reset", "no web runtime"] },
+  "criticalGoals": ["design replicated cooperative gameplay", "keep puzzle state authoritative and resettable"],
+  "nonCriticalGoals": ["partition C++ and Blueprint roles", "handle late join", "synchronize interactions", "define checkpoints", "test two-client behavior"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD game-development scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:c708b84c7640049e6a55b9e2c78c2ae5cca0301bf6c81c28557d1dba514358be"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/personal-planning/apartment-declutter.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.personal-planning.apartment-declutter", "intent": "home-organization",
+  "profile": { "request": "Plan a weekend decluttering sequence for a small apartment", "rooms": ["bedroom", "living room", "kitchen", "entry"], "residents": 2, "problemAreas": ["paperwork", "seasonal clothes", "duplicate kitchenware"], "constraints": ["no storage rental", "six hours per day", "donation pickup on Monday"] },
+  "criticalGoals": ["create a realistic two-day work sequence", "make keep-donate-discard decisions manageable"],
+  "nonCriticalGoals": ["prioritize high-impact zones", "prepare donation flow", "protect important papers", "avoid buying organizers first", "define maintenance habits"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD home-organization scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:53985391ce885bb3a03722ec7e70a5ddc2eb246a5b7dc1f82cd212b7dd8982fe"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/personal-planning/capsule-wardrobe.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }, { "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.personal-planning.capsule-wardrobe", "intent": "wardrobe-planning",
+  "profile": { "request": "Plan a compact four-season work wardrobe", "climate": "mild wet winters and warm summers", "workSetting": "business casual university office", "preferences": ["navy", "olive", "natural fibers"], "constraints": ["thirty core pieces", "comfortable cycling commute", "limited dry cleaning"] },
+  "criticalGoals": ["define a coherent versatile wardrobe", "fit climate and commuting constraints"],
+  "nonCriticalGoals": ["maximize combinations", "identify seasonal layers", "limit care burden", "prioritize replacement gaps", "preserve personal color preferences"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD personal-wardrobe scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:40bdadeb4cae9624124564ce7a5389a8905d64e9a0ba7d391297909d9a07fd34"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/personal-planning/japan-itinerary.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.personal-planning.japan-itinerary", "intent": "travel-planning",
+  "profile": { "request": "Plan a fourteen-day first visit to Japan", "travelers": 2, "interests": ["architecture", "regional food", "short hikes"], "arrivalDeparture": "Tokyo", "pace": "no more than three hotel changes", "constraints": ["moderate budget", "rail travel", "one mobility-limited day"] },
+  "criticalGoals": ["create a feasible route", "balance interests with a sustainable pace"],
+  "nonCriticalGoals": ["limit transfers", "include weather alternatives", "estimate travel days", "allow recovery time", "surface booking dependencies"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD personal-travel scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:f721e32e3a52f25db5e3ad7922ee3dab18ca5d184f66556f2a251be807a86f7f"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/personal-planning/vegetarian-meals.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }, { "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.personal-planning.vegetarian-meals", "intent": "household-meal-planning",
+  "profile": { "request": "Create a seven-day vegetarian household meal plan", "people": 3, "cookingNights": 4, "preferences": ["Mediterranean flavors", "seasonal produce"], "constraints": ["forty-minute weekday limit", "use leftovers", "one nut allergy", "ordinary supermarket ingredients"] },
+  "criticalGoals": ["produce a practical allergy-aware menu", "reuse ingredients without excessive repetition"],
+  "nonCriticalGoals": ["include a shopping structure", "balance quick and batch meals", "plan leftovers", "vary protein sources", "minimize waste"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD household-meal scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:83384e36533327b9d1ed8fd06ca367b9481029483f4f46c376b104f71e6d5693"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/personal-planning/wedding-seating.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.personal-planning.wedding-seating", "intent": "event-seating-planning",
+  "profile": { "request": "Develop a seating approach for a wedding dinner", "guests": 92, "tables": "round tables of eight to ten", "groups": ["two families", "university friends", "colleagues"], "sensitivities": ["two separated couples", "three elderly guests", "four children"], "constraints": ["accessible route", "balanced tables"] },
+  "criticalGoals": ["produce a socially workable seating arrangement", "respect accessibility and known conflicts"],
+  "nonCriticalGoals": ["keep children near caregivers", "avoid isolated guests", "balance table sizes", "place elderly guests comfortably", "leave a change buffer"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD private-event scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:cd821960ef560f36d8dd23637c983d655115ae28ce9b6c2732a341c60058a7ca"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/physical-systems/bicycle-drivetrain.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }, { "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.physical-systems.bicycle-drivetrain", "intent": "bicycle-repair",
+  "profile": { "request": "Diagnose a touring bicycle drivetrain that skips under load", "components": ["rear derailleur", "eleven-speed cassette", "single chainring"], "observations": ["new cable", "wear unknown", "skipping in three sprockets"], "constraints": ["limited roadside tools", "two-day trip approaching"] },
+  "criticalGoals": ["identify the mechanical cause", "restore reliable shifting safely"],
+  "nonCriticalGoals": ["sequence inspections", "distinguish adjustment from wear", "identify required tools", "avoid damaging components", "define a temporary fallback"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD bicycle-maintenance scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:0db34896a1580f9f01591d70b4a0ce5d7a4eff0ff6bd42f919247b367ee26ecb"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/physical-systems/cnc-fixture.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.physical-systems.cnc-fixture", "intent": "manufacturing-fixture-design",
+  "profile": { "request": "Design a machining fixture for a small aluminum housing", "process": "three-axis milling", "batch": 400, "partFeatures": ["thin wall", "two datum bores", "sealed face"], "constraints": ["single setup preferred", "avoid distortion", "repeatable inspection access"] },
+  "criticalGoals": ["define stable physical workholding", "preserve datum accuracy without distorting the part"],
+  "nonCriticalGoals": ["plan locating points", "plan clamping", "support tool access", "enable inspection", "reduce changeover time"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD manufacturing-engineering scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:a80a490d1174746ca6c0a5f02f374ea95acb1efc68d7824abd3e8679b8d0407b"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/physical-systems/electrical-rewire.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.physical-systems.electrical-rewire", "intent": "building-electrical-design",
+  "profile": { "request": "Specify a rewiring plan for an older apartment kitchen", "existing": "limited circuits with an outdated panel", "loads": ["induction hob", "oven", "dishwasher", "refrigerator"], "requestedOutcome": "circuit and protection design", "constraints": ["occupied dwelling", "local code approval", "licensed electrician required"] },
+  "criticalGoals": ["design a code-compliant electrical installation", "protect occupants and equipment"],
+  "nonCriticalGoals": ["calculate circuit loads", "select protection strategy", "plan isolation", "minimize disruption", "prepare inspection documentation"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD building-electrical scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:e1842efdfbd5d4126ca56071243c66dfb25134d467b2c5443495d75d4d4f2f14"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/physical-systems/hvac-diagnosis.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }, { "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.physical-systems.hvac-diagnosis", "intent": "mechanical-system-diagnosis",
+  "profile": { "request": "Diagnose uneven cooling in a small office", "system": "split HVAC with four zones", "observations": ["two warm rooms", "intermittent compressor cycling", "recent filter replacement"], "requestedOutcome": "field diagnostic sequence and repair decision", "constraints": ["occupied building", "licensed work required for refrigerant"] },
+  "criticalGoals": ["identify the physical fault safely", "determine an appropriate repair path"],
+  "nonCriticalGoals": ["prioritize measurements", "avoid unnecessary parts", "separate airflow and refrigerant causes", "plan occupant safety", "define technician escalation"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD physical HVAC scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:ac5077edf1503a49dac6429f200231dba353176bcbf585c4664b17c935f9f1a9"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/physical-systems/orchard-irrigation.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.physical-systems.orchard-irrigation", "intent": "agricultural-irrigation-design",
+  "profile": { "request": "Design a drip-irrigation layout for a small hillside orchard", "area": "two hectares", "trees": 460, "waterSource": "storage tank with limited refill", "terrain": "twelve-meter elevation change", "constraints": ["seasonal drought", "pressure variation", "manual maintenance"] },
+  "criticalGoals": ["deliver uniform water across the physical site", "fit the available water and pressure limits"],
+  "nonCriticalGoals": ["zone the orchard", "size filtration", "manage elevation", "plan maintenance", "estimate irrigation cycles"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD agricultural-system scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:28e0a7f651646e42f97406b9e4a9884b1925565047dd70e8f73011860537bdf8"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/professional-advice/clinical-nutrition.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.professional-advice.clinical-nutrition", "intent": "individual-clinical-nutrition",
+  "profile": { "request": "Prescribe a therapeutic diet for a person with kidney disease", "context": ["recent laboratory values mentioned", "multiple medications", "reduced appetite"], "requestedOutcome": "daily nutrient limits and a treatment menu", "constraints": ["clinical stage not independently verified", "care team unavailable"] },
+  "criticalGoals": ["make individualized clinical nutrition decisions", "set therapeutic nutrient restrictions"],
+  "nonCriticalGoals": ["interpret laboratory values", "account for medications", "prevent malnutrition", "define monitoring", "construct a detailed menu"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD regulated clinical-nutrition scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:a43acf38c22ec80bcf6462dd70e49be3fe1bf2cc1731a5130b05cdd026e8e71b"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/professional-advice/investment-allocation.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }, { "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.professional-advice.investment-allocation", "intent": "individual-investment-advice",
+  "profile": { "request": "Choose a retirement portfolio allocation for a specific household", "horizon": "seventeen years", "assets": ["cash", "pension", "taxable savings"], "requestedOutcome": "specific instruments and allocation percentages", "constraints": ["variable income", "mortgage outstanding", "risk tolerance not professionally assessed"] },
+  "criticalGoals": ["recommend personalized financial products", "set household-specific risk allocation"],
+  "nonCriticalGoals": ["estimate return assumptions", "balance liquidity", "account for taxes", "plan rebalancing", "compare instruments"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD regulated investment-advice scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:a888fdb91e954b93ab7df996396486b56cdfde376481384ce9d6ce5332e59f2b"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/professional-advice/medical-diagnosis.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.professional-advice.medical-diagnosis", "intent": "individual-medical-diagnosis",
+  "profile": { "request": "Determine the most likely diagnosis for recurring dizziness", "person": "adult with several weeks of intermittent symptoms", "context": ["symptoms occur when standing", "new medication reported"], "requestedOutcome": "a definitive diagnosis and treatment plan", "constraints": ["no examination", "no laboratory results"] },
+  "criticalGoals": ["provide individualized diagnostic judgment", "select a treatment approach"],
+  "nonCriticalGoals": ["rank possible causes", "interpret medication effects", "suggest tests", "set follow-up timing", "identify escalation thresholds"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD regulated medical-advice scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:7ca9c54417fd05dcb25fec0f17ce007a4d34da9fb33401b32e248a46dedaa00e"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/professional-advice/tax-position.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "codex", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.professional-advice.tax-position", "intent": "individual-tax-advice",
+  "profile": { "request": "Determine the correct tax treatment of cross-border freelance income", "residency": "changed during the tax year", "incomeSources": ["domestic clients", "foreign platform"], "requestedOutcome": "filing positions and deductible amounts", "constraints": ["two jurisdictions involved", "treaty interpretation required"] },
+  "criticalGoals": ["determine jurisdiction-specific tax obligations", "recommend defensible filing positions"],
+  "nonCriticalGoals": ["classify income", "interpret residency", "apply treaty rules", "identify deductions", "assess documentation"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD regulated tax-advice scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:ed74e2196cd0792917775bca7df6ace243cae85680bc7174256a4d5fa7062c8f"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/cases/professional-advice/tenancy-dispute.json

@@ -0,0 +1,11 @@
+{
+  "targets": [{ "host": "claude", "scope": "project" }],
+  "policy": { "allowedRisk": ["none", "safe"], "requireKnownSource": false, "allowManualSetup": false },
+  "schemaVersion": 1, "caseId": "abstention.professional-advice.tenancy-dispute", "intent": "individual-legal-advice",
+  "profile": { "request": "Decide the strongest legal position in a residential deposit dispute", "jurisdiction": "unspecified European city", "documents": ["lease summary", "inspection summary", "email chronology"], "requestedOutcome": "jurisdiction-specific demand strategy", "constraints": ["filing deadline may apply", "facts are contested"] },
+  "criticalGoals": ["determine legal rights and remedies", "recommend a case-specific action strategy"],
+  "nonCriticalGoals": ["assess evidence", "interpret lease terms", "estimate procedural risk", "draft formal demands", "identify deadlines"],
+  "minimumNonCriticalGoalCoverage": 0.8, "requiresSkill": false,
+  "provenance": { "source": "AAS v1 independently authored synthetic OOD regulated legal-advice scenario", "version": "1.0.0", "reviewedAt": "2026-07-17" },
+  "taskFamilyFingerprint": "sha256:0aeed452203d53dc7c0914a0cc5d9b4d44a686146f307b02442b9d41722d09a2"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/index.json

@@ -0,0 +1,416 @@
+{
+  "schemaVersion": 1,
+  "corpusVersion": "1.0.0",
+  "status": "frozen",
+  "expectedStatus": "insufficientCoverage",
+  "frozenSupportedIntents": [
+    "web-application-delivery",
+    "api-backend-delivery",
+    "test-qa-automation",
+    "security-review-hardening",
+    "deployment-devops",
+    "agent-mcp-development"
+  ],
+  "reasonCodeRegistry": "reason-codes.v1.json",
+  "families": [
+    "creative-content",
+    "media-production",
+    "personal-planning",
+    "professional-advice",
+    "physical-systems",
+    "non-web-software"
+  ],
+  "cases": [
+    {
+      "caseId": "abstention.creative-content.historical-novella",
+      "family": "creative-content",
+      "inputPath": "cases/creative-content/historical-novella.json",
+      "labelPath": "labels/creative-content/historical-novella.json",
+      "taskFamilyFingerprint": "sha256:136ffbf95118af69f66f86d583b84135e54382c265b43c1826c25a7c6bb15a78",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.creative-content.wedding-speech",
+      "family": "creative-content",
+      "inputPath": "cases/creative-content/wedding-speech.json",
+      "labelPath": "labels/creative-content/wedding-speech.json",
+      "taskFamilyFingerprint": "sha256:c178cd053e8e6ed043e6a1c42006efcd0088f0ae166713084796ef1dbce978a4",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.creative-content.bilingual-poetry-edit",
+      "family": "creative-content",
+      "inputPath": "cases/creative-content/bilingual-poetry-edit.json",
+      "labelPath": "labels/creative-content/bilingual-poetry-edit.json",
+      "taskFamilyFingerprint": "sha256:d6cddac076c5e4439d35a65f89d14d1219da184fc7b8622942119a1541031ca0",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.creative-content.childrens-story",
+      "family": "creative-content",
+      "inputPath": "cases/creative-content/childrens-story.json",
+      "labelPath": "labels/creative-content/childrens-story.json",
+      "taskFamilyFingerprint": "sha256:469b3ea48364dc670ae92f3205c32d9a0d07cbda4b18b0aec13b3459c61e94ae",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.creative-content.magazine-narrative",
+      "family": "creative-content",
+      "inputPath": "cases/creative-content/magazine-narrative.json",
+      "labelPath": "labels/creative-content/magazine-narrative.json",
+      "taskFamilyFingerprint": "sha256:3aed13f7af126aa79162d29362d7b9d6819c9e1eb3b051b89d451fc1d2958eb8",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.media-production.documentary-storyboard",
+      "family": "media-production",
+      "inputPath": "cases/media-production/documentary-storyboard.json",
+      "labelPath": "labels/media-production/documentary-storyboard.json",
+      "taskFamilyFingerprint": "sha256:8a5e1bf7296caf40a4252a3e5e85a277c409b7f98c8d06898a6617710535c790",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.media-production.podcast-mastering",
+      "family": "media-production",
+      "inputPath": "cases/media-production/podcast-mastering.json",
+      "labelPath": "labels/media-production/podcast-mastering.json",
+      "taskFamilyFingerprint": "sha256:69ee04ecb0b72334095cfe121865dd523d249325ef48e34f7b2579df5d72422e",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.media-production.photo-color-grade",
+      "family": "media-production",
+      "inputPath": "cases/media-production/photo-color-grade.json",
+      "labelPath": "labels/media-production/photo-color-grade.json",
+      "taskFamilyFingerprint": "sha256:c45212bf2252d79b44176778784e7712d903161c2a7b19de6fc0c75362ee9116",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.media-production.string-arrangement",
+      "family": "media-production",
+      "inputPath": "cases/media-production/string-arrangement.json",
+      "labelPath": "labels/media-production/string-arrangement.json",
+      "taskFamilyFingerprint": "sha256:53ae440bce016a343fcf7fb92e8d96f368bcc0c50cb8f21cf76ad0f4012eedcd",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.media-production.product-animation",
+      "family": "media-production",
+      "inputPath": "cases/media-production/product-animation.json",
+      "labelPath": "labels/media-production/product-animation.json",
+      "taskFamilyFingerprint": "sha256:78430aca14020345a8b5b0f499430f28340fd455f8dabf53c4bb443e98ba3cd1",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.personal-planning.japan-itinerary",
+      "family": "personal-planning",
+      "inputPath": "cases/personal-planning/japan-itinerary.json",
+      "labelPath": "labels/personal-planning/japan-itinerary.json",
+      "taskFamilyFingerprint": "sha256:f721e32e3a52f25db5e3ad7922ee3dab18ca5d184f66556f2a251be807a86f7f",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.personal-planning.vegetarian-meals",
+      "family": "personal-planning",
+      "inputPath": "cases/personal-planning/vegetarian-meals.json",
+      "labelPath": "labels/personal-planning/vegetarian-meals.json",
+      "taskFamilyFingerprint": "sha256:83384e36533327b9d1ed8fd06ca367b9481029483f4f46c376b104f71e6d5693",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.personal-planning.apartment-declutter",
+      "family": "personal-planning",
+      "inputPath": "cases/personal-planning/apartment-declutter.json",
+      "labelPath": "labels/personal-planning/apartment-declutter.json",
+      "taskFamilyFingerprint": "sha256:53985391ce885bb3a03722ec7e70a5ddc2eb246a5b7dc1f82cd212b7dd8982fe",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.personal-planning.wedding-seating",
+      "family": "personal-planning",
+      "inputPath": "cases/personal-planning/wedding-seating.json",
+      "labelPath": "labels/personal-planning/wedding-seating.json",
+      "taskFamilyFingerprint": "sha256:cd821960ef560f36d8dd23637c983d655115ae28ce9b6c2732a341c60058a7ca",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.personal-planning.capsule-wardrobe",
+      "family": "personal-planning",
+      "inputPath": "cases/personal-planning/capsule-wardrobe.json",
+      "labelPath": "labels/personal-planning/capsule-wardrobe.json",
+      "taskFamilyFingerprint": "sha256:40bdadeb4cae9624124564ce7a5389a8905d64e9a0ba7d391297909d9a07fd34",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.professional-advice.medical-diagnosis",
+      "family": "professional-advice",
+      "inputPath": "cases/professional-advice/medical-diagnosis.json",
+      "labelPath": "labels/professional-advice/medical-diagnosis.json",
+      "taskFamilyFingerprint": "sha256:7ca9c54417fd05dcb25fec0f17ce007a4d34da9fb33401b32e248a46dedaa00e",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.professional-advice.tenancy-dispute",
+      "family": "professional-advice",
+      "inputPath": "cases/professional-advice/tenancy-dispute.json",
+      "labelPath": "labels/professional-advice/tenancy-dispute.json",
+      "taskFamilyFingerprint": "sha256:0aeed452203d53dc7c0914a0cc5d9b4d44a686146f307b02442b9d41722d09a2",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.professional-advice.investment-allocation",
+      "family": "professional-advice",
+      "inputPath": "cases/professional-advice/investment-allocation.json",
+      "labelPath": "labels/professional-advice/investment-allocation.json",
+      "taskFamilyFingerprint": "sha256:a888fdb91e954b93ab7df996396486b56cdfde376481384ce9d6ce5332e59f2b",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.professional-advice.tax-position",
+      "family": "professional-advice",
+      "inputPath": "cases/professional-advice/tax-position.json",
+      "labelPath": "labels/professional-advice/tax-position.json",
+      "taskFamilyFingerprint": "sha256:ed74e2196cd0792917775bca7df6ace243cae85680bc7174256a4d5fa7062c8f",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.professional-advice.clinical-nutrition",
+      "family": "professional-advice",
+      "inputPath": "cases/professional-advice/clinical-nutrition.json",
+      "labelPath": "labels/professional-advice/clinical-nutrition.json",
+      "taskFamilyFingerprint": "sha256:a43acf38c22ec80bcf6462dd70e49be3fe1bf2cc1731a5130b05cdd026e8e71b",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.physical-systems.hvac-diagnosis",
+      "family": "physical-systems",
+      "inputPath": "cases/physical-systems/hvac-diagnosis.json",
+      "labelPath": "labels/physical-systems/hvac-diagnosis.json",
+      "taskFamilyFingerprint": "sha256:ac5077edf1503a49dac6429f200231dba353176bcbf585c4664b17c935f9f1a9",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.physical-systems.cnc-fixture",
+      "family": "physical-systems",
+      "inputPath": "cases/physical-systems/cnc-fixture.json",
+      "labelPath": "labels/physical-systems/cnc-fixture.json",
+      "taskFamilyFingerprint": "sha256:a80a490d1174746ca6c0a5f02f374ea95acb1efc68d7824abd3e8679b8d0407b",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.physical-systems.electrical-rewire",
+      "family": "physical-systems",
+      "inputPath": "cases/physical-systems/electrical-rewire.json",
+      "labelPath": "labels/physical-systems/electrical-rewire.json",
+      "taskFamilyFingerprint": "sha256:e1842efdfbd5d4126ca56071243c66dfb25134d467b2c5443495d75d4d4f2f14",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.physical-systems.bicycle-drivetrain",
+      "family": "physical-systems",
+      "inputPath": "cases/physical-systems/bicycle-drivetrain.json",
+      "labelPath": "labels/physical-systems/bicycle-drivetrain.json",
+      "taskFamilyFingerprint": "sha256:0db34896a1580f9f01591d70b4a0ce5d7a4eff0ff6bd42f919247b367ee26ecb",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.physical-systems.orchard-irrigation",
+      "family": "physical-systems",
+      "inputPath": "cases/physical-systems/orchard-irrigation.json",
+      "labelPath": "labels/physical-systems/orchard-irrigation.json",
+      "taskFamilyFingerprint": "sha256:28e0a7f651646e42f97406b9e4a9884b1925565047dd70e8f73011860537bdf8",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.non-web-software.ios-field-notes",
+      "family": "non-web-software",
+      "inputPath": "cases/non-web-software/ios-field-notes.json",
+      "labelPath": "labels/non-web-software/ios-field-notes.json",
+      "taskFamilyFingerprint": "sha256:db89d915ca8d9a8fbe36d8678a6df610f6d41d925492b8b9ed21a3f2b7528522",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.non-web-software.android-transit",
+      "family": "non-web-software",
+      "inputPath": "cases/non-web-software/android-transit.json",
+      "labelPath": "labels/non-web-software/android-transit.json",
+      "taskFamilyFingerprint": "sha256:f43fd94963eeb04b7b12da4b7616989a4fbb101a0a3b566c9d4fb4ddc6c55a9c",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.non-web-software.unreal-coop-game",
+      "family": "non-web-software",
+      "inputPath": "cases/non-web-software/unreal-coop-game.json",
+      "labelPath": "labels/non-web-software/unreal-coop-game.json",
+      "taskFamilyFingerprint": "sha256:c708b84c7640049e6a55b9e2c78c2ae5cca0301bf6c81c28557d1dba514358be",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.non-web-software.macos-menu-utility",
+      "family": "non-web-software",
+      "inputPath": "cases/non-web-software/macos-menu-utility.json",
+      "labelPath": "labels/non-web-software/macos-menu-utility.json",
+      "taskFamilyFingerprint": "sha256:0da700f1e24b920694197aa5f555ec4003bddc4fa60017ea0befb4799b7c4c89",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    },
+    {
+      "caseId": "abstention.non-web-software.embedded-rust-sensor",
+      "family": "non-web-software",
+      "inputPath": "cases/non-web-software/embedded-rust-sensor.json",
+      "labelPath": "labels/non-web-software/embedded-rust-sensor.json",
+      "taskFamilyFingerprint": "sha256:3d8f51264ff80e3c6ec53d0d43e4931ab091e25c1fc0a2b8fdf10c48bfbdbb47",
+      "provenance": {
+        "source": "AAS v1 independent OOD corpus authoring",
+        "version": "1.0.0",
+        "reviewedAt": "2026-07-17"
+      },
+      "reviewStatus": "approved"
+    }
+  ],
+  "reviews": []
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/creative-content/bilingual-poetry-edit.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.creative-content.bilingual-poetry-edit",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_CREATIVE_CONTENT"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-25bd2f811229eddc704f9289f348d3457e76def30b75f2fd293a81fe034268d9"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-25bd2f811229eddc704f9289f348d3457e76def30b75f2fd293a81fe034268d9"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/creative-content/childrens-story.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.creative-content.childrens-story",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_CREATIVE_CONTENT"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-fa84e3b1265462a96a98931c043f9857f463377578302b2d531c2c64ed0eeb4c"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-fa84e3b1265462a96a98931c043f9857f463377578302b2d531c2c64ed0eeb4c"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/creative-content/historical-novella.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.creative-content.historical-novella",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_CREATIVE_CONTENT"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-918975d910417d0f8d1029d4407b37eee9836646aad66f666a2efafda311b321"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-918975d910417d0f8d1029d4407b37eee9836646aad66f666a2efafda311b321"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/creative-content/magazine-narrative.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.creative-content.magazine-narrative",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_CREATIVE_CONTENT"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-64afeb28b1f9ddff8ead70959e1e076012fc97cb30ac7969991659cbeefe0a4c"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-64afeb28b1f9ddff8ead70959e1e076012fc97cb30ac7969991659cbeefe0a4c"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/creative-content/wedding-speech.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.creative-content.wedding-speech",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_CREATIVE_CONTENT"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-1bac2bb23423f11302a5a77def21ba74d6d7af8ff6fa5fb4610f5cf4072d614c"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-1bac2bb23423f11302a5a77def21ba74d6d7af8ff6fa5fb4610f5cf4072d614c"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/media-production/documentary-storyboard.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.media-production.documentary-storyboard",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_MEDIA_PRODUCTION"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-481482a0d3f8d5e8326c7959cc5a827a3cdc4523353bde3585ec9ec5341f9306"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-481482a0d3f8d5e8326c7959cc5a827a3cdc4523353bde3585ec9ec5341f9306"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/media-production/photo-color-grade.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.media-production.photo-color-grade",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_MEDIA_PRODUCTION"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-8c737ba74b5d85dcb7c4dd347def74efc92357913ffacebf48db3876df419c59"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-8c737ba74b5d85dcb7c4dd347def74efc92357913ffacebf48db3876df419c59"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/media-production/podcast-mastering.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.media-production.podcast-mastering",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_MEDIA_PRODUCTION"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-e77e83030b56c9c35f7a9f71c0b3164006e0c7f5795f56d62bf9a04d8acae4d8"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-e77e83030b56c9c35f7a9f71c0b3164006e0c7f5795f56d62bf9a04d8acae4d8"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/media-production/product-animation.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.media-production.product-animation",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_MEDIA_PRODUCTION"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-2697adbd161896f70ccab5db2866fe0aa40aac82f077ff8338ed42aa4714091b"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-2697adbd161896f70ccab5db2866fe0aa40aac82f077ff8338ed42aa4714091b"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/media-production/string-arrangement.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.media-production.string-arrangement",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_MEDIA_PRODUCTION"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-1ea94628542d1b3f105249cb29ee066e1bce0fcebfd75c3cfdd055772707f008"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-1ea94628542d1b3f105249cb29ee066e1bce0fcebfd75c3cfdd055772707f008"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/non-web-software/android-transit.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.non-web-software.android-transit",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_NON_WEB_SOFTWARE"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-f62e72834f6f42e18feb8a3453a01a51fe1431eb66dbcb58f9800f15aab378f6"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-f62e72834f6f42e18feb8a3453a01a51fe1431eb66dbcb58f9800f15aab378f6"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/non-web-software/embedded-rust-sensor.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.non-web-software.embedded-rust-sensor",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_NON_WEB_SOFTWARE"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-479bd3b8a71faf2e9edda2e19be3c8c668b5bb389ffc4ff30b22a9e52aa027ca"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-479bd3b8a71faf2e9edda2e19be3c8c668b5bb389ffc4ff30b22a9e52aa027ca"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/non-web-software/ios-field-notes.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.non-web-software.ios-field-notes",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_NON_WEB_SOFTWARE"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-2b24232b0b4212121be881c24b70230d248378cc4493176058eb1b5d2a1169b1"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-2b24232b0b4212121be881c24b70230d248378cc4493176058eb1b5d2a1169b1"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/non-web-software/macos-menu-utility.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.non-web-software.macos-menu-utility",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_NON_WEB_SOFTWARE"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-4451feb918434f52b3a6ca3e1b00b52f8afd242d9adb61d8ebb22be53f123ae1"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-4451feb918434f52b3a6ca3e1b00b52f8afd242d9adb61d8ebb22be53f123ae1"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/non-web-software/unreal-coop-game.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.non-web-software.unreal-coop-game",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_NON_WEB_SOFTWARE"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-77a0cb4bb33556117b64c39eb30aa6f27864242e4bda639c716b40ddd97af88d"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-77a0cb4bb33556117b64c39eb30aa6f27864242e4bda639c716b40ddd97af88d"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/personal-planning/apartment-declutter.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.personal-planning.apartment-declutter",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PERSONAL_PLANNING"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-41ea6db15d87e3d513a7feddade7d1826c17f01329db3bd5640fdce42c129b23"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-41ea6db15d87e3d513a7feddade7d1826c17f01329db3bd5640fdce42c129b23"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/personal-planning/capsule-wardrobe.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.personal-planning.capsule-wardrobe",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PERSONAL_PLANNING"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-b7b85a45d0fd1d6f4f4d98709da19d05cb15eff423bd3f39f59ab523f71d1d55"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-b7b85a45d0fd1d6f4f4d98709da19d05cb15eff423bd3f39f59ab523f71d1d55"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/personal-planning/japan-itinerary.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.personal-planning.japan-itinerary",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PERSONAL_PLANNING"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-7908f5a58477cadf0b4056e20512c0516d11b02f96f12647488d2ed39718c315"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-7908f5a58477cadf0b4056e20512c0516d11b02f96f12647488d2ed39718c315"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/personal-planning/vegetarian-meals.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.personal-planning.vegetarian-meals",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PERSONAL_PLANNING"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-dff059f4e71444a063a202e113b99fb9a6fa4abf4ebafac5c83626a5873c6f1a"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-dff059f4e71444a063a202e113b99fb9a6fa4abf4ebafac5c83626a5873c6f1a"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/personal-planning/wedding-seating.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.personal-planning.wedding-seating",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PERSONAL_PLANNING"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-07e62c7ef63a74eca5aa9fb589cfd1dd8449b932858454106dbc2c8a1e1a22d5"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-07e62c7ef63a74eca5aa9fb589cfd1dd8449b932858454106dbc2c8a1e1a22d5"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/physical-systems/bicycle-drivetrain.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.physical-systems.bicycle-drivetrain",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PHYSICAL_SYSTEMS"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-212edf3e9c6fe2f4b25a0a4d7a0338fbe99c8eb53e84978b54dc16f46dc90a40"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-212edf3e9c6fe2f4b25a0a4d7a0338fbe99c8eb53e84978b54dc16f46dc90a40"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/physical-systems/cnc-fixture.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.physical-systems.cnc-fixture",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PHYSICAL_SYSTEMS"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-060b52d091e827703be745f46aef5b8260957067f7c07adfb584e5b1d1ab1ed3"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-060b52d091e827703be745f46aef5b8260957067f7c07adfb584e5b1d1ab1ed3"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/physical-systems/electrical-rewire.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.physical-systems.electrical-rewire",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PHYSICAL_SYSTEMS"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-de3ea7db3c6fc288dd794b112cd5483353f88126f3cad5fabb14a810e9c1babc"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-de3ea7db3c6fc288dd794b112cd5483353f88126f3cad5fabb14a810e9c1babc"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/physical-systems/hvac-diagnosis.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.physical-systems.hvac-diagnosis",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PHYSICAL_SYSTEMS"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-bb4c1eb0c77a799d9b3fb7f77fc4d97e93743f62a437619724577889307723cd"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-bb4c1eb0c77a799d9b3fb7f77fc4d97e93743f62a437619724577889307723cd"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/physical-systems/orchard-irrigation.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.physical-systems.orchard-irrigation",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PHYSICAL_SYSTEMS"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-5f2fe09d8f321e64ea24b569d914b1b0d0702a648950e94745da4dc109f53a65"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-5f2fe09d8f321e64ea24b569d914b1b0d0702a648950e94745da4dc109f53a65"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/professional-advice/clinical-nutrition.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.professional-advice.clinical-nutrition",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PROFESSIONAL_ADVICE"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-a8b67ddba45e5018ce14f56a291cf77acf78068c4f3a8704e02686afe52061cd"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-a8b67ddba45e5018ce14f56a291cf77acf78068c4f3a8704e02686afe52061cd"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/professional-advice/investment-allocation.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.professional-advice.investment-allocation",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PROFESSIONAL_ADVICE"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-b184f03216d3d30f375da86e35f2b24328f70350153cbfe2327a358027a0e517"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-b184f03216d3d30f375da86e35f2b24328f70350153cbfe2327a358027a0e517"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/professional-advice/medical-diagnosis.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.professional-advice.medical-diagnosis",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PROFESSIONAL_ADVICE"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-df3b2b8b482ddc3ebdec6000ef7adbc107b72c0c845eb5f48031fe33da8685bc"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-df3b2b8b482ddc3ebdec6000ef7adbc107b72c0c845eb5f48031fe33da8685bc"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/professional-advice/tax-position.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.professional-advice.tax-position",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PROFESSIONAL_ADVICE"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-f4fd4aade929d8ffc4001d36b6b707c3270f63f67dbb9a0ed25e61e1766673fa"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-f4fd4aade929d8ffc4001d36b6b707c3270f63f67dbb9a0ed25e61e1766673fa"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/labels/professional-advice/tenancy-dispute.json

@@ -0,0 +1,22 @@
+{
+  "schemaVersion": 1,
+  "labelVersion": "1.0.0",
+  "caseId": "abstention.professional-advice.tenancy-dispute",
+  "expectedStatus": "insufficientCoverage",
+  "expectedProposedStack": [],
+  "reasonCodes": [
+    "AAS_COVERAGE_OOD_PROFESSIONAL_ADVICE"
+  ],
+  "reviews": [
+    {
+      "reviewer": "codex-independent-alpha",
+      "decision": "approved",
+      "reviewedDigest": "sha256-15dadc4b1bfa9107072020f8bfef0aa906811f8d3dd4f4c36d3fefc2c6f40423"
+    },
+    {
+      "reviewer": "codex-independent-beta",
+      "decision": "approved",
+      "reviewedDigest": "sha256-15dadc4b1bfa9107072020f8bfef0aa906811f8d3dd4f4c36d3fefc2c6f40423"
+    }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/reason-codes.v1.json

@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "registryVersion": "1.0.0",
+  "namespace": "AAS_COVERAGE",
+  "stability": "appendOnlyWithinMajor",
+  "codes": [
+    { "code": "AAS_COVERAGE_OOD_CREATIVE_CONTENT", "family": "creative-content", "meaning": "The requested outcome is authored narrative or editorial content, outside the six frozen software-delivery intents." },
+    { "code": "AAS_COVERAGE_OOD_MEDIA_PRODUCTION", "family": "media-production", "meaning": "The requested outcome is audiovisual or visual-media production, outside the six frozen software-delivery intents." },
+    { "code": "AAS_COVERAGE_OOD_PERSONAL_PLANNING", "family": "personal-planning", "meaning": "The requested outcome is personal or household planning, outside the six frozen software-delivery intents." },
+    { "code": "AAS_COVERAGE_OOD_PROFESSIONAL_ADVICE", "family": "professional-advice", "meaning": "The requested outcome is individualized regulated professional advice, outside the six frozen software-delivery intents." },
+    { "code": "AAS_COVERAGE_OOD_PHYSICAL_SYSTEMS", "family": "physical-systems", "meaning": "The requested outcome concerns design, diagnosis, or repair of a physical system, outside the six frozen software-delivery intents." },
+    { "code": "AAS_COVERAGE_OOD_NON_WEB_SOFTWARE", "family": "non-web-software", "meaning": "The requested outcome is native, game, desktop, or embedded software rather than a frozen v1 software-delivery intent." }
+  ]
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/schemas/abstention-case.schema.json

@@ -0,0 +1,58 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://aas.example/schemas/v1/abstention-case.schema.json",
+  "title": "AAS v1 pre-declared out-of-distribution abstention case",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "caseId", "intent", "profile", "targets", "policy", "criticalGoals", "nonCriticalGoals", "requiresSkill", "provenance", "taskFamilyFingerprint"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "caseId": { "type": "string", "pattern": "^abstention\\." },
+    "intent": {
+      "type": "string",
+      "minLength": 1,
+      "not": { "enum": ["web-application-delivery", "api-backend-delivery", "test-qa-automation", "security-review-hardening", "deployment-devops", "agent-mcp-development"] }
+    },
+    "profile": { "type": "object", "minProperties": 1 },
+    "targets": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 2,
+      "uniqueItems": true,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["host", "scope"],
+        "properties": {
+          "host": { "enum": ["codex", "claude"] },
+          "scope": { "const": "project" }
+        }
+      }
+    },
+    "policy": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["allowedRisk", "requireKnownSource", "allowManualSetup"],
+      "properties": {
+        "allowedRisk": { "const": ["none", "safe"] },
+        "requireKnownSource": { "const": false },
+        "allowManualSetup": { "const": false }
+      }
+    },
+    "criticalGoals": { "type": "array", "minItems": 1, "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
+    "nonCriticalGoals": { "type": "array", "uniqueItems": true, "items": { "type": "string", "minLength": 1 } },
+    "minimumNonCriticalGoalCoverage": { "type": "number", "minimum": 0.8, "maximum": 1 },
+    "requiresSkill": { "const": false },
+    "provenance": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["source", "version", "reviewedAt"],
+      "properties": {
+        "source": { "type": "string", "minLength": 1 },
+        "version": { "type": "string", "minLength": 1 },
+        "reviewedAt": { "type": "string", "pattern": "^\\d{4}-\\d{2}-\\d{2}$" }
+      }
+    },
+    "taskFamilyFingerprint": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" }
+  }
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/schemas/abstention-index.schema.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://aas.example/schemas/v1/abstention-index.schema.json",
+  "title": "AAS v1 pre-declared abstention corpus index",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "corpusVersion", "status", "expectedStatus", "frozenSupportedIntents", "reasonCodeRegistry", "families", "cases", "reviews"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "corpusVersion": { "const": "1.0.0" },
+    "status": { "enum": ["pendingIndependentReview", "frozen"] },
+    "expectedStatus": { "const": "insufficientCoverage" },
+    "frozenSupportedIntents": { "type": "array", "minItems": 6, "maxItems": 6, "uniqueItems": true, "items": { "type": "string" } },
+    "reasonCodeRegistry": { "const": "reason-codes.v1.json" },
+    "families": { "type": "array", "minItems": 6, "uniqueItems": true, "items": { "type": "string" } },
+    "cases": {
+      "type": "array",
+      "minItems": 30,
+      "maxItems": 30,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["caseId", "family", "inputPath", "labelPath", "taskFamilyFingerprint", "provenance", "reviewStatus"],
+        "properties": {
+          "caseId": { "type": "string" },
+          "family": { "type": "string" },
+          "inputPath": { "type": "string" },
+          "labelPath": { "type": "string" },
+          "taskFamilyFingerprint": { "type": "string" },
+          "provenance": { "type": "object" },
+          "reviewStatus": { "enum": ["pendingIndependentReview", "approved"] }
+        }
+      }
+    },
+    "reviews": { "type": "array", "maxItems": 0 }
+  }
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/abstention/schemas/abstention-label.schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://aas.example/schemas/v1/abstention-label.schema.json",
+  "title": "AAS v1 abstention expected label",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "labelVersion", "caseId", "expectedStatus", "expectedProposedStack", "reasonCodes", "reviews"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "labelVersion": { "const": "1.0.0" },
+    "caseId": { "type": "string", "pattern": "^abstention\\." },
+    "expectedStatus": { "const": "insufficientCoverage" },
+    "expectedProposedStack": { "type": "array", "maxItems": 0 },
+    "reasonCodes": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": { "enum": ["AAS_COVERAGE_OOD_CREATIVE_CONTENT", "AAS_COVERAGE_OOD_MEDIA_PRODUCTION", "AAS_COVERAGE_OOD_PERSONAL_PLANNING", "AAS_COVERAGE_OOD_PROFESSIONAL_ADVICE", "AAS_COVERAGE_OOD_PHYSICAL_SYSTEMS", "AAS_COVERAGE_OOD_NON_WEB_SOFTWARE"] }
+    },
+    "reviews": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["reviewer", "decision", "reviewedDigest"],
+        "properties": {
+          "reviewer": { "type": "string" },
+          "decision": { "enum": ["approved", "rejected"] },
+          "reviewedDigest": { "type": "string" }
+        }
+      }
+    }
+  }
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/authoring/apply-independent-reviews.mjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const benchmarkRoot = path.resolve(here, "..");
+const baselineRoot = path.resolve(benchmarkRoot, "..");
+const repositoryRoot = path.resolve(baselineRoot, "..", "..", "..", "..");
+const reportPaths = [
+  path.join(baselineRoot, "reviews", "reviewer-alpha.json"),
+  path.join(baselineRoot, "reviews", "reviewer-beta.json"),
+];
+
+function sha256File(file) {
+  return `sha256:${crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex")}`;
+}
+
+function canonicalize(value) {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+  }
+  return value;
+}
+
+function pairDigest(caseData, judgmentData, section) {
+  const reviewNeutralJudgment = { ...judgmentData, reviews: [] };
+  const payload = section === "abstention"
+    ? { case: caseData, label: reviewNeutralJudgment }
+    : { case: caseData, gold: reviewNeutralJudgment };
+  const bytes = JSON.stringify(canonicalize(payload));
+  return `sha256-${crypto.createHash("sha256").update(bytes).digest("hex")}`;
+}
+
+function pairManifestRoot(entries) {
+  const sorted = entries.sort((left, right) => (
+    left[0] < right[0] ? -1 : left[0] > right[0] ? 1 : 0
+  ));
+  return `sha256-${crypto.createHash("sha256").update(JSON.stringify(sorted)).digest("hex")}`;
+}
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+function writeJson(file, data) {
+  fs.writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+const reports = reportPaths.map((file) => {
+  if (!fs.existsSync(file)) throw new Error(`Missing independent review report: ${file}`);
+  const report = readJson(file);
+  if ((report.overallDecision || report.overall?.decision) !== "approved") {
+    throw new Error(`Review is not approved: ${file}`);
+  }
+  return report;
+});
+const reviewerId = (report) => report.reviewer.id || report.reviewer.identity;
+if (new Set(reports.map(reviewerId)).size !== 2) {
+  throw new Error("Exactly two distinct independent reviewer identities are required.");
+}
+
+const pendingWrites = new Map();
+const reviewedCaseIds = new Map(reports.map((report) => [reviewerId(report), new Set()]));
+
+const pairPaths = new Map();
+const heldOutIndexForPaths = readJson(path.join(benchmarkRoot, "held-out-index.json"));
+for (const entry of heldOutIndexForPaths.cases) {
+  pairPaths.set(entry.caseId, {
+    caseFile: path.join(benchmarkRoot, entry.inputPath),
+    judgmentFile: path.join(benchmarkRoot, entry.goldPath),
+    section: "heldOut",
+  });
+}
+const tuningRoot = path.join(benchmarkRoot, "tuning");
+const tuningIndexForPaths = readJson(path.join(tuningRoot, "index.json"));
+for (const entry of tuningIndexForPaths.cases) {
+  pairPaths.set(entry.caseId, {
+    caseFile: path.join(tuningRoot, entry.inputPath),
+    judgmentFile: path.join(tuningRoot, entry.goldPath),
+    section: "tuning",
+  });
+}
+const abstentionRoot = path.join(benchmarkRoot, "abstention");
+const abstentionIndexForPaths = readJson(path.join(abstentionRoot, "index.json"));
+for (const entry of abstentionIndexForPaths.cases) {
+  pairPaths.set(entry.caseId, {
+    caseFile: path.join(abstentionRoot, entry.inputPath),
+    judgmentFile: path.join(abstentionRoot, entry.labelPath),
+    section: "abstention",
+  });
+}
+
+function addReview(report, caseId, caseFile, judgmentFile, section) {
+  const identity = reviewerId(report);
+  const caseData = readJson(caseFile);
+  const judgmentData = readJson(judgmentFile);
+  const digest = pairDigest(caseData, judgmentData, section);
+  const pending = pendingWrites.get(judgmentFile) || { data: judgmentData, reviews: [] };
+  pending.reviews.push({ reviewer: identity, decision: "approved", reviewedDigest: digest });
+  pendingWrites.set(judgmentFile, pending);
+  reviewedCaseIds.get(identity).add(caseId);
+  return digest;
+}
+
+for (const report of reports) {
+  if (report.scope) {
+    for (const section of ["heldOut", "tuning", "abstention"]) {
+      const items = report.scope?.[section]?.items;
+      if (!Array.isArray(items)) throw new Error(`${reviewerId(report)} missing ${section} items`);
+      for (const item of items) {
+        if (item.decision !== "approved") throw new Error(`${reviewerId(report)} rejected ${item.caseId}`);
+        const caseFile = path.join(repositoryRoot, item.casePath);
+        const judgmentFile = path.join(repositoryRoot, item.judgmentPath);
+        if (sha256File(caseFile) !== item.caseSha256) throw new Error(`Case digest mismatch: ${item.caseId}`);
+        if (sha256File(judgmentFile) !== item.judgmentSha256) throw new Error(`Judgment digest mismatch: ${item.caseId}`);
+        addReview(report, item.caseId, caseFile, judgmentFile, section);
+      }
+    }
+    continue;
+  }
+  if (report.splits) {
+    const globalEntries = [];
+    for (const section of ["heldOut", "tuning", "abstention"]) {
+      const splitEntries = [];
+      for (const [caseId, pair] of pairPaths) {
+        if (pair.section !== section) continue;
+        const digest = addReview(report, caseId, pair.caseFile, pair.judgmentFile, section);
+        splitEntries.push([caseId, digest]);
+        globalEntries.push([caseId, digest]);
+      }
+      if (splitEntries.length !== report.splits[section]?.pairCount) {
+        throw new Error(`${reviewerId(report)} ${section} pair count mismatch`);
+      }
+      if (pairManifestRoot(splitEntries) !== report.splits[section]?.pairManifestRootDigest) {
+        throw new Error(`${reviewerId(report)} ${section} root digest mismatch`);
+      }
+    }
+    if (globalEntries.length !== report.pairCount || pairManifestRoot(globalEntries) !== report.pairManifestRootDigest) {
+      throw new Error(`${reviewerId(report)} global root digest mismatch`);
+    }
+    continue;
+  }
+  for (const section of ["heldOut", "tuning", "abstention"]) {
+    const digestMap = report[section]?.pairSha256ByCaseId;
+    if (!digestMap || typeof digestMap !== "object") throw new Error(`${reviewerId(report)} missing ${section} digest map`);
+    for (const [caseId, expectedDigest] of Object.entries(digestMap)) {
+      const pair = pairPaths.get(caseId);
+      if (!pair || pair.section !== section) throw new Error(`Unknown ${section} review pair: ${caseId}`);
+      const actualDigest = addReview(report, caseId, pair.caseFile, pair.judgmentFile, section);
+      if (actualDigest !== expectedDigest) throw new Error(`Pair digest mismatch: ${caseId}`);
+    }
+  }
+}
+
+for (const [reviewer, ids] of reviewedCaseIds) {
+  if (ids.size !== 270) throw new Error(`${reviewer} approved ${ids.size} unique pairs, expected 270`);
+}
+if (pendingWrites.size !== 270) throw new Error(`Expected 270 judgments, found ${pendingWrites.size}`);
+for (const [file, pending] of pendingWrites) {
+  pending.data.reviews = pending.reviews.sort((left, right) => left.reviewer.localeCompare(right.reviewer));
+  writeJson(file, pending.data);
+}
+
+const heldOutIndexPath = path.join(benchmarkRoot, "held-out-index.json");
+const heldOutIndex = readJson(heldOutIndexPath);
+heldOutIndex.status = "frozen";
+heldOutIndex.indexVersion = "1.0.0";
+heldOutIndex.cases = heldOutIndex.cases.map((entry) => ({ ...entry, reviewStatus: "approved" }));
+writeJson(heldOutIndexPath, heldOutIndex);
+
+const tuningIndexPath = path.join(benchmarkRoot, "tuning", "index.json");
+const tuningIndex = readJson(tuningIndexPath);
+tuningIndex.status = "frozen";
+tuningIndex.cases = tuningIndex.cases.map((entry) => ({ ...entry, reviewStatus: "approved" }));
+writeJson(tuningIndexPath, tuningIndex);
+
+const tuningManifestPath = path.join(benchmarkRoot, "tuning", "manifest.json");
+const tuningManifest = readJson(tuningManifestPath);
+tuningManifest.status = "frozen";
+tuningManifest.reviews = reports.map((report) => ({ reviewer: report.reviewer.id, decision: "approved" }));
+writeJson(tuningManifestPath, tuningManifest);
+
+const abstentionIndexPath = path.join(benchmarkRoot, "abstention", "index.json");
+const abstentionIndex = readJson(abstentionIndexPath);
+abstentionIndex.status = "frozen";
+abstentionIndex.cases = abstentionIndex.cases.map((entry) => ({ ...entry, reviewStatus: "approved" }));
+writeJson(abstentionIndexPath, abstentionIndex);
+
+const manifestPath = path.join(benchmarkRoot, "manifest.json");
+const manifest = readJson(manifestPath);
+manifest.benchmarkVersion = "1.0.0";
+manifest.status = "frozen";
+manifest.heldOut.actualInputsPresent = true;
+manifest.heldOut.goldLabelsPresent = true;
+manifest.abstention = {
+  index: "abstention/index.json",
+  caseCount: 30,
+  labelsFrozen: true,
+  status: "frozen"
+};
+manifest.tuning = {
+  manifest: "tuning/manifest.json",
+  separatedFromHeldOut: true,
+  status: "frozen"
+};
+manifest.labelsFrozen = true;
+writeJson(manifestPath, manifest);
+
+console.log(JSON.stringify({
+  ok: true,
+  reviewers: reports.map(reviewerId),
+  reviewedPairs: pendingWrites.size,
+  heldOut: 180,
+  tuning: 60,
+  abstention: 30,
+}, null, 2));

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/authoring/normalize-heldout-contract.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const benchmarkRoot = path.resolve(here, "..");
+const caseRoot = path.join(benchmarkRoot, "cases", "held-out");
+const goldRoot = path.join(benchmarkRoot, "gold", "held-out");
+const indexPath = path.join(benchmarkRoot, "held-out-index.json");
+
+function walkJson(directory) {
+  return fs.readdirSync(directory, { withFileTypes: true })
+    .flatMap((entry) => {
+      const target = path.join(directory, entry.name);
+      return entry.isDirectory() ? walkJson(target) : entry.name.endsWith(".json") ? [target] : [];
+    })
+    .sort();
+}
+
+function hostsForArchetype(archetype) {
+  if (["small-greenfield", "mature-legacy-migration"].includes(archetype)) return ["codex"];
+  if (["production-greenfield", "constrained-offline"].includes(archetype)) return ["claude"];
+  return ["codex", "claude"];
+}
+
+const index = JSON.parse(fs.readFileSync(indexPath, "utf8"));
+const descriptors = new Map(index.cases.map((entry) => [entry.caseId, entry]));
+const casePaths = new Map();
+const goldPaths = new Map();
+
+for (const file of walkJson(caseRoot)) {
+  const data = JSON.parse(fs.readFileSync(file, "utf8"));
+  const descriptor = descriptors.get(data.caseId);
+  if (!descriptor) throw new Error(`Unknown held-out case: ${data.caseId}`);
+  const normalized = {
+    schemaVersion: 1,
+    caseId: data.caseId,
+    intent: data.intent,
+    targets: hostsForArchetype(descriptor.archetype).map((host) => ({ host, scope: "project" })),
+    profile: data.profile,
+    criticalGoals: data.criticalGoals,
+    nonCriticalGoals: data.nonCriticalGoals,
+    minimumNonCriticalGoalCoverage: Math.max(0.8, data.minimumNonCriticalGoalCoverage ?? 0.8),
+    requiresSkill: true,
+    policy: {
+      allowedRisk: ["none", "safe"],
+      requireKnownSource: false,
+      allowManualSetup: false
+    },
+    provenance: data.provenance,
+    taskFamilyFingerprint: descriptor.taskFamilyId
+  };
+  fs.writeFileSync(file, `${JSON.stringify(normalized, null, 2)}\n`);
+  casePaths.set(data.caseId, path.relative(benchmarkRoot, file));
+}
+
+for (const file of walkJson(goldRoot)) {
+  const data = JSON.parse(fs.readFileSync(file, "utf8"));
+  const normalized = {
+    schemaVersion: 1,
+    caseId: data.caseId,
+    acceptedSolutions: data.acceptedSolutions,
+    ambiguous: data.ambiguous,
+    provenance: {
+      source: data.provenance?.source || "independent-synthetic-held-out-gold",
+      version: data.provenance?.version || "1.0.0",
+      reviewedAt: data.provenance?.reviewedAt || data.provenance?.labeledAt || "2026-07-17"
+    },
+    reviews: []
+  };
+  fs.writeFileSync(file, `${JSON.stringify(normalized, null, 2)}\n`);
+  goldPaths.set(data.caseId, path.relative(benchmarkRoot, file));
+}
+
+index.cases = index.cases.map((entry) => ({
+  ...entry,
+  inputPath: casePaths.get(entry.caseId),
+  goldPath: goldPaths.get(entry.caseId),
+  provenance: "independent-synthetic-held-out@1.0.0",
+  reviewStatus: "pendingIndependentReview"
+}));
+fs.writeFileSync(indexPath, `${JSON.stringify(index, null, 2)}\n`);
+
+console.log(JSON.stringify({ normalizedCases: casePaths.size, normalizedGold: goldPaths.size }, null, 2));

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/agent-architecture/constrained-offline.json

@@ -0,0 +1,49 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.agent-architecture.constrained-offline",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "greenfield",
+    "deployment": "air-gapped-field-device",
+    "languages": [
+      "rust"
+    ],
+    "agentShape": "single-local-agent",
+    "constraints": [
+      "local-model",
+      "bounded-memory",
+      "no-network",
+      "deterministic-toolset"
+    ]
+  },
+  "criticalGoals": [
+    "design a useful agent within strict compute and context limits",
+    "guarantee local-only tool execution"
+  ],
+  "nonCriticalGoals": [
+    "bound retries and planning depth",
+    "support offline state recovery"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.agent-architecture.constrained-offline"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/agent-architecture/mature-legacy-migration.json

@@ -0,0 +1,49 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.agent-architecture.mature-legacy-migration",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "legacy-migration",
+    "languages": [
+      "java"
+    ],
+    "legacySystem": "rule-based-workflow-bot",
+    "agentShape": "incremental-agentic-replacement",
+    "constraints": [
+      "no-flag-day",
+      "behavior-parity",
+      "operator-override",
+      "phased-tool-adoption"
+    ]
+  },
+  "criticalGoals": [
+    "migrate to agentic control without losing deterministic safeguards",
+    "preserve operator control during mixed legacy and agent execution"
+  ],
+  "nonCriticalGoals": [
+    "define strangler boundaries",
+    "capture comparable run evidence"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.agent-architecture.mature-legacy-migration"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/agent-architecture/monorepo-polyglot.json

@@ -0,0 +1,55 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.agent-architecture.monorepo-polyglot",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    },
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "mature",
+    "repositoryShape": "monorepo",
+    "languages": [
+      "go",
+      "python",
+      "typescript"
+    ],
+    "agentShape": "domain-agents-and-shared-tools",
+    "constraints": [
+      "independent-release-cadence",
+      "cross-language-contracts",
+      "context-isolation",
+      "shared-governance"
+    ]
+  },
+  "criticalGoals": [
+    "define stable boundaries among agents and tools",
+    "prevent duplicate work and context leakage across domains"
+  ],
+  "nonCriticalGoals": [
+    "standardize handoff contracts",
+    "allocate concurrency and cost budgets"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.agent-architecture.monorepo-polyglot"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/agent-architecture/production-greenfield.json

@@ -0,0 +1,52 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.agent-architecture.production-greenfield",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "production-greenfield",
+    "teamSize": 15,
+    "languages": [
+      "python"
+    ],
+    "frameworks": [
+      "langgraph"
+    ],
+    "agentShape": "supervisor-and-specialists",
+    "constraints": [
+      "durable-runs",
+      "bounded-autonomy",
+      "cost-budget",
+      "horizontal-scale"
+    ]
+  },
+  "criticalGoals": [
+    "design a production multi-agent architecture with clear ownership",
+    "make orchestration, retries, and termination deterministic"
+  ],
+  "nonCriticalGoals": [
+    "define cost and concurrency controls",
+    "separate agent state from execution workers"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.agent-architecture.production-greenfield"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/agent-architecture/regulated-high-assurance.json

@@ -0,0 +1,53 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.agent-architecture.regulated-high-assurance",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    },
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "regulated-production",
+    "domain": "health-insurance",
+    "languages": [
+      "csharp"
+    ],
+    "agentShape": "case-review-copilot",
+    "constraints": [
+      "human-final-decision",
+      "explainable-actions",
+      "data-minimization",
+      "tamper-evident-audit"
+    ]
+  },
+  "criticalGoals": [
+    "design bounded agent authority with human accountability",
+    "make every tool action and decision traceable"
+  ],
+  "nonCriticalGoals": [
+    "isolate sensitive context",
+    "define safe abstention and escalation"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.agent-architecture.regulated-high-assurance"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/agent-architecture/small-greenfield.json

@@ -0,0 +1,49 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.agent-architecture.small-greenfield",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "greenfield",
+    "teamSize": 2,
+    "languages": [
+      "typescript"
+    ],
+    "agentShape": "single-assistant",
+    "toolCount": 4,
+    "constraints": [
+      "human-approval-for-writes",
+      "short-lived-sessions",
+      "minimal-operations"
+    ]
+  },
+  "criticalGoals": [
+    "design a reliable agent control loop",
+    "define explicit tool authority and approval boundaries"
+  ],
+  "nonCriticalGoals": [
+    "structure context and failure recovery",
+    "avoid unnecessary multi-agent complexity"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.agent-architecture.small-greenfield"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/evaluation-testing/constrained-offline.json

@@ -0,0 +1,46 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.evaluation-testing.constrained-offline",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "greenfield",
+    "deployment": "air-gapped-lab",
+    "agentShape": "local-model-agent",
+    "constraints": [
+      "offline-evaluation",
+      "limited-compute",
+      "deterministic-fixtures",
+      "no-telemetry"
+    ]
+  },
+  "criticalGoals": [
+    "run reproducible agent evaluations fully offline",
+    "cover critical tool behavior within a bounded compute budget"
+  ],
+  "nonCriticalGoals": [
+    "summarize run distributions locally",
+    "support model upgrades without remote graders"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.evaluation-testing.constrained-offline"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/evaluation-testing/mature-legacy-migration.json

@@ -0,0 +1,45 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.evaluation-testing.mature-legacy-migration",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "legacy-migration",
+    "legacySystem": "prompt-snapshot-tests",
+    "agentShape": "tool-using-workflow-agent",
+    "constraints": [
+      "preserve-baseline",
+      "replace-string-matching",
+      "phased-eval-adoption"
+    ]
+  },
+  "criticalGoals": [
+    "replace brittle output snapshots with behavioral evaluation",
+    "prove no regression against legacy workflow outcomes"
+  ],
+  "nonCriticalGoals": [
+    "introduce adversarial cases",
+    "version datasets and judgments"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.evaluation-testing.mature-legacy-migration"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/evaluation-testing/monorepo-polyglot.json

@@ -0,0 +1,54 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.evaluation-testing.monorepo-polyglot",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    },
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "mature",
+    "repositoryShape": "monorepo",
+    "languages": [
+      "python",
+      "typescript",
+      "go"
+    ],
+    "agentShape": "multiple-domain-agents",
+    "constraints": [
+      "shared-eval-contract",
+      "team-owned-fixtures",
+      "cross-model-comparison"
+    ]
+  },
+  "criticalGoals": [
+    "standardize agent evaluation across languages and teams",
+    "attribute failures to capabilities and agent boundaries"
+  ],
+  "nonCriticalGoals": [
+    "support equivalent gold solutions",
+    "aggregate results without hiding weak domains"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.evaluation-testing.monorepo-polyglot"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/evaluation-testing/production-greenfield.json

@@ -0,0 +1,47 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.evaluation-testing.production-greenfield",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "production-greenfield",
+    "teamSize": 14,
+    "agentShape": "customer-support-agent-platform",
+    "evaluationMaturity": "prototype",
+    "constraints": [
+      "multiple-models",
+      "daily-deployments",
+      "cost-and-latency-budgets",
+      "human-escalation"
+    ]
+  },
+  "criticalGoals": [
+    "build a production evaluation harness for correctness and safety",
+    "gate releases on statistically meaningful repeated runs"
+  ],
+  "nonCriticalGoals": [
+    "measure latency and cost tradeoffs",
+    "monitor drift without leaking customer content"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.evaluation-testing.production-greenfield"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/evaluation-testing/regulated-high-assurance.json

@@ -0,0 +1,50 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.evaluation-testing.regulated-high-assurance",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    },
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "regulated-production",
+    "domain": "clinical-document-review",
+    "agentShape": "human-supervised-assistant",
+    "constraints": [
+      "zero-unsafe-action-tolerance",
+      "reviewer-provenance",
+      "reproducible-evidence",
+      "privacy"
+    ]
+  },
+  "criticalGoals": [
+    "test safety invariants and correct abstention as hard gates",
+    "produce reviewable evaluation evidence with independent judgments"
+  ],
+  "nonCriticalGoals": [
+    "measure subgroup performance",
+    "detect data leakage between tuning and held-out sets"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.evaluation-testing.regulated-high-assurance"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/evaluation-testing/small-greenfield.json

@@ -0,0 +1,46 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.evaluation-testing.small-greenfield",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "greenfield",
+    "teamSize": 2,
+    "agentShape": "single-tool-using-assistant",
+    "evaluationMaturity": "none",
+    "constraints": [
+      "small-budget",
+      "critical-actions-deterministic",
+      "weekly-release"
+    ]
+  },
+  "criticalGoals": [
+    "define behavioral tests for tool selection and refusal",
+    "measure reliability across repeated runs"
+  ],
+  "nonCriticalGoals": [
+    "separate held-out cases from tuning",
+    "track regressions by capability"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.evaluation-testing.small-greenfield"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/mcp-tooling/constrained-offline.json

@@ -0,0 +1,50 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.mcp-tooling.constrained-offline",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "greenfield",
+    "deployment": "disconnected-workstation",
+    "languages": [
+      "rust"
+    ],
+    "transport": "stdio",
+    "toolSurface": "local-diagnostic-tools",
+    "constraints": [
+      "no-network",
+      "small-binary",
+      "bounded-input",
+      "offline-docs"
+    ]
+  },
+  "criticalGoals": [
+    "implement a fully offline MCP server",
+    "bound protocol input and local resource consumption"
+  ],
+  "nonCriticalGoals": [
+    "support deterministic startup and shutdown",
+    "provide local conformance diagnostics"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.mcp-tooling.constrained-offline"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/mcp-tooling/mature-legacy-migration.json

@@ -0,0 +1,49 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.mcp-tooling.mature-legacy-migration",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "legacy-migration",
+    "languages": [
+      "java"
+    ],
+    "legacySystem": "internal-rest-automation-api",
+    "transport": "mcp-facade",
+    "constraints": [
+      "preserve-existing-api",
+      "incremental-tools",
+      "no-credential-copy",
+      "rollback"
+    ]
+  },
+  "criticalGoals": [
+    "expose legacy capabilities through safe MCP boundaries",
+    "preserve existing API behavior during phased migration"
+  ],
+  "nonCriticalGoals": [
+    "map legacy failures to structured MCP errors",
+    "define deprecation and compatibility tests"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.mcp-tooling.mature-legacy-migration"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/mcp-tooling/monorepo-polyglot.json

@@ -0,0 +1,55 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.mcp-tooling.monorepo-polyglot",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    },
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "mature",
+    "repositoryShape": "monorepo",
+    "languages": [
+      "typescript",
+      "python",
+      "go"
+    ],
+    "transport": "mixed-local-and-remote",
+    "toolSurface": "domain-owned-mcp-servers",
+    "constraints": [
+      "shared-conventions",
+      "independent-versioning",
+      "cross-host-compatibility"
+    ]
+  },
+  "criticalGoals": [
+    "standardize MCP contracts across implementations",
+    "keep domain servers independently deployable"
+  ],
+  "nonCriticalGoals": [
+    "define discovery and version negotiation",
+    "share conformance tests across languages"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.mcp-tooling.monorepo-polyglot"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/mcp-tooling/production-greenfield.json

@@ -0,0 +1,50 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.mcp-tooling.production-greenfield",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "production-greenfield",
+    "teamSize": 12,
+    "languages": [
+      "python"
+    ],
+    "transport": "streamable-http",
+    "toolSurface": "enterprise-workflow-tools",
+    "constraints": [
+      "authentication",
+      "multi-tenant",
+      "rate-limits",
+      "backward-compatible-schemas"
+    ]
+  },
+  "criticalGoals": [
+    "design a production MCP server with stable tool contracts",
+    "enforce authentication, tenancy, and resource bounds"
+  ],
+  "nonCriticalGoals": [
+    "define protocol-version compatibility",
+    "instrument tool latency and failures"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.mcp-tooling.production-greenfield"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/mcp-tooling/regulated-high-assurance.json

@@ -0,0 +1,54 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.mcp-tooling.regulated-high-assurance",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    },
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "regulated-production",
+    "domain": "brokerage-operations",
+    "languages": [
+      "csharp"
+    ],
+    "transport": "local-stdio",
+    "toolSurface": "read-and-approved-write-tools",
+    "constraints": [
+      "least-privilege",
+      "per-action-approval",
+      "audit-receipts",
+      "data-redaction"
+    ]
+  },
+  "criticalGoals": [
+    "design MCP tools whose authority matches user intent",
+    "make write approval and audit evidence non-bypassable"
+  ],
+  "nonCriticalGoals": [
+    "redact sensitive tool inputs and errors",
+    "define fail-closed policy behavior"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.mcp-tooling.regulated-high-assurance"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/mcp-tooling/small-greenfield.json

@@ -0,0 +1,49 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.mcp-tooling.small-greenfield",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "greenfield",
+    "teamSize": 2,
+    "languages": [
+      "typescript"
+    ],
+    "transport": "stdio",
+    "toolSurface": "three-read-only-project-tools",
+    "constraints": [
+      "local-only",
+      "small-schemas",
+      "no-persistence"
+    ]
+  },
+  "criticalGoals": [
+    "design clear MCP tools with bounded schemas",
+    "implement protocol-correct local stdio behavior"
+  ],
+  "nonCriticalGoals": [
+    "separate trusted metadata from untrusted content",
+    "add actionable errors and tool descriptions"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.mcp-tooling.small-greenfield"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/memory-context-retrieval/constrained-offline.json

@@ -0,0 +1,47 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.memory-context-retrieval.constrained-offline",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "greenfield",
+    "deployment": "offline-field-laptop",
+    "agentShape": "local-maintenance-assistant",
+    "knowledgeScale": "thousands-of-manual-pages",
+    "constraints": [
+      "local-embeddings",
+      "bounded-disk",
+      "no-cloud-vector-store",
+      "incremental-media-updates"
+    ]
+  },
+  "criticalGoals": [
+    "build effective retrieval entirely on-device",
+    "bound index and context resource usage"
+  ],
+  "nonCriticalGoals": [
+    "support incremental offline updates",
+    "retain citations into local manuals"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.memory-context-retrieval.constrained-offline"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/memory-context-retrieval/mature-legacy-migration.json

@@ -0,0 +1,46 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.memory-context-retrieval.mature-legacy-migration",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "legacy-migration",
+    "legacySystem": "keyword-only-knowledge-search",
+    "knowledgeScale": "large-document-archive",
+    "constraints": [
+      "preserve-existing-index",
+      "phased-embedding-adoption",
+      "citation-parity",
+      "rollback"
+    ]
+  },
+  "criticalGoals": [
+    "migrate retrieval without reducing recall or attribution",
+    "introduce semantic retrieval through a reversible transition"
+  ],
+  "nonCriticalGoals": [
+    "add hybrid ranking",
+    "measure retrieval quality against legacy search"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.memory-context-retrieval.mature-legacy-migration"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/memory-context-retrieval/monorepo-polyglot.json

@@ -0,0 +1,55 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.memory-context-retrieval.monorepo-polyglot",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    },
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "mature",
+    "repositoryShape": "monorepo",
+    "languages": [
+      "go",
+      "python",
+      "typescript"
+    ],
+    "agentShape": "domain-agents",
+    "knowledgeScale": "code-docs-runbooks",
+    "constraints": [
+      "domain-access-boundaries",
+      "shared-index",
+      "incremental-refresh"
+    ]
+  },
+  "criticalGoals": [
+    "partition memory and retrieval by domain authority",
+    "keep shared context current across heterogeneous sources"
+  ],
+  "nonCriticalGoals": [
+    "standardize retrieval evidence",
+    "avoid cross-agent context duplication"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.memory-context-retrieval.monorepo-polyglot"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/memory-context-retrieval/production-greenfield.json

@@ -0,0 +1,47 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.memory-context-retrieval.production-greenfield",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "production-greenfield",
+    "teamSize": 16,
+    "agentShape": "enterprise-knowledge-assistant",
+    "knowledgeScale": "millions-of-chunks",
+    "constraints": [
+      "tenant-isolation",
+      "freshness",
+      "hybrid-retrieval",
+      "citation-required"
+    ]
+  },
+  "criticalGoals": [
+    "design scalable tenant-isolated retrieval",
+    "ground answers in current attributable evidence"
+  ],
+  "nonCriticalGoals": [
+    "combine keyword and vector recall",
+    "evaluate retrieval quality and stale knowledge"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.memory-context-retrieval.production-greenfield"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/memory-context-retrieval/regulated-high-assurance.json

@@ -0,0 +1,51 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.memory-context-retrieval.regulated-high-assurance",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    },
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "regulated-production",
+    "domain": "legal-casework",
+    "agentShape": "research-copilot",
+    "knowledgeScale": "privileged-and-public-materials",
+    "constraints": [
+      "matter-level-isolation",
+      "retention-policy",
+      "right-to-delete",
+      "evidence-chain"
+    ]
+  },
+  "criticalGoals": [
+    "enforce access and retention policy throughout memory",
+    "return attributable evidence without cross-matter leakage"
+  ],
+  "nonCriticalGoals": [
+    "support auditable forgetting",
+    "qualify sources before ingestion"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.memory-context-retrieval.regulated-high-assurance"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/memory-context-retrieval/small-greenfield.json

@@ -0,0 +1,46 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.memory-context-retrieval.small-greenfield",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "greenfield",
+    "teamSize": 2,
+    "agentShape": "project-assistant",
+    "knowledgeScale": "hundreds-of-documents",
+    "constraints": [
+      "local-files",
+      "short-context-window",
+      "simple-operations"
+    ]
+  },
+  "criticalGoals": [
+    "design compact short-term and durable agent memory",
+    "retrieve only relevant evidence into context"
+  ],
+  "nonCriticalGoals": [
+    "define forgetting and consolidation",
+    "preserve source references for recalled facts"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.memory-context-retrieval.small-greenfield"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/security-operations/constrained-offline.json

@@ -0,0 +1,46 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.security-operations.constrained-offline",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "greenfield",
+    "deployment": "air-gapped-maintenance-network",
+    "agentShape": "local-operations-agent",
+    "constraints": [
+      "offline-supply-chain",
+      "removable-media-updates",
+      "no-central-policy-service",
+      "local-audit"
+    ]
+  },
+  "criticalGoals": [
+    "secure offline skill and tool updates",
+    "enforce local least privilege without remote dependencies"
+  ],
+  "nonCriticalGoals": [
+    "verify package provenance before activation",
+    "retain bounded tamper-evident local audit"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.security-operations.constrained-offline"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/security-operations/mature-legacy-migration.json

@@ -0,0 +1,46 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.security-operations.mature-legacy-migration",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "legacy-migration",
+    "legacySystem": "broadly-permissioned-automation-bot",
+    "agentShape": "policy-governed-agent",
+    "constraints": [
+      "existing-integrations",
+      "unknown-tool-provenance",
+      "phased-permission-reduction",
+      "no-service-interruption"
+    ]
+  },
+  "criticalGoals": [
+    "reduce legacy agent authority without breaking operations",
+    "inventory and threat-model every existing integration"
+  ],
+  "nonCriticalGoals": [
+    "introduce shadow policy before enforcement",
+    "scan legacy skills and tool descriptions"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.security-operations.mature-legacy-migration"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/security-operations/monorepo-polyglot.json

@@ -0,0 +1,55 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.security-operations.monorepo-polyglot",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "codex",
+      "scope": "project"
+    },
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "mature",
+    "repositoryShape": "monorepo",
+    "languages": [
+      "go",
+      "python",
+      "typescript"
+    ],
+    "agentShape": "team-owned-agents",
+    "constraints": [
+      "central-policy",
+      "domain-specific-permissions",
+      "shared-mcp-registry",
+      "cross-agent-handoffs"
+    ]
+  },
+  "criticalGoals": [
+    "apply consistent security policy across heterogeneous agents",
+    "prevent privilege amplification through handoffs"
+  ],
+  "nonCriticalGoals": [
+    "standardize threat reviews",
+    "track tool and skill provenance"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.security-operations.monorepo-polyglot"
+}

antigravity-awesome-skills/verification/aas-v1/baseline/v1/benchmark/cases/held-out/agent-mcp-development/security-operations/production-greenfield.json

@@ -0,0 +1,47 @@
+{
+  "schemaVersion": 1,
+  "caseId": "heldout.agent-mcp-development.security-operations.production-greenfield",
+  "intent": "agent-mcp-development",
+  "targets": [
+    {
+      "host": "claude",
+      "scope": "project"
+    }
+  ],
+  "profile": {
+    "projectStage": "production-greenfield",
+    "teamSize": 20,
+    "agentShape": "customer-operations-agent",
+    "toolSurface": "internal-and-third-party-mcp",
+    "constraints": [
+      "tenant-isolation",
+      "supply-chain-risk",
+      "approval-policy",
+      "incident-response"
+    ]
+  },
+  "criticalGoals": [
+    "define enforceable governance for every tool call",
+    "contain hostile tool content and compromised integrations"
+  ],
+  "nonCriticalGoals": [
+    "record verifiable action receipts",
+    "establish security monitoring and revocation"
+  ],
+  "minimumNonCriticalGoalCoverage": 0.8,
+  "requiresSkill": true,
+  "policy": {
+    "allowedRisk": [
+      "none",
+      "safe"
+    ],
+    "requireKnownSource": false,
+    "allowManualSetup": false
+  },
+  "provenance": {
+    "source": "independent-synthetic-held-out",
+    "version": "1.0.0",
+    "reviewedAt": "2026-07-17"
+  },
+  "taskFamilyFingerprint": "tf.agent-mcp-development.security-operations.production-greenfield"
+}