shakers-cli 0.0.0-stage → 0.14.0

package/src/consent-flow.js

@@ -0,0 +1,115 @@
+'use strict';
+
+const { isValidEmail, recordConsent } = require('./share');
+const {
+  getEmailVerificationRequestUrl,
+  getEmailVerificationVerifyUrl,
+} = require('./config');
+const { runEmailVerification } = require('./email-verification');
+const { renderLegalNotice } = require('./legal-notice');
+
+// Consent prompt (talents-ai-score, ADR-011 — revises issue 006 / ADR-007's disclosure wall; ADR-051 revises ADR-011's OWN ordering in turn, see below).
+
+const MAX_ATTEMPTS = 5;
+
+const YES_RE = /^(y|yes|s|si|sí)$/i;
+const NO_RE = /^(n|no)$/i;
+
+async function askYesNo(ask, question, catalog, { defaultNo = false } = {}) {
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+    const raw = String(await ask(question)).trim();
+    if (defaultNo && raw === '') return false;
+    if (YES_RE.test(raw)) return true;
+    if (NO_RE.test(raw)) return false;
+    process.stdout.write(`  ${catalog.consent.invalidAnswer}\n`);
+  }
+  return null;
+}
+
+async function askEmail(ask, catalog, question = catalog.consent.emailPrompt) {
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+    const raw = String(await ask(question)).trim();
+    if (isValidEmail(raw)) return raw;
+    process.stdout.write(`  ${catalog.consent.invalidEmail}\n`);
+  }
+  return null;
+}
+
+async function defaultVerifyEmail({ email, ask, catalog, env = process.env }) {
+  return runEmailVerification({
+    email,
+    ask,
+    catalog,
+    requestUrl: getEmailVerificationRequestUrl(env),
+    verifyUrl: getEmailVerificationVerifyUrl(env),
+  });
+}
+
+// Runs the short consent-to-persist prompt + (if accepted) email collection + (skill-code-certification / ADR-006) EMAIL-OWNERSHIP VERIFICATION.
+async function runConsentPrompt({
+  ask,
+  catalog,
+  env = process.env,
+  verifyEmail = defaultVerifyEmail,
+  loggedIn = false,
+  sessionEmail = null,
+  drainBeforeAsk = false,
+  profile = 'talent',
+}) {
+  const c = catalog.consent;
+  // Presentation only (talents-ai-score): framed by src/legal-notice.js on a
+  // real TTY, byte-identical (no heading, no rule) otherwise.
+  process.stdout.write(`\n  ${renderLegalNotice(c.persistIntro, catalog)}\n`);
+
+  if (drainBeforeAsk && typeof ask.drain === 'function') ask.drain();
+
+  if (loggedIn && sessionEmail && isValidEmail(sessionEmail)) {
+    process.stdout.write(`  ${c.savedUnderEmail(sessionEmail)}\n`);
+  }
+
+  // defaultNo: a blank Enter means "do not save" (legal requirement).
+  const accepted = await askYesNo(ask, c.persistQuestion, catalog, { defaultNo: true });
+  if (accepted === null) {
+    process.stdout.write(`  ${c.notObtained}\n\n`);
+    return null;
+  }
+
+  if (!accepted) {
+    recordConsent('denied');
+    process.stdout.write(`  ${c.deniedSaved}\n\n`);
+    return 'denied';
+  }
+
+  if (loggedIn) {
+    if (sessionEmail && isValidEmail(sessionEmail)) {
+      // Identity already proven by the login session — no email prompt, no OTP.
+      recordConsent('granted', sessionEmail, { verified: true });
+      process.stdout.write(`  ${c.grantedSaved(sessionEmail)}\n\n`);
+      return 'granted';
+    }
+    // Logged in, but this session has no cached email — only happens against an older certs deployment that omitted `email` from the login response (see auth-session-store.js).
+    process.stdout.write(`  ${c.noSessionEmail}\n\n`);
+    return null;
+  }
+
+  const email = await askEmail(ask, catalog, profile === 'external' ? c.emailPromptExternal : undefined);
+  if (!email) {
+    process.stdout.write(`  ${c.notObtained}\n\n`);
+    return null;
+  }
+
+  process.stdout.write(`  ${c.savedUnderEmail(email)}\n`);
+
+  // Prove email ownership BEFORE persisting (ADR-006) — every profile, external included.
+  const verification = await verifyEmail({ email, ask, catalog, env });
+  if (verification && verification.verified) {
+    recordConsent('granted', email, { verified: true });
+    process.stdout.write(`  ${c.grantedSaved(email)}\n\n`);
+    return 'granted';
+  }
+
+  process.stdout.write(`  ${c.notObtained}\n\n`);
+  return null;
+}
+
+module.exports = { runConsentPrompt, defaultVerifyEmail };

package/src/consent-skip.js

@@ -0,0 +1,27 @@
+'use strict';
+
+// Explains WHY the consent-to-persist prompt is skipped (or might not complete) this run, instead of doing so silently (talents-ai-score, DX).
+function computeConsentSkip({ decision, emailVerified, stdinIsTTY, consentFilePath, catalog } = {}) {
+  const c = catalog && catalog.consent;
+
+  // Only a TERMINAL decision is skippable: an explicit DECLINE, or a GRANT whose email ownership was actually verified.
+  const terminal =
+    decision === 'denied' ||
+    (decision === 'granted' && emailVerified !== false);
+
+  if (terminal) {
+    const message = c && typeof c.skipAlreadyDecided === 'function'
+      ? c.skipAlreadyDecided(decision, consentFilePath)
+      : null;
+    return { skip: true, message };
+  }
+
+  if (!stdinIsTTY) {
+    const message = c ? c.nonInteractiveWarning || null : null;
+    return { skip: false, message };
+  }
+
+  return { skip: false, message: null };
+}
+
+module.exports = { computeConsentSkip };

package/src/cv-file.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { expandHome } = require('./env-paths');
+
+// The talent names a file on their own machine. Read it only when the resolved file (symlinks
+// followed) really is a CV: an allowed extension, a regular file, under the cap, and starting
+// with that format's signature. Anything else is refused before it is loaded or sent.
+const CV_MAX_BYTES = 10 * 1024 * 1024;
+
+const CV_FORMATS = {
+  '.pdf': { contentType: 'application/pdf', signature: Buffer.from('%PDF-') },
+  '.doc': { contentType: 'application/msword', signature: Buffer.from([0xd0, 0xcf, 0x11, 0xe0]) },
+  '.docx': {
+    contentType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    signature: Buffer.from([0x50, 0x4b, 0x03, 0x04]),
+  },
+};
+
+function readLocalCv(input, { extensions, badFormat }) {
+  if (typeof input !== 'string' || !input.trim()) return { ok: false, reason: 'cv-not-found' };
+  const given = expandHome(input.trim());
+  const ext = path.extname(given).toLowerCase();
+  if (!extensions.includes(ext)) return { ok: false, reason: badFormat };
+  const format = CV_FORMATS[ext];
+  let real;
+  try {
+    real = fs.realpathSync(given);
+  } catch {
+    return { ok: false, reason: 'cv-not-found' };
+  }
+  if (path.extname(real).toLowerCase() !== ext) return { ok: false, reason: badFormat };
+
+  let fd;
+  try {
+    fd = fs.openSync(real, 'r');
+  } catch {
+    return { ok: false, reason: 'cv-not-found' };
+  }
+  try {
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile()) return { ok: false, reason: 'cv-not-found' };
+    if (stat.size > CV_MAX_BYTES) return { ok: false, reason: 'cv-too-large' };
+    const data = Buffer.alloc(stat.size);
+    let read = 0;
+    while (read < stat.size) {
+      const n = fs.readSync(fd, data, read, stat.size - read, read);
+      if (n === 0) break;
+      read += n;
+    }
+    const content = data.subarray(0, read);
+    if (!content.subarray(0, format.signature.length).equals(format.signature)) return { ok: false, reason: badFormat };
+    return { ok: true, file: { filename: path.basename(given), contentType: format.contentType, data: content } };
+  } catch {
+    return { ok: false, reason: 'cv-not-found' };
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+module.exports = { readLocalCv, CV_MAX_BYTES };

package/src/cv-text.js

@@ -0,0 +1,92 @@
+'use strict';
+
+// Plain text out of the talent's CV (PDF, DOC, DOCX), so the AI can pre-fill from
+// what the CV says. Zero-dependency on purpose (install.sh copies the CLI without
+// npm install): on macOS PDFs go through the system PDFKit (JXA) and Word files
+// through textutil; elsewhere PDFs through poppler's pdftotext when installed.
+// With none, the caller asks the talent to attach the CV to the chat instead.
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { expandHome } = require('./env-paths');
+
+const MAX_BYTES = 10 * 1024 * 1024;
+const MAX_CHARS = 20000;
+
+const JXA_PDF_TEXT = 'function run(argv){ObjC.import("PDFKit");'
+  + 'const d=$.PDFDocument.alloc.initWithURL($.NSURL.fileURLWithPath(argv[0]));'
+  + 'return d.isNil()?"":d.string.js}';
+
+function run(cmd, args, exec) {
+  return String(exec(cmd, args, { encoding: 'utf8', timeout: 20000, maxBuffer: 32 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] }) || '');
+}
+
+function extractors(platform, file) {
+  const list = [];
+  if (/\.docx?$/i.test(file)) {
+    if (platform === 'darwin') list.push({ name: 'textutil', cmd: 'textutil', args: (f) => ['-convert', 'txt', '-stdout', f] });
+    return list;
+  }
+  if (platform === 'darwin') list.push({ name: 'pdfkit', cmd: 'osascript', args: (f) => ['-l', 'JavaScript', '-e', JXA_PDF_TEXT, f] });
+  list.push({ name: 'pdftotext', cmd: 'pdftotext', args: (f) => ['-layout', '-q', f, '-'] });
+  return list;
+}
+
+const fold = (text) => String(text || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+
+// Whether the CV text names the talent: every name token of 3+ letters present.
+// Lets the AI drop a stranger's CV without showing its contents.
+function mentionsName(text, talentName) {
+  const tokens = fold(talentName).split(/[^a-z0-9]+/).filter((t) => t.length >= 3);
+  if (tokens.length === 0) return null;
+  const body = fold(text);
+  return tokens.every((t) => body.includes(t));
+}
+
+const uniq = (list) => [...new Set(list)];
+
+// Contact links a CV header usually carries, so the AI can fill them directly.
+function extractLinks(text) {
+  const t = String(text || '');
+  return {
+    linkedin: uniq((t.match(/(?:https?:\/\/)?(?:[a-z]{2,3}\.)?linkedin\.com\/in\/[A-Za-z0-9_%-]+/gi) || []).map((u) => `https://www.${u.replace(/^https?:\/\//i, '').replace(/^(?:[a-z]{2,3}\.)?linkedin/i, 'linkedin')}`)),
+    github: uniq((t.match(/(?:https?:\/\/)?github\.com\/[A-Za-z0-9-]+/gi) || []).map((u) => `https://${u.replace(/^https?:\/\//i, '')}`)),
+    emails: uniq(t.match(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g) || []),
+    phones: uniq((t.match(/\+\d{1,3}[\s.-]?\d[\d\s.-]{6,14}\d/g) || []).map((p) => p.replace(/[\s.-]+/g, ' ').trim())),
+  };
+}
+
+function readCvText(input, { platform = process.platform, exec = execFileSync, env = process.env, talentName = null } = {}) {
+  const file = expandHome(input, env);
+  if (typeof file !== 'string' || !path.isAbsolute(file) || !/\.(pdf|docx?)$/i.test(file)) return { ok: false, reason: 'not-a-cv-path' };
+  let stat;
+  try {
+    stat = fs.statSync(file);
+  } catch {
+    return { ok: false, reason: 'not-found' };
+  }
+  if (!stat.isFile()) return { ok: false, reason: 'not-found' };
+  if (stat.size > MAX_BYTES) return { ok: false, reason: 'too-large' };
+
+  for (const extractor of extractors(platform, file)) {
+    let text;
+    try {
+      text = run(extractor.cmd, extractor.args(file), exec).trim();
+    } catch {
+      continue;
+    }
+    if (!text) continue;
+    return {
+      ok: true,
+      extractor: extractor.name,
+      mentionsTalent: mentionsName(text, talentName),
+      links: extractLinks(text),
+      truncated: text.length > MAX_CHARS,
+      text: text.slice(0, MAX_CHARS),
+    };
+  }
+  return { ok: false, reason: 'no-text-extracted' };
+}
+
+module.exports = { readCvText, extractLinks, mentionsName, MAX_CHARS };

package/src/decisions-extract.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const { eachHumanText } = require('./transcript-turns');
+const { scrubSecrets } = require('./agent-synthesis');
+
+const MAX_EXCERPTS = 20;
+const MAX_EXCERPT_LEN = 200;
+
+const DECISION_RE =
+  /\b(decid\w*|decision|decisión|vamos a|vamos con|voy con|let'?s|we'?ll|we will|prefer|prefiero|option|opción|elij\w*|choose|chose|choice|pick|go with|descarta\w*|opta|trade-?off|instead of|en vez de|en lugar de|rather than|because|porque|reason|razón)\b/i;
+
+function makeDecisionsAccumulator() {
+  let decisionExchangeCount = 0;
+  const excerpts = [];
+  const seen = new Set();
+  return {
+    add(text) {
+      if (!DECISION_RE.test(text)) return;
+      decisionExchangeCount += 1;
+      if (excerpts.length >= MAX_EXCERPTS) return;
+      const scrubbed = scrubSecrets(text)
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, MAX_EXCERPT_LEN);
+      if (scrubbed && !seen.has(scrubbed)) {
+        seen.add(scrubbed);
+        excerpts.push(scrubbed);
+      }
+    },
+    result() {
+      if (decisionExchangeCount === 0) return null;
+      return { decisionExchangeCount, redactedDecisionExcerpts: excerpts };
+    },
+  };
+}
+
+function collectDecisions(env = process.env, selectedCwds = null) {
+  const acc = makeDecisionsAccumulator();
+  for (const text of eachHumanText(env, { selectedCwds })) acc.add(text);
+  return acc.result();
+}
+
+module.exports = { collectDecisions, makeDecisionsAccumulator };

package/src/detect-repos.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+const {
+  toolSources,
+  listSessionFiles,
+  readSessionObjects,
+  resolveFileCwd,
+} = require('./session-scan');
+const { normalizeRemote } = require('./authorship');
+
+const GIT_TIMEOUT_MS = 15000;
+
+function git(cwd, args) {
+  try {
+    const out = execFileSync('git', ['-C', cwd, ...args], {
+      encoding: 'utf8',
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      maxBuffer: 4 * 1024 * 1024,
+    });
+    return out ? out.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+function repoIdentityForCwd(cwd, gitRunner = git) {
+  const toplevel = gitRunner(cwd, ['rev-parse', '--show-toplevel']) || null;
+  const remoteRaw = gitRunner(cwd, ['config', '--get', 'remote.origin.url']);
+  const remote = remoteRaw && remoteRaw.trim() ? normalizeRemote(remoteRaw.trim()) : null;
+  return { toplevel, remote };
+}
+
+function sessionCwdCounts(env = process.env) {
+  const counts = new Map();
+  let unassigned = 0;
+  for (const source of toolSources(env)) {
+    for (const file of listSessionFiles(source.dir)) {
+      const cwd = resolveFileCwd(readSessionObjects(file));
+      if (cwd === null) {
+        unassigned += 1;
+        continue;
+      }
+      counts.set(cwd, (counts.get(cwd) || 0) + 1);
+    }
+  }
+  return { counts, unassigned };
+}
+
+function labelFor(remote, groupKey) {
+  if (remote) return remote;
+  return path.basename(groupKey) || groupKey;
+}
+
+function detectRepos(env = process.env, { gitRunner = git } = {}) {
+  const { counts, unassigned } = sessionCwdCounts(env);
+
+  const byGroup = new Map();
+  for (const [cwd, sessionCount] of counts) {
+    const { toplevel, remote } = repoIdentityForCwd(cwd, gitRunner);
+    const groupKey = toplevel || cwd;
+    let group = byGroup.get(groupKey);
+    if (!group) {
+      group = {
+        toplevel: toplevel || null,
+        remote: remote || null,
+        cwds: new Set(),
+        sessionCount: 0,
+        resolved: !!toplevel,
+      };
+      byGroup.set(groupKey, group);
+    }
+    group.cwds.add(cwd);
+    group.sessionCount += sessionCount;
+    if (!group.remote && remote) group.remote = remote;
+  }
+
+  const repos = [...byGroup.entries()]
+    .map(([groupKey, g]) => ({
+      id: g.remote || g.toplevel || groupKey,
+      toplevel: g.toplevel,
+      remote: g.remote,
+      label: labelFor(g.remote, groupKey),
+      sessionCount: g.sessionCount,
+      cwds: [...g.cwds].sort(),
+      resolved: g.resolved,
+    }))
+    .sort(
+      (a, b) => b.sessionCount - a.sessionCount || a.label.localeCompare(b.label),
+    );
+
+  return { repos, unassignedSessionCount: unassigned };
+}
+
+function normalizeFlagToken(token) {
+  return String(token || '').trim().toLowerCase().replace(/\/+$/, '');
+}
+
+function repoMatchesToken(repo, token) {
+  const t = normalizeFlagToken(token);
+  if (!t) return false;
+  return [repo.id, repo.remote, repo.toplevel, repo.label, path.basename(repo.toplevel || repo.id)]
+    .filter((x) => typeof x === 'string' && x)
+    .some((x) => normalizeFlagToken(x) === t || normalizeFlagToken(x).endsWith(`/${t}`));
+}
+
+function matchReposByFlag(repos, tokens) {
+  const indices = new Set();
+  const unmatched = [];
+  for (const token of tokens || []) {
+    const idx = repos.findIndex((r) => repoMatchesToken(r, token));
+    if (idx === -1) unmatched.push(token);
+    else indices.add(idx);
+  }
+  return { indices: [...indices].sort((a, b) => a - b), unmatched };
+}
+
+function scopeFromSelection(repos, indices) {
+  const selectedCwds = new Set();
+  const selectedToplevels = [];
+  for (const i of indices) {
+    const repo = repos[i];
+    if (!repo) continue;
+    for (const c of repo.cwds) selectedCwds.add(c);
+    selectedToplevels.push(repo.toplevel || repo.id);
+  }
+  return { selectedCwds, selectedToplevels };
+}
+
+function indexOfCurrentRepo(repos, cwdToplevel) {
+  if (!cwdToplevel) return -1;
+  return repos.findIndex((r) => r.toplevel === cwdToplevel);
+}
+
+module.exports = {
+  detectRepos,
+  repoIdentityForCwd,
+  sessionCwdCounts,
+  matchReposByFlag,
+  repoMatchesToken,
+  scopeFromSelection,
+  indexOfCurrentRepo,
+};

package/src/detected-tools.js

@@ -0,0 +1,15 @@
+'use strict';
+
+// Single source of truth for turning a tools array ({id, name, detected}) into what the report shows.
+
+function detectedTools(tools) {
+  return Array.isArray(tools) ? tools.filter((t) => t && t.detected === true) : [];
+}
+
+function detectedToolNames(tools) {
+  return detectedTools(tools)
+    .map((t) => (t && (t.name || t.id)) || null)
+    .filter(Boolean);
+}
+
+module.exports = { detectedTools, detectedToolNames };

package/src/detection-evidence.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const { collectAuthorship, attributeSample } = require('./authorship');
+const { detectTechnologyManifests } = require('./tech-detector');
+const { agentSourceFilesByName } = require('./agent-org-chart');
+const { classifyVendored, collectProvenance } = require('./detection-noise');
+
+// Per-CANDIDATE authorship + depth (hybrid evaluation, Slice 3c).
+
+const SKILL_DEPTH_SATURATION = 3;
+const AGENT_DEPTH_SATURATION = 8;
+const DEPTH_FLOOR = 0.3;
+
+function round2(n) {
+  return Math.round(n * 100) / 100;
+}
+
+// Maps a raw count to (0,1]: DEPTH_FLOOR..1, so a detected-but-shallow candidate
+// is ordered DOWN without being excluded. `null` when there is no signal.
+function normalizedDepth(signal, saturation) {
+  if (typeof signal !== 'number' || !Number.isFinite(signal) || signal <= 0) {
+    return null;
+  }
+  const ratio = Math.min(1, signal / saturation);
+  return round2(DEPTH_FLOOR + (1 - DEPTH_FLOOR) * ratio);
+}
+
+function recencyDaysForPaths(relPaths, authorship, nowSeconds) {
+  if (!Array.isArray(relPaths) || relPaths.length === 0) return null;
+  let mostRecent = null;
+  for (const p of relPaths) {
+    const t = authorship.mostRecentCommitTime(p);
+    if (typeof t === 'number' && Number.isFinite(t)) {
+      mostRecent = mostRecent === null ? t : Math.max(mostRecent, t);
+    }
+  }
+  if (mostRecent === null) return null;
+  return Math.max(0, Math.floor((nowSeconds - mostRecent) / 86400));
+}
+
+// Attributes a candidate's evidence files against the talent's own email via the ADR-017 gate.
+function attributionCounts(relPaths, verifiedEmail, authorship) {
+  if (!Array.isArray(relPaths) || relPaths.length === 0) {
+    return { authoredFileCount: 0, totalFileCount: 0, authorshipKnown: false };
+  }
+  const result = attributeSample(
+    { files: relPaths.map((p) => ({ path: p })) },
+    verifiedEmail,
+    authorship,
+  );
+  const totalFileCount = result.fileAttribution.filter(
+    (f) => f.authors.length > 0,
+  ).length;
+  return {
+    authoredFileCount: result.attributableFiles.length,
+    totalFileCount,
+    authorshipKnown: authorship.available && totalFileCount > 0,
+  };
+}
+
+// Builds `report.detectionEvidence` = `{ skills, agents, provenance } | null`.
+function collectDetectionEvidence(root, verifiedEmail, report) {
+  const scanRoot = root || process.cwd();
+  const authorship = collectAuthorship(scanRoot);
+  const nowSeconds = Math.floor(Date.now() / 1000);
+
+  const skills = detectTechnologyManifests(scanRoot).map(
+    ({ tech, manifestPaths }) => ({
+      tech,
+      ...attributionCounts(manifestPaths, verifiedEmail, authorship),
+      depth: normalizedDepth(manifestPaths.length, SKILL_DEPTH_SATURATION),
+      vendored: classifyVendored(manifestPaths),
+      recencyDays: recencyDaysForPaths(manifestPaths, authorship, nowSeconds),
+    }),
+  );
+
+  const sourceByName = agentSourceFilesByName(scanRoot);
+  const reportAgents =
+    report && Array.isArray(report.agents) ? report.agents : [];
+  const agents = reportAgents.map((agent) => {
+    const rel = sourceByName.get(agent.name) || null;
+    const tools = Array.isArray(agent.tools) ? agent.tools : [];
+    const evidencePaths = rel ? [rel] : [];
+    return {
+      name: agent.name,
+      tools,
+      model: agent.model || null,
+      ...attributionCounts(evidencePaths, verifiedEmail, authorship),
+      depth: normalizedDepth(tools.length, AGENT_DEPTH_SATURATION),
+      vendored: classifyVendored(evidencePaths),
+      recencyDays: recencyDaysForPaths(evidencePaths, authorship, nowSeconds),
+    };
+  });
+
+  if (skills.length === 0 && agents.length === 0) return null;
+  return { skills, agents, provenance: collectProvenance(scanRoot) };
+}
+
+module.exports = {
+  collectDetectionEvidence,
+  normalizedDepth,
+  SKILL_DEPTH_SATURATION,
+  AGENT_DEPTH_SATURATION,
+  DEPTH_FLOOR,
+};