@vibescore/tracker 0.2.4 → 0.2.6

package/README.md

@@ -33,7 +33,7 @@ _Real-time AI Analytics for Codex CLI_
 
 We believe your code and thoughts are your own. VibeScore is built with strict privacy pillars to ensure your data never leaves your control.
 
-- 🛡️ **Zero Code Infiltration**: We never touch your source code or prompts. Our sniffer only extracts numeric token counts (Input, Output, Reasoning, Cached).
+- 🛡️ **No Content Upload**: We never upload prompts or responses. We only compute token counts locally and send counts plus minimal metadata (timestamps, model, device).
 - 📡 **Local Aggregation**: All token consumption analysis happens on your machine. We only relay quantized 30-minute usage buckets to the cloud.
 - 🔐 **Hashed Identity**: Device tokens are hashed using SHA-256 server-side. Your raw credentials never exist in our database.
 - 🔦 **Full Transparency**: Audit the sync logic yourself in `src/lib/rollout.js`. We literally only capture numbers and timestamps.
@@ -63,6 +63,8 @@ Initialize your environment once and forget it. VibeScore handles all synchroniz
 npx --yes @vibescore/tracker init
 ```
 
+Note: `init` shows a consent prompt in interactive shells. Use `--yes` to skip prompts in non-interactive environments.
+Optional: `--dry-run` previews planned changes without writing files.
 Note: If `~/.code/config.toml` exists (or `CODE_HOME`), `init` also configures Every Code `notify` automatically. No further user intervention is required for data sync.
 Note: If Gemini CLI home exists, `init` installs a `SessionEnd` hook in `~/.gemini/settings.json` and sets `tools.enableHooks = true` so hooks execute. This enables all Gemini hooks; disable by setting `tools.enableHooks = false` (or disabling the `vibescore-tracker` hook).
 
@@ -134,6 +136,30 @@ npm install
 npm run dev
 ```
 
+### Debug Payload (Usage Endpoints)
+
+When `debug=1` is included in a usage endpoint request, the response adds a `debug` object that helps the dashboard attribute slow queries without relying on response headers.
+
+```ts
+const res = await fetch(
+  `${baseUrl}/functions/vibescore-usage-summary?from=2025-12-30&to=2025-12-30&debug=1`,
+  {
+    headers: { Authorization: `Bearer ${userJwt}` }
+  }
+);
+const data = await res.json();
+
+if (data.debug) {
+  console.debug('usage debug', {
+    requestId: data.debug.request_id,
+    status: data.debug.status,
+    queryMs: data.debug.query_ms,
+    slowThresholdMs: data.debug.slow_threshold_ms,
+    slowQuery: data.debug.slow_query
+  });
+}
+```
+
 ### Architecture Validation
 
 ```bash

package/README.zh-CN.md

@@ -33,7 +33,7 @@ _Codex CLI 实时 AI 分析工具_
 
 我们坚信你的代码和思想属于你自己。VibeScore 建立在严格的隐私支柱之上，确保你的数据始终处于受控状态。
 
-- 🛡️ **代码零入侵**：我们绝不触碰你的源代码或 Prompt。我们的嗅探器仅提取数值化的 Token 计数（输入、输出、推理、缓存）。
+- 🛡️ **内容不出本地**：我们从不上传 Prompt 或响应内容。只在本地计算 Token 数量，并上传 Token 计数与最小元数据（时间、模型、设备）。
 - 📡 **本地聚合**：所有 Token 消耗分析均在你的机器上完成。我们仅将量化的 30 分钟使用桶（Usage Buckets）中继到云端。
 - 🔐 **身份哈希**：设备令牌在服务端使用 SHA-256 进行哈希处理。你的原始凭据绝不会存在于我们的数据库中。
 - 🔦 **全程透明**：你可以亲自审计 `src/lib/rollout.js` 中的同步逻辑。我们真正采集的只有数字和时间戳。
@@ -63,6 +63,8 @@ _Codex CLI 实时 AI 分析工具_
 npx --yes @vibescore/tracker init
 ```
 
+说明：交互式终端会显示授权菜单；非交互环境可使用 `--yes` 跳过。
+可选：`--dry-run` 仅预览将发生的变更，不写入任何文件。
 说明：若存在 `~/.code/config.toml`（或 `CODE_HOME`），`init` 会自动配置 Every Code 的 `notify`。配置完成后，数据同步完全自动化，无需后续人工干预。
 说明：若检测到 Gemini CLI home，`init` 会在 `~/.gemini/settings.json` 安装 `SessionEnd` hook，并将 `tools.enableHooks = true` 以确保 hook 生效。这会启用所有 Gemini hooks；如需关闭，可将 `tools.enableHooks = false`（或禁用 `vibescore-tracker` hook）。
 
@@ -134,6 +136,30 @@ npm install
 npm run dev
 ```
 
+### 调试字段（Usage 接口）
+
+当请求包含 `debug=1` 时，usage 接口会在响应体中附带 `debug` 对象，方便前端定位慢查询而不依赖响应头。
+
+```ts
+const res = await fetch(
+  `${baseUrl}/functions/vibescore-usage-summary?from=2025-12-30&to=2025-12-30&debug=1`,
+  {
+    headers: { Authorization: `Bearer ${userJwt}` }
+  }
+);
+const data = await res.json();
+
+if (data.debug) {
+  console.debug('usage debug', {
+    requestId: data.debug.request_id,
+    status: data.debug.status,
+    queryMs: data.debug.query_ms,
+    slowThresholdMs: data.debug.slow_threshold_ms,
+    slowQuery: data.debug.slow_query
+  });
+}
+```
+
 ### 整体架构验证
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibescore/tracker",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Codex CLI token usage tracker (macOS-first, notify-driven).",
   "license": "MIT",
   "publishConfig": {
@@ -18,7 +18,9 @@
     "dev:shim": "node scripts/dev-bin-shim.cjs",
     "validate:copy": "node scripts/validate-copy-registry.cjs",
     "copy:pull": "node scripts/copy-sync.cjs pull",
-    "copy:push": "node scripts/copy-sync.cjs push"
+    "copy:push": "node scripts/copy-sync.cjs push",
+    "architecture:canvas": "node scripts/ops/architecture-canvas.cjs",
+    "validate:guardrails": "node scripts/validate-architecture-guardrails.cjs"
   },
   "bin": {
     "tracker": "bin/tracker.js",

package/src/cli.js

@@ -40,19 +40,22 @@ function printHelp() {
       '@vibescore/tracker',
       '',
       'Usage:',
-      '  npx @vibescore/tracker [--debug] init',
+      '  npx @vibescore/tracker [--debug] init [--yes] [--dry-run] [--no-open] [--link-code <code>]',
       '  npx @vibescore/tracker [--debug] sync [--auto] [--drain]',
       '  npx @vibescore/tracker [--debug] status',
       '  npx @vibescore/tracker [--debug] diagnostics [--out diagnostics.json]',
       '  npx @vibescore/tracker [--debug] uninstall [--purge]',
       '',
       'Notes:',
-      '  - init installs a Codex notify hook and issues a device token (default: browser sign in/up).',
-      '  - optional: pass --link-code <code> to skip browser login when provided by Dashboard.',
-      '  - when ~/.code/config.toml exists, init also installs an Every Code notify hook.',
-      '  - optional: set VIBESCORE_DASHBOARD_URL (or --dashboard-url) to use a hosted landing page.',
-      '  - sync parses ~/.codex/sessions/**/rollout-*.jsonl and ~/.code/sessions/**/rollout-*.jsonl (Every Code), then uploads token_count deltas.',
-      '  - --debug prints original backend errors when they are normalized.',
+      '  - init: consent first, local setup next, browser sign-in last.',
+      '  - --yes skips the consent menu (non-interactive safe).',
+      '  - --dry-run previews changes without writing files.',
+      '  - optional: --link-code <code> skips browser login when provided by Dashboard.',
+      '  - Every Code notify installs when ~/.code/config.toml exists.',
+      '  - auto sync waits for a device token.',
+      '  - optional: VIBESCORE_DASHBOARD_URL or --dashboard-url for hosted landing.',
+      '  - sync parses ~/.codex/sessions/**/rollout-*.jsonl and ~/.code/sessions/**/rollout-*.jsonl, then uploads token deltas.',
+      '  - --debug shows original backend errors.',
       ''
     ].join('\n')
   );

package/src/commands/init.js

@@ -9,24 +9,47 @@ const { ensureDir, writeFileAtomic, readJson, writeJson, chmod600IfPossible } =
 const { prompt, promptHidden } = require('../lib/prompt');
 const {
   upsertCodexNotify,
-  loadCodexNotifyOriginal,
   upsertEveryCodeNotify,
-  loadEveryCodeNotifyOriginal
+  readCodexNotify,
+  readEveryCodeNotify
 } = require('../lib/codex-config');
-const { upsertClaudeHook, buildClaudeHookCommand } = require('../lib/claude-config');
+const { upsertClaudeHook, buildClaudeHookCommand, isClaudeHookConfigured } = require('../lib/claude-config');
 const {
   resolveGeminiConfigDir,
   resolveGeminiSettingsPath,
   buildGeminiHookCommand,
-  upsertGeminiHook
+  upsertGeminiHook,
+  isGeminiHookConfigured
 } = require('../lib/gemini-config');
-const { resolveOpencodeConfigDir, upsertOpencodePlugin } = require('../lib/opencode-config');
-const { beginBrowserAuth } = require('../lib/browser-auth');
+const { resolveOpencodeConfigDir, upsertOpencodePlugin, isOpencodePluginInstalled } = require('../lib/opencode-config');
+const { beginBrowserAuth, openInBrowser } = require('../lib/browser-auth');
 const {
   issueDeviceTokenWithPassword,
   issueDeviceTokenWithAccessToken,
   issueDeviceTokenWithLinkCode
 } = require('../lib/insforge');
+const {
+  BOLD,
+  DIM,
+  CYAN,
+  RESET,
+  color,
+  isInteractive,
+  promptMenu,
+  createSpinner
+} = require('../lib/cli-ui');
+const { renderLocalReport, renderAuthTransition, renderSuccessBox } = require('../lib/init-flow');
+
+const ASCII_LOGO = [
+  '██╗   ██╗██╗██████╗ ███████╗███████╗ ██████╗  ██████╗ ██████╗ ███████╗',
+  '██║   ██║██║██╔══██╗██╔════╝██╔════╝██╔════╝ ██╔═══██╗██╔══██╗██╔════╝',
+  '██║   ██║██║██████╔╝█████╗  ███████╗██║      ██║   ██║██████╔╝█████╗',
+  '╚██╗ ██╔╝██║██╔══██╗██╔══╝  ╚════██║██║      ██║   ██║██╔══██╗██╔══╝',
+  ' ╚████╔╝ ██║██████╔╝███████╗███████║╚██████╗ ╚██████╔╝██║  ██║███████╗',
+  '  ╚═══╝  ╚═╝╚═════╝ ╚══════╝╚══════╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚══════╝'
+].join('\n');
+
+const DIVIDER = '----------------------------------------------';
 
 async function cmdInit(argv) {
   const opts = parseArgs(argv);
@@ -36,9 +59,6 @@ async function cmdInit(argv) {
   const trackerDir = path.join(rootDir, 'tracker');
   const binDir = path.join(rootDir, 'bin');
 
-  await ensureDir(trackerDir);
-  await ensureDir(binDir);
-
   const configPath = path.join(trackerDir, 'config.json');
   const notifyOriginalPath = path.join(trackerDir, 'codex_notify_original.json');
   const linkCodeStatePath = path.join(trackerDir, 'link_code_state.json');
@@ -49,11 +69,174 @@ async function cmdInit(argv) {
   const appDir = path.join(trackerDir, 'app');
   const trackerBinPath = path.join(appDir, 'bin', 'tracker.js');
 
+  renderWelcome();
+
+  if (opts.dryRun) {
+    process.stdout.write(`${color('Dry run: preview only (no changes applied).', DIM)}\n\n`);
+  }
+
+  if (isInteractive() && !opts.yes && !opts.dryRun) {
+    const choice = await promptMenu({
+      message: '? Proceed with installation?',
+      options: ['Yes, configure my environment', 'No, exit'],
+      defaultIndex: 0
+    });
+    const normalizedChoice = String(choice || '').trim().toLowerCase();
+    if (normalizedChoice.startsWith('no') || normalizedChoice.includes('exit')) {
+      process.stdout.write('Setup cancelled.\n');
+      return;
+    }
+  }
+
+  if (opts.dryRun) {
+    const preview = await buildDryRunSummary({
+      opts,
+      home,
+      trackerDir,
+      configPath,
+      notifyPath
+    });
+    renderLocalReport({ summary: preview.summary, isDryRun: true });
+    if (preview.pendingBrowserAuth) {
+      process.stdout.write('Account linking would be required for full setup.\n');
+    } else if (!preview.deviceToken) {
+      renderAccountNotLinked({ context: 'dry-run' });
+    }
+    return;
+  }
+
+  const spinner = createSpinner({ text: 'Analyzing and configuring local environment...' });
+  spinner.start();
+  let setup;
+  try {
+    setup = await runSetup({
+      opts,
+      home,
+      baseUrl,
+      trackerDir,
+      binDir,
+      configPath,
+      notifyOriginalPath,
+      linkCodeStatePath,
+      notifyPath,
+      appDir,
+      trackerBinPath
+    });
+  } catch (err) {
+    spinner.stop();
+    throw err;
+  }
+  spinner.stop();
+
+  renderLocalReport({ summary: setup.summary, isDryRun: false });
+
+  let deviceToken = setup.deviceToken;
+  let deviceId = setup.deviceId;
+
+  if (setup.pendingBrowserAuth) {
+    const deviceName = opts.deviceName || os.hostname();
+    if (!dashboardUrl) dashboardUrl = await detectLocalDashboardUrl();
+    const flow = await beginBrowserAuth({ baseUrl, dashboardUrl, timeoutMs: 10 * 60_000, open: false });
+    const canAutoOpen = !opts.noOpen;
+    renderAuthTransition({ authUrl: flow.authUrl, canAutoOpen });
+    if (canAutoOpen) {
+      if (isInteractive()) await sleep(250);
+      openInBrowser(flow.authUrl);
+    }
+    const callback = await flow.waitForCallback();
+    const issued = await issueDeviceTokenWithAccessToken({ baseUrl, accessToken: callback.accessToken, deviceName });
+    deviceToken = issued.token;
+    deviceId = issued.deviceId;
+    await writeJson(configPath, { baseUrl, deviceToken, deviceId, installedAt: setup.installedAt });
+    await chmod600IfPossible(configPath);
+    const resolvedDashboardUrl = dashboardUrl || null;
+    renderSuccessBox({ configPath, dashboardUrl: resolvedDashboardUrl });
+  } else if (deviceToken) {
+    if (!dashboardUrl) dashboardUrl = await detectLocalDashboardUrl();
+    const resolvedDashboardUrl = dashboardUrl || null;
+    renderSuccessBox({ configPath, dashboardUrl: resolvedDashboardUrl });
+  } else {
+    renderAccountNotLinked();
+  }
+
+  try {
+    spawnInitSync({ trackerBinPath, packageName: '@vibescore/tracker' });
+  } catch (err) {
+    const msg = err && err.message ? err.message : 'unknown error';
+    process.stderr.write(`Initial sync spawn failed: ${msg}\n`);
+  }
+}
+
+function renderWelcome() {
+  process.stdout.write(
+    [
+      ASCII_LOGO,
+      '',
+      `${BOLD}Welcome to VibeScore CLI${RESET}`,
+      DIVIDER,
+      `${CYAN}Privacy First: Your content stays local. We only upload token counts and minimal metadata, never prompts or responses.${RESET}`,
+      DIVIDER,
+      '',
+      'This tool will:',
+      '  - Analyze your local AI CLI configurations (Codex, Every Code, Claude, Gemini, Opencode)',
+      '  - Set up lightweight hooks to track your flow state',
+      '  - Link your device to your VibeScore account',
+      '',
+      '(Nothing will be changed until you confirm below)',
+      ''
+    ].join('\n')
+  );
+}
+
+function renderAccountNotLinked({ context } = {}) {
+  if (context === 'dry-run') {
+    process.stdout.write(['', 'Account not linked (dry run).', 'Run init without --dry-run to link your account.', ''].join('\n'));
+    return;
+  }
+  process.stdout.write(['', 'Account not linked.', 'Set VIBESCORE_DEVICE_TOKEN then re-run init.', ''].join('\n'));
+}
+
+function shouldUseBrowserAuth({ deviceToken, opts }) {
+  if (deviceToken) return false;
+  if (opts.noAuth) return false;
+  if (opts.linkCode) return false;
+  if (opts.email || opts.password) return false;
+  return true;
+}
+
+async function buildDryRunSummary({ opts, home, trackerDir, configPath, notifyPath }) {
+  const existingConfig = await readJson(configPath);
+  const deviceTokenFromEnv = process.env.VIBESCORE_DEVICE_TOKEN || null;
+  const deviceToken = deviceTokenFromEnv || existingConfig?.deviceToken || null;
+  const pendingBrowserAuth = shouldUseBrowserAuth({ deviceToken, opts });
+  const context = buildIntegrationTargets({ home, trackerDir, notifyPath });
+  const summary = await previewIntegrations({ context });
+  return { summary, pendingBrowserAuth, deviceToken };
+}
+
+async function runSetup({
+  opts,
+  home,
+  baseUrl,
+  trackerDir,
+  binDir,
+  configPath,
+  notifyOriginalPath,
+  linkCodeStatePath,
+  notifyPath,
+  appDir,
+  trackerBinPath
+}) {
+  await ensureDir(trackerDir);
+  await ensureDir(binDir);
+
   const existingConfig = await readJson(configPath);
   const deviceTokenFromEnv = process.env.VIBESCORE_DEVICE_TOKEN || null;
 
   let deviceToken = deviceTokenFromEnv || existingConfig?.deviceToken || null;
   let deviceId = existingConfig?.deviceId || null;
+  const installedAt = existingConfig?.installedAt || new Date().toISOString();
+  let pendingBrowserAuth = false;
 
   await installLocalTrackerApp({ appDir });
 
@@ -96,21 +279,7 @@ async function cmdInit(argv) {
       deviceToken = issued.token;
       deviceId = issued.deviceId;
     } else {
-      if (!dashboardUrl) dashboardUrl = await detectLocalDashboardUrl();
-      const flow = await beginBrowserAuth({ baseUrl, dashboardUrl, timeoutMs: 10 * 60_000, open: !opts.noOpen });
-      process.stdout.write(
-        [
-          '',
-          'Connect your account:',
-          `- Open: ${flow.authUrl}`,
-          '- Finish sign in/up in your browser, then come back here.',
-          ''
-        ].join('\n')
-      );
-      const callback = await flow.waitForCallback();
-      const issued = await issueDeviceTokenWithAccessToken({ baseUrl, accessToken: callback.accessToken, deviceName });
-      deviceToken = issued.token;
-      deviceId = issued.deviceId;
+      pendingBrowserAuth = true;
     }
   }
 
@@ -118,135 +287,228 @@ async function cmdInit(argv) {
     baseUrl,
     deviceToken,
     deviceId,
-    installedAt: existingConfig?.installedAt || new Date().toISOString()
+    installedAt
   };
 
   await writeJson(configPath, config);
   await chmod600IfPossible(configPath);
 
-  // Install notify handler (non-blocking; chains the previous notify if present).
   await writeFileAtomic(
     notifyPath,
     buildNotifyHandler({ trackerDir, trackerBinPath, packageName: '@vibescore/tracker' })
   );
   await fs.chmod(notifyPath, 0o755).catch(() => {});
 
-  // Configure Codex notify hook.
+  const summary = await applyIntegrationSetup({
+    home,
+    trackerDir,
+    notifyPath,
+    notifyOriginalPath
+  });
+
+  return {
+    summary,
+    pendingBrowserAuth,
+    deviceToken,
+    deviceId,
+    installedAt
+  };
+}
+
+function buildIntegrationTargets({ home, trackerDir, notifyPath }) {
   const codexHome = process.env.CODEX_HOME || path.join(home, '.codex');
   const codexConfigPath = path.join(codexHome, 'config.toml');
   const codeHome = process.env.CODE_HOME || path.join(home, '.code');
   const codeConfigPath = path.join(codeHome, 'config.toml');
+  const notifyOriginalPath = path.join(trackerDir, 'codex_notify_original.json');
+  const codeNotifyOriginalPath = path.join(trackerDir, 'code_notify_original.json');
   const notifyCmd = ['/usr/bin/env', 'node', notifyPath];
-  const codexProbe = await probeFile(codexConfigPath);
-  const codexConfigExists = codexProbe.exists;
-  let result = null;
-  let chained = null;
-  if (codexConfigExists) {
-    result = await upsertCodexNotify({
-      codexConfigPath,
-      notifyCmd,
-      notifyOriginalPath
+  const codeNotifyCmd = ['/usr/bin/env', 'node', notifyPath, '--source=every-code'];
+  const claudeDir = path.join(home, '.claude');
+  const claudeSettingsPath = path.join(claudeDir, 'settings.json');
+  const claudeHookCommand = buildClaudeHookCommand(notifyPath);
+  const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
+  const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
+  const geminiHookCommand = buildGeminiHookCommand(notifyPath);
+  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
+
+  return {
+    codexConfigPath,
+    codeConfigPath,
+    notifyOriginalPath,
+    codeNotifyOriginalPath,
+    notifyCmd,
+    codeNotifyCmd,
+    claudeDir,
+    claudeSettingsPath,
+    claudeHookCommand,
+    geminiConfigDir,
+    geminiSettingsPath,
+    geminiHookCommand,
+    opencodeConfigDir
+  };
+}
+
+async function applyIntegrationSetup({ home, trackerDir, notifyPath, notifyOriginalPath }) {
+  const context = buildIntegrationTargets({ home, trackerDir, notifyPath });
+  context.notifyOriginalPath = notifyOriginalPath;
+
+  const summary = [];
+
+  const codexProbe = await probeFile(context.codexConfigPath);
+  if (codexProbe.exists) {
+    const result = await upsertCodexNotify({
+      codexConfigPath: context.codexConfigPath,
+      notifyCmd: context.notifyCmd,
+      notifyOriginalPath: context.notifyOriginalPath
     });
-    chained = await loadCodexNotifyOriginal(notifyOriginalPath);
-  }
-  const codeNotifyOriginalPath = path.join(trackerDir, 'code_notify_original.json');
-  const codeProbe = await probeFile(codeConfigPath);
-  const codeConfigExists = codeProbe.exists;
-  let codeResult = null;
-  let codeChained = null;
-  if (codeConfigExists) {
-    const codeNotifyCmd = ['/usr/bin/env', 'node', notifyPath, '--source=every-code'];
-    codeResult = await upsertEveryCodeNotify({
-      codeConfigPath,
-      notifyCmd: codeNotifyCmd,
-      notifyOriginalPath: codeNotifyOriginalPath
+    summary.push({
+      label: 'Codex CLI',
+      status: result.changed ? 'updated' : 'set',
+      detail: result.changed ? 'Updated config' : 'Config already set'
     });
-    codeChained = await loadEveryCodeNotifyOriginal(codeNotifyOriginalPath);
+  } else {
+    summary.push({ label: 'Codex CLI', status: 'skipped', detail: renderSkipDetail(codexProbe) });
   }
 
-  const claudeDir = path.join(home, '.claude');
-  const claudeSettingsPath = path.join(claudeDir, 'settings.json');
-  const claudeDirExists = await isDir(claudeDir);
-  let claudeResult = null;
+  const claudeDirExists = await isDir(context.claudeDir);
   if (claudeDirExists) {
-    const claudeHookCommand = buildClaudeHookCommand(notifyPath);
-    claudeResult = await upsertClaudeHook({
-      settingsPath: claudeSettingsPath,
-      hookCommand: claudeHookCommand
+    await upsertClaudeHook({
+      settingsPath: context.claudeSettingsPath,
+      hookCommand: context.claudeHookCommand
     });
+    summary.push({ label: 'Claude', status: 'installed', detail: 'Hooks installed' });
+  } else {
+    summary.push({ label: 'Claude', status: 'skipped', detail: 'Config not found' });
   }
 
-  const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
-  const geminiConfigExists = await isDir(geminiConfigDir);
-  const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
-  let geminiResult = null;
+  const geminiConfigExists = await isDir(context.geminiConfigDir);
   if (geminiConfigExists) {
-    const geminiHookCommand = buildGeminiHookCommand(notifyPath);
-    geminiResult = await upsertGeminiHook({
-      settingsPath: geminiSettingsPath,
-      hookCommand: geminiHookCommand
+    await upsertGeminiHook({
+      settingsPath: context.geminiSettingsPath,
+      hookCommand: context.geminiHookCommand
     });
+    summary.push({ label: 'Gemini', status: 'installed', detail: 'Hooks installed' });
+  } else {
+    summary.push({ label: 'Gemini', status: 'skipped', detail: 'Config not found' });
   }
 
-  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
   const opencodeResult = await upsertOpencodePlugin({
-    configDir: opencodeConfigDir,
+    configDir: context.opencodeConfigDir,
     notifyPath
   });
+  if (opencodeResult?.skippedReason === 'config-missing') {
+    summary.push({ label: 'Opencode Plugin', status: 'skipped', detail: 'Config not found' });
+  } else {
+    summary.push({ label: 'Opencode Plugin', status: opencodeResult?.changed ? 'installed' : 'set', detail: 'Plugin installed' });
+  }
 
-  process.stdout.write(
-    [
-      'Installed:',
-      `- Tracker config: ${configPath}`,
-      `- Notify handler: ${notifyPath}`,
-      codexConfigExists
-        ? `- Codex config: ${codexConfigPath}`
-        : `- Codex notify: skipped (${renderProbeSkip(codexConfigPath, codexProbe)})`,
-      codexConfigExists
-        ? result?.changed
-          ? '- Codex notify: updated'
-          : '- Codex notify: already set'
-        : null,
-      codexConfigExists ? (chained ? '- Codex notify: chained (original preserved)' : '- Codex notify: no original') : null,
-      codeConfigExists
-        ? `- Every Code config: ${codeConfigPath}`
-        : `- Every Code notify: skipped (${renderProbeSkip(codeConfigPath, codeProbe)})`,
-      codeConfigExists && codeResult
-        ? codeResult.changed
-          ? '- Every Code notify: updated'
-          : '- Every Code notify: already set'
-        : null,
-      codeConfigExists
-        ? codeChained
-          ? '- Every Code notify: chained (original preserved)'
-          : '- Every Code notify: no original'
-        : null,
-      claudeDirExists
-        ? claudeResult?.changed
-          ? `- Claude hooks: updated (${claudeSettingsPath})`
-          : `- Claude hooks: already set (${claudeSettingsPath})`
-        : '- Claude hooks: skipped (~/.claude not found)',
-      geminiConfigExists
-        ? geminiResult?.changed
-          ? `- Gemini hooks: updated (${geminiSettingsPath})`
-          : `- Gemini hooks: already set (${geminiSettingsPath})`
-        : `- Gemini hooks: skipped (${geminiConfigDir} not found)`,
-      opencodeResult?.skippedReason === 'config-missing'
-        ? '- Opencode plugin: skipped (config dir missing)'
-        : opencodeResult?.changed
-          ? `- Opencode plugin: updated (${opencodeConfigDir})`
-          : `- Opencode plugin: already set (${opencodeConfigDir})`,
-      deviceToken ? `- Device token: stored (${maskSecret(deviceToken)})` : '- Device token: not configured (set VIBESCORE_DEVICE_TOKEN and re-run init)',
-      ''
-    ].join('\n')
-  );
+  const codeProbe = await probeFile(context.codeConfigPath);
+  if (codeProbe.exists) {
+    const result = await upsertEveryCodeNotify({
+      codeConfigPath: context.codeConfigPath,
+      notifyCmd: context.codeNotifyCmd,
+      notifyOriginalPath: context.codeNotifyOriginalPath
+    });
+    summary.push({
+      label: 'Every Code',
+      status: result.changed ? 'updated' : 'set',
+      detail: result.changed ? 'Updated config' : 'Config already set'
+    });
+  } else {
+    summary.push({ label: 'Every Code', status: 'skipped', detail: renderSkipDetail(codeProbe) });
+  }
 
-  try {
-    spawnInitSync({ trackerBinPath, packageName: '@vibescore/tracker' });
-  } catch (err) {
-    const msg = err && err.message ? err.message : 'unknown error';
-    process.stderr.write(`Initial sync spawn failed: ${msg}\n`);
+  return summary;
+}
+
+async function previewIntegrations({ context }) {
+  const summary = [];
+
+  const codexProbe = await probeFile(context.codexConfigPath);
+  if (codexProbe.exists) {
+    const existing = await readCodexNotify(context.codexConfigPath);
+    const matches = arraysEqual(existing, context.notifyCmd);
+    summary.push({
+      label: 'Codex CLI',
+      status: matches ? 'set' : 'updated',
+      detail: matches ? 'Already configured' : 'Will update config'
+    });
+  } else {
+    summary.push({ label: 'Codex CLI', status: 'skipped', detail: renderSkipDetail(codexProbe) });
+  }
+
+  const claudeDirExists = await isDir(context.claudeDir);
+  if (claudeDirExists) {
+    const configured = await isClaudeHookConfigured({
+      settingsPath: context.claudeSettingsPath,
+      hookCommand: context.claudeHookCommand
+    });
+    summary.push({
+      label: 'Claude',
+      status: 'installed',
+      detail: configured ? 'Hooks already installed' : 'Will install hooks'
+    });
+  } else {
+    summary.push({ label: 'Claude', status: 'skipped', detail: 'Config not found' });
+  }
+
+  const geminiConfigExists = await isDir(context.geminiConfigDir);
+  if (geminiConfigExists) {
+    const configured = await isGeminiHookConfigured({
+      settingsPath: context.geminiSettingsPath,
+      hookCommand: context.geminiHookCommand
+    });
+    summary.push({
+      label: 'Gemini',
+      status: 'installed',
+      detail: configured ? 'Hooks already installed' : 'Will install hooks'
+    });
+  } else {
+    summary.push({ label: 'Gemini', status: 'skipped', detail: 'Config not found' });
+  }
+
+  const opencodeDirExists = await isDir(context.opencodeConfigDir);
+  const installed = await isOpencodePluginInstalled({ configDir: context.opencodeConfigDir });
+  const opencodeDetail = installed
+    ? 'Plugin already installed'
+    : opencodeDirExists
+      ? 'Will install plugin'
+      : 'Will create config and install plugin';
+  summary.push({
+    label: 'Opencode Plugin',
+    status: 'installed',
+    detail: opencodeDetail
+  });
+
+  const codeProbe = await probeFile(context.codeConfigPath);
+  if (codeProbe.exists) {
+    const existing = await readEveryCodeNotify(context.codeConfigPath);
+    const matches = arraysEqual(existing, context.codeNotifyCmd);
+    summary.push({
+      label: 'Every Code',
+      status: matches ? 'set' : 'updated',
+      detail: matches ? 'Already configured' : 'Will update config'
+    });
+  } else {
+    summary.push({ label: 'Every Code', status: 'skipped', detail: renderSkipDetail(codeProbe) });
   }
+
+  return summary;
+}
+
+function renderSkipDetail(probe) {
+  if (!probe || probe.reason === 'missing') return 'Config not found';
+  if (probe.reason === 'permission-denied') return 'Permission denied';
+  if (probe.reason === 'not-file') return 'Invalid config';
+  return 'Unavailable';
+}
+
+function arraysEqual(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b)) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
 }
 
 function parseArgs(argv) {
@@ -258,7 +520,9 @@ function parseArgs(argv) {
     deviceName: null,
     linkCode: null,
     noAuth: false,
-    noOpen: false
+    noOpen: false,
+    yes: false,
+    dryRun: false
   };
 
   for (let i = 0; i < argv.length; i++) {
@@ -271,14 +535,16 @@ function parseArgs(argv) {
     else if (a === '--link-code') out.linkCode = argv[++i] || null;
     else if (a === '--no-auth') out.noAuth = true;
     else if (a === '--no-open') out.noOpen = true;
+    else if (a === '--yes') out.yes = true;
+    else if (a === '--dry-run') out.dryRun = true;
     else throw new Error(`Unknown option: ${a}`);
   }
   return out;
 }
 
-function maskSecret(s) {
-  if (typeof s !== 'string' || s.length < 8) return '***';
-  return `${s.slice(0, 4)}…${s.slice(-4)}`;
+function sleep(ms) {
+  if (!ms || ms <= 0) return Promise.resolve();
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 function normalizePlatform(value) {
@@ -326,7 +592,8 @@ const signalPath = ${JSON.stringify(queueSignalPath)};
 const codexOriginalPath = ${JSON.stringify(originalPath)};
 const codeOriginalPath = ${JSON.stringify(path.join(trackerDir, 'code_notify_original.json'))};
 const trackerBinPath = ${JSON.stringify(trackerBinPath)};
-const depsMarkerPath = path.join(trackerDir, 'app', 'node_modules', '@insforge', 'sdk', 'package.json');
+  const depsMarkerPath = path.join(trackerDir, 'app', 'node_modules', '@insforge', 'sdk', 'package.json');
+  const configPath = path.join(trackerDir, 'config.json');
 const fallbackPkg = ${JSON.stringify(fallbackPkg)};
 const selfPath = path.resolve(__filename);
 const home = os.homedir();
@@ -338,11 +605,19 @@ try {
 
 // Throttle spawn: at most once per 20 seconds.
 try {
-  const throttlePath = path.join(trackerDir, 'sync.throttle');
-  const now = Date.now();
-  let last = 0;
-  try { last = Number(fs.readFileSync(throttlePath, 'utf8')) || 0; } catch (_) {}
-  if (now - last > 20_000) {
+    const throttlePath = path.join(trackerDir, 'sync.throttle');
+    let deviceToken = process.env.VIBESCORE_DEVICE_TOKEN || null;
+    if (!deviceToken) {
+      try {
+        const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (cfg && typeof cfg.deviceToken === 'string') deviceToken = cfg.deviceToken;
+      } catch (_) {}
+    }
+    const canSync = Boolean(deviceToken && deviceToken.length > 0);
+    const now = Date.now();
+    let last = 0;
+    try { last = Number(fs.readFileSync(throttlePath, 'utf8')) || 0; } catch (_) {}
+    if (canSync && now - last > 20_000) {
     try { fs.writeFileSync(throttlePath, String(now), 'utf8'); } catch (_) {}
     const hasLocalRuntime = fs.existsSync(trackerBinPath);
     const hasLocalDeps = fs.existsSync(depsMarkerPath);
@@ -435,15 +710,6 @@ async function checkUrlReachable(url) {
   }
 }
 
-async function isFile(p) {
-  try {
-    const st = await fs.stat(p);
-    return st.isFile();
-  } catch (_e) {
-    return false;
-  }
-}
-
 async function probeFile(p) {
   try {
     const st = await fs.stat(p);
@@ -456,14 +722,6 @@ async function probeFile(p) {
   }
 }
 
-function renderProbeSkip(pathname, probe) {
-  if (!probe || probe.reason === 'missing') return `${pathname} not found`;
-  if (probe.reason === 'not-file') return `${pathname} is not a file`;
-  if (probe.reason === 'permission-denied') return `permission denied: ${pathname}`;
-  const code = probe.code ? ` (${probe.code})` : '';
-  return `unavailable: ${pathname}${code}`;
-}
-
 async function isDir(p) {
   try {
     const st = await fs.stat(p);
@@ -508,7 +766,9 @@ function spawnInitSync({ trackerBinPath, packageName }) {
   });
   child.on('error', (err) => {
     const msg = err && err.message ? err.message : 'unknown error';
-    process.stderr.write(`Initial sync spawn failed: ${msg}\n`);
+    const detail = process.env.VIBESCORE_DEBUG === '1' ? ` (${msg})` : '';
+    process.stderr.write(`Minor issue: Background sync could not start${detail}.\n`);
+    process.stderr.write('Run: npx --yes @vibescore/tracker sync\n');
   });
   child.unref();
 }

package/src/lib/browser-auth.js

@@ -170,5 +170,6 @@ function resolvePostAuthRedirect({ dashboardUrl, authUrl }) {
 }
 
 module.exports = {
-  beginBrowserAuth
+  beginBrowserAuth,
+  openInBrowser
 };

package/src/lib/cli-ui.js

@@ -0,0 +1,179 @@
+const readline = require('node:readline');
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const BLUE = '\x1b[34m';
+const UNDERLINE = '\x1b[4m';
+
+const SPINNER_FRAMES = ['|', '/', '-', '\\'];
+
+function isInteractive() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function formatLine(line, width) {
+  if (!width) return line;
+  const raw = String(line || '');
+  const pad = Math.max(0, width - raw.length);
+  return raw + ' '.repeat(pad);
+}
+
+function renderBox(lines, { padding = 1 } = {}) {
+  const content = lines.map((line) => String(line || ''));
+  const maxLen = content.reduce((max, line) => Math.max(max, line.length), 0);
+  const innerWidth = maxLen + padding * 2;
+  const top = `+${'-'.repeat(innerWidth)}+`;
+  const bottom = `+${'-'.repeat(innerWidth)}+`;
+  const body = content.map((line) => {
+    const padded = ' '.repeat(padding) + formatLine(line, maxLen) + ' '.repeat(padding);
+    return `|${padded}|`;
+  });
+  return [top, ...body, bottom].join('\n');
+}
+
+function color(text, token) {
+  return `${token}${text}${RESET}`;
+}
+
+function underline(text) {
+  return `${UNDERLINE}${text}${RESET}`;
+}
+
+async function promptEnter(message) {
+  if (!isInteractive()) return;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  await new Promise((resolve) => rl.question(message, () => resolve()));
+  rl.close();
+}
+
+async function promptMenu({ message, options, defaultIndex = 0 }) {
+  if (!isInteractive()) return options[defaultIndex] || options[0];
+
+  const safeOptions = Array.isArray(options) ? options : [];
+  if (safeOptions.length === 0) return '';
+
+  const maxIndex = safeOptions.length - 1;
+  let currentIndex = Math.min(Math.max(defaultIndex, 0), maxIndex);
+  const promptMessage = `${message} (Use Up/Down arrows, Enter)`;
+  const linesCount = safeOptions.length + 1;
+
+  const renderLines = () => {
+    const lines = [promptMessage];
+    safeOptions.forEach((opt, idx) => {
+      const prefix = idx === currentIndex ? '>' : ' ';
+      lines.push(`${prefix} ${opt}`);
+    });
+    process.stdout.write(lines.join('\n'));
+  };
+
+  const rerender = () => {
+    for (let i = 0; i < linesCount; i += 1) {
+      process.stdout.write('\x1b[2K');
+      if (i < linesCount - 1) process.stdout.write('\x1b[1A');
+    }
+    process.stdout.write('\r');
+    renderLines();
+  };
+
+  renderLines();
+
+  return await new Promise((resolve) => {
+    const cleanup = () => {
+      process.stdin.off('keypress', onKeypress);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+      process.stdout.write('\n');
+    };
+
+    const onKeypress = (str, key = {}) => {
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        return resolve(safeOptions[currentIndex]);
+      }
+      if (key.name === 'up' || str === 'k') {
+        currentIndex = currentIndex === 0 ? maxIndex : currentIndex - 1;
+        rerender();
+        return;
+      }
+      if (key.name === 'down' || str === 'j') {
+        currentIndex = currentIndex === maxIndex ? 0 : currentIndex + 1;
+        rerender();
+        return;
+      }
+      if (key.name === 'return') {
+        cleanup();
+        return resolve(safeOptions[currentIndex]);
+      }
+      if (str && /^[1-9]$/.test(str)) {
+        const idx = Number.parseInt(str, 10) - 1;
+        if (idx >= 0 && idx <= maxIndex) {
+          currentIndex = idx;
+          cleanup();
+          return resolve(safeOptions[currentIndex]);
+        }
+      }
+    };
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('keypress', onKeypress);
+  });
+}
+
+function createSpinner({ text, intervalMs = 80 }) {
+  let frame = 0;
+  let timer = null;
+
+  function start() {
+    if (!isInteractive()) {
+      process.stdout.write(`${text}\n`);
+      return;
+    }
+    timer = setInterval(() => {
+      const glyph = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+      frame += 1;
+      process.stdout.write(`\r${glyph} ${text}`);
+    }, intervalMs);
+  }
+
+  function stop(successText) {
+    if (timer) clearInterval(timer);
+    if (isInteractive()) {
+      process.stdout.write(`\r${' '.repeat(text.length + 4)}\r`);
+    }
+    if (successText) process.stdout.write(`${successText}\n`);
+  }
+
+  return { start, stop };
+}
+
+function formatSummaryLine({ label, status, detail }) {
+  const isSuccess = status === 'updated' || status === 'set' || status === 'installed';
+  const bullet = isSuccess ? color('*', GREEN) : 'o';
+  const statusLabel = isSuccess ? (detail || status) : detail ? `Skipped - ${detail}` : 'Skipped';
+  const line = `  ${bullet} ${label.padEnd(22)} [${statusLabel}]`;
+  return isSuccess ? line : color(line, DIM);
+}
+
+module.exports = {
+  BOLD,
+  DIM,
+  CYAN,
+  GREEN,
+  YELLOW,
+  BLUE,
+  RESET,
+  color,
+  underline,
+  renderBox,
+  isInteractive,
+  promptMenu,
+  promptEnter,
+  createSpinner,
+  formatSummaryLine
+};

package/src/lib/init-flow.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { formatSummaryLine, renderBox, underline } = require('./cli-ui');
+
+const DIVIDER = '----------------------------------------------';
+
+function renderLocalReport({ summary, isDryRun }) {
+  const header = isDryRun
+    ? 'Dry run complete. Preview only; no changes were applied.'
+    : 'Local configuration complete.';
+  const lines = [header, '', 'Integration Status:'];
+  for (const item of summary || []) lines.push(formatSummaryLine(item));
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+function renderAuthTransition({ authUrl, canAutoOpen }) {
+  const lines = ['', DIVIDER, '', 'Next: Registering device...'];
+  if (canAutoOpen) {
+    lines.push('Opening your browser to link account...');
+    if (authUrl) lines.push(`If it does not open, visit: ${underline(authUrl)}`);
+  } else {
+    lines.push('Open the link below to sign in.');
+    if (authUrl) lines.push(`Visit: ${underline(authUrl)}`);
+  }
+  lines.push('');
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+function renderSuccessBox({ configPath, dashboardUrl }) {
+  const identityLine = 'Account linked.';
+  const lines = [
+    'You are all set!',
+    '',
+    identityLine,
+    `Token saved to: ${configPath}`,
+    ''
+  ];
+  if (dashboardUrl) lines.push(`View your stats at: ${dashboardUrl}`);
+  lines.push('You can close this terminal window.');
+  process.stdout.write(`${renderBox(lines)}\n`);
+}
+
+module.exports = {
+  DIVIDER,
+  renderLocalReport,
+  renderAuthTransition,
+  renderSuccessBox
+};