@open-agent-toolkit/cli 0.2.49 → 0.2.51

package/assets/skills/oat-project-complete/scripts/finalize-synced-archive.mjs

@@ -0,0 +1,125 @@
+import { execFile as execFileCallback } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { promisify } from 'node:util';
+
+const execFile = promisify(execFileCallback);
+
+function finalizationError(message) {
+  const error = new Error(message);
+  error.code = 'E_SYNCED_ARCHIVE_FINALIZATION';
+  return error;
+}
+
+function requireFullSha(value, field) {
+  if (typeof value !== 'string' || !/^[0-9a-f]{40}$/.test(value)) {
+    throw finalizationError(
+      `Synced archive terminal report requires a full ${field} SHA.`,
+    );
+  }
+}
+
+export function validateSyncedArchiveTerminalReport(report, projectName) {
+  if (!report || typeof report !== 'object' || Array.isArray(report)) {
+    throw finalizationError(
+      'Synced archive finalization requires a structured terminal report.',
+    );
+  }
+  if (
+    report.status !== 'ok' ||
+    report.mode !== 'apply' ||
+    typeof report.archivePath !== 'string' ||
+    report.archivePath.length === 0
+  ) {
+    throw finalizationError(
+      'Synced archive terminal report is not a successful durable apply result.',
+    );
+  }
+  requireFullSha(report.lifecycleCommit, 'lifecycleCommit');
+  requireFullSha(report.verifiedSourceSha, 'verifiedSourceSha');
+  if (report.completedRef !== `refs/oat/completed/${projectName}`) {
+    throw finalizationError(
+      'Synced archive terminal report names an unexpected completed ref.',
+    );
+  }
+  if (!['removed', 'retained'].includes(report.activeAliasDisposition)) {
+    throw finalizationError(
+      'Synced archive terminal report has no verified active-alias disposition.',
+    );
+  }
+  if (report.recordRetired !== true) {
+    throw finalizationError(
+      'Synced archive terminal report does not verify discovery-record retirement.',
+    );
+  }
+  return report;
+}
+
+export async function finalizeSyncedArchive({
+  getArchiveReport,
+  projectName,
+  clearActiveProject,
+}) {
+  const report = validateSyncedArchiveTerminalReport(
+    await getArchiveReport(),
+    projectName,
+  );
+  await clearActiveProject();
+  return {
+    status: 'ok',
+    pointerCleared: true,
+    lifecycleCommit: report.lifecycleCommit,
+    completedRef: report.completedRef,
+    verifiedSourceSha: report.verifiedSourceSha,
+    activeAliasDisposition: report.activeAliasDisposition,
+    recordRetired: report.recordRetired,
+  };
+}
+
+function parseArguments(argv) {
+  if (argv.length !== 2 || argv[0] !== '--project-name' || !argv[1]) {
+    throw finalizationError(
+      'Usage: finalize-synced-archive.mjs --project-name <name>',
+    );
+  }
+  return { projectName: argv[1] };
+}
+
+async function main(argv) {
+  const { projectName } = parseArguments(argv);
+  return finalizeSyncedArchive({
+    projectName,
+    getArchiveReport: async () => {
+      try {
+        return JSON.parse(await readFile(0, 'utf8'));
+      } catch (error) {
+        throw finalizationError(
+          `Unable to parse synced archive terminal report: ${error.message}`,
+        );
+      }
+    },
+    clearActiveProject: async () => {
+      try {
+        await execFile('oat', ['config', 'set', 'activeProject', '']);
+      } catch (error) {
+        throw finalizationError(
+          `Unable to clear the active project pointer: ${error.message}`,
+        );
+      }
+    },
+  });
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  main(process.argv.slice(2))
+    .then((result) => process.stdout.write(`${JSON.stringify(result)}\n`))
+    .catch((error) => {
+      process.stderr.write(
+        `${JSON.stringify({ ok: false, code: error.code, message: error.message })}\n`,
+      );
+      process.exitCode = 1;
+    });
+}

package/assets/skills/oat-project-complete/scripts/parse-synced-archive-resume-fields.mjs

@@ -0,0 +1,106 @@
+import { pathToFileURL } from 'node:url';
+
+function fieldsError(message) {
+  const error = new Error(message);
+  error.code = 'E_SYNCED_ARCHIVE_RESUME_FIELDS';
+  return error;
+}
+
+function shellQuote(value) {
+  return `'${String(value).split("'").join("'\\''")}'`;
+}
+
+export function parseSyncedArchiveResumeFields(result) {
+  const continuation = result?.continuation;
+  const hasRecapExport = continuation?.projectRecapExport !== null;
+  if (
+    result?.status !== 'ok' ||
+    result?.route !== 'archive-resumed' ||
+    result?.terminal !== true ||
+    result?.skippedActiveSteps !== true ||
+    result?.terminalReceiptValidated !== true ||
+    continuation?.required !== true ||
+    continuation?.rejoinStep !== '8.5' ||
+    typeof continuation.archivePath !== 'string' ||
+    continuation.archivePath.length === 0 ||
+    typeof continuation.lifecycleCommit !== 'string' ||
+    !/^[0-9a-f]{40}$/.test(continuation.lifecycleCommit) ||
+    typeof continuation.evidenceCommit !== 'string' ||
+    (continuation.evidenceCommit !== '' &&
+      !/^[0-9a-f]{40}$/.test(continuation.evidenceCommit)) ||
+    typeof continuation.evidencePushRequired !== 'boolean' ||
+    (continuation.evidenceCommit === '' &&
+      continuation.evidencePushRequired !== false) ||
+    (hasRecapExport &&
+      (typeof continuation.exportedManifestPath !== 'string' ||
+        continuation.exportedManifestPath.length === 0 ||
+        typeof continuation.exportedBuildRecordPath !== 'string' ||
+        continuation.exportedBuildRecordPath.length === 0)) ||
+    (!hasRecapExport &&
+      (continuation.exportedManifestPath !== '' ||
+        continuation.exportedBuildRecordPath !== '' ||
+        continuation.evidenceCommit !== ''))
+  ) {
+    throw fieldsError(
+      'Synced archive resume result has no verified post-archive continuation.',
+    );
+  }
+  return {
+    SYNCED_ARCHIVE_RESUME: 'true',
+    SHOULD_ARCHIVE: 'true',
+    IS_DURABLE_PROJECT: 'true',
+    ARCHIVE_OUTPUT: JSON.stringify(result.archiveReport),
+    ARCHIVE_PATH: continuation.archivePath,
+    PROJECT_PATH: continuation.archivePath,
+    SUMMARY_EXPORT_FILE: continuation.summaryExportFile ?? '',
+    LIFECYCLE_COMMIT: continuation.lifecycleCommit,
+    ARCHIVE_S3_PATH: continuation.s3Path ?? '',
+    SELECTED_PROJECT_RECAP_RUN: continuation.selectedProjectRecapRun ?? '',
+    PROJECT_RECAP_EXPORT_JSON: JSON.stringify(
+      continuation.projectRecapExport ?? null,
+    ),
+    EVIDENCE_COMMIT: continuation.evidenceCommit,
+    EVIDENCE_PUSH_REQUIRED: String(continuation.evidencePushRequired),
+    EXPORTED_MANIFEST_PATH: continuation.exportedManifestPath,
+    EXPORTED_BUILD_RECORD_PATH: continuation.exportedBuildRecordPath,
+    PROJECT_REF_COMMIT: '',
+    SHOULD_OPEN_PR: 'false',
+  };
+}
+
+export function formatShellAssignments(fields) {
+  return Object.entries(fields)
+    .map(([name, value]) => `${name}=${shellQuote(value)}`)
+    .join('\n');
+}
+
+function main(argv) {
+  if (argv.length !== 1) {
+    throw fieldsError(
+      'Usage: parse-synced-archive-resume-fields.mjs <executor-json>',
+    );
+  }
+  let result;
+  try {
+    result = JSON.parse(argv[0]);
+  } catch (error) {
+    throw fieldsError(
+      `Unable to parse archive resume result: ${error.message}`,
+    );
+  }
+  return formatShellAssignments(parseSyncedArchiveResumeFields(result));
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  try {
+    process.stdout.write(`${main(process.argv.slice(2))}\n`);
+  } catch (error) {
+    process.stderr.write(
+      `${JSON.stringify({ ok: false, code: error.code, message: error.message })}\n`,
+    );
+    process.exitCode = 1;
+  }
+}

package/assets/skills/oat-project-complete/scripts/recover-completion-receipts.mjs

@@ -91,6 +91,23 @@ async function changedPaths(projectPath, commit) {
   return output === '' ? [] : output.split('\n').sort();
 }
 
+async function isAncestor(projectPath, ancestor, descendant) {
+  try {
+    await execFileAsync(
+      'git',
+      ['merge-base', '--is-ancestor', ancestor, descendant],
+      { cwd: projectPath, encoding: 'utf8' },
+    );
+    return true;
+  } catch (error) {
+    if (error?.code === 1) return false;
+    const detail = error?.stderr?.trim() || error?.message || String(error);
+    throw completionReceiptError(
+      `git merge-base failed while recovering completion receipts: ${detail}`,
+    );
+  }
+}
+
 async function committedFile(projectPath, commit, path, label) {
   const content = await git(projectPath, ['show', `${commit}:${path}`], {
     allowFailure: true,
@@ -698,6 +715,99 @@ export async function recoverCompletionReceipts({
   };
 }
 
+export async function recoverArchivedRecapEvidenceReceipt({
+  repoRoot,
+  lifecycleCommit,
+  evidencePaths,
+}) {
+  if (typeof repoRoot !== 'string' || repoRoot.length === 0) {
+    throw completionReceiptError(
+      'Archived recap evidence recovery requires the repository root.',
+    );
+  }
+  if (!FULL_SHA.test(lifecycleCommit ?? '')) {
+    throw completionReceiptError(
+      'Archived recap evidence recovery requires a full lifecycle commit SHA.',
+    );
+  }
+  if (!Array.isArray(evidencePaths) || evidencePaths.length !== 2) {
+    throw completionReceiptError(
+      'Archived recap evidence recovery requires exactly two evidence paths.',
+    );
+  }
+  const exactEvidencePaths = evidencePaths.map((path, index) =>
+    requireRelativeGitPath(path, `Archived evidence path ${index + 1}`),
+  );
+  if (new Set(exactEvidencePaths).size !== exactEvidencePaths.length) {
+    throw completionReceiptError('Archived evidence paths must be unique.');
+  }
+
+  const resolvedLifecycle = await git(repoRoot, [
+    'rev-parse',
+    '--verify',
+    `${lifecycleCommit}^{commit}`,
+  ]);
+  if (resolvedLifecycle !== lifecycleCommit) {
+    throw completionReceiptError(
+      'Archived recap lifecycle receipt does not resolve to the exact commit.',
+    );
+  }
+  const head = await git(repoRoot, ['rev-parse', 'HEAD']);
+  if (head === lifecycleCommit) {
+    return {
+      status: 'none',
+      evidenceCommit: null,
+      evidencePushRequired: false,
+      evidencePaths: exactEvidencePaths,
+    };
+  }
+  if ((await commitSubject(repoRoot, head)) !== EVIDENCE_MESSAGE) {
+    throw completionReceiptError(
+      'Archived recap retry HEAD is neither the lifecycle commit nor the exact evidence commit.',
+    );
+  }
+  if (
+    (await singleParent(repoRoot, head, 'Archived recap evidence commit')) !==
+    lifecycleCommit
+  ) {
+    throw completionReceiptError(
+      'Archived recap evidence commit must be the immediate child of the lifecycle commit.',
+    );
+  }
+  requireExactPaths(
+    await changedPaths(repoRoot, head),
+    exactEvidencePaths,
+    'Archived recap evidence commit',
+  );
+
+  const upstream = await git(
+    repoRoot,
+    ['rev-parse', '--verify', '@{u}^{commit}'],
+    { allowFailure: true },
+  );
+  let evidencePushRequired;
+  if (upstream === head) {
+    evidencePushRequired = false;
+  } else if (
+    upstream === null ||
+    (FULL_SHA.test(upstream) &&
+      (await isAncestor(repoRoot, upstream, lifecycleCommit)))
+  ) {
+    evidencePushRequired = true;
+  } else {
+    throw completionReceiptError(
+      'Archived recap evidence retry requires upstream to equal the evidence commit or remain an ancestor of its lifecycle parent.',
+    );
+  }
+
+  return {
+    status: 'recovered',
+    evidenceCommit: head,
+    evidencePushRequired,
+    evidencePaths: exactEvidencePaths,
+  };
+}
+
 function parseBoolean(value, label) {
   if (value === 'true') return true;
   if (value === 'false') return false;

package/assets/skills/oat-project-complete/scripts/resolve-synced-archive-entry.mjs

@@ -0,0 +1,164 @@
+import { execFile as execFileCallback } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+import { promisify } from 'node:util';
+
+const execFile = promisify(execFileCallback);
+
+function entryError(message) {
+  const error = new Error(message);
+  error.code = 'E_SYNCED_ARCHIVE_ENTRY';
+  return error;
+}
+
+function parseArguments(argv) {
+  const result = {};
+  for (let index = 0; index < argv.length; index += 2) {
+    const flag = argv[index];
+    const value = argv[index + 1];
+    if (value === undefined) {
+      throw entryError(`Missing value for ${flag ?? 'argument'}.`);
+    }
+    if (flag === '--repo-root') result.repoRoot = value;
+    else if (flag === '--record-path') result.recordPath = value;
+    else if (flag === '--project-name') result.projectName = value;
+    else throw entryError(`Unsupported argument: ${flag}.`);
+  }
+  for (const field of ['repoRoot', 'recordPath', 'projectName']) {
+    if (!result[field]) throw entryError(`Missing required ${field}.`);
+  }
+  return result;
+}
+
+function parseAdvertisedRefs(stdout, requestedRefs) {
+  const refs = new Map();
+  for (const row of stdout.split('\n').filter(Boolean)) {
+    const fields = row.trim().split(/\s+/);
+    if (
+      fields.length !== 2 ||
+      !/^[0-9a-f]{40}$/i.test(fields[0]) ||
+      !requestedRefs.has(fields[1]) ||
+      refs.has(fields[1])
+    ) {
+      throw entryError(
+        'Unable to validate synced terminal refs: malformed Git advertisement.',
+      );
+    }
+    refs.set(fields[1], fields[0]);
+  }
+  return refs;
+}
+
+async function probeRemoteRefs({ repoRoot, remote, activeRef, completedRef }) {
+  let stdout;
+  try {
+    ({ stdout } = await execFile(
+      'git',
+      ['ls-remote', remote, activeRef, completedRef],
+      { cwd: repoRoot },
+    ));
+  } catch (error) {
+    throw entryError(
+      `Unable to validate synced terminal refs from ${remote}: ${error.message}`,
+    );
+  }
+  const refs = parseAdvertisedRefs(stdout, new Set([activeRef, completedRef]));
+  return {
+    activeSha: refs.get(activeRef) ?? null,
+    completedSha: refs.get(completedRef) ?? null,
+  };
+}
+
+export async function resolveSyncedArchiveEntry({
+  record,
+  projectName,
+  probeRefs = probeRemoteRefs,
+  repoRoot,
+}) {
+  if (!record || typeof record !== 'object' || Array.isArray(record)) {
+    throw entryError('Synced archive entry requires a valid discovery record.');
+  }
+  const activeRef = `refs/oat/projects/${projectName}`;
+  const completedRef = `refs/oat/completed/${projectName}`;
+  if (
+    record.slug !== projectName ||
+    record.scope !== 'synced' ||
+    record.ref !== activeRef ||
+    typeof record.remote !== 'string' ||
+    record.remote.length === 0
+  ) {
+    throw entryError('Synced archive entry record identity is not canonical.');
+  }
+  const hasSnapshot = typeof record.archiveSnapshot === 'string';
+  const hasSourceSha = typeof record.archiveSourceRefSha === 'string';
+  if (hasSnapshot !== hasSourceSha) {
+    throw entryError('Synced archive retry identity is incomplete.');
+  }
+  if (!hasSnapshot) {
+    return { status: 'ok', route: 'pull', terminal: false };
+  }
+  if (
+    record.archiveSnapshot.length === 0 ||
+    !/^[0-9a-f]{40}$/.test(record.archiveSourceRefSha)
+  ) {
+    throw entryError('Synced archive retry identity is malformed.');
+  }
+  const { activeSha, completedSha } = await probeRefs({
+    repoRoot,
+    remote: record.remote,
+    activeRef,
+    completedRef,
+  });
+  if (completedSha === null) {
+    if (activeSha === record.archiveSourceRefSha) {
+      return { status: 'ok', route: 'pull', terminal: false };
+    }
+    throw entryError(
+      'Persisted archive retry identity has no matching active or completed ref.',
+    );
+  }
+  if (
+    completedSha !== record.archiveSourceRefSha ||
+    (activeSha !== null && activeSha !== record.archiveSourceRefSha)
+  ) {
+    throw entryError(
+      'Persisted archive retry identity does not match the authoritative terminal refs.',
+    );
+  }
+  return {
+    status: 'ok',
+    route: 'archive-resume',
+    terminal: true,
+    archiveSnapshot: record.archiveSnapshot,
+    verifiedSourceSha: record.archiveSourceRefSha,
+    completedRef,
+    activeAliasDisposition: activeSha === null ? 'removed' : 'retained',
+  };
+}
+
+async function main(argv) {
+  const options = parseArguments(argv);
+  let record;
+  try {
+    record = JSON.parse(await readFile(options.recordPath, 'utf8'));
+  } catch (error) {
+    throw entryError(
+      `Unable to read synced discovery record: ${error.message}`,
+    );
+  }
+  return resolveSyncedArchiveEntry({ ...options, record });
+}
+
+if (
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(process.argv[1]).href
+) {
+  main(process.argv.slice(2))
+    .then((result) => process.stdout.write(`${JSON.stringify(result)}\n`))
+    .catch((error) => {
+      process.stderr.write(
+        `${JSON.stringify({ ok: false, code: error.code, message: error.message })}\n`,
+      );
+      process.exitCode = 1;
+    });
+}

package/assets/skills/oat-project-document/references/docs/autonomy-contract.md

@@ -244,7 +244,7 @@ remains immutable baseline evidence for the original p01-t01 verification.
 | `oat-project-summary/SKILL.md`                                 | `68c197c44c18 -> NG`; `35cb2ea1d677 -> NG`; `a167d03559fa -> NG`; `cf317c17c586 -> SUMMARY-01`; `f3e49b727752 -> NG`; `f979b2342d28 -> NG`; `803bf40ec423 -> NG`; `c8fced47ef8e -> NG`; `d7ea1e2a4f5f -> NG`; `5f315ab87cb1 -> NG`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `oat-project-pr-final/SKILL.md`                                | `601ac2b890f2 -> NG`; `c264a64398f0 -> NG`; `9efcbcee42ea -> NG`; `655d61df0a8f -> NG`; `cf317c17c586 -> PRFINAL-01`; `2de348a391c0 -> PRFINAL-03`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `oat-project-pr-final/references/docs/autonomy-contract.md`    | `* -> NG`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `oat-project-complete/SKILL.md`                                | `6ed459f9e462 -> NG`; `a167d03559fa -> NG`; `79c2eeed668c -> COMPLETE-01`; `2c1514b9d9af -> COMPLETE-01`; `31c750b4fea7 -> COMPLETE-01`; `cfba413b1293 -> COMPLETE-01`; `7fcfce0423ac -> COMPLETE-01`; `7bcbf58b54e9 -> NG`; `4c7f88a7f942 -> COMPLETE-02`; `6a1a95acc8cc -> COMPLETE-02`; `3b559956b3eb -> COMPLETE-03`; `14d161cdf99b -> COMPLETE-03`; `12f7c30a54c8 -> NG`; `fffe5eea5ebd -> NG`; `e7dc6fdc4eb3 -> COMPLETE-01`; `e5460e437299 -> NG`; `882b61c9096c -> NG`; `9ffa1c752505 -> NG`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `oat-project-complete/SKILL.md`                                | `6ed459f9e462 -> NG`; `a167d03559fa -> NG`; `79c2eeed668c -> COMPLETE-01`; `2c1514b9d9af -> COMPLETE-01`; `31c750b4fea7 -> COMPLETE-01`; `cfba413b1293 -> COMPLETE-01`; `7fcfce0423ac -> COMPLETE-01`; `7bcbf58b54e9 -> NG`; `4c7f88a7f942 -> COMPLETE-02`; `6a1a95acc8cc -> COMPLETE-02`; `3b559956b3eb -> COMPLETE-03`; `14d161cdf99b -> COMPLETE-03`; `fffe5eea5ebd -> NG`; `e7dc6fdc4eb3 -> COMPLETE-01`; `e5460e437299 -> NG`; `882b61c9096c -> NG`; `9ffa1c752505 -> NG`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `oat-project-review-provide/SKILL.md`                          | `1f4b981cac8b -> NG`; `adaeca152bb2 -> NG`; `2f7c201c3c06 -> NG`; `88f79700afdc -> NG`; `655d61df0a8f -> NG`; `efafde9ef5a0 -> NG`; `d2a3861d6323 -> REVIEWPROVIDE-02`; `65f5b9cf49cd -> REVIEWPROVIDE-04`; `962cb38d246a -> REVIEWPROVIDE-04`; `1a568483ba0b -> REVIEWPROVIDE-04`; `610e27edfe85 -> REVIEWPROVIDE-04`; `bb0096e95c47 -> REVIEWPROVIDE-06`; `55f6357a987d -> REVIEWPROVIDE-06`; `1bee61f8531c -> REVIEWPROVIDE-07`; `3d35091607a1 -> REVIEWPROVIDE-08`; `fb40c4341c4c -> NG`; `b22d16885150 -> NG`; `d2b25906242e -> REVIEWPROVIDE-08`; `fd8ebf72b3c4 -> NG`; `fcb9de611ff3 -> NG`; `d2a838dfb18d -> NG`; `c3d50ea7cf69 -> NG`; `09b1b8dd445c -> NG`; `7acc8f3718d2 -> REVIEWPROVIDE-09`; `b2fa883fc4a2 -> NG`; `fe4421531b4c -> NG`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | `oat-project-review-receive/SKILL.md`                          | `9b8a3743d626 -> NG`; `df49c8c6f192 -> NG`; `4ee8730382d3 -> NG`; `655d61df0a8f -> NG`; `765f897d67ac -> NG`; `53b58d16dd32 -> NG`; `fb8755a3bdf4 -> NG`; `c8ab5dd90075 -> NG`; `1f7dd98dff2f -> NG`; `56f78c6740e6 -> NG`; `76f5fb5a88cd -> NG`; `085abfa3599f -> REVIEWRECEIVE-01`; `3ad3aadb8c60 -> NG`; `a7d114059bb6 -> NG`; `ac88cfaa83d9 -> NG`; `594bbf70346c -> REVIEWRECEIVE-08`; `f31f07284718 -> REVIEWRECEIVE-02`; `aba178a21441 -> REVIEWRECEIVE-04`; `a37e601cd731 -> REVIEWRECEIVE-05`; `20e05e1a4381 -> REVIEWRECEIVE-06`; `90001dadf75f -> REVIEWRECEIVE-07`; `f8fd58180ecf -> NG`; `c3abcdc02d9f -> NG`; `f2ebdd6abb9b -> NG`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 | `oat-project-review-provide/SKILL.md`                          | `2e794bf4fc4a -> REVIEWPROVIDE-08`; `5441ab977b46 -> REVIEWPROVIDE-08`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
@@ -260,7 +260,7 @@ remains immutable baseline evidence for the original p01-t01 verification.
 | `oat-project-dispatch-subagents/SKILL.md`                      | `eca03ad1ca12 -> PDISPATCH-01`; `59fbcdc79cea -> PDISPATCH-01`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | `oat-project-plan/SKILL.md`                                    | `f99e44b39932 -> PLAN-12`; `7e6a9854504b -> NG`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `oat-project-implement/references/completion-and-closeout.md`  | `6909a5a5a1fa -> IMPLEMENT-19`; `a7c02ef670fd -> IMPLEMENT-19`; `9dde56d89a71 -> IMPLEMENT-16`; `13c41b2b2590 -> IMPLEMENT-16`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `oat-project-complete/SKILL.md`                                | `0177956707aa -> NG`; `8305b5bb65ef -> NG`; `eb3e75663ac0 -> NG`; `8cc1fa5aab1e -> COMPLETE-01`; `4c209fbb4716 -> COMPLETE-01`; `02e4175e1171 -> COMPLETE-01`; `d698d4f98e76 -> COMPLETE-01`; `9f86a7218d93 -> COMPLETE-01`; `024713698d9a -> COMPLETE-01`; `c327995053fa -> COMPLETE-01`; `61f81d4ec7c1 -> COMPLETE-01`; `14fb2e56809f -> COMPLETE-01`; `7d4ff668744d -> COMPLETE-01`; `502a6c141784 -> COMPLETE-01`; `fb7e2db356af -> COMPLETE-01`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `oat-project-complete/SKILL.md`                                | `0177956707aa -> NG`; `8305b5bb65ef -> NG`; `eb3e75663ac0 -> NG`; `8cc1fa5aab1e -> COMPLETE-01`; `4c209fbb4716 -> COMPLETE-01`; `02e4175e1171 -> COMPLETE-01`; `d698d4f98e76 -> COMPLETE-01`; `9f86a7218d93 -> COMPLETE-01`; `024713698d9a -> COMPLETE-01`; `c327995053fa -> COMPLETE-01`; `61f81d4ec7c1 -> COMPLETE-01`; `14fb2e56809f -> COMPLETE-01`; `7d4ff668744d -> COMPLETE-01`; `502a6c141784 -> COMPLETE-01`; `fb7e2db356af -> COMPLETE-01`; `f73f8476360a -> NG`; `1e15f420039f -> NG`; `cc234032ddd7 -> NG`; `c3d25f1398bb -> NG`; `ca13a6645df2 -> NG`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 
 ## Prompt-scan comparison