@open-agent-toolkit/cli 0.2.73 → 0.2.75

package/assets/skills/oat-project-complete/scripts/consume-persisted-recap-intent.mjs

@@ -0,0 +1,125 @@
+import { readdir, realpath } from 'node:fs/promises';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { readPersistedIntent } from '../../oat-explainer-kit/scripts/persist-intent.mjs';
+
+function consumptionError(message) {
+  const error = new Error(message);
+  error.code = 'E_RECAP_CONSUMPTION';
+  return error;
+}
+
+async function discoverManifestCandidates(explainersPath) {
+  let entries;
+  try {
+    entries = await readdir(explainersPath, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === 'ENOENT') return [];
+    throw error;
+  }
+
+  const candidates = [];
+  for (const entry of entries.sort((left, right) =>
+    left.name.localeCompare(right.name),
+  )) {
+    if (!entry.isDirectory()) continue;
+    const runEntries = await readdir(join(explainersPath, entry.name), {
+      withFileTypes: true,
+    });
+    if (
+      runEntries.some(
+        (runEntry) => runEntry.isFile() && runEntry.name === 'manifest.json',
+      )
+    ) {
+      candidates.push(`explainers/${entry.name}/manifest.json`);
+    }
+  }
+  return candidates;
+}
+
+async function resolveFailedAttemptEvidence(projectRoot, locator) {
+  try {
+    const { resolveProjectFailedAttemptEvidence } =
+      await import('../../oat-explainer-kit/scripts/check-terminal-outcome.mjs');
+    return await resolveProjectFailedAttemptEvidence({
+      projectPath: projectRoot,
+      locator,
+    });
+  } catch (error) {
+    throw consumptionError(
+      `Persisted failed-attempt evidence is invalid: ${error.message}`,
+    );
+  }
+}
+
+export async function consumePersistedRecapIntent({ projectPath }) {
+  const projectRoot = await realpath(projectPath);
+  const record = await readPersistedIntent({
+    statePath: join(projectRoot, 'state.md'),
+    product: 'projectRecap',
+  });
+  if (record === null) {
+    throw consumptionError(
+      'Completion recap intent must be persisted before consumption.',
+    );
+  }
+  if (record.decision === 'skip') {
+    const failedAttemptEvidence =
+      record.source === 'failed_attempt'
+        ? await resolveFailedAttemptEvidence(
+            projectRoot,
+            record.failed_attempt_evidence,
+          )
+        : null;
+    return {
+      decision: 'skip',
+      source: record.source,
+      route: 'skip',
+      manifestDiscoveryPerformed: false,
+      manifestCandidates: [],
+      authoringPermitted: false,
+      failedAttemptEvidence,
+    };
+  }
+  if (record.decision !== 'generate') {
+    throw consumptionError(
+      `Unsupported persisted recap decision: ${String(record.decision)}`,
+    );
+  }
+  const manifestCandidates = await discoverManifestCandidates(
+    join(projectRoot, 'explainers'),
+  );
+  return {
+    decision: 'generate',
+    source: record.source,
+    route: 'generate',
+    manifestDiscoveryPerformed: true,
+    manifestCandidates,
+    authoringPermitted: true,
+    failedAttemptEvidence: null,
+  };
+}
+
+async function main(argv) {
+  if (argv.length !== 1) {
+    throw consumptionError(
+      'Usage: consume-persisted-recap-intent.mjs <project-path>',
+    );
+  }
+  return consumePersistedRecapIntent({ projectPath: argv[0] });
+}
+
+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/execute-synced-archive-entry.mjs

@@ -5,7 +5,6 @@ import { pathToFileURL } from 'node:url';
 import { promisify } from 'node:util';
 
 import { validateSyncedArchiveTerminalReport } from './finalize-synced-archive.mjs';
-import { recoverArchivedRecapEvidenceReceipt } from './recover-completion-receipts.mjs';
 import { resolveSyncedArchiveEntry } from './resolve-synced-archive-entry.mjs';
 
 const execFile = promisify(execFileCallback);
@@ -20,13 +19,9 @@ async function buildPostArchiveContinuation(
   archiveReport,
   projectPath,
   repoRoot,
-  recoverArchiveEvidence,
 ) {
   let selectedProjectRecapRun = '';
   let exportedManifestPath = '';
-  let exportedBuildRecordPath = '';
-  let evidenceCommit = '';
-  let evidencePushRequired = false;
   if (archiveReport.projectRecapExport != null) {
     const sourceRunRoot = archiveReport.projectRecapExport?.sourceRunRoot;
     const exportRoot = archiveReport.projectRecapExport?.exportRoot;
@@ -66,19 +61,6 @@ async function buildPostArchiveContinuation(
       );
     }
     exportedManifestPath = posix.join(exportRootRelative, manifestPath);
-    exportedBuildRecordPath = posix.join(
-      exportRootRelative,
-      'build-record.json',
-    );
-    const recoveredEvidence = await recoverArchiveEvidence({
-      repoRoot,
-      lifecycleCommit: archiveReport.lifecycleCommit,
-      evidencePaths: [exportedManifestPath, exportedBuildRecordPath],
-    });
-    if (recoveredEvidence.evidenceCommit !== null) {
-      evidenceCommit = recoveredEvidence.evidenceCommit;
-      evidencePushRequired = recoveredEvidence.evidencePushRequired;
-    }
   }
   return {
     required: true,
@@ -90,9 +72,6 @@ async function buildPostArchiveContinuation(
     selectedProjectRecapRun,
     projectRecapExport: archiveReport.projectRecapExport ?? null,
     exportedManifestPath,
-    exportedBuildRecordPath,
-    evidenceCommit,
-    evidencePushRequired,
   };
 }
 
@@ -100,7 +79,6 @@ export async function continueSyncedArchiveCompletion({
   executionResult,
   finalizeLinks,
   refreshDashboard,
-  attestRecap,
   pushBookkeeping,
   closeoutPr,
   clearPointer,
@@ -118,12 +96,6 @@ export async function continueSyncedArchiveCompletion({
   }
   await finalizeLinks(executionResult.continuation);
   await refreshDashboard(executionResult.continuation);
-  if (
-    executionResult.continuation.projectRecapExport !== null &&
-    executionResult.continuation.evidenceCommit === ''
-  ) {
-    await attestRecap(executionResult.continuation);
-  }
   await pushBookkeeping(executionResult.continuation);
   await closeoutPr(executionResult.continuation);
   await clearPointer(executionResult.archiveReport);
@@ -145,7 +117,6 @@ export async function executeSyncedArchiveEntry({
   runActiveWorkflowSteps,
   archiveProject,
   validateArchive,
-  recoverArchiveEvidence = recoverArchivedRecapEvidenceReceipt,
 }) {
   const entry = record
     ? await resolveSyncedArchiveEntry({
@@ -214,7 +185,6 @@ export async function executeSyncedArchiveEntry({
       archiveReport,
       projectPath,
       repoRoot,
-      recoverArchiveEvidence,
     ),
   };
 }

package/assets/skills/oat-project-complete/scripts/parse-completion-retry-fields.mjs

@@ -141,8 +141,6 @@ export function parseCompletionRetryFields(input) {
 
   requireExactKeys(value, [
     'candidate',
-    'evidenceCommit',
-    'evidencePushRequired',
     'localCommit',
     'nextStep',
     'prArtifactPath',
@@ -177,16 +175,6 @@ export function parseCompletionRetryFields(input) {
       'Recovered completion retry receipts must use full commit SHAs.',
     );
   }
-  if (value.evidenceCommit !== null && !FULL_SHA.test(value.evidenceCommit)) {
-    throw completionRetryFieldsError(
-      'Recovered completion retry evidence receipt must be null or a full commit SHA.',
-    );
-  }
-  if (typeof value.evidencePushRequired !== 'boolean') {
-    throw completionRetryFieldsError(
-      'Recovered completion retry evidence push flag must be boolean.',
-    );
-  }
   if (
     typeof value.retainedRef !== 'string' ||
     !RETAINED_REF.test(value.retainedRef)
@@ -203,31 +191,12 @@ export function parseCompletionRetryFields(input) {
       'Recovered completion retry PR artifact path is malformed.',
     );
   }
-  if (value.evidenceCommit === null) {
-    if (
-      value.evidencePushRequired ||
-      value.localCommit !== value.projectRefCommit ||
-      value.remoteCommit !== value.projectRefCommit
-    ) {
-      throw completionRetryFieldsError(
-        'Recovered completion retry receipts are contradictory without evidence.',
-      );
-    }
-  } else if (value.evidencePushRequired) {
-    if (
-      value.localCommit !== value.evidenceCommit ||
-      value.remoteCommit !== value.projectRefCommit
-    ) {
-      throw completionRetryFieldsError(
-        'Recovered unpublished evidence receipts are contradictory.',
-      );
-    }
-  } else if (
-    value.localCommit !== value.evidenceCommit ||
-    value.remoteCommit !== value.evidenceCommit
+  if (
+    value.localCommit !== value.projectRefCommit ||
+    value.remoteCommit !== value.projectRefCommit
   ) {
     throw completionRetryFieldsError(
-      'Recovered published evidence receipts are contradictory.',
+      'Recovered completion retry receipts are contradictory.',
     );
   }
 
@@ -235,8 +204,6 @@ export function parseCompletionRetryFields(input) {
     'recovery',
     value.projectLinksPinCommit,
     value.projectRefCommit,
-    value.evidenceCommit ?? '-',
-    String(value.evidencePushRequired),
     value.prArtifactPath,
   ].join('\t');
 }

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

@@ -13,7 +13,22 @@ function shellQuote(value) {
 export function parseSyncedArchiveResumeFields(result) {
   const continuation = result?.continuation;
   const hasRecapExport = continuation?.projectRecapExport !== null;
+  const allowedContinuationFields = new Set([
+    'required',
+    'rejoinStep',
+    'archivePath',
+    'summaryExportFile',
+    'lifecycleCommit',
+    's3Path',
+    'selectedProjectRecapRun',
+    'projectRecapExport',
+    'exportedManifestPath',
+  ]);
   if (
+    !continuation ||
+    Object.keys(continuation).some(
+      (field) => !allowedContinuationFields.has(field),
+    ) ||
     result?.status !== 'ok' ||
     result?.route !== 'archive-resumed' ||
     result?.terminal !== true ||
@@ -25,21 +40,10 @@ export function parseSyncedArchiveResumeFields(result) {
     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 !== ''))
+        continuation.exportedManifestPath.length === 0)) ||
+    (!hasRecapExport && continuation.exportedManifestPath !== '')
   ) {
     throw fieldsError(
       'Synced archive resume result has no verified post-archive continuation.',
@@ -59,10 +63,7 @@ export function parseSyncedArchiveResumeFields(result) {
     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',
   };

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

@@ -7,7 +7,6 @@ const execFileAsync = promisify(execFile);
 
 const PIN_SOURCE_MESSAGE = 'chore(oat): finalize project lifecycle';
 const FINAL_ARTIFACT_MESSAGE = 'chore(oat): publish final project links';
-const EVIDENCE_MESSAGE = 'chore(oat): attest final project recap';
 const LINKS_START = '<!-- oat:project-links:start -->';
 const LINKS_END = '<!-- oat:project-links:end -->';
 const FULL_SHA = /^[0-9a-f]{40}$/;
@@ -91,23 +90,6 @@ 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,
@@ -394,7 +376,7 @@ export async function detectCompletionReceiptCandidate({
       'Retained ref must be a canonical OAT project ref.',
     );
   }
-  const receiptSubjects = new Set([FINAL_ARTIFACT_MESSAGE, EVIDENCE_MESSAGE]);
+  const receiptSubjects = new Set([FINAL_ARTIFACT_MESSAGE]);
   const head = await git(projectPath, ['rev-parse', 'HEAD']);
   const retained = await git(
     projectPath,
@@ -528,7 +510,6 @@ export async function recoverCompletionReceipts({
   projectPath,
   retainedRef,
   prArtifactPath,
-  evidencePaths = [],
   remote = 'origin',
 }) {
   if (typeof projectPath !== 'string' || projectPath.length === 0) {
@@ -552,13 +533,6 @@ export async function recoverCompletionReceipts({
       `Project checkout basename must match retained project ${expectedSlug}.`,
     );
   }
-  const exactEvidencePaths = evidencePaths.map((path, index) =>
-    requireRelativeGitPath(path, `Evidence path ${index + 1}`),
-  );
-  if (new Set(exactEvidencePaths).size !== exactEvidencePaths.length) {
-    throw completionReceiptError('Evidence paths must be unique.');
-  }
-
   const status = await git(projectPath, [
     'status',
     '--porcelain=v1',
@@ -594,60 +568,17 @@ export async function recoverCompletionReceipts({
   const expectedRepository = parseGitHubRepository(remoteUrl);
   const localSubject = await commitSubject(projectPath, localCommit);
 
-  let finalArtifactCommit;
-  let evidenceCommit = null;
-  let evidencePushRequired = false;
-
-  if (localSubject === FINAL_ARTIFACT_MESSAGE) {
-    if (
-      localCommit !== remoteCommit ||
-      localRetainedRefCommit !== localCommit
-    ) {
-      throw completionReceiptError(
-        'Final-artifact receipt recovery requires equal checkout, local retained ref, and remote retained ref commits.',
-      );
-    }
-    finalArtifactCommit = localCommit;
-  } else if (localSubject === EVIDENCE_MESSAGE) {
-    if (exactEvidencePaths.length === 0) {
-      throw completionReceiptError(
-        'Recap-evidence receipt recovery requires exact evidence paths.',
-      );
-    }
-    evidenceCommit = localCommit;
-    requireExactPaths(
-      await changedPaths(projectPath, evidenceCommit),
-      exactEvidencePaths,
-      'Recap evidence commit',
-    );
-    finalArtifactCommit = await singleParent(
-      projectPath,
-      evidenceCommit,
-      'Recap evidence commit',
-    );
-    if (remoteCommit === finalArtifactCommit) {
-      if (localRetainedRefCommit !== finalArtifactCommit) {
-        throw completionReceiptError(
-          'Unpublished recap evidence requires the local retained ref to remain at the final-artifact parent.',
-        );
-      }
-      evidencePushRequired = true;
-    } else if (remoteCommit === evidenceCommit) {
-      if (localRetainedRefCommit !== evidenceCommit) {
-        throw completionReceiptError(
-          'Published recap evidence requires equal local and remote retained refs.',
-        );
-      }
-    } else {
-      throw completionReceiptError(
-        'Recap-evidence recovery requires the remote retained ref to equal either the evidence commit or its final-artifact parent.',
-      );
-    }
-  } else {
+  if (localSubject !== FINAL_ARTIFACT_MESSAGE) {
     throw completionReceiptError(
       `HEAD subject ${JSON.stringify(localSubject)} is not an exact completion receipt.`,
     );
   }
+  if (localCommit !== remoteCommit || localRetainedRefCommit !== localCommit) {
+    throw completionReceiptError(
+      'Final-artifact receipt recovery requires equal checkout, local retained ref, and remote retained ref commits.',
+    );
+  }
+  const finalArtifactCommit = localCommit;
 
   if (
     (await commitSubject(projectPath, finalArtifactCommit)) !==
@@ -710,101 +641,6 @@ export async function recoverCompletionReceipts({
     remoteCommit,
     projectLinksPinCommit,
     projectRefCommit: finalArtifactCommit,
-    evidenceCommit,
-    evidencePushRequired,
-  };
-}
-
-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,
   };
 }
 
@@ -815,7 +651,7 @@ function parseBoolean(value, label) {
 }
 
 function parseArguments(argv) {
-  const result = { evidencePaths: [] };
+  const result = {};
   for (let index = 0; index < argv.length; index += 2) {
     const flag = argv[index];
     const value = argv[index + 1];
@@ -825,7 +661,6 @@ function parseArguments(argv) {
     if (flag === '--project-path') result.projectPath = value;
     else if (flag === '--retained-ref') result.retainedRef = value;
     else if (flag === '--pr-artifact') result.prArtifactPath = value;
-    else if (flag === '--evidence-path') result.evidencePaths.push(value);
     else if (flag === '--remote') result.remote = value;
     else if (flag === '--detect-candidate') {
       result.detectCandidate = parseBoolean(value, flag);

package/assets/skills/oat-project-complete/scripts/resolve-completion-retry.mjs

@@ -23,7 +23,7 @@ function completionRetryError(message) {
 }
 
 function parseArguments(argv) {
-  const result = { evidencePaths: [] };
+  const result = {};
   for (let index = 0; index < argv.length; index += 2) {
     const flag = argv[index];
     const value = argv[index + 1];
@@ -33,7 +33,6 @@ function parseArguments(argv) {
     if (flag === '--project-path') result.projectPath = value;
     else if (flag === '--retained-ref') result.retainedRef = value;
     else if (flag === '--pr-artifact') result.prArtifactPath = value;
-    else if (flag === '--evidence-path') result.evidencePaths.push(value);
     else if (flag === '--remote') result.remote = value;
     else throw completionRetryError(`Unsupported argument: ${flag}.`);
   }

package/assets/skills/oat-project-document/SKILL.md

@@ -6,7 +6,7 @@ disable-model-invocation: false
 user-invocable: true
 allowed-tools: Read, Write, Edit, Bash(git:*), Bash(jq:*), Bash(oat pjm:*), Bash(oat project push:*), Bash(oat project scope:*), Bash(oat tools:*), Glob, Grep, AskUserQuestion, Skill
 metadata:
-  version: 1.8.3
+  version: 1.8.4
 ---
 
 # Project Documentation Sync