failproofai 1.0.0-beta.11 → 1.0.0-beta.13

package/src/hooks/harness-cli.ts

@@ -0,0 +1,309 @@
+/**
+ * `failproofai harness` — manage extra capture paths per harness.
+ *
+ * Each supported agent CLI has one location its own installer put it in, and
+ * the collector watches that. This command adds others: a second profile, a
+ * bind-mounted team share, a container's home mapped in beside the host's, an
+ * agent an operator relocated. Those hold real sessions and nothing collected
+ * them.
+ *
+ * # This file edits config; the daemon decides what the config means
+ *
+ * Entries are stored as written. The grammar (`label=path`, folder-name
+ * fallback), `~` expansion, overlap rejection and the `<label>-<agentId>`
+ * namespacing all live in `crates/fpai-collect/src/extra_paths.rs`, and the
+ * daemon reports what it rejected at startup. Re-implementing any of that here
+ * would give one product two parsers, and the way that fails is the CLI
+ * accepting a path the daemon then silently drops — which is indistinguishable
+ * from the feature working.
+ *
+ * The one thing validated here is the HARNESS NAME, because that failure has no
+ * other detector: `[collector.sources.claud]` is valid TOML, parses cleanly,
+ * captures nothing, and is mentioned nowhere else a user would look.
+ *
+ * # No restart, and no sudo
+ *
+ * This writes one file in the user's own home and nothing else. The daemon's
+ * collector manager re-reads `config.toml` on an interval and cycles the
+ * collector whenever the resolved `CollectorConfig` changes — the same path
+ * that already picks up `--connect`, a stream being switched off, and a
+ * verbosity change. `extra_paths` rides it for free by living inside
+ * `Settings`, which is part of the value being compared. That is load-bearing
+ * rather than incidental, and `collector_config_change_cycles_the_collector`
+ * in `crates/fpai-collect/src/config.rs` pins it: move `sources` out of
+ * `CollectorConfig` and the CLI would keep reporting success for paths the
+ * running daemon never picks up.
+ */
+
+import { readConfig, updateConfig } from "./fp-config";
+import { configFile } from "./fp-home";
+
+/**
+ * Harness keys `[collector.sources.<key>]` accepts.
+ *
+ * MUST stay in step with `HARNESS_KEYS` in `crates/failproofaid/src/main.rs`,
+ * which is the side that actually registers the tasks. A name here that the
+ * daemon does not know configures a table nothing reads; a name the daemon
+ * knows and this list omits is a path the user cannot add. `__tests__` asserts
+ * the two lists are identical by reading the Rust source, because nothing else
+ * connects them.
+ *
+ * Twelve keys, thirteen sources: `claude` covers both the main and the subagent
+ * transcript formats, which share a root — an extra path holding Claude
+ * transcripts holds their subagents too.
+ */
+export const HARNESS_KEYS = [
+  "claude",
+  "codex",
+  "copilot",
+  "openclaw",
+  "pi",
+  "factory",
+  "antigravity",
+  "cursor",
+  "goose",
+  "opencode",
+  "devin",
+  "hermes",
+] as const;
+
+export type HarnessKey = (typeof HARNESS_KEYS)[number];
+
+export interface HarnessResult {
+  lines: string[];
+  exitCode: number;
+}
+
+const ok = (lines: string[]): HarnessResult => ({ lines, exitCode: 0 });
+const fail = (lines: string[]): HarnessResult => ({ lines, exitCode: 1 });
+
+function unknownHarness(name: string): HarnessResult {
+  return fail([
+    `Unknown harness: ${name}`,
+    "",
+    `Known harnesses: ${HARNESS_KEYS.join(", ")}`,
+  ]);
+}
+
+/** The path half of an entry, for comparing against what a user typed. */
+function pathOf(entry: string): string {
+  const eq = entry.indexOf("=");
+  if (eq <= 0) return entry.trim();
+  const label = entry.slice(0, eq).trim();
+  return label === "" ? entry.trim() : entry.slice(eq + 1).trim();
+}
+
+/** The label half, or `null` when the entry did not name one. */
+function labelOf(entry: string): string | null {
+  const eq = entry.indexOf("=");
+  if (eq <= 0) return null;
+  const label = entry.slice(0, eq).trim();
+  return label === "" ? null : label;
+}
+
+function currentPaths(harness: string): string[] {
+  return readConfig().collector.sources?.[harness]?.extraPaths ?? [];
+}
+
+function writePaths(harness: string, paths: string[]): void {
+  const cfg = readConfig();
+  const sources = { ...(cfg.collector.sources ?? {}) };
+  if (paths.length > 0) sources[harness] = { extraPaths: paths };
+  else delete sources[harness];
+  updateConfig({
+    collector: {
+      ...cfg.collector,
+      // `undefined` rather than `{}` when the last entry goes, so removing what
+      // you added leaves the file as it was rather than carrying an empty table
+      // forever.
+      sources: Object.keys(sources).length > 0 ? sources : undefined,
+    },
+  });
+}
+
+/**
+ * No restart, and deliberately no instruction to perform one.
+ *
+ * The daemon's collector manager re-reads `config.toml` on an interval and
+ * cycles the collector whenever the resolved `CollectorConfig` changes — the
+ * same path that already picks up `--connect`, a stream being switched off and
+ * a verbosity change. `extra_paths` rides that for free because it lives inside
+ * `Settings`, which lives inside the value being compared.
+ *
+ * Verified live: adding a path to a running daemon logged "collector
+ * configuration changed; cycling the collector", took the task count from 21 to
+ * 23, and the first transcript written under the new path reached the server.
+ *
+ * This said "run `sudo systemctl restart failproofaid@$USER`" first. That was
+ * wrong twice over: the restart is unnecessary, and it asks for root from a
+ * command that writes one file in the user's own home and needs none.
+ */
+const TAKES_EFFECT_HINT = [
+  "",
+  "The daemon picks this up on its own within a few seconds — no restart, no sudo.",
+];
+
+export function addPath(harness: string, entry: string): HarnessResult {
+  if (!(HARNESS_KEYS as readonly string[]).includes(harness)) return unknownHarness(harness);
+  const trimmed = entry.trim();
+  if (trimmed === "") return fail(["A path is required."]);
+  if (pathOf(trimmed) === "") {
+    return fail([`Could not read a path out of ${JSON.stringify(entry)}.`, "", "Use `<path>` or `<label>=<path>`."]);
+  }
+
+  const existing = currentPaths(harness);
+
+  // Exact duplicate: succeed rather than error. `add-path` run twice from a
+  // provisioning script must not fail the second time.
+  if (existing.includes(trimmed)) {
+    return ok([`${harness}: ${trimmed} is already configured.`]);
+  }
+
+  // Same path under a different label, or the same label on a different path.
+  // Both are rejected HERE rather than left to the daemon, because the daemon
+  // resolves them at startup and drops one — so the CLI would report success
+  // for a path that is never captured.
+  const samePath = existing.find((e) => pathOf(e) === pathOf(trimmed));
+  if (samePath) {
+    return fail([
+      `${harness} already captures ${pathOf(trimmed)} as ${JSON.stringify(samePath)}.`,
+      "",
+      "Remove it first if you meant to relabel it:",
+      `  failproofai harness remove-path ${harness} ${pathOf(trimmed)}`,
+    ]);
+  }
+  const wanted = labelOf(trimmed);
+  if (wanted) {
+    const sameLabel = existing.find((e) => labelOf(e) === wanted);
+    if (sameLabel) {
+      return fail([
+        `${harness} already uses the label ${JSON.stringify(wanted)} for ${pathOf(sameLabel)}.`,
+        "",
+        "Labels namespace agent ids, so two paths cannot share one.",
+      ]);
+    }
+  }
+
+  writePaths(harness, [...existing, trimmed]);
+  return ok([
+    `${harness}: now also capturing ${pathOf(trimmed)}`,
+    wanted
+      ? `  agent ids will be namespaced ${wanted}-*`
+      : "  a label will be derived from the folder name; `failproofai harness list` shows it",
+    `  written to ${configFile()}`,
+    ...TAKES_EFFECT_HINT,
+  ]);
+}
+
+export function removePath(harness: string, target: string): HarnessResult {
+  if (!(HARNESS_KEYS as readonly string[]).includes(harness)) return unknownHarness(harness);
+  const existing = currentPaths(harness);
+  const t = target.trim();
+  // Match on the whole entry, on its path, or on its label — a user removing
+  // something is working from what `list` printed, which shows all three.
+  const kept = existing.filter((e) => e !== t && pathOf(e) !== t && labelOf(e) !== t);
+  if (kept.length === existing.length) {
+    return fail([
+      `${harness} has no extra path matching ${JSON.stringify(t)}.`,
+      "",
+      existing.length > 0
+        ? `Configured: ${existing.join(", ")}`
+        : `${harness} has no extra paths configured.`,
+    ]);
+  }
+  writePaths(harness, kept);
+  return ok([
+    `${harness}: no longer capturing ${t}`,
+    "",
+    "Already-collected sessions from that path are NOT removed — they are on the",
+    "server. This only stops new ones.",
+    ...TAKES_EFFECT_HINT,
+  ]);
+}
+
+export function listPaths(harness?: string): HarnessResult {
+  if (harness && !(HARNESS_KEYS as readonly string[]).includes(harness)) return unknownHarness(harness);
+  const sources = readConfig().collector.sources ?? {};
+  const names: string[] = harness
+    ? [harness]
+    : HARNESS_KEYS.filter((k) => sources[k]?.extraPaths?.length);
+
+  // Computed BEFORE the empty-state return, not after. A config whose only
+  // tables are typos has no known harness configured, so the early return fired
+  // and the warning below was unreachable in precisely the case it exists for —
+  // the user sees "No extra capture paths configured" while their file plainly
+  // contains one, which is the most confusing possible answer.
+  const unknown = Object.keys(sources).filter(
+    (k) => !(HARNESS_KEYS as readonly string[]).includes(k),
+  );
+
+  if (names.length === 0 && unknown.length === 0) {
+    return ok([
+      "No extra capture paths configured.",
+      "",
+      "Every harness is watching only its default location. Add one with:",
+      "  failproofai harness add-path <harness> [<label>=]<path>",
+      "",
+      `Harnesses: ${HARNESS_KEYS.join(", ")}`,
+    ]);
+  }
+
+  const lines: string[] = [];
+  for (const name of names) {
+    const entries = sources[name]?.extraPaths ?? [];
+    if (entries.length === 0) {
+      if (harness) lines.push(`${name}: no extra paths configured (default location only)`);
+      continue;
+    }
+    lines.push(`${name}:`);
+    for (const e of entries) {
+      const label = labelOf(e);
+      lines.push(
+        label
+          ? `  ${pathOf(e)}   → agent ids ${label}-*`
+          : `  ${pathOf(e)}   → label derived from the folder name`,
+      );
+    }
+  }
+  // Unknown tables are surfaced here as well as by the daemon: a user who
+  // hand-edited config.toml runs `list` to check it, and that is the moment the
+  // typo is cheapest to find.
+  if (unknown.length > 0) {
+    if (lines.length === 0) lines.push("No extra capture paths configured for any known harness.");
+    lines.push(
+      "",
+      `⚠ config.json configures ${unknown.length} unknown harness(es): ${unknown.join(", ")}`,
+      "  Nothing is captured from them.",
+      `  Known: ${HARNESS_KEYS.join(", ")}`,
+    );
+  }
+  return ok(lines);
+}
+
+/** Dispatch for `failproofai harness <sub> ...`. */
+export function runHarnessCommand(argv: string[]): HarnessResult {
+  const [sub, ...rest] = argv;
+  switch (sub) {
+    case "add-path":
+      if (rest.length < 2) {
+        return fail(["Usage: failproofai harness add-path <harness> [<label>=]<path>"]);
+      }
+      return addPath(rest[0], rest.slice(1).join(" "));
+    case "remove-path":
+      if (rest.length < 2) {
+        return fail(["Usage: failproofai harness remove-path <harness> <path|label>"]);
+      }
+      return removePath(rest[0], rest.slice(1).join(" "));
+    case "list":
+      return listPaths(rest[0]);
+    default:
+      return fail([
+        sub ? `Unknown subcommand: ${sub}` : "A subcommand is required.",
+        "",
+        "Usage:",
+        "  failproofai harness list [<harness>]",
+        "  failproofai harness add-path <harness> [<label>=]<path>",
+        "  failproofai harness remove-path <harness> <path|label>",
+      ]);
+  }
+}

package/src/hooks/hook-activity-store.ts

@@ -99,16 +99,16 @@ export interface HookActivityEntry {
   policySource?: "builtin" | "custom" | "convention" | "cloud";
   /** Cloud policy id of the decider. Present only when `policySource` is "cloud". */
   cloudPolicyId?: string;
-  /** Immutable revision of that policy — the half of attribution that identifies WHICH version ran. */
-  cloudRevision?: number;
+  /** Immutable version of that policy — the half of attribution that identifies WHICH version ran. */
+  cloudVersion?: number;
   /**
-   * The cloud generation active when this event was evaluated, recorded on
+   * The cloud deployment active when this event was evaluated, recorded on
    * every row of a managed machine regardless of what decided. "What was
    * deployed here" is a different question from "what decided", and only this
    * distinguishes a rollout that changed no outcomes from one that never
    * arrived.
    */
-  cloudGeneration?: number;
+  cloudDeployment?: number;
   /**
    * What observe-mode policies WOULD have done, had they been enforcing. This
    * record is the entire point of observe mode: without it the row is
@@ -117,7 +117,7 @@ export interface HookActivityEntry {
    */
   observed?: Array<{
     policyId: string;
-    revision: number;
+    version: number;
     decision: "deny" | "instruct";
     reason: string | null;
   }>;

package/src/hooks/manager.ts

@@ -25,6 +25,7 @@ import { getInstanceId, hashToId } from "../../lib/telemetry-id";
 import { CliError } from "../cli-error";
 import { hookLogWarn } from "./hook-logger";
 import { customPoliciesDir, globalPolicyConfigFile } from "./fp-home";
+import { readActiveCloudManagedPolicies } from "./cloud-managed-policies";
 
 const VALID_POLICY_NAMES = new Set(BUILTIN_POLICIES.map((p) => p.name));
 
@@ -839,6 +840,40 @@ export async function listHooks(cwd?: string): Promise<void> {
     console.log();
   }
 
+  // Cloud-managed policies. These enforce on this machine exactly like the two
+  // sections above, but nothing here listed them — so `failproofai policies`
+  // answered "what is enforcing?" with a subset, and the policies an operator
+  // pushed to a fleet were the ones invisible to the person running the
+  // command on it.
+  //
+  // Read-only on purpose: these are owned by the deployment, not by local
+  // config. `--uninstall <name>` cannot switch one off, and printing them
+  // beside toggleable rows without saying so would imply it can.
+  try {
+    const cloud = readActiveCloudManagedPolicies();
+    if (cloud.length > 0) {
+      const gen = cloud[0].deployment;
+      console.log(
+        `\n  \u2500\u2500 Cloud-managed \u2014 deployment ${gen} \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`,
+      );
+      const colWidth = Math.max(nameColWidth, ...cloud.map((c) => c.id.length + 2));
+      for (const artifact of cloud) {
+        // `observe` is evaluated and then has its verdict discarded, so a row
+        // that read "ON" would claim enforcement this policy deliberately is
+        // not doing.
+        const status =
+          artifact.effect === "observe" ? "\x1B[33m\u25D0 OBS\x1B[0m" : "\x1B[32m\u2713 ON\x1B[0m";
+        console.log(`  ${status}    ${artifact.id.padEnd(colWidth)}v${artifact.version}`);
+      }
+      console.log("\n  Managed from the dashboard \u2014 not switchable with `failproofai policies`.");
+      console.log();
+    }
+  } catch {
+    // A machine with no deployment, or an unreadable manifest, simply has no
+    // section. The hook path reports its own failures; a listing must not be
+    // the thing that turns a bad manifest into a broken command.
+  }
+
   // Mirror what was just listed into the USER config. Safe here because
   // `failproofai policies` is a one-shot command — never do this on the hook
   // path (see the HooksConfig.conventionPolicies doc comment).

package/src/hooks/onboarding-attempt.ts

@@ -29,11 +29,13 @@
  * elevate. So each reason carries a cheap local check for whether its blocker
  * is gone, and the wizard offers itself again the moment one is:
  *
- *   needs_root     -> elevation is now possible without a prompt
- *   daemon_failed  -> the service manager now reports something different
- *   cancelled      -> the CLI version changed; an upgrade is a fair moment to
- *                     ask again, and nothing else about a deliberate cancel
- *                     should re-nag
+ *   needs_root          -> elevation is now possible without a prompt
+ *   daemon_failed       -> the service manager now reports something different
+ *   cancelled           -> the CLI version changed; an upgrade is a fair moment to
+ *                          ask again, and nothing else about a deliberate cancel
+ *                          should re-nag
+ *   unsupported_platform -> the CLI version changed (a future release might
+ *                          support this platform)
  *
  * Every probe is local and takes milliseconds. None of them runs on the hook
  * path — `--hook` never reaches the first-run gate at all.
@@ -150,6 +152,11 @@ export function blockerCleared(attempt: OnboardingAttempt, probe: RetryProbe): b
       // this module removes — but an upgrade is a new thing to say, so it is
       // allowed to ask once more.
       return probe.cliVersion !== attempt.cliVersion;
+    case "unsupported_platform":
+      // A permanent property of the machine, not the invocation — nagging every
+      // command would just repeat the hard-fail. Only a new release is a reason
+      // to ask again (it might add support for this platform).
+      return probe.cliVersion !== attempt.cliVersion;
     case "not_a_tty":
     case "running_as_sudo":
       // Both are properties of the invocation, not of the machine, so the next
@@ -166,14 +173,23 @@ export function attemptHintLines(attempt: OnboardingAttempt): string[] {
     needs_root: "it needs root to install the failproofaid service",
     daemon_failed: "the failproofaid service could not be started",
     cancelled: "it was cancelled",
+    unsupported_platform: "failproofaid does not run on this platform",
     not_a_tty: "there was no terminal to ask in",
     running_as_sudo: "it was run under sudo",
   };
   const detail = why[attempt.reason] ?? "it did not finish";
+  // Every other reason is fixable by the user right now, so the generic
+  // retry is correct. unsupported_platform is not — blockerCleared only
+  // re-offers it on a CLI version change, and `failproofai config` would
+  // hit the exact same hard-fail in the meantime.
+  const action =
+    attempt.reason === "unsupported_platform"
+      ? "Check for a failproofai update — this platform may be supported by a newer release."
+      : "Run `failproofai config` when you are ready.";
   return [
     ``,
     `[failproofai] Setup is not finished — ${detail}.`,
-    `              Run \`failproofai config\` when you are ready.`,
+    `              ${action}`,
     ``,
   ];
 }

package/src/hooks/tui.ts

@@ -34,6 +34,8 @@ export interface SelectChoice<T> {
 }
 
 export interface SelectOneOptions<T> {
+  /** Offer ← to go back a step. The caller must handle `BACK`. */
+  allowBack?: boolean;
   message: string;
   choices: SelectChoice<T>[];
   /** Static info lines rendered under the question (e.g. a review summary). */
@@ -64,6 +66,8 @@ export interface MultiChoice<T> {
 }
 
 export interface MultiSelectOptions<T> {
+  /** Offer ← to go back a step. The caller must handle `BACK`. */
+  allowBack?: boolean;
   message: string;
   choices: MultiChoice<T>[];
   minSelected?: number;
@@ -423,6 +427,8 @@ interface PromptSpec<R> {
   renderRow: (index: number, active: boolean, budget: number) => string;
   /** Extra line(s) above the footer (e.g. a min-selected warning). */
   warnLine?: () => string | null;
+  /** When set, ← resolves `BACK` so the caller can step backwards. */
+  allowBack?: boolean;
   footer: string;
   /** Handle non-navigation keys. `{done}` finishes, `"redraw"` repaints. */
   onKey: (key: readline.Key, cursor: number) => { done: R } | "redraw" | undefined;
@@ -469,10 +475,21 @@ function runPrompt<R>(p: PromptSpec<R>): Promise<R | null> {
   };
 
   const collapse = (result: R | null): void => {
+    // BACK is handled HERE, not in each `summaryFor`, because it is not a value
+    // of `R` at all — it is a sentinel the shared key handler injects, so every
+    // prompt would otherwise have to know about a symbol it never declared.
+    //
+    // Both existing callers got it wrong in different ways, and one of them
+    // hung: `multiSelect`'s summary calls `values.includes(...)`, which throws
+    // `TypeError` on a symbol — and it throws INSIDE `finish`, before
+    // `resolve(result)`, so pressing ← never settled the promise and the wizard
+    // stopped responding entirely. `selectOne` fell through to `String(value)`
+    // and rendered the literal text `Symbol(failproofai.back)`.
+    const summary = (result as unknown) === BACK ? "back" : p.summaryFor(result);
     repaint(stdout, region, [
       c.dim(BAR),
       `${c.dim(STEP_DONE)}  ${p.message}`,
-      `${c.dim(BAR)}  ${c.dim(p.summaryFor(result))}`,
+      `${c.dim(BAR)}  ${c.dim(summary)}`,
     ]);
   };
 
@@ -500,6 +517,10 @@ function runPrompt<R>(p: PromptSpec<R>): Promise<R | null> {
       if (!key) return;
       if ((key.ctrl && (key.name === "c" || key.name === "d")) || key.name === "escape") {
         finish(null);
+      } else if (key.name === "left" && p.allowBack) {
+        // Only when the caller opted in. A prompt with nowhere to go back TO
+        // must not appear to offer it.
+        finish(BACK as unknown as never);
       } else if (key.name === "up") {
         cursor = cursor > 0 ? cursor - 1 : choices.length - 1;
         repaint(stdout, region, build());
@@ -519,7 +540,24 @@ function runPrompt<R>(p: PromptSpec<R>): Promise<R | null> {
 
 // ── selectOne (radio) ─────────────────────────────────────────────────────────
 
-export function selectOne<T>(opts: SelectOneOptions<T>): Promise<T | null> {
+/**
+ * Returned by a prompt when the user asked to go BACK a step, as distinct from
+ * cancelling. Both used to be `null`, which made "I picked the wrong scope" and
+ * "I want out" the same keystroke — so the only way to change an earlier answer
+ * was to abandon setup and start over.
+ *
+ * A symbol rather than a sentinel string because a caller's value type is its
+ * own: `selectOne<string>` could legitimately have "back" as a real choice.
+ */
+export const BACK: unique symbol = Symbol("failproofai.back");
+export type Back = typeof BACK;
+
+// Overloaded so `BACK` appears in the return type ONLY where it was asked for.
+// Widening every caller to `T | Back | null` would make dozens of call sites
+// handle a value they can never receive.
+export function selectOne<T>(opts: SelectOneOptions<T> & { allowBack: true }): Promise<T | Back | null>;
+export function selectOne<T>(opts: SelectOneOptions<T>): Promise<T | null>;
+export function selectOne<T>(opts: SelectOneOptions<T>): Promise<T | Back | null> {
   const stdin: TTYIn = opts.stdin ?? process.stdin;
   const stdout: TTYOut = opts.stdout ?? process.stdout;
   const choices = opts.choices;
@@ -550,7 +588,10 @@ export function selectOne<T>(opts: SelectOneOptions<T>): Promise<T | null> {
       const hint = choice.hint ? `  ${c.dim(ellipsize(choice.hint, budget))}` : "";
       return `${dot} ${label}${hint}`;
     },
-    footer: "↑/↓ navigate · enter to select · esc to cancel",
+    allowBack: opts.allowBack,
+    footer: opts.allowBack
+      ? "↑/↓ navigate · enter to select · ← back · esc to cancel"
+      : "↑/↓ navigate · enter to select · esc to cancel",
     onKey: (key, cursor) =>
       key.name === "return" ? { done: choices[cursor].value } : undefined,
     summaryFor: (value) =>
@@ -562,7 +603,9 @@ export function selectOne<T>(opts: SelectOneOptions<T>): Promise<T | null> {
 
 // ── multiSelect (checklist) ────────────────────────────────────────────────────
 
-export function multiSelect<T>(opts: MultiSelectOptions<T>): Promise<T[] | null> {
+export function multiSelect<T>(opts: MultiSelectOptions<T> & { allowBack: true }): Promise<T[] | null | Back>;
+export function multiSelect<T>(opts: MultiSelectOptions<T>): Promise<T[] | null>;
+export function multiSelect<T>(opts: MultiSelectOptions<T>): Promise<T[] | null | Back> {
   const stdin: TTYIn = opts.stdin ?? process.stdin;
   const stdout: TTYOut = opts.stdout ?? process.stdout;
   const choices = opts.choices;
@@ -604,7 +647,12 @@ export function multiSelect<T>(opts: MultiSelectOptions<T>): Promise<T[] | null>
       return `${caret} ${box} ${label}${hint}`;
     },
     warnLine: () => (warn ? c.warn(`Select at least ${minSelected}.`) : null),
-    footer: opts.hint ?? "↑/↓ move · space select · ctrl+a all · enter confirm",
+    allowBack: opts.allowBack,
+    footer:
+      opts.hint ??
+      (opts.allowBack
+        ? "↑/↓ move · space select · ctrl+a all · ← back · enter confirm"
+        : "↑/↓ move · space select · ctrl+a all · enter confirm"),
     onKey: (key, cursor) => {
       if (key.name === "space") {
         if (choices[cursor]?.locked) return "redraw"; // always on — not a choice
@@ -705,10 +753,19 @@ export function promptText(opts: PromptTextOptions): Promise<string | null> {
   return new Promise((resolve) => {
     let value = "";
     const draw = (error?: string) => {
+      const cols = stdout.columns || 80;
       const shown = opts.mask ? "•".repeat(value.length) : value;
       const hint = opts.hint ? `  ${c.dim(opts.hint)}` : "";
-      const err = error ? `\n  ${c.warn(error)}` : "";
-      stdout.write(`\r\x1b[2K${c.bold(opts.message)} ${shown}${hint}${err}`);
+      // Truncate to ONE physical row. `\r\x1b[2K` erases the row the cursor is
+      // on and nothing above it — so a line wider than the terminal wraps, the
+      // erase reaches only its last row, and every keystroke leaves the earlier
+      // rows behind. That is why pasting a 40-character API key printed 40
+      // stacked copies of the prompt: `API key for <host>` plus the masked
+      // value plus the `needs events:add · policies:pull …` hint is past 80
+      // columns before the key is even half typed.
+      const line = truncate(`${c.bold(opts.message)} ${shown}${hint}`, cols - 1);
+      const err = error ? `\n  ${truncate(c.warn(error), cols - 3)}` : "";
+      stdout.write(`\r\x1b[2K${line}${err}`);
       if (err) stdout.write("\x1b[1A");
     };
     draw();

package/src/hooks/uninstall-cli.ts

@@ -229,7 +229,7 @@ export async function runUninstallCommand(opts: UninstallOptions = {}): Promise<
         purged: false,
         lines: [
           ...lines,
-          `✗ could not update ${failproofaiHome()}/config.toml: ${err instanceof Error ? err.message : String(err)}`,
+          `✗ could not update ${failproofaiHome()}/config.json: ${err instanceof Error ? err.message : String(err)}`,
           ``,
           `Stopped before touching the service. Removing it while this machine still`,
           `requires it would deny every tool call. Fix the file's permissions and re-run.`,