@canonical/pragma-cli 0.33.0 → 0.35.0

package/src/capabilities/shared/assertExecOk.ts

@@ -13,13 +13,66 @@
  * A denied `npm i -g` (EACCES), a registry/network failure, or any other
  * nonzero exit is a fixable ENVIRONMENT condition — NOT a pragma bug — so it is
  * classified UNSUPPORTED with an actionable recovery, never INTERNAL_ERROR's
- * "please report this issue". (A spawn error like ENOENT REJECTS the effect
+ * "report this issue". (A spawn error like ENOENT REJECTS the effect
  * instead of resolving, so it never reaches here.)
  */
 
-import { type ExecResult, fail, recover, type Task } from "@canonical/task";
-import { PragmaError } from "../../kernel/error/PragmaError.js";
-import type { Recovery } from "../../kernel/error/types.js";
+import {
+  type ExecResult,
+  fail,
+  pure,
+  recover,
+  type Task,
+} from "@canonical/task";
+import type { Recovery } from "../../kernel/error/index.js";
+import { PragmaError } from "../../kernel/error/index.js";
+
+/**
+ * Route a {@link PragmaError} through the Task FAILURE CHANNEL (a `Fail` node
+ * carrying the error as `cause`) instead of a synchronous throw.
+ *
+ * The distinction is load-bearing: a synchronous throw from a bind/recover
+ * continuation ESCAPES the interpreter's trampoline entirely — no enclosing
+ * `recover` can see it — whereas a `Fail` node unwinds to the nearest recovery
+ * frame. Setup's run-all isolates each step with `recover` so one failed step
+ * cannot abort the rest (S1-1); that only works if step failures travel the
+ * failure channel. The boundary (`asPragmaError`) unwraps the carried cause,
+ * so a failure that escapes un-recovered still renders with its own code,
+ * message, and recovery — never the INTERNAL_ERROR catch-all.
+ */
+export function failPragma(error: PragmaError): Task<never> {
+  return fail({ code: error.code, message: error.message, cause: error });
+}
+
+/**
+ * The failure-channel sibling of {@link assertExecOk}: yield `pure(undefined)`
+ * on exit 0, otherwise fail with an UNSUPPORTED {@link PragmaError} carrying
+ * the command, exit code, trimmed stderr, and the CALLER'S recovery — the
+ * recovery must name an action that works on this machine now, not the generic
+ * "permissions or network" guess.
+ *
+ * @param command - Human-readable command, surfaced in the error message.
+ * @param result - The {@link ExecResult} the `exec` effect yielded.
+ * @param recovery - The actionable, site-specific recovery.
+ * @returns A Task that succeeds on exit 0 and fails (recoverably) otherwise.
+ */
+export function checkExecOk(
+  command: string,
+  result: ExecResult,
+  recovery: Recovery,
+): Task<void> {
+  if (result.exitCode === 0) return pure(undefined);
+  const stderr = result.stderr.trim();
+  return failPragma(
+    new PragmaError({
+      code: "UNSUPPORTED",
+      message: `\`${command}\` exited with code ${result.exitCode}.${
+        stderr ? `\n${stderr}` : ""
+      }`,
+      recovery,
+    }),
+  );
+}
 
 /**
  * Raise UNSUPPORTED when an `exec` result carries a nonzero exit code.
@@ -40,7 +93,7 @@ export function assertExecOk(command: string, result: ExecResult): void {
     }`,
     recovery: {
       message:
-        "The command failed — often a permissions or network issue. Check the output above and retry (for a global install, try elevated privileges).",
+        "Check the command's output above; a global install may need elevated privileges.",
     },
   });
 }
@@ -93,11 +146,16 @@ export function guardMissingBinary<A>(
 ): Task<A> {
   return recover(task, (error) => {
     if (isMissingBinaryError(error)) {
-      throw new PragmaError({
-        code: "UNSUPPORTED",
-        message: `\`${bin}\` was not found on your PATH.`,
-        recovery,
-      });
+      // Failure CHANNEL, not a synchronous throw: an enclosing recover (the
+      // run-all's per-step isolation, S1-1) must be able to catch this, and
+      // the boundary unwraps the carried PragmaError when nothing does.
+      return failPragma(
+        new PragmaError({
+          code: "UNSUPPORTED",
+          message: `\`${bin}\` was not found on your PATH.`,
+          recovery,
+        }),
+      );
     }
     // Not a missing binary — re-raise unchanged (the interpreter rethrows it as
     // a TaskExecutionError, exactly as it would with no guard installed).

package/src/capabilities/shared/index.ts

@@ -0,0 +1,32 @@
+/**
+ * The cross-capability shared surface — the few facts more than one capability
+ * needs and none of them owns.
+ *
+ * Everything here earned its place by being needed in two capabilities at
+ * once, and the cohesion principle is that shortness of the list. `shared/` is
+ * not a utility drawer: a helper used by exactly one capability belongs in
+ * that capability, and the moment something here has a single consumer again
+ * it should move back. What survives is the environment the CLI reports on but
+ * does not own — how it was installed, what the registry says about it,
+ * whether a subprocess it ran actually succeeded — plus the one piece of
+ * vocabulary (`BAND_LABELS`) that keeps `setup` and `doctor` calling the two
+ * config bands by the same names users meet in the flags.
+ *
+ * The exec guard is exported as the pair a caller needs together: `checkExecOk`
+ * to classify a result inside a Task and `assertExecOk` to throw on one
+ * outside, with `guardMissingBinary` wrapping the absent-binary case that
+ * neither should report as a pragma bug. The predicates they are built from
+ * stay internal — a caller reaching for the predicate instead of the guard is
+ * a caller about to reimplement the classification.
+ */
+
+export {
+  assertExecOk,
+  checkExecOk,
+  guardMissingBinary,
+} from "./assertExecOk.js";
+export { BAND_LABELS } from "./bands.js";
+export type { InstallSource } from "./packageManager.js";
+export { detectInstallSource, pmUpdateCommand } from "./packageManager.js";
+export type { RegistryCheckResult } from "./registry.js";
+export { checkRegistryVersion, PRAGMA_PACKAGE } from "./registry.js";

package/src/capabilities/shared/packageManager.test.ts

@@ -0,0 +1,55 @@
+/**
+ * The install-scope heuristic's two path questions.
+ *
+ * `detectInstallSource` itself reads `import.meta.url` and the real working
+ * directory, so the decision it makes is exercised here through the two pure
+ * helpers it composes — which is where every case that has ever been wrong
+ * lives.
+ */
+
+import { describe, expect, it } from "vitest";
+import { containsPath, findInstallRoot } from "./packageManager.js";
+
+describe("findInstallRoot", () => {
+  it("yields the directory the package was installed into", () => {
+    expect(
+      findInstallRoot(
+        "/proj/node_modules/@canonical/pragma-cli/dist/src/bin.js",
+      ),
+    ).toBe("/proj");
+  });
+
+  it("takes the INNERMOST node_modules when they nest", () => {
+    expect(
+      findInstallRoot("/proj/node_modules/a/node_modules/b/dist/bin.js"),
+    ).toBe("/proj/node_modules/a");
+  });
+
+  it("reports no install root for a source checkout", () => {
+    expect(findInstallRoot("/work/pragma/packages/cli/pragma/src/bin.ts")).toBe(
+      undefined,
+    );
+  });
+});
+
+describe("containsPath", () => {
+  it("counts a directory as containing itself", () => {
+    expect(containsPath("/proj", "/proj")).toBe(true);
+  });
+
+  // The case a literal cwd-prefix test got wrong: an ordinary local install run
+  // from a subdirectory — which in a monorepo is the usual way to run it — was
+  // reported as a GLOBAL install.
+  it("counts a subdirectory as contained", () => {
+    expect(containsPath("/proj", "/proj/packages/foo")).toBe(true);
+  });
+
+  it("does not count a sibling that merely shares a prefix", () => {
+    expect(containsPath("/proj", "/proj-two")).toBe(false);
+  });
+
+  it("does not count an ancestor or an unrelated tree", () => {
+    expect(containsPath("/proj/packages/foo", "/proj")).toBe(false);
+    expect(containsPath("/usr/lib", "/home/u/proj")).toBe(false);
+  });
+});

package/src/capabilities/shared/packageManager.ts

@@ -4,12 +4,15 @@
  *
  * Promotes the detector that lived inline in `info/collectInfo.ts`: the package
  * manager comes from npm's `npm_config_user_agent` (set by npm/pnpm/yarn/bun
- * when they run a script), the scope from whether the binary sits under
- * `node_modules`. With no agent we report the honest runtime rather than
- * guessing. The old shell's full package.json walk (`#package-manager`) is
+ * when they run a script), the scope from whether the installed entry sits
+ * under the CURRENT PROJECT. With no agent we report the honest runtime rather
+ * than guessing. The old shell's full package.json walk (`#package-manager`) is
  * dropped — only this heuristic and the update-command map survive.
  */
 
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+
 /** The install source: package manager and a display label. */
 export interface InstallSource {
   /** Package-manager name (`bun`/`npm`/`pnpm`/`yarn`), else the honest runtime. */
@@ -30,11 +33,64 @@ function packageManager(): string {
  * Detect how the binary was installed — package manager and scope.
  *
  * @returns The install source (pm, label).
- * @note Impure — reads `process.argv`/`process.env`.
+ * @note Impure — reads `import.meta.url`, the working directory, and `process.env`.
  */
+/**
+ * The directory a package was installed INTO — the parent of the `node_modules`
+ * holding it, so `/proj/node_modules/@scope/x/dist/bin.js` yields `/proj`.
+ *
+ * The LAST occurrence, because nested `node_modules` mean the innermost one is
+ * the tree the entry actually lives in.
+ *
+ * @param entry - Absolute path to the running module.
+ * @returns The install root, or `undefined` when the entry is not installed at
+ *   all (a source checkout, where no `node_modules` segment appears).
+ * @remarks Exported for its unit test; not part of the package's public surface.
+ */
+export function findInstallRoot(entry: string): string | undefined {
+  const segments = entry.split(sep);
+  const index = segments.lastIndexOf("node_modules");
+  return index === -1 ? undefined : segments.slice(0, index).join(sep);
+}
+
+/**
+ * Whether `directory` contains `candidate`, or is it.
+ *
+ * Compared through `relative()` rather than a string prefix: a prefix test needs
+ * a hard-coded separator (wrong on Windows) and would call `/proj-two` a child
+ * of `/proj`.
+ *
+ * @param directory - The containing directory.
+ * @param candidate - The path to test.
+ * @returns True when `candidate` is `directory` or sits beneath it.
+ * @remarks Exported for its unit test; not part of the package's public surface.
+ */
+export function containsPath(directory: string, candidate: string): boolean {
+  const offset = relative(directory, candidate);
+  return offset === "" || (!offset.startsWith("..") && !isAbsolute(offset));
+}
+
 export function detectInstallSource(): InstallSource {
-  const bin = process.argv[1] ?? "";
-  const scope = bin.includes("node_modules") ? "local" : "global";
+  // The entry's own location, NOT `process.argv[1]`. Under the compiled binary
+  // argv[1] was the user's FIRST ARGUMENT (the executable was argv[0]), so the
+  // old `includes("node_modules")` test read a command word and answered
+  // "global" for almost everything. Shipping `node dist/src/bin.js` moves the
+  // entry path INTO argv[1], where it always contains `node_modules` — which
+  // would answer "local" for everything, the same bug facing the other way.
+  // `import.meta.url` is the honest source either way.
+  const entry = fileURLToPath(import.meta.url);
+  // LOCAL means the working directory sits inside the project this package was
+  // installed into — not merely that the entry sits under the cwd. Asking the
+  // narrower question called a perfectly ordinary local install "global" the
+  // moment the user ran it from a subdirectory, which in a monorepo is the
+  // usual case. Going the other way, deriving the install root also settles the
+  // $HOME-nested global prefixes (nvm, `~/.npm-global`): their root is the
+  // prefix, which contains no user project.
+  const root = findInstallRoot(entry);
+  const scope =
+    root !== undefined && containsPath(root, resolve(process.cwd()))
+      ? "local"
+      : "global";
   const pm = packageManager();
   return { pm, label: `${pm} (${scope})` };
 }

package/src/capabilities/skill/discover.ts

@@ -13,6 +13,7 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
+import { BIN_NAME } from "../../constants.js";
 
 /** Parsed SKILL.md frontmatter. */
 export interface SkillFrontmatter {
@@ -103,26 +104,44 @@ export function parseFrontmatter(content: string): SkillFrontmatter | null {
 }
 
 /**
- * The installed-skills root: `$XDG_DATA_HOME/pragma/skills`. This is where
+ * The installed-skills root: `$XDG_DATA_HOME/<bin>/skills`. This is where
  * `sources update` INSTALLS package-provided skills (U10) — a symlink per skill
  * — and the second discovery root below reads them back. The single source of
  * truth for both, so the install target and the discovery root can never drift.
+ *
+ * Namespaced by {@link BIN_NAME}, like config, state and cache: two
+ * distributions installed side by side owned ONE skills root, so a `recipes`
+ * build served skills a `pragma` build had installed and could not install its
+ * own without colliding.
  */
 export function installedSkillsDir(): string {
   const dataHome =
     process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share");
-  return join(dataHome, "pragma", "skills");
+  return join(dataHome, BIN_NAME, "skills");
+}
+
+/**
+ * The project skills root: `<cwd>/.<bin>/skills` — skills that belong to THIS
+ * repository and travel with it. Named separately from {@link skillRoots}
+ * because the two roots are also the two setup BANDS: `setup skills --local`
+ * links this root into the project's harness directories, while the global band
+ * links {@link installedSkillsDir} into the user-level ones. Mixing them leaks
+ * machine state into a repository's directories, or applies one repository's
+ * skills machine-wide.
+ */
+export function projectSkillsDir(cwd: string): string {
+  return join(cwd, `.${BIN_NAME}`, "skills");
 }
 
 /**
  * The conventional roots skills are discovered from, in PRECEDENCE order: the
- * project root (`<cwd>/.pragma/skills`) FIRST so a project-local skill overrides
+ * project root (`<cwd>/.<bin>/skills`) FIRST so a project-local skill overrides
  * an installed skill of the same name (`discoverSkills` dedups first-seen-wins),
- * then installed skills under `$XDG_DATA_HOME/pragma/skills` (where package
+ * then installed skills under `$XDG_DATA_HOME/<bin>/skills` (where package
  * skills land on `sources update`).
  */
 export function skillRoots(cwd: string): string[] {
-  return [join(cwd, ".pragma", "skills"), installedSkillsDir()];
+  return [projectSkillsDir(cwd), installedSkillsDir()];
 }
 
 /** Immediate subdirectories of `root` (each a candidate skill folder). */
@@ -143,16 +162,24 @@ function subdirs(root: string): string[] {
 }
 
 /**
- * Discover every skill reachable from the conventional roots.
+ * Discover every skill reachable from an EXPLICIT list of roots, in precedence
+ * order (first-seen wins on a duplicate name).
  *
- * @param cwd - The project directory (project skills root).
+ * Split out of {@link discoverSkills} so a caller that owns one band can read
+ * exactly that band's root: `setup skills` links the project root into project
+ * harness directories and the installed root into user-level ones, and reading
+ * both roots for either band is what used to mix the two.
+ *
+ * @param roots - The roots to read, in precedence order.
  * @returns Discovered skills, sorted by name; malformed ones are skipped.
  * @note Impure — reads SKILL.md files.
  */
-export function discoverSkills(cwd: string): DiscoveredSkill[] {
+export function discoverSkillsFrom(
+  roots: readonly string[],
+): DiscoveredSkill[] {
   const skills: DiscoveredSkill[] = [];
   const seen = new Set<string>();
-  for (const root of skillRoots(cwd)) {
+  for (const root of roots) {
     for (const dir of subdirs(root)) {
       let content: string;
       try {
@@ -176,3 +203,14 @@ export function discoverSkills(cwd: string): DiscoveredSkill[] {
     a.name < b.name ? -1 : a.name > b.name ? 1 : 0,
   );
 }
+
+/**
+ * Discover every skill reachable from the conventional roots.
+ *
+ * @param cwd - The project directory (project skills root).
+ * @returns Discovered skills, sorted by name; malformed ones are skipped.
+ * @note Impure — reads SKILL.md files.
+ */
+export function discoverSkills(cwd: string): DiscoveredSkill[] {
+  return discoverSkillsFrom(skillRoots(cwd));
+}

package/src/capabilities/skill/index.ts

@@ -2,7 +2,7 @@
  * The `skill` capability module — storeless filesystem discovery.
  */
 
-import type { CapabilityModule } from "../../kernel/spec/types.js";
+import type { CapabilityModule } from "../../kernel/spec/index.js";
 import { skillListVerb, skillLookupVerb } from "./verbs.js";
 
 /** The `skill` capability module (`list`, `lookup`). */

package/src/capabilities/skill/render.ts

@@ -2,26 +2,26 @@
  * Formatters for `skill list` and `skill lookup`.
  */
 
-import type { Formatters } from "../../kernel/spec/types.js";
+import { BIN_NAME } from "../../constants.js";
+import type { Formatters } from "../../kernel/spec/index.js";
 import type { DiscoveredSkill } from "./discover.js";
 import type { SkillLookup } from "./verbs.js";
 
-/** Empty-state guidance (U5) — where skills come from now that packages ship them. */
-const EMPTY_PLAIN =
-  "No skills found.\nSkills come from installed design-system packages — add one to your config, run `pragma sources update`, then `pragma setup skills`.";
-const EMPTY_LLM =
-  "## Skills (0)\n\nNo skills found. Skills come from installed design-system packages — add one to the project config, run `pragma sources update`, then `pragma setup skills`.";
+/** Empty-state guidance (U5) — where skills come from now that packs ship them. */
+const EMPTY_PLAIN = `No skills found.\nSkills come from design-system packs — add one to your config's packs, run \`${BIN_NAME} sources update\`, then \`${BIN_NAME} setup skills\`.`;
+const EMPTY_LLM = `## Skills (0)\n\nNo skills found. Skills come from design-system packs — add one to the project config's packs, run \`${BIN_NAME} sources update\`, then \`${BIN_NAME} setup skills\`.`;
 
 export const skillListFormatters: Formatters<DiscoveredSkill[]> = {
+  // Zero skills: plain stdout stays empty — the guidance is `emptyNotice`,
+  // which the dispatcher routes to stderr (exit 0) so a pipe reads no prose.
   plain: (skills) =>
-    skills.length === 0
-      ? EMPTY_PLAIN
-      : skills
-          .map(
-            (s) =>
-              `${s.name}${s.frontmatter.prompt ? " (prompt)" : ""}  ${s.description}`,
-          )
-          .join("\n"),
+    skills
+      .map(
+        (s) =>
+          `${s.name}${s.frontmatter.prompt ? " (prompt)" : ""}  ${s.description}`,
+      )
+      .join("\n"),
+  emptyNotice: (skills) => (skills.length === 0 ? EMPTY_PLAIN : undefined),
   llm: (skills) =>
     skills.length === 0
       ? EMPTY_LLM

package/src/capabilities/skill/skill.test.ts

@@ -85,11 +85,13 @@ describe("skill lookup (storeless)", () => {
 });
 
 describe("skill list empty-state (U5)", () => {
-  it("plain output is non-blank and guides toward package sources", () => {
-    const plain = skillListFormatters.plain([]);
-    expect(plain).not.toBe("");
-    expect(plain).toContain("No skills found");
-    expect(plain).toContain("pragma sources update");
+  it("the empty notice (stderr's text) guides toward package sources", () => {
+    // Zero skills: plain stdout is empty (a pipe reads no prose) and the
+    // guidance rides the dispatcher's stderr via `emptyNotice`.
+    expect(skillListFormatters.plain([])).toBe("");
+    const notice = skillListFormatters.emptyNotice?.([]);
+    expect(notice).toContain("No skills found");
+    expect(notice).toContain("pragma sources update");
   });
 
   it("llm output announces zero and guides, json stays []", () => {

package/src/capabilities/skill/verbs.ts

@@ -8,11 +8,12 @@
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-import { PragmaError } from "../../kernel/error/PragmaError.js";
+import { BIN_NAME } from "../../constants.js";
+import { cliRecovery, PragmaError } from "../../kernel/error/index.js";
 import { suggestNames } from "../../kernel/project/cli/suggestNames.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
+import type { PragmaRuntime } from "../../kernel/runtime/index.js";
 import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { VerbSpec } from "../../kernel/spec/types.js";
+import type { VerbSpec } from "../../kernel/spec/index.js";
 import { type DiscoveredSkill, discoverSkills } from "./discover.js";
 import { skillListFormatters, skillLookupFormatters } from "./render.js";
 
@@ -26,7 +27,7 @@ const listVerb: VerbSpec<Record<string, unknown>, DiscoveredSkill[]> = {
   summary: "List discovered skills (SKILL.md files under the skill roots).",
   params: [],
   output: { formatters: skillListFormatters },
-  examples: [{ cmd: "pragma skill list" }],
+  examples: [{ cmd: `${BIN_NAME} skill list` }],
   capability: {
     needsStore: false,
     mutates: false,
@@ -53,7 +54,7 @@ const lookupVerb: VerbSpec<Record<string, unknown>, SkillLookup> = {
     },
   ],
   output: { formatters: skillLookupFormatters },
-  examples: [{ cmd: "pragma skill lookup docx" }],
+  examples: [{ cmd: `${BIN_NAME} skill lookup docx` }],
   capability: {
     needsStore: false,
     mutates: false,
@@ -74,11 +75,9 @@ const lookupVerb: VerbSpec<Record<string, unknown>, SkillLookup> = {
           name,
           skills.map((skill) => skill.name),
         ),
-        recovery: {
-          message: "List discovered skills.",
-          cli: "pragma skill list",
-          mcp: { tool: "skill_list" },
-        },
+        recovery: cliRecovery("skill list", "List discovered skills.", {
+          tool: "skill_list",
+        }),
       });
     }
     return { ...match, instructions: readInstructions(match.sourcePath) };

package/src/capabilities/sources/collectStatus.ts

@@ -1,35 +1,37 @@
 /**
  * Collect the `sources status` payload — storeless.
  *
- * Reports the store's readiness without booting it: it reads the lock, the
- * resolved config, and — if the locked pack is cached — the manifest and the
- * index.json count (a plain `JSON.parse`, no store, no oxigraph). This is the
- * capability that must stay off the store factory (the storeless-guarantee spy
- * covers it), so it reaches for the pack files directly rather than through a
- * store session. It absorbs the v1 `info store` summary.
+ * Reports the store's readiness without booting it. The `store` field IS the
+ * boot decision ({@link resolveSources}) — status never re-derives which pack
+ * answers reads, so it can never disagree with what the next read actually
+ * loads. Everything else is provenance read straight off that pack's manifest
+ * (a plain `JSON.parse`, no store, no oxigraph). This is the capability that
+ * must stay off the store factory (the storeless-guarantee spy covers it). It
+ * absorbs the v1 `info store` summary.
  */
 
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import type { PackageEntry } from "../../kernel/config/types.js";
+import type { PackDeclaration } from "../../kernel/config/index.js";
+// DIRECT LEAF IMPORTS, not `graphpack/index.js`. The barrel re-exports
+// `build.ts`/`read.ts` (pulling `@canonical/ke` and `@canonical/ke-graphql`)
+// and `embedded.ts`, whose generated payload is ~1.9 MB. `sources status`
+// reads two manifests and prints them; routing that through the barrel
+// would make a status-only command initialise the whole pack stack.
+import { embeddedManifest } from "../../kernel/runtime/graphpack/embedded.js";
 import { readManifest } from "../../kernel/runtime/graphpack/manifest.js";
 import { INDEX_FILE } from "../../kernel/runtime/graphpack/types.js";
-import { readLock } from "../../kernel/runtime/lock.js";
-import { packDir } from "../../kernel/runtime/paths.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import type {
-  SourceStaleness,
-  SourceStatusEntry,
-  SourcesStatusData,
-} from "./types.js";
+import type { PragmaRuntime } from "../../kernel/runtime/index.js";
+import { resolveSources } from "../../kernel/runtime/resolveSources.js";
+import type { SourcesStatusData } from "./types.js";
 
-const entryName = (entry: PackageEntry): string =>
+const entryName = (entry: PackDeclaration): string =>
   typeof entry === "string" ? entry : entry.name;
-const entrySource = (entry: PackageEntry): string =>
+const entrySource = (entry: PackDeclaration): string =>
   typeof entry === "string" ? entry : (entry.source ?? entry.name);
 
 /**
- * The distinct-abox entity count from a cached pack's index.json (storeless).
+ * The distinct-abox entity count from a built pack's index.json (storeless).
  *
  * Only reached for LEGACY packs whose manifest predates the persisted
  * `entityCount` (A10) — a current pack's count is read straight from the
@@ -59,44 +61,52 @@ function indexEntityCount(dir: string): number | null {
  *
  * @param runtime - The per-invocation runtime.
  * @returns The storeless status payload.
- * @note Impure — reads config, the lock, and the pack cache from disk.
+ * @note Impure — reads config, the active-pack pointer, and the pack cache.
  */
 export async function collectStatus(
   runtime: PragmaRuntime,
 ): Promise<SourcesStatusData> {
   const layers = await runtime.loadConfig();
-  const entries = layers.config.packages ?? [];
-  const lock = readLock(runtime.cwd);
+  const sources = (layers.config.packs ?? []).map((entry) => ({
+    name: entryName(entry),
+    ref: entrySource(entry),
+  }));
+  const decision = resolveSources(layers, runtime.cwd);
+  const base = { cwd: runtime.cwd, sources };
 
-  const dir = lock ? packDir(lock.contentHash) : undefined;
-  const manifest = dir ? readManifest(dir) : undefined;
-  const cached = manifest !== undefined;
-
-  const sources: SourceStatusEntry[] = entries.map((entry) => {
-    const name = entryName(entry);
-    const ref = entrySource(entry);
-    const lockEntry = lock?.packs.find((pack) => pack.name === name);
-    let staleness: SourceStaleness;
-    if (!lock || !cached) {
-      staleness = "uncached";
-    } else if (!lockEntry || lockEntry.source !== ref) {
-      staleness = "config-drift";
-    } else {
-      staleness = "up-to-date";
+  switch (decision.kind) {
+    case "embedded": {
+      const manifest = embeddedManifest();
+      return {
+        ...base,
+        store: "embedded",
+        contentHash: manifest.contentHash,
+        sourceRef: manifest.sourceRef,
+        builtAt: manifest.createdAt,
+        entityCount: manifest.entityCount ?? null,
+      };
     }
-    return { name, ref, resolved: lockEntry?.resolved ?? null, staleness };
-  });
-
-  return {
-    cwd: runtime.cwd,
-    lockPresent: lock !== undefined,
-    contentHash: lock?.contentHash ?? null,
-    cached,
-    builtAt: manifest?.createdAt ?? null,
-    // Prefer the manifest's persisted count (no index parse); a legacy pack
-    // without it falls back to counting the index's abox subjects (A10).
-    entityCount:
-      dir && cached ? (manifest?.entityCount ?? indexEntityCount(dir)) : null,
-    sources,
-  };
+    case "pack": {
+      const manifest = readManifest(decision.dir);
+      return {
+        ...base,
+        store: "built",
+        contentHash: decision.contentHash,
+        sourceRef: manifest?.sourceRef ?? null,
+        builtAt: manifest?.createdAt ?? null,
+        // Prefer the manifest's persisted count (no index parse); a legacy pack
+        // without it falls back to counting the index's abox subjects (A10).
+        entityCount: manifest?.entityCount ?? indexEntityCount(decision.dir),
+      };
+    }
+    case "unavailable":
+      return {
+        ...base,
+        store: "unavailable",
+        contentHash: null,
+        sourceRef: null,
+        builtAt: null,
+        entityCount: null,
+      };
+  }
 }