chainlesschain 0.162.149 → 0.162.150

package/src/lib/cross-chain.js

@@ -651,6 +651,11 @@ const BASE_FEE = {
 export function estimateFee({ fromChain, toChain, amount }) {
   if (!_validateChain(fromChain) || !_validateChain(toChain))
     return { fee: null, reason: "unsupported_chain" };
+  // `cc crosschain estimate-fee` passes parseFloat(amount); a non-numeric arg
+  // yields NaN. Without this guard percentageFee/totalFee become NaN, the
+  // command's `fee === null` check misses it, and it prints "$NaN USD".
+  if (!Number.isFinite(amount) || amount <= 0)
+    return { fee: null, reason: "invalid_amount" };
 
   const baseFee = (BASE_FEE[fromChain] || 1.0) + (BASE_FEE[toChain] || 1.0);
   const percentageFee = amount * (DEFAULT_CONFIG.feePercentage / 100);

package/src/lib/dao-governance.js

@@ -112,6 +112,153 @@ export function ensureDAOv2Tables(db) {
   `);
 }
 
+/**
+ * Hydrate the in-memory stores from the DB. The CLI is one-shot: _proposals/
+ * _votes/_delegations/_treasury/_delegationsV2/_treasuryTxs all start empty each
+ * process. Every write dual-writes (Map/obj + INSERT) but every read/mutate is
+ * Map-only and nothing SELECTed the tables back — so the ENTIRE dao feature was
+ * broken across invocations: vote/execute/allocate threw "not found", stats
+ * reported 0, and the treasury deposit was invisible (allocate always
+ * "Insufficient"). Call after ensureDAOv2Tables(db).
+ *
+ * Faithful: proposals' votesFor/votesAgainst/status, votes, legacy delegations,
+ * and the treasury balance (DERIVED = Σdeposit − Σallocation, replayed in
+ * chronological order so each tx's balanceAfter is reconstructed too).
+ *
+ * Lossy (defaulted to stay correct/safe — these columns don't exist in the
+ * schema): V2 proposal abstain/quadratic-weight tallies → 0; proposal.queueEnd →
+ * a far-future sentinel so executeProposalV2 FAILS CLOSED (a null/undefined
+ * would make its timelock check `now < NaN` and BYPASS the timelock); V2
+ * delegation status/expiresAt → ACTIVE/none (revocation is not persisted).
+ */
+const _REHYDRATE_QUEUE_END_SENTINEL = "9999-12-31T23:59:59.999Z";
+
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureDAOv2Tables(db);
+  _proposals.clear();
+  _votes.clear();
+  _delegations.clear();
+  _delegationsV2.clear();
+  _treasuryTxs.length = 0;
+  _treasury.balance = 0;
+  _treasury.allocations = [];
+
+  for (const r of db
+    .prepare(
+      `SELECT id, title, description, proposer, status, votes_for, votes_against, voting_type, created_at, ends_at, executed_at
+         FROM dao_v2_proposals`,
+    )
+    .all()) {
+    _proposals.set(r.id, {
+      id: r.id,
+      title: r.title,
+      description: r.description || "",
+      proposer: r.proposer,
+      proposerDid: r.proposer, // V2 field mirrors legacy proposer
+      type: "standard",
+      status: r.status,
+      votesFor: Number(r.votes_for) || 0,
+      votesAgainst: Number(r.votes_against) || 0,
+      votingType: r.voting_type,
+      createdAt: r.created_at,
+      updatedAt: r.created_at,
+      endsAt: r.ends_at,
+      executedAt: r.executed_at,
+      // Non-persisted V2 fields — default to stay NaN-safe (see fn doc).
+      votesAbstain: 0,
+      quadraticWeightFor: 0,
+      quadraticWeightAgainst: 0,
+      quorumReached: false,
+      votingStart: null,
+      votingEnd: null,
+      cancelledAt: null,
+      // Fail-closed: a rehydrated QUEUED proposal cannot be executed until it is
+      // re-queued (real queueEnd is not persisted). Never bypass the timelock.
+      queueEnd: _REHYDRATE_QUEUE_END_SENTINEL,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, proposal_id, voter, weight, direction, delegated_from, created_at
+         FROM dao_v2_votes`,
+    )
+    .all()) {
+    _votes.set(r.id, {
+      id: r.id,
+      proposalId: r.proposal_id,
+      voter: r.voter,
+      voterDid: r.voter, // both read paths (stats uses voter, anti-sybil voterDid)
+      weight: Number(r.weight) || 0,
+      voteCount: Number(r.weight) || 0,
+      direction: r.direction,
+      voteType: r.direction,
+      delegatedFrom: r.delegated_from,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT delegator, delegate, weight, created_at FROM dao_v2_delegations`,
+    )
+    .all()) {
+    _delegations.set(r.delegator, {
+      delegator: r.delegator,
+      delegate: r.delegate,
+      weight: Number(r.weight) || 0,
+    });
+    // Synthesize a V2 record (status/expiresAt are not persisted → default).
+    _delegationsV2.set(`deleg:${r.delegator}`, {
+      id: `deleg:${r.delegator}`,
+      fromDid: r.delegator,
+      toDid: r.delegate,
+      weight: Number(r.weight) || 0,
+      status: DELEGATION_STATUS.ACTIVE,
+      expiresAt: null,
+      revokedAt: null,
+      createdAt: r.created_at,
+    });
+  }
+
+  // Treasury: no balance column — derive it by replaying the tx log in
+  // chronological order (deposit +, allocation −), reconstructing balanceAfter.
+  const treasuryRows = db
+    .prepare(
+      `SELECT id, type, amount, description, proposal_id, created_at
+         FROM dao_v2_treasury ORDER BY created_at ASC`,
+    )
+    .all();
+  for (const r of treasuryRows) {
+    const amt = Number(r.amount) || 0;
+    if (r.type === TREASURY_TX_TYPE.DEPOSIT) _treasury.balance += amt;
+    else if (r.type === TREASURY_TX_TYPE.ALLOCATION) _treasury.balance -= amt;
+    _treasuryTxs.push({
+      id: r.id,
+      txType: r.type,
+      proposalId: r.proposal_id,
+      amount: amt,
+      memo: r.description || "",
+      balanceAfter: _treasury.balance,
+      createdAt: r.created_at,
+    });
+    if (r.type === TREASURY_TX_TYPE.ALLOCATION) {
+      _treasury.allocations.push({
+        id: r.id,
+        proposalId: r.proposal_id,
+        amount: amt,
+        description: r.description || "",
+        date: r.created_at,
+      });
+    }
+  }
+
+  return (
+    _proposals.size + _votes.size + _delegations.size + _treasuryTxs.length
+  );
+}
+
 /* ── Proposals ─────────────────────────────────────────────── */
 
 export function propose(db, title, description, proposer, options = {}) {
@@ -259,7 +406,8 @@ export function getTreasury() {
 
 export function allocate(db, proposalId, amount, description) {
   if (!proposalId) throw new Error("Proposal ID is required");
-  if (amount <= 0) throw new Error("Amount must be positive");
+  if (!Number.isFinite(amount) || amount <= 0)
+    throw new Error("Amount must be positive");
   if (_treasury.balance < amount) {
     throw new Error("Insufficient treasury balance");
   }
@@ -287,7 +435,8 @@ export function allocate(db, proposalId, amount, description) {
 }
 
 export function depositToTreasury(db, amount, description) {
-  if (amount <= 0) throw new Error("Amount must be positive");
+  if (!Number.isFinite(amount) || amount <= 0)
+    throw new Error("Amount must be positive");
 
   const id = `dep-${Date.now()}-${crypto.randomBytes(4).toString("hex")}`;
   const now = new Date().toISOString();

package/src/lib/did-manager.js

@@ -163,16 +163,29 @@ export function setDefaultIdentity(db, did) {
   const identity = getIdentity(db, did);
   if (!identity) return false;
 
-  // Clear the current default(s). Match on is_default rather than `did LIKE '%'`
-  // so there's no wildcard pattern here that a reader/scanner could mistake for
-  // LIKE-injection — the target below is set via exact `did = ?` regardless.
-  db.prepare(
-    "UPDATE did_identities SET is_default = 0 WHERE is_default = 1",
-  ).run();
-  db.prepare("UPDATE did_identities SET is_default = ? WHERE did = ?").run(
-    1,
-    identity.did,
-  );
+  // Clear the current default(s) then set the new one atomically. Match on
+  // is_default rather than `did LIKE '%'` so there's no wildcard pattern here
+  // that a reader/scanner could mistake for LIKE-injection — the target below
+  // is set via exact `did = ?` regardless.
+  //
+  // The two UPDATEs must both land: without a transaction, a failure on the
+  // second leaves EVERY identity non-default (the default DID silently
+  // disappears until manually re-set), breaking the exactly-one-default
+  // invariant.
+  const applyWrites = () => {
+    db.prepare(
+      "UPDATE did_identities SET is_default = 0 WHERE is_default = 1",
+    ).run();
+    db.prepare("UPDATE did_identities SET is_default = ? WHERE did = ?").run(
+      1,
+      identity.did,
+    );
+  };
+  if (db && typeof db.transaction === "function") {
+    db.transaction(applyWrites)();
+  } else {
+    applyWrites();
+  }
   return true;
 }
 

package/src/lib/dlp-engine.js

@@ -325,6 +325,76 @@ export function _resetState() {
   _v2IncidentMeta.clear();
 }
 
+/**
+ * Rehydrate the in-memory _policies/_incidents Maps from the persisted dlp_*
+ * tables. The CLI runs each `cc dlp` subcommand in a fresh node process, so both
+ * Maps start empty every invocation. createPolicy/scanContent dual-write (Map +
+ * INSERT into dlp_policies/dlp_incidents) but every read (listDLPPolicies/
+ * listIncidents/getDLPStats + the scanContent enforcement loop over _policies)
+ * is Map-only and nothing SELECTed the tables back.
+ *
+ * SECURITY IMPACT: `cc dlp scan` iterates an empty _policies → matches nothing →
+ * returns allowed:true, so a BLOCK policy created in a prior invocation silently
+ * never enforces. Persisted policies were also un-listable and un-deletable
+ * (`policy delete`/`resolve` threw "not found"). Call after ensureDLPTables(db).
+ */
+export function loadFromDb(db) {
+  if (!db) return 0;
+  ensureDLPTables(db);
+  _policies.clear();
+  _incidents.clear();
+
+  const parse = (v, fallback) => {
+    try {
+      return v ? JSON.parse(v) : fallback;
+    } catch {
+      return fallback;
+    }
+  };
+
+  for (const r of db
+    .prepare(
+      `SELECT id, name, patterns, keywords, action, severity, enabled, created_at
+         FROM dlp_policies ORDER BY created_at ASC`,
+    )
+    .all()) {
+    _policies.set(r.id, {
+      id: r.id,
+      name: r.name,
+      patterns: parse(r.patterns, []),
+      keywords: parse(r.keywords, []),
+      action: r.action,
+      severity: r.severity,
+      enabled: !!r.enabled,
+      createdAt: r.created_at,
+    });
+  }
+
+  for (const r of db
+    .prepare(
+      `SELECT id, policy_id, channel, action_taken, content_hash, matched_patterns,
+              severity, user_id, created_at, resolved_at, resolution
+         FROM dlp_incidents ORDER BY created_at ASC`,
+    )
+    .all()) {
+    _incidents.set(r.id, {
+      id: r.id,
+      policyId: r.policy_id,
+      channel: r.channel,
+      actionTaken: r.action_taken,
+      contentHash: r.content_hash,
+      matchedPatterns: parse(r.matched_patterns, []),
+      severity: r.severity,
+      userId: r.user_id,
+      createdAt: r.created_at,
+      resolvedAt: r.resolved_at ?? null,
+      resolution: r.resolution ?? null,
+    });
+  }
+
+  return _policies.size + _incidents.size;
+}
+
 // ═══════════════════════════════════════════════════════════════
 // V2 Canonical Surface (Phase 50)
 // ═══════════════════════════════════════════════════════════════

package/src/lib/eval/runner.js

@@ -18,6 +18,7 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
+import crypto from "crypto";
 
 export const _deps = {
   mkdtempSync: fs.mkdtempSync,
@@ -25,6 +26,55 @@ export const _deps = {
   now: () => Date.now(),
 };
 
+/**
+ * Content-hash every file under `dir` → Map<relPath (forward-slash), sha1>. Used
+ * to measure edit locality: snapshot after setup (the baseline the agent starts
+ * from) vs after the agent runs, so we can see EXACTLY which files it touched.
+ */
+function snapshotWorkspace(dir) {
+  const out = new Map();
+  const walk = (cur) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(cur, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path.join(cur, e.name);
+      if (e.isDirectory()) {
+        walk(full);
+      } else if (e.isFile()) {
+        const rel = path.relative(dir, full).split(path.sep).join("/");
+        let hash;
+        try {
+          hash = crypto
+            .createHash("sha1")
+            .update(fs.readFileSync(full))
+            .digest("hex");
+        } catch {
+          hash = "?"; // unreadable → treat as its own value (still "changed" if it flips)
+        }
+        out.set(rel, hash);
+      }
+    }
+  };
+  walk(dir);
+  return out;
+}
+
+/** Relative paths that were created, modified, or deleted between two snapshots. */
+function diffSnapshots(before, after) {
+  const changed = new Set();
+  for (const [p, h] of after) {
+    if (!before.has(p) || before.get(p) !== h) changed.add(p); // created / modified
+  }
+  for (const p of before.keys()) {
+    if (!after.has(p)) changed.add(p); // deleted
+  }
+  return [...changed].sort();
+}
+
 /**
  * Run a suite of eval tasks and score them.
  *
@@ -77,6 +127,9 @@ export async function runEvalSuite(tasks, opts = {}) {
       if (typeof task.setup === "function") {
         await task.setup(dir);
       }
+      // Baseline AFTER setup, BEFORE the agent — so the diff is exactly the
+      // agent's edits (not the task's starting files).
+      const before = snapshotWorkspace(dir);
       let agentResult;
       try {
         agentResult = await runAgent({
@@ -90,6 +143,20 @@ export async function runEvalSuite(tasks, opts = {}) {
         rec.error = `agent error: ${agentErr.message}`;
       }
       rec.agentOk = agentResult ? agentResult.ok !== false : false;
+      // Edit locality — snapshot NOW, before check() (some checks write to the
+      // workspace themselves). `unrelatedChanges` = files touched outside the
+      // task's declared legitimate surface; null when the task doesn't declare
+      // `expectedFiles` (→ excluded from the suite's 无关改动率).
+      const changed = diffSnapshots(before, snapshotWorkspace(dir));
+      rec.changedFiles = changed;
+      if (Array.isArray(task.expectedFiles)) {
+        const expected = new Set(
+          task.expectedFiles.map((p) => String(p).split(path.sep).join("/")),
+        );
+        rec.unrelatedChanges = changed.filter((p) => !expected.has(p));
+      } else {
+        rec.unrelatedChanges = null; // not measured
+      }
       const verdict = await task.check(dir, agentResult);
       rec.pass = verdict?.pass === true;
       rec.detail = verdict?.detail || "";
@@ -136,12 +203,23 @@ export async function runEvalSuite(tasks, opts = {}) {
 
   const passed = results.filter((r) => r.pass).length;
   const total = results.length;
+  // 无关改动率: over tasks that declared expectedFiles, the fraction that
+  // touched at least one file outside their legitimate surface. An agent that
+  // solves a task but also scribbles on unrelated files scores lower quality.
+  const measured = results.filter((r) => Array.isArray(r.unrelatedChanges));
+  const tasksWithUnrelatedChanges = measured.filter(
+    (r) => r.unrelatedChanges.length > 0,
+  ).length;
   return {
     results,
     passed,
     failed: total - passed,
     total,
     passRate: total > 0 ? passed / total : 0,
+    tasksWithUnrelatedChanges,
+    unrelatedChangeRate: measured.length
+      ? tasksWithUnrelatedChanges / measured.length
+      : 0,
     ms: _deps.now() - suiteStart,
     ...(recorder ? { telemetry: recorder.summary() } : {}),
   };
@@ -154,10 +232,20 @@ export function formatEvalReport(summary) {
   lines.push(
     `Eval: ${summary.passed}/${summary.total} passed (${pct}%) in ${summary.ms}ms`,
   );
+  if (typeof summary.unrelatedChangeRate === "number") {
+    const upct = (summary.unrelatedChangeRate * 100).toFixed(1);
+    lines.push(
+      `Unrelated-change rate: ${upct}% (${summary.tasksWithUnrelatedChanges} task(s) edited files outside their expected surface)`,
+    );
+  }
   for (const r of summary.results) {
     const mark = r.pass ? "✔" : "✗";
     const detail = r.error ? ` — ${r.error}` : r.detail ? ` — ${r.detail}` : "";
-    lines.push(`  ${mark} ${r.id} (${r.ms}ms)${detail}`);
+    const stray =
+      Array.isArray(r.unrelatedChanges) && r.unrelatedChanges.length
+        ? ` [+${r.unrelatedChanges.length} unrelated: ${r.unrelatedChanges.join(", ")}]`
+        : "";
+    lines.push(`  ${mark} ${r.id} (${r.ms}ms)${detail}${stray}`);
   }
   return lines.join("\n");
 }

package/src/lib/eval/tasks.js

@@ -21,9 +21,19 @@ function read(dir, rel) {
   }
 }
 
+// The `stringutil` "dependency" at v2, used by BOTH the upgrade-dependency
+// setup and its check so the task can verify the vendored dependency file was
+// not edited (the agent must adapt the caller, not touch the dependency).
+const STRINGUTIL_V2 =
+  "export function toTitle(s) {\n" +
+  "  const str = String(s);\n" +
+  "  return str.charAt(0).toUpperCase() + str.slice(1);\n" +
+  "}\n";
+
 export const BUILTIN_TASKS = [
   {
     id: "create-file",
+    expectedFiles: ["greeting.txt"],
     description: "Create a new file with exact content",
     prompt:
       'Create a file named greeting.txt containing exactly the text "Hello, ChainlessChain!" (no trailing newline).',
@@ -40,6 +50,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "fix-syntax-error",
+    expectedFiles: ["bug.js"],
     description: "Fix a syntax error so the script runs",
     prompt:
       "The file bug.js has a syntax error. Fix it so that running `node bug.js` prints exactly OK.",
@@ -71,6 +82,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "add-function",
+    expectedFiles: ["math.js"],
     description: "Add a function to an existing module",
     prompt:
       "In math.js, add a named export `add(a, b)` that returns a + b. Keep the existing `mul` export.",
@@ -105,6 +117,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "fix-failing-test",
+    expectedFiles: ["calc.js"],
     description:
       "Fix a bug so an existing test suite passes (bug-fix category)",
     prompt:
@@ -170,6 +183,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "refactor-rename",
+    expectedFiles: ["util.js", "main.js"],
     description:
       "Rename a symbol across two files, keeping behavior (refactor)",
     prompt:
@@ -226,6 +240,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "write-test",
+    expectedFiles: ["verify.mjs"],
     description:
       "Write a meaningful verifier for a module (test-completion category)",
     prompt:
@@ -300,6 +315,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "migrate-signature",
+    expectedFiles: ["greet.mjs", "app.mjs"],
     description:
       "Migrate a function's call convention and update all callers (api-upgrade category)",
     prompt:
@@ -361,6 +377,7 @@ export const BUILTIN_TASKS = [
   },
   {
     id: "secure-path",
+    expectedFiles: ["notes.mjs"],
     description:
       "Fix a path-traversal vulnerability, verified by an exploit probe (security-fix category)",
     prompt:
@@ -447,6 +464,159 @@ export const BUILTIN_TASKS = [
       };
     },
   },
+  {
+    id: "fix-build",
+    expectedFiles: ["config.mjs", "app.mjs"],
+    description:
+      "Fix a cross-module build/link failure so the build passes (build-failure category)",
+    prompt:
+      "The build is broken: `node build.mjs` fails to LINK because of an " +
+      "export/import name mismatch between app.mjs and config.mjs. Reconcile " +
+      "them so `node build.mjs` prints BUILD OK. Do not edit build.mjs.",
+    setup: (dir) => {
+      // config exports `version` (lowercase) but app imports `VERSION` — an ESM
+      // link error at build time, distinct from a single-file syntax typo.
+      fs.writeFileSync(
+        path.join(dir, "config.mjs"),
+        'export const version = "1.0.0";\n',
+        "utf8",
+      );
+      fs.writeFileSync(
+        path.join(dir, "app.mjs"),
+        'import { VERSION } from "./config.mjs";\n' +
+          'export function banner() {\n  return "v" + VERSION;\n}\n',
+        "utf8",
+      );
+      fs.writeFileSync(
+        path.join(dir, "build.mjs"),
+        'import { banner } from "./app.mjs";\n' +
+          'if (banner() !== "v1.0.0") {\n' +
+          '  console.error("BUILD FAIL: " + banner());\n' +
+          "  process.exit(1);\n" +
+          "}\n" +
+          'console.log("BUILD OK");\n',
+        "utf8",
+      );
+    },
+    check: (dir) => {
+      const build = read(dir, "build.mjs");
+      if (build == null) return { pass: false, detail: "build.mjs missing" };
+      // Guard: fix the modules, don't neuter the build harness.
+      if (!/banner\(\)\s*!==\s*"v1\.0\.0"/.test(build)) {
+        return { pass: false, detail: "build.mjs assertion was altered" };
+      }
+      try {
+        const out = execFileSync(process.execPath, ["build.mjs"], {
+          cwd: dir,
+          encoding: "utf8",
+          timeout: 10000,
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+        return out.includes("BUILD OK")
+          ? { pass: true, detail: "build links + passes" }
+          : {
+              pass: false,
+              detail: `unexpected output ${JSON.stringify(out.trim())}`,
+            };
+      } catch (err) {
+        const first = String(err.message || "").split("\n")[0];
+        return { pass: false, detail: `build still failing: ${first}` };
+      }
+    },
+  },
+  {
+    id: "upgrade-dependency",
+    expectedFiles: ["package.json", "app.mjs"],
+    description:
+      "Adapt code to a dependency's breaking upgrade + bump the manifest (dependency-upgrade category)",
+    prompt:
+      "The `stringutil` dependency was upgraded to 2.0.0. Breaking change: its " +
+      "`capitalize` export was renamed to `toTitle` (same behavior). Do all of: " +
+      "(1) bump stringutil to ^2.0.0 in package.json; (2) update app.mjs to " +
+      "import and use `toTitle` instead of `capitalize`; (3) do NOT edit " +
+      "stringutil.mjs. Afterwards `node run.mjs` must print OK.",
+    setup: (dir) => {
+      fs.writeFileSync(
+        path.join(dir, "package.json"),
+        JSON.stringify(
+          {
+            name: "app",
+            type: "module",
+            dependencies: { stringutil: "1.0.0" },
+          },
+          null,
+          2,
+        ) + "\n",
+        "utf8",
+      );
+      // The upgraded (v2) dependency — vendored, must not be edited.
+      fs.writeFileSync(path.join(dir, "stringutil.mjs"), STRINGUTIL_V2, "utf8");
+      // The caller still uses the removed v1 `capitalize` export (link error).
+      fs.writeFileSync(
+        path.join(dir, "app.mjs"),
+        'import { capitalize } from "./stringutil.mjs";\n' +
+          "export function label(s) {\n  return capitalize(s);\n}\n",
+        "utf8",
+      );
+      fs.writeFileSync(
+        path.join(dir, "run.mjs"),
+        'import { label } from "./app.mjs";\n' +
+          'if (label("hello") !== "Hello") {\n' +
+          '  console.error("FAIL: " + label("hello"));\n' +
+          "  process.exit(1);\n" +
+          "}\n" +
+          'console.log("OK");\n',
+        "utf8",
+      );
+    },
+    check: (dir) => {
+      // The dependency is vendored — the agent must adapt the caller, NOT edit
+      // the dependency to re-add the old export and dodge the upgrade.
+      const dep = read(dir, "stringutil.mjs");
+      if (dep == null) return { pass: false, detail: "stringutil.mjs missing" };
+      if (dep !== STRINGUTIL_V2) {
+        return {
+          pass: false,
+          detail: "the stringutil dependency was edited (adapt the caller)",
+        };
+      }
+      const pkg = read(dir, "package.json");
+      if (pkg == null || !/"stringutil"\s*:\s*"[\^~]?2\./.test(pkg)) {
+        return {
+          pass: false,
+          detail: "package.json not bumped to stringutil 2.x",
+        };
+      }
+      const app = read(dir, "app.mjs");
+      if (app == null) return { pass: false, detail: "app.mjs missing" };
+      if (/\bcapitalize\b/.test(app)) {
+        return {
+          pass: false,
+          detail: "app.mjs still references the removed capitalize export",
+        };
+      }
+      if (!/\btoTitle\b/.test(app)) {
+        return { pass: false, detail: "app.mjs does not use the new toTitle" };
+      }
+      try {
+        const out = execFileSync(process.execPath, ["run.mjs"], {
+          cwd: dir,
+          encoding: "utf8",
+          timeout: 10000,
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+        return out.trim() === "OK"
+          ? { pass: true, detail: "adapted to new API + manifest bumped" }
+          : {
+              pass: false,
+              detail: `run.mjs printed ${JSON.stringify(out.trim())}`,
+            };
+      } catch (err) {
+        const first = String(err.message || "").split("\n")[0];
+        return { pass: false, detail: `run.mjs failed: ${first}` };
+      }
+    },
+  },
 ];
 
 /** Look up a suite by name (only "builtin" for now). */