@canonical/pragma-cli 0.34.0 → 0.36.0

package/src/capabilities/sources/index.ts

@@ -4,7 +4,7 @@
  */
 
 import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { CapabilityModule } from "../../kernel/spec/types.js";
+import type { CapabilityModule } from "../../kernel/spec/index.js";
 import { statusVerb } from "./status.verb.js";
 import { updateVerb } from "./update.verb.js";
 

package/src/capabilities/sources/installSkills.ts

@@ -10,27 +10,62 @@
  * first), and the update Task stays reversible (each created link carries an
  * unlink undo).
  *
+ * Installing alone leaks, because planning walks the PACKAGES and so only ever
+ * visits a skill that still exists. When a package DROPS one (a `0.1.2` that
+ * shipped `component-specifier` upgrading to a `0.2.0` that does not), the link
+ * the previous update installed is never revisited and is left dangling at a
+ * target that no longer exists — which reads as a broken install rather than the
+ * intentional removal it is, and which `skill` commands can still list or try to
+ * open. So planning ALSO walks the installed root and prunes those, under a
+ * deliberately narrow rule: an entry is removed only when this run did not plan
+ * it AND it is a symlink whose target is gone. A real directory is a
+ * manually-installed skill and a still-resolving symlink is someone's own link;
+ * neither is this update's to delete.
+ *
  * Decisions run against REAL fs here so the update's `--dry-run` plan is
  * accurate; the composed Task performs only the symlink/delete effects.
  */
 
-import { existsSync, lstatSync, readdirSync, readlinkSync } from "node:fs";
+import {
+  existsSync,
+  lstatSync,
+  readdirSync,
+  readlinkSync,
+  statSync,
+} from "node:fs";
 import { basename, join, resolve } from "node:path";
-import type { ResolvedPackage } from "../../kernel/runtime/refs/resolve.js";
+import type { ResolvedPackage } from "../../kernel/runtime/refs/index.js";
+// The ownership test, imported rather than reimplemented: `setup skills` and
+// this module must not be able to disagree about which links belong to pragma.
+// `setupSkills.ts` reaches `@canonical/harnesses` only through a DYNAMIC
+// import, so this edge adds no static one (`capabilities/lazy.test.ts`).
+import { withinAnyRoot } from "../setup/operations/setupSkills.js";
 import { installedSkillsDir } from "../skill/discover.js";
 
 /** One planned skill symlink into the installed-skills root. */
 export interface SkillLinkAction {
-  /** The package's skill folder — the symlink target. */
+  /**
+   * The symlink target: the package's skill folder for an install, or — on a
+   * `pruned` entry — the missing target the stale link still points at, kept so
+   * the prune's undo can put the link back exactly as it was.
+   */
   readonly target: string;
   /** `<installedSkillsDir>/<folderName>` — where the symlink is created. */
   readonly linkPath: string;
-  /** created (absent), skipped (already correct / a real dir), or replaced. */
-  readonly action: "created" | "skipped" | "replaced";
+  /**
+   * created (absent), skipped (already correct / a real dir), replaced, or
+   * pruned (an unplanned link whose target is gone — deleted, not re-created).
+   */
+  readonly action: "created" | "skipped" | "replaced" | "pruned";
   /** The skill folder name (the discovery key). */
   readonly folderName: string;
-  /** The package the skill came from. */
-  readonly packageName: string;
+  /**
+   * The package the skill came from. Absent on a `pruned` entry: a stale link
+   * records only a target path, and the package that installed it is precisely
+   * the one that no longer provides the skill — there is nothing honest left to
+   * attribute it to.
+   */
+  readonly packageName?: string;
 }
 
 /** What currently occupies a candidate link path. */
@@ -70,7 +105,11 @@ function packageSkillDirs(root: string): string[] {
   for (const name of names) {
     const dir = join(skillsDir, name);
     try {
-      if (lstatSync(dir).isDirectory() && existsSync(join(dir, "SKILL.md"))) {
+      // `stat`, not `lstat`: a package that ships `skills/<name>` as a SYMLINK
+      // — the ordinary pnpm / monorepo / `file:` layout — contributed nothing
+      // at all, silently, because `lstat` reports the link and not the
+      // directory behind it. Discovery uses `stat`; so does this now.
+      if (statSync(dir).isDirectory() && existsSync(join(dir, "SKILL.md"))) {
         out.push(dir);
       }
     } catch {
@@ -80,9 +119,58 @@ function packageSkillDirs(root: string): string[] {
   return out;
 }
 
+/**
+ * Plan the removal of the links a package has since dropped.
+ *
+ * The install pass walks the packages, so it can only ever visit a skill that
+ * still exists; this pass walks the installed root, which is the ONLY place a
+ * dropped skill still shows up. An entry is pruned only when both hold: this run
+ * did not plan it, and it is a symlink whose target is gone. Both halves matter —
+ *
+ * - a real (non-symlink) entry is a manually-installed skill, which the install
+ *   pass already refuses to clobber (`skipped`) and which this pass must refuse
+ *   just as firmly: "unplanned" is exactly what a hand-placed skill looks like;
+ * - a symlink whose target still resolves is someone's own link into a checkout
+ *   this command knows nothing about. Unplanned does not make it garbage, and an
+ *   update that silently ate it would be a worse bug than the dangling link.
+ *
+ * A broken target, by contrast, cannot be anything but debris: nothing can read
+ * it, and re-creating it is a matter of re-running the update that installed it
+ * (which is also what this prune's undo does).
+ *
+ * @param dest - The installed-skills root.
+ * @param planned - Every folder name the install pass planned, whatever action.
+ * @returns One `pruned` action per stale link, for the plan and its preview.
+ * @note Impure — reads the installed root and stats each entry's target.
+ */
+function planStaleLinkPrunes(
+  dest: string,
+  planned: ReadonlySet<string>,
+): SkillLinkAction[] {
+  let names: string[];
+  try {
+    names = readdirSync(dest);
+  } catch {
+    return []; // No installed root — nothing was ever installed to go stale.
+  }
+  const out: SkillLinkAction[] = [];
+  for (const folderName of names) {
+    if (planned.has(folderName)) continue;
+    const linkPath = resolve(dest, folderName);
+    const state = linkState(linkPath);
+    if (state.kind !== "symlink") continue;
+    // A relative target is stored relative to the link's OWN directory, which
+    // for an entry of the installed root is that root itself.
+    if (existsSync(resolve(dest, state.target))) continue;
+    out.push({ target: state.target, linkPath, action: "pruned", folderName });
+  }
+  return out;
+}
+
 /**
  * Plan the symlink actions that install each resolved package's `skills/*` into
- * the installed-skills discovery root. First-seen wins on a folder-name clash
+ * the installed-skills discovery root, then the removals that retire the links
+ * a package has since dropped. First-seen wins on a folder-name clash
  * across packages. A real (non-symlink) entry at the link path is left untouched
  * (`skipped`) so a manually-installed skill is never clobbered.
  *
@@ -103,10 +191,17 @@ export function planSkillInstall(
       seen.add(folderName);
       const linkPath = resolve(dest, folderName);
       const state = linkState(linkPath);
+      // Already correct means the link RESOLVES to the skill dir, not that its
+      // raw `readlink` string equals an absolute path. A relative link was
+      // therefore never "already correct": it was torn down and rebuilt on
+      // every single update, and the sibling planner reported it as drift.
+      const resolvesToSkill =
+        state.kind === "symlink" &&
+        resolve(dest, state.target) === resolve(skillDir);
       const action: SkillLinkAction["action"] =
         state.kind === "absent"
           ? "created"
-          : state.kind === "symlink" && state.target === skillDir
+          : resolvesToSkill
             ? "skipped"
             : state.kind === "symlink"
               ? "replaced"
@@ -120,5 +215,165 @@ export function planSkillInstall(
       });
     }
   }
+  // `seen` is every folder name this run planned — the `skipped` ones included,
+  // so a name a package still provides is never a prune candidate even when the
+  // install pass decided to leave its entry alone.
+  actions.push(...planStaleLinkPrunes(dest, seen));
   return actions;
 }
+
+/**
+ * One planned link action in a HARNESS skills directory (layer 2).
+ *
+ * Layer 1 (`<installedSkillsDir>/<name>` → the package's folder) is what
+ * {@link planSkillInstall} owns. This is the layer above it: the links inside
+ * `~/.claude/skills` and `~/.agents/skills` that point AT layer 1 — a link to a
+ * link — and that `setup skills` owns.
+ */
+export interface HarnessLinkAction {
+  readonly target: string;
+  readonly linkPath: string;
+  readonly action: "created" | "replaced" | "pruned";
+  readonly folderName: string;
+  /** The harness directory's display name, for the progress line. */
+  readonly dirName: string;
+  /**
+   * The target the link ALREADY holds, recorded only for a `replaced` action so
+   * its undo can put that link back. Without it the undo could only delete what
+   * the forward run created, which restores an ABSENT path — a state that never
+   * existed — instead of the link the run overwrote.
+   *
+   * Stored as `readlink` returned it, not resolved: a relative link is relative
+   * to its own directory, which for a candidate of `dir` is `dir` itself, so
+   * re-linking the raw value reproduces the link exactly as found.
+   */
+  readonly previousTarget?: string;
+}
+
+/**
+ * Plan the CONVERGE-ONLY refresh of the global scope's harness skill links.
+ *
+ * The reported bug lives here. `sources update` installed and pruned layer 1
+ * and stopped, so a new pack skill reached no harness directory until the user
+ * separately ran `setup skills`, and a dropped one left its layer-2 link
+ * dangling with nothing that would ever clear it. This closes the loop, under
+ * two rules that are the entire safety argument:
+ *
+ * 1. CONVERGE-ONLY. `dirs` are directories that already exist — this function
+ *    never creates one, and the caller composes no `mkdir`. A `sources update`
+ *    that materialised `~/.claude/skills` would be litter, and would silently
+ *    opt the user into linking they never asked for.
+ * 2. OWNERSHIP, by the SAME test `setup skills` uses. A path is this command's
+ *    to touch only when it holds a symlink resolving INSIDE one of the global
+ *    scope's roots (`withinAnyRoot`, a pure path-SEGMENT test that reads nothing
+ *    — so it still answers correctly after the layer-1 target is gone, which is
+ *    exactly the stale case). A real directory is a hand-installed skill; a
+ *    symlink pointing anywhere else is the user's own; a `<root>-backup/foo`
+ *    sibling is not "inside" despite sharing a string prefix. None is removed.
+ *
+ *    THE SET, NOT JUST THE INSTALLED ROOT, and that is what keeps precedence
+ *    true one layer up. A harness link left pointing at the BUNDLED snapshot
+ *    for a skill this update has just installed for real is owned, so it is
+ *    `replaced` onto the installed copy. Tested against the installed root
+ *    alone it read as "someone else's link" and was skipped — and the user who
+ *    deliberately ran `sources update` would have kept running the shipped copy.
+ *
+ * The plan is derived from the layer-1 plan rather than from a filesystem
+ * re-read, because at planning time the layer-1 writes have not happened yet:
+ * `surviving` is the post-update truth, and reading the disk would see the
+ * pre-update state. That is also why a surviving name always targets
+ * `roots[0]`: layer 1 is about to hold it, whether or not it does now.
+ *
+ * A RETIRED NAME IS NOT AUTOMATICALLY DEBRIS any more. The fallback roots
+ * (today: the bundled snapshot) are NOT written by this update, so their
+ * contents ARE readable at plan time — and a skill the packages dropped that
+ * the shipped snapshot still carries is still discoverable, still listed by
+ * `skill list`, and so still belongs in the harness directory. Such a link is
+ * RETARGETED onto the surviving root rather than pruned; only a name no root
+ * provides at all is deleted.
+ *
+ * @param dirs - The EXISTING global link directories.
+ * @param roots - The global scope's source roots in PRECEDENCE order.
+ *   `roots[0]` is the installed root (layer 1) every surviving name targets;
+ *   the rest are fallbacks a retired name may still resolve in. The whole set
+ *   is the ownership set.
+ * @param surviving - Folder names layer 1 will hold after this update.
+ * @param retired - Folder names layer 1 is pruning in this update.
+ * @returns The layer-2 actions, for the plan and its effects.
+ * @note Impure — lstats each candidate link path, and stats the fallback roots
+ *   for each retired name.
+ */
+export function planHarnessSkillLinks(
+  dirs: readonly { dir: string; name: string }[],
+  roots: readonly string[],
+  surviving: readonly string[],
+  retired: readonly string[],
+): HarnessLinkAction[] {
+  const dest = resolve(roots[0] as string);
+  /** The first FALLBACK root that still holds `folderName`, if any. */
+  const fallback = (folderName: string): string | undefined =>
+    roots
+      .slice(1)
+      .map((root) => resolve(root, folderName))
+      .find((candidate) => existsSync(candidate));
+  const out: HarnessLinkAction[] = [];
+  for (const { dir, name } of dirs) {
+    for (const folderName of surviving) {
+      const linkPath = resolve(dir, folderName);
+      const target = resolve(dest, folderName);
+      const state = linkState(linkPath);
+      if (state.kind === "other") continue; // A hand-placed entry — never ours.
+      if (state.kind === "absent") {
+        out.push({
+          target,
+          linkPath,
+          action: "created",
+          folderName,
+          dirName: name,
+        });
+        continue;
+      }
+      if (resolve(dir, state.target) === target) continue; // Already correct.
+      // A symlink pointing outside every scope root is the user's own link into
+      // their own checkout. Unplanned does not make it ours to replace.
+      if (!withinAnyRoot(roots, linkPath, state.target)) continue;
+      out.push({
+        target,
+        linkPath,
+        action: "replaced",
+        folderName,
+        dirName: name,
+        previousTarget: state.target,
+      });
+    }
+    for (const folderName of retired) {
+      const linkPath = resolve(dir, folderName);
+      const state = linkState(linkPath);
+      if (state.kind !== "symlink") continue;
+      if (!withinAnyRoot(roots, linkPath, state.target)) continue;
+      const surviving = fallback(folderName);
+      if (surviving !== undefined) {
+        // Dropped upstream, still shipped: retarget rather than delete. Already
+        // correct is nothing to do.
+        if (resolve(dir, state.target) === surviving) continue;
+        out.push({
+          target: surviving,
+          linkPath,
+          action: "replaced",
+          folderName,
+          dirName: name,
+          previousTarget: state.target,
+        });
+        continue;
+      }
+      out.push({
+        target: resolve(dir, state.target),
+        linkPath,
+        action: "pruned",
+        folderName,
+        dirName: name,
+      });
+    }
+  }
+  return out;
+}

package/src/capabilities/sources/runUpdate.ts

@@ -31,24 +31,30 @@ import {
   writeFile,
 } from "@canonical/task";
 import { VERSION } from "../../constants.js";
-import { PragmaError } from "../../kernel/error/PragmaError.js";
-import { cliRecovery } from "../../kernel/error/recovery.js";
+import { cliRecovery, PragmaError } from "../../kernel/error/index.js";
+// DIRECT LEAF IMPORT, not `graphpack/index.js`. The barrel re-exports
+// `embedded.ts`, which statically imports the ~1.9 MB generated pack — and
+// with per-file `tsc` output ESM evaluates that re-export when this module
+// loads. `sources update` builds a USER pack; it must not pay the embedded
+// pack's cost to do it.
 import { buildPack } from "../../kernel/runtime/graphpack/build.js";
+import type { PragmaRuntime } from "../../kernel/runtime/index.js";
 import { activePackPath, readActivePack } from "../../kernel/runtime/paths.js";
-import type { PackageRef } from "../../kernel/runtime/refs/parseRef.js";
-import {
-  parsePackDeclaration,
-  redactUrl,
-} from "../../kernel/runtime/refs/parseRef.js";
+import type { PackageRef } from "../../kernel/runtime/refs/index.js";
 import {
   detectPrefixClashes,
   harvestPrefixes,
+  parsePackDeclaration,
   type ResolvedPackage,
+  redactUrl,
   resolvePackage,
-} from "../../kernel/runtime/refs/resolve.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import { installedSkillsDir } from "../skill/discover.js";
-import { planSkillInstall } from "./installSkills.js";
+} from "../../kernel/runtime/refs/index.js";
+// The global scope's EXISTING link directories, from the module that owns the
+// scope covenant — so `sources update` cannot drift away from what
+// `setup skills --global` links, or widen the scope on its own.
+import { existingGlobalSkillDirs } from "../setup/operations/setupSkills.js";
+import { globalSkillRoots, installedSkillsDir } from "../skill/discover.js";
+import { planHarnessSkillLinks, planSkillInstall } from "./installSkills.js";
 import type { SourcesUpdateData } from "./types.js";
 
 /** Generic-core prefixes; config `prefixes` merge over them (config wins). */
@@ -209,17 +215,17 @@ export async function buildUpdateTask(
   // prefix. Display-only, so a warning (not a hard failure) is the right call.
   for (const clash of detectPrefixClashes(inputs)) {
     report?.(
-      `Prefix "${clash.label}:" is declared with conflicting IRIs across packages (${clash.iris.join(" vs ")}); last wins, so some entities may compact to the wrong prefix.`,
+      `Prefix "${clash.label}:" is declared with conflicting IRIs across packs (${clash.iris.join(" vs ")}); last wins, so some entities may compact to the wrong prefix.`,
     );
   }
 
   report?.(`Building store from ${inputs.length} source(s)`);
   if (verbose) for (const input of inputs) report?.(`  parse ${input.path}`);
   if (stories.length > 0)
-    report?.(`Carrying ${stories.length} package read story file(s)`);
+    report?.(`Carrying ${stories.length} pack read story file(s)`);
 
   // Build the pack. On a parse/build failure, classify it as a NAMED data error
-  // (U6) — not INTERNAL_ERROR's "please report this issue" — identifying the
+  // (U6) — not INTERNAL_ERROR's "report this issue" — identifying the
   // offending package source, since ke's parser error carries only line/column.
   // With `--skip-invalid`, drop the unparseable sources (warning LOUDLY about
   // each — never a silent partial graph) and build from the rest instead of
@@ -262,7 +268,7 @@ export async function buildUpdateTask(
     );
     if (usableInputs.length === 0)
       throw PragmaError.configError(
-        `All ${inputs.length} configured source(s) failed to parse — nothing to build.`,
+        `None of the ${inputs.length} configured source(s) can be parsed — nothing to build.`,
         {
           recovery: cliRecovery(
             "sources update --verbose",
@@ -299,7 +305,7 @@ export async function buildUpdateTask(
       {
         recovery: cliRecovery(
           "sources update --verbose",
-          "Check that the package sources actually contain RDF triples, then re-run.",
+          "Check that the pack sources actually contain RDF triples, then re-run.",
         ),
       },
     );
@@ -322,13 +328,63 @@ export async function buildUpdateTask(
 
   // Install package-provided skills (U10): symlink each resolved package's
   // `skills/*` into the installed-skills root, so `skill list` / `setup skills`
-  // see them after an update. Kept in this Task (reversible: created links carry
-  // an unlink undo) so `sources update --undo` also removes them.
-  const skillLinks = planSkillInstall(resolved).filter(
-    (link) => link.action !== "skipped",
+  // see them after an update — and RETIRE the links of skills those packages
+  // have since dropped, which the same plan reports as `pruned`. Kept in this
+  // Task (reversible: a created link carries an unlink undo, a pruned one a
+  // re-link undo) so `sources update --undo` restores the root as it was.
+  //
+  // The two are split, not counted together: a prune is a deletion, so folding
+  // it into "Installing N skill(s)" would report a removal as an install.
+  const skillPlan = planSkillInstall(resolved);
+  const skillLinks = skillPlan.filter(
+    (link) => link.action === "created" || link.action === "replaced",
   );
+  const staleLinks = skillPlan.filter((link) => link.action === "pruned");
   if (skillLinks.length > 0)
     report?.(`Installing ${skillLinks.length} skill(s)`);
+  if (staleLinks.length > 0)
+    report?.(
+      `Removing ${staleLinks.length} skill link(s) no longer provided by any package`,
+    );
+
+  // Converge the GLOBAL scope (layer 2). Layer 1 above is the installed root;
+  // the harness directories link AT it, and until now nothing here touched
+  // them — a new pack skill reached no harness directory until the user
+  // separately ran `setup skills`, and a dropped one left a dangling link that
+  // nothing would ever clear. That two-step was the reported bug.
+  //
+  // CONVERGE-ONLY, and this is a policy line, not an optimisation:
+  // `existingGlobalSkillDirs` returns only directories that ALREADY EXIST, and
+  // nothing below composes a `mkdir`. `sources update` is `mcp: {expose:true}`
+  // with `mutates: true` and `needsNetwork: true`, so creating directories here
+  // would mean an agent, over MCP, after a network fetch, conjuring
+  // `~/.claude/skills` into being and opting the user into linking they never
+  // asked for. Refresh what is there; never bring a directory into existence.
+  //
+  // Ownership is the SAME `withinAnyRoot` test `setup skills` applies, over the
+  // SAME root set (`globalSkillRoots`), so a real directory, a still-resolving
+  // link into the user's own checkout, and a `<root>-backup/foo` sibling are all
+  // left exactly as found — while a link still pointing at the BUNDLED snapshot
+  // for a skill this update just installed is ours, and is moved onto it.
+  const harnessPlan = planHarnessSkillLinks(
+    await existingGlobalSkillDirs(runtime.cwd),
+    globalSkillRoots(),
+    skillPlan
+      .filter((link) => link.action !== "pruned")
+      .map((link) => link.folderName),
+    staleLinks.map((link) => link.folderName),
+  );
+  const harnessLinks = harnessPlan.filter((link) => link.action !== "pruned");
+  const harnessStale = harnessPlan.filter((link) => link.action === "pruned");
+  if (harnessLinks.length > 0)
+    report?.(
+      `Linking ${harnessLinks.length} skill(s) into your harness folders`,
+    );
+  if (harnessStale.length > 0)
+    report?.(`Removing ${harnessStale.length} stale harness skill link(s)`);
+  if (verbose)
+    for (const link of harnessPlan)
+      report?.(`  ${link.action} ${link.folderName} in ${link.dirName}`);
 
   report?.(`Pointing ${runtime.cwd} at pack ${built.contentHash.slice(0, 12)}`);
   return gen(function* () {
@@ -344,6 +400,58 @@ export async function buildUpdateTask(
         );
       }
     }
+    // No `mkdir` guard here: a stale link can only have been enumerated FROM
+    // the installed root, so the root necessarily exists.
+    //
+    // The undo re-creates the link exactly as found — dangling target and all —
+    // because undo's job is to restore the prior state, not to improve on it. It
+    // clears the path first because the undo interpreter MOCKS forward effects
+    // when collecting: the delete above may never have run, and `fs.symlink`
+    // refuses a path that already exists. Same delete-then-link shape the
+    // `replaced` branch above uses, for the same reason.
+    for (const stale of staleLinks) {
+      yield* $(
+        deleteFile(stale.linkPath, {
+          undo: gen(function* () {
+            yield* $(deleteFile(stale.linkPath));
+            yield* $(symlink(stale.target, stale.linkPath));
+          }),
+        }),
+      );
+    }
+    // Layer 2, in the same Task and so under the same `--undo`. Still no
+    // `mkdir`: every directory here was proven to exist at plan time, and
+    // creating one is the thing converge-only exists to forbid.
+    for (const link of harnessLinks) {
+      // A `created` link undoes by deletion — absent IS the state it replaced.
+      // A `replaced` one does not: the path held a link, and the delete above
+      // carries no undo of its own, so deleting what the symlink created would
+      // leave the path ABSENT rather than pointing where it pointed before.
+      // Its undo is therefore the same delete-then-relink shape the prunes
+      // below use, against the target detection recorded — and it clears the
+      // path first because undo collection MOCKS forward effects, so the link
+      // may still be there and `fs.symlink` refuses an existing path.
+      const previous = link.previousTarget;
+      const undoLink =
+        link.action === "replaced" && previous !== undefined
+          ? gen(function* () {
+              yield* $(deleteFile(link.linkPath));
+              yield* $(symlink(previous, link.linkPath));
+            })
+          : deleteFile(link.linkPath);
+      if (link.action === "replaced") yield* $(deleteFile(link.linkPath));
+      yield* $(symlink(link.target, link.linkPath, { undo: undoLink }));
+    }
+    for (const stale of harnessStale) {
+      yield* $(
+        deleteFile(stale.linkPath, {
+          undo: gen(function* () {
+            yield* $(deleteFile(stale.linkPath));
+            yield* $(symlink(stale.target, stale.linkPath));
+          }),
+        }),
+      );
+    }
     return data;
   });
 }
@@ -385,12 +493,12 @@ export async function classifySourceBuildError(
   const culprit = await isolateBadSource(inputs);
   const detail = culprit?.message ?? parserMessage;
   const where = culprit
-    ? `Package source "${culprit.path}" could not be parsed`
-    : "The configured package sources could not be built into a store";
+    ? `Pack source "${culprit.path}" cannot be parsed`
+    : "The configured packs cannot be built into a store";
   return PragmaError.configError(`${where}: ${detail}`, {
     recovery: cliRecovery(
       "sources update --verbose",
-      "Re-run with --verbose to see each file as it parses. If a package ships malformed RDF, report it to that package's maintainer.",
+      "Re-run with --verbose to see each file as it parses. If a pack ships malformed RDF, report it to that pack's maintainer.",
     ),
   });
 }