shakers-cli-beta 0.8.0-beta.0

package/src/auth-method-picker.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const { runInteractiveMultiSelect } = require('./interactive-select');
+const { methodsForFlow, methodLabel } = require('./auth-methods');
+
+// The shared interactive method picker for the CLI (talents-ai-score).
+async function askNumberedChoice(ask, promptText, count) {
+  const raw = (await ask(promptText)).trim();
+  if (!raw) return null;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isInteger(n) || n < 1 || n > count) return null;
+  return n - 1;
+}
+
+async function chooseAuthMethod({ flow, ask, stdinIsTTY, catalog, input, output } = {}) {
+  const methods = methodsForFlow(flow);
+  if (methods.length === 0) return null;
+  if (methods.length === 1) return methods[0].id;
+  if (!stdinIsTTY) return methods[0].id;
+
+  if (ask && typeof ask.suspend === 'function') {
+    ask.suspend();
+    const picked = await runInteractiveMultiSelect({
+      items: methods,
+      labelFor: (m) => methodLabel(m, catalog),
+      header: catalog.chooseMethodHeading,
+      hint: catalog.selectHint,
+      single: true,
+      ...(input ? { input } : {}),
+      ...(output ? { output } : {}),
+    });
+    if (typeof ask.resume === 'function') ask.resume();
+    if (!picked || picked.length === 0) return null;
+    return picked[0].id;
+  }
+
+  const stream = output || process.stdout;
+  stream.write(`\n  ${catalog.chooseMethodHeading}\n`);
+  methods.forEach((m, i) => stream.write(`    ${i + 1}) ${methodLabel(m, catalog)}\n`));
+  const idx = await askNumberedChoice(ask, `  ${catalog.chooseMethodPrompt(methods.length)}`, methods.length);
+  return idx === null ? null : methods[idx].id;
+}
+
+module.exports = { chooseAuthMethod, askNumberedChoice };

package/src/auth-methods.js

@@ -0,0 +1,35 @@
+'use strict';
+
+// The SINGLE source of truth for which auth methods exist and where each one is offered (talents-ai-score).
+const AUTH_METHODS = [
+  { id: 'email', labelKey: 'methodEmail', availableFor: { login: true, register: true } },
+  { id: 'google', labelKey: 'methodGoogle', availableFor: { login: true, register: true } },
+  { id: 'linkedin', labelKey: 'methodLinkedin', availableFor: { login: true, register: true } },
+];
+
+// Social methods share ONE device flow; only the `provider` query param differs.
+const SOCIAL_METHODS = new Set(['google', 'linkedin']);
+function isSocialMethod(id) {
+  return SOCIAL_METHODS.has(id);
+}
+
+function methodsForFlow(flow) {
+  return AUTH_METHODS.filter((m) => m.availableFor && m.availableFor[flow] === true);
+}
+
+function methodIdsForFlow(flow) {
+  return methodsForFlow(flow).map((m) => m.id);
+}
+
+function isMethodAvailable(id, flow) {
+  return methodIdsForFlow(flow).includes(id);
+}
+
+function methodLabel(method, catalog) {
+  const entry = typeof method === 'string' ? AUTH_METHODS.find((m) => m.id === method) : method;
+  const key = entry && entry.labelKey;
+  if (catalog && key && catalog[key]) return catalog[key];
+  return entry ? entry.id : String(method);
+}
+
+module.exports = { AUTH_METHODS, SOCIAL_METHODS, isSocialMethod, methodsForFlow, methodIdsForFlow, isMethodAvailable, methodLabel };

package/src/auth-session-store.js

@@ -0,0 +1,214 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { getConfigDir } = require('./config-dir');
+
+// `~/.config/shakers/auth-session.json` — the logged-in Talent's session (talents-ai-score, issue 122 / ADR-044).
+
+// Hub's `UserSubtypeEnum` (shared/domain/enum/user-subtype.enum.ts), copied VERBATIM — this repo never invents a value the wire does not send.
+const PLATFORM_TALENT_USER_TYPES = new Set(['WORKS_TALENT', 'WORKS_PARTNER']);
+const KNOWN_USER_TYPES = new Set(['HUB', 'WORKS_CLIENT', 'WORKS_TALENT', 'WORKS_PARTNER']);
+
+// Decodes (NEVER verifies — this module has no secret to verify with, and the claim only ever picks which COPY prints) a JWT's payload segment.
+function decodeJwtPayload(token) {
+  if (typeof token !== 'string' || !token) return null;
+  const parts = token.split('.');
+  if (parts.length !== 3) return null;
+  try {
+    const json = Buffer.from(parts[1], 'base64url').toString('utf8');
+    const parsed = JSON.parse(json);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+// The one place `hubAccessToken` -> `userType` happens.
+function userTypeFromHubToken(hubAccessToken) {
+  const payload = decodeJwtPayload(hubAccessToken);
+  const userType = payload && typeof payload.userType === 'string' ? payload.userType : null;
+  return userType && KNOWN_USER_TYPES.has(userType) ? userType : null;
+}
+
+function emailFromHubToken(hubAccessToken) {
+  const payload = decodeJwtPayload(hubAccessToken);
+  const email = payload && typeof payload.email === 'string' ? payload.email : null;
+  return email || null;
+}
+
+function firstNameFromSession(session) {
+  if (!session || typeof session !== 'object') return null;
+  const token = (typeof session.hubAccessToken === 'string' && session.hubAccessToken)
+    ? session.hubAccessToken
+    : (typeof session.accessToken === 'string' ? session.accessToken : null);
+  const payload = decodeJwtPayload(token);
+  if (!payload) return null;
+  const raw = [payload.name, payload.given_name, payload.firstName, payload.first_name]
+    .find((v) => typeof v === 'string' && v.trim());
+  if (!raw) return null;
+  const first = raw.trim().split(/\s+/)[0];
+  return first || null;
+}
+
+// `exp` (JWT seconds-since-epoch) -> ISO string, or null.
+function expiresAtFromToken(token) {
+  const payload = decodeJwtPayload(token);
+  const exp = payload && typeof payload.exp === 'number' && Number.isFinite(payload.exp) ? payload.exp : null;
+  if (exp === null) return null;
+  try {
+    return new Date(exp * 1000).toISOString();
+  } catch {
+    return null;
+  }
+}
+
+// The ONE predicate every gate reads (src/report-gating.js), so two call
+// sites can never disagree about which `userType` values count as a Talent.
+function isPlatformTalent(session) {
+  return !!(session && PLATFORM_TALENT_USER_TYPES.has(session.userType));
+}
+
+const SESSION_FILE_NAME = 'auth-session.json';
+
+// Bumped when the shape changes in a way an older/newer CLI cannot read.
+const SESSION_FILE_VERSION = 2;
+
+function configDir(env = process.env) {
+  return getConfigDir(env);
+}
+
+function authSessionPath(env = process.env) {
+  return path.join(configDir(env), SESSION_FILE_NAME);
+}
+
+// ATOMIC 0600 write.
+function saveAuthSession(session, env = process.env, { fs: fsImpl = fs } = {}) {
+  const explicitHubToken = typeof session.hubAccessToken === 'string' && session.hubAccessToken ? session.hubAccessToken : null;
+  const hubAccessToken = explicitHubToken || (typeof session.accessToken === 'string' && session.accessToken ? session.accessToken : null);
+
+  const cookie = typeof session.cookie === 'string' && session.cookie ? session.cookie : null;
+  let expiresAt;
+  let accessTokenExpiresAt;
+  if (cookie) {
+    expiresAt = (typeof session.cookieExpiresAt === 'string' && session.cookieExpiresAt)
+      ? session.cookieExpiresAt
+      : (typeof session.expiresAt === 'string' && session.expiresAt ? session.expiresAt : null);
+    accessTokenExpiresAt = (typeof session.accessTokenExpiresAt === 'string' && session.accessTokenExpiresAt)
+      ? session.accessTokenExpiresAt
+      : expiresAtFromToken(session.accessToken);
+  } else {
+    expiresAt = (typeof session.expiresAt === 'string' && session.expiresAt) ? session.expiresAt : expiresAtFromToken(session.accessToken);
+    accessTokenExpiresAt = expiresAt;
+  }
+
+  const payload = `${JSON.stringify(
+    {
+      accessToken: typeof session.accessToken === 'string' && session.accessToken ? session.accessToken : null,
+      expiresAt: expiresAt ?? null,
+      accessTokenExpiresAt: accessTokenExpiresAt ?? null,
+      cookie,
+      email: (typeof session.email === 'string' && session.email ? session.email : null)
+        || emailFromHubToken(hubAccessToken),
+      hubAccessToken,
+      // Decoded once from the SAME `hubAccessToken` this session carries (see the
+      // module docblock) — never a second round-trip or source of truth.
+      userType: userTypeFromHubToken(hubAccessToken),
+      version: SESSION_FILE_VERSION,
+    },
+    null,
+    2,
+  )}\n`;
+
+  const target = authSessionPath(env);
+  const dir = path.dirname(target);
+  fsImpl.mkdirSync(dir, { recursive: true, mode: 0o700 });
+
+  const tmp = path.join(dir, `.${SESSION_FILE_NAME}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`);
+  let fd = null;
+  try {
+    fd = fsImpl.openSync(tmp, 'wx', 0o600);
+    fsImpl.writeFileSync(fd, payload);
+    try { fsImpl.fsyncSync(fd); } catch { /* e.g. EINVAL on some filesystems */ }
+    fsImpl.closeSync(fd);
+    fd = null;
+    fsImpl.renameSync(tmp, target);
+  } catch (e) {
+    if (fd !== null) { try { fsImpl.closeSync(fd); } catch { /* already closed */ } }
+    // A stale temp would accumulate one bearer-token-holding file per failure.
+    try { fsImpl.unlinkSync(tmp); } catch { /* never existed */ }
+    throw e;
+  }
+  return target;
+}
+
+// Reads the file, or `null` for "no session": missing, unreadable, malformed JSON, unrecognized `version`, or missing the one field without which there is no session (`accessToken`).
+function loadAuthSession(env = process.env, { fs: fsImpl = fs } = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(fsImpl.readFileSync(authSessionPath(env), 'utf8'));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+  if (parsed.version !== SESSION_FILE_VERSION) return null;
+  // A usable session needs at least ONE credential: the durable cookie (email/
+  // better-auth) or a JWT (Google/legacy, or an email session whose JWT is cached).
+  const hasCookie = typeof parsed.cookie === 'string' && parsed.cookie;
+  const hasToken = typeof parsed.accessToken === 'string' && parsed.accessToken;
+  if (!hasCookie && !hasToken) return null;
+  const hubAccessToken = typeof parsed.hubAccessToken === 'string' && parsed.hubAccessToken ? parsed.hubAccessToken : null;
+  const email = (typeof parsed.email === 'string' && parsed.email ? parsed.email : null) || emailFromHubToken(hubAccessToken);
+  return {
+    accessToken: hasToken ? parsed.accessToken : null,
+    expiresAt: typeof parsed.expiresAt === 'string' ? parsed.expiresAt : null,
+    accessTokenExpiresAt: typeof parsed.accessTokenExpiresAt === 'string' ? parsed.accessTokenExpiresAt : null,
+    cookie: hasCookie ? parsed.cookie : null,
+    email,
+    hubAccessToken,
+    userType: typeof parsed.userType === 'string' && KNOWN_USER_TYPES.has(parsed.userType) ? parsed.userType : null,
+  };
+}
+
+// Removes the file. Idempotent and never throws — `logout` on no session is a
+// no-op, not a failure.
+function clearAuthSession(env = process.env, { fs: fsImpl = fs } = {}) {
+  try {
+    fsImpl.unlinkSync(authSessionPath(env));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// `none | active | expired`, the three states the caller needs to give the Talent a true message.
+function sessionStatus(session, now = Date.now()) {
+  // A credential is either the durable cookie (email) or a JWT (Google/legacy).
+  const hasCred = !!(session && ((typeof session.accessToken === 'string' && session.accessToken) || (typeof session.cookie === 'string' && session.cookie)));
+  if (!hasCred) return 'none';
+  const expiry = Date.parse(String(session.expiresAt || ''));
+  if (!Number.isFinite(expiry)) return 'expired';
+  return expiry > now ? 'active' : 'expired';
+}
+
+// The single predicate the rest of the CLI asks: is there a usable session right
+// now? Everything gating reads reduces to this.
+function isLoggedIn(env = process.env, now = Date.now(), deps = {}) {
+  return sessionStatus(loadAuthSession(env, deps), now) === 'active';
+}
+
+module.exports = {
+  SESSION_FILE_NAME,
+  SESSION_FILE_VERSION,
+  authSessionPath,
+  saveAuthSession,
+  loadAuthSession,
+  clearAuthSession,
+  sessionStatus,
+  isLoggedIn,
+  isPlatformTalent,
+  PLATFORM_TALENT_USER_TYPES,
+  decodeJwtPayload,
+  firstNameFromSession,
+};

package/src/authorship.js

@@ -0,0 +1,203 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+
+// Git AUTHORSHIP + provenance for the certify phase (skill-code-certification, ADR-017).
+
+const GIT_TIMEOUT_MS = 15000;
+const SHORT_SHA_LEN = 10;
+
+function runGit(root, args) {
+  try {
+    return execFileSync('git', ['-C', root, ...args], {
+      encoding: 'utf8',
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      maxBuffer: 64 * 1024 * 1024,
+    });
+  } catch {
+    return null;
+  }
+}
+
+// True only inside a real work tree. Everything else (no git, bare repo, not a
+// repo) is treated as "cannot attribute" upstream.
+function isGitRepo(root) {
+  return runGit(root, ['rev-parse', '--is-inside-work-tree']) !== null;
+}
+
+// Repo identity for the evidence record.
+function getRepository(root) {
+  const remote = runGit(root, ['config', '--get', 'remote.origin.url']);
+  if (remote && remote.trim()) return normalizeRemote(remote.trim());
+  const top = runGit(root, ['rev-parse', '--show-toplevel']);
+  if (top && top.trim()) return path.basename(top.trim());
+  return null;
+}
+
+function normalizeRemote(url) {
+  // `git@host:owner/repo.git` | `https://[token@]host/owner/repo.git` ->
+  // `host/owner/repo`. Any userinfo (a token/password) is dropped, never kept.
+  let s = url.replace(/\.git$/, '');
+  const scp = s.match(/^[^@]+@([^:]+):(.+)$/); // scp-like ssh
+  if (scp) return `${scp[1]}/${scp[2]}`;
+  try {
+    const u = new URL(s);
+    return `${u.host}${u.pathname}`.replace(/\/+$/, '');
+  } catch {
+    return s;
+  }
+}
+
+// `<root-commit>..<HEAD>` short shas over the current branch. `null` when the
+// history can't be read (e.g. a repo with no commits yet).
+function getCommitRange(root) {
+  const head = runGit(root, ['rev-parse', `--short=${SHORT_SHA_LEN}`, 'HEAD']);
+  if (!head || !head.trim()) return null;
+  const roots = runGit(root, ['rev-list', '--max-parents=0', 'HEAD']);
+  const firstFull = roots && roots.trim() ? roots.trim().split('\n').pop().trim() : null;
+  if (!firstFull) return head.trim();
+  const first = runGit(root, ['rev-parse', `--short=${SHORT_SHA_LEN}`, firstFull]);
+  const firstShort = first && first.trim() ? first.trim() : firstFull.slice(0, SHORT_SHA_LEN);
+  return `${firstShort}..${head.trim()}`;
+}
+
+// The path git sees for a file is repo-relative; the sampler's paths are relative to `root`, which may be a SUBDIR of the repo.
+function getRootPrefix(root) {
+  const prefix = runGit(root, ['rev-parse', '--show-prefix']);
+  return prefix && prefix.trim() ? prefix.trim().replace(/\/+$/, '') : '';
+}
+
+function buildPathIndex(root) {
+  const authorsByPath = new Map();
+  const timeByPath = new Map();
+  const log = runGit(root, [
+    'log',
+    '--no-merges',
+    '--pretty=format:\x01%ae\x1f%at',
+    '--name-only',
+  ]);
+  if (log === null) return { authorsByPath, timeByPath };
+
+  let currentEmail = null;
+  let currentTime = null;
+  for (const rawLine of log.split('\n')) {
+    if (rawLine.startsWith('\x01')) {
+      const [email, atRaw] = rawLine.slice(1).split('\x1f');
+      currentEmail = String(email || '').trim().toLowerCase();
+      const ts = Number.parseInt(atRaw, 10);
+      currentTime = Number.isFinite(ts) ? ts : null;
+      continue;
+    }
+    const file = rawLine.trim();
+    if (!file || currentEmail === null) continue;
+    let set = authorsByPath.get(file);
+    if (!set) {
+      set = new Set();
+      authorsByPath.set(file, set);
+    }
+    set.add(currentEmail);
+    if (currentTime !== null) {
+      const prev = timeByPath.get(file);
+      if (prev === undefined || currentTime > prev) {
+        timeByPath.set(file, currentTime);
+      }
+    }
+  }
+  return { authorsByPath, timeByPath };
+}
+
+// Full authorship context for `root`, collected ONCE per run.
+function collectAuthorship(root) {
+  if (!isGitRepo(root)) {
+    return {
+      available: false,
+      repository: null,
+      commitRange: null,
+      authorsForPath: () => [],
+      mostRecentCommitTime: () => null,
+    };
+  }
+
+  const prefix = getRootPrefix(root);
+  const { authorsByPath, timeByPath } = buildPathIndex(root);
+
+  return {
+    available: true,
+    repository: getRepository(root),
+    commitRange: getCommitRange(root),
+    authorsForPath(relPathFromRoot) {
+      if (typeof relPathFromRoot !== 'string' || !relPathFromRoot) return [];
+      const repoRel = prefix ? `${prefix}/${relPathFromRoot}` : relPathFromRoot;
+      const set = authorsByPath.get(repoRel);
+      return set ? [...set] : [];
+    },
+    // UNIX seconds of the most recent commit touching `relPathFromRoot`, or `null` when the path is untracked / history is unreadable.
+    mostRecentCommitTime(relPathFromRoot) {
+      if (typeof relPathFromRoot !== 'string' || !relPathFromRoot) return null;
+      const repoRel = prefix ? `${prefix}/${relPathFromRoot}` : relPathFromRoot;
+      const t = timeByPath.get(repoRel);
+      return t === undefined ? null : t;
+    },
+  };
+}
+
+// Builds an "is this author attributable?" predicate for one certifying identity.
+function buildAttributionPredicate(verifiedEmail, authorizedSet) {
+  const target = String(verifiedEmail || '').trim().toLowerCase();
+  const domainSuffix =
+    authorizedSet && authorizedSet.domain
+      ? `@${String(authorizedSet.domain).trim().toLowerCase()}`
+      : null;
+  const extra = new Set(
+    authorizedSet && Array.isArray(authorizedSet.extraEmails)
+      ? authorizedSet.extraEmails.map((e) => String(e).trim().toLowerCase())
+      : [],
+  );
+  return (author) => {
+    const a = String(author || '').toLowerCase();
+    if (target && a === target) return true;
+    if (domainSuffix && a.endsWith(domainSuffix)) return true;
+    if (extra.has(a)) return true;
+    return false;
+  };
+}
+
+// Applies the ADR-017 gate (with the ADR-023 widening for test identities) to ONE sampled Skill.
+function attributeSample(sample, verifiedEmail, authorship, authorizedSet = null) {
+  const isAttributable = buildAttributionPredicate(verifiedEmail, authorizedSet);
+  const files = Array.isArray(sample.files) ? sample.files : [];
+
+  const consideredEmails = new Set();
+  const attributableFiles = [];
+  const fileAttribution = [];
+
+  for (const file of files) {
+    const authors = authorship.authorsForPath(file.path);
+    for (const a of authors) consideredEmails.add(a);
+    const attributed = authors.some((a) => isAttributable(a));
+    if (attributed) attributableFiles.push(file);
+    fileAttribution.push({ path: file.path, authors, attributed });
+  }
+
+  const authorEmails = [...consideredEmails].map((email) => ({
+    email,
+    matched: isAttributable(email),
+  }));
+
+  return {
+    attributableFiles,
+    authorEmails,
+    fileAttribution,
+    certifiable: attributableFiles.length > 0,
+  };
+}
+
+module.exports = {
+  collectAuthorship,
+  attributeSample,
+  // exported for unit tests
+  normalizeRemote,
+  isGitRepo,
+};

package/src/automations-detector.js

@@ -0,0 +1,170 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { getHomeDir } = require('./env-paths');
+
+// Deterministic (no-LLM) automations detector (talents-ai-score, issue 017 / ADR-013-014).
+
+const AI_CLI_NAMES = ['claude', 'aider', 'gemini', 'codex'];
+const AI_CLI_RE = new RegExp(`\\b(${AI_CLI_NAMES.join('|')})\\b`, 'i');
+
+function mentionsAiCli(text) {
+  return typeof text === 'string' && AI_CLI_RE.test(text);
+}
+
+function looksLikeJsonPiping(text) {
+  if (typeof text !== 'string') return false;
+  return mentionsAiCli(text) && /\|/.test(text) && /(--json\b|(^|\s)-p\b)/.test(text);
+}
+
+const MAX_SHELL_SCRIPT_BYTES = 200_000; // safety cap, never a product requirement
+const MAX_SHELL_SCRIPTS = 50;
+
+/* ---------- 1 & 2: scripts (npm + shell) ---------- */
+
+function scanNpmScripts(root) {
+  let raw;
+  try {
+    raw = fs.readFileSync(path.join(root, 'package.json'), 'utf8');
+  } catch {
+    return { aiMentions: 0, jsonPiping: 0 };
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(raw);
+  } catch {
+    return { aiMentions: 0, jsonPiping: 0 };
+  }
+  const scripts = pkg && typeof pkg.scripts === 'object' ? pkg.scripts : {};
+  let aiMentions = 0;
+  let jsonPiping = 0;
+  for (const command of Object.values(scripts)) {
+    if (mentionsAiCli(command)) aiMentions += 1;
+    if (looksLikeJsonPiping(command)) jsonPiping += 1;
+  }
+  return { aiMentions, jsonPiping };
+}
+
+function scanShellScripts(root) {
+  const dir = path.join(root, 'scripts');
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return { aiMentions: 0, jsonPiping: 0 };
+  }
+  let aiMentions = 0;
+  let jsonPiping = 0;
+  let scanned = 0;
+  for (const entry of entries) {
+    if (scanned >= MAX_SHELL_SCRIPTS) break;
+    if (!entry.isFile() || !entry.name.endsWith('.sh')) continue;
+    scanned += 1;
+    const file = path.join(dir, entry.name);
+    let content;
+    try {
+      const st = fs.statSync(file);
+      if (st.size > MAX_SHELL_SCRIPT_BYTES) continue;
+      content = fs.readFileSync(file, 'utf8');
+    } catch {
+      continue;
+    }
+    if (mentionsAiCli(content)) aiMentions += 1;
+    if (looksLikeJsonPiping(content)) jsonPiping += 1;
+  }
+  return { aiMentions, jsonPiping };
+}
+
+/* ---------- 3: schedulers (inspected-where-possible) ---------- */
+
+// cron: the CURRENT user's own crontab only (`crontab -l`), never the system-wide crontab (would need elevated permissions, not attempted).
+function probeCron() {
+  let out;
+  try {
+    out = execFileSync('crontab', ['-l'], { timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'] }).toString('utf8');
+  } catch {
+    return { inspected: false, matches: 0 }; // no crontab / binary missing / not permitted: not invented
+  }
+  const lines = out.split('\n').filter((l) => l.trim() && !l.trim().startsWith('#'));
+  return { inspected: true, matches: lines.filter(mentionsAiCli).length };
+}
+
+// launchd (macOS): the user's own ~/Library/LaunchAgents only (never LaunchDaemons, system-wide, needs root).
+function probeLaunchd(home) {
+  const dir = path.join(home, 'Library', 'LaunchAgents');
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return { inspected: false, matches: 0 };
+  }
+  let matches = 0;
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.plist')) continue;
+    try {
+      const content = fs.readFileSync(path.join(dir, entry.name), 'utf8');
+      if (mentionsAiCli(content)) matches += 1;
+    } catch {
+      /* unreadable: skip, never invented */
+    }
+  }
+  return { inspected: true, matches };
+}
+
+// pm2: the user's own process dump (~/.pm2/dump.pm2, JSON). Counts AI-CLI
+// mentions across the whole dump — coarse but derived, never returns it.
+function probePm2(home) {
+  let raw;
+  try {
+    raw = fs.readFileSync(path.join(home, '.pm2', 'dump.pm2'), 'utf8');
+  } catch {
+    return { inspected: false, matches: 0 };
+  }
+  const matches = (raw.match(new RegExp(AI_CLI_RE.source, 'gi')) || []).length;
+  return { inspected: true, matches };
+}
+
+// systemd (Linux, user-level only): ~/.config/systemd/user/*.service.
+// Never the system-wide /etc/systemd (needs root, not attempted).
+function probeSystemdUser(home) {
+  const dir = path.join(home, '.config', 'systemd', 'user');
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return { inspected: false, matches: 0 };
+  }
+  let matches = 0;
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.service')) continue;
+    try {
+      const content = fs.readFileSync(path.join(dir, entry.name), 'utf8');
+      if (mentionsAiCli(content)) matches += 1;
+    } catch {
+      /* unreadable: skip, never invented */
+    }
+  }
+  return { inspected: true, matches };
+}
+
+// Deterministic (no-LLM) automations detection.
+function detectAutomations(root) {
+  const home = getHomeDir();
+  const npm = scanNpmScripts(root);
+  const shell = scanShellScripts(root);
+
+  return {
+    scripts: { npm: npm.aiMentions, shell: shell.aiMentions },
+    jsonPiping: npm.jsonPiping + shell.jsonPiping,
+    schedulers: {
+      cron: probeCron(),
+      launchd: probeLaunchd(home),
+      pm2: probePm2(home),
+      systemd: probeSystemdUser(home),
+    },
+  };
+}
+
+module.exports = { detectAutomations, mentionsAiCli, looksLikeJsonPiping };