blume 2.0.1 → 2.0.3

package/src/audit/report.ts

@@ -33,12 +33,47 @@ const TIER_FLAGS: { tier: AuditTier; flag: string }[] = [
 interface CheckRollup {
   id: CheckId;
   count: number;
+  /** Distinct affected URLs — one page can carry several findings. */
+  pages: number;
   severity: DiagnosticSeverity;
   category: AuditCategory;
   title: string;
   findings: Diagnostic[];
 }
 
+const SEVERITY_ORDER = {
+  error: 0,
+  info: 2,
+  warning: 1,
+} satisfies Record<DiagnosticSeverity, number>;
+
+/**
+ * The group's severity: the worst of its findings'. A check can downgrade a
+ * finding at runtime (an external link answering 503 is a warning, not the
+ * catalog's error), and the group's glyph must agree with the summary counts.
+ */
+const worstSeverity = (findings: Diagnostic[]): DiagnosticSeverity => {
+  let worst: DiagnosticSeverity = "info";
+  for (const finding of findings) {
+    if (SEVERITY_ORDER[finding.severity] < SEVERITY_ORDER[worst]) {
+      worst = finding.severity;
+    }
+  }
+  return worst;
+};
+
+/** The first finding per affected URL, in report order. */
+const firstPerPage = (findings: Diagnostic[]): Diagnostic[] => {
+  const seen = new Set<string | undefined>();
+  return findings.filter((finding) => {
+    if (seen.has(finding.url)) {
+      return false;
+    }
+    seen.add(finding.url);
+    return true;
+  });
+};
+
 /**
  * Group findings by check. This is the difference between a report people read
  * and one they close: 214 pages × 6 findings is an unreadable wall, but "Meta
@@ -55,22 +90,18 @@ export const rollup = (diagnostics: Diagnostic[]): CheckRollup[] => {
     }
   }
 
-  const order = {
-    error: 0,
-    info: 2,
-    warning: 1,
-  } satisfies Record<DiagnosticSeverity, number>;
   const checks = [...groups.entries()].map(([id, findings]) => {
     // SAFETY: audit findings are only ever created through `finding()`, whose
     // codes are the check catalog's ids.
     const checkId = id as CheckId;
-    const { category, severity, title } = checkMeta(checkId);
+    const { category, title } = checkMeta(checkId);
     return {
       category,
       count: findings.length,
       findings,
       id: checkId,
-      severity,
+      pages: firstPerPage(findings).length,
+      severity: worstSeverity(findings),
       title,
     };
   });
@@ -80,7 +111,7 @@ export const rollup = (diagnostics: Diagnostic[]): CheckRollup[] => {
   // and print "content" three separate times.
   const worst = new Map<AuditCategory, number>();
   for (const check of checks) {
-    const rank = order[check.severity];
+    const rank = SEVERITY_ORDER[check.severity];
     worst.set(
       check.category,
       Math.min(worst.get(check.category) ?? rank, rank)
@@ -91,7 +122,7 @@ export const rollup = (diagnostics: Diagnostic[]): CheckRollup[] => {
     (a, b) =>
       (worst.get(a.category) ?? 0) - (worst.get(b.category) ?? 0) ||
       a.category.localeCompare(b.category) ||
-      order[a.severity] - order[b.severity] ||
+      SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] ||
       b.count - a.count
   );
 };
@@ -176,14 +207,16 @@ export const formatReport = (
     }
 
     const color = SEVERITY_COLOR[group.severity];
-    const pages = `${group.count} page${group.count === 1 ? "" : "s"}`;
+    const pages = `${group.pages} page${group.pages === 1 ? "" : "s"}`;
     lines.push(
       `  ${color(`${GLYPH[group.severity]} ${group.title}`)}  ${colors.dim(pages)}`
     );
 
+    // The preview lists affected pages, each once; --verbose lists every
+    // finding, since each one's message names a different specific.
     const shown = options.verbose
       ? group.findings
-      : group.findings.slice(0, PREVIEW);
+      : firstPerPage(group.findings).slice(0, PREVIEW);
     for (const diagnostic of shown) {
       lines.push(findingLine(diagnostic, root));
       // The message names the specifics the rolled-up line can't — which target
@@ -192,16 +225,20 @@ export const formatReport = (
         lines.push(`        ${colors.dim(diagnostic.message)}`);
       }
     }
-    const hidden = group.count - shown.length;
+    const hidden = options.verbose ? 0 : group.pages - shown.length;
     if (hidden > 0) {
       lines.push(`      ${colors.dim(`… and ${hidden} more (--verbose)`)}`);
     }
 
-    // Every finding in a group shares the catalog's fix unless it overrode it,
-    // so showing the first one's is showing the group's.
-    const [first] = group.findings;
-    const fix = first?.suggestion;
-    if (fix) {
+    // Findings share the catalog's fix unless one overrode it (a navigation
+    // entry, a page generated from an API spec), so each distinct fix is
+    // printed once.
+    const fixes = new Set(
+      group.findings.flatMap((finding) =>
+        finding.suggestion ? [finding.suggestion] : []
+      )
+    );
+    for (const fix of fixes) {
       lines.push(`      ${colors.cyan(`fix: ${fix}`)}`);
     }
     lines.push("");

package/src/audit/run.ts

@@ -2,10 +2,12 @@ import { readFile } from "node:fs/promises";
 
 import pMap from "p-map";
 
-import { normalizeBasePath, withBasePath } from "../core/base-path.ts";
+import { normalizeBasePath } from "../core/base-path.ts";
+import { routeSetFor } from "../core/locale-links.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
 import type { Diagnostic } from "../core/types.ts";
 import { deployStaticDir } from "../deploy/adapter-output.ts";
+import { applyBaseToAstroRedirects } from "../deploy/redirects.ts";
 import { CHECKS } from "./catalog.ts";
 import type { CheckId } from "./catalog.ts";
 import { assetChecks } from "./checks/assets.ts";
@@ -137,6 +139,7 @@ export const runAudit = async (options: AuditOptions): Promise<AuditResult> => {
 
   const crawl = await crawlStaticDir({
     basePath,
+    deployBase: normalizeBasePath(project.config.deployment.options.base),
     manifest: project.manifest,
     staticDir,
   });
@@ -161,14 +164,15 @@ export const runAudit = async (options: AuditOptions): Promise<AuditResult> => {
     redirects: resolveRedirects(
       // Redirects are authored as if mounted at root; the built page URLs they
       // are checked against carry `basePath` (it's a real directory in the
-      // build), so both sides gain it here — mirroring what
-      // `applyBaseToAstroRedirects` does at build time. `withBasePath` is
-      // idempotent and leaves external `to` URLs untouched.
-      project.config.redirects.map((redirect) => ({
-        ...redirect,
-        from: withBasePath(basePath, redirect.from),
-        to: withBasePath(basePath, redirect.to),
-      })),
+      // build), so both sides gain it here, based exactly as the build bases
+      // them — a `to` naming a public file stays at the root, and external
+      // `to` URLs pass through.
+      applyBaseToAstroRedirects(
+        project.config.redirects,
+        basePath,
+        "",
+        routeSetFor(project.manifest.routes)
+      ),
       // Pages, static files, and server routes alike: a redirect may
       // legitimately land on a served asset (`/old-whitepaper` ->
       // `/files/whitepaper.pdf`), and the same predicate the link and llms.txt

package/src/audit/snapshot.ts

@@ -196,8 +196,13 @@ export const buildSnapshot = (options: {
     scripts: collectAssets(document, "script[src]", "src"),
     source: route?.sourcePath,
     styles: collectAssets(document, 'link[rel="stylesheet"][href]', "href"),
+    // Only the document's own titles: an accessible inline SVG carries a
+    // `<title>` of its own (an SVG-namespace element, not the page title), and
+    // counting it would flag BLUME_AUDIT_TITLE_MULTIPLE — or stand in for a
+    // head `<title>` that is genuinely missing.
     titles: document
       .querySelectorAll("title")
+      .filter((title) => !title.closest("svg"))
       .map((title) => title.text.trim())
       .filter((text) => text.length > 0),
     twitter: prefixedMeta(document, "name", "twitter:"),

package/src/audit/types.ts

@@ -113,6 +113,16 @@ export interface RedirectResolution {
   outcome: "ok" | "loop" | "broken" | "chain";
 }
 
+/** One urlset file behind a sitemap, for the per-file size limits. */
+export interface SitemapPart {
+  file: string;
+  /** Site path the file is served at, e.g. `/sitemap-1.xml`. */
+  url: string;
+  bytes: number;
+  /** How many `<url>` entries the file lists. */
+  urls: number;
+}
+
 /** A parsed `sitemap.xml`. */
 export interface SitemapDoc {
   file: string;
@@ -121,6 +131,14 @@ export interface SitemapDoc {
   urls: string[];
   /** Each `<url>` block's `<lastmod>`, keyed by its `<loc>`. */
   lastmod?: Map<string, string>;
+  /**
+   * The child sitemaps' `<loc>`s, when `sitemap.xml` is a sitemap index —
+   * Blume writes one past 50,000 URLs. The crawler reads each child from the
+   * build and merges its URLs into `urls` and `lastmod`.
+   */
+  sitemaps?: string[];
+  /** The index's child urlset files, once the crawler has read them. */
+  parts?: SitemapPart[];
   /** Parse failure, when the document isn't usable. */
   error?: string;
 }

package/src/audit/url.ts

@@ -43,11 +43,21 @@ export type ResolvedHref =
   | { kind: "internal"; path: string; hash: string }
   /** An absolute URL that resolves back to this site — should have been a path. */
   | { kind: "self-origin"; path: string; hash: string }
+  /**
+   * A path on this origin that lacks `deployment.base`. The host serves the
+   * whole build under the base, so nothing answers here — `path` is the path
+   * as requested, base missing.
+   */
+  | { kind: "outside-base"; path: string }
   /** An absolute URL on another origin. */
   | { kind: "external"; url: string }
   /** In-page anchor, `mailto:`, `tel:`, `javascript:`, data URI — not a page link. */
   | { kind: "ignored" };
 
+/** Whether a served path sits under the deployment base (always, without one). */
+const underBase = (deployBase: string, path: string): boolean =>
+  !deployBase || path === deployBase || path.startsWith(`${deployBase}/`);
+
 const NON_HTTP_SCHEME = /^(?!https?:)[a-z][a-z0-9+.-]*:/iu;
 
 /**
@@ -65,6 +75,20 @@ export const decodePath = (path: string): string => {
   }
 };
 
+/**
+ * Whether a `--url` value is an absolute http(s) URL the network tier can
+ * probe. A bare host (`example.com`) has no scheme, and `localhost:4321`
+ * parses with `localhost:` as its scheme — both are rejected.
+ */
+export const isHttpUrl = (input: string): boolean => {
+  try {
+    const { protocol } = new URL(input);
+    return protocol === "http:" || protocol === "https:";
+  } catch {
+    return false;
+  }
+};
+
 /** The origin of `deployment.site`, or null when no site is configured. */
 export const siteOrigin = (site?: string): string | null => {
   if (!site) {
@@ -113,12 +137,14 @@ export const resolveHref = (
       return { kind: "ignored" };
     }
     if (origin && parsed.origin === origin) {
+      const served = decodePath(parsed.pathname);
+      if (!underBase(deployBase, served)) {
+        return { kind: "outside-base", path: normalizePath(served) };
+      }
       return {
         hash: parsed.hash.slice(1),
         kind: "self-origin",
-        path: normalizePath(
-          stripBasePath(deployBase, decodePath(parsed.pathname))
-        ),
+        path: normalizePath(stripBasePath(deployBase, served)),
       };
     }
     return { kind: "external", url: parsed.toString() };
@@ -140,11 +166,16 @@ export const resolveHref = (
   } catch {
     return { kind: "ignored" };
   }
+  const served = decodePath(resolved.pathname);
+  // Only a root-relative href names the served path outright; a relative one
+  // (`./auth`) was resolved against the base-less page URL above, so it
+  // inherits the page's base by construction.
+  if (target.startsWith("/") && !underBase(deployBase, served)) {
+    return { kind: "outside-base", path: normalizePath(served) };
+  }
   return {
     hash: resolved.hash.slice(1),
     kind: "internal",
-    path: normalizePath(
-      stripBasePath(deployBase, decodePath(resolved.pathname))
-    ),
+    path: normalizePath(stripBasePath(deployBase, served)),
   };
 };

package/src/cli/args.ts

@@ -21,3 +21,35 @@ export const parsePort = (value?: string): number | undefined => {
   }
   return port;
 };
+
+/**
+ * The longest `--timeout` a timer can hold, in seconds. Node clamps a
+ * `setTimeout` delay above 2^31−1 ms (about 24.8 days) to 1 ms, so a larger
+ * value would time every agent out the moment it starts.
+ */
+export const MAX_TIMEOUT_S = Math.floor(2_147_483_647 / 1000);
+
+/**
+ * Parse a `--timeout` value in whole seconds, or return `fallback` when unset.
+ * A non-integer, non-positive, or too-long value exits with an error.
+ */
+export const parseTimeoutSeconds = (
+  value: string | undefined,
+  fallback: number
+): number => {
+  if (value === undefined) {
+    return fallback;
+  }
+  const timeout = Number(value);
+  if (!Number.isInteger(timeout) || timeout <= 0) {
+    logger.error(`Invalid --timeout "${value}" (whole seconds).`);
+    process.exit(1);
+  }
+  if (timeout > MAX_TIMEOUT_S) {
+    logger.error(
+      `Invalid --timeout "${value}" (at most ${MAX_TIMEOUT_S} seconds, about 24 days).`
+    );
+    process.exit(1);
+  }
+  return timeout;
+};

package/src/cli/build-failure.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+
+import type { Diagnostic } from "../core/types.ts";
+
+/**
+ * The fields of an `astro build` rejection the report reads. Rolldown bundles
+ * every plugin failure (an MDX compile error, say) into one error whose
+ * `errors` holds each; a failure carries `loc` where the compiler pinned it,
+ * or only `id`, the module that failed.
+ */
+const buildErrorSchema = z.looseObject({
+  errors: z.array(z.instanceof(Error)).optional(),
+  id: z.string().optional(),
+  loc: z
+    .looseObject({
+      column: z.number().optional(),
+      file: z.string().optional(),
+      line: z.number().optional(),
+    })
+    .optional(),
+});
+
+/** One failure as a diagnostic at the file (and position) it names. */
+const failureDiagnostic = (error: Error): Diagnostic => {
+  const parsed = buildErrorSchema.safeParse(error);
+  const { id, loc } = parsed.success ? parsed.data : {};
+  // A named error (`MDXError`, `CompilerError`) says which step failed.
+  const name = error.name === "Error" ? "" : `${error.name}: `;
+  return {
+    code: "BLUME_BUILD_FAILED",
+    column: loc?.column,
+    file: loc?.file ?? id,
+    line: loc?.line,
+    message: `${name}${error.message}`,
+    severity: "error",
+  };
+};
+
+/**
+ * What `astro build` rejected with, as build diagnostics: one per failure
+ * Rolldown collected, else the error itself. A page Blume's own checks pass
+ * can still fail Astro's compile (MDX that doesn't parse) or render, and that
+ * is a problem in the site, reported at its file, rather than an internal
+ * error blaming Blume.
+ */
+export const astroBuildDiagnostics = (error: Error): Diagnostic[] => {
+  const parsed = buildErrorSchema.safeParse(error);
+  const failures = parsed.success ? (parsed.data.errors ?? []) : [];
+  return (failures.length > 0 ? failures : [error]).map(failureDiagnostic);
+};

package/src/cli/commands/audit.ts

@@ -11,6 +11,7 @@ import { formatCatalog, formatReport, reportJson } from "../../audit/report.ts";
 import { NoBuildError, runAudit } from "../../audit/run.ts";
 import type { AuditResult } from "../../audit/run.ts";
 import { checkTerms, unknownCheckTerms } from "../../audit/terms.ts";
+import { isHttpUrl } from "../../audit/url.ts";
 import { BlumeError } from "../../core/diagnostics.ts";
 import { scanProject } from "../../core/project-graph.ts";
 import type { DiagnosticSeverity } from "../../core/types.ts";
@@ -162,6 +163,12 @@ export const auditCommand = defineCommand({
       logger.error(`--json and --${agent} are mutually exclusive.`);
       process.exit(1);
     }
+    if (args.url !== undefined && !isHttpUrl(args.url)) {
+      logger.error(
+        `Invalid --url "${args.url}": pass the deployment's full URL, scheme included (e.g. https://${args.url}).`
+      );
+      process.exit(1);
+    }
     const only = splitTerms(args.only);
     const skip = splitTerms(args.skip);
     rejectUnknownTerms([...only, ...skip]);
@@ -231,7 +238,10 @@ export const auditCommand = defineCommand({
     process.stderr.write(formatReport(result, root, { verbose: args.verbose }));
 
     if (shouldFail(result, gate)) {
-      process.exit(1);
+      // Set the code and return rather than `process.exit`, which doesn't wait
+      // for a piped stderr: a long report was cut off after the first 64 KiB,
+      // in exactly the CI logs that need to show every finding.
+      process.exitCode = 1;
     }
   },
 });

package/src/cli/commands/build.ts

@@ -6,6 +6,7 @@ import { defineCommand } from "citty";
 import { join } from "pathe";
 
 import { publishBuildProject } from "../../astro/integration.ts";
+import { BlumeError } from "../../core/diagnostics.ts";
 import { ensureGitignore } from "../../core/gitignore.ts";
 import type { BlumeProject } from "../../core/project-graph.ts";
 import { serverFeatures } from "../../core/server-features.ts";
@@ -21,10 +22,11 @@ import {
   removedBuildFlags,
   removedBuildFlagsAdvice,
 } from "../../upgrade/upgrade.ts";
+import { astroBuildDiagnostics } from "../build-failure.ts";
 import { commandMeta } from "../command-meta.ts";
 import { refuseIfDevRunning } from "../dev-lock.ts";
 import { refuseIfEjected } from "../eject-scripts.ts";
-import { logger } from "../log.ts";
+import { logger, reportDiagnostics } from "../log.ts";
 import { prepareProject } from "../prepare.ts";
 
 const BUDGET_JS = "budget-js";
@@ -333,10 +335,22 @@ export const buildCommand = defineCommand({
       publishBuildProject(project);
     }
 
-    await build({
-      logLevel: "info",
-      root: project.context.outDir,
-    });
+    try {
+      await build({
+        logLevel: "info",
+        root: project.context.outDir,
+      });
+    } catch (error) {
+      // Astro rejects when the site fails to compile or render (MDX that
+      // doesn't parse, a component that throws): report that as a build error
+      // at the file it names, not as an internal error blaming Blume. A
+      // BlumeError keeps its own diagnostic.
+      if (error instanceof BlumeError || !(error instanceof Error)) {
+        throw error;
+      }
+      reportDiagnostics(astroBuildDiagnostics(error), root);
+      process.exit(1);
+    }
 
     // A real build also prunes the cache; an isolated verify must not evict
     // cards a live dev server is still serving.

package/src/cli/commands/check.ts

@@ -8,6 +8,7 @@ import { join } from "pathe";
 import { ensureGitignore } from "../../core/gitignore.ts";
 import { commandMeta } from "../command-meta.ts";
 import { refuseIfDevRunning } from "../dev-lock.ts";
+import { refuseIfEjected } from "../eject-scripts.ts";
 import { logger } from "../log.ts";
 import { prepareProject } from "../prepare.ts";
 
@@ -30,6 +31,7 @@ export const checkCommand = defineCommand({
   meta: commandMeta.check,
   async run({ args }) {
     const root = process.cwd();
+    await refuseIfEjected(root, "check");
 
     // `blume check` regenerates `.blume` just like `build`, so it must refuse a
     // live dev server unless isolated. `--isolated` (or BLUME_RUNTIME_DIR)

package/src/cli/commands/doctor.ts

@@ -187,7 +187,9 @@ export const doctorCommand = defineCommand({
       logger.success("No problems found.");
     }
     if (hadErrors) {
-      process.exit(1);
+      // Set the code and return rather than `process.exit`, which doesn't wait
+      // for a piped stderr: a long diagnostic list would be cut off.
+      process.exitCode = 1;
     }
   },
 });

package/src/cli/commands/eval.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 
 import { defineCommand } from "citty";
-import { join } from "pathe";
+import { resolve } from "pathe";
 
 import { AGENTS, launchAgent } from "../../audit/agent.ts";
 import type { AgentKind } from "../../audit/agent.ts";
@@ -19,9 +19,10 @@ import {
   warningLines,
   writeEvalReport,
 } from "../../eval/report.ts";
-import { runEval } from "../../eval/run.ts";
+import { passFraction, runEval } from "../../eval/run.ts";
 import type { EvalResult } from "../../eval/run.ts";
 import { EvalsFileError, loadEvalsFile } from "../../eval/schema.ts";
+import { parseTimeoutSeconds } from "../args.ts";
 import { commandMeta } from "../command-meta.ts";
 import { reportInternalError } from "../internal-error.ts";
 import { flushStdout, logger, reportDiagnostics } from "../log.ts";
@@ -63,12 +64,6 @@ const launchAgentCode = async (
   }
 };
 
-/** The fraction of run (non-skipped) questions that passed. */
-export const passFraction = (result: EvalResult): number => {
-  const ran = result.results.length - result.counts.skip;
-  return ran === 0 ? 1 : result.counts.pass / ran;
-};
-
 interface EvalFlags {
   action?: string;
   agent: string;
@@ -94,16 +89,18 @@ const parseFlags = (args: EvalFlags) => {
     process.exit(1);
   }
   const threshold = args.threshold === undefined ? 1 : Number(args.threshold);
-  if (!Number.isFinite(threshold) || threshold < 0 || threshold > 1) {
+  // A bare `--threshold` (or `--threshold $UNSET_VAR`) arrives as "", which
+  // `Number` reads as 0 — a gate that passes every run — so it's rejected.
+  if (
+    args.threshold?.trim() === "" ||
+    !Number.isFinite(threshold) ||
+    threshold < 0 ||
+    threshold > 1
+  ) {
     logger.error(`Invalid --threshold "${args.threshold}" (use 0..1).`);
     process.exit(1);
   }
-  const timeoutS =
-    args.timeout === undefined ? DEFAULT_TIMEOUT_S : Number(args.timeout);
-  if (!Number.isInteger(timeoutS) || timeoutS <= 0) {
-    logger.error(`Invalid --timeout "${args.timeout}" (whole seconds).`);
-    process.exit(1);
-  }
+  const timeoutS = parseTimeoutSeconds(args.timeout, DEFAULT_TIMEOUT_S);
   return { agent: args.agent, threshold, timeoutS };
 };
 
@@ -131,7 +128,7 @@ const runFixHandoff = async (
 
 /** `blume eval init`: draft a starter evals file via the interactive agent. */
 const runInit = async (agent: AgentKind, file: string): Promise<void> => {
-  const path = join(process.cwd(), file);
+  const path = resolve(process.cwd(), file);
   if (existsSync(path)) {
     logger.error(
       `${file} already exists — edit it directly, or pass --file to draft elsewhere.`
@@ -199,7 +196,9 @@ export const evalCommand = defineCommand({
       // and never regenerates the runtime, so it doesn't contend with a
       // running dev server. Same reasoning as `blume audit`.
       const project = await scanProject(root, { mode: "build" });
-      const evalsPath = join(root, args.file);
+      // `resolve`, not `join`: an absolute `--file` (`/ci/evals.yaml`) is
+      // used as given instead of being nested under the project root.
+      const evalsPath = resolve(root, args.file);
       const { evals, raw } = await loadEvalsFile(evalsPath);
 
       process.stderr.write(`${headerLine(evals.questions.length, agent)}\n\n`);
@@ -276,7 +275,10 @@ export const evalCommand = defineCommand({
     }
 
     if (failed) {
-      process.exit(1);
+      // Set the code and return rather than `process.exit`, which doesn't wait
+      // for a piped stderr: a long `--verbose` report was cut off mid-write, in
+      // exactly the CI logs that need to show every failure.
+      process.exitCode = 1;
     }
   },
 });

package/src/cli/commands/init.ts

@@ -11,9 +11,11 @@ import { collectAnswers } from "../init/questions.ts";
 import {
   applyPlan,
   buildPlan,
+  cdCommand,
   commandsFor,
   detectPackageManager,
   nextSteps,
+  outsidePnpmWorkspace,
   PACKAGE_MANAGERS,
   readExistingPackage,
   TEMPLATES,
@@ -25,7 +27,7 @@ import { logger } from "../log.ts";
 
 /** The `cd` line that opens every next-steps hint, when one is needed. */
 const cdStep = (answers: InitAnswers): string[] =>
-  answers.directory === "." ? [] : [`cd ${answers.directory}`];
+  answers.directory === "." ? [] : [cdCommand(answers.directory)];
 
 /**
  * Install the scaffolded project's dependencies. Interactive runs hide the
@@ -99,8 +101,13 @@ const ejectScaffold = async (
   } catch (error) {
     // SAFETY: eject and the script rewrite throw Error instances; only the
     // message is surfaced in the fallback hint.
+    const { message } = error as Error;
+    // Only a skipped install explains the failure; after an install that ran,
+    // the error itself is the reason.
     logger.warn(
-      `Scaffolded, but eject needs the project's dependencies installed to load blume.config.ts: ${(error as Error).message}`
+      needsInstall
+        ? `Scaffolded, but eject needs the project's dependencies installed to load blume.config.ts: ${message}`
+        : `Scaffolded, but eject failed: ${message}`
     );
     const steps = [...cd, ...install, `${commands.exec} blume eject --yes`];
     logger.box(`Next steps:\n\n  ${steps.join("\n  ")}`);
@@ -229,7 +236,7 @@ export const initCommand = defineCommand({
         { cwd, userAgent: process.env.npm_config_user_agent }
       );
       if (collected === null) {
-        clack.cancel("Cancelled — nothing was written.");
+        clack.cancel("Canceled — nothing was written.");
         process.exit(0);
       }
       answers = collected;
@@ -279,8 +286,11 @@ export const initCommand = defineCommand({
     }
 
     // A newly written package.json is the only one `init` knows lists blume;
-    // an existing one is left alone, and so are its dependencies.
-    const shouldInstall = createdPackage && args.install;
+    // an existing one is left alone, and so are its dependencies. In a pnpm
+    // workspace that doesn't list the folder, an install would exit 0 without
+    // installing it, so that one waits until the note's change is made.
+    const shouldInstall =
+      createdPackage && args.install && !outsidePnpmWorkspace(root, answers);
     if (note) {
       (interactive ? clack.log : logger).warn(note);
     }