@canonical/pragma-cli 0.33.0 → 0.34.0

package/src/capabilities/skill/render.ts

@@ -2,15 +2,14 @@
  * Formatters for `skill list` and `skill lookup`.
  */
 
+import { BIN_NAME } from "../../constants.js";
 import type { Formatters } from "../../kernel/spec/types.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[]> = {
   plain: (skills) =>

package/src/capabilities/skill/verbs.ts

@@ -8,7 +8,9 @@
 
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+import { BIN_NAME } from "../../constants.js";
 import { PragmaError } from "../../kernel/error/PragmaError.js";
+import { cliRecovery } from "../../kernel/error/recovery.js";
 import { suggestNames } from "../../kernel/project/cli/suggestNames.js";
 import type { PragmaRuntime } from "../../kernel/runtime/types.js";
 import { asVerb } from "../../kernel/spec/asVerb.js";
@@ -26,7 +28,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 +55,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 +76,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,32 @@
 /**
  * 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/types.js";
+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 { resolveSources } from "../../kernel/runtime/resolveSources.js";
 import type { PragmaRuntime } from "../../kernel/runtime/types.js";
-import type {
-  SourceStaleness,
-  SourceStatusEntry,
-  SourcesStatusData,
-} from "./types.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 +56,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,
+      };
+  }
 }

package/src/capabilities/sources/index.ts

@@ -1,6 +1,6 @@
 /**
  * The `sources` capability barrel — `status` (storeless read) and `update`
- * (the resolve/build/lock Task).
+ * (the resolve/build/point Task).
  */
 
 import { asVerb } from "../../kernel/spec/asVerb.js";

package/src/capabilities/sources/installSkills.ts

@@ -4,9 +4,9 @@
  * Design-system packages ship a top-level `skills/<name>/SKILL.md`, but skill
  * discovery only scans the project root and the installed-skills root — never a
  * resolved package's clone/dir. So `sources update` INSTALLS each package's
- * skills into the installed-skills root (`$XDG_DATA_HOME/pragma/skills`) as
+ * skills into the installed-skills root (`$XDG_DATA_HOME/<bin>/skills`) as
  * symlinks, exactly the root `discoverSkills` already reads. Precedence is
- * preserved (a project `.pragma/skills` entry still wins — it is discovered
+ * preserved (a project `.<bin>/skills` entry still wins — it is discovered
  * first), and the update Task stays reversible (each created link carries an
  * unlink undo).
  *

package/src/capabilities/sources/runUpdate.ts

@@ -5,18 +5,19 @@
  *
  * - Preview (CLI `--dry-run`, or MCP without `confirm`): NETWORK-FREE. It reads
  *   only the config, then hands back a plan-only Task listing the refs it would
- *   resolve+build and the lock it would write — no git fetch, no compile, no
+ *   resolve+build and the pointer it would write — no git fetch, no compile, no
  *   cache write. This is what a dry-run / agent "preview" must be: side-effect
  *   free and offline-safe.
- * - Real execution: the heavy work — resolve every configured package (git
+ * - Real execution: the heavy work — resolve every configured pack (git
  *   clone/fetch, file verify, npm resolve), then build the ONE combined
  *   content-addressed pack — runs eagerly (it is not expressible as a task
  *   effect: the effect set is fs + exec, and the in-process compile is not an
- *   effect at all). The returned Task models the one project mutation, the
- *   `pragma.lock.json` write, with an undo that restores (or removes) the prior
- *   lock. Under `--frozen` each package re-resolves to the lock's pinned
- *   revision and keeps its `resolvedAt`, so an unchanged update rewrites a
- *   byte-identical lock.
+ *   effect at all). The returned Task models the mutations: the active-pack
+ *   pointer write (undo restores or removes the prior pointer) and the package
+ *   skill symlinks.
+ *
+ * Pinning a revision is the ref's job, not a flag's: put a SHA in the source
+ * (`git+https://…#<sha>`) and every update resolves to exactly that commit.
  */
 
 import {
@@ -29,20 +30,14 @@ import {
   type Task,
   writeFile,
 } from "@canonical/task";
-import { RECOVERY_CLI_PREFIX, VERSION } from "../../constants.js";
-import type { PackageEntry } from "../../kernel/config/types.js";
+import { VERSION } from "../../constants.js";
 import { PragmaError } from "../../kernel/error/PragmaError.js";
 import { cliRecovery } from "../../kernel/error/recovery.js";
 import { buildPack } from "../../kernel/runtime/graphpack/build.js";
-import {
-  type PragmaLock,
-  readLock,
-  serializeLock,
-} from "../../kernel/runtime/lock.js";
-import { LOCK_BASENAME, lockPath } from "../../kernel/runtime/paths.js";
+import { activePackPath, readActivePack } from "../../kernel/runtime/paths.js";
 import type { PackageRef } from "../../kernel/runtime/refs/parseRef.js";
 import {
-  parsePackageEntry,
+  parsePackDeclaration,
   redactUrl,
 } from "../../kernel/runtime/refs/parseRef.js";
 import {
@@ -67,17 +62,43 @@ const CORE_PREFIXES: Readonly<Record<string, string>> = {
   dcterms: "http://purl.org/dc/terms/",
 };
 
-const entryName = (entry: PackageEntry): string =>
-  typeof entry === "string" ? entry : entry.name;
+/**
+ * The prefix map a pack is built with: core < the packs' own `@prefix` < config.
+ *
+ * A resolved package's own declarations are harvested from its TTL (ke does not
+ * fold parsed-Turtle prefixes into `store.prefixes`) and merged beneath config
+ * so the index compacts pack URIs to `pfx:Local` — the FROZEN `{name,type}`
+ * token contract — while config still wins any clash. The merged map is
+ * persisted in the manifest, so boot reads the same names.
+ *
+ * Exported because the bundler (`scripts/bundle.ts`) compiles the embedded pack
+ * through this exact precedence. If the two pipelines computed prefixes
+ * separately, the embed could compact entities differently from what the SAME
+ * config produces on a user's machine — a silent divergence in entity names.
+ *
+ * @param inputs - The resolved packages' labelled RDF sources.
+ * @param configPrefixes - The config layer's `prefixes`, if any.
+ * @returns The merged prefix map to build with.
+ */
+export function buildPackPrefixes(
+  inputs: readonly { readonly content: string }[],
+  configPrefixes: Readonly<Record<string, string>> | undefined,
+): Record<string, string> {
+  return {
+    ...CORE_PREFIXES,
+    ...harvestPrefixes(inputs),
+    ...(configPrefixes ?? {}),
+  };
+}
 
 /**
  * Build the NETWORK-FREE preview plan for `sources update`.
  *
  * A plan-only Task: it reads the config to list the refs a real update would
- * resolve and build, then models the single project mutation (the lock write)
- * as effects the dry-run interpreter can describe WITHOUT running them. No git,
- * no compile, no cache write — so `--dry-run` and an MCP plan-first call are
- * offline-safe. Config refs are parsed (a cheap, offline validity check) but
+ * resolve and build, then models the project mutation (the active-pack pointer
+ * write) as effects the dry-run interpreter can describe WITHOUT running them.
+ * No git, no compile, no cache write — so `--dry-run` and an MCP plan-first call
+ * are offline-safe. Config refs are parsed (a cheap, offline validity check) but
  * never resolved.
  *
  * @param runtime - The per-invocation runtime.
@@ -87,57 +108,51 @@ async function buildUpdatePlan(
   runtime: PragmaRuntime,
 ): Promise<Task<SourcesUpdateData>> {
   const layers = await runtime.loadConfig();
-  const entries = layers.config.packages ?? [];
-  const refs = entries.map(parsePackageEntry);
-  const path = lockPath(runtime.cwd);
+  const entries = layers.config.packs ?? [];
+  const refs = entries.map(parsePackDeclaration);
 
   const data: SourcesUpdateData = {
     contentHash: "",
     reused: false,
-    lockPath: path,
-    packs: refs.map((ref) => ({ name: ref.pkg, resolved: "", sourceCount: 0 })),
-  };
-  // A representative (never-written) lock, so the previewed write shows a
-  // plausible shape/size. Placeholders make clear nothing was resolved.
-  const previewLock: PragmaLock = {
-    version: 1,
-    contentHash: "(resolved on execute)",
     packs: refs.map((ref) => ({
       name: ref.pkg,
-      source: ref.source,
-      resolved: "(resolved on execute)",
-      resolvedAt: "(resolved on execute)",
+      resolved: "",
+      sourceCount: 0,
+      storyCount: 0,
     })),
   };
-  const previewContent = serializeLock(previewLock);
 
   return gen(function* () {
     yield* $(
       info(
         refs.length > 0
-          ? `Resolve and build ${refs.length} package(s): ${refs.map((ref) => ref.source).join(", ")}`
-          : "No packages configured — the embedded pack answers store reads",
+          ? `Resolve and build ${refs.length} pack(s): ${refs.map((ref) => ref.source).join(", ")}`
+          : "No packs configured — the embedded pack answers store reads",
       ),
     );
-    // The one project mutation, previewed (dry-run never executes it).
-    yield* $(writeFile(path, previewContent));
+    // The project mutation, previewed (dry-run never executes it). The content
+    // is a placeholder: the real hash only exists once the build has run.
+    yield* $(
+      writeFile(activePackPath(runtime.cwd), "(the pack hash, on execute)"),
+    );
     return data;
   });
 }
 
 /**
- * Resolve, build, and produce the lock-writing Task — or, for a preview, the
+ * Resolve, build, and produce the pointer-writing Task — or, for a preview, the
  * network-free plan.
  *
  * @param runtime - The per-invocation runtime.
- * @param frozen - When true, re-resolve to the lock's pinned revisions only.
- * @returns A Task that writes `pragma.lock.json` and returns the update result.
+ * @param skipInvalid - Drop sources that fail to parse (warning about each)
+ *   rather than failing the whole update.
+ * @returns A Task that points the project at the built pack and returns the
+ *   update result.
  * @note Impure — resolves packages (may hit git) and builds the pack eagerly,
  *   UNLESS `runtime.mutation.preview` is set, in which case it stays offline.
  */
 export async function buildUpdateTask(
   runtime: PragmaRuntime,
-  frozen: boolean,
   skipInvalid = false,
 ): Promise<Task<SourcesUpdateData>> {
   if (runtime.mutation?.preview) return buildUpdatePlan(runtime);
@@ -149,55 +164,45 @@ export async function buildUpdateTask(
   const verbose = runtime.globalFlags.verbose;
 
   const layers = await runtime.loadConfig();
-  const entries = layers.config.packages ?? [];
-  const existing = readLock(runtime.cwd);
-  const priorContent = existing ? serializeLock(existing) : undefined;
+  const entries = layers.config.packs ?? [];
+  const priorHash = readActivePack(runtime.cwd);
 
-  const resolved: ResolvedPackage[] = [];
+  const resolved: (ResolvedPackage & { readonly kind: PackageRef["kind"] })[] =
+    [];
   for (const entry of entries) {
-    const ref = parsePackageEntry(entry);
+    const ref = parsePackDeclaration(entry);
     report?.(resolveProgress(ref));
-    const pinned = existing?.packs.find((pack) => pack.name === ref.pkg);
-    resolved.push(
-      await resolvePackage(ref, {
-        cwd: runtime.cwd,
-        frozen,
-        pinned: pinned?.resolved,
-      }),
-    );
+    resolved.push({
+      kind: ref.kind,
+      ...(await resolvePackage(ref, { cwd: runtime.cwd })),
+    });
   }
 
-  // Prefix precedence: core < pack < config. A resolved package's own
-  // `@prefix` declarations are harvested from its TTL and merged beneath config
-  // so the index compacts pack URIs to `pfx:Local` (the FROZEN {name,type}
-  // token contract); config still wins any clash. The merged map is persisted
-  // in the manifest, so boot reads the same names.
   const inputs = resolved.flatMap((pkg) => pkg.sources);
+  // The packages' own `stories/*.json`, carried into the pack verbatim (see
+  // graphpack/types.STORIES_FILE). Raw text: nothing interprets them here.
+  const stories = resolved.flatMap((pkg) => pkg.stories);
 
-  // Refuse to lock an empty store (A4). A package that ships no `.ttl` (or no
-  // configured packages at all) would build a 0-triple pack whose empty
+  // Refuse to build an empty store (A4). A package that ships no `.ttl` (or no
+  // configured packs at all) would build a 0-triple pack whose empty
   // `data.nq` fails the completeness gate — so the "successful" update boots to
   // a PERMANENT `STORE_UNAVAILABLE` loop. Fail loudly here, leaving the embedded
-  // fallback (or the prior lock) intact, instead of writing that broken lock.
+  // pack (or the prior build) answering reads, instead of pointing at that one.
   if (inputs.length === 0) {
     throw PragmaError.configError(
       entries.length === 0
-        ? "No packages are configured, so there are no sources to build a store from. The embedded sample pack answers reads until you add a package."
-        : `The ${entries.length} configured package(s) resolved 0 RDF sources (no definitions/**.ttl or data/**.ttl). Refusing to write a lock for an empty store.`,
+        ? "No packs are configured, so there are no sources to build a store from. The embedded pack answers reads until you add a pack."
+        : `The ${entries.length} configured pack(s) resolved 0 RDF sources (no definitions/**.ttl or data/**.ttl). Refusing to build an empty store.`,
       {
         recovery: cliRecovery(
-          `${RECOVERY_CLI_PREFIX}sources update --verbose`,
-          "Add a package that ships `.ttl` under definitions/ or data/, then re-run.",
+          "sources update --verbose",
+          "Add a pack that ships `.ttl` under definitions/ or data/, then re-run.",
         ),
       },
     );
   }
 
-  const prefixes = {
-    ...CORE_PREFIXES,
-    ...harvestPrefixes(inputs),
-    ...(layers.config.prefixes ?? {}),
-  };
+  const prefixes = buildPackPrefixes(inputs, layers.config.prefixes);
 
   // Warn on conflicting `@prefix` declarations across packages (A5): last-wins
   // is silent otherwise, compacting the losing package's URIs to the wrong
@@ -210,6 +215,8 @@ export async function buildUpdateTask(
 
   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)`);
 
   // 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
@@ -217,7 +224,20 @@ export async function buildUpdateTask(
   // With `--skip-invalid`, drop the unparseable sources (warning LOUDLY about
   // each — never a silent partial graph) and build from the rest instead of
   // failing the whole update.
-  const sourceRef = entries.map(entryName).join(",") || "embedded";
+  // `<name>@<kind>:<resolved>` — the SAME provenance label the bundler writes
+  // for the embed, so the manifest field means one thing whoever built the pack,
+  // and `sources status` / `doctor` can still answer "which revision is my store
+  // built from?" now that no lock records it. A `file:` pack resolves to a local
+  // PATH rather than a revision, so it contributes its name alone: a machine
+  // path is not provenance, and `sources status` already lists the ref.
+  const sourceRef =
+    resolved
+      .map((pkg) =>
+        pkg.kind === "file"
+          ? pkg.name
+          : `${pkg.name}@${pkg.kind}:${pkg.resolved}`,
+      )
+      .join(", ") || "embedded";
   let built: Awaited<ReturnType<typeof buildPack>>;
   try {
     built = await buildPack(inputs, {
@@ -225,6 +245,7 @@ export async function buildUpdateTask(
       version: VERSION,
       sourceRef,
       prefixes,
+      stories,
     });
   } catch (error) {
     if (!skipInvalid) throw await classifySourceBuildError(error, inputs);
@@ -244,7 +265,7 @@ export async function buildUpdateTask(
         `All ${inputs.length} configured source(s) failed to parse — nothing to build.`,
         {
           recovery: cliRecovery(
-            `${RECOVERY_CLI_PREFIX}sources update --verbose`,
+            "sources update --verbose",
             "Fix the reported sources, then re-run.",
           ),
         },
@@ -256,11 +277,8 @@ export async function buildUpdateTask(
         sourceRef,
         // Re-harvest prefixes from only the sources that survived, so a dropped
         // file's declarations don't skew compaction.
-        prefixes: {
-          ...CORE_PREFIXES,
-          ...harvestPrefixes(usableInputs),
-          ...(layers.config.prefixes ?? {}),
-        },
+        prefixes: buildPackPrefixes(usableInputs, layers.config.prefixes),
+        stories,
       });
     } catch (rebuildError) {
       throw await classifySourceBuildError(rebuildError, usableInputs);
@@ -270,64 +288,37 @@ export async function buildUpdateTask(
     `${built.reused ? "Reused" : "Built"} store ${built.contentHash.slice(0, 12)}`,
   );
 
-  // Refuse to lock a 0-triple build (A4): non-empty sources can still parse to
-  // no triples (e.g. comment-only TTL, or a file of only `@prefix` lines). A
-  // locked empty pack boots to the same `STORE_UNAVAILABLE` loop, so treat it
-  // as a data error rather than a silent "success". (A manifest predating the
-  // triple count is left alone — `undefined` never trips this.)
+  // Refuse a 0-triple build (A4): non-empty sources can still parse to no
+  // triples (e.g. comment-only TTL, or a file of only `@prefix` lines). Pointing
+  // the project at an empty pack boots to the same `STORE_UNAVAILABLE` loop, so
+  // treat it as a data error rather than a silent "success". (A manifest
+  // predating the triple count is left alone — `undefined` never trips this.)
   if (built.manifest.tripleCount === 0) {
     throw PragmaError.configError(
-      `The configured sources parsed to 0 RDF triples, so the store would be empty. Refusing to write a lock for an empty store.`,
+      `The configured sources parsed to 0 RDF triples, so the store would be empty. Refusing to build an empty store.`,
       {
         recovery: cliRecovery(
-          `${RECOVERY_CLI_PREFIX}sources update --verbose`,
+          "sources update --verbose",
           "Check that the package sources actually contain RDF triples, then re-run.",
         ),
       },
     );
   }
 
-  const now = new Date().toISOString();
-  const lock: PragmaLock = {
-    version: 1,
-    contentHash: built.contentHash,
-    packs: resolved.map((pkg) => {
-      const prev = existing?.packs.find((entry) => entry.name === pkg.name);
-      // Preserve the prior `resolvedAt` when nothing actually changed — under
-      // --frozen (re-pinned to the same revision) AND on a plain re-run that
-      // resolves the IDENTICAL revision from the same source. Otherwise every
-      // `sources update` stamped a fresh timestamp and rewrote the lock, dirtying
-      // the git tree on a no-op run (L1). A moved revision still restamps.
-      const reproducible =
-        prev !== undefined &&
-        (frozen ||
-          (prev.resolved === pkg.resolved && prev.source === pkg.source));
-      return {
-        name: pkg.name,
-        source: pkg.source,
-        resolved: pkg.resolved,
-        resolvedAt: reproducible && prev ? prev.resolvedAt : now,
-      };
-    }),
-  };
-  const newContent = serializeLock(lock);
-  const path = lockPath(runtime.cwd);
-
+  const path = activePackPath(runtime.cwd);
   const data: SourcesUpdateData = {
     contentHash: built.contentHash,
     reused: built.reused,
-    lockPath: path,
     packs: resolved.map((pkg) => ({
       name: pkg.name,
       resolved: pkg.resolved,
       sourceCount: pkg.sources.length,
+      storyCount: pkg.stories.length,
     })),
   };
 
   const undo =
-    priorContent !== undefined
-      ? writeFile(path, priorContent)
-      : deleteFile(path);
+    priorHash !== undefined ? writeFile(path, priorHash) : deleteFile(path);
 
   // Install package-provided skills (U10): symlink each resolved package's
   // `skills/*` into the installed-skills root, so `skill list` / `setup skills`
@@ -339,9 +330,9 @@ export async function buildUpdateTask(
   if (skillLinks.length > 0)
     report?.(`Installing ${skillLinks.length} skill(s)`);
 
-  report?.(`Writing ${LOCK_BASENAME}`);
+  report?.(`Pointing ${runtime.cwd} at pack ${built.contentHash.slice(0, 12)}`);
   return gen(function* () {
-    yield* $(writeFile(path, newContent, { undo }));
+    yield* $(writeFile(path, built.contentHash, { undo }));
     if (skillLinks.length > 0) {
       yield* $(mkdir(installedSkillsDir(), true));
       for (const link of skillLinks) {
@@ -398,7 +389,7 @@ export async function classifySourceBuildError(
     : "The configured package sources could not be built into a store";
   return PragmaError.configError(`${where}: ${detail}`, {
     recovery: cliRecovery(
-      `${RECOVERY_CLI_PREFIX}sources update --verbose`,
+      "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.",
     ),
   });