failproofai 1.0.1 → 1.0.2-beta.1

package/src/hooks/manager.ts

@@ -1,5 +1,5 @@
 /**
- * Install/remove/list failproofai hooks for one or more agent CLIs.
+ * Install/remove/list failproofai hooks for one or more agent harnesses.
  *
  * Per-CLI path resolution and settings I/O live in `./integrations` (one
  * `Integration` impl per CLI). This module orchestrates: validation, policy
@@ -26,6 +26,23 @@ import { CliError } from "../cli-error";
 import { hookLogWarn } from "./hook-logger";
 import { customPoliciesDir, globalPolicyConfigFile } from "./fp-home";
 import { readActiveCloudManagedPolicies } from "./cloud-managed-policies";
+import { CORE_SOURCE, addPack, setPackPolicyEnabled } from "./pack-store";
+import type { ResolvedPack } from "./pack-manifest";
+import { hasInstalledPacks, readInstalledPacks } from "./pack-manifest";
+import {
+  chip,
+  note,
+  nextStep,
+  optsFor,
+  printBlock,
+  rule,
+  stack,
+  table,
+  title,
+  warning,
+  type ChipState,
+  type TableRow,
+} from "./tui";
 
 const VALID_POLICY_NAMES = new Set(BUILTIN_POLICIES.map((p) => p.name));
 
@@ -63,13 +80,167 @@ function resolveFailproofaiBinary(): string {
   }
 }
 
-function validatePolicyNames(names: string[]): void {
-  const invalid = names.filter((n) => !VALID_POLICY_NAMES.has(n));
-  if (invalid.length > 0) {
-    const validList = [...VALID_POLICY_NAMES].join(", ");
+/** One policy of one installed pack, resolved from a name the user typed. */
+interface PackPolicyRef {
+  packId: string;
+  packVersion: string;
+  name: string;
+  /** The `disabledCustomPolicies` entry the dashboard writes for it. */
+  disabledKey: string;
+}
+
+/**
+ * Split names the user typed into builtins and installed-pack policies.
+ *
+ * Without this, every name went through `validatePolicyNames`, whose set is the
+ * compiled builtins — so `policies --disable block-big-refund` on a pack the
+ * user had just installed answered "Unknown policy name" and listed 39 names
+ * that were not the one they meant. A pack could be installed and then not
+ * managed at all.
+ *
+ * A builtin wins a bare name, because that is the name people have typed for a
+ * year and a third-party pack must not be able to capture it. Two packs
+ * declaring the same name is the one case that cannot be guessed, so it is
+ * refused with the qualified `<pack-id>:<name>` form spelled out.
+ */
+function resolvePolicyNames(names: string[]): { builtins: string[]; packs: PackPolicyRef[] } {
+  const builtins: string[] = [];
+  const packs: PackPolicyRef[] = [];
+  const unknown: string[] = [];
+
+  let installed: ResolvedPack[] = [];
+  try {
+    installed = readInstalledPacks().packs;
+  } catch {
+    // No packs, or an unreadable manifest: names simply resolve as builtins and
+    // an unknown one gets the ordinary error. A listing-adjacent command must
+    // not fail because a pack manifest is corrupt.
+  }
+
+  const refsFor = (packId: string | null, policyName: string): PackPolicyRef[] =>
+    installed
+      .filter((pack) => (packId === null || pack.id === packId))
+      .filter((pack) => pack.policies.some((p) => p.name === policyName))
+      .map((pack) => ({
+        packId: pack.id,
+        packVersion: pack.version,
+        name: policyName,
+        disabledKey: `pack:${pack.id}@${pack.version}:${policyName}`,
+      }));
+
+  for (const raw of names) {
+    // A PACK first, then the compiled set. This order is the whole fix for
+    // `policy remove block-sudo` printing "Disabled 0" while `block-sudo` kept
+    // denying: the name resolved to a builtin, the command edited
+    // `enabledPolicies`, and `enabledPolicies` stopped deciding anything when
+    // this build stopped registering builtins. The pack is where the switch is.
+    const direct = refsFor(null, raw);
+    if (direct.length === 1) {
+      packs.push(direct[0]);
+      continue;
+    }
+    if (direct.length > 1) {
+      throw new CliError(
+        `"${raw}" is declared by ${direct.length} installed packs.\n` +
+          `Name the one you mean:\n` +
+          direct.map((m) => `  ${m.packId}:${m.name}`).join("\n"),
+      );
+    }
+    // No pack carries it. Falls back to the compiled name set, which is what a
+    // machine still running on the migration shim has.
+    if (VALID_POLICY_NAMES.has(raw)) {
+      builtins.push(raw);
+      continue;
+    }
+    // `acme/finance:block-big-refund` — a pack id holds a slash, never a colon,
+    // so the last colon separates them unambiguously.
+    const colon = raw.lastIndexOf(":");
+    const qualified = colon > 0
+      ? { packId: raw.slice(0, colon), name: raw.slice(colon + 1) }
+      : null;
+    const matches = qualified
+      ? refsFor(qualified.packId, qualified.name)
+      : refsFor(null, raw);
+
+    if (matches.length === 1) {
+      packs.push(matches[0]);
+      continue;
+    }
+    if (matches.length > 1) {
+      throw new CliError(
+        `"${raw}" is declared by ${matches.length} installed packs.\n` +
+          `Name the one you mean:\n` +
+          matches.map((m) => `  ${m.packId}:${m.name}`).join("\n"),
+      );
+    }
+    unknown.push(raw);
+  }
+
+  if (unknown.length > 0) {
+    const packNames = installed.flatMap((pack) =>
+      pack.policies.map((p) => `${pack.id}:${p.name}`),
+    );
     throw new CliError(
-      `Unknown policy name(s): ${invalid.join(", ")}\n` +
-      `Valid policies: ${validList}`
+      `Unknown policy name(s): ${unknown.join(", ")}\n` +
+        `Valid policies: ${[...VALID_POLICY_NAMES].join(", ")}` +
+        (packNames.length > 0 ? `\nFrom installed packs: ${packNames.join(", ")}` : ""),
+    );
+  }
+  return { builtins, packs };
+}
+
+/** Turn pack policies on or off, and say what happened. */
+function applyPackPolicies(
+  refs: PackPolicyRef[],
+  on: boolean,
+  scope: HookScope,
+  cwd?: string,
+): void {
+  if (refs.length === 0) return;
+  for (const ref of refs) {
+    const result = setPackPolicyEnabled(ref.packId, ref.name, on);
+    if (!result.ok) {
+      throw new CliError(`Could not ${on ? "enable" : "disable"} ${ref.name}: ${result.reason}`);
+    }
+  }
+  if (on) {
+    // Clearing the dashboard's key too. The selection and the disabled key are
+    // two different switches for one policy, and leaving the second one set
+    // would report the policy enabled while it stayed off.
+    const config = readScopedHooksConfig(scope, cwd);
+    const keys = new Set(refs.map((r) => r.disabledKey));
+    const remaining = (config.disabledCustomPolicies ?? []).filter((k) => !keys.has(k));
+    if (remaining.length !== (config.disabledCustomPolicies ?? []).length) {
+      const next: HooksConfig = { ...config, disabledCustomPolicies: remaining };
+      if (remaining.length === 0) delete next.disabledCustomPolicies;
+      writeScopedHooksConfig(next, scope, cwd);
+    }
+  }
+  for (const ref of refs) {
+    console.log(
+      `${on ? "Enabled" : "Disabled"} ${ref.name} from pack ${ref.packId}@${ref.packVersion}.`,
+    );
+  }
+}
+
+/**
+ * Refuse to "disable" a policy that will register anyway.
+ *
+ * Removing an `alwaysOn` name from `enabledPolicies` succeeds at the file level
+ * and changes nothing at the enforcement level, so without this the CLI reports
+ * a policy disabled while it keeps denying — the operator's mental model and the
+ * machine's behaviour diverge silently, which is the failure this policy exists
+ * to prevent in the first place.
+ */
+function rejectAlwaysOnPolicies(names: string[]): void {
+  const alwaysOn = new Set(BUILTIN_POLICIES.filter((p) => p.alwaysOn).map((p) => p.name));
+  const refused = names.filter((n) => alwaysOn.has(n));
+  if (refused.length > 0) {
+    throw new CliError(
+      `Cannot disable: ${refused.join(", ")}\n` +
+      `This policy stops an agent from switching off failproofai itself, so it ` +
+      `is always on and ships with the package. A guard the agent can disable ` +
+      `by the means it is meant to prevent is not a guard.`
     );
   }
 }
@@ -151,8 +322,21 @@ async function installHooksImpl(
   // Validate user input first before any system checks
   if (policyNames !== undefined && policyNames.length > 0) {
     const nonAllNames = policyNames.filter((n) => n !== "all");
-    // Check unknown names first (most actionable error for the user)
-    if (nonAllNames.length > 0) validatePolicyNames(nonAllNames);
+    // Check unknown names first (most actionable error for the user). Pack
+    // policies are applied here and taken out of the list: the rest of this
+    // function writes `enabledPolicies`, which is a builtin-only set.
+    if (nonAllNames.length > 0) {
+      const resolved = resolvePolicyNames(nonAllNames);
+      applyPackPolicies(resolved.packs, true, scope, cwd);
+      if (resolved.packs.length > 0) {
+        policyNames = policyNames.filter((n) => n === "all" || resolved.builtins.includes(n));
+        // Named ONLY pack policies: the work is done. Carrying on would resolve
+        // the failproofai binary and rewrite every CLI's settings to enable a
+        // set of builtins nobody asked about — and would fail outright on a
+        // machine where the binary is not on PATH, AFTER the pack change landed.
+        if (policyNames.length === 0) return;
+      }
+    }
     // Then check if "all" is mixed with valid specific names
     if (policyNames.includes("all") && nonAllNames.length > 0) {
       throw new CliError(
@@ -290,6 +474,55 @@ async function installHooksImpl(
     }
   }
   writeScopedHooksConfig(configToWrite, scope, cwd);
+
+  // Choosing policies IS selecting from the pack now. Nothing registers these
+  // names from this build any more, so writing `enabledPolicies` and stopping
+  // would leave a freshly set-up machine enforcing nothing at all — which is
+  // the failure mode this whole product exists to prevent.
+  //
+  // Fetched from the pack's GitHub release: there is no copy in this package,
+  // cannot fail behind a proxy, and the machine is guarded the moment it is
+  // configured rather than the moment it next reaches github.com.
+  // The always-on guard is excluded: a pack may not declare `alwaysOn`, so the
+  // pack does not carry it and asking for it by name is a selection the pack
+  // cannot satisfy. It ships compiled in and registers regardless.
+  const alwaysOnNames = new Set(BUILTIN_POLICIES.filter((p) => p.alwaysOn).map((p) => p.name));
+  const fromPack = selectedPolicies.filter((name) => !alwaysOnNames.has(name));
+  if (fromPack.length > 0) {
+    // ONLY when there is no pack yet. Fetching the core pack with
+    // `only: <selection>` REPLACES whatever the machine had chosen, and
+    // `selectedPolicies` is derived from `enabledPolicies` — which is empty on a
+    // machine whose pack came from `pack add core`. `policy add block-rm-rf`
+    // therefore took a machine from ten guards to one, silently, and nine
+    // policies went from denying to allowing.
+    //
+    // With a pack already installed the names are switched on individually
+    // instead, which is additive and touches nothing else.
+    if (!hasInstalledPacks()) {
+      // Fetched, not unpacked from this package: there is no copy in here any
+      // more. That makes this the one path in `policies --install` that needs
+      // the network, so its failure is reported rather than thrown — the names
+      // are already written to config, and the no-pack fallback enforces them
+      // until a pack arrives.
+      try {
+        await addPack(CORE_SOURCE, { only: fromPack });
+      } catch (err) {
+        console.log(
+          `\nWarning: could not fetch the policy pack (${err instanceof Error ? err.message : String(err)}).\n` +
+            `Run \`failproofai policies add core\` once you are online.`,
+        );
+      }
+    } else {
+      for (const name of fromPack) {
+        for (const pack of readInstalledPacks().packs) {
+          if (pack.policies.some((p) => p.name === name)) {
+            setPackPolicyEnabled(pack.id, name, true);
+            break;
+          }
+        }
+      }
+    }
+  }
   console.log(`\nEnabled ${selectedPolicies.length} policy(ies): ${selectedPolicies.join(", ")}\n`);
   if (removeCustomHooks) {
     console.log("Custom hooks path cleared.");
@@ -434,7 +667,18 @@ export async function removeHooks(policyNames?: string[], scope: HookScope | "al
 
   // Remove specific policies from config (keep hooks installed)
   if (policyNames && policyNames.length > 0 && !(policyNames.length === 1 && policyNames[0] === "all")) {
-    validatePolicyNames(policyNames);
+    const resolved = resolvePolicyNames(policyNames);
+    applyPackPolicies(resolved.packs, false, configScope, cwd);
+    policyNames = resolved.builtins;
+    rejectAlwaysOnPolicies(policyNames);
+    // Named ONLY pack policies: they are off now and there is nothing else to
+    // do. Falling through would reach the hook-removal path below with an empty
+    // name list, which is the "remove failproofai from every CLI" branch — so
+    // `--uninstall <a-pack-policy>` would have torn out every hook on the
+    // machine.
+    if (resolved.packs.length > 0 && policyNames.length === 0) return;
+  }
+  if (policyNames && policyNames.length > 0 && !(policyNames.length === 1 && policyNames[0] === "all")) {
     const config = readScopedHooksConfig(configScope, cwd);
     const removeSet = new Set(policyNames);
     const remaining = config.enabledPolicies.filter((p) => !removeSet.has(p));
@@ -593,135 +837,88 @@ export async function removeHooks(policyNames?: string[], scope: HookScope | "al
  */
 export async function listHooks(cwd?: string): Promise<void> {
   const config = readMergedHooksConfig(cwd);
-  const enabledSet = new Set(config.enabledPolicies);
   const disabledCustomSet = new Set(config.disabledCustomPolicies ?? []);
+  const opts = optsFor(process.stdout);
 
   // Determine which scopes have hooks installed (deduplicate when paths overlap, e.g. cwd === home)
   const uniqueScopes = deduplicateScopes(HOOK_SCOPES, cwd);
   const installedScopes = uniqueScopes.filter((s) => hooksInstalledInSettings(s, cwd));
 
-  // Separate beta from regular policies
-  const regularPolicies = BUILTIN_POLICIES.filter((p) => !p.beta);
-  const betaPolicies = BUILTIN_POLICIES.filter((p) => p.beta);
-
-  // Dynamic name column width based on longest policy name
-  const nameColWidth = Math.max(...BUILTIN_POLICIES.map((p) => p.name.length)) + 2;
-
-  // All known builtin policy names (for unknown policyParams key detection)
-  const builtinPolicyNames = new Set(BUILTIN_POLICIES.map((p) => p.name));
-
-  // Helper: print params summary lines beneath a policy row
-  const printParamsSummary = (policyName: string, indent: string) => {
-    const params = config.policyParams?.[policyName];
-    if (!params) return;
-    for (const [key, val] of Object.entries(params)) {
-      console.log(`${indent}  ${key}: ${JSON.stringify(val)}`);
+  // Names a `policyParams` key may legitimately use: every policy an installed
+  // pack carries. Previously the compiled catalog, which no longer describes
+  // what runs.
+  const knownPolicyNames = new Set<string>();
+  try {
+    for (const pack of readInstalledPacks().packs) {
+      for (const policy of pack.policies) knownPolicyNames.add(policy.name);
     }
-  };
+  } catch {
+    // Unreadable manifest: skip the typo warning rather than invent one.
+  }
 
-  const statusCol = 8;
-  const printSimpleRow = (policy: { name: string; description: string }) => {
-    const mark = enabledSet.has(policy.name) ? `\x1B[32m\u2713\x1B[0m` : " ";
-    console.log(`  ${mark}${" ".repeat(statusCol - 1)}${policy.name.padEnd(nameColWidth)}${policy.description}`);
-    printParamsSummary(policy.name, `  ${" ".repeat(statusCol)}`);
-  };
-  const printBetaSection = (printRow: (p: { name: string; description: string }) => void) => {
-    if (betaPolicies.length > 0) {
-      console.log(`\n  \x1B[2m\u2500\u2500 Beta \u2500\u2500\x1B[0m`);
-      for (const policy of betaPolicies) printRow(policy);
+  const groups: Array<string[] | null> = [];
+  const packCount = (() => {
+    try {
+      return readInstalledPacks().packs.reduce(
+        (n, pack) => n + (pack.enabled ?? pack.policies.map((p) => p.name)).length,
+        0,
+      );
+    } catch {
+      return 0;
     }
-  };
+  })();
+  groups.push(
+    title(
+      "failproofai policies",
+      installedScopes.length === 0
+        ? "not installed"
+        : `${installedScopes.join(" + ")} · ${packCount} on`,
+      opts,
+    ),
+  );
 
   if (installedScopes.length === 0) {
-    // State A: No hooks installed — show table with configured state + descriptions
-    console.log("\nFailproof AI Policies \u2014 not installed\n");
-
-    console.log(`  ${"Status".padEnd(statusCol)}${"Name".padEnd(nameColWidth)}Description`);
-    console.log(`  ${"\u2500".repeat(6)}  ${"\u2500".repeat(nameColWidth - 2)}  ${"\u2500".repeat(38)}`);
-
-    for (const policy of regularPolicies) printSimpleRow(policy);
-    printBetaSection(printSimpleRow);
-
-    if (config.enabledPolicies.length > 0) {
-      console.log("\n  Policies not installed. Run `failproofai policies --install` to activate.");
-    } else {
-      console.log("\n  Run `failproofai policies --install` to get started.");
-    }
-    console.log(`  Config: ${globalPolicyConfigFile()}\n`);
-  } else if (installedScopes.length === 1) {
-    // State B: Single scope — table with header row
-    const scope = installedScopes[0];
-    console.log(`\nFailproof AI Hook Policies (${scope})\n`);
-
-    console.log(`  ${"Status".padEnd(statusCol)}${"Name".padEnd(nameColWidth)}Description`);
-    console.log(`  ${"\u2500".repeat(6)}  ${"\u2500".repeat(nameColWidth - 2)}  ${"\u2500".repeat(38)}`);
-
-    for (const policy of regularPolicies) printSimpleRow(policy);
-    printBetaSection(printSimpleRow);
-
-    console.log(`\n  Config: ${globalPolicyConfigFile()}\n`);
-  } else {
-    // State C: Multiple scopes — column table
-    const COL = 9;
-    const scopeLabelMap: Record<HookScope, string> = {
-      user: "User",
-      project: "Project",
-      local: "Local",
-    };
-
-    console.log("\nFailproof AI Hook Policies\n");
-
-    // Header with only installed scope columns + separator
-    const buildScopePrefix = () => {
-      let s = "  ";
-      for (const sc of installedScopes) s += scopeLabelMap[sc].padEnd(COL);
-      return s;
-    };
-    const scopeHeaderWidth = installedScopes.length * COL;
-    console.log(`${buildScopePrefix()}${"Name".padEnd(nameColWidth)}Description`);
-    console.log(`  ${"\u2500".repeat(scopeHeaderWidth)}${"\u2500".repeat(nameColWidth)}${"\u2500".repeat(38)}`);
-
-    const printMultiScopeRow = (policy: { name: string; description: string }) => {
-      const enabled = enabledSet.has(policy.name);
-      let row = "  ";
-      for (const _scope of installedScopes) {
-        if (enabled) {
-          row += `\x1B[32m\u2713 ON\x1B[0m` + " ".repeat(COL - 4);
-        } else {
-          row += "  OFF" + " ".repeat(COL - 5);
-        }
-      }
-      row += policy.name.padEnd(nameColWidth) + policy.description;
-      console.log(row);
-      printParamsSummary(policy.name, `  ${" ".repeat(scopeHeaderWidth)}`);
-    };
-
-    for (const policy of regularPolicies) printMultiScopeRow(policy);
-
-    if (betaPolicies.length > 0) {
-      console.log(`\n  \x1B[2m\u2500\u2500 Beta \u2500\u2500\x1B[0m`);
-      for (const policy of betaPolicies) printMultiScopeRow(policy);
-    }
-
-    console.log(`\n  Config: ${globalPolicyConfigFile()}`);
-
-    // Multi-scope warning
-    const scopeNames = installedScopes.join(", ");
-    console.log();
-    console.log(`\x1B[33m\u26A0 Hooks in multiple scopes (${scopeNames}).\x1B[0m`);
-    console.log("  Consider keeping one. Remove with: failproofai policies --uninstall --scope <scope>\n");
+    groups.push(
+      nextStep(
+        "failproofai policies --install",
+        config.enabledPolicies.length > 0
+          ? "These are configured but NOT installed — no hook is running them:"
+          : "Nothing is installed yet. Get started with:",
+        opts,
+      ),
+    );
+  }
+  // Held back to the end rather than printed here. Everything below this point
+  // is another section of the same listing, and a footer in the middle of it
+  // reads as the end of the output — while a warning at the very end is the one
+  // a reader scrolling back from their prompt actually sees.
+  const footer: Array<string[] | null> = [note(`Config: ${globalPolicyConfigFile()}`, opts)];
+
+  if (installedScopes.length > 1) {
+    footer.push(
+      warning(
+        [
+          `Hooks in multiple scopes (${installedScopes.join(", ")}).`,
+          "Consider keeping one. Remove with: failproofai policies --uninstall --scope <scope>",
+        ],
+        opts,
+      ),
+    );
   }
 
   // Warn about unknown policyParams keys
   if (config.policyParams) {
     const unknownKeys: string[] = [];
     for (const key of Object.keys(config.policyParams)) {
-      if (!builtinPolicyNames.has(key)) {
-        console.log(`  \x1B[33mWarning: unknown policyParams key "${key}" — possible typo\x1B[0m`);
-        unknownKeys.push(key);
-      }
+      if (knownPolicyNames.size > 0 && !knownPolicyNames.has(key)) unknownKeys.push(key);
     }
     if (unknownKeys.length > 0) {
+      footer.push(
+        warning(
+          unknownKeys.map((key) => `unknown policyParams key "${key}" — possible typo`),
+          opts,
+        ),
+      );
       try {
         await trackHookEvent(getInstanceId(), "policy_params_validation_warning", {
           unknown_keys_count: unknownKeys.length,
@@ -734,30 +931,38 @@ export async function listHooks(cwd?: string): Promise<void> {
   // Explicit Custom Policies section
   const explicitPaths = configuredCustomPolicyPaths(config);
   if (explicitPaths.length > 0) {
-    console.log(`\n  \u2500\u2500 Custom Policies \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    groups.push(rule("Custom Policies", opts));
     for (const path of explicitPaths) {
       // Enforcement resolves configured paths from the project config root.
       // Use the same canonical path here so the ID checked by the CLI exactly
       // matches the ID written by the dashboard.
       const absPath = resolve(findProjectConfigDir(cwd ?? process.cwd()), path);
-      console.log(`  ${absPath}`);
+      groups.push(note(absPath, opts));
       if (!existsSync(absPath)) {
-        console.log(`  \x1B[31m\u2717 File not found: ${absPath}\x1B[0m`);
+        groups.push(warning([`file not found: ${absPath}`], opts));
         continue;
       }
       const hooks = await loadCustomHooks(absPath);
       if (hooks.length === 0) {
-        console.log(`  \x1B[31m\u2717 ERR  failed to load (check ~/.failproofai/logs/hooks.log)\x1B[0m`);
+        groups.push(
+          warning(["failed to load (check ~/.failproofai/logs/hooks.log)"], opts),
+        );
       } else {
-        const descColWidth = nameColWidth;
-        for (const hook of hooks) {
-          const disabled = disabledCustomSet.has(`custom:${absPath}:${hook.name}`);
-          const status = disabled ? "\x1B[2m  OFF\x1B[0m" : "\x1B[32m\u2713 ON\x1B[0m";
-          console.log(`  ${status}    ${hook.name.padEnd(descColWidth)}${hook.description ?? ""}`);
-        }
+        groups.push(
+          table(
+            {
+              head: ["", "Name", "Description"],
+              rows: hooks.map((hook) => [
+                chip(disabledCustomSet.has(`custom:${absPath}:${hook.name}`) ? "off" : "on", opts),
+                hook.name,
+                hook.description ?? "",
+              ]),
+            },
+            opts,
+          ),
+        );
       }
     }
-    console.log();
   }
 
   // Convention Policies section (.failproofai/policies/*policies.{js,mjs,ts})
@@ -801,43 +1006,82 @@ export async function listHooks(cwd?: string): Promise<void> {
       for (const t of targets) discovered[t].push({ file, hooks });
     };
 
-    console.log(`\n  \u2500\u2500 Convention Policies \u2014 ${label} (${dir}) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
-    // `nameColWidth` is sized to the longest BUILTIN name, but a convention
-    // filename can be longer \u2014 `padEnd` is then a no-op and the hook count runs
-    // straight into the filename with no space
-    // (`enforce-bengaluru-event-links-policies.mjs1 hook(s)`). Widen to fit the
-    // files actually being printed, keeping a two-space gutter.
-    const colWidth = Math.max(nameColWidth, ...files.map((f) => basename(f).length + 2));
+    groups.push(rule(`Convention Policies — ${label}`, opts));
+    groups.push(note(dir, opts));
+    const rows: TableRow[] = [];
     for (const file of files) {
+      const filename = basename(file);
       try {
         const hooks = await loadCustomHooks(file);
-        const filename = basename(file);
         record(filename, hooks.map((h) => h.name));
         if (hooks.length === 0) {
-          console.log(`  \x1B[31m\u2717\x1B[0m       ${filename.padEnd(colWidth)}\x1B[31mfailed to load\x1B[0m`);
-        } else {
-          const hookStates = hooks.map((hook) => ({
-            hook,
-            disabled: disabledCustomSet.has(`convention:${policyScope}:${filename}:${hook.name}`),
-          }));
-          const disabledCount = hookStates.filter((entry) => entry.disabled).length;
-          const status = disabledCount === 0
-            ? "\x1B[32m\u2713 ON\x1B[0m"
-            : disabledCount === hooks.length
-              ? "\x1B[2m  OFF\x1B[0m"
-              : "\x1B[33m\u25D0 MIXED\x1B[0m";
-          const hookSummary = hookStates
-            .map(({ hook, disabled }) => `${hook.name}${disabled ? " (OFF)" : ""}`)
-            .join(", ");
-          console.log(`  ${status}    ${filename.padEnd(colWidth)}${hooks.length} hook(s): ${hookSummary}`);
+          rows.push({ cells: [chip("failed", opts), filename, "failed to load"] });
+          continue;
         }
+        const hookStates = hooks.map((hook) => ({
+          hook,
+          disabled: disabledCustomSet.has(`convention:${policyScope}:${filename}:${hook.name}`),
+        }));
+        const disabledCount = hookStates.filter((entry) => entry.disabled).length;
+        const state: ChipState =
+          disabledCount === 0 ? "on" : disabledCount === hooks.length ? "off" : "mixed";
+        const hookSummary = hookStates
+          .map(({ hook, disabled }) => `${hook.name}${disabled ? " (OFF)" : ""}`)
+          .join(", ");
+        rows.push({
+          cells: [chip(state, opts), filename, `${hooks.length} hook(s): ${hookSummary}`],
+        });
       } catch {
-        const filename = basename(file);
         record(filename, []);
-        console.log(`  \x1B[31m\u2717\x1B[0m       ${filename.padEnd(colWidth)}\x1B[31merror\x1B[0m`);
+        rows.push({ cells: [chip("failed", opts), filename, "error"] });
       }
     }
-    console.log();
+    groups.push(table({ head: ["", "File", "Hooks"], rows }, opts));
+  }
+
+  // Installed packs. They enforce on this machine exactly like every section
+  // above, and until now the only way to see one was `failproofai policies` —
+  // so the command that answers "what is enforcing here?" answered it with a
+  // subset, for the one source a person had to go out of their way to install.
+  try {
+    const { packs, errors } = readInstalledPacks();
+    for (const pack of packs) {
+      const taken = pack.enabled ?? pack.policies.map((p) => p.name);
+      groups.push(rule(`Pack — ${pack.id}@${pack.version}`, opts));
+      groups.push(
+        table(
+          {
+            head: ["", "Name", "Description"],
+            rows: pack.policies.map((policy) => {
+              const disabled = disabledCustomSet.has(
+                `pack:${pack.id}@${pack.version}:${policy.name}`,
+              );
+              // `observe` evaluates and discards its verdict, so a row reading
+              // ON would claim enforcement the pack deliberately is not doing.
+              const state: ChipState =
+                pack.effect === "observe"
+                  ? "observe"
+                  : !taken.includes(policy.name) || disabled
+                    ? "off"
+                    : "pack";
+              return [chip(state, opts), policy.name, policy.description];
+            }),
+          },
+          opts,
+        ),
+      );
+    }
+    if (errors.length > 0) {
+      groups.push(
+        warning(
+          errors.map((err) => `pack ${err.id ?? "(unnamed)"} will not load: ${err.reason}`),
+          opts,
+        ),
+      );
+    }
+  } catch {
+    // Same rule as the cloud section below: a listing must not be the thing
+    // that turns an unreadable manifest into a broken command.
   }
 
   // Cloud-managed policies. These enforce on this machine exactly like the two
@@ -852,21 +1096,27 @@ export async function listHooks(cwd?: string): Promise<void> {
   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`,
+      groups.push(rule(`Cloud-managed — deployment ${cloud[0].deployment}`, opts));
+      groups.push(
+        table(
+          {
+            head: ["", "Policy", "Version"],
+            rows: cloud.map((artifact) => [
+              // `observe` is evaluated and then has its verdict discarded, so a
+              // row that read "ON" would claim enforcement this policy
+              // deliberately is not doing.
+              chip(artifact.effect === "observe" ? "observe" : "cloud", opts),
+              artifact.id,
+              `v${artifact.version}`,
+            ]),
+            flex: 1,
+          },
+          opts,
+        ),
+      );
+      groups.push(
+        note("Managed from the dashboard — not switchable with `failproofai policies`.", opts),
       );
-      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
@@ -874,6 +1124,8 @@ export async function listHooks(cwd?: string): Promise<void> {
     // the thing that turns a bad manifest into a broken command.
   }
 
+  printBlock(process.stdout, stack(...groups, ...footer));
+
   // 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).