peaks-loop 4.0.48 → 4.0.49

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

@@ -44,7 +44,14 @@ const MODERN_RETENTION_REQUIREMENTS = [
     'qa/test-reports/{sliceId}.md',
     'txt/handoff.md'
 ];
-const SLICE_ID_PATTERN = /^(?!\.{1,2}$)[A-Za-z0-9._-]+$/;
+/**
+ * The repo's slice-id control — no separator, no drive, no `..`, non-empty, and
+ * not a bare `.`/`..`. Exported 2026-09-14 (repair R1) so the slice-id axis has
+ * ONE control: `slice-review-state.getReviewPath` joins a caller-supplied slice
+ * id into a filename and previously had none, and a second copy of this regex
+ * there would be the same axis decided twice.
+ */
+export const SLICE_ID_PATTERN = /^(?!\.{1,2}$)[A-Za-z0-9._-]+$/;
 function getPeaksPath(workspaceRoot) {
     return resolve(workspaceRoot, '.peaks');
 }

package/dist/services/session/getSessionDir.d.ts

@@ -1 +1,34 @@
 export declare function getSessionDir(projectRoot: string, sessionId: string): string;
+/**
+ * The TOTAL entry to the same axis. Same predicate, same path; the only
+ * difference is that this one is total — it never throws.
+ *
+ * WHY TWO ENTRIES RATHER THAN ONE. The partial entry above is correct
+ * for a caller that cannot proceed without a session dir: a throw is
+ * the one failure a caller cannot forget to handle. It is the WRONG
+ * shape for a frame whose own doc promises never to throw — the
+ * statusline, the fire-and-forget telemetry writer, the best-effort
+ * probe. Each of those frames had to wrap the partial entry in a
+ * `try { } catch { return null }`, and that swallow cannot be told
+ * apart from a real "there is nothing here" answer. Measured on the
+ * compact backoff (`auto-compact-lifecycle.ts`), the conflation turned
+ * an unresolvable id into the ADMIT branch and re-opened a dispatch
+ * that the open run should have suppressed.
+ *
+ * The split does NOT make a swallow unwriteable — TypeScript has no
+ * checked exceptions, so nothing here can. It makes the swallow
+ * UNNECESSARY at a named place, and it gives every checker a stable
+ * name to key on: a frame that degrades must say so by calling this
+ * function, and the degrading branch (`ok: false`) is then a value the
+ * caller has to handle rather than a `catch` nobody reads.
+ *
+ * `reason` is a single-line English sentence fit for an envelope — no
+ * stack traces, no CLI verbs (see `human-nl-choice-only-tenet`).
+ */
+export declare function tryGetSessionDir(projectRoot: string, sessionId: string): {
+    readonly ok: true;
+    readonly dir: string;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};

package/dist/services/session/getSessionDir.js

@@ -22,11 +22,71 @@
  *       legacy `.peaks/<sid>/...` artifact path that a sub-agent would
  *       follow verbatim.
  *
+ * `sessionId` is the last caller-supplied segment of every session-scoped
+ * path here, so its segment check lives at this join rather than being
+ * re-derived at each call site: `../../x` used to be joined verbatim, and
+ * the CLI wrote outside the project root while still returning `ok: true`.
+ *
+ * The predicate is `isUnsafePathInput`, NOT `SESSION_ID_PATTERN` /
+ * `validateSessionId`. The latter are stricter than the segment axis and
+ * reject ids that are legal today (`sid-1`, a request id reused as the
+ * session-dir name), so adopting them would change results for
+ * well-formed callers.
+ *
+ * Not covered, recorded rather than implied: the `\0` axis
+ * (`isUnsafePathInput` admits a NUL, and `execFileSync` raises EINVAL
+ * before it can be exercised), and callers that hand-roll
+ * `join(root, '.peaks', '_runtime', sid, ...)` instead of calling this.
+ *
  * @param projectRoot - Absolute path to the project root.
  * @param sessionId - The session identifier (e.g. `2026-06-06-session-5b1095`).
  * @returns Absolute path to the canonical session directory.
+ * @throws Error when `sessionId` is not a single path segment.
  */
 import { join } from 'node:path';
+import { isUnsafePathInput } from '../../shared/path-safety.js';
 export function getSessionDir(projectRoot, sessionId) {
+    // Throwing, not `null` / a tagged result: those widen the return type
+    // to `string | null` and make every call site handle a bad id — the
+    // per-site slice this guard replaces. This is also the shape the repo
+    // already refuses with, and a caller cannot forget to handle a throw.
+    if (isUnsafePathInput(sessionId)) {
+        throw new Error(`Invalid session id: ${sessionId} (must be a single path segment)`);
+    }
     return join(projectRoot, '.peaks', '_runtime', sessionId);
 }
+/**
+ * The TOTAL entry to the same axis. Same predicate, same path; the only
+ * difference is that this one is total — it never throws.
+ *
+ * WHY TWO ENTRIES RATHER THAN ONE. The partial entry above is correct
+ * for a caller that cannot proceed without a session dir: a throw is
+ * the one failure a caller cannot forget to handle. It is the WRONG
+ * shape for a frame whose own doc promises never to throw — the
+ * statusline, the fire-and-forget telemetry writer, the best-effort
+ * probe. Each of those frames had to wrap the partial entry in a
+ * `try { } catch { return null }`, and that swallow cannot be told
+ * apart from a real "there is nothing here" answer. Measured on the
+ * compact backoff (`auto-compact-lifecycle.ts`), the conflation turned
+ * an unresolvable id into the ADMIT branch and re-opened a dispatch
+ * that the open run should have suppressed.
+ *
+ * The split does NOT make a swallow unwriteable — TypeScript has no
+ * checked exceptions, so nothing here can. It makes the swallow
+ * UNNECESSARY at a named place, and it gives every checker a stable
+ * name to key on: a frame that degrades must say so by calling this
+ * function, and the degrading branch (`ok: false`) is then a value the
+ * caller has to handle rather than a `catch` nobody reads.
+ *
+ * `reason` is a single-line English sentence fit for an envelope — no
+ * stack traces, no CLI verbs (see `human-nl-choice-only-tenet`).
+ */
+export function tryGetSessionDir(projectRoot, sessionId) {
+    // Deliberately NOT `try { return {ok:true, dir: getSessionDir(...)} } catch`.
+    // That would re-introduce the swallow this function exists to remove, and it
+    // would also catch a throw from `join` for reasons that are not a bad id.
+    if (isUnsafePathInput(sessionId)) {
+        return { ok: false, reason: `Invalid session id: ${sessionId} (must be a single path segment)` };
+    }
+    return { ok: true, dir: join(projectRoot, '.peaks', '_runtime', sessionId) };
+}

package/dist/services/slice/slice-review-state.js

@@ -15,6 +15,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { isUnsafePathInput } from '../../shared/path-safety.js';
+import { SLICE_ID_PATTERN } from '../sc/sc-service.js';
 /** The 5 default review items per slice (the 12 Gaps memory checklist). */
 export const DEFAULT_REVIEW_ITEMS = [
     { id: 'business-match', question: '这个 slice 做完,业务流程对吗?(跟产品最初给的需求匹配)' },
@@ -33,16 +34,30 @@ export function buildEmptySliceReview(sliceId, sessionId, now = new Date()) {
     };
 }
 export function getReviewDir(projectRoot, sessionId) {
-    // Sid axis. Every `peaks slice-review|score|accept|reject` subcommand reaches
-    // the runtime tree through this one constructor. Measured: `--session-id
-    // ../../../../…/PWNED` wrote `slice-reviews/<slice-id>.json` outside every
-    // project root under an `ok: true` envelope (RD sweep case A26).
+    // Sid axis ONLY. Every `peaks slice-review|score|accept|reject` subcommand
+    // reaches the runtime tree through this one constructor. Measured:
+    // `--session-id ../../../../…/PWNED` wrote `slice-reviews/<slice-id>.json`
+    // outside every project root under an `ok: true` envelope (RD sweep case A26).
+    //
+    // It does NOT cover the slice-id axis: the slice id is joined one function
+    // later, in `getReviewPath` below. Corrected 2026-09-14 (repair R1) — this
+    // comment previously said one guard covered the whole family; the security
+    // audit of `2026-09-14-cli-id-escape-instrumentation` (F1b) measured that
+    // false: `slice-review '../../../../…/EVILSL'` wrote a `.json` file outside
+    // the project root under `ok: true`.
     if (isUnsafePathInput(sessionId)) {
         throw new Error(`Invalid session id: ${sessionId} (must be a single path segment)`);
     }
     return resolve(projectRoot, '.peaks', '_runtime', sessionId, 'slice-reviews');
 }
 export function getReviewPath(projectRoot, sessionId, sliceId) {
+    // Slice-id axis. The slice id is the CLI positional (`slice-review
+    // <slice-id>`), so it is caller-supplied and it becomes a filename segment
+    // here. Same control as the rid axis: a pinned format beats the segment check,
+    // which admits `a/b`.
+    if (!SLICE_ID_PATTERN.test(sliceId)) {
+        throw new Error(`Invalid slice id: ${sliceId} (expected letters, digits, dots, underscores, or dashes)`);
+    }
     return join(getReviewDir(projectRoot, sessionId), `${sliceId}.json`);
 }
 export function readSliceReview(projectRoot, sessionId, sliceId) {

package/dist/services/workflow/pipeline-verify-gate-support.js

@@ -28,17 +28,16 @@ export async function findRequestFile(projectRoot, role, rid) {
     const artifact = await showRequestArtifact({ projectRoot, role: role, requestId: rid });
     if (artifact === null)
         return null;
-    // Slice 2026-06-28-code-mode-bypass-fix (defect #3): the legacy
-    // `showRequestArtifact` returns the FULL SCOPE (`_runtime/<sid>`)
-    // as `sessionId`, not just the trailing id segment. The canonical
-    // evidence lookup needs only the bare id (`.peaks/_runtime/change/<id>/`).
-    // When the scope starts with `_runtime/`, strip that prefix so the
-    // path resolver builds the right canonical location.
-    let sessionId = artifact.sessionId;
-    if (sessionId.startsWith('_runtime/') || sessionId.startsWith('_runtime\\')) {
-        sessionId = sessionId.replace(/^_runtime[\\/]/, '');
-    }
-    return { path: artifact.path, content: artifact.content, sessionId };
+    // Slice 2026-06-28-code-mode-bypass-fix (defect #3) used to strip a
+    // `_runtime/` prefix here, because `showRequestArtifact` then returned the
+    // FULL SCOPE (`_runtime/<sid>`) as `sessionId`. Repair R5 removed that
+    // round-trip at its source: `readSummary` now builds the summary from the
+    // already-resolved directory and the bare id, so `sessionId` is the bare id
+    // and the prefix strip could never fire. It was removed by repair R7 rather
+    // than left in place as dead code with a comment asserting a behaviour its
+    // callee no longer has — an artifact claiming something the code does not do
+    // is the defect class this line of work exists to remove.
+    return { path: artifact.path, content: artifact.content, sessionId: artifact.sessionId };
 }
 /**
  * Where the CURRENT contract puts one gate's evidence.

package/dist/services/workflow/pipeline-verify-service.d.ts

@@ -5,7 +5,7 @@
  * returns a structured `PipelineVerification` envelope. Type
  * declarations live in `pipeline-verify-types.ts`; private gate
  * helpers (`rdGatesForType`, `qaGatesForType`, `extractState`,
- * `findRequestFile`, the `_runtime/` prefix strip, the RD/QA handoff
+ * `findRequestFile`, the RD/QA handoff
  * state sets, and the RD/QA evidence path probes) live in
  * `pipeline-verify-gate-support.ts`. The re-export shim at the
  * bottom preserves the original public surface so existing import

package/dist/services/workflow/pipeline-verify-service.js

@@ -5,7 +5,7 @@
  * returns a structured `PipelineVerification` envelope. Type
  * declarations live in `pipeline-verify-types.ts`; private gate
  * helpers (`rdGatesForType`, `qaGatesForType`, `extractState`,
- * `findRequestFile`, the `_runtime/` prefix strip, the RD/QA handoff
+ * `findRequestFile`, the RD/QA handoff
  * state sets, and the RD/QA evidence path probes) live in
  * `pipeline-verify-gate-support.ts`. The re-export shim at the
  * bottom preserves the original public surface so existing import
@@ -16,7 +16,7 @@
 import { isRequestType } from '../artifacts/artifact-prerequisites.js';
 import { readSkipState } from './workflow-state-store.js';
 import { getSessionIdCanonical } from '../session/session-manager.js';
-import { listUnpromotedFeedback } from '../feedback/feedback-promotion-service.js';
+import { listPromotionExempt, listUnpromotedFeedback } from '../feedback/feedback-promotion-service.js';
 import { QA_COMPLETE_STATES, RD_QA_HANDOFF_STATES, extractState, findRequestFile, qaGatesForType, rdGatesForType, resolveQaEvidencePaths, resolveRdEvidencePaths } from './pipeline-verify-gate-support.js';
 export async function verifyPipeline(options) {
     const requestType = isRequestType(options.requestType ?? '') ? options.requestType : 'feature';
@@ -178,10 +178,12 @@ export async function verifyPipeline(options) {
     }
     // Slice 002 (v2.15.0) AC-3 — Gate H "feedback-promotion". Scans
     // `.peaks/memory/*.md` for `metadata.type === 'feedback'` entries
-    // without a promotion marker (HTML comment or `.promotion.json`
-    // sidecar). When any unpromoted feedback is found, the gate fails
-    // and the pipeline does not complete until the user promotes via
-    // `peaks feedback promote <memory-file> --layer <A|B|C>`.
+    // that lack a promotion marker (HTML comment or `.promotion.json`
+    // sidecar) OR whose marker is not backed by the layer's artifact
+    // (rid 2026-09-14-gate-h-promotion). When any such feedback is
+    // found, the gate fails and the pipeline does not complete until the
+    // user promotes via `peaks feedback promote <memory-file> --layer
+    // <A|B|C>` — which now produces the artifact, not just the marker.
     //
     // The scan is intentionally non-throwing — a missing or unreadable
     // memory dir is treated as "no feedback found, gate passes" so
@@ -196,14 +198,25 @@ export async function verifyPipeline(options) {
     ];
     try {
         const unpromoted = listUnpromotedFeedback({ projectRoot: options.projectRoot });
+        // rid 2026-09-14-gate-h-promotion (classify slice): memories that declare
+        // themselves out of the gate are reported, never dropped. An exemption the
+        // gate does not show would be indistinguishable from a fixed violation.
+        const exempt = listPromotionExempt({ projectRoot: options.projectRoot });
+        const exemptNote = exempt.length === 0
+            ? ''
+            : `; ${exempt.length} declared not-to-be-promoted: ${exempt.map((e) => `${e.name} (${e.code})`).join('; ')}`;
         if (unpromoted.length === 0) {
             feedbackGates[0].passed = true;
-            feedbackGates[0].detail = `0 unpromoted feedback memories in .peaks/memory/`;
+            feedbackGates[0].detail = `0 unpromoted feedback memories in .peaks/memory/${exemptNote}`;
         }
         else {
-            feedbackGates[0].detail = `${unpromoted.length} unpromoted feedback memor${unpromoted.length === 1 ? 'y' : 'ies'}: ${unpromoted.map((u) => u.name).join(', ')}`;
-            violations.push(`Gate H feedback-promotion FAILED: ${unpromoted.length} feedback memor${unpromoted.length === 1 ? 'y is' : 'ies are'} not yet promoted to an enforcement layer (${unpromoted.map((u) => u.name).join(', ')}). Run \`peaks feedback promote <memory-file> --layer <A|B|C>\` for each. See sops/feedback-promotion-sop.md.`);
-            nextActions.push(`Run \`peaks feedback promote <memory-file> --layer <A|B|C>\` for each unpromoted feedback memory to satisfy Gate H.`);
+            // rid 2026-09-14-gate-h-promotion: the gate no longer passes on a marker
+            // alone. `listUnpromotedFeedback` now also reports markers whose layer
+            // artifact is absent, so `unpromoted` mixes "never promoted" with
+            // "promoted on paper only" — the reason on each entry says which.
+            feedbackGates[0].detail = `${unpromoted.length} feedback memor${unpromoted.length === 1 ? 'y' : 'ies'} without a backed promotion: ${unpromoted.map((u) => `${u.name} (${u.reason})`).join('; ')}${exemptNote}`;
+            violations.push(`Gate H feedback-promotion FAILED: ${unpromoted.length} feedback memor${unpromoted.length === 1 ? 'y is' : 'ies are'} not yet promoted to an enforcement layer with a real artifact (${unpromoted.map((u) => u.name).join(', ')})${exemptNote}. A marker alone does not count: layer A needs a registered SOP manifest, layer B a hook command that runs something named after the rule in .peaks/.claude-settings-template.json, layer C a hard-floor category in src/services/code/mode-gate.ts. Run \`peaks feedback promote <memory-file> --layer <A|B|C>\` for each and read what it reports. See sops/feedback-promotion-sop.md.`);
+            nextActions.push(`Run \`peaks feedback promote <memory-file> --layer <A|B|C>\` for each feedback memory without a backed promotion to satisfy Gate H.`);
         }
     }
     catch {

package/dist/services/workflow/pipeline-verify-types.d.ts

@@ -50,9 +50,11 @@ export type PipelineVerification = {
      * Slice 002 (v2.15.0) AC-3: Gate H "feedback-promotion". Always
      * present (single-element array). Evaluates whether every
      * `metadata.type === 'feedback'` memory in `.peaks/memory/`
-     * carries a promotion marker (comment OR sidecar). Failures
-     * block the `complete` verdict via the `gateH` field below; the
-     * pipeline only completes when every gate in this array passes.
+     * carries a promotion marker (comment OR sidecar) AND whether the
+     * layer that marker claims is actually backed by its artifact
+     * (rid 2026-09-14-gate-h-promotion). Failures block the `complete`
+     * verdict via the `gateH` field below; the pipeline only completes
+     * when every gate in this array passes.
      */
     feedbackPhase?: {
         gates: PipelineGate[];

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.49",
   "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-internal-runtime": "0.0.34",
+    "peaks-loop-mut": "0.1.47",
+    "peaks-loop-shared": "0.0.83",
+    "peaks-loop-shared-channel": "0.0.51"
   },
   "devDependencies": {
     "@changesets/cli": "2.31.1",