ruvnet-brain 4.3.20 → 4.3.25

package/scripts/updater-manifest.mjs

@@ -0,0 +1,162 @@
+/**
+ * scripts/updater-manifest.mjs — every shipped repository store gets a complete, honestly-provenanced
+ * updater entry in SOURCE.json.
+ *
+ * WHY (measured 2026-09-15). A full local build reached bundle assembly and was refused:
+ * "2bottalk: sealed corpus SOURCE.json carries no updater entry for this repository store". The corpus
+ * carried 194 repository stores; SOURCE.json carried entries for 94, and of those, 90 were exactly the
+ * stores refreshed that run. Zero of the 100 missing had been refreshed. The worker path is correct —
+ * corpus-reconcile's validateWorkerOutput requires an entry for each store a worker builds — so the gap
+ * is purely INHERITANCE from the pinned bootstrap seed, whose own SOURCE.json never covered them.
+ * build-bundle refuses rather than ship a store with no self-update configuration, which is right.
+ *
+ * THE RULE (Dual, decision A, verifier APPROVE_WITH_REQUIRED_IMPLEMENTATION_CONDITIONS): backfill
+ * deterministically from the corpus's OWN authenticated records, and never let a migration masquerade
+ * as a build.
+ *   - `builtUtc` is the ORIGINAL artifact build time from the ledger. Never the migration time.
+ *   - `builder` and `sourceDescribe` are preserved when evidenced and otherwise explicitly null.
+ *     A fallback that fabricated "rvf-kb-forge" or reconstructed a git describe string is forbidden.
+ *   - `contentOrigin` (inherited | built-this-generation) and `metadataOrigin` (worker-produced |
+ *     inherited-existing | backfilled-from-seed-ledger) are recorded SEPARATELY for every store,
+ *     because metadata written now does not make the content new.
+ *   - Pinned is not automatically authenticated and unrefreshed is not automatically byte-identical:
+ *     an entry is only synthesized after the artifact on disk matches the ledger's digest and size.
+ *     A store that fails that check is reported, never quietly backfilled — it needs a real rebuild.
+ *   - Only REPOSITORY stores require an entry; aggregates and derived stores are classified out, using
+ *     the same rule build-bundle applies.
+ *   - `updateManaged: false` is preserved exactly: a store deliberately excluded from self-update stays
+ *     excluded.
+ * Deterministic and idempotent: keys are sorted and a second run over its own output changes nothing.
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const UPDATER_MANIFEST_VERSION = 'updater-manifest-normalization/1';
+export const GIST_AGGREGATE_STORE = 'ruv-gists';
+const SAFE_STORE = /^[a-z0-9][a-z0-9._-]*$/i;
+
+const sha256File = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const readJson = (file) => JSON.parse(fs.readFileSync(file, 'utf8'));
+
+/** Same classification build-bundle uses: the gist aggregate, the derived registry, else a repository. */
+export function classifyStore(store, derivedStores) {
+  const folded = String(store).toLowerCase();
+  if (folded === GIST_AGGREGATE_STORE) return 'gist-aggregate';
+  return derivedStores.has(folded) ? 'derived' : 'repository';
+}
+
+export function derivedStoreSet(assetsDir) {
+  const file = path.join(assetsDir, 'public-store-classes.json');
+  if (!fs.existsSync(file)) return new Set();
+  const classes = readJson(file);
+  return new Set((classes?.derived || []).map((entry) => String(entry?.store || entry || '').toLowerCase()).filter(Boolean));
+}
+
+/**
+ * Normalize SOURCE.json in place. Returns a summary; it never throws for a missing entry — the caller
+ * decides, because a store whose artifact cannot be verified needs a rebuild rather than a synthesized row.
+ */
+export function normalizeUpdaterManifest({ assetsDir, coverage, refreshedStores = [], seedIdentity = null }) {
+  const assets = path.resolve(assetsDir || '');
+  const sourceFile = path.join(assets, 'SOURCE.json');
+  const ledgerFile = path.join(assets, 'RVF-GENERATIONS.json');
+  if (!fs.existsSync(ledgerFile)) throw new Error(`updater normalization needs the generation ledger (${ledgerFile})`);
+  const source = fs.existsSync(sourceFile) ? readJson(sourceFile) : { builder: 'rvf-kb-forge', stores: {} };
+  if (!source.stores || typeof source.stores !== 'object' || Array.isArray(source.stores)) {
+    throw new Error('SOURCE.json is malformed (expected an object with a stores object)');
+  }
+  const ledger = readJson(ledgerFile);
+  const ledgerSha256 = sha256File(ledgerFile);
+  const derived = derivedStoreSet(assets);
+  const refreshed = new Set(refreshedStores.map((s) => String(s).toLowerCase()));
+  const urlByStore = new Map();
+  for (const row of coverage?.rows || []) {
+    const store = String(row?.artifact?.store || '').toLowerCase();
+    if (store && row?.url && !urlByStore.has(store)) urlByStore.set(store, row.url);
+  }
+
+  const stores = fs.readdirSync(assets).filter((f) => f.endsWith('.big.rvf')).map((f) => f.slice(0, -'.big.rvf'.length)).sort();
+  const normalized = {};
+  const backfilled = [];
+  const unverified = [];
+  const classification = { repository: 0, 'gist-aggregate': 0, derived: 0 };
+
+  for (const store of stores) {
+    const kind = classifyStore(store, derived);
+    classification[kind] += 1;
+    const existing = source.stores[store] ?? source.stores[Object.keys(source.stores).find((k) => k.toLowerCase() === store.toLowerCase()) ?? ''];
+    const contentOrigin = refreshed.has(store.toLowerCase()) ? 'built-this-generation' : 'inherited';
+    if (existing && typeof existing === 'object') {
+      // An entry that was BACKFILLED keeps that provenance forever: re-running normalization must not
+      // quietly relabel synthesized metadata as though the seed had shipped it. Only an entry with no
+      // recorded metadataOrigin gets one derived, which is also what makes this idempotent.
+      const metadataOrigin = typeof existing.metadataOrigin === 'string' && existing.metadataOrigin
+        ? existing.metadataOrigin
+        : (contentOrigin === 'built-this-generation' ? 'worker-produced' : 'inherited-existing');
+      normalized[store] = sortKeys({ ...existing, contentOrigin, metadataOrigin });
+      continue;
+    }
+    if (kind !== 'repository') continue; // only repository stores require an updater entry
+    if (!SAFE_STORE.test(store)) { unverified.push({ store, reason: 'unsafe store name' }); continue; }
+
+    // Pinned is not authenticated, and unrefreshed is not byte-identical: verify before synthesizing.
+    const generation = ledger?.stores?.[store]
+      ?? Object.entries(ledger?.stores || {}).find(([k]) => k.toLowerCase() === store.toLowerCase())?.[1];
+    if (!generation) { unverified.push({ store, reason: 'no generation record in the corpus ledger' }); continue; }
+    const rvf = path.join(assets, `${store}.big.rvf`);
+    const bytes = fs.statSync(rvf).size;
+    const digest = sha256File(rvf);
+    if (generation.sha256 !== digest || generation.bytes !== bytes) {
+      unverified.push({ store, reason: 'artifact on disk does not match its ledger digest or size' });
+      continue;
+    }
+    const url = urlByStore.get(store.toLowerCase()) ?? null;
+    if (!url) { unverified.push({ store, reason: 'no coverage row supplies an upstream repository URL' }); continue; }
+
+    normalized[store] = sortKeys({
+      kbName: store,
+      sourceRepo: url,
+      sourceCommit: generation.sourceCommit ?? null,
+      // Preserved, never reconstructed. An absent historical value is stated as unknown.
+      sourceDescribe: generation.sourceDescribe ?? null,
+      builtUtc: generation.builtUtc ?? null,
+      builder: generation.builder ?? null,
+      // Per-store nulls are correct while the TOP-LEVEL discovery contract supplies the endpoint.
+      canonicalManifestUrl: null,
+      canonicalBundleUrl: null,
+      selfUpdate: `node forge-update.mjs ${store}`,
+      contentOrigin: 'inherited',
+      metadataOrigin: 'backfilled-from-seed-ledger',
+      inheritanceEvidence: sortKeys({
+        ledgerSha256,
+        artifactSha256: digest,
+        artifactBytes: bytes,
+        sourceCommit: generation.sourceCommit ?? null,
+        builtUtc: generation.builtUtc ?? null,
+        seedTag: seedIdentity?.tag ?? null,
+        seedSha256: seedIdentity?.sha256 ?? null,
+      }),
+      migrationIdentity: UPDATER_MANIFEST_VERSION,
+    });
+    backfilled.push(store);
+  }
+
+  const out = { ...source, stores: sortKeys(normalized) };
+  fs.writeFileSync(sourceFile, `${JSON.stringify(out, null, 2)}\n`);
+  const required = stores.filter((s) => classifyStore(s, derived) === 'repository');
+  const missing = required.filter((s) => !normalized[s]);
+  return {
+    version: UPDATER_MANIFEST_VERSION,
+    classification,
+    requiredRepositoryStores: required.length,
+    entries: Object.keys(normalized).length,
+    backfilled,
+    unverified,
+    missing,
+  };
+}
+
+function sortKeys(value) {
+  return Object.fromEntries(Object.keys(value).sort().map((k) => [k, value[k]]));
+}

package/scripts/verify-channels.mjs

@@ -29,6 +29,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
+import { describeLatestPointer, latestCodeReleaseTag } from './release-channel-kind.mjs';
 
 const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 const JSON_OUT = process.argv.includes('--json');
@@ -133,20 +134,31 @@ async function run() {
   // place of the thing (receipt-count for "is routing running", backlog-remaining for "is promotion in
   // force", cache-exists for "is this measurement current"). Reachability is the proxy; version is the
   // thing. Users updating via the release bundle get whatever THIS says, not whatever npm says.
+  // ADR-086 S1: `releases/latest` is the CUSTOMER download pointer and may legitimately be a corpus
+  // generation (`corpus-sha256-<digest>`), which can never equal a semver. Asking that pointer "are
+  // you the shipping version?" therefore stopped being the right question the moment corpus
+  // promotion existed — and because release.mjs runs this script as `runOrDie` in step E, the wrong
+  // question would have failed the OWNER'S OWN preflight every time a corpus night succeeded. The
+  // code generation is a separate fact, so it gets asked separately.
   {
-    let tag = null, err = null;
+    let releases = null, tag = null, latestPointer = null, err = null;
     try {
-      const r = await fetch(`https://api.github.com/repos/${REPO}/releases/latest`, {
+      const r = await fetch(`https://api.github.com/repos/${REPO}/releases?per_page=30`, {
         headers: { 'User-Agent': 'ruvnet-brain-verify-channels' },
       });
-      if (r.ok) tag = (await r.json()).tag_name || null; else err = `HTTP ${r.status}`;
+      if (r.ok) {
+        releases = await r.json();
+        tag = latestCodeReleaseTag(releases);
+        latestPointer = (Array.isArray(releases) ? releases.find((row) => row && !row.draft) : null)?.tag_name || null;
+      } else err = `HTTP ${r.status}`;
     } catch (e) { err = String(e && e.message || e); }
     // Tags carry a leading `v`; the version does not. Compare the bare versions.
     const bare = (s) => String(s || '').replace(/^v/, '');
+    const pointerNote = latestPointer ? ` · ${describeLatestPointer(latestPointer)}` : '';
     check('GitHub Release IS the shipping version', tag != null && bare(tag) === bare(V),
       tag == null
-        ? `could not read releases/latest (${err}) — release currency NOT verified`
-        : `release=${tag} · shipping=${V}${bare(tag) === bare(V) ? '' : `  ← ${bare(tag) !== bare(V) ? 'STALE: the release channel is behind npm. Cut the release, or users on --update stay on ' + tag : ''}`}`);
+        ? `could not read the latest code release (${err || 'no semver-tagged release found'}) — release currency NOT verified`
+        : `code release=${tag} · shipping=${V}${pointerNote}${bare(tag) === bare(V) ? '' : '  ← STALE: the release channel is behind npm. Cut the release, or users on --update stay on ' + tag}`);
   }
 
   // 4) release signature present (auto-apply verifies against it)

package/scripts/wired-check.mjs

@@ -51,7 +51,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { loadLessons, TRIGGERS, STATUS } from './lesson-store.mjs';
-import { isAllowedContinuityRegistration } from '../plugin/scripts/continuity-hook-policy.mjs';
+import { continuityRegistrations, isAllowedContinuityRegistration } from '../plugin/scripts/continuity-hook-policy.mjs';
 
 const REPO = path.resolve(import.meta.dirname, '..');
 const argv = process.argv.slice(2);
@@ -70,11 +70,23 @@ const argv = process.argv.slice(2);
  * every entry on every run, below, so they cannot rot unseen.
  */
 const STANDALONE = [
+  ['spike-run', 'ADR-086 Step 14 oracle feasibility-spike driver, run by hand against disposable snapshots outside the checkout. '
+    + 'It is deliberately NOT imported by the pipeline: Step 14 only proves or disproves that a trustworthy unattended label '
+    + 'producer exists, and Step 15 owns any prepareCorpusCandidate wiring. The three modules it drives (source-units, '
+    + 'produce-questions, validate-labels) are each wired to a real caller; this driver is the human entry point.'],
   ['gate', 'retired automatic-hook helper and manual benchmark retained for explicit human use; no workflow or scheduler invokes this expensive command'],
   ['dream-issue-gate', 'pure Dream Cycle disposition policy; invoked by the external issue adapter, never a GitHub writer'],
   ['sync-census', 'explicit maintainer census writer; a destructive source-to-surface refresh is never scheduled'],
   ['sync-commands', 'explicit maintainer alias synchronizer; run deliberately before release, never from a lifecycle hook'],
   ['version-bump-gate', 'retired automatic interceptor; explicit version checks own release validation'],
+  ['project-progression-checkpoint', 'the body of the shipped `/ruvnet-brain:checkpoint` command '
+    + '(plugin/commands/checkpoint.md:39; added a7167b6b 2026-09-11). The command host executes that '
+    + 'instruction, and this check does not scan command markdown — the same shape as '
+    + '`onboarding-console` below. Recorded 2026-09-11 when wired-check first named it.'],
+  ['handoff-asset', 'client explainer handoff to a named host, run by a human per docs/CLIENT-ASSET-HANDOFF.md '
+    + '(added 32b7b7ca 2026-09-11 with the TriSmart sub-product); nothing may schedule a copy to a client '
+    + 'machine. Surfaced 2026-09-11 the first time wired-check ran with no agent worktrees under '
+    + '.claude/worktrees/ — their package.json copies had been counted as callers all day.'],
   ['lesson-seed', 'one-shot seeding, run deliberately by a human'],
   ['lesson-ratify', 'the human control surface — a CLI is its entire purpose'],
   ['stamp-sweep', 'ADR-056 §2 — the ONE-TIME backfill half of the stamp rule. A human runs it once '
@@ -101,10 +113,6 @@ const STANDALONE = [
     + 'RVFs to RVF-GENERATIONS.json and optionally prunes legacy sidecars; build-bundle.mjs consumes '
     + 'and validates the resulting manifest, so scheduling this destructive migration would be wrong'],
   ['release', 'the ship path, run by a human'],
-  ['corpus-seed-publish', 'privileged manual corpus publication wrapper; corpus-seed.yml explicitly '
-    + 'stops at sealed preparation with contents:read. This entry validates receipt/archive inputs '
-    + 'and delegates mutation to release.mjs protected authority. No operational caller is registered; '
-    + 'classification does not claim publication works or has occurred'],
   ['execution-preflight', 'external orchestration boundary — invoked by the host before consequential Ruflo/Codex execution; no in-repo caller exists because the host supplies the live Brain and AgentDB receipts'],
   ['fix-workstream', 'session-supervised coordination CLI run explicitly by the integration owner or an '
     + 'isolated writing agent to start and hand off a fix lane. Scheduling it would violate its safety '
@@ -316,11 +324,31 @@ const CALLER_ROOTS = [
 const CALLER_EXTS = new Set(['.mjs', '.js', '.sh', '.json', '.html', '.yml', '.yaml']);
 export const REQUIRED_OPERATIONAL_EXPORTS = [
   { rel: 'scripts/corpus-reconcile.mjs', symbol: 'syncCorpusInputs' },
-  { rel: 'scripts/corpus-reconcile.mjs', symbol: 'materializeGistReceipts' },
-  { rel: 'scripts/corpus-reconcile.mjs', symbol: 'observeAndMaterializeGistReceipts' },
   { rel: 'scripts/corpus-aggregates.mjs', symbol: 'rebuildCorpusAggregates' },
-  { rel: 'scripts/corpus-reconcile.mjs', symbol: 'reconcileCorpusUntilStable' },
+  { rel: 'scripts/corpus-reconcile.mjs', symbol: 'acquireCorpusGeneration' },
   { rel: 'scripts/corpus-reconcile.mjs', symbol: 'reconcileAndPrepareCorpusCandidate' },
+  { rel: 'scripts/gist-receipts.mjs', symbol: 'buildGistAggregate' },
+  // Step 3 (2026-09-13): the single canonical public-prose selection entry point, same rigor as
+  // buildGistAggregate above.
+  { rel: 'scripts/public-inputs.mjs', symbol: 'materializePublicInputs' },
+  // Step 5 (2026-09-13): the single canonical assembly entry point (replaces the old ad hoc
+  // discover/copy/rebind logic previously scattered across build-bundle.mjs's module top level) and
+  // the single canonical release-coverage-projection entry point it calls in-process. Both are wired
+  // from build-bundle.mjs's own CLI wrapper at the bottom of the same file.
+  { rel: 'scripts/build-bundle.mjs', symbol: 'assembleBundle' },
+  { rel: 'scripts/release-projection.mjs', symbol: 'createReleaseProjection' },
+  // Step 13 (2026-09-13): the C2 deep store audit — measured recall, hash-verified segments, id-map /
+  // passage / source-map correspondence — that corpus-candidate.mjs fails closed on.
+  { rel: 'scripts/rvf-index-audit.mjs', symbol: 'auditCorpusStores' },
+  // Step 15 (2026-09-14): the C3 retrieval-accuracy gate. prepareCorpusCandidate shells out to its
+  // CLI after single-pass assembly; corpus-candidate.mjs and release.mjs both import its
+  // readAccuracyReport reader so candidate acceptance and publication can never drift apart.
+  { rel: 'scripts/oracle/retrieval-accuracy.mjs', symbol: 'runRetrievalAccuracy' },
+  // ADR-086 amendment (2026-09-15): the BLOCKING retrieval gate. C3 above still runs and still ships,
+  // but as a published diagnostic; this is the module that can refuse a candidate. prepareCorpusCandidate
+  // shells out to its CLI after single-pass assembly, and corpus-candidate.mjs and release.mjs both
+  // import its readRecallReport reader so candidate acceptance and publication can never drift apart.
+  { rel: 'scripts/oracle/repo-recall.mjs', symbol: 'runRepoRecall' },
 ];
 
 const isTestFile = (f) => /\.(test|spec)\.(mjs|js)$/.test(path.basename(f))
@@ -369,6 +397,14 @@ function callerFiles(repo = REPO) {
     // the remedy: "an invoker outside the roots proves the ROOTS are incomplete — the fix is to add
     // the root, never to" special-case the module. Same rule, applied to the extension filter.
     for (const f of walk(abs, true)) {
+      // `.claude/` is a caller root because `.claude/settings.json` genuinely invokes hooks. But
+      // `.claude/worktrees/<agent>/` holds FULL COPIES of this repository (Claude Code agent
+      // worktrees), and a copy of the repo is not a caller of the repo. Measured 2026-09-11: with any
+      // worktree present, card-from-source read `wired` via `.claude/worktrees/…/package.json`
+      // (`manual` with none present), handoff-asset read `wired` while invoked by nothing, and the
+      // MANUAL class read 0 all day. Same rule as the `kb/` exclusion in this file's header.
+      const rel = path.relative(repo, f).split(path.sep).join('/');
+      if (rel.startsWith('.claude/worktrees/')) continue;
       if (CALLER_EXTS.has(path.extname(f))) { out.push(f); continue; }
       if (path.extname(f) === '' && path.basename(path.dirname(f)) === 'git-hooks') out.push(f);
     }
@@ -790,8 +826,10 @@ export function hookWiringAudit({
     const packageRegistry = file.endsWith('/plugin/hooks/hooks.json') || file.endsWith('/plugin/hooks/codex-hooks.json');
     const rows = Object.entries(doc.hooks).flatMap(([event, groups]) => (groups ?? []).flatMap((group) =>
       (group?.hooks ?? []).map((hook) => ({ event, matcher: group.matcher ?? '', command: hook.command }))));
+    const host = file.endsWith('/plugin/hooks/codex-hooks.json') ? 'codex' : 'claude';
     return packageRegistry
-      ? rows.length === 2 && rows.every((row) => isAllowedContinuityRegistration(row))
+      ? rows.length === continuityRegistrations(host).length
+        && rows.every((row) => isAllowedContinuityRegistration({ ...row, host }))
       : rows.length === 0;
   });
   const table = hookShimTable(repo);
@@ -850,7 +888,7 @@ export function hookWiringAudit({
     else if (automaticHooksConstrained && declared) rows.push({
       file: f,
       state: 'retired',
-      why: 'legacy automatic Brain hooks remain retired; only the two constrained continuity handlers are wired',
+      why: 'legacy automatic Brain hooks remain retired; only the declared continuity plane (see plugin/hooks/hook-contracts.json) is wired',
     });
     else if (held[f]) rows.push({ file: f, state: 'held', why: held[f] });
     else rows.push({ file: f, state: 'unwired' });

package/tri-smart-skill/QUICKSTART.md

@@ -0,0 +1,37 @@
+# TriSmart Skill quick start
+
+Version 1.1.0
+
+TriSmart Skill lets two or three subscription developer tools think through an important design together before ordinary coding begins.
+
+1. Install the official developer CLIs you want to use: Claude Code, Codex, and/or Grok Code.
+
+   Official starting points: [Claude Code setup](https://docs.anthropic.com/en/docs/claude-code/getting-started), [OpenAI Developers](https://developers.openai.com/), and [Grok CLI reference](https://docs.x.ai/build/cli/reference). Follow each provider's current instructions; ModelMesh does not install third-party wrappers.
+2. Unzip this package.
+3. Start the installer for your operating system: double-click `install.command` on macOS, double-click `install.cmd` on Windows, or run `./install.sh` on Linux. If you prefer a terminal, run `node install.mjs` from the extracted folder. It installs to your user-level host directories by default; use `--project=/path/to/project` for a project-local install.
+4. The installer copies the skill into the host-specific directory and starts the guided OAuth walkthrough:
+
+   ```sh
+node install.mjs
+```
+
+Prefer a customized setup? Skip the installer and drag the extracted `tri-smart` folder into the skill directory for your host: `.claude/skills/tri-smart/`, `.agents/skills/tri-smart/`, or `.grok/skills/tri-smart/`. Reload the host afterward.
+
+5. Follow each provider's official browser login. TriSmart never asks for an API key and never stores login tokens.
+
+On macOS, the first double-click may show a Gatekeeper warning because the launcher is unsigned. Control-click `install.command`, choose **Open**, then choose **Open** again. The terminal fallback is `./install.sh`.
+6. When setup finishes, ask your current coding assistant:
+
+   ```text
+   Use ModelMesh to review this architecture before implementation: [describe the decision]
+   ```
+
+TriSmart chooses **TriSmart** when all three providers are available. With any two it chooses **Dual** and tells you which pair is active. It uses the highest model your account can actually run, or that provider's verified default when your plan does not include the preferred model.
+
+You will see a plain-language update for every stage: independent proposals, adversarial challenge, one shared synthesis, and independent verification. If the reviewers identify an unresolved critical issue, the result is **blocked** and nothing is handed to implementation. That is an intentional safety result.
+
+Preview installation without changing files or logging in:
+
+```sh
+node install.mjs --dry-run
+```

package/tri-smart-skill/README.md

@@ -0,0 +1,92 @@
+# TriSmart Skill
+
+**Version 1.1.0** · semantic versioning (`major.minor.patch`)
+
+For a non-technical first run, start with [QUICKSTART.md](QUICKSTART.md).
+
+TriSmart Skill is a portable subscription-only, cross-provider architectural review skill. It uses native Claude Code, Codex, and Grok CLIs with their top verified models, performs adversarial proposal and critique stages, persists only non-secret receipts in AgentDB, and hands accepted work to lower-cost implementation agents. It selects TriSmart when all three are available and Dual when any two are available; Claude + OpenAI is the preferred pair, but the available pair is reported explicitly.
+
+## Install
+
+The installer is a Node program. Double-clicking `install.mjs` opens its source text; that is expected. Use the launcher for your operating system:
+
+- **macOS:** double-click `install.command`, or run `./install.sh` in Terminal.
+- **Windows:** double-click `install.cmd`, or run `install.cmd` in PowerShell or Command Prompt.
+- **Linux:** run `./install.sh` in a terminal.
+
+All launchers run the same installer. Node.js 18+ is required. The direct command is:
+
+```sh
+node install.mjs
+```
+
+### macOS first run
+
+Because this ZIP contains an unsigned local script, macOS may show “Apple could not verify install.command.” In Finder, **Control-click (or right-click) `install.command`, choose Open, then choose Open again**. That approves this copy. If you prefer Terminal, use the shell launcher instead:
+
+```sh
+cd /path/to/tri-smart-skill
+chmod +x install.sh
+./install.sh
+```
+
+If macOS has already quarantined the file and the right-click path is unavailable, remove quarantine from this extracted copy and run it:
+
+```sh
+xattr -d com.apple.quarantine install.command install.sh 2>/dev/null || true
+./install.sh
+```
+
+There are two supported setup styles:
+
+- **Guided / high-tech:** run the launcher or `node install.mjs`. It creates the host folders, copies the skill, and walks you through OAuth setup.
+- **Manual / low-tech:** open the extracted ZIP and drag the `tri-smart` folder into the host's skill directory. Use `.claude/skills/tri-smart/` for Claude Code, `.agents/skills/tri-smart/` for Codex, or `.grok/skills/tri-smart/` for Grok Code. Then restart or reload that host so it discovers the skill.
+
+It installs the same host-neutral skill into your user-level Claude, Codex, and Grok skill directories by default, then starts the guided OAuth walkthrough. Existing installations are preserved; use `--force` only when deliberately upgrading one. Preview it with `node install.mjs --dry-run`; target one host with `--host=claude`, `--host=codex`, or `--host=grok`; target a project-local install with `--project=/path/to/project`.
+
+If you prefer to install manually, copy the `tri-smart` directory into the skill directory used by your host. This is a valid setup path; the installer only automates the copy and guided login:
+
+- Claude Code: `.claude/skills/tri-smart/` or `~/.claude/skills/tri-smart/`
+- Codex: `.agents/skills/tri-smart/` or `~/.codex/skills/tri-smart/`
+- Grok Code: the skills directory shown by `grok inspect` (commonly `.grok/skills/tri-smart/`)
+
+The same `SKILL.md` is host-neutral and can be loaded by all three hosts. The active host must be able to discover and invoke the other two native CLIs to execute the full workflow; otherwise ModelMesh returns a clearly labeled degraded result. Account tiers vary: ModelMesh tries the preferred top model, then uses the provider's own highest/default model if the account does not include it, and reports the actual model used. It never silently labels a fallback as the top model. Use the host's documented skill directory and verify discovery from that host before relying on it.
+
+## Verify access
+
+For a guided first setup, run:
+
+```sh
+node tri-smart/scripts/setup.mjs
+```
+
+It detects the CLIs, offers each official OAuth login, explains the selected Dual/TriSmart mode, and asks before spending subscription allowance on a live probe. Use `--dry-run` to see the walkthrough without logging in.
+
+After setup, run the bounded orchestration directly from any of the three hosts:
+
+```sh
+node tri-smart/scripts/review.mjs --task-file=architecture-question.md
+```
+
+The runner performs independent proposals in bounded parallel waves (two native sessions at a time to avoid provider throttling), pairwise challenge, deterministic synthesis, and independent verification. It prints only stage explanations and a structured decision; it stays read-only and reports the actual model or provider-default fallback used.
+Before Stage 1 it prints the exact host/provider/model mapping and native authentication mode. “Dual” or “TriSmart” alone is never the complete model status.
+It also prints: “native provider subscription/OAuth CLIs; API-key variables unset.” That proves the access path used by the runner; it does not claim visibility into a provider's internal billing ledger.
+
+From the unzipped directory:
+
+```sh
+node tri-smart/scripts/verify-access.mjs
+node tri-smart/scripts/verify-access.mjs --probe
+node tri-smart/scripts/verify-access.mjs --mode=dual --probe
+node tri-smart/scripts/verify-access.mjs --mode=tri --probe
+```
+
+The second command performs real single-turn probes only after the selected mode's OAuth/subscription checks pass and may consume subscription allowance. It strips provider API, cloud, helper, and custom-routing variables, validates the exact OAuth mode and model marker, and emits allowlisted metadata only; raw provider output is never printed.
+
+## Trigger
+
+Say **“use ModelMesh”** / **“model mesh”** for automatic mode selection, **“use TriSmart”** / **“tri smart”** / **“trip smart”** for the three-way review, or **“use Dual”** / **“dual smart”** for a two-provider review. “Brock” is accepted as a casual name for Grok. The skill recalls AgentDB, RVF, the North Star, active hooks, release contracts, and prior lessons before starting the review.
+
+## Scope and safety
+
+The package contains instructions and a deterministic access verifier; it does not contain credentials or a hidden API proxy. Native CLI authentication remains in each vendor's secure user store. A provider outage produces a degraded result and never silently substitutes another model. The skill does not claim a production release from a local pass or draft receipt. The verifier proves access prerequisites and marker probes; it does not by itself prove host skill discovery, a complete architectural review, or production readiness.

package/tri-smart-skill/install.cmd

@@ -0,0 +1,14 @@
+@echo off
+setlocal
+where node >nul 2>nul
+if errorlevel 1 (
+  echo TriSmart Skill needs Node.js 18 or newer. Install it from https://nodejs.org/ and run this file again.
+  pause
+  exit /b 2
+)
+set "HAS_PROJECT="
+for %%A in (%*) do if /I "%%~A"=="--project" set "HAS_PROJECT=1"
+for %%A in (%*) do echo %%~A | findstr /b /i "--project=" >nul && set "HAS_PROJECT=1"
+if defined HAS_PROJECT (node "%~dp0install.mjs" %*) else (node "%~dp0install.mjs" %* --project="%USERPROFILE%")
+if errorlevel 1 pause
+endlocal

package/tri-smart-skill/install.command

@@ -0,0 +1,13 @@
+#!/usr/bin/env sh
+set -eu
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+if ! command -v node >/dev/null 2>&1; then
+  printf '%s\n' 'TriSmart Skill needs Node.js 18 or newer. Install it from https://nodejs.org/ and run this file again.'
+  printf '%s\n' 'Press Return to close.'
+  read -r _
+  exit 2
+fi
+case " $* " in *" --project="*|*" --project "*) ;; *) set -- "$@" "--project=$HOME" ;; esac
+node "$SCRIPT_DIR/install.mjs" "$@"
+printf '%s\n' 'TriSmart setup finished. Press Return to close.'
+read -r _

package/tri-smart-skill/install.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/** Install TriSmart into one or all supported project-local skill directories. */
+import { cpSync, existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+
+const VERSION = '1.1.0';
+
+const args = process.argv.slice(2);
+if (Number.parseInt(process.versions.node.split('.')[0], 10) < 18) {
+  console.error(`TriSmart Skill requires Node.js 18 or newer. Found ${process.version}. Install Node from https://nodejs.org/ and run this installer again.`);
+  process.exit(2);
+}
+if (args.includes('--help') || args.includes('-h')) {
+  console.log('Usage: node install.mjs [--host=claude|codex|grok|all] [--project=PATH] [--dry-run] [--no-setup] [--force]');
+  console.log('Guided path: installs the same TriSmart Skill for the selected host(s), then starts guided OAuth setup.');
+  console.log('Manual path: drag the tri-smart folder into the host skill directory shown in README.md.');
+  process.exit(0);
+}
+if (args.includes('--version')) { console.log(`TriSmart Skill ${VERSION}`); process.exit(0); }
+const host = (args.find((a) => a.startsWith('--host='))?.slice(7) || 'all').toLowerCase();
+const defaultProject = process.env.HOME || process.env.USERPROFILE || process.cwd();
+const project = path.resolve(args.find((a) => a.startsWith('--project='))?.slice(10) || defaultProject);
+const dryRun = args.includes('--dry-run');
+const noSetup = args.includes('--no-setup');
+const force = args.includes('--force');
+const roots = { claude: '.claude/skills', codex: '.agents/skills', grok: '.grok/skills' };
+const hosts = host === 'all' ? Object.keys(roots) : [host];
+if (!hosts.every((item) => Object.hasOwn(roots, item))) { console.error('host must be claude, codex, grok, or all'); process.exit(2); }
+if (!existsSync(project)) { console.error(`Project directory does not exist: ${project}`); process.exit(2); }
+const source = path.resolve(path.dirname(fileURLToPath(import.meta.url)), 'tri-smart');
+console.log(`TriSmart Skill ${VERSION} installation options:`);
+console.log('  Guided: continue and this program copies the skill into the selected host directories.');
+console.log('  Manual: stop here and drag the tri-smart folder into .claude/skills, .agents/skills, or .grok/skills.');
+console.log('');
+for (const item of hosts) {
+  const destination = path.join(project, roots[item], 'tri-smart');
+  if (existsSync(destination) && !force) {
+    console.log(`Already installed for ${item}; leaving it unchanged. Use --force to replace it.`);
+    continue;
+  }
+  console.log(`${dryRun ? 'Would install' : 'Installing'} TriSmart for ${item}: ${destination}`);
+  if (!dryRun) cpSync(source, destination, { recursive: true, force: true });
+}
+if (!dryRun && !noSetup) {
+  console.log('\nStarting the guided TriSmart login walkthrough...');
+  const setup = spawnSync(process.execPath, [path.join(source, 'scripts', 'setup.mjs')], { stdio: 'inherit' });
+  process.exitCode = setup.status ?? 1;
+} else if (dryRun) console.log('\nDry run only: no files changed and no login started.');

package/tri-smart-skill/install.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env sh
+set -eu
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+if ! command -v node >/dev/null 2>&1; then
+  printf '%s\n' 'TriSmart Skill needs Node.js 18 or newer. Install it from https://nodejs.org/ and run this file again.' >&2
+  exit 2
+fi
+case " $* " in *" --project="*|*" --project "*) ;; *) set -- "$@" "--project=$HOME" ;; esac
+exec node "$SCRIPT_DIR/install.mjs" "$@"