peaks-loop 4.0.48 → 4.0.50

package/dist/services/workspace/generated-artifacts-stamp.js

@@ -0,0 +1,167 @@
+/**
+ * Version stamp for the artifacts `peaks workspace init` generates into a
+ * consumer project (G4, 2026-09-15).
+ *
+ * WHY THIS EXISTS. `initWorkspace` is the only writer of a consumer project's
+ * generated config: `.claude/settings.local.json`, the offline
+ * `.peaks/.claude-settings-template.json` copy, and the managed `.gitignore`
+ * snippet. `ensureSession` early-returns as soon as a session is bound —
+ * deliberately, see its own comment — so after the FIRST init nothing ever
+ * re-runs the generator. `npm i -g peaks-loop@<newer>` therefore upgrades the
+ * CLI and leaves the project's generated config exactly as the OLD release
+ * wrote it.
+ *
+ * `.claude/settings.local.json` IS drift-checked against the current template
+ * — but only when something calls `initWorkspace`, which is precisely the
+ * event that stopped happening. The escape hatch (`peaks upgrade
+ * --apply-init`) is real and idempotent. What was missing is anything that
+ * tells the user — or the LLM driving them — that they need it. That is the
+ * gap this module closes: a stamp the generator writes, and a detector that
+ * can answer "the file on disk was produced by 4.0.40 while the installed
+ * peaks-loop is 4.0.49".
+ *
+ * WHY A SEPARATE FILE AND NOT A KEY INSIDE THE ARTIFACTS.
+ * `.claude/settings.local.json` is read by Claude Code, which owns its schema;
+ * a version key peaks invented has no contract there and could be rejected or
+ * silently ignored — a stamp nobody reads is worse than none. `.peaks/_runtime/`
+ * is peaks' own gitignored tree and already holds exactly this kind of
+ * machine-local bookkeeping (`session.json`, `.outer-session-cache.json`), so
+ * the stamp lives beside them and needs no new `.gitignore` line.
+ *
+ * WHAT IS COMPARED. Two versions, because they move independently and a
+ * mismatch of either means the same thing to the user (regenerate):
+ *   - `packageVersion`  — the installed peaks-loop release. Moves on `npm i -g`.
+ *   - `templateVersion` — `TEMPLATE_VERSION`, the shape of the hooks tree this
+ *     release emits. Can move without a release the user would notice.
+ *
+ * The stamp records what the generator LAST WROTE. It is not a promise that
+ * the on-disk artifacts still match it — a user may have hand-edited
+ * `.claude/settings.local.json` since. That question is the existing
+ * `templateContentMatches` comparator's, and it is asked on the next init,
+ * which is what this detector tells the user to trigger.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { CLI_VERSION } from 'peaks-loop-shared/version';
+import { isExpectedFsMiss } from '../../shared/fs-utils.js';
+import { TEMPLATE_VERSION } from './claude-settings-template.js';
+/**
+ * Where the stamp lives, relative to the project root.
+ *
+ * `.peaks/_runtime/` is gitignored by every peaks-loop project already (see
+ * the root `.gitignore` snippet), so this file never shows up in
+ * `git status` — which matters, because the whole point is that its content
+ * changes on the user's machine and not in their repository.
+ */
+export const GENERATED_ARTIFACTS_STAMP_RELATIVE_PATH = join('.peaks', '_runtime', 'generated-artifacts.json');
+/**
+ * The artifacts whose generation the stamp describes. Used to answer "is
+ * there anything on disk that could be stale?" — a project that has never run
+ * `peaks workspace init` has nothing to refresh and must not be nagged.
+ */
+export const GENERATED_ARTIFACT_RELATIVE_PATHS = [
+    join('.claude', 'settings.local.json'),
+    join('.peaks', '.claude-settings-template.json')
+];
+export function generatedArtifactsStampPath(projectRoot) {
+    return join(projectRoot, GENERATED_ARTIFACTS_STAMP_RELATIVE_PATH);
+}
+/** Does this project have any generated artifact on disk at all? */
+function hasGeneratedArtifact(projectRoot) {
+    return GENERATED_ARTIFACT_RELATIVE_PATHS.some((rel) => existsSync(join(projectRoot, rel)));
+}
+/**
+ * Read the stamp, or `null` when there is none / it is not the shape this
+ * module writes. Tolerant on purpose: a malformed stamp must degrade to
+ * "unstamped", never to a crash on the per-turn read path.
+ *
+ * The catch still NAMES what it tolerates rather than swallowing everything —
+ * the same correction the two P1 sites in this slice got (see
+ * `isExpectedFsMiss`). A missing file (raced away between `existsSync` and the
+ * read) and a stamp we cannot parse both mean "no usable stamp"; a
+ * `TypeError` from a broken dependency does not.
+ */
+export function readGeneratedArtifactsStamp(projectRoot) {
+    const stampPath = generatedArtifactsStampPath(projectRoot);
+    if (!existsSync(stampPath))
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(stampPath, 'utf8'));
+    }
+    catch (err) {
+        if (!isExpectedFsMiss(err) && !(err instanceof SyntaxError))
+            throw err;
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        return null;
+    const candidate = parsed;
+    if (typeof candidate['packageVersion'] !== 'string' ||
+        typeof candidate['templateVersion'] !== 'string' ||
+        typeof candidate['writtenAt'] !== 'string') {
+        return null;
+    }
+    return {
+        stampVersion: 1,
+        packageVersion: candidate['packageVersion'],
+        templateVersion: candidate['templateVersion'],
+        writtenAt: candidate['writtenAt']
+    };
+}
+/**
+ * Record what the generator just wrote. Called by `initWorkspace` on every
+ * successful materialization — including the one that changes nothing —
+ * because the stamp's job is "when did a release last regenerate this
+ * project", not "when did the bytes change".
+ *
+ * `packageVersion` / `now` are injectable so a test can write a deliberately
+ * old stamp without touching the clock or the package.
+ */
+export function writeGeneratedArtifactsStamp(projectRoot, options = {}) {
+    const stamp = {
+        stampVersion: 1,
+        packageVersion: options.packageVersion ?? CLI_VERSION,
+        templateVersion: TEMPLATE_VERSION,
+        writtenAt: (options.now ?? new Date()).toISOString()
+    };
+    const stampPath = generatedArtifactsStampPath(projectRoot);
+    const dir = dirname(stampPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(stampPath, `${JSON.stringify(stamp, null, 2)}\n`, 'utf8');
+    return stamp;
+}
+/**
+ * Is this project's generated config behind the installed peaks-loop?
+ *
+ * Returns `stale: false` — with no reasons — for the two cases that are NOT
+ * staleness:
+ *   - the project has no generated artifact at all (never initialized), and
+ *   - the stamp matches both expected versions.
+ *
+ * `unstamped` is reported only when an artifact EXISTS and no stamp does:
+ * those are projects initialized by a release that predates this module, and
+ * they are exactly the population the defect was reported against.
+ */
+export function detectStaleGeneratedArtifacts(projectRoot) {
+    const expected = { packageVersion: CLI_VERSION, templateVersion: TEMPLATE_VERSION };
+    const onDisk = readGeneratedArtifactsStamp(projectRoot);
+    const artifactsPresent = hasGeneratedArtifact(projectRoot);
+    if (!artifactsPresent) {
+        return { stale: false, reasons: [], onDisk, expected };
+    }
+    if (existsSync(generatedArtifactsStampPath(projectRoot)) && onDisk === null) {
+        return { stale: true, reasons: ['stamp-unreadable'], onDisk, expected };
+    }
+    if (onDisk === null) {
+        return { stale: true, reasons: ['unstamped'], onDisk, expected };
+    }
+    const reasons = [];
+    if (onDisk.packageVersion !== expected.packageVersion)
+        reasons.push('package-upgraded');
+    if (onDisk.templateVersion !== expected.templateVersion)
+        reasons.push('template-changed');
+    return { stale: reasons.length > 0, reasons, onDisk, expected };
+}

package/dist/services/workspace/workspace-claude-settings-materializer.d.ts

@@ -9,6 +9,14 @@
  * the parent module and calls into this sibling. Function signatures
  * and behaviour are unchanged (verbatim move).
  */
+/**
+ * The peaks-managed snippet appended to the consumer project's
+ * `.peaks/.gitignore` so the local-only settings file never lands
+ * in a commit. Marked with a managed-by header so we can detect (and
+ * not double-append) on subsequent inits.
+ */
+export declare const PEAKS_GITIGNORE_HEADER = "# >>> peaks-loop managed snippet (slice 2.0.1-bug3) \u2014 do not edit by hand";
+export declare const PEAKS_GITIGNORE_FOOTER = "# <<< peaks-loop managed snippet";
 /**
  * Materialize the consumer-project `.claude/settings.local.json` and
  * ensure the consumer's `.peaks/.gitignore` covers it. Returns a

package/dist/services/workspace/workspace-claude-settings-materializer.js

@@ -81,6 +81,9 @@ function readEnvObject(serialized) {
  *   → installAutoCompactHook (installed, 4: … | Bash|Task)
  *   → init again (REFRESHED, 3: … )   ← the Bash|Task entry is gone
  *
+ * (The 3 is a 2 since TEMPLATE_VERSION 1.8.0 retired the
+ * `Write|Edit|MultiEdit` entry. The measurement above is left as taken.)
+ *
  * and nothing re-installs it: the hook's whole job was to fire on the next
  * Bash/Task call, so once it is deleted the auto-compact contract stops
  * silently.
@@ -139,8 +142,13 @@ function isPlainRecord(value) {
  * in a commit. Marked with a managed-by header so we can detect (and
  * not double-append) on subsequent inits.
  */
-const PEAKS_GITIGNORE_HEADER = '# >>> peaks-loop managed snippet (slice 2.0.1-bug3) — do not edit by hand';
-const PEAKS_GITIGNORE_FOOTER = '# <<< peaks-loop managed snippet';
+// Exported (S6, 2026-09-15) so the convergence tests can build a block with
+// the REAL delimiters. A test that retypes them gets a prefix and silently
+// exercises the append path instead of the converge path — which is exactly
+// what happened on the first run of
+// `tests/unit/services/workspace/gitignore-snippet-convergence.test.ts`.
+export const PEAKS_GITIGNORE_HEADER = '# >>> peaks-loop managed snippet (slice 2.0.1-bug3) — do not edit by hand';
+export const PEAKS_GITIGNORE_FOOTER = '# <<< peaks-loop managed snippet';
 const PEAKS_GITIGNORE_SNIPPET = [
     PEAKS_GITIGNORE_HEADER,
     '# Consumer-project .claude/settings.local.json: written by `peaks workspace init`',
@@ -386,7 +394,34 @@ async function upsertPeaksGitignoreSnippet(projectRoot) {
             existing = '';
         }
     }
-    if (existing.includes(PEAKS_GITIGNORE_HEADER)) {
+    // D2 fix (2026-09-15): the block is now converged, not merely appended.
+    //
+    // Before this, a project that already had the header returned here forever:
+    // the snippet was written once by whichever release first initialized the
+    // project and NEVER updated, so a pattern added to the snippet by a later
+    // release (`slice 2.0.1-bug3` moved the block from `.peaks/.gitignore` to
+    // the root for exactly this class of reason) reached only projects that had
+    // not been initialized yet — i.e. new users got the fix and existing users
+    // did not, which is backwards.
+    //
+    // Scope of the rewrite is the managed block, and only the block. Every line
+    // outside `HEADER..FOOTER` is spliced through byte-for-byte, which is the
+    // "never overwrite the user's edits" semantic this function always had. The
+    // header itself says "do not edit by hand"; a user who did is the case
+    // `stripLegacyPeaksGitignoreSnippet` already refuses to guess at, and this
+    // does the same — a header with no footer is left alone rather than opened
+    // up and repaired at the risk of eating the rest of the file.
+    const start = existing.indexOf(PEAKS_GITIGNORE_HEADER);
+    if (start !== -1) {
+        const footerAt = existing.indexOf(PEAKS_GITIGNORE_FOOTER, start + PEAKS_GITIGNORE_HEADER.length);
+        if (footerAt === -1)
+            return;
+        const end = footerAt + PEAKS_GITIGNORE_FOOTER.length;
+        const currentBlock = existing.slice(start, end);
+        const nextBlock = PEAKS_GITIGNORE_SNIPPET.trimEnd();
+        if (currentBlock === nextBlock)
+            return;
+        await writeFile(gitignorePath, existing.slice(0, start) + nextBlock + existing.slice(end), 'utf8');
         return;
     }
     const separator = existing.length > 0 && !existing.endsWith('\n') ? '\n' : '';

package/dist/services/workspace/workspace-service.js

@@ -363,6 +363,15 @@ export async function initWorkspace(options) {
                 .map((write) => write.relativePath)
         };
     }
+    const claudeSettings = await materializeClaudeSettingsLocal(options.projectRoot, options.noClaudeHooks === true);
+    // G4 (2026-09-15): record which release generated this project's config.
+    // Without it there is nothing on disk for a LATER release to compare
+    // against, so "your generated config is behind the installed peaks-loop"
+    // is not a decidable question — which is the whole of D1. Written on every
+    // init (including the no-op ones): the stamp answers "when did a release
+    // last regenerate this project", not "when did the bytes change". See
+    // `generated-artifacts-stamp.ts`.
+    writeGeneratedArtifactsStamp(options.projectRoot);
     return {
         sessionId: options.sessionId,
         sessionRoot,
@@ -370,7 +379,7 @@ export async function initWorkspace(options) {
         alreadyExisted,
         bound,
         previousSessionId,
-        claudeSettings: await materializeClaudeSettingsLocal(options.projectRoot, options.noClaudeHooks === true),
+        claudeSettings,
         standardsMissing,
         ...(standardsApplied !== undefined ? { standardsApplied } : {})
     };
@@ -385,6 +394,7 @@ export async function initWorkspace(options) {
 // are unchanged (verbatim move).
 import { materializeClaudeSettingsLocal } from './workspace-claude-settings-materializer.js';
 export { materializeClaudeSettingsLocal } from './workspace-claude-settings-materializer.js';
+import { writeGeneratedArtifactsStamp } from './generated-artifacts-stamp.js';
 /**
  * Slice C10 (2026-06-24-legacy-change-id-sibling): whole-dir shape check
  * for the legacy sibling `.peaks/_runtime/<sessionId>/`. Returns `true` ONLY when

package/dist/shared/fs-utils.d.ts

@@ -1,4 +1,30 @@
 import { type Platform } from './platform.js';
+/**
+ * Does this error mean "the path is legitimately absent or unreadable by us"?
+ *
+ * A `catch` is allowed to turn THAT class of failure into a fallback value.
+ * Every other error is a bug and must propagate. Without the distinction,
+ * "this catch only swallows IO errors" is a claim the code cannot keep:
+ *
+ *   catch (err) {
+ *     if (err instanceof ReferenceError) throw err;
+ *     if (err instanceof SyntaxError) throw err;
+ *     return null;   // ← swallows every TypeError, every ERR_INVALID_ARG_TYPE,
+ *                    //   every error a dependency throws, and calls it "IO"
+ *   }
+ *
+ * That exact shape sat on two priority sites (`post-compact-detector`,
+ * `step-08-gate`) with that exact comment. Rethrowing the two JS error
+ * classes it happened to name is not the same rule as swallowing one error
+ * class and rethrowing the rest — and it is the *inverted* one: the more
+ * unexpected the failure, the more certainly it was swallowed.
+ *
+ * The set is deliberately the "miss" codes only. `EISDIR` is included because
+ * reading a directory where a file was expected is indistinguishable from
+ * absent to every caller here, and excluding it would turn a pre-existing
+ * silent fallback into a new loud failure for no gain.
+ */
+export declare function isExpectedFsMiss(err: unknown): boolean;
 export declare function getDirectoryLinkType(targetPlatform?: Platform): 'junction' | 'dir';
 export declare function createDirectoryLinkSync(target: string, linkPath: string): void;
 export declare function readDirectoryLinkTarget(linkPath: string): string | null;

package/dist/shared/fs-utils.js

@@ -1,5 +1,40 @@
 import { symlinkSync as nodeSymlinkSync, readlinkSync } from 'node:fs';
 import { platform } from './platform.js';
+/**
+ * Does this error mean "the path is legitimately absent or unreadable by us"?
+ *
+ * A `catch` is allowed to turn THAT class of failure into a fallback value.
+ * Every other error is a bug and must propagate. Without the distinction,
+ * "this catch only swallows IO errors" is a claim the code cannot keep:
+ *
+ *   catch (err) {
+ *     if (err instanceof ReferenceError) throw err;
+ *     if (err instanceof SyntaxError) throw err;
+ *     return null;   // ← swallows every TypeError, every ERR_INVALID_ARG_TYPE,
+ *                    //   every error a dependency throws, and calls it "IO"
+ *   }
+ *
+ * That exact shape sat on two priority sites (`post-compact-detector`,
+ * `step-08-gate`) with that exact comment. Rethrowing the two JS error
+ * classes it happened to name is not the same rule as swallowing one error
+ * class and rethrowing the rest — and it is the *inverted* one: the more
+ * unexpected the failure, the more certainly it was swallowed.
+ *
+ * The set is deliberately the "miss" codes only. `EISDIR` is included because
+ * reading a directory where a file was expected is indistinguishable from
+ * absent to every caller here, and excluding it would turn a pre-existing
+ * silent fallback into a new loud failure for no gain.
+ */
+export function isExpectedFsMiss(err) {
+    const code = err?.code;
+    return (code === 'ENOENT' ||
+        code === 'ENOTDIR' ||
+        code === 'EISDIR' ||
+        code === 'EACCES' ||
+        code === 'EPERM' ||
+        code === 'ELOOP' ||
+        code === 'ENAMETOOLONG');
+}
 export function getDirectoryLinkType(targetPlatform = platform) {
     return targetPlatform === 'win32' ? 'junction' : 'dir';
 }

package/dist/shared/runtime-root.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The one seam through which a `.peaks/_runtime` path is built.
+ *
+ * Slice 2026-09-15 (runtime-path-unrepresentable). Three attempts to *detect*
+ * a caller-supplied id reaching a runtime join all failed the same way: the
+ * shipped text rule caught 4 of 12 fixture shapes where the name-based
+ * predicate it replaced caught 8, and the version that reached 10 of 12 gave
+ * back the change that reached 12 because it cost seven findings on live code —
+ * two of them structural (a guard helper, and readers that take the guarded
+ * value as a parameter). Its measured verdict: reassignment between guard and
+ * join, and guard-after-join, are **domination failures inside a single
+ * function, invisible to any text key**.
+ *
+ * So the instrument is retired in favour of a property. The id cannot reach a
+ * runtime join unguarded because there is no longer a join that accepts an
+ * unguarded string: `RuntimeRoot.join` takes `GuardedSegment`, and a
+ * `GuardedSegment` can only be produced by `guardRuntimeSegment`, which throws
+ * on the shapes the escapes used. A newly written unguarded join is a type
+ * error at authoring time — not a removed guard that some later scan notices.
+ *
+ * The raw root is not obtainable as a string except through `dir()`, which is
+ * named so that a join written from it (`join(root.dir(), id)`) reads at review
+ * time as the bypass it is. `dir()` exists because callers legitimately
+ * enumerate the root itself; it is not a join.
+ */
+declare const RUNTIME_SEGMENT: unique symbol;
+/**
+ * A path segment that has been checked as a single safe segment.
+ *
+ * Unforgeable by construction: the brand is a `unique symbol` that is never
+ * exported, so `value as GuardedSegment` outside this module is a type error
+ * and a plain `string` is not assignable. `guardRuntimeSegment` is the only
+ * producer.
+ */
+export type GuardedSegment = string & {
+    readonly [RUNTIME_SEGMENT]: true;
+};
+/**
+ * Check a caller-supplied string and brand it for use as a runtime path
+ * segment. `label` names the id in the error the way the caller knows it
+ * ("session id", "project id"), because the throw site is one function away
+ * from the caller that supplied it.
+ *
+ * Rejects exactly the shapes `isUnsafePathInput` rejects: separators, `..`,
+ * absolute and drive-prefixed paths, UNC and URL shapes, and empty segments.
+ */
+export declare function guardRuntimeSegment(value: string, label: string): GuardedSegment;
+/**
+ * The `.peaks/_runtime` root of one project, as a capability rather than a
+ * string. `#path` is a private field, so the raw root cannot be read off the
+ * object and joined by an unguarded `join()`.
+ */
+export declare class RuntimeRoot {
+    #private;
+    private constructor();
+    /** The runtime root of `projectRoot`. */
+    static at(projectRoot: string): RuntimeRoot;
+    /**
+     * Join guarded segments onto the root. At least one segment is required: a
+     * zero-argument `join()` would hand back the bare root as a `string`, which
+     * is the capability this class exists to withhold.
+     */
+    join(first: GuardedSegment, ...rest: readonly GuardedSegment[]): string;
+    /**
+     * The root itself, for READ-only enumeration (`readdir`, `existsSync`) — not
+     * for joining. Deliberately a method rather than a property so a bypass is
+     * legible at the call site.
+     */
+    dir(): string;
+}
+/** The runtime root of `projectRoot`. */
+export declare function runtimeRoot(projectRoot: string): RuntimeRoot;
+export {};

package/dist/shared/runtime-root.js

@@ -0,0 +1,77 @@
+/**
+ * The one seam through which a `.peaks/_runtime` path is built.
+ *
+ * Slice 2026-09-15 (runtime-path-unrepresentable). Three attempts to *detect*
+ * a caller-supplied id reaching a runtime join all failed the same way: the
+ * shipped text rule caught 4 of 12 fixture shapes where the name-based
+ * predicate it replaced caught 8, and the version that reached 10 of 12 gave
+ * back the change that reached 12 because it cost seven findings on live code —
+ * two of them structural (a guard helper, and readers that take the guarded
+ * value as a parameter). Its measured verdict: reassignment between guard and
+ * join, and guard-after-join, are **domination failures inside a single
+ * function, invisible to any text key**.
+ *
+ * So the instrument is retired in favour of a property. The id cannot reach a
+ * runtime join unguarded because there is no longer a join that accepts an
+ * unguarded string: `RuntimeRoot.join` takes `GuardedSegment`, and a
+ * `GuardedSegment` can only be produced by `guardRuntimeSegment`, which throws
+ * on the shapes the escapes used. A newly written unguarded join is a type
+ * error at authoring time — not a removed guard that some later scan notices.
+ *
+ * The raw root is not obtainable as a string except through `dir()`, which is
+ * named so that a join written from it (`join(root.dir(), id)`) reads at review
+ * time as the bypass it is. `dir()` exists because callers legitimately
+ * enumerate the root itself; it is not a join.
+ */
+import { join } from 'node:path';
+import { isUnsafePathInput } from './path-safety.js';
+/**
+ * Check a caller-supplied string and brand it for use as a runtime path
+ * segment. `label` names the id in the error the way the caller knows it
+ * ("session id", "project id"), because the throw site is one function away
+ * from the caller that supplied it.
+ *
+ * Rejects exactly the shapes `isUnsafePathInput` rejects: separators, `..`,
+ * absolute and drive-prefixed paths, UNC and URL shapes, and empty segments.
+ */
+export function guardRuntimeSegment(value, label) {
+    if (isUnsafePathInput(value)) {
+        throw new Error(`Invalid ${label}: ${value} (must be a single path segment)`);
+    }
+    return value;
+}
+/**
+ * The `.peaks/_runtime` root of one project, as a capability rather than a
+ * string. `#path` is a private field, so the raw root cannot be read off the
+ * object and joined by an unguarded `join()`.
+ */
+export class RuntimeRoot {
+    #path;
+    constructor(path) {
+        this.#path = path;
+    }
+    /** The runtime root of `projectRoot`. */
+    static at(projectRoot) {
+        return new RuntimeRoot(join(projectRoot, '.peaks', '_runtime'));
+    }
+    /**
+     * Join guarded segments onto the root. At least one segment is required: a
+     * zero-argument `join()` would hand back the bare root as a `string`, which
+     * is the capability this class exists to withhold.
+     */
+    join(first, ...rest) {
+        return join(this.#path, first, ...rest);
+    }
+    /**
+     * The root itself, for READ-only enumeration (`readdir`, `existsSync`) — not
+     * for joining. Deliberately a method rather than a property so a bypass is
+     * legible at the call site.
+     */
+    dir() {
+        return this.#path;
+    }
+}
+/** The runtime root of `projectRoot`. */
+export function runtimeRoot(projectRoot) {
+    return RuntimeRoot.at(projectRoot);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "peaks-loop",
-  "version": "4.0.48",
+  "version": "4.0.50",
   "description": "Loop Engineering CLI — workflow primitive / loop guards / evaluators / slice orchestration",
   "author": "SquabbyZ",
   "keywords": [
@@ -102,10 +102,10 @@
     "picomatch": "4.0.4",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "peaks-loop-internal-runtime": "0.0.33",
-    "peaks-loop-shared-channel": "0.0.50",
-    "peaks-loop-shared": "0.0.82",
-    "peaks-loop-mut": "0.1.46"
+    "peaks-loop-mut": "0.1.48",
+    "peaks-loop-internal-runtime": "0.0.35",
+    "peaks-loop-shared-channel": "0.0.52",
+    "peaks-loop-shared": "0.0.84"
   },
   "devDependencies": {
     "@changesets/cli": "2.31.1",
@@ -141,6 +141,8 @@
     "test:dev": "vitest run tests/unit",
     "test:dev:cli": "vitest run tests/unit",
     "test:unit": "vitest run tests/unit",
+    "test:e2e": "vitest run --config vitest.config.e2e.ts",
+    "test:lint": "vitest run --config vitest.config.lint.ts",
     "test:integration": "vitest run --config vitest.config.integration.ts tests/integration",
     "test:capability-guard": "vitest run --config vitest.config.integration.ts tests/integration/capability-guard",
     "test:cli": "vitest run tests/unit",
@@ -149,8 +151,8 @@
     "test:ci": "node ./scripts/sync-version.mjs && node ./scripts/lint/silent-warning-detector.mjs && vitest run --coverage",
     "test:changed": "node scripts/test-changed.mjs",
     "lint:silent-warning": "node ./scripts/lint/silent-warning-detector.mjs",
-    "test:race": "vitest run --no-file-parallelism packages/peaks-loop-shared-channel/tests/shared-channel.test.ts tests/unit/dispatch-record-writer.test.ts tests/unit/services/retrospective/heartbeat.test.ts tests/unit/cli/commands/share-commands.test.ts",
-    "test:replay": "node scripts/fixture-capture-setup.mjs && vitest run tests/unit/replay tests/unit/fixture",
+    "test:race": "vitest run --no-file-parallelism packages/peaks-loop-shared-channel/tests/shared-channel.test.ts tests/unit/services/dispatch/dispatch-record-writer.test.ts",
+    "test:replay": "node scripts/fixture-capture-setup.mjs && vitest run tests/unit/services/dispatch/conflict-replay.test.ts tests/unit/services/dispatch/e2e-fixtures.test.ts",
     "fixture:capture-setup": "node scripts/fixture-capture-setup.mjs",
     "test:coverage": "node ./scripts/coverage-c8.mjs",
     "test:coverage:c8": "node ./scripts/coverage-c8.mjs",

package/scripts/copy-templates.mjs

@@ -60,18 +60,6 @@ const targets = [
     src: join(packageRoot, 'src/services/skillhub/migrations'),
     dest: join(packageRoot, 'dist/services/skillhub/migrations'),
     extensions: ['.sql']
-  },
-  {
-    // Slice c5-write-hook-exec-form: the Write|Edit|MultiEdit PreToolUse gate
-    // emitted by `peaks workspace init` is invoked as `node <path>`, and the
-    // path is resolved relative to this module — `dist/services/hooks/` in an
-    // installed consumer, `src/services/hooks/` under tsx. A plain `.js` asset
-    // (not a `.ts` compiled by tsc) is what lets ONE relative filename be valid
-    // in both trees. Without this copy the hook would be a broken path in every
-    // installed consumer while every test in this repo still passed.
-    src: join(packageRoot, 'src/services/hooks'),
-    dest: join(packageRoot, 'dist/services/hooks'),
-    extensions: ['.js']
   }
 ];