@mean-weasel/lineage 0.1.21 → 0.1.23

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## Unreleased
+
+## 0.1.23
+
+- Make missing Codex CLI failures explain how to restore `PATH`, verify `npx` and Codex prerequisites explicitly, and gate releases on compatibility with the independently published plugin installer.
+- Add a reusable Lineage showcase cover and refine its presentation without browser text-selection artifacts.
+- Show absolute local paths in asset details while preserving safe relative paths in persisted lineage data.
+- Add the public documentation hub, freshness checks, CI routing, and GitHub Pages deployment workflow.
+- Refresh vulnerable transitive dependencies for `brace-expansion`, `postcss`, and `nanoid`.
+
+## 0.1.22
+
+- Harden the landing page, README, and packaged manual dogfood guide with fail-fast first-run commands that complete the post-initialization runtime, profile, database, and service identity gate.
+- Isolate bootstrap dependencies from stable and preview shims so repeat and coexisting channel installs cannot clobber their launchers.
+- Package and scan the manual install runbook, and make the Node.js 22.22+ requirement explicit for the independently published Codex plugin installer.
+- Stabilize the rich-demo browser readiness proof so delayed workspace discovery cannot race the media download check.
+- Make plugin-installer dist-tag promotion verification tolerate npm registry propagation while still failing closed on the wrong version.
+
 ## 0.1.21
 
 - Make immutable annotated tags on reviewed `main` the sole authority for matching npm and GitHub releases, with verified plugin assets built before publication and stable/prerelease channels selected directly from SemVer.

package/MANUAL_INSTALL_DOGFOOD.md

@@ -0,0 +1,341 @@
+# Hermetic manual install dogfood
+
+Use this runbook to exercise the public first-user journey without modifying an
+existing Lineage runtime, profile, database, service, npm prefix, cache, or
+Codex home. Use synthetic demo data only. Never place credentials, customer
+content, private media, or a live SQLite database in the dogfood root.
+
+Run one channel at a time. The primary public journey is `stable`; stop it and
+finish its evidence before beginning a separate checkout-only `dev` journey.
+
+## Prepare isolated roots
+
+Create one owner-only temporary root:
+
+```bash
+DOGFOOD_ROOT="$(mktemp -d /tmp/lineage-manual-dogfood.XXXXXX)"
+chmod 700 "$DOGFOOD_ROOT"
+
+DOGFOOD_HOME="$DOGFOOD_ROOT/home"
+DOGFOOD_NPM_PREFIX="$DOGFOOD_ROOT/npm-global"
+DOGFOOD_NPM_CACHE="$DOGFOOD_ROOT/npm-cache"
+DOGFOOD_RUNTIME_ROOT="$DOGFOOD_ROOT/runtimes"
+DOGFOOD_PROFILE_ROOT="$DOGFOOD_ROOT/profiles"
+DOGFOOD_SERVICE_ROOT="$DOGFOOD_ROOT/services"
+DOGFOOD_CODEX_HOME="$DOGFOOD_ROOT/codex-home"
+DOGFOOD_BASE_PATH="$PATH"
+DOGFOOD_PROFILE="manual-stable"
+DOGFOOD_PORT="5297"
+DOGFOOD_ORIGIN="http://127.0.0.1:$DOGFOOD_PORT"
+
+mkdir -p \
+  "$DOGFOOD_HOME" \
+  "$DOGFOOD_NPM_PREFIX" \
+  "$DOGFOOD_NPM_CACHE" \
+  "$DOGFOOD_RUNTIME_ROOT" \
+  "$DOGFOOD_PROFILE_ROOT" \
+  "$DOGFOOD_SERVICE_ROOT" \
+  "$DOGFOOD_CODEX_HOME"
+```
+
+Keep isolation scoped to each child process instead of exporting it over the
+maintainer's normal shell:
+
+```bash
+run_lineage_dogfood() {
+  env \
+    HOME="$DOGFOOD_HOME" \
+    CODEX_HOME="$DOGFOOD_CODEX_HOME" \
+    LINEAGE_RUNTIME_ROOT="$DOGFOOD_RUNTIME_ROOT" \
+    LINEAGE_PROFILE_ROOT="$DOGFOOD_PROFILE_ROOT" \
+    LINEAGE_SERVICE_ROOT="$DOGFOOD_SERVICE_ROOT" \
+    npm_config_cache="$DOGFOOD_NPM_CACHE" \
+    npm_config_prefix="$DOGFOOD_NPM_PREFIX" \
+    PATH="$DOGFOOD_NPM_PREFIX/bin:$DOGFOOD_RUNTIME_ROOT/bin:$DOGFOOD_BASE_PATH" \
+    "$@"
+}
+```
+
+Confirm the chosen port is unused before profile initialization:
+
+```bash
+lsof -nP -iTCP:"$DOGFOOD_PORT" -sTCP:LISTEN
+```
+
+Choose another port if that prints a listener. The service origin becomes part
+of the immutable profile identity.
+
+## Install the published stable channel
+
+Record the prerequisites and registry selection:
+
+```bash
+run_lineage_dogfood node --version
+run_lineage_dogfood npm --version
+run_lineage_dogfood npx --version
+run_lineage_dogfood codex --version
+run_lineage_dogfood npm view @mean-weasel/lineage dist-tags version engines --json
+```
+
+Install the same global bootstrap and isolated stable runtime documented in the
+public first run:
+
+```bash
+run_lineage_dogfood npm install --global @mean-weasel/lineage@latest
+run_lineage_dogfood lineage-channel install stable \
+  --root "$DOGFOOD_RUNTIME_ROOT" \
+  --shim-dir "$DOGFOOD_RUNTIME_ROOT/bin" \
+  --json
+run_lineage_dogfood lineage-stable runtime doctor --json
+```
+
+Require `stable`, `package`, `verified: true`, and code/receipt paths beneath
+`$DOGFOOD_RUNTIME_ROOT`. Stop if the launcher resolves into a checkout or any
+normal user data root.
+
+## Initialize and gate the fresh profile
+
+Fresh-profile bootstrap exception: profile doctor and `db info` cannot pass
+before the profile exists. Runtime doctor is therefore the only pre-init
+identity check. Initialize atomically, then immediately complete the full gate:
+
+```bash
+run_lineage_dogfood lineage-stable profile init \
+  --profile "$DOGFOOD_PROFILE" \
+  --service-origin "$DOGFOOD_ORIGIN" \
+  --confirm-write \
+  --json
+
+run_lineage_dogfood lineage-stable runtime doctor --json
+run_lineage_dogfood lineage-stable profile doctor \
+  --profile "$DOGFOOD_PROFILE" \
+  --json
+run_lineage_dogfood lineage-stable db info \
+  --profile "$DOGFOOD_PROFILE" \
+  --json
+```
+
+Require the runtime fingerprint, profile ID/environment/fingerprint, database
+identity, and service origin to agree. Database and media paths must remain
+beneath `$DOGFOOD_PROFILE_ROOT`. Offline database information should report
+`process.role: command` and no live service object.
+
+Repeat `profile init` once as a negative check. It must refuse to overwrite the
+existing profile and print reuse or profile doctor guidance.
+
+## Exercise foreground startup and the app
+
+Start the exact public foreground command:
+
+```bash
+run_lineage_dogfood lineage-stable start --profile "$DOGFOOD_PROFILE"
+```
+
+Open `$DOGFOOD_ORIGIN` in a browser. Record:
+
+1. Runtime Settings show the exact stable package, profile, database, media
+   root, and service origin from the gate.
+2. **Load demo lineage** produces 10 nodes and 9 edges.
+3. **Load rich image demo** produces 14 nodes, 13 edges, and 14 PNG previews.
+4. No preview is broken and no stale empty-lineage message remains.
+5. Browser console errors and terminal warnings are copied verbatim.
+6. A screenshot contains only synthetic demo content and temporary paths.
+
+Stop with Ctrl-C and confirm the port closes.
+
+## Exercise managed lifecycle and CLI handoff
+
+```bash
+run_lineage_dogfood lineage-stable-service start \
+  --channel stable \
+  --profile "$DOGFOOD_PROFILE" \
+  --json
+run_lineage_dogfood lineage-stable-service status \
+  --channel stable \
+  --profile "$DOGFOOD_PROFILE" \
+  --json
+```
+
+Require the managed receipt and `/api/runtime` to agree on the service instance,
+code fingerprint, profile/database fingerprints, and origin. Repeat `start` and
+require the same healthy instance. Confirm both demo workspaces survived the
+foreground restart.
+
+Use the rich-demo root returned by the app:
+
+```bash
+run_lineage_dogfood lineage-stable next \
+  --profile "$DOGFOOD_PROFILE" \
+  --project demo-project \
+  --root "<rich-root-id>" \
+  --json
+run_lineage_dogfood lineage-stable brief \
+  --profile "$DOGFOOD_PROFILE" \
+  --project demo-project \
+  --root "<rich-root-id>" \
+  --json
+```
+
+Generated handoff commands must retain `lineage-stable` and the selected
+temporary profile.
+
+## Exercise the optional Codex plugin
+
+Install and doctor only the temporary Codex home:
+
+```bash
+run_lineage_dogfood npx --yes \
+  @mean-weasel/lineage-plugin-installer@latest \
+  install \
+  --channel latest \
+  --codex-home "$DOGFOOD_CODEX_HOME" \
+  --json
+run_lineage_dogfood npx --yes \
+  @mean-weasel/lineage-plugin-installer@latest \
+  doctor \
+  --channel latest \
+  --codex-home "$DOGFOOD_CODEX_HOME" \
+  --json
+run_lineage_dogfood codex plugin list --json
+```
+
+Require `lineage-codex-plugin@lineage` at the exact installed Lineage version,
+installed and enabled. Repeat installation once to prove safe reinstall, then
+remove only the temporary registration:
+
+```bash
+run_lineage_dogfood codex plugin remove \
+  lineage-codex-plugin@lineage \
+  --json
+run_lineage_dogfood codex plugin marketplace remove lineage --json
+```
+
+Do not restart a normal Codex desktop session against this temporary home.
+
+## Stop, recheck, and clean up
+
+```bash
+run_lineage_dogfood lineage-stable-service stop \
+  --channel stable \
+  --profile "$DOGFOOD_PROFILE" \
+  --json
+run_lineage_dogfood lineage-stable profile doctor \
+  --profile "$DOGFOOD_PROFILE" \
+  --json
+run_lineage_dogfood lineage-stable db info \
+  --profile "$DOGFOOD_PROFILE" \
+  --json
+```
+
+The origin must be unreachable after stop, while the offline profile and
+database checks still pass. Preserve the root for inspection on any failure.
+After a clean pass and sanitized report, remove only the validated target:
+
+```bash
+case "$DOGFOOD_ROOT" in
+  /tmp/lineage-manual-dogfood.*)
+    rm -rf -- "$DOGFOOD_ROOT"
+    ;;
+  *)
+    echo "Refusing unexpected cleanup target: $DOGFOOD_ROOT"
+    exit 1
+    ;;
+esac
+```
+
+## Separate source-development journey
+
+Create a second temporary root with a different profile, service origin, npm
+cache, and Codex home. Do not reuse the stable profile or database:
+
+```bash
+DEV_DOGFOOD_ROOT="$(mktemp -d /tmp/lineage-manual-dev-dogfood.XXXXXX)"
+chmod 700 "$DEV_DOGFOOD_ROOT"
+
+DEV_DOGFOOD_HOME="$DEV_DOGFOOD_ROOT/home"
+DEV_DOGFOOD_NPM_CACHE="$DEV_DOGFOOD_ROOT/npm-cache"
+DEV_DOGFOOD_RUNTIME_ROOT="$DEV_DOGFOOD_ROOT/runtimes"
+DEV_DOGFOOD_PROFILE_ROOT="$DEV_DOGFOOD_ROOT/profiles"
+DEV_DOGFOOD_SERVICE_ROOT="$DEV_DOGFOOD_ROOT/services"
+DEV_DOGFOOD_CODEX_HOME="$DEV_DOGFOOD_ROOT/codex-home"
+DEV_DOGFOOD_BASE_PATH="$PATH"
+DEV_DOGFOOD_PROFILE="manual-development"
+DEV_DOGFOOD_PORT="5298"
+DEV_DOGFOOD_ORIGIN="http://127.0.0.1:$DEV_DOGFOOD_PORT"
+
+mkdir -p \
+  "$DEV_DOGFOOD_HOME" \
+  "$DEV_DOGFOOD_NPM_CACHE" \
+  "$DEV_DOGFOOD_RUNTIME_ROOT" \
+  "$DEV_DOGFOOD_PROFILE_ROOT" \
+  "$DEV_DOGFOOD_SERVICE_ROOT" \
+  "$DEV_DOGFOOD_CODEX_HOME"
+
+run_lineage_dev_dogfood() {
+  env \
+    HOME="$DEV_DOGFOOD_HOME" \
+    CODEX_HOME="$DEV_DOGFOOD_CODEX_HOME" \
+    LINEAGE_RUNTIME_ROOT="$DEV_DOGFOOD_RUNTIME_ROOT" \
+    LINEAGE_PROFILE_ROOT="$DEV_DOGFOOD_PROFILE_ROOT" \
+    LINEAGE_SERVICE_ROOT="$DEV_DOGFOOD_SERVICE_ROOT" \
+    npm_config_cache="$DEV_DOGFOOD_NPM_CACHE" \
+    PATH="$DEV_DOGFOOD_HOME/.local/bin:$DEV_DOGFOOD_BASE_PATH" \
+    "$@"
+}
+```
+
+Confirm that `$DEV_DOGFOOD_PORT` is unused, choosing a different port if
+necessary. Then perform every source command through the wrapper:
+
+```bash
+run_lineage_dev_dogfood git clone \
+  https://github.com/mean-weasel/lineage.git \
+  "$DEV_DOGFOOD_ROOT/lineage"
+cd "$DEV_DOGFOOD_ROOT/lineage"
+run_lineage_dev_dogfood npm ci
+run_lineage_dev_dogfood npm run lineage:dev -- runtime doctor --json
+run_lineage_dev_dogfood npm run lineage:dev -- profile init \
+  --profile "$DEV_DOGFOOD_PROFILE" \
+  --service-origin "$DEV_DOGFOOD_ORIGIN" \
+  --confirm-write \
+  --json
+run_lineage_dev_dogfood npm run lineage:dev -- runtime doctor --json
+run_lineage_dev_dogfood npm run lineage:dev -- profile doctor \
+  --profile "$DEV_DOGFOOD_PROFILE" \
+  --json
+run_lineage_dev_dogfood npm run lineage:dev -- db info \
+  --profile "$DEV_DOGFOOD_PROFILE" \
+  --json
+run_lineage_dev_dogfood npm run dev -- --profile "$DEV_DOGFOOD_PROFILE"
+```
+
+Repeat the synthetic demo, restart, Settings, and CLI checks. Then stop the
+foreground process and prove the bundled managed-development path:
+
+```bash
+run_lineage_dev_dogfood make install-dev
+run_lineage_dev_dogfood npm run lineage:dev -- runtime doctor --json
+run_lineage_dev_dogfood make start-dev-bg \
+  LINEAGE_DEV_PROFILE="$DEV_DOGFOOD_PROFILE"
+run_lineage_dev_dogfood make status-dev \
+  LINEAGE_DEV_PROFILE="$DEV_DOGFOOD_PROFILE"
+run_lineage_dev_dogfood make stop-dev \
+  LINEAGE_DEV_PROFILE="$DEV_DOGFOOD_PROFILE"
+```
+
+The final evidence must identify `dev`, `checkout`, and the fresh clone's
+canonical root and fingerprint. It must not match or open the stable database.
+Preserve the temporary root on failure. After a clean pass, remove only the
+guarded development target:
+
+```bash
+case "$DEV_DOGFOOD_ROOT" in
+  /tmp/lineage-manual-dev-dogfood.*)
+    rm -rf -- "$DEV_DOGFOOD_ROOT"
+    ;;
+  *)
+    echo "Refusing unexpected cleanup target: $DEV_DOGFOOD_ROOT"
+    exit 1
+    ;;
+esac
+```

package/README.md

@@ -59,14 +59,22 @@ Before installing anything, verify the tools used by the path you choose:
 ```bash
 node --version
 npm --version
+npx --version
 make --version
 ```
 
-Lineage requires Node.js 22.22.0 or newer and npm. Make is required only for
-the documented `make` shortcuts. A real Codex installation is optional for the
-app, but required to install and activate the Codex plugin; verify that
-additional prerequisite with `codex --version` before following the plugin
-step.
+Lineage requires Node.js 22.22.0 or newer and npm, including the accompanying
+`npx` command used by the plugin installer. Make is required only for the
+documented `make` shortcuts. A real Codex installation is optional for the app,
+but required to install and activate the Codex plugin; verify that additional
+prerequisite with `codex --version` in the same shell before following the
+plugin step. If either command is missing, restore its executable directory on
+`PATH` before installing.
+
+On the minimum supported Node 22 line, foreground startup can print one
+`ExperimentalWarning` for Node's built-in SQLite module before the healthy
+`Lineage listening` line. Lineage keeps that category-specific warning visible;
+it does not indicate an identity or database failure.
 
 ### Develop from a fresh clone
 
@@ -76,8 +84,12 @@ development data:
 ```bash
 git clone https://github.com/mean-weasel/lineage.git
 cd lineage
-npm ci
-npm run lineage:dev -- profile init --profile team-development --confirm-write --json
+npm ci &&
+npm run lineage:dev -- runtime doctor --json &&
+npm run lineage:dev -- profile init --profile team-development --confirm-write --json &&
+npm run lineage:dev -- runtime doctor --json &&
+npm run lineage:dev -- profile doctor --profile team-development --json &&
+npm run lineage:dev -- db info --profile team-development --json &&
 npm run dev -- --profile team-development
 ```
 
@@ -94,19 +106,25 @@ Use the currently published npm dist-tags when you want installed rather than
 checkout code:
 
 ```bash
-npm install -g @mean-weasel/lineage@latest
-lineage-channel install stable
-lineage-stable runtime doctor --json
-lineage-stable profile init --profile team-production --confirm-write --json
+npm install -g @mean-weasel/lineage@latest &&
+lineage-channel install stable &&
+lineage-stable runtime doctor --json &&
+lineage-stable profile init --profile team-production --confirm-write --json &&
+lineage-stable runtime doctor --json &&
+lineage-stable profile doctor --profile team-production --json &&
+lineage-stable db info --profile team-production --json &&
 lineage-stable start --profile team-production
 ```
 
 Preview is independent and must use its own runtime root and profile:
 
 ```bash
-lineage-channel install preview
-lineage-preview runtime doctor --json
-lineage-preview profile init --profile team-preview --confirm-write --json
+lineage-channel install preview &&
+lineage-preview runtime doctor --json &&
+lineage-preview profile init --profile team-preview --confirm-write --json &&
+lineage-preview runtime doctor --json &&
+lineage-preview profile doctor --profile team-preview --json &&
+lineage-preview db info --profile team-preview --json &&
 lineage-preview start --profile team-preview
 ```
 
@@ -128,6 +146,10 @@ If doctor fails, it prints a version-pinned remediation command for that same
 Codex home. For verification, use a temporary `--codex-home`; do not test an
 installer against your real Codex profile.
 
+Maintainers can exercise the complete published and source journeys without
+touching an existing Lineage or Codex installation by following the
+[hermetic manual install dogfood runbook](MANUAL_INSTALL_DOGFOOD.md).
+
 ## Package Channels
 
 Lineage is packaged as `@mean-weasel/lineage`, but stable and preview must not
@@ -175,6 +197,12 @@ lineage-preview profile init --profile team-preview --confirm-write --json
 npm run lineage:dev -- profile init --profile team-development --confirm-write --json
 ```
 
+Fresh-profile bootstrap exception: because profile doctor and `db info` cannot
+pass before a profile and database exist, run runtime doctor first, perform the
+atomic `profile init`, and then immediately run runtime doctor, profile doctor,
+and `db info --profile <profile> --json`. Do not start a service or perform
+another write until that post-init gate passes.
+
 `profile init` derives the environment and exact verified code pin from the
 launcher, creates owner-only media and SQLite paths, binds the new database
 identity, and publishes the profile manifest only after those steps succeed.
@@ -614,6 +642,10 @@ and then cleans up.
 
 The root `Makefile` provides memorable wrappers for common setup, startup, and
 verification commands. Run `make` or `make help` to list the available targets.
+`make install-prod` and `make install-preview` bootstrap the published
+`@mean-weasel/lineage@latest` package under the isolated runtime root before
+creating the channel runtime and its launchers, so they work from a fresh clone
+without checkout build artifacts or overwriting an existing channel launcher.
 
 ```bash
 make install-prod

package/dist/cli/lineage-dev.js

@@ -4,7 +4,7 @@
 import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { homedir as homedir2, platform as platform2 } from "node:os";
-import { dirname as dirname6, join as join10, resolve as resolve8 } from "node:path";
+import { dirname as dirname6, join as join10, resolve as resolve9 } from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
@@ -2810,7 +2810,7 @@ function validateAgentClaimForWrite(fields) {
 }
 
 // src/server/assetLineage.ts
-import { join as join7 } from "node:path";
+import { isAbsolute as isAbsolute2, join as join7, resolve as resolve5 } from "node:path";
 
 // src/server/assetLineageSelection.ts
 function selectedRows(database, project, root) {
@@ -3515,6 +3515,11 @@ function collectAssets(project, source) {
   }
   return assets;
 }
+function absoluteLocalPath(localPath) {
+  if (!localPath) return void 0;
+  if (isAbsolute2(localPath)) return localPath;
+  return resolve5(repoRoot, ".asset-scratch", localPath);
+}
 function upsertProject(database, project) {
   const timestamp = nowIso();
   database.prepare(`
@@ -3929,6 +3934,7 @@ function getLineageSnapshot(project, assetId) {
     const lineageTasks = lineageTasksByNode.get(row.asset_id);
     return {
       ...node,
+      absolute_path: absoluteLocalPath(row.local_path),
       attempt_count: attempts.length,
       current_attempt: currentAttempt,
       is_latest: !childIds.has(row.asset_id),
@@ -4361,7 +4367,7 @@ function linkSelectedLineageChild(project, fields) {
 
 // src/server/generationReceipts.ts
 import { existsSync as existsSync8, realpathSync as realpathSync2, statSync as statSync4 } from "node:fs";
-import { relative as relative3, resolve as resolve5 } from "node:path";
+import { relative as relative3, resolve as resolve6 } from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 
 // src/shared/generationOutputManifest.ts
@@ -4896,8 +4902,8 @@ function isPathInside(child, parent) {
   return Boolean(rel) && !rel.startsWith("..") && !rel.startsWith("/");
 }
 function scratchCandidate(file) {
-  const scratchRoot = resolve5(repoRoot, ".asset-scratch");
-  const candidate = file.startsWith(".asset-scratch/") || resolve5(file).startsWith(scratchRoot) ? resolve5(repoRoot, file) : resolve5(scratchRoot, file);
+  const scratchRoot = resolve6(repoRoot, ".asset-scratch");
+  const candidate = file.startsWith(".asset-scratch/") || resolve6(file).startsWith(scratchRoot) ? resolve6(repoRoot, file) : resolve6(scratchRoot, file);
   if (!isPathInside(candidate, scratchRoot)) throw new GenerationReceiptError(`Import file must be under .asset-scratch: ${file}`);
   return { candidate, scratchRoot };
 }
@@ -5152,7 +5158,7 @@ function importImageRerollOutput(project = defaultProject, fields) {
 // src/server/lineageSelectionPacket.ts
 import { createHash as createHash5 } from "node:crypto";
 import { existsSync as existsSync9, statSync as statSync5 } from "node:fs";
-import { isAbsolute as isAbsolute2, resolve as resolve6 } from "node:path";
+import { isAbsolute as isAbsolute3, resolve as resolve7 } from "node:path";
 var LineageSelectionPacketError = class extends Error {
   constructor(message, warnings = [], errors = [], diagnostics = []) {
     super(message);
@@ -5198,10 +5204,10 @@ function resolveWorkspace(project, options) {
 }
 function resolveLocalReference(reference) {
   if (!reference) return void 0;
-  if (isAbsolute2(reference)) return reference;
-  const repoRelative = resolve6(repoRoot, reference);
+  if (isAbsolute3(reference)) return reference;
+  const repoRelative = resolve7(repoRoot, reference);
   if (existsSync9(repoRelative)) return repoRelative;
-  return resolve6(repoRoot, ".asset-scratch", reference);
+  return resolve7(repoRoot, ".asset-scratch", reference);
 }
 function fileSize(path) {
   if (!path || !existsSync9(path)) return void 0;
@@ -5656,7 +5662,7 @@ function getLineageSelectionPacket(project, options = {}) {
 import { createHash as createHash6 } from "node:crypto";
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { existsSync as existsSync10, lstatSync as lstatSync3, readFileSync as readFileSync5, readdirSync as readdirSync3, readlinkSync, realpathSync as realpathSync3, statSync as statSync6 } from "node:fs";
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join9, resolve as resolve7 } from "node:path";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join9, resolve as resolve8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/shared/runtimeInfoTypes.ts
@@ -5675,7 +5681,7 @@ function isLineagePackageRoot(root) {
 }
 function executingCodeRoot() {
   const moduleDirectory = dirname5(fileURLToPath2(import.meta.url));
-  const candidates = [resolve7(moduleDirectory, "../.."), resolve7(moduleDirectory, "..")];
+  const candidates = [resolve8(moduleDirectory, "../.."), resolve8(moduleDirectory, "..")];
   const root = candidates.find(isLineagePackageRoot);
   if (!root) throw new Error(`Unable to derive Lineage code root from executing module ${fileURLToPath2(import.meta.url)}`);
   return canonicalRoot(root);
@@ -5688,7 +5694,7 @@ function canonicalRoot(root) {
   try {
     return realpathSync3(root);
   } catch {
-    return resolve7(root);
+    return resolve8(root);
   }
 }
 function packageInfo(root = codeRoot) {
@@ -5788,7 +5794,7 @@ function readInstallReceipt(path, errors) {
     return void 0;
   }
   let receipt;
-  const receiptPath = resolve7(path);
+  const receiptPath = resolve8(path);
   try {
     receipt = JSON.parse(readFileSync5(receiptPath, "utf8"));
   } catch (error) {
@@ -5796,7 +5802,7 @@ function readInstallReceipt(path, errors) {
     return void 0;
   }
   if (receipt.schema_version !== lineageRuntimeInstallSchemaVersion) errors.push(`Unsupported runtime install receipt schema: ${String(receipt.schema_version)}`);
-  if (!isAbsolute3(receipt.package_root || "")) errors.push("Runtime install receipt package_root must be absolute");
+  if (!isAbsolute4(receipt.package_root || "")) errors.push("Runtime install receipt package_root must be absolute");
   if (!receipt.package_integrity?.startsWith("sha512-")) errors.push("Runtime install receipt package integrity is invalid");
   if (receipt.package_source !== "registry" && receipt.package_source !== "local") errors.push("Runtime install receipt package source is invalid");
   if (typeof receipt.package_spec !== "string" || !receipt.package_spec) errors.push("Runtime install receipt package spec is invalid");
@@ -6074,7 +6080,7 @@ var signalExitCodes = {
   SIGTERM: 143
 };
 function packageRoot2() {
-  return resolve8(dirname6(fileURLToPath3(import.meta.url)), "..", "..");
+  return resolve9(dirname6(fileURLToPath3(import.meta.url)), "..", "..");
 }
 function packageVersion() {
   try {
@@ -6113,7 +6119,7 @@ function readOptions(args, name) {
 }
 function readJsonFile(path, label) {
   try {
-    return JSON.parse(readFileSync6(resolve8(path), "utf8"));
+    return JSON.parse(readFileSync6(resolve9(path), "utf8"));
   } catch (error) {
     throw new Error(`${label} must be a readable JSON file: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }
@@ -6157,7 +6163,7 @@ function resolveStartOptions(config, args) {
   };
 }
 function resolveCliAssetRoot(args) {
-  return resolve8(readOption(args, "--asset-root") || process.env.LINEAGE_ASSET_ROOT || packageRoot);
+  return resolve9(readOption(args, "--asset-root") || process.env.LINEAGE_ASSET_ROOT || packageRoot);
 }
 function configureCliAssetRoot(args) {
   const assetRoot = resolveCliAssetRoot(args);
@@ -6189,10 +6195,10 @@ function prepareCliProfile(config, args) {
   if (hasOption(args, "--db")) throw new Error("A named profile cannot be combined with --db");
   if (hasOption(args, "--asset-root")) throw new Error("A named profile cannot be combined with --asset-root");
   const profile = resolveLineageProfile(selector);
-  if (process.env.LINEAGE_DB && resolve8(process.env.LINEAGE_DB) !== profile.database_path) {
+  if (process.env.LINEAGE_DB && resolve9(process.env.LINEAGE_DB) !== profile.database_path) {
     throw new Error(`Profile ${profile.profile_id} database_path conflicts with LINEAGE_DB`);
   }
-  if (process.env.LINEAGE_ASSET_ROOT && resolve8(process.env.LINEAGE_ASSET_ROOT) !== profile.asset_root) {
+  if (process.env.LINEAGE_ASSET_ROOT && resolve9(process.env.LINEAGE_ASSET_ROOT) !== profile.asset_root) {
     throw new Error(`Profile ${profile.profile_id} asset_root conflicts with LINEAGE_ASSET_ROOT`);
   }
   assertProfileChannel(profile, config.channel);
@@ -6293,7 +6299,7 @@ function lineageServiceIdentityErrors(runtime, expected) {
   if (runtime.channel !== expected.channel) errors.push(`channel ${runtime.channel} != ${expected.channel}`);
   if (!runtime.code?.verified) errors.push("service code identity is not verified");
   if (runtime.code?.fingerprint !== expected.code_fingerprint) errors.push(`code fingerprint ${runtime.code?.fingerprint || "missing"} != ${expected.code_fingerprint}`);
-  if (resolve8(runtime.database.path) !== resolve8(expected.database_path)) errors.push(`database ${runtime.database.path} != ${expected.database_path}`);
+  if (resolve9(runtime.database.path) !== resolve9(expected.database_path)) errors.push(`database ${runtime.database.path} != ${expected.database_path}`);
   if (runtime.service?.instance_id !== expected.instance_id) errors.push(`service instance ${runtime.service?.instance_id || "missing"} != ${expected.instance_id}`);
   if (runtime.service?.launcher_pid !== expected.launcher_pid) errors.push(`launcher pid ${runtime.service?.launcher_pid || "missing"} != ${expected.launcher_pid}`);
   if (expected.profile) {
@@ -6388,7 +6394,7 @@ function runLineageDataCommand(command, args) {
     });
     const out = readOption(args, "--out");
     if (out) {
-      const outPath = resolve8(out);
+      const outPath = resolve9(out);
       mkdirSync6(dirname6(outPath), { recursive: true });
       writeFileSync4(outPath, `${JSON.stringify(packet, null, 2)}
 `);