portable-agent-layer 0.90.0 → 0.91.1

package/src/cli/index.ts

@@ -35,8 +35,8 @@ import { palHome, palPkg, paths, platform, toPath } from "../hooks/lib/paths";
 import { log, narrateSteps } from "../targets/lib";
 import { helpText, runCommand } from "../tools/lib/command";
 import { type DoctorResult, detectAgents } from "./doctor/agents";
-import { installChromium } from "./doctor/environment";
 import { runDoctor } from "./doctor/run";
+import type { InstallPlan } from "./install-flow";
 import { findSessionAgent, NO_SESSION_AGENT_MESSAGE } from "./session-agent";
 import { cliTree, type DebugState } from "./tree";
 
@@ -45,7 +45,7 @@ const CLI_PATH = ["pal", "cli"];
 const tree = cliTree({
   init: ({ argv }) => init(argv),
   install: async ({ argv }) => {
-    banner();
+    narrateSteps(argv.includes("--verbose"));
     process.exit(await install(resolveTargets(argv), argv));
   },
   uninstall: ({ argv }) => uninstall(argv),
@@ -153,14 +153,6 @@ async function doctor(args: string[]): Promise<never> {
 
 // ── Helpers ──
 
-function banner() {
-  console.log("");
-  console.log("  ╔═══════════════════════════════════╗");
-  console.log("  ║  PAL — Portable Agent Layer       ║");
-  console.log("  ╚═══════════════════════════════════╝");
-  console.log("");
-}
-
 function showHelp() {
   console.log(
     `Usage: pal [agent-args...]\n\n  Start the first installed agent, passing the arguments on\n\n${helpText(tree, CLI_PATH)}`
@@ -268,42 +260,27 @@ async function probeInference(): Promise<void> {
 
 // ── Commands ──
 
-async function init(args: string[]) {
+/**
+ * memory/state is scaffolded here, not left to generateSkillIndex: that returns
+ * early when ~/.pal/skills is absent, so an init that installs no skills would
+ * leave every writer of memory/state with nowhere to write.
+ */
+async function createPalHome(): Promise<void> {
   const { scaffoldTelos } = await import("../targets/lib");
-
-  banner();
-  narrateSteps(args.includes("--verbose"));
-
-  const health = detectAgents();
-  if (!health.hasAgent) process.exit(runDoctor([], health));
-
   const home = palHome();
-  log.info(`Creating PAL home at ${home}`);
   mkdirSync(resolve(home, "telos"), { recursive: true });
-  mkdirSync(resolve(home, "memory"), { recursive: true });
-  // Scaffolded here, not left to generateSkillIndex: that returns early when
-  // ~/.pal/skills is absent, so an init that installs no skills would leave
-  // every writer of memory/state with nowhere to write.
   mkdirSync(resolve(home, "memory", "state"), { recursive: true });
-
   scaffoldTelos();
-
-  // Auto-detect available targets
-  const targets = resolveTargets(args, health);
-  process.exit(await install(targets, args));
 }
 
-/**
- * Run a setup subprocess, showing its output only when it fails.
- *
- * These are idempotent and usually report "no changes", so their banners are
- * pure noise on a re-install — but the moment one fails, the reason it gives
- * is the only thing that explains the warning.
- */
-function runQuietly(cmd: string, args: string[], cwd: string): number | null {
-  const r = spawnSync(cmd, args, { cwd, encoding: "utf-8", shell: true });
-  if (r.status !== 0) process.stderr.write((r.stdout ?? "") + (r.stderr ?? ""));
-  return r.status;
+async function init(args: string[]) {
+  narrateSteps(args.includes("--verbose"));
+  const health = detectAgents();
+  if (!health.hasAgent) process.exit(runDoctor([], health));
+  const targets = resolveTargets(args, health);
+  process.exit(
+    await install(targets, args, { kind: "init", prepareHome: createPalHome })
+  );
 }
 
 function targetScripts(): Record<
@@ -338,91 +315,28 @@ function targetScripts(): Record<
   };
 }
 
-function targetInstallers(): [AgentName, string, () => Promise<unknown>][] {
-  return AGENT_NAMES.map((agent) => [
-    agent,
-    AGENT_REGISTRY[agent].label,
-    targetScripts()[agent].install,
-  ]);
-}
-
-async function install(targets: Targets, args: string[]): Promise<number> {
-  narrateSteps(args.includes("--verbose"));
-  const pkg = palPkg();
-  const { dependencyInstall } = await import("./dependencies");
-  const { isRepoMode } = await import("../hooks/handlers/update-check");
-  const bunInstall = dependencyInstall(pkg, isRepoMode());
-  if (bunInstall && runQuietly("bun", bunInstall, pkg) !== 0) {
-    log.warn("bun install failed — continuing anyway, but hooks may not work");
-  }
-
-  const { applyPendingMigrations } = await import("./migrate");
-  for (const line of applyPendingMigrations()) log.info(line);
-
-  // Uses `bun x` (not `bunx`) for Windows compatibility — bunx resolves unreliably under cmd.exe.
-  if (process.env.PAL_SKIP_BROWSER_INSTALL !== "1") installChromium();
-
-  // Scaffold TELOS + PAL settings, then prompt for missing identity
-  const { scaffoldTelos, scaffoldPalSettings, copyPalDocs, generateSkillIndex } =
-    await import("../targets/lib");
-  const { promptIdentity } = await import("./setup-identity");
-  const { promptAttribution } = await import("./setup-attribution");
-  const { promptAutoUpdate } = await import("./setup-auto-update");
-  scaffoldTelos();
-  scaffoldPalSettings();
-  await promptIdentity();
-  await promptAttribution();
-  await promptAutoUpdate();
-
-  // Registers the label loadActor derives, so it travels on the next export.
-  const { ensureActorRegistered } = await import("../hooks/lib/actor");
-  ensureActorRegistered();
-
-  // Shared, target-independent state. Every target installer used to repeat these
-  // identical calls; AGENTS.md in particular must exist before any target symlinks
-  // to it, so it runs once here rather than once per target.
-  const { regenerateIfNeeded } = await import("../hooks/lib/claude-md");
-  const palDocsCount = copyPalDocs();
-  regenerateIfNeeded();
-
-  for (const [target, label, installTarget] of targetInstallers()) {
-    if (!targets[target]) continue;
-    log.heading(label);
-    await installTarget();
-  }
-
-  // The rest of the shared work reads what the installers just wrote: the index
-  // walks ~/.pal/skills, and the digests land in ~/.cursor/rules and
-  // ~/.copilot/instructions and the Antigravity plugin's rules/, which are skipped
-  // when the agent's home is absent.
-  const { writeContextDigests } = await import("../hooks/handlers/context-digests");
-  const indexedSkills = generateSkillIndex();
-  writeContextDigests();
-  log.success(
-    `Shared: ${indexedSkills} skills indexed · ${palDocsCount} docs → ~/.pal/docs/ · AGENTS.md + context digests written`
-  );
-
-  await refreshControlRoom();
-
-  if (args.includes("--verbose")) console.log("");
-  return runDoctor(args);
+function targetInstallers(): Record<AgentName, () => Promise<unknown>> {
+  return Object.fromEntries(
+    AGENT_NAMES.map((agent) => [agent, targetScripts()[agent].install])
+  ) as Record<AgentName, () => Promise<unknown>>;
 }
 
-/**
- * A published install carries the page in its tarball; a checkout does not —
- * ui/dist is gitignored, so a pull leaves whatever was built last. Rebuild
- * there, then replace the process, because the API is the running code.
- */
-async function refreshControlRoom(): Promise<void> {
-  const { isRepoMode } = await import("../hooks/handlers/update-check");
-  const { buildPage } = await import("../tools/control-room/static");
-  if (isRepoMode() && !buildPage()) {
-    log.warn("Control room page could not be rebuilt — run: bun run build:ui");
-    return;
-  }
-
-  const { restartIfRunning } = await import("./server");
-  if (await restartIfRunning()) log.success("Control room restarted on the new build");
+async function install(
+  targets: Targets,
+  args: string[],
+  plan: Pick<InstallPlan, "kind" | "prepareHome"> = { kind: "install" }
+): Promise<number> {
+  const { runInstall } = await import("./install-flow");
+  const updatedFrom = process.env.PAL_UPDATED_FROM;
+  return runInstall({
+    ...plan,
+    kind: updatedFrom ? "update" : plan.kind,
+    agents: AGENT_NAMES.filter((agent) => targets[agent]),
+    installers: targetInstallers(),
+    verbose: args.includes("--verbose"),
+    version: packageVersion(),
+    updatedFrom,
+  });
 }
 
 async function uninstall(args: string[]) {
@@ -643,50 +557,17 @@ async function update() {
   const { checkForUpdate, clearUpdateCache } = await import(
     "../hooks/handlers/update-check"
   );
-  const result = await checkForUpdate(true);
-
-  log.info(`Current: ${result.current} (${result.mode} mode)`);
-
-  if (!result.available) {
-    log.success("Already up to date.");
-    return;
-  }
-
-  log.info(`Available: ${result.latest}`);
-
-  const pkg = palPkg();
-  if (result.mode === "repo") {
-    log.info("Pulling updates...");
-    const pull = spawnSync("git", ["pull", "--ff-only"], { cwd: pkg, stdio: "inherit" });
-    if (pull.status !== 0) {
-      log.error("git pull failed. You may have local changes — try pulling manually.");
-      process.exit(1);
-    }
-  } else {
-    log.info("Updating via bun...");
-    const up = spawnSync("bun", ["add", "-g", `portable-agent-layer@${result.latest}`], {
-      stdio: "inherit",
-    });
-    if (up.status !== 0) {
-      log.error(`Update failed. Try: bun add -g portable-agent-layer@${result.latest}`);
-      process.exit(1);
-    }
-  }
-
-  let newPkg: { version: string };
-  try {
-    newPkg = JSON.parse(readFileSync(resolve(pkg, "package.json"), "utf-8")) as {
-      version: string;
-    };
-  } catch (e) {
-    throw new Error(`Failed to read updated package.json: ${e}`);
-  }
-  log.success(`Updated: ${result.current} → ${newPkg.version}`);
-  clearUpdateCache();
-
-  log.info("Reinstalling...");
   const { reinstallInFreshProcess } = await import("./reinstall");
-  process.exit(reinstallInFreshProcess());
+  const { runUpdate } = await import("./update-flow");
+  process.exit(
+    await runUpdate({
+      check: () => checkForUpdate(true),
+      reinstall: (env) => {
+        clearUpdateCache();
+        return reinstallInFreshProcess(process.argv[1], env);
+      },
+    })
+  );
 }
 
 function cliDebug(state: DebugState) {

package/src/cli/install-flow.ts

@@ -0,0 +1,331 @@
+/**
+ * `pal cli init`, `install` and the reinstall that ends `update`: one rail of
+ * steps, each settling into a line that says what it did, then the doctor's verdict.
+ */
+
+import { spawn } from "node:child_process";
+import { AGENT_REGISTRY, type AgentName } from "../hooks/lib/agent-registry";
+import { palHome, palPkg } from "../hooks/lib/paths";
+import { raw as readSettings } from "../hooks/lib/settings";
+import { capturingLog, type LogLevel, narrateSteps } from "../targets/lib";
+import { agentInventory, detectAgents } from "./doctor/agents";
+import {
+  type DoctorReport,
+  doctorExitCode,
+  plainProblemLines,
+  plainSummary,
+  problemLines,
+  tally,
+} from "./doctor/render";
+import { doctorReport } from "./doctor/run";
+import { banner } from "./ui/banner";
+import { type Done, LiveRail, type Note } from "./ui/live";
+import { box, healthBadge, mark, railEnd, railGap, railNote, railTop } from "./ui/rail";
+import { createStyle, homeShortened, PALETTE, type Style } from "./ui/style";
+import { whatsNew } from "./whats-new";
+
+type InstallKind = "init" | "install" | "update";
+
+export interface InstallPlan {
+  kind: InstallKind;
+  agents: AgentName[];
+  installers: Record<AgentName, () => Promise<unknown>>;
+  verbose: boolean;
+  version: string;
+  updatedFrom?: string;
+  prepareHome?: () => Promise<void>;
+}
+
+export interface Captured {
+  code: number;
+  output: string;
+}
+
+export function runCaptured(
+  cmd: string,
+  args: string[],
+  cwd?: string
+): Promise<Captured> {
+  return new Promise((done) => {
+    const child = spawn(cmd, args, { cwd, shell: true });
+    let output = "";
+    const collect = (chunk: Buffer) => {
+      output += chunk.toString();
+    };
+    child.stdout?.on("data", collect);
+    child.stderr?.on("data", collect);
+    child.on("error", (error) => done({ code: 1, output: error.message }));
+    child.on("close", (code) => done({ code: code ?? 1, output }));
+  });
+}
+
+function lastLines(output: string, count = 4): Note[] {
+  return output
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .slice(-count)
+    .map((text) => ({ level: "info", text }));
+}
+
+const labelOf = (agent: AgentName) => AGENT_REGISTRY[agent].label;
+
+function plural(count: number, noun: string): string {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+
+function openRail(rail: LiveRail, style: Style, plan: InstallPlan): void {
+  if (plan.kind === "update") return;
+  if (!style.term.rich) {
+    rail.line(`PAL ${plan.version} ${plan.kind}`);
+    return;
+  }
+  for (const line of banner(style, plan.version)) rail.line(line);
+  const title =
+    plan.kind === "init"
+      ? "Setting up PAL"
+      : `Installing into ${plural(plan.agents.length, "agent")}`;
+  rail.line(railTop(style, title));
+  rail.line(railGap(style));
+  if (plan.kind !== "init") return;
+  const found = plan.agents.map(labelOf).join(` ${style.glyph.dot} `);
+  rail.line(
+    `${mark(style, "info")}  Found ${plural(plan.agents.length, "agent")}  ${style.soft(found)}`
+  );
+  rail.line(railGap(style));
+}
+
+async function installDependencies(): Promise<Done | null> {
+  const { dependencyInstall } = await import("./dependencies");
+  const { isRepoMode } = await import("../hooks/handlers/update-check");
+  const args = dependencyInstall(palPkg(), isRepoMode());
+  if (!args) return null;
+  const run = await runCaptured("bun", args, palPkg());
+  if (run.code === 0)
+    return /no changes/.test(run.output) ? null : { detail: ["installed"] };
+  return {
+    detail: ["bun install failed"],
+    notes: [
+      { level: "warn", text: "continuing anyway, but hooks may not work" },
+      ...lastLines(run.output),
+    ],
+  };
+}
+
+async function applyMigrations(): Promise<Done | null> {
+  const { applyPendingMigrations } = await import("./migrate");
+  const lines = applyPendingMigrations();
+  if (lines.length === 0) return null;
+  return {
+    detail: [`${plural(lines.length, "change")} applied`],
+    notes: lines.map((text) => ({ level: "info", text })),
+  };
+}
+
+async function downloadChromium(): Promise<Done | null> {
+  if (process.env.PAL_SKIP_BROWSER_INSTALL === "1") return null;
+  const { installChromium } = await import("./doctor/environment");
+  const installed = await installChromium();
+  if (installed === null) return null;
+  return { detail: [installed ? "installed for screenshots" : "download failed"] };
+}
+
+async function askSetupQuestions(): Promise<boolean> {
+  const { scaffoldTelos, scaffoldPalSettings } = await import("../targets/lib");
+  const { promptIdentity } = await import("./setup-identity");
+  const { promptAttribution } = await import("./setup-attribution");
+  const { promptAutoUpdate } = await import("./setup-auto-update");
+  scaffoldTelos();
+  scaffoldPalSettings();
+  const asked = [
+    await promptIdentity(),
+    await promptAttribution(),
+    await promptAutoUpdate(),
+  ];
+  const { ensureActorRegistered } = await import("../hooks/lib/actor");
+  ensureActorRegistered();
+  return asked.some(Boolean);
+}
+
+function noteFor(level: LogLevel, message: string, verbose: boolean): Note | null {
+  const text = homeShortened(message);
+  if (level === "warn") return { level: "warn", text };
+  if (level === "error") return { level: "fail", text };
+  return verbose ? { level: "info", text } : null;
+}
+
+async function runInstaller(plan: InstallPlan, agent: AgentName, notes: Note[]) {
+  await capturingLog((level, message) => {
+    const note = noteFor(level, message, plan.verbose);
+    if (note) notes.push(note);
+  }, plan.installers[agent]);
+}
+
+async function installOne(plan: InstallPlan, agent: AgentName): Promise<Done> {
+  const notes: Note[] = [];
+  await runInstaller(plan, agent, notes);
+  return { detail: agentInventory(agent), notes };
+}
+
+async function installAll(plan: InstallPlan): Promise<Done> {
+  const notes: Note[] = [];
+  for (const agent of plan.agents) await runInstaller(plan, agent, notes);
+  return { detail: plan.agents, notes };
+}
+
+async function prepareShared(): Promise<number> {
+  const { copyPalDocs } = await import("../targets/lib");
+  const { regenerateIfNeeded } = await import("../hooks/lib/claude-md");
+  const docs = copyPalDocs();
+  regenerateIfNeeded();
+  return docs;
+}
+
+async function finishShared(docs: number): Promise<Done> {
+  const { generateSkillIndex } = await import("../targets/lib");
+  const { writeContextDigests } = await import("../hooks/handlers/context-digests");
+  const skills = generateSkillIndex();
+  writeContextDigests();
+  return {
+    detail: [`${plural(skills, "skill")} indexed`, plural(docs, "doc"), "digests"],
+  };
+}
+
+/**
+ * A published install carries the page in its tarball; a checkout does not —
+ * ui/dist is gitignored, so a pull leaves whatever was built last. Rebuild
+ * there, then replace the process, because the API is the running code.
+ */
+async function refreshControlRoom(): Promise<Done | null> {
+  const { isRepoMode } = await import("../hooks/handlers/update-check");
+  const { buildPage } = await import("../tools/control-room/static");
+  const rebuilt = isRepoMode() ? buildPage() : null;
+  if (rebuilt === false)
+    return {
+      detail: ["page not rebuilt"],
+      notes: [{ level: "warn", text: "run: bun run build:ui" }],
+    };
+  const { restartIfRunning } = await import("./server");
+  const restarted = await restartIfRunning();
+  const detail = [rebuilt ? "page rebuilt" : "", restarted ? "restarted" : ""].filter(
+    Boolean
+  );
+  return detail.length > 0 ? { detail } : null;
+}
+
+function truncated(text: string, width: number): string {
+  return [...text].length <= width ? text : `${[...text].slice(0, width - 1).join("")}…`;
+}
+
+export function notesLink(url: string, more: number, width: number): [string, string] {
+  const label = more > 0 ? `${more} more:` : "all notes:";
+  const room = width - label.length - 3;
+  const short =
+    url.length <= room ? url : url.replace(/github\.com\/[^/]+\/[^/]+/, "github.com/…");
+  return [label, short];
+}
+
+async function showWhatsNew(rail: LiveRail, style: Style, from: string, to: string) {
+  const news = await whatsNew(from, to);
+  if (!news) return;
+  const width = Math.max(30, style.term.width - 6);
+  if (!style.term.rich) {
+    for (const item of news.items) rail.line(`new  ${item}`);
+    rail.line(`notes ${news.url}`);
+    return;
+  }
+  const [label, url] = notesLink(news.url, news.more, width);
+  rail.line(railGap(style));
+  const heading = `What's new in ${to.replace(/\.0$/, "")}`;
+  rail.line(`${mark(style, "info")}  ${style.bold(heading)}`);
+  for (const item of news.items)
+    rail.line(
+      railNote(
+        style,
+        `${style.paint(PALETTE.violet, style.glyph.sparkle)} ${truncated(item, width)}`
+      )
+    );
+  const lead = style.dim(`${style.glyph.arrow} ${label}`);
+  rail.line(railNote(style, `${lead} ${style.cmd(url)}`));
+}
+
+function closeRail(rail: LiveRail, style: Style, report: DoctorReport | null): void {
+  if (!report) {
+    rail.line(style.term.rich ? railEnd(style, style.soft("Installed")) : "installed");
+    return;
+  }
+  const t = tally(report.findings);
+  if (!style.term.rich) {
+    for (const line of [...plainProblemLines(t), plainSummary(t)]) rail.line(line);
+    return;
+  }
+  const count = { fails: t.fails.length, warns: t.warns.length };
+  rail.line(railGap(style));
+  const passedCount = style.soft(`${plural(t.passes.length, "check")} passed`);
+  rail.line(railEnd(style, `${healthBadge(style, count)}  ${passedCount}`));
+  const problems = problemLines(style, t, "   ");
+  rail.line();
+  for (const line of problems) rail.line(line);
+  if (problems.length > 0) rail.line();
+}
+
+function showNextSteps(rail: LiveRail, style: Style): void {
+  const who = readSettings().identity;
+  const name = who?.principal?.name ? `, ${who.principal.name}` : "";
+  const ai = who?.ai?.name || "PAL";
+  if (!style.term.rich) {
+    rail.line(
+      `Next: run pal to start your agent, ask it to "onboard me", run pal cli doctor anytime`
+    );
+    return;
+  }
+  const step = (n: string, command: string, what: string) =>
+    `${style.dim(n)}  ${style.cmd(command.padEnd(17))}${style.soft(what)}`;
+  const lines = box(style, [
+    "",
+    style.bold(style.gradient(`You're set${name}. ${ai} is ready.`)),
+    "",
+    step("1", "pal", "start your agent"),
+    step("2", '"onboard me"', "teach it your goals"),
+    step("3", "pal cli doctor", "check health anytime"),
+    "",
+  ]);
+  for (const line of lines) rail.line(line);
+  rail.line();
+}
+
+async function installAgents(rail: LiveRail, plan: InstallPlan): Promise<void> {
+  if (plan.kind === "update") {
+    await rail.step("Reinstall", "reinstalling…", () => installAll(plan));
+    return;
+  }
+  for (const agent of plan.agents)
+    await rail.step(labelOf(agent), "installing…", () => installOne(plan, agent));
+}
+
+export async function runInstall(plan: InstallPlan): Promise<number> {
+  narrateSteps(plan.verbose);
+  const style = createStyle();
+  const rail = new LiveRail(style);
+  openRail(rail, style, plan);
+  const prepareHome = plan.prepareHome;
+  if (prepareHome)
+    await rail.step("PAL home", "creating…", async () => {
+      await prepareHome();
+      return { detail: [homeShortened(palHome()), "TELOS scaffolded"] };
+    });
+  await rail.step("Dependencies", "installing…", installDependencies);
+  await rail.step("Migrations", "applying…", applyMigrations);
+  await rail.step("Chromium", "downloading the browser…", downloadChromium);
+  if ((await askSetupQuestions()) && style.term.rich) rail.line(railGap(style));
+  const docs = await prepareShared();
+  await installAgents(rail, plan);
+  await rail.step("Shared", "indexing…", () => finishShared(docs));
+  await rail.step("Control room", "refreshing…", refreshControlRoom);
+  const report =
+    process.env.PAL_SKIP_DOCTOR === "1" ? null : doctorReport(detectAgents());
+  if (plan.updatedFrom) await showWhatsNew(rail, style, plan.updatedFrom, plan.version);
+  closeRail(rail, style, report);
+  if (plan.kind === "init") showNextSteps(rail, style);
+  return report ? doctorExitCode(report.findings) : 0;
+}

package/src/cli/reinstall.ts

@@ -5,9 +5,13 @@ import { spawnSync } from "node:child_process";
  * modules in Bun's cache, so a new installer importing a new export would bind
  * against the stale module and throw. A fresh process loads everything from disk.
  */
-export function reinstallInFreshProcess(entry: string = process.argv[1]): number {
+export function reinstallInFreshProcess(
+  entry: string = process.argv[1],
+  env: Record<string, string> = {}
+): number {
   const run = spawnSync(process.execPath, [entry, "cli", "install"], {
     stdio: "inherit",
+    env: { ...process.env, ...env },
   });
   return run.status ?? 1;
 }

package/src/cli/setup-attribution.ts

@@ -15,17 +15,16 @@ import {
 } from "../hooks/lib/settings";
 import { buildAttributionText } from "../targets/lib";
 
-/** Prompt once for git attribution opt-in. No-op if already decided or non-TTY. */
-export async function promptAttribution(): Promise<void> {
-  if (!process.stdin.isTTY) return;
+/** Prompt once for git attribution opt-in; true when it asked. */
+export async function promptAttribution(): Promise<boolean> {
+  if (!process.stdin.isTTY) return false;
 
   const settings = { ...readSettings() };
-  if (settings.attribution?.decided) return;
+  if (settings.attribution?.decided) return false;
 
   const name = identity().ai.name;
   const { commit, pr } = buildAttributionText(name);
 
-  clack.intro("Git attribution");
   clack.note(
     `commit: ${commit}\npr:     ${pr}`,
     `Credit ${name} on the commits & PRs it makes?`
@@ -36,14 +35,15 @@ export async function promptAttribution(): Promise<void> {
     initialValue: true,
   });
   if (clack.isCancel(enabled)) {
-    clack.cancel("Skipped — will ask again next time");
-    return;
+    clack.log.warn("Skipped — will ask again next time");
+    return true;
   }
 
   settings.attribution = { enabled: enabled === true, decided: true };
   writeSettings(settings);
   const state = enabled ? `${name} attribution on` : "Attribution off";
-  clack.outro(
-    `${state} ✓  ·  change later: edit pal-settings.json, then run 'pal install'`
+  clack.log.success(
+    `${state} · change later: edit pal-settings.json, then run 'pal install'`
   );
+  return true;
 }

package/src/cli/setup-auto-update.ts

@@ -21,13 +21,13 @@ function whatItDoes(): string {
     : onClose;
 }
 
-export async function promptAutoUpdate(): Promise<void> {
-  if (!process.stdin.isTTY) return;
+/** True when it asked. */
+export async function promptAutoUpdate(): Promise<boolean> {
+  if (!process.stdin.isTTY) return false;
 
   const settings = { ...readSettings() };
-  if (settings.autoUpdate?.decided) return;
+  if (settings.autoUpdate?.decided) return false;
 
-  clack.intro("Automatic updates");
   clack.note(whatItDoes(), "Keep PAL up to date on its own?");
 
   const enabled = await clack.confirm({
@@ -35,12 +35,13 @@ export async function promptAutoUpdate(): Promise<void> {
     initialValue: false,
   });
   if (clack.isCancel(enabled)) {
-    clack.cancel("Skipped — will ask again next time");
-    return;
+    clack.log.warn("Skipped — will ask again next time");
+    return true;
   }
 
   settings.autoUpdate = { enabled: enabled === true, decided: true };
   writeSettings(settings);
   const state = enabled ? "Automatic updates on" : "Automatic updates off";
-  clack.outro(`${state} ✓  ·  change later: control room → Settings → Updates`);
+  clack.log.success(`${state} · change later: control room → Settings → Updates`);
+  return true;
 }