failproofai 1.0.10 → 1.0.11-beta.1

package/src/audit/index.ts

@@ -11,7 +11,7 @@ import { batchAll } from "../../lib/concurrency";
 import { BUILTIN_POLICIES } from "../hooks/builtin-policies";
 import { readMergedHooksConfig } from "../hooks/hooks-config";
 import { readInstalledPacks } from "../hooks/pack-manifest";
-import { normalizePolicyName } from "../hooks/policy-registry";
+import { getAllPolicies, normalizePolicyName } from "../hooks/policy-registry";
 import { INTEGRATION_TYPES, type IntegrationType } from "../hooks/types";
 import { ADAPTERS } from "./cli-adapters";
 import { AUDIT_DETECTORS } from "./detectors";
@@ -22,6 +22,7 @@ import {
   AUDIT_EXAMPLE_MAX_CHARS,
   AUDIT_MAX_EXAMPLES_PER_NAME,
   type AuditCount,
+  type AuditProgress,
   type AuditResult,
   type DetectorSessionState,
   type NormalizedToolEvent,
@@ -443,6 +444,32 @@ async function runAuditInner(opts: RunAuditOptions, startedAt: number): Promise<
     allTranscripts.push(...list);
   }
 
+  // Progress is reported through this and nothing else, so a callback that
+  // throws can never reach the scan below — where a throw inside a task would
+  // count as a scan error and change the result.
+  const report = (progress: AuditProgress): void => {
+    try {
+      opts.onProgress?.(progress);
+    } catch {
+      // A progress display must never change what an audit finds.
+    }
+  };
+  if (opts.onProgress) {
+    const perAgent = new Map<IntegrationType, number>();
+    for (const meta of allTranscripts) perAgent.set(meta.cli, (perAgent.get(meta.cli) ?? 0) + 1);
+    report({
+      kind: "discovered",
+      agents: clis.map((cli) => ({ cli, transcripts: perAgent.get(cli) ?? 0 })),
+      // The builtins `initReplay` registered that can fire on a tool event. The
+      // require-*-before-stop policies match only Stop, which a replay never
+      // sends, so counting them would claim checks that never run.
+      policies: getAllPolicies().filter((p) => {
+        const events = p.match.events;
+        return !events || events.length === 0 || events.includes("PreToolUse") || events.includes("PostToolUse");
+      }).length,
+    });
+  }
+
   // 2. Scan each transcript (cache-aware), 8 in parallel.
   let skipped = 0;
   let errors = 0;
@@ -503,7 +530,23 @@ async function runAuditInner(opts: RunAuditOptions, startedAt: number): Promise<
     }
   });
 
-  const settled = await batchAll(tasks, TRANSCRIPT_CONCURRENCY);
+  // With a listener, each task reports when it finishes, however it finishes:
+  // a cache hit, a scan, a failed scan, or a task that threw and is counted as
+  // skipped below. Every transcript counts toward its agent's total, so a bar
+  // can always reach the end. Without one, the tasks run exactly as they are.
+  const run = opts.onProgress
+    ? tasks.map((task, i) => async (): Promise<TranscriptAuditResult> => {
+        let hitsByName: Record<string, number> = {};
+        try {
+          const done = await task();
+          hitsByName = done.hitsByName;
+          return done;
+        } finally {
+          report({ kind: "transcript", cli: allTranscripts[i].cli, hitsByName });
+        }
+      })
+    : tasks;
+  const settled = await batchAll(run, TRANSCRIPT_CONCURRENCY);
   const perTranscript: TranscriptAuditResult[] = [];
   for (const s of settled) {
     if (s.status === "fulfilled") perTranscript.push(s.value);

package/src/audit/schedule-cli.ts

@@ -31,20 +31,7 @@ import { readAuditSchedule } from "./audit-schedule";
 import { readDashboardCacheMeta } from "./dashboard-cache";
 import { readMachineIdentity } from "./machine-store";
 import { ensureSignedIn, invalidEmail, LoginError } from "./cli-login";
-import {
-  ANSI_BOLD,
-  ANSI_DIM,
-  ANSI_RESET,
-  brandAnsi,
-  colorsEnabled,
-  optsFor,
-  outro,
-  printBlock,
-  rows as kitRows,
-  stack,
-  step,
-  title,
-} from "../hooks/tui";
+import { INDENT, optsFor, paint, printBlock, screenKit, stack, type TTYOut } from "../hooks/tui";
 
 /** Mirrors `fp-config`'s own bounds so the error can name them before writing. */
 const MIN_DAYS = 1;
@@ -53,19 +40,17 @@ const MAX_DAYS = 90;
 export class ScheduleCliError extends Error {}
 
 /**
- * Colour and the spine answer to ONE gate, checked at call time.
- *
- * They used to disagree: these helpers emitted ANSI unconditionally while the
- * frame asked `colorsEnabled`, so a piped `--status` came out as escape codes
- * with no structure — the worst of both. `colorsEnabled` is false off a TTY and
- * under `NO_COLOR`, which is exactly when a readout should be plain text.
+ * The 2026-10 kit for one stream, read at call time: colour only on a terminal
+ * and never under NO_COLOR, so a piped `--status` is plain text. The daemon
+ * warning goes to stderr, which can be a terminal when stdout is not, so it is
+ * asked about separately.
  */
-const styled = () => colorsEnabled(process.stdout);
-const wrap = (open: string, s: string) => (styled() ? `${open}${s}${ANSI_RESET}` : s);
-const pink = (s: string) => wrap(brandAnsi("pink"), s);
-const green = (s: string) => wrap(brandAnsi("guide"), s);
-const dim = (s: string) => wrap(ANSI_DIM, s);
-const bold = (s: string) => wrap(ANSI_BOLD, s);
+const kitFor = (stream: TTYOut = process.stdout) => screenKit(optsFor(stream));
+
+/** `every 7 days`, `every day`. */
+function everyPhrase(days: number): string {
+  return days === 1 ? "every day" : `every ${days} days`;
+}
 
 /**
  * Turn scheduled audits on, signing in first if needed.
@@ -123,64 +108,48 @@ export async function runScheduleOn(
     },
   });
   const interval = next.audit.intervalDays;
+  const k = kitFor();
 
-  // Two rows rather than one long one: at 80 columns the combined sentence
-  // wrapped, and a wrapped summary loses the spine on its second row.
-  // The third row enumerates what leaves the machine, and it is not optional.
-  // This is the ONLY opt-in path on the headless boxes the whole feature was
-  // built for — the settings panel says "sends: counts, redacted examples, and
-  // this machine's name" and argues in its own comment that a checkable list
-  // beats a stronger claim, and that reasoning applies here at least as much.
-  // The list is the real payload from `report-harm.ts`: machine id, hostname,
-  // platform, the window bounds and the redacted examples.
-  const summary = [
-    `every ${interval} day${interval === 1 ? "" : "s"} · reports to ${user.email}`,
-    "you only hear from it when a scan finds something harmful",
-    "each report sends: finding counts, redacted example commands, this machine's name",
+  // The second line enumerates what leaves the machine, and it is not optional.
+  // `reportsConsentedAt`, stamped above, records that a person READ it before
+  // anything is sent, so it is part of the consent rather than fine print — the
+  // one explanatory line the redesign keeps (decision D6). This is the ONLY
+  // opt-in path on the headless boxes the whole feature was built for, and the
+  // settings panel argues in its own comment that a checkable list beats a
+  // stronger claim. The list is the real payload from `report-harm.ts`: machine
+  // id, hostname, platform, the window bounds and the redacted examples.
+  const result = [
+    k.ok(`Scheduled audits to report to ${user.email} ${everyPhrase(interval)}.`),
+    `${INDENT}${paint(optsFor(process.stdout).color).ink3("Each report sends finding counts, redacted example commands and this machine's name.")}`,
   ];
-
-  if (prompted) {
-    // A sign-in just drew the frame, so the result continues it and the `└`
-    // closes both at once — rather than the frame ending and a loose line
-    // appearing underneath.
-    step("scheduled audits are on", summary);
-  } else {
-    // Nothing was asked, so nothing was a flow: a spine here would open a frame
-    // that has no beginning.
-    process.stdout.write(
-      `\n${green("✓")}  ${bold("scheduled audits are on")}\n` +
-        summary.map((r) => `   ${dim(r)}\n`).join(""),
-    );
-  }
+  // A sign-in just drew this screen's header, so the result continues it;
+  // otherwise this is the screen, and it opens with its own.
+  process.stdout.write(`\n${(prompted ? result : [k.header("Audit"), "", ...result]).join("\n")}\n`);
 
   // The switch is config; whether anything RUNS is the daemon. Saying "on"
   // without checking would be the same "on but silent" state the settings panel
   // exists to make visible.
   warnIfDaemonWontRun();
 
-  if (prompted) {
-    outro("failproofai audit --status  ·  when the next scan is due");
-  } else {
-    process.stdout.write(dim(`\n   failproofai audit --status   when the next scan is due\n\n`));
-  }
+  process.stdout.write(`\nSee when the next scan runs:  ${k.cmd("failproofai audit --status")}\n\n`);
 }
 
 export function runScheduleOff(): void {
   const before = readConfig().audit.auto;
   const next = updateConfig({ audit: { auto: false } });
+  const k = kitFor();
+  const say = (line: string) => printBlock(process.stdout, [k.header("Audit"), "", line]);
   if (next.audit.auto) {
-    process.stdout.write("Could not turn scheduled audits off.\n");
+    say(k.fail("Could not turn scheduled audits off."));
     return;
   }
   if (!before) {
-    process.stdout.write(dim("\nScheduled audits were already off.\n\n"));
+    say("Scheduled audits were already off.");
     return;
   }
-  process.stdout.write(
-    `\n${green("✓")}  ${bold("scheduled audits are off")}\n` +
-      `   ${dim("nothing runs on a timer and nothing is sent")}\n` +
-      `   ${dim("your session is untouched — sign out from the dashboard for that")}\n\n`,
-  );
+  // Nothing scans on a timer once this is off, so nothing is sent either. The
+  // sign-in is kept, so turning them back on costs no second code.
+  say(k.ok("Turned off scheduled audits."));
 }
 
 /**
@@ -200,93 +169,89 @@ export function runScheduleStatus(): void {
   const daemon = daemonServiceStatus();
 
   const on = config.audit.auto;
-  const opts = optsFor(process.stdout);
+  const k = kitFor();
   const detail: Array<[string, string]> = [];
+  // One ▲ per distinct problem, the one that stops scans before the one that
+  // stops digests.
+  const problems: string[] = [];
 
   // The state first, because everything below is detail about a machine that is
   // either doing this or not, and reading the detail first answers a question
-  // nobody has asked yet. It is a ROW like the rest, though: the headline used
-  // to be hand-padded to a different column than `row()` used, which is why this
-  // readout printed its first value at column 21 and every other at 18.
-  detail.push([
-    "scheduled audit",
-    on
-      ? `${green("on")}${dim(`  every ${config.audit.intervalDays} days`)}`
-      : dim("off"),
-  ]);
+  // nobody has asked yet. It is a ROW like the rest, on the one column every
+  // row shares.
+  const every = everyPhrase(config.audit.intervalDays);
+  detail.push(["scans", on ? `${k.on} ${every[0].toUpperCase()}${every.slice(1)}` : `${k.off} Off`]);
 
   // A session whose refresh window has closed cannot mint another access token,
   // so it is a destination in name only. Showing the address for one would tell
   // somebody their digests are going somewhere they are not.
   const live = auth && auth.refresh_expires_at * 1000 > Date.now() ? auth : null;
-  detail.push(["reports to", live ? live.user.email : dim("— signed out")]);
+  detail.push(["reports to", live ? live.user.email : "Signed out"]);
+
+  const daemonRow = describeDaemon(daemon, k);
+  detail.push(["daemon", daemonRow.value]);
+  if (daemonRow.problem) problems.push(daemonRow.problem);
+
   if (on && !live) {
     // The state the reporter surfaces as "signed-out". Named here for the same
     // reason the settings panel names it: the scans keep running, so silence
     // about the digests would look like the feature failing.
-    detail.push(["", pink("scans continue; digests are paused until you sign in")]);
+    problems.push(k.caution("Scans continue, but digests are paused until you sign in.", "failproofai audit --schedule"));
   } else if (on && config.audit.reportsConsentedAt === undefined) {
     // Signed in, scheduled, and still not sending: this machine set `audit.auto`
     // when it only meant "scan locally", so nothing has consented to the digest
-    // leaving the box. Without this row the status screen would show a healthy
+    // leaving the box. Without this line the status screen would show a healthy
     // schedule and a live address and still mail nothing, with no explanation
     // anywhere the user can see.
-    detail.push([
-      "",
-      pink("scans continue; digests need a fresh opt-in — run `--schedule` to turn them on"),
-    ]);
+    problems.push(k.caution("Scans continue, but digests need a fresh opt-in.", "failproofai audit --schedule"));
   }
 
-  detail.push(["daemon", describeDaemon(daemon)]);
-
   if (sched?.nextDueAtMs != null && on) {
     detail.push(["next scan", untilPhrase(sched.nextDueAtMs)]);
   }
   if (sched?.lastRunAtMs != null) {
     const exit = sched.lastExitCode;
     const failed = exit != null && exit !== 0 && exit !== 75;
-    detail.push([
-      "last scheduled",
-      agoPhrase(sched.lastRunAtMs) + (failed ? `  ${pink(`exit ${exit}`)}` : ""),
-    ]);
+    detail.push(["last scheduled", agoPhrase(sched.lastRunAtMs) + (failed ? `, failed with exit ${exit}` : "")]);
   }
-  detail.push([
-    "last result",
-    meta?.cachedAt ? agoPhrase(Date.parse(meta.cachedAt)) : dim("none yet"),
-  ]);
+  detail.push(["last result", meta?.cachedAt ? agoPhrase(Date.parse(meta.cachedAt)) : "None yet"]);
   if (machine?.last_reported_at) {
     detail.push(["last reported", agoPhrase(Date.parse(machine.last_reported_at))]);
   }
 
-  printBlock(
-    process.stdout,
-    stack(
-      // The meta carries a fact, not the word "status" — a heading that repeats
-      // the command name tells the reader nothing they did not just type.
-      title(
-        "failproofai audit",
-        on ? `scheduled · every ${config.audit.intervalDays} days` : "not scheduled",
-        opts,
-      ),
-      kitRows(detail, opts),
-    ),
-  );
+  printBlock(process.stdout, stack([k.header("Audit")], [k.head("Schedule"), ...k.kv(detail)], problems));
 }
 
-function describeDaemon(status: ReturnType<typeof daemonServiceStatus>): string {
+/**
+ * The daemon's row, and the ▲ that goes with it when it needs fixing. The fix
+ * is named whether or not scheduling is on: the daemon is what every scheduled
+ * scan would run under, and this is the screen people open to ask about it.
+ */
+function describeDaemon(
+  status: ReturnType<typeof daemonServiceStatus>,
+  k: ReturnType<typeof kitFor>,
+): { value: string; problem?: string } {
   switch (status) {
     case "running":
-      return green("running");
+      return { value: `${k.on} Running` };
     case "stopped":
-      return pink("stopped — run `failproofai config` to repair it");
+      return { value: `${k.off} Stopped`, problem: k.caution("The daemon is stopped.", "failproofai config") };
     case "not-installed":
-      return pink("not installed — run `failproofai config`");
+      return {
+        value: `${k.off} Not installed`,
+        problem: k.caution("The daemon is not installed.", "failproofai config"),
+      };
     case "condition-failed":
-      return pink("installed but its binary is missing — run `failproofai config`");
+      return {
+        value: `${k.off} Binary missing`,
+        problem: k.caution("The daemon is installed but its binary is missing.", "failproofai config"),
+      };
+    case "unknown":
+      // Only macOS without a cached sudo credential reads this, about a daemon
+      // that is usually running perfectly — not a fault to fix.
+      return { value: "Unknown" };
     default:
-      return isDaemonSupportedPlatform()
-        ? dim(String(status))
-        : dim("unavailable on this platform");
+      return { value: isDaemonSupportedPlatform() ? String(status) : "Unavailable on this platform" };
   }
 }
 
@@ -302,17 +267,15 @@ function warnIfDaemonWontRun(): void {
   // timer yet" in the same breath as confirming their schedule was on. The
   // dashboard already special-cases it; this is the same call.
   if (status === "unknown") return;
+  const k = kitFor(process.stderr);
   if (!isDaemonSupportedPlatform()) {
-    process.stderr.write(
-      `\n  ${pink("!")} The background service is not available on this platform,\n` +
-        `    so nothing will run on the timer here. \`failproofai audit\` still works.\n`,
-    );
+    process.stderr.write(`\n${k.caution("The daemon is not available on this platform, so nothing will run on the timer.")}\n`);
     return;
   }
+  const state =
+    status === "not-installed" ? "not installed" : status === "condition-failed" ? "missing its binary" : status.replace(/-/g, " ");
   process.stderr.write(
-    `\n  ${pink("!")} The background service is ${status.replace("-", " ")}, ` +
-      `so nothing will run on the timer yet.\n` +
-      `    Run \`failproofai config\` to install or repair it.\n`,
+    `\n${k.caution(`The daemon is ${state}, so nothing will run on the timer yet.`, "failproofai config")}\n`,
   );
 }
 

package/src/audit/types.ts

@@ -181,8 +181,39 @@ export interface AuditResult {
   enabledBuiltinNames: string[];
 }
 
+/**
+ * What `runAudit()` reports while it runs, for a caller drawing live progress.
+ *
+ * Two kinds, in this order: ONE `discovered` once every agent's transcripts
+ * are listed, then one `transcript` per transcript as each finishes — a cache
+ * hit, a scan, a scan that failed and a task that was skipped alike, so the
+ * per-agent counts always reach their totals. Transcripts finish in whatever
+ * order the scan pool completes them, not in discovery order.
+ */
+export type AuditProgress =
+  | {
+      kind: "discovered";
+      /** Every agent the audit covers, in scan order, with how many transcripts it has to scan (0 included). */
+      agents: Array<{ cli: IntegrationType; transcripts: number }>;
+      /** How many policies each tool call is replayed against: the builtins that can fire on a tool event. */
+      policies: number;
+    }
+  | {
+      kind: "transcript";
+      cli: IntegrationType;
+      /** This transcript's hits, by policy or detector name. Empty when it found nothing or could not be scanned. */
+      hitsByName: Record<string, number>;
+    };
+
 /** CLI-supplied options for `runAudit()`. Set by `bin/failproofai.mjs`. */
 export interface RunAuditOptions {
+  /**
+   * Called as the audit progresses. Optional, and only `failproofai audit`'s
+   * own screen passes it: the dashboard and the scheduled run do not, and the
+   * result is the same either way. A callback that throws is ignored — a
+   * progress display must never change what an audit finds.
+   */
+  onProgress?: (progress: AuditProgress) => void;
   /** Restrict to one or more CLIs. Default: all 7. */
   clis?: IntegrationType[];
   /** Restrict to sessions whose cwd matches one of these paths. */

package/src/hooks/agent-selection.ts

@@ -0,0 +1,155 @@
+/**
+ * Decision D2: a command that installs or removes an agent's hooks keeps the
+ * agent selection true.
+ *
+ * `agents.selected` in `config.json` is one list with three readers: which
+ * agents `failproofai config` hooks, which harnesses the daemon collects, and
+ * which ones `backfill` re-sends. Only `config` used to write it, so any other
+ * command that changed an agent's hooks left the list saying the opposite:
+ *
+ *  - `policies --install --cli goose`, on a machine whose selection leaves Goose
+ *    out, wired Goose — and the next `failproofai config`, which takes out the
+ *    hooks of every agent it does not trace, silently removed them again.
+ *  - `policies --uninstall --cli goose` took the hooks out and left Goose
+ *    traced, so the daemon kept collecting its sessions and the next `config`
+ *    put the hooks back.
+ *
+ * An install traces the agent at ANY scope: whichever file the hooks went into,
+ * somebody asked for that agent to be guarded. A removal untraces it only at
+ * user scope or every scope. The selection is per machine, and taking one
+ * repository's project hooks out says nothing about whether this machine should
+ * trace the agent — so that decision is the caller's, which knows the scope.
+ *
+ * Absent means every agent is traced, so an install has nothing to add. A
+ * removal cannot be recorded without a list, so it writes one: the agents on
+ * this machine — detected, or still hooked at user scope — but the ones
+ * removed, and `seen` as detected now. Not "every agent but the ones removed":
+ * `failproofai config` restores a saved list as it stands, so that list would
+ * have it hook every agent this build knows, installed or not.
+ *
+ * An agent traced again starts fresh (`requestFreshStart`), exactly as one
+ * re-ticked in `failproofai config` does.
+ *
+ * Only the commands that ask for it (`syncAgentSelection`) come here.
+ * `failproofai config` writes the selection itself, and `failproofai uninstall`
+ * leaves it alone.
+ */
+import { existsSync } from "node:fs";
+
+import { machineCollectsSessions, requestFreshStart } from "./backfill-request";
+import { readConfig, updateConfig } from "./fp-config";
+import { detectInstalledClis, getIntegration, hermesProfileHealth, settingsPathsFor } from "./integrations";
+import { optsFor, screenKit } from "./tui";
+import { INTEGRATION_TYPES, type IntegrationType } from "./types";
+
+/**
+ * Whether an agent has failproofai hooks in its USER settings — the seed for an
+ * upgrade in `failproofai config`, and what a removal on a machine with no
+ * saved list keeps traced. User scope only: project hooks depend on the
+ * directory a command happens to run from. A gateway with several profiles
+ * counts when ANY profile is hooked; requiring all of them would drop a partly
+ * hooked Hermes from the seed, and setup would then unhook every profile it has.
+ *
+ * Hooked means routed to failproofai, not healthy: a Hermes profile still on the
+ * legacy shell hooks sends every tool call here today. Requiring the healthy
+ * native plugin left such a gateway unticked, so setup stopped collecting it and
+ * never ran the install that moves it onto the plugin.
+ */
+export function hookedAtUserScope(id: IntegrationType, cwd: string): boolean {
+  const integration = getIntegration(id);
+  try {
+    if (integration.hooksInstalledInSettings("user", cwd)) return true;
+    if (id === "hermes") {
+      return hermesProfileHealth().some(
+        (p) => existsSync(p.home) && ((p.pluginInstalled && p.pluginEnabled) || p.legacyShellHookPresent),
+      );
+    }
+    const paths = settingsPathsFor(integration, "user", cwd);
+    if (paths.length < 2) return false;
+    return paths.some((one) =>
+      integration.hooksInstalledInSettings.call({ ...integration, getSettingsPaths: () => [one] }, "user", cwd),
+    );
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Bring the selection in line with hooks just installed for, or removed from,
+ * `clis`, and return the one line that says so: a ✓ note, a ▲ when the change
+ * could not be written, or null when the selection already agreed.
+ *
+ * The caller prints it after its own output, and only where the scope counts —
+ * see the module comment.
+ */
+export function keepAgentSelectionTrue(
+  change: "installed" | "removed",
+  clis: readonly IntegrationType[],
+): string | null {
+  const touched = INTEGRATION_TYPES.filter((id) => clis.includes(id));
+  if (touched.length === 0) return null;
+  const saved = readConfig().agents;
+
+  let moved: IntegrationType[];
+  let next: { selected: string[]; seen: string[] };
+  if (change === "installed") {
+    if (!saved) return null;
+    moved = touched.filter((id) => !saved.selected.includes(id));
+    if (moved.length === 0) return null;
+    // INTEGRATION_TYPES order. An id this build does not know is a newer
+    // build's agent, so it is kept after them as written, never dropped.
+    const inOrder = (ids: readonly string[]): string[] => [
+      ...INTEGRATION_TYPES.filter((id) => ids.includes(id)),
+      ...ids.filter((id) => !(INTEGRATION_TYPES as readonly string[]).includes(id)),
+    ];
+    const detected = detectInstalledClis();
+    const nowSeen = moved.filter((id) => detected.includes(id) && !saved.seen.includes(id));
+    next = {
+      selected: inOrder([...saved.selected, ...moved]),
+      seen: nowSeen.length > 0 ? inOrder([...saved.seen, ...nowSeen]) : saved.seen,
+    };
+  } else if (saved) {
+    moved = touched.filter((id) => saved.selected.includes(id));
+    if (moved.length === 0) return null;
+    const gone = new Set<string>(moved);
+    // Possibly empty, after every agent's hooks came out: an empty selection
+    // traces nothing, which is exactly what was asked for.
+    next = { selected: saved.selected.filter((id) => !gone.has(id)), seen: saved.seen };
+  } else {
+    moved = touched;
+    const detected = detectInstalledClis();
+    const cwd = process.cwd();
+    next = {
+      selected: INTEGRATION_TYPES.filter(
+        (id) => !touched.includes(id) && (detected.includes(id) || hookedAtUserScope(id, cwd)),
+      ),
+      seen: detected,
+    };
+  }
+
+  const kit = screenKit(optsFor(process.stdout));
+  const names = moved.map((id) => getIntegration(id).displayName);
+  const who = names.length === 1 ? names[0] : `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+  const one = names.length === 1;
+  const setup = kit.cmd("failproofai config");
+  // Before the selection that traces them, in the same order setup uses.
+  if (change === "installed") requestFreshStart(moved, machineCollectsSessions());
+  try {
+    updateConfig({ agents: next });
+  } catch (err) {
+    // The hooks themselves are in place, so the command is not failed for
+    // this. Said instead, because it is the exact drift this module exists to
+    // stop, and nothing else would mention it.
+    const why = err instanceof Error ? err.message : String(err);
+    return kit.caution(
+      change === "installed"
+        ? `Couldn't record ${who} as traced (${why}), so ${setup} may remove ${one ? "its" : "their"} hooks again.`
+        : `Couldn't record ${who} as no longer traced (${why}), so ${setup} may add ${one ? "its" : "their"} hooks back.`,
+    );
+  }
+  return kit.ok(
+    change === "installed"
+      ? `${who} ${one ? "is" : "are"} traced again, so ${setup} keeps ${one ? "its" : "their"} hooks.`
+      : `${who} ${one ? "is" : "are"} no longer traced, so ${setup} won't add ${one ? "its" : "their"} hooks back.`,
+  );
+}