peaks-loop 3.1.2 → 4.0.0-beta.10

package/dist/services/migrate-skill-name/migrate.d.ts

@@ -0,0 +1,17 @@
+import type { MigrateResult } from './schema.js';
+export interface MigrateOpts {
+    projectRoot: string;
+    from: string;
+    to: string;
+    /** false = dry-run (default); true = write through. */
+    apply: boolean;
+}
+/** True iff `absPath` falls under any skip-path (substring match). */
+export declare function shouldSkip(projectRoot: string, absPath: string): boolean;
+/**
+ * Recursively walk a directory and return every `.json` / `.md`
+ * path. Missing root → empty list (the CLI reports scannedFiles:0,
+ * which is the truthful "nothing to look at" signal).
+ */
+export declare function walkRuntimeFiles(root: string): string[];
+export declare function migrateSkillName(opts: MigrateOpts): MigrateResult;

package/dist/services/migrate-skill-name/migrate.js

@@ -0,0 +1,152 @@
+/**
+ * `peaks session migrate-skill-name` core service (slice 2 of the
+ * peaks-code → peaks-code rename plan).
+ *
+ * Walks `.peaks/_runtime/**` and rewrites two patterns:
+ *   1. Key-value:   `"skill": "<old>"`  →  `"skill": "<new>"`
+ *   2. Slash-trig:  `/<old>`            →  `/<new>`
+ *
+ * Files under known skip-paths (`.peaks/memory/**`,
+ * `.peaks/skills/.system/bees/<old>/manifest.json`) are recorded in
+ * `skipped` but never opened. The operation is idempotent: re-running
+ * with the same `--from` on a tree already migrated reports 0
+ * modifications.
+ *
+ * Dry-run (`apply: false`) counts what WOULD change without writing;
+ * apply (`apply: true`) validates each `.json` payload with
+ * `JSON.parse` before writing so a broken mid-edit never lands on
+ * disk. Errors are pushed into `result.errors` (never swallowed).
+ */
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+/**
+ * Skip-paths are matched against the path relative to `projectRoot`,
+ * forward-slashed (Windows-friendly). Each entry is a SUBSTRING —
+ * the brief pins two specific exclusions: the memory dir, and the
+ * .system bee manifest for the old skill (which the renamer must
+ * leave alone until the bee itself is moved in a later slice).
+ */
+const SKIP_DIRS = ['.peaks/memory', '.peaks/skills/.system/bees'];
+const TARGET_ROOT = '.peaks/_runtime';
+const KEY_VALUE_PATTERN = (from, to) => new RegExp(`"skill"\\s*:\\s*"${escapeRe(from)}"`, 'g');
+const STRING_PATTERN = (from, to) => new RegExp(`/${escapeRe(from)}`, 'g');
+/**
+ * Escape regex metachars so an aggressive `--from` value (e.g.
+ * `peaks.code`) doesn't blow up the regex compiler. The two regexes
+ * above use `from` inside both body and character-class territory,
+ * so escaping is the safe path regardless of input.
+ */
+function escapeRe(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** True iff `absPath` falls under any skip-path (substring match). */
+export function shouldSkip(projectRoot, absPath) {
+    const rel = relative(projectRoot, absPath).replace(/\\/g, '/');
+    return SKIP_DIRS.some((skip) => rel.includes(skip));
+}
+/**
+ * Recursively walk a directory and return every `.json` / `.md`
+ * path. Missing root → empty list (the CLI reports scannedFiles:0,
+ * which is the truthful "nothing to look at" signal).
+ */
+export function walkRuntimeFiles(root) {
+    const out = [];
+    if (!existsSync(root))
+        return out;
+    const visit = (dir) => {
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                visit(full);
+            }
+            else if (entry.endsWith('.json') || entry.endsWith('.md')) {
+                out.push(full);
+            }
+        }
+    };
+    visit(root);
+    return out;
+}
+export function migrateSkillName(opts) {
+    const runtimeRoot = join(opts.projectRoot, TARGET_ROOT);
+    const files = walkRuntimeFiles(runtimeRoot);
+    const result = {
+        ok: true,
+        scannedFiles: files.length,
+        modifiedFiles: 0,
+        keyValueReplacements: 0,
+        stringReplacements: 0,
+        skipped: [...SKIP_DIRS],
+        errors: [],
+    };
+    for (const file of files) {
+        if (shouldSkip(opts.projectRoot, file))
+            continue;
+        let original;
+        try {
+            original = readFileSync(file, 'utf-8');
+        }
+        catch (e) {
+            // Unreadable file: surface the error and keep going (other
+            // files may be fine). `ok` flips to false; reporting stops
+            // hiding the failure from the operator.
+            result.errors.push(`${file}: read failed: ${e.message}`);
+            result.ok = false;
+            continue;
+        }
+        // Pin the broken-JSON test: any .json runtime file that fails
+        // to parse MUST be surfaced as an error, EVEN when it does not
+        // contain the from-name (the operator still needs to know the
+        // file is unparseable so they can fix it before re-running).
+        // Per Karpathy §4 honesty, silent skip is the worst kind of
+        // fake-green.
+        if (file.endsWith('.json')) {
+            try {
+                JSON.parse(original);
+            }
+            catch (e) {
+                result.errors.push(`${file}: invalid JSON: ${e.message}`);
+                result.ok = false;
+                continue;
+            }
+        }
+        let mutated = original;
+        const kvPattern = KEY_VALUE_PATTERN(opts.from, opts.to);
+        const kvMatches = mutated.match(kvPattern);
+        if (kvMatches) {
+            mutated = mutated.replace(kvPattern, `"skill": "${opts.to}"`);
+            result.keyValueReplacements += kvMatches.length;
+        }
+        const strPattern = STRING_PATTERN(opts.from, opts.to);
+        const strMatches = mutated.match(strPattern);
+        if (strMatches) {
+            mutated = mutated.replace(strPattern, `/${opts.to}`);
+            result.stringReplacements += strMatches.length;
+        }
+        if (mutated === original)
+            continue;
+        if (opts.apply) {
+            try {
+                if (file.endsWith('.json')) {
+                    // Validate the post-edit JSON before touching the disk —
+                    // catches accidents (e.g., stray quotes in the renamed
+                    // from/to values) without leaving a corrupted runtime file
+                    // behind.
+                    JSON.parse(mutated);
+                }
+                writeFileSync(file, mutated, 'utf-8');
+                result.modifiedFiles += 1;
+            }
+            catch (e) {
+                result.errors.push(`${file}: ${e.message}`);
+                result.ok = false;
+            }
+        }
+        // Dry-run path intentionally does not bump `modifiedFiles` —
+        // pin: `expect(result.modifiedFiles).toBe(0)` in the dry-run
+        // test. The would-be count lives implicitly in the *Replacement
+        // counters, which both dry-run and apply share.
+    }
+    return result;
+}

package/dist/services/migrate-skill-name/schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+/**
+ * Result shape for `peaks session migrate-skill-name`.
+ *
+ * Counters:
+ *   - `scannedFiles` — every .json / .md under `.peaks/_runtime/**` (excluding
+ *     skip dirs below).
+ *   - `modifiedFiles` — files whose contents would change (dry-run reports
+ *     the predicted count; --apply reports the actually-written count).
+ *   - `keyValueReplacements` — `"skill": "<old>"` → `"skill": "<new>"`.
+ *   - `stringReplacements` — `/<old>` → `/<new>` slash-trigger mentions.
+ *
+ * Errors are surfaced per-file with `errors: [ "<absPath>: <message>", … ]`;
+ * the tool never silently skips a broken JSON file (Karpathy §4 honesty:
+ * silence on bad data is the worst kind of fake-green).
+ */
+export declare const MigrateResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    scannedFiles: z.ZodNumber;
+    modifiedFiles: z.ZodNumber;
+    keyValueReplacements: z.ZodNumber;
+    stringReplacements: z.ZodNumber;
+    skipped: z.ZodArray<z.ZodString, "many">;
+    errors: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    skipped: string[];
+    scannedFiles: number;
+    modifiedFiles: number;
+    keyValueReplacements: number;
+    stringReplacements: number;
+    errors: string[];
+}, {
+    ok: boolean;
+    skipped: string[];
+    scannedFiles: number;
+    modifiedFiles: number;
+    keyValueReplacements: number;
+    stringReplacements: number;
+    errors: string[];
+}>;
+export type MigrateResult = z.infer<typeof MigrateResultSchema>;

package/dist/services/migrate-skill-name/schema.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/**
+ * Result shape for `peaks session migrate-skill-name`.
+ *
+ * Counters:
+ *   - `scannedFiles` — every .json / .md under `.peaks/_runtime/**` (excluding
+ *     skip dirs below).
+ *   - `modifiedFiles` — files whose contents would change (dry-run reports
+ *     the predicted count; --apply reports the actually-written count).
+ *   - `keyValueReplacements` — `"skill": "<old>"` → `"skill": "<new>"`.
+ *   - `stringReplacements` — `/<old>` → `/<new>` slash-trigger mentions.
+ *
+ * Errors are surfaced per-file with `errors: [ "<absPath>: <message>", … ]`;
+ * the tool never silently skips a broken JSON file (Karpathy §4 honesty:
+ * silence on bad data is the worst kind of fake-green).
+ */
+export const MigrateResultSchema = z.object({
+    ok: z.boolean(),
+    scannedFiles: z.number().int().nonnegative(),
+    modifiedFiles: z.number().int().nonnegative(),
+    keyValueReplacements: z.number().int().nonnegative(),
+    stringReplacements: z.number().int().nonnegative(),
+    skipped: z.array(z.string()),
+    errors: z.array(z.string()),
+});

package/dist/services/observability/aggregation.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Read-only aggregations over observability events.
+ *
+ * Slice B of v2.11.1. Pure functions over `readonly ObservabilityEvent[]`
+ * — the CLI layer reads events via `readObservabilityEvents` (or
+ * `listSessionDirsWithMetrics` for cross-session rollups) and passes
+ * them in. Tests pass synthetic events directly.
+ *
+ * Aggregations:
+ *   - `aggregateStatus(events)`        → AC-1
+ *   - `aggregateSlices(events)`        → AC-2
+ *   - `aggregateFanout(events)`        → AC-3
+ *   - `aggregateRepairCycles(events)`  → AC-4
+ *
+ * The dispatch / mode-gate / context / post-compact categories land
+ * in Slice C (more hooks); for Slice B only `slice-transition` events
+ * are emitted from the `peaks request transition` hook. Slice B
+ * builds the read-side surface so Slice C is purely additive.
+ */
+import { type ObservabilityEvent, type ObservabilitySubagentRole } from './observability-service.js';
+export type StatusAggregate = {
+    totalEvents: number;
+    totalSlices: number;
+    successCount: number;
+    failCount: number;
+    repairCyclePeak: number;
+    fanoutCostTotal: number;
+};
+export type SliceRollup = {
+    sliceRid: string;
+    transitions: number;
+    firstTs: string | null;
+    lastTs: string | null;
+    durationMs: number | null;
+    finalState: string | null;
+    fanoutCount: number;
+    repairCycleCount: number;
+    success: boolean;
+};
+export type FanoutBreakdown = {
+    total: number;
+    perRole: Record<ObservabilitySubagentRole, number>;
+};
+export type RepairCycleReport = {
+    totalCycles: number;
+    cap: number;
+    capHit: boolean;
+    capHitCount: number;
+    perSlice: Array<{
+        sliceRid: string;
+        cycleCount: number;
+    }>;
+};
+/** RD/QA repair-loop cap (matches the peaks-code repair-loop contract). */
+export declare const REPAIR_CYCLE_CAP = 3;
+export declare function aggregateStatus(events: readonly ObservabilityEvent[]): StatusAggregate;
+export declare function aggregateSlices(events: readonly ObservabilityEvent[]): SliceRollup[];
+export declare function aggregateFanout(events: readonly ObservabilityEvent[]): FanoutBreakdown;
+export declare function aggregateRepairCycles(events: readonly ObservabilityEvent[]): RepairCycleReport;
+export type Period = 'day' | 'week' | 'month';
+export declare function periodStartIso(period: Period, now?: () => Date): string;
+export declare function filterByPeriod(events: readonly ObservabilityEvent[], period: Period, now?: () => Date): ObservabilityEvent[];
+export declare function readAllSessionEvents(projectRoot: string): ObservabilityEvent[];
+export declare function readSessionEvents(projectRoot: string, sessionId: string): ObservabilityEvent[];

package/dist/services/observability/aggregation.js

@@ -0,0 +1,217 @@
+/**
+ * Read-only aggregations over observability events.
+ *
+ * Slice B of v2.11.1. Pure functions over `readonly ObservabilityEvent[]`
+ * — the CLI layer reads events via `readObservabilityEvents` (or
+ * `listSessionDirsWithMetrics` for cross-session rollups) and passes
+ * them in. Tests pass synthetic events directly.
+ *
+ * Aggregations:
+ *   - `aggregateStatus(events)`        → AC-1
+ *   - `aggregateSlices(events)`        → AC-2
+ *   - `aggregateFanout(events)`        → AC-3
+ *   - `aggregateRepairCycles(events)`  → AC-4
+ *
+ * The dispatch / mode-gate / context / post-compact categories land
+ * in Slice C (more hooks); for Slice B only `slice-transition` events
+ * are emitted from the `peaks request transition` hook. Slice B
+ * builds the read-side surface so Slice C is purely additive.
+ */
+import { readObservabilityEvents } from './observability-service.js';
+import { listSessionDirsWithMetrics } from './jsonl-store.js';
+// Slice lifecycle terminal states. Anything not listed is in-flight
+// (draft / spec-locked / implemented / qa-handoff / running).
+const TERMINAL_HAPPY_STATES = new Set([
+    'handed-off',
+    'verdict-issued',
+    'impact-recorded',
+    'boundary-recorded'
+]);
+const TERMINAL_FAIL_STATES = new Set(['blocked']);
+/** RD/QA repair-loop cap (matches the peaks-code repair-loop contract). */
+export const REPAIR_CYCLE_CAP = 3;
+// v2.12.0 fan-out collapse: see OBSERVABILITY_SUBAGENT_ROLES for the
+// rationale on why `security-reviewer` was dropped and `peaks-security-audit`
+// + `peaks-perf-audit` were added.
+const ZERO_FANOUT = {
+    'rd': 0,
+    'qa': 0,
+    'code-reviewer': 0,
+    'karpathy-reviewer': 0,
+    'peaks-security-audit': 0,
+    'peaks-perf-audit': 0
+};
+// ----- internal helpers -----
+function isSliceTransition(event) {
+    return event.category === 'slice-transition' && typeof event.sliceRid === 'string';
+}
+function artifactRole(event) {
+    const detail = event.detail;
+    return typeof detail.artifactRole === 'string' ? detail.artifactRole : '';
+}
+function transitionTo(event) {
+    const detail = event.detail;
+    return typeof detail.to === 'string' ? detail.to : null;
+}
+function durationMsBetween(firstTs, lastTs) {
+    const a = new Date(firstTs).getTime();
+    const b = new Date(lastTs).getTime();
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        return 0;
+    }
+    return Math.max(0, b - a);
+}
+// ----- per-slice rollup (shared by status + slices queries) -----
+function rollupSlices(events) {
+    const bySlice = new Map();
+    for (const event of events) {
+        if (!isSliceTransition(event))
+            continue;
+        const rid = event.sliceRid;
+        let rollup = bySlice.get(rid);
+        if (rollup === undefined) {
+            rollup = {
+                sliceRid: rid,
+                transitions: 0,
+                firstTs: null,
+                lastTs: null,
+                durationMs: null,
+                finalState: null,
+                fanoutCount: 0,
+                repairCycleCount: 0,
+                success: false
+            };
+            bySlice.set(rid, rollup);
+        }
+        rollup.transitions += 1;
+        if (rollup.firstTs === null || event.ts < rollup.firstTs)
+            rollup.firstTs = event.ts;
+        if (rollup.lastTs === null || event.ts > rollup.lastTs)
+            rollup.lastTs = event.ts;
+        const to = transitionTo(event);
+        if (to !== null)
+            rollup.finalState = to;
+    }
+    for (const rollup of bySlice.values()) {
+        if (rollup.finalState !== null && TERMINAL_HAPPY_STATES.has(rollup.finalState)) {
+            rollup.success = true;
+        }
+        if (rollup.firstTs !== null && rollup.lastTs !== null) {
+            rollup.durationMs = durationMsBetween(rollup.firstTs, rollup.lastTs);
+        }
+    }
+    return bySlice;
+}
+function computeRepairCyclesBySlice(events) {
+    // Repair cycle = each rd → qa transition within one slice (proxy for the
+    // RD→QA→RD loop). For each slice we count qa transitions that follow an
+    // rd transition. Multiple qa transitions on the same slice are capped by
+    // REPAIR_CYCLE_CAP at the report level — the per-slice count here is the
+    // raw observation count.
+    const cyclesBySlice = new Map();
+    for (const event of events) {
+        if (!isSliceTransition(event))
+            continue;
+        const rid = event.sliceRid;
+        const role = artifactRole(event);
+        if (role === 'qa') {
+            cyclesBySlice.set(rid, (cyclesBySlice.get(rid) ?? 0) + 1);
+        }
+    }
+    return cyclesBySlice;
+}
+// ----- public aggregations -----
+export function aggregateStatus(events) {
+    const bySlice = rollupSlices(events);
+    const cyclesBySlice = computeRepairCyclesBySlice(events);
+    let repairCyclePeak = 0;
+    for (const rollup of bySlice.values()) {
+        const cycles = cyclesBySlice.get(rollup.sliceRid) ?? 0;
+        rollup.repairCycleCount = cycles;
+        if (cycles > repairCyclePeak)
+            repairCyclePeak = cycles;
+    }
+    const successCount = Array.from(bySlice.values()).filter((r) => r.success).length;
+    const failCount = Array.from(bySlice.values()).filter((r) => r.finalState !== null && TERMINAL_FAIL_STATES.has(r.finalState)).length;
+    const fanoutCostTotal = events.filter((e) => e.category === 'dispatch').length;
+    return {
+        totalEvents: events.length,
+        totalSlices: bySlice.size,
+        successCount,
+        failCount,
+        repairCyclePeak,
+        fanoutCostTotal
+    };
+}
+export function aggregateSlices(events) {
+    const bySlice = rollupSlices(events);
+    const cyclesBySlice = computeRepairCyclesBySlice(events);
+    for (const rollup of bySlice.values()) {
+        rollup.repairCycleCount = cyclesBySlice.get(rollup.sliceRid) ?? 0;
+    }
+    return Array.from(bySlice.values()).sort((a, b) => a.sliceRid.localeCompare(b.sliceRid));
+}
+export function aggregateFanout(events) {
+    const perRole = { ...ZERO_FANOUT };
+    let total = 0;
+    for (const event of events) {
+        if (event.category !== 'dispatch')
+            continue;
+        if (event.role !== undefined && event.role in perRole) {
+            perRole[event.role] += 1;
+            total += 1;
+        }
+    }
+    return { total, perRole };
+}
+export function aggregateRepairCycles(events) {
+    const cyclesBySlice = computeRepairCyclesBySlice(events);
+    const perSlice = Array.from(cyclesBySlice.entries())
+        .map(([sliceRid, cycleCount]) => ({ sliceRid, cycleCount }))
+        .sort((a, b) => a.sliceRid.localeCompare(b.sliceRid));
+    const totalCycles = perSlice.reduce((sum, row) => sum + row.cycleCount, 0);
+    const capHitCount = perSlice.filter((row) => row.cycleCount >= REPAIR_CYCLE_CAP).length;
+    return {
+        totalCycles,
+        cap: REPAIR_CYCLE_CAP,
+        capHit: capHitCount > 0,
+        capHitCount,
+        perSlice
+    };
+}
+export function periodStartIso(period, now = () => new Date()) {
+    const d = now();
+    if (period === 'day') {
+        d.setUTCHours(0, 0, 0, 0);
+        return d.toISOString();
+    }
+    if (period === 'week') {
+        d.setUTCHours(0, 0, 0, 0);
+        const day = d.getUTCDay();
+        const diff = (day + 6) % 7; // Monday = 0
+        d.setUTCDate(d.getUTCDate() - diff);
+        return d.toISOString();
+    }
+    d.setUTCDate(1);
+    d.setUTCHours(0, 0, 0, 0);
+    return d.toISOString();
+}
+export function filterByPeriod(events, period, now) {
+    const start = periodStartIso(period, now);
+    return events.filter((e) => e.ts >= start);
+}
+// ----- event-source helpers (CLI calls these; tests use pure functions) -----
+export function readAllSessionEvents(projectRoot) {
+    const sessions = listSessionDirsWithMetrics(projectRoot);
+    const all = [];
+    for (const { sessionId } of sessions) {
+        for (const event of readObservabilityEvents(projectRoot, sessionId)) {
+            all.push(event);
+        }
+    }
+    all.sort((a, b) => a.ts.localeCompare(b.ts));
+    return all;
+}
+export function readSessionEvents(projectRoot, sessionId) {
+    return readObservabilityEvents(projectRoot, sessionId);
+}

package/dist/services/perf/perf-baseline-service.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Performance baseline scaffolding for the RD stage.
+ *
+ * peaks-code's RD stage runs before the QA stage. The user-facing pain is
+ * that performance tests (lighthouse / k6 / project-local benches / etc.)
+ * have historically only been run at QA Gate A4 — too late in the loop,
+ * because a slow regression discovered at QA triggers a return-to-rd
+ * cycle, the RD ships another "fix", QA re-runs, and the same cycle
+ * repeats up to 3 times before the slice ships.
+ *
+ * `peaks perf baseline` is the user-visible artifact of a deliberate
+ * compromise: keep the heavy performance measurement as something the
+ * RD runs themselves (lighthouse is project-shape dependent and we
+ * don't want to bake a lighthouse dependency into the CLI), but capture
+ * the result in a stable, scaffolded file under
+ * `.peaks/_runtime/<sid>/rd/perf-baseline.md` so QA Gate A4 has a known-good
+ * reference to diff against. The CLI itself only writes the scaffold
+ * and records the path; the actual measurement is a project-local
+ * concern that lives in the README, not in peaks-loop.
+ *
+ * The four-grounds check (per the skill-primary-CLI-auxiliary dev
+ * preference):
+ *   1. hook/script/CI invokability  — yes, a hook can call this CLI
+ *                                     to scaffold the file on session
+ *                                     init, similar to session bootstrap.
+ *   2. JSON envelope that gates a downstream decision — yes,
+ *                                     peaks-rd reads the result and
+ *                                     attaches it to the handoff.
+ *   3. Destructive --apply side effect — yes, default dry-run.
+ *   4. Machine-enforced gate that prose cannot enforce — no, the
+ *                                     measurement still lives in
+ *                                     the LLM / project tools. We do
+ *                                     NOT add a lint gate here.
+ *
+ * Net: CLI is justified. The destructive --apply default is dry-run,
+ * matching the rest of peaks-loop's scaffolding pattern.
+ */
+export type PerfBaselineInitOptions = {
+    projectRoot: string;
+    apply?: boolean;
+    reason?: string;
+};
+export type PerfBaselinePlan = {
+    apply: boolean;
+    projectRoot: string;
+    sessionId: string | null;
+    perfBaselinePath: string | null;
+    plannedWrites: Array<{
+        path: string;
+        kind: 'directory' | 'file';
+        bytes: number;
+        content: string;
+    }>;
+    alreadyInitialized: boolean;
+    existingFiles: string[];
+};
+export type PerfBaselineResult = PerfBaselinePlan & {
+    writtenFiles: string[];
+    createdDirectories: string[];
+    reason?: string;
+};
+export declare function executePerfBaselineInit(options: PerfBaselineInitOptions): Promise<PerfBaselineResult>;
+/**
+ * Re-exported so the CLI command can fall back to a project-root
+ * resolution when the caller did not pass --project. The CLI does
+ * the same findProjectRoot walk that `workspace init` does; this
+ * helper exists for the command layer to import without reaching
+ * into config-safety directly.
+ */
+export declare function resolveProjectRootFromCwd(cwd: string): string;