@stravica-ai/digital-operator-pa 0.1.28 → 0.1.30

package/dist/engineering-pa-library-cli/src/config.mjs

@@ -15,15 +15,89 @@
 //   - Consumers pass `{ repoRoot }` or the resolved paths; both surfaces
 //     are seams for tests.
 
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { resolve, join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { execFileSync } from 'node:child_process';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-// operator/extensions/tools/library-cli/src/ → up five levels to the repo root.
-export const DEFAULT_REPO_ROOT = resolve(__dirname, '..', '..', '..', '..', '..');
+// Legacy in-tree assumption: operator/extensions/tools/library-cli/src/ up
+// five levels to the repo root. That assumption held while this CLI lived
+// inside the operator repo tree; once shipped through
+// `@stravica-ai/digital-operator-pa`'s bundled `dist/`, the same five-up walk
+// lands INSIDE node_modules and preferences.json is never found — the
+// consumer silently boots SIMPLE and every put/flush is refused (see
+// w-2026-08-24-dave-021, Stream 5 P0). Kept only as the fallback for the
+// in-tree/test invocation shape.
+const IN_TREE_FIVE_UP = resolve(__dirname, '..', '..', '..', '..', '..');
+
+/**
+ * Layered repo-root resolution. Called each time a default is needed so
+ * the answer reflects the CURRENT environment / cwd, never a value frozen
+ * at module import.
+ *
+ * Order:
+ *   (a) DAVE_ROOT env override (estate standard — CLAUDE.md Bucket 7 rule 8)
+ *   (b) LIBRARY_REPO_ROOT env override (explicit CLI-scoped opt-in)
+ *   (c) Walk upward from process.cwd() until a directory containing
+ *       operator/config/preferences.json is found — this is the shape that
+ *       proves we are inside an operator repo, and works whether the CLI
+ *       ships from node_modules or lives in-tree.
+ *   (d) Legacy five-up from the module directory (in-tree / test fallback).
+ *
+ * Injectable {@link opts} exists so unit tests can pin cwd + env without
+ * mutating the surrounding process.
+ *
+ * @param {object} [opts]
+ * @param {NodeJS.ProcessEnv} [opts.env]  defaults to process.env
+ * @param {string} [opts.cwd]             defaults to process.cwd()
+ * @returns {string}                      resolved repo root
+ */
+export function resolveDefaultRepoRoot(opts = {}) {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+
+  // (a) DAVE_ROOT — the estate-standard project-root env (CLAUDE.md B7 R8).
+  const daveRoot = env.DAVE_ROOT;
+  if (typeof daveRoot === 'string' && daveRoot.trim() !== '') {
+    return resolve(daveRoot);
+  }
+
+  // (b) LIBRARY_REPO_ROOT — subsystem-scoped override.
+  const libRoot = env.LIBRARY_REPO_ROOT;
+  if (typeof libRoot === 'string' && libRoot.trim() !== '') {
+    return resolve(libRoot);
+  }
+
+  // (c) Walk up from cwd looking for operator/config/preferences.json.
+  let dir = resolve(cwd);
+  // Belt-and-braces guard: 64 levels is far beyond any real filesystem depth.
+  for (let i = 0; i < 64; i += 1) {
+    if (existsSync(join(dir, 'operator', 'config', 'preferences.json'))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // (d) Legacy in-tree five-up — kept for the checkout-and-run test shape.
+  return IN_TREE_FIVE_UP;
+}
+
+/**
+ * Deprecated export retained for backwards compatibility. Points at the
+ * legacy in-tree five-up value — which is exactly the shape that fails
+ * once shipped from `node_modules`. New callers MUST use
+ * {@link resolveDefaultRepoRoot} (live) or pass an explicit `repoRoot`.
+ *
+ * Left in place because dropping the export would surface as an
+ * ImportError on any consumer that pinned the old name; the retained
+ * value never reaches the CLI's default-parameter path any more — those
+ * now call `resolveDefaultRepoRoot()` at invocation time.
+ */
+export const DEFAULT_REPO_ROOT = IN_TREE_FIVE_UP;
 
 export class LibraryConfigError extends Error {
   constructor(message, code) {
@@ -146,15 +220,16 @@ const REMOTE_KEY_REF_RE = /^([a-z0-9-]+)\/([A-Z][A-Z0-9_]*)$/;
  */
 export function resolveRemoteKeyRef(
   refOrLiteral,
-  { repoRoot = DEFAULT_REPO_ROOT, secretsGet = defaultSecretsGet } = {},
+  { repoRoot, secretsGet = defaultSecretsGet } = {},
 ) {
   if (typeof refOrLiteral !== 'string') return refOrLiteral;
   const m = REMOTE_KEY_REF_RE.exec(refOrLiteral);
   if (!m) return refOrLiteral;
   const [, scope, key] = m;
+  const root = repoRoot ?? resolveDefaultRepoRoot();
   let resolved;
   try {
-    resolved = secretsGet({ scope, key, repoRoot });
+    resolved = secretsGet({ scope, key, repoRoot: root });
   } catch (err) {
     throw new LibraryConfigError(
       `library.remoteKey vault reference "${refOrLiteral}" failed to resolve ` +
@@ -215,9 +290,10 @@ function defaultSecretsGet({ scope, key, repoRoot }) {
  * @param {string} [opts.repoRoot]  defaults to DEFAULT_REPO_ROOT
  * @returns {{mode: 'simple'|'remote', remoteEndpoint?: string, remoteKey?: string, repoRoot: string, preferences: object}}
  */
-export function loadLibraryConfig({ repoRoot = DEFAULT_REPO_ROOT } = {}) {
-  const base = join(repoRoot, 'operator', 'config', 'preferences.json');
-  const local = join(repoRoot, 'operator', 'config', 'preferences.local.json');
+export function loadLibraryConfig({ repoRoot } = {}) {
+  const root = repoRoot ?? resolveDefaultRepoRoot();
+  const base = join(root, 'operator', 'config', 'preferences.json');
+  const local = join(root, 'operator', 'config', 'preferences.local.json');
   const preferences = readMergedPreferences({ base, local });
   // Vault-ref resolution runs BEFORE resolveLibraryConfig's shape check
   // so a ref value never reaches the `<subkeyId>:<secret>` validator.
@@ -229,11 +305,11 @@ export function loadLibraryConfig({ repoRoot = DEFAULT_REPO_ROOT } = {}) {
     typeof preferences.library.remoteKey === 'string'
   ) {
     const original = preferences.library.remoteKey;
-    const resolved = resolveRemoteKeyRef(original, { repoRoot });
+    const resolved = resolveRemoteKeyRef(original, { repoRoot: root });
     if (resolved !== original) {
       preferences.library = { ...preferences.library, remoteKey: resolved };
     }
   }
   const resolved = resolveLibraryConfig(preferences);
-  return { ...resolved, repoRoot, preferences };
+  return { ...resolved, repoRoot: root, preferences };
 }

package/dist/engineering-pa-library-cli/src/envelope.mjs

@@ -13,7 +13,7 @@
 
 import { createHash, randomUUID } from 'node:crypto';
 import { hostname } from 'node:os';
-import { relative, isAbsolute } from 'node:path';
+import { isAbsolute, normalize, relative, sep } from 'node:path';
 
 import { EVENT_KINDS, canonicalJson } from '@stravica-ai/remote-library';
 
@@ -31,6 +31,47 @@ export function contentShaOf(payload) {
   return `sha256:${createHash('sha256').update(canonical).digest('hex')}`;
 }
 
+/**
+ * Refuse a source path that would encode as an escape from the repo root.
+ * Root-cause cure for the poison-event wedge Stream 5 re-verify Scope C
+ * surfaced (w-2026-08-24-dave-025, SA14). Called by buildEnvelope after
+ * relPath is computed. Semantics match the server's assertPathSafe
+ * (spec §4 apply gate): reject empty, absolute, NUL, drive-letter,
+ * root-backslash, `..`-segments, and any string that normalises to a
+ * path starting with `..`. The error names the input sourcePath and
+ * repoRoot so an operator can see immediately why the encoding refused.
+ *
+ * @param {string} relPath      candidate repo-relative path
+ * @param {string} sourcePath   original input (for the error message)
+ * @param {string} repoRoot     resolved repo root (for the error message)
+ * @throws {Error} with exitCode=1 if the path is unsafe
+ */
+export function assertRepoRelativeSafe(relPath, sourcePath, repoRoot) {
+  const fail = (reason) => {
+    const err = new Error(
+      `refusing to encode source path outside repo root (${reason}): ` +
+        `sourcePath=${JSON.stringify(sourcePath)}, repoRoot=${JSON.stringify(repoRoot)}, ` +
+        `resolvedRelative=${JSON.stringify(relPath)}. ` +
+        `Move the file into the repo or stage it under a repo-resident path before calling library put.`,
+    );
+    err.exitCode = 1;
+    throw err;
+  };
+  if (typeof relPath !== 'string') fail('path must be a string');
+  if (relPath.length === 0) fail('path resolves empty');
+  if (relPath.includes('\0')) fail('path contains NUL byte');
+  if (isAbsolute(relPath)) fail('resolved path is absolute');
+  if (/^[A-Za-z]:[\\/]/.test(relPath) || relPath.startsWith('\\')) {
+    fail('drive-letter or root-backslash path');
+  }
+  const parts = relPath.split(/[/\\]/);
+  if (parts.some((seg) => seg === '..')) fail("'..' segments not permitted");
+  const normalised = normalize(relPath);
+  if (normalised === '..' || normalised.startsWith('..' + sep) || normalised.startsWith('../')) {
+    fail('path normalises outside repo root');
+  }
+}
+
 /**
  * Guess the event kind from a staging file path when the operator did
  * not supply one via `--kind`. Falls back to
@@ -77,9 +118,22 @@ export function buildEnvelope({
   sourceKind = 'manual',
   clock = () => new Date(),
 }) {
+  // Repo-relative resolution + refusal for anything that would encode as
+  // a `..`-segment or otherwise escape the repo root. This is the root
+  // cause cure for the Stream 5 re-verify Scope C poison-event wedge
+  // (w-2026-08-24-dave-025). Before this cure `relative(repoRoot, abs)`
+  // silently produced `../../etc/...` for files sitting outside the
+  // repo and the envelope was posted with a payload path the worker's
+  // apply gate would later refuse — halting single-writer propagation
+  // for the whole estate. Refusing here (client-side, at encoding time)
+  // stops the poison at source; SA14's ingest-side check is the second
+  // line; the worker's apply gate remains the third.
   const relPath = sourcePath
     ? isAbsolute(sourcePath) ? relative(repoRoot, sourcePath) : sourcePath
     : undefined;
+  if (relPath !== undefined) {
+    assertRepoRelativeSafe(relPath, sourcePath, repoRoot);
+  }
 
   const resolvedKind = kind ?? guessKindFromPath(relPath ?? sourcePath ?? '') ?? null;
   if (!resolvedKind) {

package/dist/engineering-pa-library-tunnel/src/config.mjs

@@ -12,8 +12,60 @@ import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
-// operator/extensions/tools/library-tunnel/src/ → up five levels to repo root.
-export const DEFAULT_REPO_ROOT = resolve(HERE, '..', '..', '..', '..', '..');
+
+// Legacy in-tree assumption: operator/extensions/tools/library-tunnel/src/ up
+// five levels to repo root. Held while the tool lived in-tree; once shipped
+// through `@stravica-ai/digital-operator-pa`, the same walk lands INSIDE
+// node_modules and state files spray into the platform tarball instead of
+// the consumer's .cache/. Same defect class as library-cli
+// (w-2026-08-24-dave-021); layered resolution below fixes both.
+const IN_TREE_FIVE_UP = resolve(HERE, '..', '..', '..', '..', '..');
+
+/**
+ * Layered repo-root resolution. See library-cli/src/config.mjs for the
+ * full rationale; short version: (a) DAVE_ROOT env, (b) LIBRARY_REPO_ROOT
+ * env, (c) walk cwd upward until operator/config/preferences.json is
+ * found, (d) fall back to the legacy five-up for in-tree/test invocations.
+ *
+ * @param {object} [opts]
+ * @param {NodeJS.ProcessEnv} [opts.env]  defaults to process.env
+ * @param {string} [opts.cwd]             defaults to process.cwd()
+ * @returns {string}                      resolved repo root
+ */
+export function resolveDefaultRepoRoot(opts = {}) {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+
+  const daveRoot = env.DAVE_ROOT;
+  if (typeof daveRoot === 'string' && daveRoot.trim() !== '') {
+    return resolve(daveRoot);
+  }
+
+  const libRoot = env.LIBRARY_REPO_ROOT;
+  if (typeof libRoot === 'string' && libRoot.trim() !== '') {
+    return resolve(libRoot);
+  }
+
+  let dir = resolve(cwd);
+  for (let i = 0; i < 64; i += 1) {
+    if (existsSync(join(dir, 'operator', 'config', 'preferences.json'))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  return IN_TREE_FIVE_UP;
+}
+
+/**
+ * Deprecated export retained for backwards compatibility. Points at the
+ * legacy in-tree five-up value (which is exactly the shape that fails
+ * once shipped from node_modules). New callers use
+ * {@link resolveDefaultRepoRoot} or pass an explicit `repoRoot`.
+ */
+export const DEFAULT_REPO_ROOT = IN_TREE_FIVE_UP;
 
 function readJsonObject(path) {
   try {
@@ -30,7 +82,7 @@ function readJsonObject(path) {
  * @param {string} repoRoot
  * @returns {string|null}
  */
-export function readPaName(repoRoot = DEFAULT_REPO_ROOT) {
+export function readPaName(repoRoot = resolveDefaultRepoRoot()) {
   const base = readJsonObject(join(repoRoot, 'operator', 'config', 'preferences.json')) || {};
   const local = readJsonObject(join(repoRoot, 'operator', 'config', 'preferences.local.json')) || {};
   const merged = { ...base, ...local };
@@ -65,13 +117,13 @@ export function plistPath(host) {
  * @param {string} host
  * @param {string} repoRoot
  */
-export function stateDir(repoRoot = DEFAULT_REPO_ROOT) {
+export function stateDir(repoRoot = resolveDefaultRepoRoot()) {
   return join(repoRoot, '.cache', 'library-tunnel');
 }
-export function statePath(host, repoRoot = DEFAULT_REPO_ROOT) {
+export function statePath(host, repoRoot = resolveDefaultRepoRoot()) {
   return join(stateDir(repoRoot), `${host}.json`);
 }
-export function logPath(host, repoRoot = DEFAULT_REPO_ROOT) {
+export function logPath(host, repoRoot = resolveDefaultRepoRoot()) {
   return join(stateDir(repoRoot), `${host}.log`);
 }
 
@@ -88,7 +140,7 @@ export function logPath(host, repoRoot = DEFAULT_REPO_ROOT) {
  *   installedAt: string
  * }}
  */
-export function readState(host, repoRoot = DEFAULT_REPO_ROOT) {
+export function readState(host, repoRoot = resolveDefaultRepoRoot()) {
   return readJsonObject(statePath(host, repoRoot));
 }
 
@@ -98,7 +150,7 @@ export function readState(host, repoRoot = DEFAULT_REPO_ROOT) {
  * @param {object} state
  * @param {string} [repoRoot]
  */
-export function writeState(host, state, repoRoot = DEFAULT_REPO_ROOT) {
+export function writeState(host, state, repoRoot = resolveDefaultRepoRoot()) {
   const dir = stateDir(repoRoot);
   mkdirSync(dir, { recursive: true });
   const path = statePath(host, repoRoot);
@@ -111,7 +163,7 @@ export function writeState(host, state, repoRoot = DEFAULT_REPO_ROOT) {
  * @param {string} host
  * @param {string} [repoRoot]
  */
-export function removeState(host, repoRoot = DEFAULT_REPO_ROOT) {
+export function removeState(host, repoRoot = resolveDefaultRepoRoot()) {
   const path = statePath(host, repoRoot);
   if (existsSync(path)) unlinkSync(path);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stravica-ai/digital-operator-pa",
-  "version": "0.1.28",
-  "description": "Digital Operator PA — single-bundled public package surface (bins + library) for the platform.",
+  "version": "0.1.30",
+  "description": "Digital Operator PA \u2014 single-bundled public package surface (bins + library) for the platform.",
   "type": "module",
   "main": "./index.mjs",
   "exports": {
@@ -52,10 +52,11 @@
   "engines": {
     "node": ">=24"
   },
-  "//": "test pins --test-isolation=none: default process-isolation mode silently undercounts (drops passed tests from totals) when a test awaits async work while stdout is patched by a capture() helper — see packages/cli/test/secrets. Counts must never lie.",
   "scripts": {
     "build": "node build.mjs",
+    "prepack": "node build.mjs",
     "test": "node --test --test-isolation=none test/*.test.mjs",
     "dry-publish": "node build.mjs && node scripts/dry-publish.mjs"
-  }
-}
+  },
+  "//": "test pins --test-isolation=none: default process-isolation mode silently undercounts (drops passed tests from totals) when a test awaits async work while stdout is patched by a capture() helper \u2014 see packages/cli/test/secrets. Counts must never lie."
+}