@open-agent-toolkit/cli 0.2.30 → 0.2.32

package/assets/skills/oat-explainer-kit/scripts/resolve-config.mjs

@@ -15,6 +15,7 @@ export const EXPLAINER_CONFIG_KEYS = Object.freeze([
   'explainers.publish.s3Uri',
   'explainers.publish.publicBaseUrl',
   'explainers.publish.awsRegion',
+  'explainers.publish.publicAccess',
   'explainers.publish.awsProfile',
   'workflow.explainers.projectExplainer',
   'workflow.explainers.projectRecap',
@@ -115,7 +116,7 @@ export async function resolveExplainerConfig({
     }
   }
 
-  const publish = resolvePublish(values);
+  const { publish, publishReport } = resolvePublish(values, sources);
   const preferences = {
     projectExplainer: resolvePreference(
       'workflow.explainers.projectExplainer',
@@ -127,7 +128,15 @@ export async function resolveExplainerConfig({
     ),
   };
 
-  return { values, sources, theme, publish, preferences, warnings };
+  return {
+    values,
+    sources,
+    theme,
+    publish,
+    publishReport,
+    preferences,
+    warnings,
+  };
 }
 
 export function toExplainerRunRequest({
@@ -170,8 +179,9 @@ export function toExplainerRunRequest({
       );
     }
     durability.publish = {
-      schemaVersion: 'explainer-kit.publish-request/v1',
+      schemaVersion: 'explainer-kit.publish-request/v2',
       ...resolvedConfig.publish,
+      publicAccess: resolvedConfig.publish.publicAccess ?? 'public',
       siteRoot: join(outputRoot, slug, 'site'),
       manifestPath: join(outputRoot, slug, 'manifest.json'),
     };
@@ -179,7 +189,10 @@ export function toExplainerRunRequest({
 
   return {
     schemaVersion: 'explainer-kit.run-request/v1',
-    recipe: { id: recipe, version: '1' },
+    recipe: {
+      id: recipe,
+      version: recipe === 'project-recap' ? '2' : '1',
+    },
     slug,
     outputRoot,
     factBase,
@@ -254,6 +267,12 @@ function normalizeRuntimeValue(key, value) {
   if (key === 'explainers.publish.provider' && normalized !== 's3-static') {
     throw new Error(`${key} runtime override must be s3-static.`);
   }
+  if (
+    key === 'explainers.publish.publicAccess' &&
+    !['public', 'protected'].includes(normalized)
+  ) {
+    throw new Error(`${key} runtime override must be public or protected.`);
+  }
   if (key === 'explainers.defaults.style' && !STYLES.has(normalized)) {
     throw new Error(
       `${key} runtime override must name a curated explainer style.`,
@@ -283,27 +302,30 @@ function normalizeRuntimeValue(key, value) {
   return normalized;
 }
 
-function resolvePublish(values) {
-  const provider = nullableString(values['explainers.publish.provider']);
-  if (!provider) {
-    return null;
-  }
-  if (provider !== 's3-static') {
-    throw new Error(`Unsupported explainer publish provider: ${provider}`);
-  }
-
+function resolvePublish(values, sources) {
   const fields = {
+    provider: nullableString(values['explainers.publish.provider']),
     s3Uri: nullableString(values['explainers.publish.s3Uri']),
     publicBaseUrl: nullableString(values['explainers.publish.publicBaseUrl']),
     awsRegion: nullableString(values['explainers.publish.awsRegion']),
   };
+  if (fields.provider && fields.provider !== 's3-static') {
+    throw new Error(
+      `Unsupported explainer publish provider: ${fields.provider}`,
+    );
+  }
   const missing = Object.entries(fields)
     .filter(([, value]) => !value)
     .map(([key]) => key);
   if (missing.length > 0) {
-    throw new Error(
-      `Incomplete explainer publish configuration; missing ${missing.join(', ')}.`,
-    );
+    return {
+      publish: null,
+      publishReport: {
+        mode: 'build-only',
+        publishCapable: false,
+        missing,
+      },
+    };
   }
   if (!/^s3:\/\/[^/\s]+(?:\/.*)?$/.test(fields.s3Uri)) {
     throw new Error('explainers.publish.s3Uri must be a valid s3:// URI.');
@@ -315,12 +337,29 @@ function resolvePublish(values) {
   }
 
   const awsProfile = nullableString(values['explainers.publish.awsProfile']);
+  const publicAccess =
+    nullableString(values['explainers.publish.publicAccess']) ?? 'public';
+  if (!['public', 'protected'].includes(publicAccess)) {
+    throw new Error(
+      'explainers.publish.publicAccess must be public or protected.',
+    );
+  }
   return {
-    provider,
-    s3Uri: fields.s3Uri.replace(/\/+$/, ''),
-    publicBaseUrl: fields.publicBaseUrl.replace(/\/+$/, ''),
-    awsRegion: fields.awsRegion,
-    ...(awsProfile ? { awsProfile } : {}),
+    publish: {
+      provider: fields.provider,
+      s3Uri: fields.s3Uri.replace(/\/+$/, ''),
+      publicBaseUrl: fields.publicBaseUrl.replace(/\/+$/, ''),
+      awsRegion: fields.awsRegion,
+      ...(sources['explainers.publish.publicAccess'] !== 'default'
+        ? { publicAccess }
+        : {}),
+      ...(awsProfile ? { awsProfile } : {}),
+    },
+    publishReport: {
+      mode: 'publish-capable',
+      publishCapable: true,
+      missing: [],
+    },
   };
 }
 

package/assets/skills/oat-explainer-kit/scripts/resolve-paths.mjs

@@ -1,11 +1,12 @@
 import { lstat, realpath } from 'node:fs/promises';
-import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
 
 export async function resolveExplainerOutputRoot({
   repoRoot,
   invocation,
   activeProject,
   outputRoot,
+  slug,
 }) {
   if (!repoRoot) {
     throw new TypeError('repoRoot is required.');
@@ -17,19 +18,26 @@ export async function resolveExplainerOutputRoot({
         'Direct callers must provide an explicit outputRoot to the core.',
       );
     }
-    return resolveSafePath(outputRoot, {
+    const resolvedRoot = await resolveSafePath(outputRoot, {
       baseRoot: repoRoot,
       field: 'outputRoot',
     });
+    assertParentOutputRoot(resolvedRoot, slug);
+    return resolvedRoot;
   }
 
   const canonicalRepoRoot = await realpath(resolve(repoRoot));
   if (invocation === 'repo') {
-    return resolveSafePath('.oat/repo/reference/explainers', {
-      baseRoot: canonicalRepoRoot,
-      confinedRoot: canonicalRepoRoot,
-      field: 'repo explainer output root',
-    });
+    const resolvedRoot = await resolveSafePath(
+      '.oat/repo/reference/explainers',
+      {
+        baseRoot: canonicalRepoRoot,
+        confinedRoot: canonicalRepoRoot,
+        field: 'repo explainer output root',
+      },
+    );
+    assertParentOutputRoot(resolvedRoot, slug);
+    return resolvedRoot;
   }
 
   if (invocation !== 'project') {
@@ -49,11 +57,13 @@ export async function resolveExplainerOutputRoot({
     throw new Error('The active project cannot be the repository root.');
   }
 
-  return resolveSafePath(join(projectRoot, 'explainers'), {
+  const resolvedRoot = await resolveSafePath(join(projectRoot, 'explainers'), {
     baseRoot: canonicalRepoRoot,
     confinedRoot: projectRoot,
     field: 'project explainer output root',
   });
+  assertParentOutputRoot(resolvedRoot, slug);
+  return resolvedRoot;
 }
 
 export async function resolveSourceAwarePath({
@@ -164,3 +174,37 @@ function isWithin(root, target) {
 function isMissing(error) {
   return error && typeof error === 'object' && error.code === 'ENOENT';
 }
+
+function assertParentOutputRoot(outputRoot, slug) {
+  if (slug === undefined) return;
+  const normalizedSlug = normalizeRunSlug(slug);
+  if (basename(outputRoot) === normalizedSlug) {
+    throw new Error(
+      `Output root already ends in run slug "${normalizedSlug}"; supply the parent output root to avoid double-nesting.`,
+    );
+  }
+}
+
+function normalizeRunSlug(candidate) {
+  if (
+    typeof candidate !== 'string' ||
+    candidate.includes('/') ||
+    candidate.includes('\\') ||
+    candidate.includes('\0') ||
+    candidate === '.' ||
+    candidate === '..'
+  ) {
+    throw new Error('Run slug must be text, not a path or traversal value.');
+  }
+  const slug = candidate
+    .normalize('NFKD')
+    .replaceAll(/\p{Mark}/gu, '')
+    .toLowerCase()
+    .trim()
+    .replaceAll(/[^a-z0-9]+/g, '-')
+    .replaceAll(/^-+|-+$/g, '');
+  if (!slug) {
+    throw new Error('Run slug must contain at least one letter or number.');
+  }
+  return slug;
+}

package/assets/skills/oat-explainer-kit/scripts/run.mjs

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
 
 import { readFile } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
-import { bindProjectSources } from './bind-project-sources.mjs';
+import {
+  bindProjectSources,
+  bindRepositorySources,
+} from './bind-project-sources.mjs';
 import { checkCoreCompatibility } from './check-core.mjs';
+import { deriveExplainerDestination } from './derive-destination.mjs';
 import {
   resolveExplainerConfig,
   toExplainerRunRequest,
 } from './resolve-config.mjs';
 import { resolveExplainerOutputRoot } from './resolve-paths.mjs';
 
-export const MINIMUM_CORE_VERSION = '2.0.3';
+export const MINIMUM_CORE_VERSION = '2.1.0';
 const ADAPTER_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 
 export async function runOatExplainer({
@@ -80,21 +84,52 @@ export async function runOatExplainer({
     repoRoot,
     invocation,
     activeProject,
+    slug,
   });
-  if (invocation !== 'project' || !activeProject) {
+  const destination = resolvedConfig.publish
+    ? deriveExplainerDestination({
+        invocation,
+        ...(invocation === 'project' && {
+          projectSlug: basename(activeProject),
+        }),
+        s3Uri: resolvedConfig.publish.s3Uri,
+        publicBaseUrl: resolvedConfig.publish.publicBaseUrl,
+      })
+    : null;
+  let bound;
+  if (invocation === 'project') {
+    if (!activeProject) {
+      throw new Error(
+        'Project artifact binding requires an activeProject input.',
+      );
+    }
+    bound = await bindProjectSources({
+      projectRoot: resolve(repoRoot, activeProject),
+      repoRoot,
+      recipe,
+      suppliedFactBasePath,
+    });
+  } else if (invocation === 'repo') {
+    bound = await bindRepositorySources({
+      repoRoot,
+      suppliedFactBasePath,
+    });
+  } else {
     throw new Error(
-      'Project artifact binding requires a project invocation and activeProject.',
+      'The OAT adapter accepts project or repository invocations; direct callers invoke the core with an explicit output root.',
     );
   }
-  const projectRoot = resolve(repoRoot, activeProject);
-  const bound = await bindProjectSources({
-    projectRoot,
-    repoRoot,
-    recipe,
-    suppliedFactBasePath,
-  });
+  const requestConfig = destination
+    ? {
+        ...resolvedConfig,
+        publish: {
+          ...resolvedConfig.publish,
+          ...destination,
+        },
+      }
+    : resolvedConfig;
   const request = toExplainerRunRequest({
-    resolvedConfig,
+    resolvedConfig: requestConfig,
     recipe,
     slug,
     outputRoot,
@@ -181,13 +216,6 @@ export async function runOatExplainer({
     }),
     reviewedSource: bound.reviewedSource,
   });
-  const criticContractError = result?.errors?.find(
-    ({ message }) =>
-      typeof message === 'string' && message.includes('critic result contract'),
-  );
-  if (criticContractError) {
-    throw new Error(criticContractError.message);
-  }
   const manifest = await readManifest(result, request);
   return {
     compatibility,
@@ -195,7 +223,9 @@ export async function runOatExplainer({
     manifest,
     result,
     marking: result.marking ?? null,
+    publication: result.publication ?? null,
     outputRoot,
+    destination,
   };
 }
 
@@ -204,10 +234,11 @@ export function supportsAdaptiveSetPlanning(version) {
   const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-|$)/);
   if (!match) return false;
   const [major, minor, patch] = match.slice(1).map(Number);
+  const [minimumMajor, minimumMinor, minimumPatch] =
+    MINIMUM_CORE_VERSION.split('.').map(Number);
   return (
-    major === 2 &&
-    (minor > 0 ||
-      (minor === 0 && patch >= Number(MINIMUM_CORE_VERSION.split('.')[2])))
+    major === minimumMajor &&
+    (minor > minimumMinor || (minor === minimumMinor && patch >= minimumPatch))
   );
 }
 
@@ -467,11 +498,8 @@ async function resolveLifecycleBrowserSession({
     return core.assertBrowserProbeSession(resolvedSession, {
       allowFixture: !required,
     });
-  } catch (cause) {
-    const error = new Error(
-      `Browser session validation failed: ${cause?.message ?? String(cause)}`,
-      { cause },
-    );
+  } catch {
+    const error = new Error('Browser session validation failed.');
     error.code = 'E_BROWSER_PROBE_REQUIRED';
     throw error;
   }
@@ -633,24 +661,29 @@ async function readManifest(result, request) {
   return manifest;
 }
 
-async function runCli(argv = process.argv.slice(2), io = console) {
+export async function runOatExplainerCli(
+  argv = process.argv.slice(2),
+  io = console,
+  run = runOatExplainer,
+) {
   try {
     if (argv.length !== 2 || argv[0] !== '--context') {
       throw new Error('Usage: run.mjs --context <adapter-context.json>');
     }
     const context = JSON.parse(await readFile(argv[1], 'utf8'));
-    const result = await runOatExplainer(context);
-    io.log(JSON.stringify(result, null, 2));
+    const result = await run(context);
+    io.log(JSON.stringify(projectAdapterCliResult(result), null, 2));
     return result.result.outcome === 'failed' ? 1 : 0;
-  } catch (error) {
+  } catch {
     io.error(
       JSON.stringify(
         {
           outcome: 'failed',
-          errors: [
+          reasons: [
             {
-              code: error.code ?? 'E_ADAPTER',
-              message: error instanceof Error ? error.message : String(error),
+              stage: 'finalization',
+              kind: 'pipeline-failure',
+              count: 1,
             },
           ],
         },
@@ -662,9 +695,211 @@ async function runCli(argv = process.argv.slice(2), io = console) {
   }
 }
 
+function projectAdapterCliResult(value) {
+  if (!isObject(value) || !isObject(value.result)) {
+    return {
+      result: {
+        outcome: 'failed',
+        reasons: [
+          {
+            stage: 'finalization',
+            kind: 'pipeline-failure',
+            count: 1,
+          },
+        ],
+      },
+    };
+  }
+  const projected = {};
+  for (const key of ['compatibility', 'request', 'manifest', 'destination']) {
+    if (isObject(value[key])) projected[key] = structuredClone(value[key]);
+  }
+  for (const key of ['marking', 'outputRoot']) {
+    if (typeof value[key] === 'string' || value[key] === null) {
+      projected[key] = value[key];
+    }
+  }
+  projected.result = projectAdapterRunResult(value.result);
+  const publication = projectAdapterPublication(value.publication);
+  if (publication) projected.publication = publication;
+  return projected;
+}
+
+function projectAdapterRunResult(value) {
+  const projected = {};
+  for (const key of [
+    'runId',
+    'runRoot',
+    'manifestPath',
+    'buildRecordPath',
+    'outcome',
+    'marking',
+  ]) {
+    if (typeof value[key] === 'string') projected[key] = value[key];
+  }
+  if (Array.isArray(value.warnings)) {
+    projected.warnings = [
+      ...new Set(value.warnings.filter(isAdapterWarningCode)),
+    ];
+  }
+  for (const key of ['discovery', 'approval']) {
+    if (isObject(value[key])) projected[key] = structuredClone(value[key]);
+  }
+  const reasons = projectAdapterReasons(value.reasons);
+  if (reasons.length > 0) projected.reasons = reasons;
+  const visualReview = projectAdapterVisualReview(value.visualReview);
+  if (visualReview) projected.visualReview = visualReview;
+  const publication = projectAdapterPublication(value.publication);
+  if (publication) projected.publication = publication;
+  return projected;
+}
+
+function projectAdapterVisualReview(value) {
+  if (!isObject(value)) return null;
+  const reasons = projectAdapterReasons(value.reasons);
+  if (
+    value.schemaVersion !== 'explainer-kit.visual-review-evidence/v1' ||
+    typeof value.requestHash !== 'string' ||
+    ![1, 2].includes(value.attempt) ||
+    !['pass', 'correct', 'failed'].includes(value.disposition) ||
+    !Array.isArray(value.reasons) ||
+    reasons.length !== value.reasons.length
+  ) {
+    return null;
+  }
+  return {
+    schemaVersion: value.schemaVersion,
+    requestHash: value.requestHash,
+    attempt: value.attempt,
+    disposition: value.disposition,
+    reasons,
+  };
+}
+
+function projectAdapterPublication(value) {
+  if (!isObject(value)) return null;
+  if (
+    value.schemaVersion !== 'explainer-kit.publish-summary/v1' &&
+    value.schemaVersion !== 'explainer-kit.publish-summary/v2'
+  ) {
+    return null;
+  }
+  return {
+    schemaVersion: value.schemaVersion,
+    ...(typeof value.receiptSchemaVersion === 'string' && {
+      receiptSchemaVersion: value.receiptSchemaVersion,
+    }),
+    ...(typeof value.publicAccess === 'string' && {
+      publicAccess: value.publicAccess,
+    }),
+    ...(Array.isArray(value.artifacts) && {
+      artifacts: value.artifacts.map((artifact) =>
+        isObject(artifact)
+          ? {
+              ...pickAdapterStringFields(artifact, [
+                'relativePath',
+                'publicUrl',
+                's3Uri',
+                'hash',
+                'contentType',
+              ]),
+              ...(isObject(artifact.source) && {
+                source: pickAdapterStringFields(artifact.source, [
+                  'kind',
+                  'artifactId',
+                  'name',
+                ]),
+              }),
+              ...(isObject(artifact.objectVerification) && {
+                objectVerification: projectAdapterVerification(
+                  artifact.objectVerification,
+                ),
+              }),
+              ...(isObject(artifact.publicVerification) && {
+                publicVerification: projectAdapterVerification(
+                  artifact.publicVerification,
+                ),
+              }),
+            }
+          : {},
+      ),
+    }),
+  };
+}
+
+function projectAdapterVerification(value) {
+  return {
+    ...pickAdapterStringFields(value, ['status', 'method', 'hash']),
+    ...(Number.isInteger(value.httpStatus) && {
+      httpStatus: value.httpStatus,
+    }),
+  };
+}
+
+function projectAdapterReasons(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((reason) => {
+    if (
+      !isObject(reason) ||
+      ![
+        'planning',
+        'authoring',
+        'rendering',
+        'link-validation',
+        'browser-review',
+        'visual-review',
+        'durability',
+        'finalization',
+      ].includes(reason.stage) ||
+      ![
+        'finding',
+        'provider-failure',
+        'pipeline-failure',
+        'superseded',
+      ].includes(reason.kind) ||
+      !Number.isInteger(reason.count) ||
+      reason.count < 1 ||
+      reason.count > 50
+    ) {
+      return [];
+    }
+    return [
+      {
+        stage: reason.stage,
+        kind: reason.kind,
+        ...(typeof reason.artifactId === 'string' && {
+          artifactId: reason.artifactId,
+        }),
+        count: reason.count,
+      },
+    ];
+  });
+}
+
+function pickAdapterStringFields(value, keys) {
+  return Object.fromEntries(
+    keys.flatMap((key) =>
+      typeof value[key] === 'string' ? [[key, value[key]]] : [],
+    ),
+  );
+}
+
+function isAdapterWarningCode(value) {
+  return (
+    typeof value === 'string' &&
+    /^(?:fact-base-freshness-warning|theme-selection-normalized|durability-evidence-required|publish-receipt-evidence-required|(?:expansion|guideline|render|qa)-[a-z0-9-]+|visual-review-required:[a-z0-9-]+|stage-reopened:[a-z0-9-]+:[0-9TZ:.-]+|missing-(?:theme-token|required-anchor):[a-z0-9-]+)$/.test(
+      value,
+    )
+  );
+}
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
 if (
   process.argv[1] &&
   pathToFileURL(process.argv[1]).href === import.meta.url
 ) {
-  process.exitCode = await runCli();
+  process.exitCode = await runOatExplainerCli();
 }

package/assets/skills/oat-project-autonomous/references/gate-inventory.md

@@ -259,8 +259,8 @@ remains immutable baseline evidence for the original p01-t01 verification.
 | `oat-dispatch-subagents/references/record-schema.md`           | `78f8069274a8 -> NG`; `1c9a84c4d1e0 -> NG`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | `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`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `oat-project-complete/SKILL.md`                                | `ffad9f909dba -> COMPLETE-01`; `ffe636f736e8 -> COMPLETE-01`; `9262624c148f -> COMPLETE-01`; `23ec8b6a5cee -> COMPLETE-01`; `9e6c4d7cc3a8 -> COMPLETE-01`; `47383d4ab654 -> COMPLETE-01`; `ba34449bd586 -> COMPLETE-01`; `2407ebed0921 -> NG`; `0177956707aa -> NG`; `8305b5bb65ef -> 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`                                | `ffad9f909dba -> COMPLETE-01`; `ffe636f736e8 -> COMPLETE-01`; `9262624c148f -> COMPLETE-01`; `23ec8b6a5cee -> COMPLETE-01`; `9e6c4d7cc3a8 -> COMPLETE-01`; `47383d4ab654 -> COMPLETE-01`; `ba34449bd586 -> COMPLETE-01`; `0177956707aa -> NG`; `8305b5bb65ef -> NG`; `eb3e75663ac0 -> NG`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 
 ## Prompt-scan comparison