troxy-cli 1.25.0 → 1.26.0

package/README.md

@@ -50,7 +50,7 @@ npx troxy-cli <command>
 |---------|-------------|
 | `troxy init` | Connect an agent to Troxy — validates API key, sets agent name, patches MCP configs |
 | `troxy login` | Start a 12-hour CLI session (opens browser → copy code → paste into terminal) |
-| `troxy tools` | Scan for installed AI coding tools and set your subscription plan for each |
+| `troxy tools` | Scan for installed AI coding tools and report them to the dashboard |
 | `troxy mcps` | List connected MCP agents and their status |
 | `troxy policies` | List every org/space policy that applies to you (creating one is admin-only) |
 | `troxy activity` | View recent transaction audit log |

package/bin/troxy.js

@@ -91,9 +91,8 @@ switch (command) {
   troxy tools
 
   Re-scans this machine for AI coding tools (Claude Code, Cursor, GitHub
-  Copilot, Windsurf, Continue, Aider) and lets you set the subscription plan
-  for each, so the dashboard shows what you actually pay instead of raw
-  token estimates. Run this any time your plan changes.
+  Copilot, Windsurf, Continue, Aider) and reports which ones it found to the
+  dashboard's "My AI tools" view. Run this any time you install or remove one.
 `);
       process.exit(0);
     }
@@ -107,7 +106,7 @@ switch (command) {
       console.log('\n  No supported AI coding tools detected on this machine.\n');
       break;
     }
-    await runToolDetection(apiKey, { interactive: true });
+    await runToolDetection(apiKey);
     console.log('  Saved ✓  See it at https://dash.troxy.io\n');
     break;
   }
@@ -649,7 +648,7 @@ switch (command) {
     troxy init --key <api-key>     Connect this machine as an MCP + save key
     troxy init --key <api-key> --name "My Agent"   Same, no interactive prompt
                                     (for cloud/scripted agents that can't answer stdin)
-    troxy tools                    Scan for AI tools + set your subscription plans
+    troxy tools                    Scan for AI tools + report them to the dashboard
     troxy restart                  Restart the MCP background service
     troxy uninstall                Remove Troxy from this machine
     troxy status                   API health + MCP status (no login needed)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "troxy-cli",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "description": "A secure control layer for AI agents: policies across payments, messages, logins, destructive actions, model usage, and secrets, all enforceable from the CLI",
   "homepage": "https://troxy.io",
   "bugs": {

package/src/api.js

@@ -132,8 +132,9 @@ export const api = {
   // MCP status (agent API key — no login needed)
   mcpStatus:  (apiKey) => request('GET', '/mcp/status', { apiKey }),
 
-  // AI tool inventory + subscription plans, self-reported by `troxy init` /
-  // `troxy tools`. Agent API key auth, same as the evaluate/heartbeat paths.
+  // AI tool inventory (presence only - no plan/price), self-reported by
+  // `troxy init` / `troxy tools`. Agent API key auth, same as the
+  // evaluate/heartbeat paths.
   reportToolPlans: (apiKey, tools) => request('POST', '/agents/tool-plans', { apiKey, body: { tools } }),
 
   // Setup instructions for an agent with no MCP client to configure. Fetched

package/src/init.js

@@ -306,13 +306,11 @@ export async function runInit({ key, name, proxy } = {}) {
 
   await reprovisionKeyConsumers(key, agentName, proxyOptIn);
 
-  // Scan for local AI coding tools and (interactively) confirm the plan for
-  // each, so the dashboard shows real subscription cost, not token math.
-  // Non-fatal + TTY-gated inside runToolDetection - a scripted init never
-  // hangs and a scan failure never breaks setup.
+  // Scan for local AI coding tools so the dashboard's "My AI tools" view has
+  // something to show. Non-fatal - a scan failure never breaks setup.
   try {
     const { runToolDetection } = await import('./tool_detect.js');
-    await runToolDetection(key, { interactive: true });
+    await runToolDetection(key);
   } catch {
     // Tool detection is a bonus, never a blocker for a successful init.
   }
@@ -611,7 +609,9 @@ async function maybeEnableClaudeCodeProxy(proxyOptIn) {
     console.log('  opportunity, not just suggest one.');
     console.log("  Trade-off: while this is on, Claude Code's Remote Control feature is");
     console.log('  disabled (Anthropic disables it whenever the API base URL points');
-    console.log('  anywhere other than api.anthropic.com).');
+    console.log('  anywhere other than api.anthropic.com). Also, model policies (e.g. a');
+    console.log('  BLOCK rule on a specific model) are not enforced on this path yet -');
+    console.log('  only the cost-saving model swap is live.');
     const answer = await prompt('  Enable? (y/N): ');
     enable = /^y(es)?$/i.test(answer);
   }

package/src/tests/tool_detect.test.js

@@ -1,9 +1,15 @@
-// tool_detect.js: the AI-tool inventory scan + subscription-plan self-report
-// wired into `troxy init` (after reprovisionKeyConsumers) and standalone
-// `troxy tools`. A single machine can have more than one of these six tools
-// installed at once, and each is tracked independently - never assume "one
-// AI tool per user" (that's the whole reason detectAiTools() returns an
-// array, not a single match).
+// tool_detect.js: the AI-tool presence scan wired into `troxy init` (after
+// reprovisionKeyConsumers) and standalone `troxy tools`. A single machine
+// can have more than one of these six tools installed at once, and each is
+// tracked independently - never assume "one AI tool per user" (that's the
+// whole reason detectAiTools() returns an array, not a single match).
+//
+// The self-reported subscription-plan concept this file used to test
+// (promptForToolPlans, silentToolReport, a per-tool `plans` menu) has been
+// removed entirely - a member's own guess should never feed cost math again
+// (see troxy-tf-live's dashboard.py handle_token_analysis). What's left is
+// presence-only: detect, then report {slug, installed:true} with nothing
+// else attached.
 //
 // Path-based detection (cursor/github_copilot/windsurf/continue) runs
 // against a real temp HOME, the same technique config.test.js and
@@ -37,8 +43,6 @@ process.env.LOCALAPPDATA = path.join(TMP, 'AppData/Local');
 
 const {
   detectAiTools,
-  promptForToolPlans,
-  silentToolReport,
   reportToolPlans,
   runToolDetection,
   binExists,
@@ -59,25 +63,11 @@ describe('TOOLS registry', () => {
     );
   });
 
-  // Keep in sync with the backend registry (tool_plans.py TOOL_PLANS) - the
-  // backend validates against its own copy of these slugs, so a slug typo
-  // here would silently fail every report for that tool.
-  const EXPECTED_PLAN_SLUGS = {
-    claude_code:     ['free', 'pro', 'max_5x', 'max_20x', 'api', 'not_sure'],
-    cursor:          ['hobby', 'pro', 'business', 'not_sure'],
-    github_copilot:  ['individual', 'business', 'enterprise', 'not_sure'],
-    windsurf:        ['free', 'pro', 'not_sure'],
-    continue:        ['free', 'pro', 'not_sure'],
-    aider:           ['free', 'pro', 'not_sure'],
-  };
-
-  for (const [slug, expected] of Object.entries(EXPECTED_PLAN_SLUGS)) {
-    it(`${slug} offers exactly the plan slugs the backend registry expects`, () => {
-      const tool = TOOLS.find(t => t.slug === slug);
-      assert.ok(tool, `${slug} missing from TOOLS`);
-      assert.deepEqual(tool.plans.map(p => p.slug), expected);
-    });
-  }
+  it('carries no plan/price data any more - presence only', () => {
+    for (const t of TOOLS) {
+      assert.equal(t.plans, undefined, `${t.slug} must not have a plans array`);
+    }
+  });
 });
 
 describe('binExists (the mechanism behind claude_code/aider detection)', () => {
@@ -97,7 +87,7 @@ describe('binExists (the mechanism behind claude_code/aider detection)', () => {
 describe('claude_code / aider detection wiring', () => {
   it('claude_code reuses init.js\'s hasClaudeCode() rather than reimplementing the probe', () => {
     assert.ok(
-      toolDetectSrc.includes("import { prompt, hasClaudeCode } from './init.js'"),
+      toolDetectSrc.includes("import { hasClaudeCode } from './init.js'"),
       'tool_detect.js must import hasClaudeCode from init.js, not redeclare its own execSync probe',
     );
     const claudeBlock = toolDetectSrc.slice(
@@ -178,28 +168,47 @@ describe('detectAiTools - path-based markers (cursor / github_copilot / windsurf
   });
 });
 
-describe('silentToolReport (non-interactive fallback shape)', () => {
-  it('reports every installed tool as not_sure with no cycle_day, and skips tools that are not installed', () => {
+describe('reportToolPlans (presence-only report)', () => {
+  let originalReportToolPlans;
+  beforeEach(() => { originalReportToolPlans = api.reportToolPlans; });
+  afterEach(() => { api.reportToolPlans = originalReportToolPlans; });
+
+  it('POSTs only installed tools, as bare {slug, installed:true} - no plan, no cycle_day', async () => {
+    let captured;
+    api.reportToolPlans = async (apiKey, tools) => { captured = { apiKey, tools }; return {}; };
     const detected = [
       { slug: 'claude_code', name: 'Claude Code', installed: true },
       { slug: 'cursor',      name: 'Cursor',      installed: false },
       { slug: 'aider',       name: 'Aider',       installed: true },
     ];
-    assert.deepEqual(silentToolReport(detected), [
-      { slug: 'claude_code', installed: true, plan: 'not_sure', cycle_day: null },
-      { slug: 'aider',       installed: true, plan: 'not_sure', cycle_day: null },
-    ]);
+    await reportToolPlans('txy-key', detected);
+    assert.deepEqual(captured, {
+      apiKey: 'txy-key',
+      tools: [
+        { slug: 'claude_code', installed: true },
+        { slug: 'aider', installed: true },
+      ],
+    });
   });
 
-  it('returns an empty array when nothing is installed', () => {
-    assert.deepEqual(silentToolReport([{ slug: 'cursor', name: 'Cursor', installed: false }]), []);
+  it('makes no API call when nothing is installed', async () => {
+    let called = false;
+    api.reportToolPlans = async () => { called = true; };
+    await reportToolPlans('txy-key', [{ slug: 'cursor', name: 'Cursor', installed: false }]);
+    assert.equal(called, false);
+  });
+
+  it('swallows a failed report rather than throwing - must never break `troxy init`', async () => {
+    api.reportToolPlans = async () => { throw new Error('network down'); };
+    await assert.doesNotReject(
+      reportToolPlans('txy-key', [{ slug: 'cursor', name: 'Cursor', installed: true }]),
+    );
   });
 });
 
-describe('runToolDetection - non-interactive guard (a scripted/CI init must never hang on stdin)', () => {
+describe('runToolDetection', () => {
   let calls;
   let originalReportToolPlans;
-  let originalIsTTY;
 
   before(() => {
     // A deterministic installed tool, independent of whether claude/aider
@@ -214,16 +223,13 @@ describe('runToolDetection - non-interactive guard (a scripted/CI init must neve
     calls = [];
     originalReportToolPlans = api.reportToolPlans;
     api.reportToolPlans = async (apiKey, tools) => { calls.push({ apiKey, tools }); return {}; };
-    originalIsTTY = process.stdin.isTTY;
   });
   afterEach(() => {
     api.reportToolPlans = originalReportToolPlans;
-    process.stdin.isTTY = originalIsTTY;
   });
 
-  it('skips the interactive prompt and reports every detected tool as not_sure when stdin is not a TTY', async () => {
-    process.stdin.isTTY = false;
-    await runToolDetection('txy-test-key', { interactive: true });
+  it('reports every detected tool as bare presence - no prompt, no stdin involved', async () => {
+    await runToolDetection('txy-test-key');
 
     assert.equal(calls.length, 1, 'reportToolPlans must be called exactly once when at least one tool is installed');
     assert.equal(calls[0].apiKey, 'txy-test-key');
@@ -231,125 +237,15 @@ describe('runToolDetection - non-interactive guard (a scripted/CI init must neve
     const cont = tools.find(t => t.slug === 'continue');
     assert.ok(cont, 'the tool detected via the temp-HOME marker must be in the reported set');
     for (const t of tools) {
+      assert.deepEqual(Object.keys(t).sort(), ['installed', 'slug']);
       assert.equal(t.installed, true);
-      assert.equal(t.plan, 'not_sure');
-      assert.equal(t.cycle_day, null);
     }
   });
 
-  it('returns promptly rather than blocking on stdin when stdin is not a TTY', async () => {
-    process.stdin.isTTY = false;
+  it('returns promptly - nothing here ever waits on stdin', async () => {
     const start = Date.now();
-    await runToolDetection('txy-test-key', { interactive: true });
-    assert.ok(Date.now() - start < 2000, 'runToolDetection must not block waiting on a readline question nothing will ever answer');
-  });
-
-  it('runToolDetection only takes the interactive path when both interactive AND stdin.isTTY are true', () => {
-    assert.ok(
-      toolDetectSrc.includes('(interactive && process.stdin.isTTY)'),
-      'the non-interactive guard must check both interactive and process.stdin.isTTY, not just one',
-    );
-  });
-});
-
-describe("promptForToolPlans - returns immediately when nothing is installed (no prompt call, no stdin needed)", () => {
-  it('resolves to [] without touching stdin', async () => {
-    const result = await promptForToolPlans([{ slug: 'cursor', name: 'Cursor', installed: false }]);
-    assert.deepEqual(result, []);
-  });
-});
-
-describe('promptForToolPlans numbered-choice parsing (mirrors the real logic in tool_detect.js)', () => {
-  // Mirrors the parsing inside promptForToolPlans's loop: a numbered-menu
-  // answer maps 1-based to the plan array; anything out of range - blank,
-  // 0, a too-large number, non-numeric junk - degrades to 'not_sure' rather
-  // than re-prompting, so a stray keystroke can never hang setup. The last
-  // test in each block below source-checks that the real implementation
-  // still contains this exact logic, so the two can't silently drift apart.
-  function resolvePlanChoice(ans, plans) {
-    const idx = parseInt(ans, 10) - 1;
-    return (idx >= 0 && idx < plans.length) ? plans[idx].slug : 'not_sure';
-  }
-
-  const cursorPlans = TOOLS.find(t => t.slug === 'cursor').plans; // hobby, pro, business, not_sure
-
-  it('maps a valid 1-based numbered choice to the matching plan slug', () => {
-    assert.equal(resolvePlanChoice('1', cursorPlans), 'hobby');
-    assert.equal(resolvePlanChoice('2', cursorPlans), 'pro');
-    assert.equal(resolvePlanChoice('3', cursorPlans), 'business');
-    assert.equal(resolvePlanChoice('4', cursorPlans), 'not_sure');
-  });
-
-  it('defaults to not_sure on a blank answer (Enter to skip)', () => {
-    assert.equal(resolvePlanChoice('', cursorPlans), 'not_sure');
-  });
-
-  it('defaults to not_sure on an out-of-range or non-numeric answer, rather than throwing', () => {
-    assert.equal(resolvePlanChoice('99', cursorPlans), 'not_sure');
-    assert.equal(resolvePlanChoice('0', cursorPlans), 'not_sure');
-    assert.equal(resolvePlanChoice('-1', cursorPlans), 'not_sure');
-    assert.equal(resolvePlanChoice('banana', cursorPlans), 'not_sure');
-  });
-
-  it('the real implementation uses this exact idx = parseInt(ans, 10) - 1 mapping', () => {
-    assert.ok(toolDetectSrc.includes('const idx = parseInt(ans, 10) - 1;'));
-    assert.ok(toolDetectSrc.includes("(idx >= 0 && idx < tool.plans.length) ? tool.plans[idx].slug : 'not_sure'"));
-  });
-});
-
-describe('promptForToolPlans cycle_day parsing (mirrors the real logic)', () => {
-  function resolveCycleDay(ans) {
-    const day = parseInt(ans, 10);
-    return (day >= 1 && day <= 31) ? day : null;
-  }
-
-  it('accepts a valid day 1-31', () => {
-    assert.equal(resolveCycleDay('1'), 1);
-    assert.equal(resolveCycleDay('15'), 15);
-    assert.equal(resolveCycleDay('31'), 31);
-  });
-
-  it('rejects out-of-range or non-numeric input as null (Enter to skip), never throws', () => {
-    assert.equal(resolveCycleDay(''), null);
-    assert.equal(resolveCycleDay('0'), null);
-    assert.equal(resolveCycleDay('32'), null);
-    assert.equal(resolveCycleDay('abc'), null);
-  });
-
-  it('the real implementation uses this exact 1-31 range check', () => {
-    assert.ok(toolDetectSrc.includes('if (day >= 1 && day <= 31) cycle_day = day;'));
-  });
-
-  it('only asks for a renewal day on a real paid plan - never free/hobby/not_sure/api', () => {
-    assert.ok(toolDetectSrc.includes("!['free', 'hobby', 'not_sure', 'api'].includes(plan)"));
-  });
-});
-
-describe('reportToolPlans', () => {
-  let originalReportToolPlans;
-  beforeEach(() => { originalReportToolPlans = api.reportToolPlans; });
-  afterEach(() => { api.reportToolPlans = originalReportToolPlans; });
-
-  it('POSTs the tools array via api.reportToolPlans, unchanged', async () => {
-    let captured;
-    api.reportToolPlans = async (apiKey, tools) => { captured = { apiKey, tools }; return {}; };
-    const results = [{ slug: 'cursor', installed: true, plan: 'pro', cycle_day: 5 }];
-    await reportToolPlans('txy-key', results);
-    assert.deepEqual(captured, { apiKey: 'txy-key', tools: results });
-  });
-
-  it('makes no API call for an empty result set', async () => {
-    let called = false;
-    api.reportToolPlans = async () => { called = true; };
-    await reportToolPlans('txy-key', []);
-    assert.equal(called, false);
-  });
-
-  it('swallows a failed report rather than throwing - must never break `troxy init`', async () => {
-    api.reportToolPlans = async () => { throw new Error('network down'); };
-    await assert.doesNotReject(
-      reportToolPlans('txy-key', [{ slug: 'cursor', installed: true, plan: 'pro', cycle_day: 5 }]),
-    );
+    await runToolDetection('txy-test-key');
+    assert.ok(Date.now() - start < 2000, 'runToolDetection must never block waiting on input');
   });
 });
 

package/src/tool_detect.js

@@ -3,13 +3,14 @@ import os       from 'os';
 import path     from 'path';
 import { execSync } from 'child_process';
 import { api }   from './api.js';
-import { prompt, hasClaudeCode } from './init.js';
+import { hasClaudeCode } from './init.js';
 
-// AI coding tools we detect + the subscription plans a user can confirm for
-// each. Mirrors the backend registry (troxy-tf-live tool_plans.py TOOL_PLANS)
-// deliberately - six rows that rarely change aren't worth a shared package.
-// Keep the plan slugs identical on both sides; the backend validates against
-// its own copy and resolves the price, so the CLI never sends a price.
+// AI coding tools we detect on this machine. Used to mirror the backend
+// registry (troxy-tf-live tool_plans.py TOOL_PLANS) with a `plans` list per
+// tool - that self-reported subscription-plan concept has been removed from
+// cost math entirely (a member's own guess should never feed a dollar total
+// again), so this is presence-only now: does the tool look installed, yes
+// or no.
 //
 // `detect()` returns true if the tool looks present. Two techniques, same as
 // init.js's detectMcpClients: a `--version` probe for CLI tools, an
@@ -38,14 +39,6 @@ export const TOOLS = [
     // --version')) rather than reimplementing it - one source of truth for
     // "is Claude Code on PATH".
     detect: () => hasClaudeCode(),
-    plans: [
-      { slug: 'free',     label: 'Free' },
-      { slug: 'pro',      label: 'Pro ($20/mo)' },
-      { slug: 'max_5x',   label: 'Max 5x ($100/mo)' },
-      { slug: 'max_20x',  label: 'Max 20x ($200/mo)' },
-      { slug: 'api',      label: 'API / pay-per-token' },
-      { slug: 'not_sure', label: 'Not sure' },
-    ],
   },
   {
     slug: 'cursor',
@@ -55,12 +48,6 @@ export const TOOLS = [
       path.join(process.env.APPDATA || home, 'Cursor'),
       path.join(home, '.config/Cursor'),
     ]),
-    plans: [
-      { slug: 'hobby',    label: 'Hobby (free)' },
-      { slug: 'pro',      label: 'Pro ($20/mo)' },
-      { slug: 'business', label: 'Business ($40/mo)' },
-      { slug: 'not_sure', label: 'Not sure' },
-    ],
   },
   {
     slug: 'github_copilot',
@@ -70,42 +57,21 @@ export const TOOLS = [
       path.join(home, '.config/github-copilot/apps.json'),
       path.join(process.env.LOCALAPPDATA || path.join(home, 'AppData/Local'), 'github-copilot/hosts.json'),
     ]),
-    plans: [
-      { slug: 'individual', label: 'Individual ($10/mo)' },
-      { slug: 'business',   label: 'Business ($19/mo)' },
-      { slug: 'enterprise', label: 'Enterprise ($39/mo)' },
-      { slug: 'not_sure',   label: 'Not sure' },
-    ],
   },
   {
     slug: 'windsurf',
     name: 'Windsurf',
     detect: () => anyPathExists([path.join(home, '.codeium/windsurf')]),
-    plans: [
-      { slug: 'free',     label: 'Free' },
-      { slug: 'pro',      label: 'Pro ($15/mo)' },
-      { slug: 'not_sure', label: 'Not sure' },
-    ],
   },
   {
     slug: 'continue',
     name: 'Continue',
     detect: () => anyPathExists([path.join(home, '.continue')]),
-    plans: [
-      { slug: 'free',     label: 'Free' },
-      { slug: 'pro',      label: 'Pro ($15/mo)' },
-      { slug: 'not_sure', label: 'Not sure' },
-    ],
   },
   {
     slug: 'aider',
     name: 'Aider',
     detect: () => binExists('aider --version'),
-    plans: [
-      { slug: 'free',     label: 'Free (bring your own API key)' },
-      { slug: 'pro',      label: 'Pro ($15/mo)' },
-      { slug: 'not_sure', label: 'Not sure' },
-    ],
   },
 ];
 
@@ -113,69 +79,24 @@ export function detectAiTools() {
   return TOOLS.map(t => ({ slug: t.slug, name: t.name, installed: !!t.detect() }));
 }
 
-// For each detected tool: show a numbered plan menu, read a choice, then ask
-// the renewal day. Returns [{slug, installed:true, plan, cycle_day}]. A tool
-// detected but skipped (blank / invalid choice) is reported as 'not_sure' so
-// the dashboard still shows it's installed. Never throws on bad input - a
-// stray keystroke degrades to 'not_sure', it doesn't abort setup.
-export async function promptForToolPlans(detected) {
+export async function reportToolPlans(apiKey, detected) {
   const installed = detected.filter(d => d.installed);
-  if (installed.length === 0) return [];
-
-  console.log('\n  Found these AI tools on this machine. Set your plan for each so');
-  console.log('  the dashboard shows what you actually pay, not raw token estimates.\n');
-
-  const results = [];
-  for (const d of installed) {
-    const tool = TOOLS.find(t => t.slug === d.slug);
-    console.log(`  ${tool.name}:`);
-    tool.plans.forEach((p, i) => console.log(`    ${i + 1}) ${p.label}`));
-    const ans = await prompt(`  Which plan? [1-${tool.plans.length}, Enter to skip]: `);
-    const idx = parseInt(ans, 10) - 1;
-    const plan = (idx >= 0 && idx < tool.plans.length) ? tool.plans[idx].slug : 'not_sure';
-
-    let cycle_day = null;
-    const chosen = tool.plans.find(p => p.slug === plan);
-    // Only ask the renewal day for a real paid plan - "Free"/"Not sure"/API
-    // have no monthly renewal to track a usage window against.
-    const isPaid = chosen && !['free', 'hobby', 'not_sure', 'api'].includes(plan);
-    if (isPaid) {
-      const dayAns = await prompt('  What day of the month does it renew? [1-31, Enter to skip]: ');
-      const day = parseInt(dayAns, 10);
-      if (day >= 1 && day <= 31) cycle_day = day;
-    }
-    results.push({ slug: d.slug, installed: true, plan, cycle_day });
-    console.log('');
-  }
-  return results;
-}
-
-// Non-interactive fallback (piped stdin / CI): report what's installed as
-// 'not_sure' with no prompt, so a scripted `troxy init` never hangs. The
-// dashboard still gets the inventory; the plan can be set later via the
-// dashboard or an interactive `troxy tools`.
-export function silentToolReport(detected) {
-  return detected.filter(d => d.installed).map(d => ({ slug: d.slug, installed: true, plan: 'not_sure', cycle_day: null }));
-}
-
-export async function reportToolPlans(apiKey, results) {
-  if (!results || results.length === 0) return;
+  if (installed.length === 0) return;
   try {
-    await api.reportToolPlans(apiKey, results);
+    await api.reportToolPlans(apiKey, installed.map(d => ({ slug: d.slug, installed: true })));
   } catch (err) {
-    // Non-fatal: a failed tool-plan report must never break `troxy init`.
-    console.error(`\n  Could not save AI tool info: ${err.message} (you can set it later in the dashboard).`);
+    // Non-fatal: a failed tool report must never break `troxy init`.
+    console.error(`\n  Could not save AI tool info: ${err.message} (you can retry later with "troxy tools").`);
   }
 }
 
-// The full flow, shared by `troxy init` (interactive step) and `troxy tools`.
-export async function runToolDetection(apiKey, { interactive = true } = {}) {
+// The full flow, shared by `troxy init` (a quiet inventory step) and
+// `troxy tools` (an explicit re-scan). No prompting - detection is a fact,
+// not a question - so `interactive` no longer changes behavior; kept as a
+// parameter so callers don't need to change, in case a future non-detection
+// step needs the distinction.
+export async function runToolDetection(apiKey) {
   const detected = detectAiTools();
-  const installedCount = detected.filter(d => d.installed).length;
-  if (installedCount === 0) return;
-
-  const results = (interactive && process.stdin.isTTY)
-    ? await promptForToolPlans(detected)
-    : silentToolReport(detected);
-  await reportToolPlans(apiKey, results);
+  if (detected.every(d => !d.installed)) return;
+  await reportToolPlans(apiKey, detected);
 }