@rune-kit/rune 2.28.0 → 2.29.1

package/compiler/__tests__/hooks-tiers.test.js

@@ -13,7 +13,6 @@
  */
 
 import assert from 'node:assert';
-import { existsSync } from 'node:fs';
 import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
@@ -54,7 +53,7 @@ const PRO_MANIFEST_FIXTURE = {
       skill: 'context-inject',
       event: 'UserPromptSubmit',
       matcher: '.*',
-      command: 'node "${RUNE_PRO_ROOT}/hooks/run-hook.cjs" context-inject',
+      command: `node "\${RUNE_PRO_ROOT}/hooks/run-hook.cjs" context-inject`,
       description: 'Inject rolling context summary',
       platforms: { claude: 'hook', cursor: 'rule-alwaysApply', windsurf: 'workflow+rule', antigravity: 'rule' },
     },
@@ -63,7 +62,7 @@ const PRO_MANIFEST_FIXTURE = {
       skill: 'context-sense',
       event: 'PreToolUse',
       matcher: 'Edit|Write',
-      command: 'node "${RUNE_PRO_ROOT}/hooks/run-hook.cjs" context-sense',
+      command: `node "\${RUNE_PRO_ROOT}/hooks/run-hook.cjs" context-sense`,
       description: 'Detect context pressure',
       globs: ['**/*.ts', '**/*.js'],
       platforms: { claude: 'hook', cursor: 'rule-glob', windsurf: 'workflow+rule', antigravity: 'rule' },
@@ -72,7 +71,7 @@ const PRO_MANIFEST_FIXTURE = {
       id: 'rune-pulse',
       skill: 'rune-pulse',
       event: 'statusLine',
-      command: 'node "${RUNE_PRO_ROOT}/hooks/rune-pulse/index.cjs"',
+      command: `node "\${RUNE_PRO_ROOT}/hooks/rune-pulse/index.cjs"`,
       padding: 0,
       claudeOnly: true,
       description: 'Context pressure indicator',

package/compiler/__tests__/setup.test.js

@@ -397,6 +397,65 @@ describe('runSetup — Pro skill installation (regression: rune:autopilot Unknow
 
     assert.deepStrictEqual(result.skillResults, []);
   });
+
+  test('installs Codex tier skills into project .agents/skills', async () => {
+    const projectRoot = path.join(tmpRoot, 'codex-project');
+    await mkdir(path.join(projectRoot, '.codex'), { recursive: true });
+    await seedTier(projectRoot, 'pro', { skills: ['autopilot'] });
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+
+    const result = await runSetup({
+      projectRoot,
+      runeRoot,
+      args: { here: true, platform: 'codex', preset: 'gentle', tier: 'pro' },
+    });
+
+    assert.strictEqual(result.skillTarget.source, 'codex-project');
+    assert.deepStrictEqual(result.platforms, ['codex']);
+    assert.ok(existsSync(path.join(projectRoot, '.codex', 'hooks.json')));
+    const installed = path.join(projectRoot, '.agents', 'skills', 'rune-autopilot', 'SKILL.md');
+    assert.ok(existsSync(installed));
+    const content = readFileSync(installed, 'utf-8');
+    assert.match(content, /^name: rune-autopilot$/m);
+    assert.doesNotMatch(content, /^context: fork$/m);
+    assert.doesNotMatch(content, /^agent: general-purpose$/m);
+  });
+
+  test('installs tier skills into every detected non-Claude platform using native adapters', async () => {
+    const projectRoot = path.join(tmpRoot, 'multi-project');
+    await mkdir(path.join(projectRoot, '.cursor'), { recursive: true });
+    await mkdir(path.join(projectRoot, '.windsurf'), { recursive: true });
+    await seedTier(projectRoot, 'business', { skills: ['quarterly-review'] });
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+
+    const result = await runSetup({
+      projectRoot,
+      runeRoot,
+      args: { here: true, platform: 'all', preset: 'gentle', tier: 'business' },
+    });
+
+    assert.deepStrictEqual(result.platforms.sort(), ['cursor', 'windsurf']);
+    assert.ok(existsSync(path.join(projectRoot, '.cursor', 'skills', 'rune-quarterly-review', 'SKILL.md')));
+    assert.ok(existsSync(path.join(projectRoot, '.windsurf', 'skills', 'rune-quarterly-review', 'SKILL.md')));
+    assert.deepStrictEqual(result.skillResults.map((entry) => entry.platform).sort(), ['cursor', 'windsurf']);
+  });
+
+  test('Codex dry-run reports tier skills on a fresh project without creating directories', async () => {
+    const projectRoot = path.join(tmpRoot, 'fresh-codex-project');
+    await mkdir(projectRoot, { recursive: true });
+    await seedTier(projectRoot, 'business', { skills: ['launch-product'] });
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+
+    const result = await runSetup({
+      projectRoot,
+      runeRoot,
+      args: { here: true, platform: 'codex', preset: 'gentle', tier: 'business', dry: true },
+    });
+
+    assert.deepStrictEqual(result.skillResults[0].installed, ['launch-product']);
+    assert.strictEqual(result.skillResults[0].reason, null);
+    assert.ok(!existsSync(path.join(projectRoot, '.agents')));
+  });
 });
 
 describe('formatSetupResult', () => {

package/compiler/__tests__/status.test.js

@@ -2,6 +2,7 @@ import assert from 'node:assert';
 import path from 'node:path';
 import { describe, test } from 'node:test';
 import { fileURLToPath } from 'node:url';
+import { checkMeshIntegrity } from '../doctor.js';
 import { collectStats, renderStatus, renderStatusJson } from '../status.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -42,6 +43,11 @@ describe('collectStats', () => {
     assert.ok(parseFloat(stats.avgConnections) > 1);
   });
 
+  test('uses the same canonical outbound connection count as doctor', async () => {
+    const [stats, mesh] = await Promise.all([collectStats(RUNE_ROOT), checkMeshIntegrity(RUNE_ROOT)]);
+    assert.strictEqual(stats.totalConnections, mesh.stats.connections);
+  });
+
   test('discovers free packs', async () => {
     const stats = await collectStats(RUNE_ROOT);
     assert.ok(stats.freePacks.length >= 14);
@@ -203,7 +209,7 @@ describe('renderStatus', () => {
     if (stats.bizPacks.length > 0) {
       const output = renderStatus(stats);
       assert.ok(output.includes('Business Packs'));
-      assert.ok(output.includes('@rune-biz/'));
+      assert.ok(output.includes('@rune-pro/'));
     }
   });
 

package/compiler/__tests__/tier-override.test.js

@@ -11,7 +11,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { describe, test } from 'node:test';
-import { discoverTieredPacks } from '../emitter.js';
+import { discoverTieredPacks, discoverTieredSkills } from '../emitter.js';
 
 /**
  * Create a temp directory structure with PACK.md files for testing
@@ -197,3 +197,44 @@ describe('discoverTieredPacks', () => {
     }
   });
 });
+
+describe('discoverTieredSkills', () => {
+  test('includes standalone Pro and Business skills and applies tier priority', async () => {
+    const root = mkdtempSync(path.join(tmpdir(), 'rune-tier-skills-'));
+    try {
+      const freeSkills = path.join(root, 'Free', 'skills');
+      const proExtensions = path.join(root, 'Pro', 'extensions');
+      const businessExtensions = path.join(root, 'Business', 'extensions');
+      for (const [skillsDir, names] of [
+        [freeSkills, ['cook', 'shared']],
+        [path.join(root, 'Pro', 'skills'), ['autopilot', 'shared']],
+        [path.join(root, 'Business', 'skills'), ['launch-product', 'shared']],
+      ]) {
+        for (const name of names) {
+          const dir = path.join(skillsDir, name);
+          mkdirSync(dir, { recursive: true });
+          writeFileSync(path.join(dir, 'SKILL.md'), `---\nname: ${name}\n---\n# ${name}\n`);
+        }
+      }
+      mkdirSync(proExtensions, { recursive: true });
+      mkdirSync(businessExtensions, { recursive: true });
+
+      const skills = await discoverTieredSkills(freeSkills, {
+        pro: proExtensions,
+        business: businessExtensions,
+      });
+
+      assert.deepStrictEqual(
+        skills.map(({ name, tier }) => [name, tier]),
+        [
+          ['autopilot', 'pro'],
+          ['cook', 'free'],
+          ['launch-product', 'business'],
+          ['shared', 'business'],
+        ],
+      );
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/compiler/__tests__/transforms.test.js

@@ -2,6 +2,7 @@ import assert from 'node:assert';
 import { describe, test } from 'node:test';
 import { addBranding } from '../transforms/branding.js';
 import { transformCrossReferences } from '../transforms/cross-references.js';
+import { transformSubagents } from '../transforms/subagents.js';
 import { transformToolNames } from '../transforms/tool-names.js';
 
 // --- Mock adapter ---
@@ -75,6 +76,20 @@ describe('transformToolNames', () => {
   });
 });
 
+describe('transformSubagents', () => {
+  const input = 'Launch 3 parallel agents as independent Task agents.';
+
+  test('preserves native Codex subagent instructions', () => {
+    assert.strictEqual(transformSubagents(input, { name: 'codex' }), input);
+  });
+
+  test('keeps sequential fallback for platforms without native subagents', () => {
+    const result = transformSubagents(input, { name: 'generic' });
+    assert.notStrictEqual(result, input);
+    assert.match(result, /sequentially/);
+  });
+});
+
 // --- Branding transform ---
 
 describe('addBranding', () => {

package/compiler/__tests__/update.test.js

@@ -0,0 +1,416 @@
+import assert from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, test } from 'node:test';
+import { installHooks } from '../commands/hooks/install.js';
+import { detectTiers } from '../commands/setup.js';
+import {
+  detectInstalledPreset,
+  detectInstalledTiers,
+  formatUpdateResult,
+  pullTierRepos,
+  runUpdate,
+} from '../commands/update.js';
+
+let tmpRoot;
+
+/** Seed a tier repo sibling (../Pro or ../Business) with a manifest whose
+ * entries reference the tier env var — matching what real tier manifests emit. */
+async function seedTierRepo(projectRoot, tier, opts = {}) {
+  const tierRoot = path.join(projectRoot, '..', tier === 'pro' ? 'Pro' : 'Business');
+  await mkdir(path.join(tierRoot, 'hooks'), { recursive: true });
+  const envVar = tier === 'pro' ? 'RUNE_PRO_ROOT' : 'RUNE_BUSINESS_ROOT';
+  await writeFile(
+    path.join(tierRoot, 'hooks', 'manifest.json'),
+    JSON.stringify({
+      tier,
+      version: '1.0.0',
+      minFreeVersion: '2.0.0',
+      requires: [envVar],
+      entries: [
+        {
+          id: `${tier}-pulse`,
+          event: 'PreToolUse',
+          matcher: 'Edit|Write',
+          command: `node "\${${envVar}}/hooks/pulse.js"`,
+        },
+      ],
+    }),
+  );
+  if (opts.git) {
+    await mkdir(path.join(tierRoot, '.git'), { recursive: true });
+  }
+  return tierRoot;
+}
+
+async function seedFakeRuneRoot(root) {
+  const runeRoot = path.join(root, 'fake-rune');
+  await mkdir(path.join(runeRoot, 'skills'), { recursive: true });
+  return runeRoot;
+}
+
+/** Install real Free hooks (optionally + tier) into the tmp project so the
+ * "already installed" detection paths have something real to read. */
+async function installProjectHooks(projectRoot, { preset = 'gentle', tier } = {}) {
+  await mkdir(path.join(projectRoot, '.claude'), { recursive: true });
+  await installHooks(projectRoot, { preset, tier, platform: 'claude' });
+}
+
+beforeEach(async () => {
+  delete process.env.RUNE_PRO_ROOT;
+  delete process.env.RUNE_BUSINESS_ROOT;
+  tmpRoot = await mkdtemp(path.join(tmpdir(), 'rune-update-'));
+  await mkdir(path.join(tmpRoot, 'project'), { recursive: true });
+});
+
+afterEach(async () => {
+  if (tmpRoot) await rm(tmpRoot, { recursive: true, force: true });
+  delete process.env.RUNE_PRO_ROOT;
+  delete process.env.RUNE_BUSINESS_ROOT;
+});
+
+describe('detectInstalledTiers', () => {
+  test('returns [] for a project with no Rune hook configs', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    assert.deepStrictEqual(await detectInstalledTiers(projectRoot), []);
+  });
+
+  test('returns [] when only Free preset hooks are installed (no false positive)', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await installProjectHooks(projectRoot, { preset: 'gentle' });
+    assert.deepStrictEqual(await detectInstalledTiers(projectRoot), []);
+  });
+
+  test('detects pro from RUNE_PRO_ROOT tokens in .claude/settings.json', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedTierRepo(projectRoot, 'pro');
+    await installProjectHooks(projectRoot, { preset: 'gentle', tier: ['pro'] });
+    assert.deepStrictEqual(await detectInstalledTiers(projectRoot), ['pro']);
+  });
+
+  test('detects business from tier token in .codex/hooks.json', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await mkdir(path.join(projectRoot, '.codex'), { recursive: true });
+    await writeFile(
+      path.join(projectRoot, '.codex', 'hooks.json'),
+      JSON.stringify({
+        hooks: {
+          PreToolUse: [
+            {
+              matcher: '.*',
+              // biome-ignore lint/suspicious/noTemplateCurlyInString: literal env token by design
+              hooks: [{ type: 'command', command: 'node "${RUNE_BUSINESS_ROOT}/hooks/gate.js"' }],
+            },
+          ],
+        },
+      }),
+    );
+    assert.deepStrictEqual(await detectInstalledTiers(projectRoot), ['business']);
+  });
+
+  test('detects pro from rune-tier frontmatter in .cursor/rules', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const rulesDir = path.join(projectRoot, '.cursor', 'rules');
+    await mkdir(rulesDir, { recursive: true });
+    await writeFile(path.join(rulesDir, 'rune-pro-pulse.mdc'), '---\nrune-managed: true\nrune-tier: pro\n---\n# x\n');
+    assert.deepStrictEqual(await detectInstalledTiers(projectRoot), ['pro']);
+  });
+});
+
+describe('detectInstalledPreset', () => {
+  test('returns null when nothing is installed', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    assert.strictEqual(await detectInstalledPreset(projectRoot), null);
+  });
+
+  test('returns the installed preset (strict)', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await installProjectHooks(projectRoot, { preset: 'strict' });
+    assert.strictEqual(await detectInstalledPreset(projectRoot), 'strict');
+  });
+
+  test('returns gentle for a gentle install', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await installProjectHooks(projectRoot, { preset: 'gentle' });
+    assert.strictEqual(await detectInstalledPreset(projectRoot), 'gentle');
+  });
+});
+
+describe('pullTierRepos', () => {
+  test('reports absent tiers as skipped without calling git', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const calls = [];
+    const exec = async (...args) => {
+      calls.push(args);
+      return { code: 0, stdout: '', stderr: '' };
+    };
+    const detected = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    const result = await pullTierRepos({ detected, exec });
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(calls.length, 0);
+    for (const r of result.results) {
+      assert.strictEqual(r.status, 'absent');
+    }
+  });
+
+  test('skips (with note) a detected tier that is not a git repo', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedTierRepo(projectRoot, 'pro'); // no .git
+    const exec = async () => {
+      throw new Error('git must not be called');
+    };
+    const detected = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    const result = await pullTierRepos({ detected, exec });
+    assert.strictEqual(result.ok, true);
+    const pro = result.results.find((r) => r.tier === 'pro');
+    assert.strictEqual(pro.status, 'skipped');
+    assert.match(pro.detail, /not a git repo/i);
+  });
+
+  test('pulls a detected git tier with git -C <root> pull --ff-only', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const tierRoot = await seedTierRepo(projectRoot, 'pro', { git: true });
+    const calls = [];
+    const exec = async (cmd, argv) => {
+      calls.push([cmd, argv]);
+      return { code: 0, stdout: 'Already up to date.\n', stderr: '' };
+    };
+    const detected = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    const result = await pullTierRepos({ detected, exec });
+    assert.strictEqual(result.ok, true);
+    const pro = result.results.find((r) => r.tier === 'pro');
+    assert.strictEqual(pro.status, 'pulled');
+    assert.strictEqual(calls.length, 1);
+    assert.strictEqual(calls[0][0], 'git');
+    assert.deepStrictEqual(calls[0][1], ['-C', path.resolve(tierRoot), 'pull', '--ff-only']);
+  });
+
+  test('fails loud when git pull fails (dirty tree, auth, ...)', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    await seedTierRepo(projectRoot, 'pro', { git: true });
+    const exec = async () => ({ code: 1, stdout: '', stderr: 'error: Your local changes would be overwritten' });
+    const detected = detectTiers(projectRoot, { wellKnownPaths: { pro: [], business: [] } });
+    const result = await pullTierRepos({ detected, exec });
+    assert.strictEqual(result.ok, false);
+    const pro = result.results.find((r) => r.tier === 'pro');
+    assert.strictEqual(pro.status, 'failed');
+    assert.match(pro.detail, /local changes/);
+  });
+});
+
+describe('runUpdate', () => {
+  test('fails with guidance when no Rune installation is detected', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+    const result = await runUpdate({
+      projectRoot,
+      runeRoot,
+      args: {},
+      deps: { wellKnownPaths: { pro: [], business: [] } },
+    });
+    assert.strictEqual(result.ok, false);
+    assert.match(result.reason, /setup/i);
+  });
+
+  test('re-runs setup reusing installed preset + tier, pulls tier repo', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+    await seedTierRepo(projectRoot, 'pro', { git: true });
+    await installProjectHooks(projectRoot, { preset: 'strict', tier: ['pro'] });
+    const execCalls = [];
+    const exec = async (cmd, argv) => {
+      execCalls.push([cmd, argv]);
+      return { code: 0, stdout: 'Already up to date.\n', stderr: '' };
+    };
+
+    const result = await runUpdate({
+      projectRoot,
+      runeRoot,
+      args: {},
+      deps: { exec, skillTarget: runeRoot, wellKnownPaths: { pro: [], business: [] } },
+    });
+
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(result.preset, 'strict');
+    assert.deepStrictEqual(result.tiers, ['pro']);
+    assert.strictEqual(execCalls.length, 1);
+    assert.ok(result.setup, 'setup result expected');
+    assert.deepStrictEqual(result.setup.tiers, ['pro']);
+    assert.strictEqual(result.setup.preset, 'strict');
+    assert.ok(result.drift, 'drift result expected');
+    const pro = result.pull.results.find((r) => r.tier === 'pro');
+    assert.strictEqual(pro.status, 'pulled');
+  });
+
+  test('does NOT run setup when a tier pull fails', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+    await seedTierRepo(projectRoot, 'pro', { git: true });
+    await installProjectHooks(projectRoot, { preset: 'gentle', tier: ['pro'] });
+    let setupRan = false;
+    const result = await runUpdate({
+      projectRoot,
+      runeRoot,
+      args: {},
+      deps: {
+        exec: async () => ({ code: 128, stdout: '', stderr: 'fatal: could not read Username' }),
+        runSetupFn: async () => {
+          setupRan = true;
+          return {};
+        },
+        wellKnownPaths: { pro: [], business: [] },
+      },
+    });
+    assert.strictEqual(result.ok, false);
+    assert.strictEqual(setupRan, false);
+    assert.match(result.reason, /pull failed/i);
+  });
+
+  test('--no-pull skips git pulls entirely', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+    await seedTierRepo(projectRoot, 'pro', { git: true });
+    await installProjectHooks(projectRoot, { preset: 'gentle', tier: ['pro'] });
+    const exec = async () => {
+      throw new Error('git must not be called with --no-pull');
+    };
+    const result = await runUpdate({
+      projectRoot,
+      runeRoot,
+      args: { 'no-pull': true },
+      deps: { exec, skillTarget: runeRoot, wellKnownPaths: { pro: [], business: [] } },
+    });
+    assert.strictEqual(result.ok, true);
+    for (const r of result.pull.results) {
+      assert.notStrictEqual(r.status, 'pulled');
+    }
+  });
+
+  test('skips (with note) an installed tier whose repo is no longer found', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+    // Install hooks WITH the pro tier while the repo exists...
+    await seedTierRepo(projectRoot, 'pro');
+    await installProjectHooks(projectRoot, { preset: 'gentle', tier: ['pro'] });
+    // ...then the repo disappears (user deleted the clone).
+    await rm(path.join(projectRoot, '..', 'Pro'), { recursive: true, force: true });
+
+    const result = await runUpdate({
+      projectRoot,
+      runeRoot,
+      args: {},
+      deps: { skillTarget: runeRoot, wellKnownPaths: { pro: [], business: [] } },
+    });
+
+    assert.strictEqual(result.ok, true);
+    assert.deepStrictEqual(result.tiers, []);
+    assert.ok(
+      result.notes.some((n) => /pro/.test(n) && /not found/i.test(n)),
+      `expected a "repo not found" note, got: ${JSON.stringify(result.notes)}`,
+    );
+  });
+
+  test('--dry passes dry through to setup (no writes)', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+    await installProjectHooks(projectRoot, { preset: 'gentle' });
+    const result = await runUpdate({
+      projectRoot,
+      runeRoot,
+      args: { dry: true, 'no-pull': true },
+      deps: { skillTarget: runeRoot, wellKnownPaths: { pro: [], business: [] } },
+    });
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(result.setup.written, false);
+  });
+
+  test('flags Codex re-trust when .codex/hooks.json content changed', async () => {
+    const projectRoot = path.join(tmpRoot, 'project');
+    const runeRoot = await seedFakeRuneRoot(tmpRoot);
+    await mkdir(path.join(projectRoot, '.codex'), { recursive: true });
+    // Stale/no hooks file → setup rewrite will change it.
+    const result = await runUpdate({
+      projectRoot,
+      runeRoot,
+      args: { 'no-pull': true },
+      deps: { skillTarget: runeRoot, wellKnownPaths: { pro: [], business: [] } },
+    });
+    assert.strictEqual(result.ok, true);
+    assert.strictEqual(result.codexReTrust, true);
+  });
+});
+
+describe('formatUpdateResult', () => {
+  test('renders pull, setup, and verification summary', () => {
+    const out = formatUpdateResult({
+      ok: true,
+      pull: {
+        ok: true,
+        results: [
+          { tier: 'pro', status: 'pulled', detail: 'Already up to date.' },
+          { tier: 'business', status: 'absent', detail: 'not detected' },
+        ],
+      },
+      platforms: ['claude'],
+      preset: 'gentle',
+      tiers: ['pro'],
+      setup: {
+        scope: 'current',
+        targetRoot: '/p',
+        tiers: ['pro'],
+        preset: 'gentle',
+        platforms: ['claude'],
+        written: true,
+        skillResults: [],
+      },
+      drift: {
+        findings: [],
+        summary: { drifted: 0, missing: 0, errors: 0 },
+        platforms: [{ platform: 'claude', preset: 'gentle' }],
+      },
+      doctor: { skipped: true, reason: 'no rune.config.json' },
+      codexReTrust: false,
+      notes: [],
+    });
+    assert.match(out, /Rune Update/);
+    assert.match(out, /pro.*pulled/i);
+    assert.match(out, /business.*not detected/i);
+    assert.match(out, /preset.*gentle/i);
+    assert.match(out, /0 drifted, 0 missing/);
+    assert.doesNotMatch(out, /\/hooks/);
+  });
+
+  test('renders the Codex re-trust reminder when hooks.json changed', () => {
+    const out = formatUpdateResult({
+      ok: true,
+      pull: { ok: true, results: [] },
+      platforms: ['codex'],
+      preset: 'gentle',
+      tiers: [],
+      setup: { platforms: ['codex'], written: true, skillResults: [] },
+      drift: { findings: [], summary: { drifted: 0, missing: 0, errors: 0 }, platforms: [] },
+      doctor: { skipped: true, reason: 'no rune.config.json' },
+      codexReTrust: true,
+      notes: [],
+    });
+    assert.match(out, /\/hooks/);
+    assert.match(out, /re-trust/i);
+  });
+
+  test('renders loud failure for a failed pull', () => {
+    const out = formatUpdateResult({
+      ok: false,
+      reason: 'tier pull failed — resolve manually and re-run `rune update`',
+      pull: {
+        ok: false,
+        results: [{ tier: 'pro', status: 'failed', detail: 'error: Your local changes would be overwritten' }],
+      },
+      notes: [],
+    });
+    assert.match(out, /✗/);
+    assert.match(out, /pro/);
+    assert.match(out, /local changes/);
+    assert.match(out, /re-run/i);
+  });
+});