@open-agent-toolkit/cli 0.2.77 → 0.2.79

package/assets/skills/recon/references/worker-contract.md

@@ -21,7 +21,7 @@ Reject an incomplete or contradictory assignment before reading sources. Never
 request credentials, mutate an investigated source, broaden scope, or choose an
 alternate write path.
 
-The manifest's ten wave modes map to the worker's closed seven-mode vocabulary:
+The manifest's nine wave modes map to the worker's closed six-mode vocabulary:
 
 | Manifest wave mode         | Worker assignment mode |
 | -------------------------- | ---------------------- |
@@ -31,7 +31,6 @@ The manifest's ten wave modes map to the worker's closed seven-mode vocabulary:
 | `semantic-verification`    | `verify`               |
 | `adversarial`              | `adversary`            |
 | `coverage`                 | `coverage`             |
-| `reconciliation`           | `reconcile`            |
 | `redundant-gather`         | `gather`               |
 | `redundant-verification`   | `verify`               |
 | `contradiction-resolution` | `adversary`            |
@@ -47,17 +46,16 @@ wave target; the worker neither selects nor upgrades it.
 - `gather`: inspect assigned sources and emit source-grounded findings with
   typed locators, minimal display excerpts, uncertainty, and contradictions.
 - `compile`: consume only designated dossiers and create a provisional claim
-  ledger candidate. Deduplicate without inventing evidence.
+  ledger candidate. Deduplicate without inventing evidence. Display excerpts
+  must be exact contiguous source substrings, except for the explicit
+  `redacted-exact` representation; never paraphrase an excerpt.
 - `verify`: consume an immutable verification brief, reopen only its declared
   sources, test locators and claim semantics, and report claim dispositions.
 - `adversary`: consume scope, questions, and provisional statements only; seek
   counterevidence, unsupported inference, and missing alternatives.
 - `coverage`: compare declared scope and questions with ledger coverage without
   reading gatherer reasoning.
-- `reconcile`: apply review dispositions and contradiction outcomes to a new
-  ledger candidate. Preserve prior revisions and never invent evidence.
-
-No other mode is valid.
+  No other mode is valid.
 
 ## Output Contract
 
@@ -83,11 +81,93 @@ Persist minimal excerpts only. Detect and redact secret spans before writing;
 never persist the secret or its sensitive-span digest. Finish by returning the
 artifact path and compact outcome only.
 
+Before returning, run the supplied deterministic validator against the sole
+unpromoted `writePath`. Correct an invalid candidate within the same accepted
+task and validate again. A terminal invalid candidate is `PASS_FAILED`; it does
+not authorize controller retry or replacement.
+
+Closed review-result examples (all omitted arrays are still required as shown):
+
+```json
+{
+  "kind": "recon.review-result",
+  "schemaVersion": 1,
+  "id": "review-semantic",
+  "runId": "run-1",
+  "reviewKind": "semantic",
+  "reviewerLane": "lane-semantic",
+  "status": "complete",
+  "brief": {
+    "path": "reviews/briefs/verify.json",
+    "digest": "sha256:0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  "permittedInputs": [],
+  "excludedInputs": [],
+  "dispositions": [],
+  "newEvidence": [],
+  "evidenceAssociations": [],
+  "coverageFindings": [],
+  "unresolvedIssues": []
+}
+```
+
+```json
+{
+  "kind": "recon.review-result",
+  "schemaVersion": 1,
+  "id": "review-adversarial",
+  "runId": "run-1",
+  "reviewKind": "adversarial",
+  "reviewerLane": "lane-adversarial",
+  "status": "complete",
+  "brief": {
+    "path": "reviews/briefs/adversary.json",
+    "digest": "sha256:0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  "permittedInputs": [],
+  "excludedInputs": [],
+  "dispositions": [],
+  "newEvidence": [],
+  "evidenceAssociations": [],
+  "coverageFindings": [],
+  "unresolvedIssues": []
+}
+```
+
+```json
+{
+  "kind": "recon.review-result",
+  "schemaVersion": 1,
+  "id": "review-coverage",
+  "runId": "run-1",
+  "reviewKind": "coverage",
+  "reviewerLane": "lane-coverage",
+  "status": "complete",
+  "brief": {
+    "path": "reviews/briefs/coverage.json",
+    "digest": "sha256:0000000000000000000000000000000000000000000000000000000000000000"
+  },
+  "permittedInputs": [],
+  "excludedInputs": [],
+  "dispositions": [],
+  "newEvidence": [],
+  "evidenceAssociations": [],
+  "coverageFindings": [],
+  "unresolvedIssues": []
+}
+```
+
 The controller validates the candidate against `packet-contract.md` with the
 bundled deterministic artifact validator. A validation failure quarantines the
 candidate; it never authorizes the worker to rewrite a shared artifact, retry,
 or launch a replacement.
 
+For an accepted launch, the approved-path artifact is authoritative over the
+return transport. If its identity, schema, bytes, and digest validate, a later
+stream-close diagnostic is non-material and the lane is complete. Missing or
+invalid output remains terminal `PASS_FAILED`; neither outcome authorizes a
+replacement launch.
+
 ## Invariants
 
 - Read only the assignment's allowed inputs using its source-read authority.

package/assets/skills/recon/scripts/create-review-brief.mjs

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 
-import { realpathSync } from 'node:fs';
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { dirname, relative, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 
 import { canonicalJson, hashFile } from './lib/canonical-json.mjs';
+import { isDirectExecution } from './lib/cli-entry.mjs';
 import { issue, isObject, validateArtifactShape } from './lib/contracts.mjs';
 import { assertSafeOutputPath } from './lib/safe-path.mjs';
 
@@ -442,29 +441,7 @@ async function main(argv) {
   process.stdout.write(`${JSON.stringify(reference, null, 2)}\n`);
 }
 
-/**
- * Direct invocation, compared as canonical paths on both sides. Comparing a raw
- * `process.argv[1]` against `import.meta.url` makes this script a silent no-op
- * that exits 0 whenever the skill is reached through a symlinked install root,
- * and canonicalizing only one side has the same effect under
- * `--preserve-symlinks-main`, which keeps the link in `import.meta.url`.
- * A path that cannot be canonicalized is not a module Node loaded as the entry
- * point, so a thrown `realpathSync` means "not invoked directly" and returns
- * `false`; it never masks a direct run.
- */
-function isDirectInvocation(invokedPath) {
-  if (!invokedPath) return false;
-  try {
-    return (
-      realpathSync(fileURLToPath(import.meta.url)) ===
-      realpathSync(resolve(invokedPath))
-    );
-  } catch {
-    return false;
-  }
-}
-
-if (isDirectInvocation(process.argv[1])) {
+if (isDirectExecution(import.meta.url)) {
   main(process.argv.slice(2)).catch((error) => {
     process.stderr.write(`${error instanceof Error ? error.message : error}\n`);
     process.exitCode = 1;

package/assets/skills/recon/scripts/lib/cli-entry.mjs

@@ -0,0 +1,21 @@
+import { realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/**
+ * Compare canonical paths on both sides so direct execution works through a
+ * symlinked install root, including with `--preserve-symlinks-main`. A path
+ * that cannot be canonicalized is not the loaded entry module, so resolution
+ * failure returns false without masking a direct run.
+ */
+export function isDirectExecution(moduleUrl, entryPath = process.argv[1]) {
+  if (!entryPath) return false;
+  try {
+    return (
+      realpathSync(fileURLToPath(moduleUrl)) ===
+      realpathSync(resolve(entryPath))
+    );
+  } catch {
+    return false;
+  }
+}

package/assets/skills/recon/scripts/lib/contracts.mjs

@@ -33,7 +33,6 @@ export const workerModes = [
   'verify',
   'adversary',
   'coverage',
-  'reconcile',
 ];
 export const evidenceRelations = [
   'supports',
@@ -49,7 +48,6 @@ export const waveModes = [
   'semantic-verification',
   'adversarial',
   'coverage',
-  'reconciliation',
   'redundant-gather',
   'redundant-verification',
   'contradiction-resolution',
@@ -67,6 +65,18 @@ export const conditionPredicates = [
   'unresolved-material-challenge',
 ];
 
+const reconciliationReviewPaths = Object.freeze({
+  'semantic-verification': 'reviews/semantic.json',
+  adversarial: 'reviews/adversarial.json',
+  coverage: 'reviews/coverage.json',
+  'redundant-verification': 'reviews/redundant-verification.json',
+  'contradiction-resolution': 'reviews/contradiction-resolution.json',
+});
+
+const singletonReviewWaveModes = new Set(
+  Object.keys(reconciliationReviewPaths),
+);
+
 function profilePolicy(
   orderedSingletonWaveModes,
   allowedWaveModes,
@@ -100,7 +110,6 @@ export const profileRoutingPolicy = Object.freeze({
       'semantic-verification',
       'adversarial',
       'coverage',
-      'reconciliation',
     ],
     [
       'map',
@@ -109,7 +118,6 @@ export const profileRoutingPolicy = Object.freeze({
       'semantic-verification',
       'adversarial',
       'coverage',
-      'reconciliation',
       'contradiction-resolution',
     ],
     [
@@ -131,7 +139,6 @@ export const profileRoutingPolicy = Object.freeze({
       'adversarial',
       'coverage',
       'redundant-verification',
-      'reconciliation',
     ],
     [
       'map',
@@ -142,7 +149,6 @@ export const profileRoutingPolicy = Object.freeze({
       'coverage',
       'redundant-gather',
       'redundant-verification',
-      'reconciliation',
       'contradiction-resolution',
     ],
     [
@@ -154,7 +160,7 @@ export const profileRoutingPolicy = Object.freeze({
       'redundant-verification',
       'contradiction-resolution',
     ],
-    { lanes: 20, concurrency: 8, conditions: 2 },
+    { lanes: 20, concurrency: 8, conditions: 1 },
   ),
 });
 
@@ -359,6 +365,7 @@ const executionV2Keys = new Set([
   'retryLimit',
   'waves',
   'conditions',
+  'reconciliation',
   'approval',
 ]);
 
@@ -410,6 +417,57 @@ function validateExecutionV2(value, errors, path) {
   requiredObject(value, 'approval', errors, path);
   validateApprovalEvidence(value.approval, errors, `${path}.approval`);
 
+  if (Object.hasOwn(value, 'reconciliation')) {
+    const reconciliation = value.reconciliation;
+    requiredObject(value, 'reconciliation', errors, path);
+    if (isObject(reconciliation)) {
+      closedObject(
+        reconciliation,
+        new Set([
+          'producer',
+          'inputLedger',
+          'outputLedger',
+          'outputReview',
+          'requiredReviews',
+          'conditionalReviews',
+        ]),
+        errors,
+        `${path}.reconciliation`,
+      );
+      for (const key of [
+        'producer',
+        'inputLedger',
+        'outputLedger',
+        'outputReview',
+      ]) {
+        requiredString(reconciliation, key, errors, `${path}.reconciliation`);
+      }
+      if (reconciliation.producer !== 'controller:reconcile-ledger-v1') {
+        errors.push(
+          issue(
+            'INVALID_RECONCILIATION_PRODUCER',
+            'Controller reconciliation must use controller:reconcile-ledger-v1',
+            `${path}.reconciliation.producer`,
+          ),
+        );
+      }
+      for (const key of ['requiredReviews', 'conditionalReviews']) {
+        requiredArray(reconciliation, key, errors, `${path}.reconciliation`);
+        for (const [index, item] of (reconciliation[key] ?? []).entries()) {
+          if (typeof item !== 'string' || item.length === 0) {
+            errors.push(
+              issue(
+                'INVALID_RECONCILIATION_PATH',
+                `${key} must contain non-empty paths`,
+                `${path}.reconciliation.${key}[${index}]`,
+              ),
+            );
+          }
+        }
+      }
+    }
+  }
+
   const waves = Array.isArray(value.waves) ? value.waves : [];
   const waveIds = new Set();
   const laneIds = new Set();
@@ -624,7 +682,8 @@ export function validateV2ProfileTopology(
   for (const [waveIndex, wave] of waves.entries()) {
     if (
       policy.allowedWaveModes.includes(wave?.mode) &&
-      !policy.countedLaneModes.includes(wave.mode) &&
+      (!policy.countedLaneModes.includes(wave.mode) ||
+        singletonReviewWaveModes.has(wave.mode)) &&
       Array.isArray(wave?.lanes) &&
       wave.lanes.length !== 1
     ) {
@@ -673,25 +732,77 @@ export function validateV2ProfileTopology(
       ),
     );
   }
-  const reconciliationIndexes = waves
-    .map((wave, index) => (wave?.mode === 'reconciliation' ? index : -1))
-    .filter((index) => index !== -1);
   const requiresReconciliation = ['standard', 'thorough'].includes(
     requestedProfile,
   );
-  if (
-    reconciliationIndexes.length > 1 ||
-    (requiresReconciliation && reconciliationIndexes.length !== 1) ||
-    reconciliationIndexes.some((index) => index !== waves.length - 1) ||
-    reconciliationIndexes.some((index) => waves[index]?.conditional === true)
-  ) {
+  if (requiresReconciliation !== isObject(execution.reconciliation)) {
     errors.push(
       issue(
         'INVALID_TERMINAL_TOPOLOGY',
-        'Standard and thorough routing require exactly one non-conditional terminal reconciliation wave',
-        `${path}.waves`,
+        'Standard and thorough routing require exactly one controller reconciliation declaration',
+        `${path}.reconciliation`,
       ),
     );
+  } else if (requiresReconciliation) {
+    const reconciliation = execution.reconciliation;
+    const expected = {
+      producer: 'controller:reconcile-ledger-v1',
+      inputLedger: 'raw/drafts/claims-v1.json',
+      outputLedger: 'raw/drafts/claims-v2.json',
+      outputReview: 'reviews/reconciliation.json',
+      requiredReviews: [
+        reconciliationReviewPaths['semantic-verification'],
+        reconciliationReviewPaths.adversarial,
+        reconciliationReviewPaths.coverage,
+      ],
+      conditionalReviews: [
+        reconciliationReviewPaths['redundant-verification'],
+        reconciliationReviewPaths['contradiction-resolution'],
+      ],
+    };
+    const matchesExpected =
+      ['producer', 'inputLedger', 'outputLedger', 'outputReview'].every(
+        (key) => reconciliation[key] === expected[key],
+      ) &&
+      ['requiredReviews', 'conditionalReviews'].every(
+        (key) =>
+          Array.isArray(reconciliation[key]) &&
+          reconciliation[key].length === expected[key].length &&
+          reconciliation[key].every(
+            (value, index) => value === expected[key][index],
+          ),
+      );
+    if (!matchesExpected) {
+      errors.push(
+        issue(
+          'INVALID_RECONCILIATION_PATH',
+          'Controller reconciliation paths and review sets must exactly match the closed manifest contract',
+          `${path}.reconciliation`,
+        ),
+      );
+    }
+    for (const [mode, reviewPath] of Object.entries(
+      reconciliationReviewPaths,
+    )) {
+      const matchingWaves = waves.filter((wave) => wave?.mode === mode);
+      if (matchingWaves.length !== 1 || matchingWaves[0].lanes?.length !== 1) {
+        continue;
+      }
+      const writeRoot = matchingWaves[0].lanes[0].writeRoot;
+      if (
+        typeof writeRoot === 'string' &&
+        reviewPath !== writeRoot &&
+        !reviewPath.startsWith(`${writeRoot}/`)
+      ) {
+        errors.push(
+          issue(
+            'INVALID_RECONCILIATION_PATH',
+            `${mode} output ${reviewPath} must be inside its approved write root`,
+            `${path}.waves`,
+          ),
+        );
+      }
+    }
   }
 
   const waveIndexes = new Map(
@@ -708,7 +819,6 @@ export function validateV2ProfileTopology(
     'predicate',
     'maxActivations',
   ]);
-  const terminalIndex = reconciliationIndexes[0] ?? -1;
   for (const [index, condition] of conditions.entries()) {
     const conditionPath = `${path}.conditions[${index}]`;
     if (
@@ -852,24 +962,10 @@ export function validateV2ProfileTopology(
         );
       }
     }
-    if (
-      terminalIndex !== -1 &&
-      destinationIndex !== undefined &&
-      destinationIndex >= terminalIndex
-    ) {
-      errors.push(
-        issue(
-          'INVALID_TERMINAL_TOPOLOGY',
-          'Conditional evidence waves must complete before the one terminal reconciliation',
-          `${conditionPath}.destinationWaveId`,
-        ),
-      );
-    }
   }
   for (const wave of waves) {
     if (
       wave?.conditional === true &&
-      wave.mode !== 'reconciliation' &&
       !policy.orderedSingletonWaveModes.includes(wave.mode) &&
       !conditionDestinations.has(wave.waveId)
     ) {
@@ -927,10 +1023,7 @@ export function validateV2ProfileTopology(
     );
   }
   const conditionalRequired = stageIndexes.find(
-    ({ mode, indexes }) =>
-      mode !== 'reconciliation' &&
-      indexes.length === 1 &&
-      waves[indexes[0]]?.conditional,
+    ({ indexes }) => indexes.length === 1 && waves[indexes[0]]?.conditional,
   );
   if (conditionalRequired) {
     errors.push(
@@ -2192,6 +2285,19 @@ function validateReviewResult(value, errors) {
   ]) {
     requiredArray(value, key, errors);
   }
+  if (Array.isArray(value.unresolvedIssues)) {
+    for (const [index, unresolvedIssue] of value.unresolvedIssues.entries()) {
+      if (typeof unresolvedIssue !== 'string') {
+        errors.push(
+          issue(
+            'INVALID_UNRESOLVED_ISSUE',
+            'unresolvedIssues members must be strings',
+            `$.unresolvedIssues[${index}]`,
+          ),
+        );
+      }
+    }
+  }
   if (
     ![
       'semantic',

package/assets/skills/recon/scripts/lib/routing.mjs

@@ -52,11 +52,6 @@ const economicalDefaults = Object.freeze({
       'Compare evidence with an explicit question or source inventory.',
     taskClass: 'mechanical-recon',
   }),
-  reconciliation: Object.freeze({
-    assignment:
-      'Assemble agreement and disagreement without deciding implications.',
-    taskClass: 'mechanical-recon',
-  }),
   'contradiction-resolution': Object.freeze({
     assignment: 'Seek discriminating evidence for a named contradiction.',
     taskClass: 'mechanical-recon',
@@ -172,6 +167,7 @@ function assertProposalExecution(manifest) {
       'retryLimit',
       'waves',
       'conditions',
+      'reconciliation',
       'approval',
     ]),
     'INVALID_ROUTING_PROPOSAL',
@@ -377,6 +373,7 @@ export function normalizeManifestRouting(manifest) {
       target: resolveEffectiveWaveTarget(execution, wave),
     })),
     conditions: clone(execution.conditions),
+    reconciliation: clone(execution.reconciliation ?? null),
     approval: clone(execution.approval),
   };
   return deepFreeze(routing);

package/assets/skills/recon/scripts/lib/validated-run.mjs

@@ -58,7 +58,7 @@ export function createValidatedRun({
     passes: normalizePasses(passes),
     achievedProfile,
     assuranceReviewIds: [...assuranceReviewIds].sort(),
-    terminalReconciliation: reconciliationContext?.reconciliation
+    controllerReconciliation: reconciliationContext?.reconciliation
       ? clone(reconciliationContext.reconciliation)
       : null,
     priorLedger: reconciliationContext?.priorLedger

package/assets/skills/recon/scripts/prepare-routing.mjs

@@ -1,10 +1,8 @@
 #!/usr/bin/env node
 
-import { realpathSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
 
+import { isDirectExecution } from './lib/cli-entry.mjs';
 import {
   checkApprovedWaveTarget,
   createRoutingPreview,
@@ -81,29 +79,7 @@ export async function main(argv = process.argv.slice(2)) {
   );
 }
 
-/**
- * Direct invocation, compared as canonical paths on both sides. Comparing a raw
- * `process.argv[1]` against `import.meta.url` makes this script a silent no-op
- * that exits 0 whenever the skill is reached through a symlinked install root,
- * and canonicalizing only one side has the same effect under
- * `--preserve-symlinks-main`, which keeps the link in `import.meta.url`.
- * A path that cannot be canonicalized is not a module Node loaded as the entry
- * point, so a thrown `realpathSync` means "not invoked directly" and returns
- * `false`; it never masks a direct run.
- */
-function isDirectInvocation(invokedPath) {
-  if (!invokedPath) return false;
-  try {
-    return (
-      realpathSync(fileURLToPath(import.meta.url)) ===
-      realpathSync(resolve(invokedPath))
-    );
-  } catch {
-    return false;
-  }
-}
-
-if (isDirectInvocation(process.argv[1])) {
+if (isDirectExecution(import.meta.url)) {
   main().catch((error) => {
     const code = error instanceof RoutingContractError ? error.code : 'ERROR';
     process.stderr.write(`${code}: ${error.message}\n`);