syndes 0.1.0 → 0.2.0

package/README.md

@@ -29,6 +29,13 @@ surface at most one nudge, at a moment that does not interrupt you, always with
 the evidence attached: *"you edited `src/app.ts` six times in twelve minutes
 without running tests."*
 
+**Splits one shared account between the people on it.** Two people on one Claude
+plan look like one user to Anthropic — there is no per-person breakdown to ask
+for. SynDes measures on each machine and pools the results through a private git
+repo or a synced folder, so you get the actual split: who used what, when, and
+which hours you spent competing for the same rate-limit window. Counts and
+tokens are shared; prompts, paths and commands never leave the machine.
+
 **Shows you the whole picture.** `syndes dashboard` opens a local
 dashboard: your efficiency score and its five pillars, token and cost
 breakdowns, cache hit rate, active time versus wall-clock, permission friction,
@@ -50,6 +57,8 @@ machine already has — `syndes lock system` asks Touch ID — or set a PIN.
 | `syndes sessions` | list and drill down |
 | `syndes export --format=csv` | all of it, back out |
 | `syndes lock system` | require Touch ID to open the dashboard |
+| `syndes team join <repo>` | share one account, see the split |
+| `syndes team status` | who used how much |
 | `syndes sources` | which coding agents SynDes can see |
 | `syndes watch` | follow agents that have no hook API |
 | `syndes doctor` | what is wired and what actually works |
@@ -66,6 +75,26 @@ request whose `Host` is not a literal loopback address — without that, any web
 page you have open could read it. The lock is the second layer, for machines
 other people also use.
 
+## Sharing an account
+
+```bash
+syndes team join git@github.com:you/usage.git   # a private repo you both push to
+syndes team join ~/Dropbox/usage --folder       # or no server at all
+syndes team name "Ada"
+```
+
+Each machine writes only its own folder and reads everyone's, so there is nothing
+to merge and nothing to run. Open the dashboard and the **Team** page is live
+while you watch it.
+
+What leaves your machine: daily counts, tokens, and the hours you worked. What
+never does: your prompts, your file paths, your commands — at any setting.
+
+This is cooperative measurement, not enforcement. It sees Claude Code on machines
+where SynDes is installed, and anyone can stop publishing. Note that consumer
+plans are licensed to one person; per-person logins are both the supported path
+and the only way a split can be enforced rather than agreed.
+
 ## Honest limits
 
 The ledger is **tamper-evident, not tamper-proof**. Anything running as your

package/analytics/metrics/rework.mjs

@@ -85,11 +85,17 @@ export function merge(parts) {
   let verifiedRuns = 0;
   let unverifiedRuns = 0;
 
+  // A storm's key names the command that failed, so it is never shared — but
+  // the COUNT is what the score reads, and without it a shared rollup scored a
+  // free hundred on the one part meant to catch a loop that is not converging.
+  let stormsCounted = 0;
+
   for (const part of parts) {
     for (const [path, count] of Object.entries(part.churn ?? {})) {
       churn[path] = Math.max(churn[path] ?? 0, count);
     }
-    storms.push(...(part.storms ?? []));
+    if (Array.isArray(part.storms)) storms.push(...part.storms);
+    else stormsCounted += part.stormCount ?? 0;
     errors += part.errors ?? 0;
     calls += part.calls ?? 0;
     verifiedRuns += part.verifiedRuns ?? 0;
@@ -102,7 +108,7 @@ export function merge(parts) {
     churn: Object.fromEntries(ranked.slice(0, 25)),
     worstChurn: ranked[0] ? { path: ranked[0][0], edits: ranked[0][1] } : null,
     storms: storms.slice(0, 25),
-    stormCount: storms.length,
+    stormCount: storms.length + stormsCounted,
     errors,
     calls,
     errorRate: calls ? errors / calls : 0,

package/analytics/metrics/volume.mjs

@@ -68,11 +68,24 @@ export function merge(parts) {
   const files = new Set();
   const totals = { prompts: 0, toolCalls: 0, writes: 0, commits: 0, insertions: 0, deletions: 0, filesChanged: 0 };
 
+  // A shared rollup has had its ids removed and carries only a count (see
+  // sync/share.mjs). Deduplication is impossible without the ids, so those
+  // counts are summed instead — which over-counts a session spanning midnight
+  // and is far better than the alternative, which was reporting zero sessions
+  // and silently dropping the largest part of the context score.
+  const counted = { sessions: 0, projects: 0, files: 0 };
+
   const bySource = {};
   for (const part of parts) {
-    for (const id of part.sessions ?? []) sessions.add(id);
-    for (const id of part.projects ?? []) projects.add(id);
-    for (const file of part.files ?? []) files.add(file);
+    if (Array.isArray(part.sessions)) for (const id of part.sessions) sessions.add(id);
+    else counted.sessions += part.sessionCount ?? 0;
+
+    if (Array.isArray(part.projects)) for (const id of part.projects) projects.add(id);
+    else counted.projects += part.projectCount ?? 0;
+
+    if (Array.isArray(part.files)) for (const file of part.files) files.add(file);
+    else counted.files += part.fileCount ?? 0;
+
     for (const key of Object.keys(totals)) totals[key] += part[key] ?? 0;
 
     for (const [id, bucket] of Object.entries(part.bySource ?? {})) {
@@ -86,9 +99,9 @@ export function merge(parts) {
 
   return {
     ...totals,
-    sessionCount: sessions.size,
-    projectCount: projects.size,
-    fileCount: files.size,
+    sessionCount: sessions.size + counted.sessions,
+    projectCount: projects.size + counted.projects,
+    fileCount: files.size + counted.files,
     sessions: [...sessions],
     projects: [...projects],
     bySource: Object.fromEntries(Object.entries(bySource).map(([id, b]) => [id, {

package/analytics/team.mjs

@@ -0,0 +1,245 @@
+/**
+ * The shared-account view: who used how much, and when you were in each
+ * other's way.
+ *
+ * The headline number here is deliberately NOT dollars. On a shared plan there
+ * is no per-token bill to split — the scarce thing is the usage window, and two
+ * people working the same hour throttle each other in a way neither of them can
+ * see from their own machine. So this module computes share, and it computes
+ * contention, and it treats cost as the secondary figure it actually is.
+ *
+ * Everything is derived from sanitised peer rollups (sync/share.mjs), which
+ * carry counts and no content. Nothing here reads a peer's records, because
+ * nothing ever sends them.
+ */
+
+import { rangeFor, previousRange } from './ranges.mjs';
+import { mergeRollups, METRICS } from './rollup.mjs';
+import { costOf } from './metrics/cost.mjs';
+import { score } from './score.mjs';
+import { readPool, loadState, teamConfig, isEnabled, poolRoot } from '../sync/index.mjs';
+import { identity, initialsOf } from '../runtime/identity.mjs';
+import { loadConfig } from '../runtime/config.mjs';
+
+/** Three-hour bands: eight rows is a grid you can read, twenty-four is a wall. */
+const BAND_HOURS = 3;
+const BANDS = 24 / BAND_HOURS;
+/** Beyond this the grid stops being a picture and starts being a spreadsheet. */
+const MAX_GRID_DAYS = 14;
+
+/**
+ * @param {string} spec  a range spec, as analytics/ranges.mjs understands it
+ * @returns {Promise<object>} everything the Team page renders
+ */
+export async function team(spec = '7d') {
+  const range = rangeFor(spec);
+  const before = previousRange(range);
+  const prices = loadConfig().prices ?? {};
+  const me = identity();
+
+  const enabled = isEnabled();
+  const pool = enabled ? readPool() : [];
+
+  const peers = pool.map((peer) => {
+    const current = rollupsIn(peer, range.days);
+    const previous = rollupsIn(peer, before.days);
+
+    const merged = mergeRollups(current);
+    const mergedBefore = mergeRollups(previous);
+    const tokens = totalTokens(merged.tokens);
+
+    return {
+      deviceId: peer.deviceId,
+      name: peer.name,
+      initials: initialsOf(peer.name),
+      host: peer.host,
+      os: peer.os,
+      scope: peer.scope,
+      isMe: peer.isMe,
+      lastSeen: peer.lastSeen,
+      // A shelf nobody has updated in a day is stale, not quiet. The UI must be
+      // able to tell those apart or it will report someone as idle who has
+      // simply stopped syncing.
+      stale: peer.lastSeen ? Date.now() - peer.lastSeen > 6 * 3_600_000 : true,
+      days: current.length,
+      totals: {
+        tokens,
+        input: merged.tokens.input ?? 0,
+        output: merged.tokens.output ?? 0,
+        cacheRead: merged.tokens.cacheRead ?? 0,
+        cacheWrite: merged.tokens.cacheWrite ?? 0,
+        cacheHitRate: merged.tokens.cacheHitRate ?? 0,
+        prompts: merged.prompts.count ?? 0,
+        toolCalls: merged.tools.calls ?? 0,
+        sessions: sessionCountOf(merged, current),
+        activeMs: merged.time.activeMs ?? 0,
+        wallMs: merged.time.wallMs ?? 0,
+        compacts: merged.context.compacts ?? 0,
+        blocks: merged.friction.blocks ?? 0,
+        usd: costOf(merged.tokens, prices).usd,
+      },
+      previousTokens: totalTokens(mergedBefore.tokens),
+      // A peer sharing at `summary` still has every pillar the score reads,
+      // because the score never needed a path or a session id.
+      score: score(merged).total,
+      hours: merged.time.hours ?? new Array(24).fill(0),
+      series: range.days.map((day) => {
+        const rollup = peer.rollups.get(day);
+        return {
+          day,
+          tokens: rollup ? totalTokens(mergeRollups([rollup]).tokens) : 0,
+          activeMs: rollup?.metrics?.time?.activeMs ?? 0,
+          prompts: rollup?.metrics?.prompts?.count ?? 0,
+          toolCalls: rollup?.metrics?.tools?.calls ?? 0,
+          hours: rollup?.metrics?.time?.hours ?? new Array(24).fill(0),
+        };
+      }),
+    };
+  });
+
+  const poolTokens = peers.reduce((sum, peer) => sum + peer.totals.tokens, 0);
+  const poolBefore = peers.reduce((sum, peer) => sum + peer.previousTokens, 0);
+
+  for (const peer of peers) {
+    peer.share = poolTokens ? peer.totals.tokens / poolTokens : 0;
+    const shareBefore = poolBefore ? peer.previousTokens / poolBefore : null;
+    peer.shareDelta = shareBefore === null ? null : peer.share - shareBefore;
+  }
+  peers.sort((a, b) => b.totals.tokens - a.totals.tokens);
+
+  return {
+    enabled,
+    config: {
+      transport: teamConfig().transport ?? null,
+      scope: teamConfig().scope ?? 'summary',
+      pollSeconds: teamConfig().pollSeconds ?? 30,
+      pool: enabled ? poolRoot() : null,
+    },
+    sync: loadState(),
+    me: { deviceId: me.deviceId, name: me.name, initials: initialsOf(me.name) },
+    range: { ...range, label: range.label },
+    peers,
+    totals: {
+      tokens: poolTokens,
+      usd: peers.reduce((sum, peer) => sum + peer.totals.usd, 0),
+      prompts: peers.reduce((sum, peer) => sum + peer.totals.prompts, 0),
+      toolCalls: peers.reduce((sum, peer) => sum + peer.totals.toolCalls, 0),
+      activeMs: peers.reduce((sum, peer) => sum + peer.totals.activeMs, 0),
+      sessions: peers.reduce((sum, peer) => sum + peer.totals.sessions, 0),
+      people: peers.length,
+      deltaTokens: poolBefore ? poolTokens - poolBefore : null,
+    },
+    grid: contentionGrid(peers, range.days),
+    lanes: laneRows(peers, range.days),
+  };
+}
+
+/**
+ * The contention grid — the one picture that answers "were we in each other's
+ * way".
+ *
+ * Each cell is a three-hour band of one day. Size carries volume; colour carries
+ * how many people were working in it, which on a shared plan is the thing that
+ * actually costs you: one person alone gets the whole window, two people split
+ * it and both get throttled. Colour is therefore load-bearing here in exactly
+ * the way the palette intends — orange means look at this, and it means it
+ * because that band is where your limits were being spent twice.
+ */
+function contentionGrid(peers, days) {
+  const window = days.slice(-MAX_GRID_DAYS);
+  const cells = [];
+  let peak = 0;
+
+  for (const day of window) {
+    for (let band = 0; band < BANDS; band += 1) {
+      const byDevice = {};
+      let total = 0;
+
+      for (const peer of peers) {
+        const entry = peer.series.find((point) => point.day === day);
+        if (!entry) continue;
+        let count = 0;
+        for (let hour = band * BAND_HOURS; hour < (band + 1) * BAND_HOURS; hour += 1) {
+          count += entry.hours[hour] ?? 0;
+        }
+        if (count > 0) byDevice[peer.deviceId] = count;
+        total += count;
+      }
+
+      peak = Math.max(peak, total);
+      cells.push({
+        day,
+        band,
+        hour: band * BAND_HOURS,
+        total,
+        people: Object.keys(byDevice).length,
+        byDevice,
+      });
+    }
+  }
+
+  const overlapping = cells.filter((cell) => cell.people > 1);
+  return {
+    days: window,
+    bands: BANDS,
+    bandHours: BAND_HOURS,
+    cells,
+    peak,
+    overlapBands: overlapping.length,
+    // Reported as a share of the bands that had ANY work in them. A share of all
+    // bands would be dominated by everyone being asleep, which flatters nobody.
+    overlapRate: cells.filter((cell) => cell.total > 0).length
+      ? overlapping.length / cells.filter((cell) => cell.total > 0).length
+      : 0,
+  };
+}
+
+/** One row per day, split into each person's segment — the split, day by day. */
+function laneRows(peers, days) {
+  return [...days].reverse().slice(0, 12).map((day) => {
+    const segments = peers
+      .map((peer) => {
+        const point = peer.series.find((entry) => entry.day === day);
+        return {
+          deviceId: peer.deviceId,
+          name: peer.name,
+          initials: peer.initials,
+          isMe: peer.isMe,
+          tokens: point?.tokens ?? 0,
+          activeMs: point?.activeMs ?? 0,
+        };
+      })
+      .filter((segment) => segment.tokens > 0)
+      .sort((a, b) => b.tokens - a.tokens);
+
+    return { day, total: segments.reduce((sum, s) => sum + s.tokens, 0), segments };
+  });
+}
+
+function rollupsIn(peer, days) {
+  const out = [];
+  for (const day of days) {
+    const rollup = peer.rollups.get(day);
+    if (rollup) out.push(rollup);
+  }
+  return out;
+}
+
+function totalTokens(summary) {
+  if (!summary) return 0;
+  return (summary.input ?? 0) + (summary.output ?? 0) + (summary.cacheRead ?? 0) + (summary.cacheWrite ?? 0);
+}
+
+/**
+ * Sessions, from whichever field the peer's scope left us.
+ *
+ * At `summary` the ids are gone and only a count survives, so summing the
+ * per-day counts is the honest answer — it over-counts a session that spans
+ * midnight, which is a smaller error than reporting zero.
+ */
+function sessionCountOf(merged, rollups) {
+  if (merged.volume?.sessionCount) return merged.volume.sessionCount;
+  return rollups.reduce((sum, rollup) => sum + (rollup.metrics?.volume?.sessionCount ?? 0), 0);
+}
+
+export { contentionGrid, BAND_HOURS, BANDS };

package/bin/cli.mjs

@@ -10,6 +10,7 @@
 import { readFileSync, writeFileSync, existsSync, unlinkSync, mkdirSync } from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import { join } from 'node:path';
+import { homedir } from 'node:os';
 import {
   packageRoot, displayPath, dataDir, installDir, workerScript, pauseFile,
   ensureDataDirs, installedCliScript, isInstalledCopy,
@@ -41,6 +42,9 @@ import { openUrl } from '../src/open.mjs';
 import { pendingCount } from '../runtime/spool.mjs';
 import { detectAll, adapterFor, ADAPTERS } from '../adapters/index.mjs';
 import { pollTails, resetCursors } from '../collect/tail.mjs';
+import { joinPool, leave as leavePool, syncOnce, readPool, isEnabled, teamConfig, loadState, poolRoot } from '../sync/index.mjs';
+import { identity, setName, initialsOf } from '../runtime/identity.mjs';
+import { team as teamView } from '../analytics/team.mjs';
 
 const VERSION = readVersion();
 
@@ -48,7 +52,7 @@ const COMMANDS = {
   install: cmdInstall, uninstall: cmdUninstall, doctor: cmdDoctor,
   status: cmdStatus, report: cmdReport, dashboard: cmdDashboard, ui: cmdDashboard,
   lock: cmdLock, verify: cmdVerify, sessions: cmdSessions,
-  sources: cmdSources, watch: cmdWatch,
+  sources: cmdSources, watch: cmdWatch, team: cmdTeam,
   projects: cmdProjects, practices: cmdPractices, habits: cmdPractices, coach: cmdCoach,
   ledger: cmdLedger, export: cmdExport, rebuild: cmdRebuild, drain: cmdDrain,
   archive: cmdArchive, prune: cmdPrune, config: cmdConfig,
@@ -119,10 +123,114 @@ async function cmdInstall(args) {
   if (found.length) scan.succeed(found.map((agent) => agent.name).join(', '));
   else scan.skip('none besides Claude Code');
 
+  await setUpSharing(args);
+
   await runBriefing(result);
   clearPending();
 }
 
+/**
+ * The sharing question, asked during install rather than left to be discovered.
+ *
+ * Several people on one Claude account is the case SynDes cannot see without
+ * being told, and somebody who does not know the feature exists will never run
+ * `syndes team join`. So install asks — once, in the one moment the user is
+ * already configuring the tool.
+ *
+ * Three things this must never do:
+ *   • Ask when nobody is there to answer. The npm postinstall runs install()
+ *     with no TTY, and a prompt there would hang `npm install -g` forever.
+ *   • Ask again on a re-install. Repairing an install is not an invitation to
+ *     re-interview somebody about a decision they already made.
+ *   • Fail the install. A pool that cannot be reached is a pool problem; the
+ *     hooks are wired and the ledger is open either way.
+ */
+async function setUpSharing(args = []) {
+  const flag = (name) => args.find((arg) => arg.startsWith(`--${name}=`))?.split('=').slice(1).join('=');
+  const repoFlag = flag('team');
+  const nameFlag = flag('name');
+
+  if (args.includes('--no-team')) return;
+
+  // Already in a pool: report, do not re-ask.
+  if (isEnabled() && !repoFlag) {
+    const step = spinner('Checking the shared pool');
+    await beat();
+    const state = syncOnce();
+    if (state.ok) step.succeed(`${identity().name} · ${readPool().length} machine(s)`);
+    else step.fail(state.error ?? 'could not reach the pool');
+    return;
+  }
+
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY) && !process.env.CI;
+  if (!repoFlag && !interactive) return; // nobody is there to answer
+
+  let repo = repoFlag;
+  let who = nameFlag;
+
+  if (!repo) {
+    write();
+    write(`  ${bold('Is anyone else using this Claude account?')}`);
+    write(grey('  Two people on one account look like one user. SynDes can pool each'));
+    write(grey('  machine\'s numbers through a private repo so you see the real split.'));
+    write(grey('  Counts and tokens are shared. Prompts, paths and commands never are.'));
+    write();
+
+    if (!(await confirm('  Set up sharing now?'))) {
+      write(grey(`  ${DOT} skipped — ${cyan('syndes team join <repo>')} whenever you want it`));
+      write();
+      return;
+    }
+
+    write();
+    write(grey('  A private git repo everyone can push to, or a synced folder.'));
+    write(grey('  e.g. git@github.com:you/usage.git   or   ~/Dropbox/usage'));
+    repo = (await ask('  Repository or folder: ')).trim();
+    if (!repo) {
+      write(grey(`  ${DOT} nothing entered — ${cyan('syndes team join <repo>')} later`));
+      write();
+      return;
+    }
+    who = who || (await ask(`  Your name [${identity().name}]: `)).trim();
+  }
+
+  if (who) {
+    try { setName(who); } catch { /* an unusable name is not worth failing an install over */ }
+  }
+
+  const path = repo.startsWith('~') ? repo.replace('~', homedir()) : repo;
+  const transport = /^(https?:\/\/|git@|ssh:\/\/|git:\/\/)/.test(path) || path.endsWith('.git')
+    ? 'git'
+    : 'folder';
+
+  write();
+  const step = spinner(`Joining the pool over ${transport}`);
+  await beat();
+  try {
+    joinPool({ transport, repo: path });
+  } catch (error) {
+    // Deliberately not fatal. The install succeeded; only the pool did not.
+    step.fail(error.message);
+    write(grey(`  ${DOT} everything else is installed — fix the repo and run ${cyan('syndes team join')}`));
+    write();
+    return;
+  }
+  step.succeed(path);
+
+  const share = spinner('Publishing this machine');
+  await beat();
+  const state = syncOnce();
+  if (state.ok) {
+    share.succeed(`${state.published} day(s) shared as ${identity().name}`);
+    const others = readPool().filter((peer) => !peer.isMe);
+    if (others.length) write(grey(`  ${DOT} already in the pool: ${others.map((peer) => peer.name).join(', ')}`));
+  } else {
+    share.fail(state.error ?? 'could not publish');
+    write(grey(`  ${DOT} joined, but the exchange failed — check git access, then ${cyan('syndes team sync')}`));
+  }
+  write();
+}
+
 async function cmdUninstall(args) {
   const purge = args.includes('--purge');
 
@@ -484,6 +592,122 @@ async function cmdWatch(args) {
   process.on('SIGINT', () => { clearInterval(timer); write(); process.exit(0); });
 }
 
+/**
+ * `syndes team …` — the shared-account pool.
+ *
+ * Sub-verbs rather than top-level commands: everything here is meaningless
+ * unless sharing is on, and hanging six more verbs off the root would bury the
+ * ones that matter to somebody using this alone.
+ */
+async function cmdTeam(args) {
+  const [verb = 'status', ...rest] = args;
+
+  if (verb === 'join') {
+    const repo = rest.find((arg) => !arg.startsWith('--'));
+    if (!repo) throw new Error('usage: syndes team join <repo-url|folder> [--folder] [--detailed]');
+
+    const transport = rest.includes('--folder') || !/^(https?:\/\/|git@|ssh:\/\/|git:\/\/)/.test(repo)
+      ? (repo.endsWith('.git') ? 'git' : 'folder')
+      : 'git';
+
+    const spin = spinner(`Joining the pool over ${transport}`);
+    await beat();
+    let result;
+    try {
+      result = joinPool({ transport, repo, scope: rest.includes('--detailed') ? 'detailed' : undefined });
+    } catch (error) {
+      spin.fail(error.message);
+      throw error;
+    }
+    spin.succeed(result.describe ?? repo);
+
+    const push = spinner('Publishing this machine');
+    await beat();
+    const state = syncOnce();
+    if (state.ok) push.succeed(`${state.published} day(s) shared`);
+    else push.fail(state.error ?? 'could not reach the pool');
+
+    write();
+    write(grey(`  You appear as ${bold(identity().name)}. ${cyan('syndes team name <you>')} to change it.`));
+    write(grey(`  ${cyan('syndes dashboard')} then open Team for the live view.`));
+    write();
+    return;
+  }
+
+  if (verb === 'leave') {
+    leavePool();
+    write(`${OK} left the pool ${grey('· your shelf stays until someone deletes it')}`);
+    return;
+  }
+
+  if (verb === 'name') {
+    if (!rest.length) throw new Error('usage: syndes team name <your name>');
+    const me = setName(rest.join(' '));
+    if (isEnabled()) syncOnce();
+    write(`${OK} this machine is ${bold(me.name)}`);
+    return;
+  }
+
+  if (verb === 'scope') {
+    const scope = rest[0];
+    if (!['summary', 'detailed'].includes(scope)) throw new Error('usage: syndes team scope <summary|detailed>');
+    const next = rawConfig();
+    setPath(next, 'team.scope', scope);
+    saveConfig(next);
+    if (isEnabled()) syncOnce();
+    write(`${OK} sharing ${bold(scope)} ${grey('· prompt text is never shared, at any scope')}`);
+    return;
+  }
+
+  if (verb === 'sync') {
+    if (!isEnabled()) return write(grey('sharing is off — syndes team join <repo>'));
+    const spin = spinner('Exchanging with the pool');
+    await beat();
+    const state = syncOnce();
+    if (state.ok) spin.succeed(`${state.published} day(s) published${state.pushed ? ', pushed' : ', nothing new to push'}`);
+    else spin.fail(state.error ?? 'sync failed');
+    if (!state.ok) process.exitCode = 1;
+    return;
+  }
+
+  // status
+  if (!isEnabled()) {
+    write();
+    write(`  ${grey('sharing is')} ${bold('off')}`);
+    write();
+    write(grey('  One Claude account used by several people shows up as one user.'));
+    write(grey('  A pool gives each machine its own shelf, so the split is visible.'));
+    write();
+    write(`  ${cyan('syndes team join git@github.com:you/usage.git')}`);
+    write(`  ${cyan('syndes team join ~/Dropbox/usage --folder')}`);
+    write();
+    return;
+  }
+
+  const data = await teamView(rest[0] ?? '7d');
+  const state = loadState();
+
+  write();
+  write(`  ${bold('Pool')} ${grey(poolRoot())}`);
+  write(`  ${grey('transport')} ${teamConfig().transport}  ${grey('scope')} ${teamConfig().scope}  ${grey('last sync')} ${state.at ? new Date(state.at).toLocaleTimeString() : '—'}${state.error ? red(' · ' + String(state.error).slice(0, 60)) : ''}`);
+  write();
+  write(table([
+    [grey(''), grey('person'), grey('share'), grey('tokens'), grey('sessions'), grey('active'), grey('last seen')],
+    ...data.peers.map((peer) => [
+      peer.isMe ? green('›') : ' ',
+      `${peer.name}${peer.stale ? yellow(' (stale)') : ''}`,
+      percent(peer.share),
+      compact(peer.totals.tokens),
+      String(peer.totals.sessions),
+      duration(peer.totals.activeMs),
+      peer.lastSeen ? new Date(peer.lastSeen).toLocaleString(undefined, { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' }) : '—',
+    ]),
+  ], { align: ['left', 'left', 'right', 'right', 'right', 'right', 'left'] }).map((line) => `  ${line}`).join('\n'));
+  write();
+  write(`  ${grey('overlap')} ${percent(data.grid.overlapRate)} ${grey(`of working hours had more than one of you in them`)}`);
+  write();
+}
+
 /** `syndes lock [open|system|pin]` */
 async function cmdLock(args) {
   const requested = args[0];
@@ -577,6 +801,7 @@ function usage_() {
     [cyan('export --format=csv'), 'all of it, back out'],
     [cyan('sources'), 'which coding agents SynDes can see'],
     [cyan('watch [--once]'), 'follow agents that have no hook API'],
+    [cyan('team [join|status]'), 'share one account and see the split'],
     [cyan('lock [mode]'), 'how the dashboard unlocks: open, system or pin'],
     [cyan('doctor [--full]'), 'what is wired and what actually works'],
     [cyan('off [30m] / on'), 'pause and resume tracking'],

package/collect/projects.mjs

@@ -11,22 +11,38 @@
  */
 
 import { execFileSync } from 'node:child_process';
-import { basename, resolve } from 'node:path';
+import { basename, resolve, sep } from 'node:path';
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { projectsFile } from '../runtime/paths.mjs';
+import { projectsFile, dataDir } from '../runtime/paths.mjs';
 import { which } from '../runtime/platform.mjs';
 
 const cache = new Map();
 
+/**
+ * Our own data directory is not a project.
+ *
+ * The shared pool is a git working copy living under dataDir, so the git-root
+ * rule below would classify it as somewhere the user works — and it would then
+ * appear in their per-project breakdown and get told off for having no
+ * CLAUDE.md. It is a mirror of a remote that this tool maintains, and counting
+ * it would be the tool measuring itself.
+ */
+function isOurs(path) {
+  const root = resolve(dataDir);
+  return path === root || path.startsWith(root + sep);
+}
+
 /** @returns {{id: string, name: string, root: string}|null} */
 export function projectFor(cwd) {
   if (!cwd) return null;
   const key = resolve(cwd);
   if (cache.has(key)) return cache.get(key);
+  if (isOurs(key)) { cache.set(key, null); return null; }
 
   const root = gitRoot(key) ?? key;
+  if (isOurs(resolve(root))) { cache.set(key, null); return null; }
   const project = {
     id: createHash('sha256').update(root).digest('hex').slice(0, 12),
     name: basename(root) || root,