@open-agent-toolkit/cli 0.3.9 → 0.3.11

package/assets/skills/recon/scripts/render-packet.mjs

@@ -6,6 +6,12 @@ import { join, resolve } from 'node:path';
 
 import { hashFile } from './lib/canonical-json.mjs';
 import { isDirectExecution } from './lib/cli-entry.mjs';
+import {
+  affirmingDispositionByReviewKind,
+  classifyUnresolvedIssue,
+  requiredReviewKinds,
+  unresolvedIssuesBlockClaim,
+} from './lib/contracts.mjs';
 import {
   assertSafeExistingPath,
   assertSafeOutputPath,
@@ -99,7 +105,7 @@ function intendedRoutingSection(manifest, routing) {
     '',
     `- **Manifest routing version:** ${routing.sourceSchemaVersion}`,
     `- **Approved authority:** ${escapeInline(routing.authority)}`,
-    `- **Approved limits:** ${routing.waves.length} waves; ${routing.waves.reduce((count, wave) => count + wave.lanes.length, 0)} lanes; concurrency ${routing.maxConcurrency}; deadline ${routing.deadlineSeconds}s; retries ${routing.retryLimit}`,
+    `- **Approved limits:** ${routing.waves.length} waves; ${routing.waves.reduce((count, wave) => count + wave.lanes.length, 0)} lanes; concurrency ${routing.maxConcurrency}; deadline ${routing.deadlineSeconds}s; pre-acceptance admission retries per lane ${routing.retryLimit}`,
     '- **Evidence boundary:** These are normalized approved intended targets and root-recorded condition dispositions. They are not launcher receipts or observations of native runtime identity, usage, cost, or conclusion correctness.',
     '',
     '### Waves',
@@ -115,6 +121,88 @@ function intendedRoutingSection(manifest, routing) {
   ];
 }
 
+// The required reviews that gave `claimId` no disposition at all. Such a
+// claim stays below `verified`, like an uncertain one, and is listed as not
+// reviewed.
+function omittedReviews(claimId, reviews) {
+  return requiredReviewKinds
+    .map((kind) => reviews.find((review) => review.reviewKind === kind))
+    .filter(
+      (review) =>
+        review &&
+        !(review.dispositions ?? []).some((item) => item.claimId === claimId),
+    );
+}
+
+function issueText(entry) {
+  return typeof entry === 'string' ? entry : (entry?.text ?? '');
+}
+
+// Every claim an incorporated review kept below `verified` (an unresolved
+// issue that applies to it, a coverage finding that names it, a
+// non-affirming disposition, or a required review that left it without a
+// disposition), with the review's own words. Key-claim status
+// alone would let a `complete` packet hide a downgraded non-key claim.
+function reviewDowngradeLines(validatedRun) {
+  const { ledger, artifacts, assuranceReviewIds } = validatedRun;
+  const assurance = new Set(assuranceReviewIds);
+  const reviews = artifacts
+    .map(({ value }) => value)
+    .filter(
+      (value) =>
+        value.kind === 'recon.review-result' && assurance.has(value.id),
+    );
+  const lines = [];
+  for (const claim of ledger.claims) {
+    if (claim.status === 'verified') continue;
+    const reasons = [];
+    for (const review of reviews) {
+      const disposition = (review.dispositions ?? []).find(
+        (item) => item.claimId === claim.id,
+      );
+      if (!disposition) continue;
+      if (
+        disposition.disposition !==
+        affirmingDispositionByReviewKind[review.reviewKind]
+      ) {
+        reasons.push(`${review.reviewKind} review: ${disposition.disposition}`);
+      }
+      if (unresolvedIssuesBlockClaim(review, claim.id)) {
+        for (const entry of review.unresolvedIssues) {
+          const classification = classifyUnresolvedIssue(entry);
+          if (
+            classification.scope === 'claims' &&
+            !classification.claimIds.includes(claim.id)
+          ) {
+            continue;
+          }
+          const scope =
+            classification.scope === 'claims' ? 'issue' : 'global issue';
+          reasons.push(`${review.reviewKind} ${scope}: ${issueText(entry)}`);
+        }
+      }
+    }
+    for (const review of omittedReviews(claim.id, reviews)) {
+      reasons.push(
+        `${review.reviewKind} review: not reviewed (no disposition)`,
+      );
+    }
+    for (const review of reviews) {
+      for (const finding of review.coverageFindings ?? []) {
+        if (!finding.claimIds.includes(claim.id)) continue;
+        reasons.push(
+          `${finding.material ? 'material ' : ''}coverage finding ${finding.code}: ${finding.message}`,
+        );
+      }
+    }
+    if (reasons.length === 0) continue;
+    lines.push(
+      `**${escapeInline(claim.id)}** (${escapeInline(claim.status)}): ${escapeInline(claim.statement)} — ${reasons.map(escapeInline).join('; ')}`,
+    );
+  }
+  return lines;
+}
+
 export function renderPacketDocument(validatedRun) {
   const { manifest, ledger, routing } = assertValidatedRun(validatedRun);
   const evidenceById = new Map(
@@ -186,6 +274,10 @@ export function renderPacketDocument(validatedRun) {
       ),
     ),
     '',
+    '## Review Downgrades',
+    '',
+    ...bulletLines(reviewDowngradeLines(validatedRun)),
+    '',
     '## Unresolved Questions',
     '',
     ...bulletLines(

package/assets/skills/recon/scripts/validate-packet.mjs

@@ -3,15 +3,20 @@
 import { readFile, rm } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
 
+import { createReviewBrief } from './create-review-brief.mjs';
 import { hashCanonicalJson, hashFile, sha256 } from './lib/canonical-json.mjs';
 import { isDirectExecution } from './lib/cli-entry.mjs';
 import {
+  affirmingDispositionByReviewKind,
   isDigest,
   isObject,
   issue,
   profiles,
+  requiredReviewKinds,
+  unresolvedIssuesBlockClaim,
   validateArtifactShape,
 } from './lib/contracts.mjs';
+import { reviewBriefEntries } from './lib/review-binding.mjs';
 import { normalizeManifestRouting } from './lib/routing.mjs';
 import {
   assertCanonicalRoot,
@@ -1318,44 +1323,69 @@ function resolveTerminalReconciliation(
   };
 }
 
-function reviewBriefBindsClaim(brief, reviewKind, claim, ledger, manifest) {
-  const projected =
-    reviewKind === 'semantic' || reviewKind === 'redundant-verification'
-      ? brief?.claims?.find((item) => item.id === claim.id)
-      : reviewKind === 'adversarial' ||
-          reviewKind === 'contradiction-resolution'
-        ? brief?.provisionalStatements?.find((item) => item.id === claim.id)
-        : brief?.claims?.find((item) => item.id === claim.id);
-  if (!projected || projected.statement !== claim.statement) return false;
-  if (reviewKind !== 'semantic' && reviewKind !== 'redundant-verification') {
-    return Object.keys(projected).sort().join(',') === 'id,statement';
-  }
-  const evidenceById = new Map(ledger.evidence.map((item) => [item.id, item]));
-  const expectedEvidence = claim.evidence.map((link) => {
-    const evidence = evidenceById.get(link.evidenceId);
-    return evidence
-      ? {
-          id: evidence.id,
-          sourceId: evidence.sourceId,
-          displayExcerpt: evidence.displayExcerpt,
-          locator: evidence.locator,
-        }
-      : null;
-  });
-  if (
-    expectedEvidence.some((item) => !item) ||
-    hashCanonicalJson(projected.evidence) !==
-      hashCanonicalJson(expectedEvidence)
-  ) {
-    return false;
-  }
-  const sourceIds = new Set(expectedEvidence.map((item) => item.sourceId));
-  const expectedSources = manifest.sources.filter((source) =>
-    sourceIds.has(source.id),
-  );
-  return (
-    hashCanonicalJson(brief.sources) === hashCanonicalJson(expectedSources)
+// Brief integrity is one check: rebuild the brief with the production
+// generator from the prior ledger and the manifest, for the claim IDs it
+// lists, and require identical canonical JSON. Any edited, injected,
+// duplicated, or unprojected field differs, so no field-by-field binding is
+// needed. Briefs stay blind because the generator is the only projection.
+function checkReviewBrief(
+  brief,
+  reviewKind,
+  { manifest, ledger, rebuildReviewBrief = createReviewBrief },
+) {
+  const entryIds = reviewBriefEntries(brief, reviewKind).map(
+    (entry) => entry?.id,
   );
+  let rebuilt;
+  try {
+    rebuilt = rebuildReviewBrief({
+      id: brief.id,
+      mode: brief.mode,
+      createdAt: brief.createdAt,
+      manifest,
+      ledger,
+      claimIds: entryIds,
+    });
+  } catch (error) {
+    return {
+      ok: false,
+      entryIds,
+      reason: `rebuild failed: ${error instanceof Error ? error.message : error}`,
+    };
+  }
+  if (hashCanonicalJson(rebuilt) === hashCanonicalJson(brief)) {
+    return { ok: true, entryIds };
+  }
+  const keys = [...new Set([...Object.keys(brief), ...Object.keys(rebuilt)])]
+    .sort()
+    .filter(
+      (key) =>
+        !Object.hasOwn(brief, key) ||
+        !Object.hasOwn(rebuilt, key) ||
+        hashCanonicalJson(brief[key]) !== hashCanonicalJson(rebuilt[key]),
+    );
+  return { ok: false, entryIds, reason: `differs at ${keys[0]}` };
+}
+
+// One rebuild per distinct brief per validation pass. The key is the exact
+// artifact reference (path and digest) plus the review kind that selects the
+// brief's entries; the cache lives only as long as this pass's checker.
+function createBriefChecker({ manifest, ledger, rebuildReviewBrief }) {
+  const results = new Map();
+  return (briefEntry, reviewKind) => {
+    const key = `${briefEntry.reference?.path}\u0000${briefEntry.reference?.digest}\u0000${reviewKind}`;
+    if (!results.has(key)) {
+      results.set(
+        key,
+        checkReviewBrief(briefEntry.value, reviewKind, {
+          manifest,
+          ledger,
+          rebuildReviewBrief,
+        }),
+      );
+    }
+    return results.get(key);
+  };
 }
 
 function validateReviewBindings(
@@ -1365,6 +1395,7 @@ function validateReviewBindings(
   artifactsByPath,
   reconciliationContext,
   errors,
+  checkBrief,
 ) {
   const claims = new Map(ledger.claims.map((claim) => [claim.id, claim]));
   const priorLedger = reconciliationContext.priorLedger;
@@ -1378,11 +1409,12 @@ function validateReviewBindings(
     ) {
       continue;
     }
-    const brief = [...artifactsByPath.values()].find(
+    const briefEntry = [...artifactsByPath.values()].find(
       ({ reference, value }) =>
         sameReference(reference, result.brief) &&
         value.kind === 'recon.review-brief',
-    )?.value;
+    );
+    const brief = briefEntry?.value;
     const expectedMode =
       result.reviewKind === 'semantic' ||
       result.reviewKind === 'redundant-verification'
@@ -1401,27 +1433,26 @@ function validateReviewBindings(
       );
       continue;
     }
+    const check = checkBrief(briefEntry, result.reviewKind);
+    if (!check.ok) {
+      errors.push(
+        issue(
+          'REVIEW_BRIEF_MISMATCH',
+          `Review ${result.id} brief is not the production brief rebuilt from the prior ledger and manifest (${check.reason})`,
+          result.id,
+        ),
+      );
+    }
     const seen = new Set();
     for (const disposition of result.dispositions) {
-      const currentClaim = claims.get(disposition.claimId);
-      const priorClaim = priorClaims.get(disposition.claimId);
-      const claim = priorClaim ?? currentClaim;
-      const bindingLedger = priorClaim ? priorLedger : ledger;
       if (
-        !claim ||
         seen.has(disposition.claimId) ||
-        !reviewBriefBindsClaim(
-          brief,
-          result.reviewKind,
-          claim,
-          bindingLedger,
-          manifest,
-        )
+        !check.entryIds.includes(disposition.claimId)
       ) {
         errors.push(
           issue(
             'REVIEW_BRIEF_MISMATCH',
-            `Review ${result.id} dispositions must exactly match claim-bearing brief projections`,
+            `Review ${result.id} dispositions must be unique members of its brief's claims`,
             result.id,
           ),
         );
@@ -1869,16 +1900,13 @@ function validateReconciliation(
         );
       }
       if (disposition?.disposition === 'accepted-gap') {
+        // A material finding forces every named claim below `verified`, the
+        // same downgrade the reconciler applies. The reviewer's per-statement
+        // disposition may stay `covered`: a question omission is not a
+        // statement defect.
         for (const claimId of finding.claimIds) {
           const claim = currentClaims.get(claimId);
-          const coverageDisposition = coverage.dispositions.find(
-            (item) => item.claimId === claimId,
-          );
-          if (
-            finding.material === true &&
-            (claim?.status === 'verified' ||
-              coverageDisposition?.disposition !== 'gap')
-          ) {
+          if (finding.material === true && claim?.status === 'verified') {
             errors.push(
               issue(
                 'MATERIAL_COVERAGE_ASSURANCE_EXCEEDED',
@@ -1969,7 +1997,7 @@ function validateDerivedSourceGaps(manifest, ledger, errors) {
   }
 }
 
-function validateAssurance(validatedRun, errors) {
+function validateAssurance(validatedRun, errors, checkBrief) {
   const { manifest, ledger, achievedProfile } = validatedRun;
   const exactEvidence = new Set(validatedRun.exactEvidenceIds);
   const assuranceReviewIds = new Set(validatedRun.assuranceReviewIds);
@@ -1979,9 +2007,6 @@ function validateAssurance(validatedRun, errors) {
   const evidenceById = new Map(
     (ledger.evidence ?? []).map((item) => [item.id, item]),
   );
-  const priorClaims = new Map(
-    (validatedRun.priorLedger?.claims ?? []).map((claim) => [claim.id, claim]),
-  );
   const claimIds = new Set((ledger.claims ?? []).map((claim) => claim.id));
   for (const claimId of ledger.synthesis?.keyClaimIds ?? []) {
     if (!claimIds.has(claimId)) {
@@ -2056,14 +2081,12 @@ function validateAssurance(validatedRun, errors) {
           ),
         );
       }
-      const required = new Map([
-        ['semantic', 'affirmed'],
-        ['adversarial', 'unchallenged'],
-        ['coverage', 'covered'],
-      ]);
-      if (achievedProfile === 'thorough') {
-        required.set('redundant-verification', 'affirmed');
-      }
+      const required = new Map(
+        [
+          ...requiredReviewKinds,
+          ...(achievedProfile === 'thorough' ? ['redundant-verification'] : []),
+        ].map((kind) => [kind, affirmingDispositionByReviewKind[kind]]),
+      );
       const satisfied = new Set();
       const reviewerLanes = new Set();
       for (const reviewId of new Set(claim.reviewIds ?? [])) {
@@ -2128,11 +2151,12 @@ function validateAssurance(validatedRun, errors) {
           );
         }
         reviewerLanes.add(artifact.reviewerLane);
-        const brief = [...artifactsById.values()].find(
+        const briefEntry = [...artifactsById.values()].find(
           ({ reference, value }) =>
             sameReference(reference, artifact.brief) &&
             value.kind === 'recon.review-brief',
-        )?.value;
+        );
+        const brief = briefEntry?.value;
         const expectedMode =
           artifact.reviewKind === 'semantic' ||
           artifact.reviewKind === 'redundant-verification'
@@ -2141,17 +2165,15 @@ function validateAssurance(validatedRun, errors) {
                 artifact.reviewKind === 'contradiction-resolution'
               ? 'adversary'
               : 'coverage';
+        const briefCheck = brief
+          ? checkBrief(briefEntry, artifact.reviewKind)
+          : null;
         if (
           !brief ||
           brief.runId !== ledger.runId ||
           brief.mode !== expectedMode ||
-          !reviewBriefBindsClaim(
-            brief,
-            artifact.reviewKind,
-            priorClaims.get(claim.id) ?? claim,
-            priorClaims.has(claim.id) ? validatedRun.priorLedger : ledger,
-            manifest,
-          ) ||
+          !briefCheck.ok ||
+          !briefCheck.entryIds.includes(claim.id) ||
           !artifact.permittedInputs?.some((reference) =>
             sameReference(reference, artifact.brief),
           )
@@ -2168,9 +2190,7 @@ function validateAssurance(validatedRun, errors) {
           (item) => item.claimId === claim.id,
         );
         const expectedDisposition =
-          artifact.reviewKind === 'contradiction-resolution'
-            ? 'resolved'
-            : required.get(artifact.reviewKind);
+          affirmingDispositionByReviewKind[artifact.reviewKind];
         if (
           dispositions.length !== 1 ||
           dispositions[0].disposition !== expectedDisposition
@@ -2183,11 +2203,11 @@ function validateAssurance(validatedRun, errors) {
             ),
           );
         }
-        if ((artifact.unresolvedIssues ?? []).length > 0) {
+        if (unresolvedIssuesBlockClaim(artifact, claim.id)) {
           errors.push(
             issue(
               'REVIEW_DISPOSITION_MISMATCH',
-              `Review ${reviewId} retains unresolved issues`,
+              `Review ${reviewId} retains an unresolved issue that applies to this claim`,
               claim.id,
             ),
           );
@@ -2280,7 +2300,12 @@ function validateAssurance(validatedRun, errors) {
   }
 }
 
-export async function compileValidatedRun(packetDirectory) {
+// `rebuildReviewBrief` is a test seam for counting brief rebuilds; production
+// callers use the default generator.
+export async function compileValidatedRun(
+  packetDirectory,
+  { rebuildReviewBrief = createReviewBrief } = {},
+) {
   const packetRoot = resolve(packetDirectory);
   const errors = [];
   const warnings = [];
@@ -2532,6 +2557,11 @@ export async function compileValidatedRun(packetDirectory) {
         errors,
       );
     }
+    const checkBrief = createBriefChecker({
+      manifest,
+      ledger: reconciliationContext.priorLedger ?? ledger,
+      rebuildReviewBrief,
+    });
     validateReviewBindings(
       manifest,
       ledger,
@@ -2539,6 +2569,7 @@ export async function compileValidatedRun(packetDirectory) {
       artifactsByPath,
       reconciliationContext,
       errors,
+      checkBrief,
     );
     validateReconciliation(
       manifest,
@@ -2586,7 +2617,7 @@ export async function compileValidatedRun(packetDirectory) {
         assuranceReviewIds,
         reconciliationContext,
       });
-      validateAssurance(validatedRun, errors);
+      validateAssurance(validatedRun, errors, checkBrief);
     }
 
     const valid = errors.length === 0;

package/assets/skills/subagent-orchestration/SKILL.md

@@ -4,7 +4,7 @@ description: Use when delegating work to subagents or choosing a model for a tas
 compatibility: Self-contained; no OAT installation required.
 user-invocable: true
 metadata:
-  version: 1.0.10
+  version: 1.0.11
 ---
 
 # Subagent Orchestration

package/assets/skills/subagent-orchestration/references/evidence-and-refresh.md

@@ -1,10 +1,10 @@
 # Evidence and Refresh Policy
 
 ```yaml
-guidance_version: 2026-09-24
-last_verified: 2026-09-24
-review_after: 2026-10-08
-stale_after: 2026-10-23
+guidance_version: 2026-10-01
+last_verified: 2026-10-01
+review_after: 2026-10-15
+stale_after: 2026-10-30
 ```
 
 This file governs dated provider examples. It does not override a live catalog,
@@ -17,7 +17,9 @@ authorization boundary.
 - `review-required`: older than 45 days, a newer family is observed, or a material control, price, tool, context, alias, or harness change is detected.
 - `stale`: older than 90 days, named models are unavailable or deprecated, or the launching surface can no longer express the recorded controls.
 
-The named routes were refreshed against provider catalogues on 2026-09-23.
+The October 1 availability refresh adds GPT-6.1 Sol and Sonnet 5.5 support;
+it migrates active Codex Sol selectors by user direction while preserving
+efforts. Earlier provider observations retain their own dates.
 The benchmark observations below remain dated to 2026-07-25 and require
 review before making a new cross-provider performance claim. Each provider
 reference carries its own verification date; availability refresh does not
@@ -83,8 +85,9 @@ publish a provider-independent effort conversion.
   explicit user direction. No local task evaluation establishes an Astra
   advantage, and this preference is not acceptance by the separately
   maintained model-selection policy.
-- GPT-6 Sol and Luna are selectable in the current Codex catalogue and are
-  the default new-work routes in `provider-codex.md`. GPT-5.6 Sol/Luna/Terra
+- GPT-6.1 Sol and GPT-6 Luna are the default new-work selectors in
+  `provider-codex.md`. The Sol migration preserves existing effort choices,
+  including medium for intelligent recon. GPT-6 Sol and GPT-5.6 Sol/Luna/Terra
   remain supported for explicit configurations. The July independent coding
   data on GPT-5.6 Luna/Terra supported a mechanical floor of Luna high; this
   is historical evidence, not a measured GPT-6 performance comparison.
@@ -93,7 +96,12 @@ publish a provider-independent effort conversion.
   evidence. Earlier Opus 5 effort observations are historical and do not
   establish an Opus 5.5 benchmark result. Consequence adds independent review
   rather than automatically raising effort.
-- Sonnet 5 is a conditional route when measured latency, throughput, access,
+- Sonnet 5.5 is a supported Claude conditional route and the user-selected
+  Economy medium candidate. Cursor 3.22.12 native probes matched Sonnet 5.5
+  exact-ID pins; its bracket-form pins fell back. Every pin requires its own
+  approved evidence and registry entry. Sonnet 5 remains
+  supported for compatibility and established workflows. Sonnet is a
+  conditional route when measured latency, throughput, access,
   rate limits, or end-to-end workload economics win. Fable 5 is an
   eligibility-gated specialist; its missing-domain-concept or long-horizon
   reviewer instantiation remains provisional, and zero-data-retention
@@ -195,6 +203,10 @@ component it cannot resolve. Probe a non-default rung as well, or a result that
 merely matches the family default cannot distinguish an honored parameter from
 an ignored one.
 
+An exact-ID Cursor pin meets the same evidence gate as a bracket-form pin;
+CLI catalog presence alone never permits generic pass-through. The Sonnet 5.5
+refresh uses explicit exact-ID mappings because its bracket-form pins fell back.
+
 The six Cursor `claude-opus-5` and `claude-opus-4-8` mappings shipped on
 2026-07-25 met this gate; their resolved identities are listed in
 `provider-cursor.md`.

package/assets/skills/subagent-orchestration/references/provider-claude.md

@@ -1,7 +1,7 @@
 ---
-guidance_version: 2026-09-23
-last_verified: 2026-09-23
-review_after: 2026-12-22
+guidance_version: 2026-10-01
+last_verified: 2026-10-01
+review_after: 2026-12-30
 ---
 
 # Claude Model Selection
@@ -17,7 +17,12 @@ the dated model examples below. Launch mechanics for OAT dispatch live in
   high-volume, mechanically verified work.
 - `claude-opus-5-5`: normal substantive route and the default for
   interpretation-heavy implementation, hard reasoning, and consequential work.
-- `claude-sonnet-5`: conditional route when measured latency, throughput,
+- `claude-sonnet-5-5`: supported conditional route at `low`, `medium`,
+  `high`, `xhigh`, and `max`; qualify it against the relevant Opus route on
+  representative work. The bundled Economy tier selects medium by explicit
+  user direction; this is separate from task-performance qualification.
+- `claude-sonnet-5`: supported compatibility and established-workflow route
+  when measured latency, throughput,
   access, rate limits, or established-workflow economics beat the relevant
   Opus route.
 - `claude-fable-5-1`: eligibility-gated specialist for a directly relevant
@@ -45,6 +50,12 @@ host.
   is the bottleneck or an evaluated long-horizon workload benefits. Max is
   exceptional and requires a workload-specific effort sweep or an explicit
   quality-first exception.
+- Sonnet 5.5: availability and its five efforts are documented in the
+  [Sonnet 5.5 overview](https://platform.claude.com/docs/en/models/sonnet-5-5/overview)
+  and [effort reference](https://platform.claude.com/docs/en/build-with-claude/effort).
+  The existing conditional-route posture applies; availability is not an
+  evaluated workload ranking. Check the installed Claude Code version and
+  returned assistant model before launch.
 - Sonnet 5: use medium or high only when measured latency, throughput, access,
   or workload economics justify the conditional route. Do not preserve xhigh
   or max as generic workhorse settings.
@@ -65,13 +76,13 @@ These routes are dated guidance and benchmark-derived routing hypotheses.
 Evaluate them on representative local work before treating fine boundaries as
 stable.
 
-| Task class               | Default                               | Economy                                                | Escalation                                            | Floor notes                                                                                     |
-| ------------------------ | ------------------------------------- | ------------------------------------------------------ | ----------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
-| `mechanical-recon`       | Haiku 4.5                             | Same, with strict output and mechanical verification   | Opus 5.5 medium                                       | Haiku is below floor for semantic audits and silent-miss-prone exploration.                     |
-| `intelligent-recon`      | Opus 5.5 low                          | Sonnet 5 medium/high only when its measured route wins | Opus 5.5 medium; high when deeper reasoning is needed | Verify silent-miss-prone conclusions; do not use Sonnet low for open-ended recon.               |
-| `default-implementation` | Opus 5.5 medium                       | Sonnet 5 medium/high for evaluated bounded throughput  | Opus 5.5 high                                         | Fable is not a routine implementation or economy route.                                         |
-| `hard-reasoning`         | Opus 5.5 high                         | Opus 5.5 medium only after narrowing and evaluation    | Opus 5.5 xhigh for a reasoning-depth bottleneck       | Use max only after a workload-specific effort sweep.                                            |
-| `consequential`          | Opus 5.5 high plus independent review | No routine economy route                               | Opus 5.5 xhigh when deeper reasoning is also required | Consequence adds review and root authorization; it does not automatically require xhigh or max. |
+| Task class               | Default                               | Economy                                                  | Escalation                                            | Floor notes                                                                                     |
+| ------------------------ | ------------------------------------- | -------------------------------------------------------- | ----------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
+| `mechanical-recon`       | Haiku 4.5                             | Same, with strict output and mechanical verification     | Opus 5.5 medium                                       | Haiku is below floor for semantic audits and silent-miss-prone exploration.                     |
+| `intelligent-recon`      | Opus 5.5 low                          | Sonnet 5.5 medium/high only when its measured route wins | Opus 5.5 medium; high when deeper reasoning is needed | Verify silent-miss-prone conclusions; do not use Sonnet low for open-ended recon.               |
+| `default-implementation` | Opus 5.5 medium                       | Sonnet 5.5 medium/high for evaluated bounded throughput  | Opus 5.5 high                                         | Fable is not a routine implementation or economy route.                                         |
+| `hard-reasoning`         | Opus 5.5 high                         | Opus 5.5 medium only after narrowing and evaluation      | Opus 5.5 xhigh for a reasoning-depth bottleneck       | Use max only after a workload-specific effort sweep.                                            |
+| `consequential`          | Opus 5.5 high plus independent review | No routine economy route                                 | Opus 5.5 xhigh when deeper reasoning is also required | Consequence adds review and root authorization; it does not automatically require xhigh or max. |
 
 ## Root and Subagent Cost Posture
 
@@ -108,7 +119,9 @@ verified before selection.
 
 Eligibility filters the candidate set before capability or economy is compared.
 A route that fails one of these gates is unavailable regardless of benchmark
-standing. The non-Opus constraints are dated observations; reverify against the live
+standing. The table below records existing generations; it does not establish Sonnet 5.5
+retention, service tiers, or context limits. Verify those separately.
+The non-Opus constraints are dated observations; reverify against the live
 schema and the organization's actual plan before launch. Do not transfer Opus 5
 service-tier or retention claims to Opus 5.5 without fresh evidence.