peaks-loop 4.0.0-beta.8 → 4.0.0-beta.9

package/dist/services/slice/multi-pass-orchestrator.js

@@ -0,0 +1,225 @@
+/**
+ * MultiPassOrchestrator — Phase 2 of slice-topology-multipass (W2 T9).
+ *
+ * Top-level orchestrator that runs the existing 6-stage algorithm
+ * (`decomposeSlices`) at service-level and/or file-level granularity, then
+ * stitches the passes together with `merge` to produce a v2
+ * `DecompositionResultV2` with cross-pass edges.
+ *
+ * Granularity semantics:
+ *   - 'service': Pass 1 only. Each workUnit becomes a SliceV2 with
+ *                granularity='service' and parentSliceId=null.
+ *   - 'file':    Pass 2 only. `decomposeSlices` is called once on the full
+ *                scope (no parent subdivision). Each workUnit becomes a
+ *                SliceV2 with granularity='file' and parentSliceId=null.
+ *   - 'both':    Pass 1 + N Pass 2 (one per parent). Pass 2 runs for every
+ *                Pass 1 slice without decider filtering.
+ *   - 'auto':    Same as 'both' but Pass 2 only runs for parents where
+ *                `shouldSubdivide(wu).subdivide !== false` (both `true` and
+ *                `'tie-break'` qualify).
+ *
+ * Granularity-mapping approach (see pre-flight note in the task spec):
+ *   Approach 1 — pass-through with post-hoc filter. The 6-stage algorithm
+ *   (`decomposeSlices`) does NOT accept a `granularity` or `scopeFilter`
+ *   option, and the pre-flight note recommends NOT extending `DecomposeOptions`
+ *   (surgical change rule). We therefore:
+ *     1. Pass the full `opts` (including the orchestrator-only `granularity`
+ *        and `llmRunner` fields) through to `decomposeSlices`; the algorithm
+ *        ignores the extra fields.
+ *     2. Filter Pass 2 `result.workUnits` post-hoc so each Pass 2 result
+ *        only contains files inside the parent slice's file scope.
+ *
+ * Cross-pass edges are produced by `merge` whenever there are ≥2 passes.
+ * The merger handles both static detection (type-shares, fixture-shares,
+ * import-re-export — runs UNCONDITIONALLY) and the LLM fallback path (only
+ * when `opts.llmRunner` is provided). Without an llmRunner the orchestrator
+ * still gets statically-detected cross-pass edges; only `llmArbitrations`
+ * stays empty.
+ *
+ * @see ./slice-decompose-service.ts  — the 6-stage algorithm (reused as-is)
+ * @see ./granularity-decider.ts      — subdivide decision
+ * @see ./cross-pass-edge-merger.ts   — cross-pass edge detection
+ * @see ./llm-arbitrator.ts           — LLM fallback for cross-pass edges
+ * @see ./slice-topology-types.ts     — DecompositionResultV2, PassResult, etc.
+ */
+import { decomposeSlices } from './slice-decompose-service.js';
+import { resetArbitratorBudget } from './llm-arbitrator.js';
+import { shouldSubdivide } from './granularity-decider.js';
+import { merge } from './cross-pass-edge-merger.js';
+/**
+ * Run the multi-pass decomposition algorithm and return a v2 result.
+ *
+ * 1. Reset the LLM arbitrator budget for this invocation.
+ * 2. Run Pass 1 (service-level) if granularity includes 'service'.
+ * 3. Run Pass 2 (file-level) — for every qualifying parent in 'both'/'auto',
+ *    or once on the full scope in 'file'-only mode.
+ * 4. Compute cross-pass edges via `merge` whenever there are ≥2 passes
+ *    (static detection runs unconditionally; LLM fallback only when an
+ *    llmRunner is supplied).
+ * 5. Return a `DecompositionResultV2` with `partial: false`.
+ */
+export async function decompose(rid, prdMarkdown, projectRoot, opts = {}) {
+    resetArbitratorBudget();
+    const granularity = opts.granularity ?? 'both';
+    const wantService = granularity === 'service' || granularity === 'both' || granularity === 'auto';
+    const wantFile = granularity === 'file' || granularity === 'both' || granularity === 'auto';
+    const passes = [];
+    let codegraph = zeroCodegraph();
+    let understandAnything = zeroUnderstand();
+    let pass1WorkUnits = [];
+    if (wantService) {
+        const result1 = await decomposeSlices(rid, prdMarkdown, projectRoot, opts);
+        pass1WorkUnits = result1.workUnits;
+        passes.push({
+            passNumber: 1,
+            granularity: 'service',
+            slices: result1.workUnits.map((wu) => workUnitToSliceV2(wu, 'service')),
+            internalEdges: v1EdgesToV2(result1.dependencyDAG.edges)
+        });
+        codegraph = result1.codegraph;
+        understandAnything = result1.understandAnything;
+    }
+    if (wantFile) {
+        if (pass1WorkUnits.length > 0) {
+            // Per-parent subdivision. In 'auto' mode, only parents where
+            // shouldSubdivide is not explicitly false qualify.
+            const qualifyingParents = granularity === 'auto'
+                ? pass1WorkUnits.filter((wu) => shouldSubdivide(wu).subdivide !== false)
+                : pass1WorkUnits;
+            const pass2Results = await Promise.all(qualifyingParents.map(async (parent) => {
+                const result = await decomposeSlices(rid, prdMarkdown, projectRoot, opts);
+                const filtered = filterWorkUnitsByScope(result.workUnits, parent.files);
+                const pass2Slices = filtered.map((wu, i) => workUnitToSliceV2(wu, 'file', {
+                    id: `${parent.id}.${i + 1}`,
+                    parentSliceId: parent.id
+                }));
+                const pass2 = {
+                    passNumber: 2,
+                    granularity: 'file',
+                    slices: pass2Slices,
+                    internalEdges: v1EdgesToV2(result.dependencyDAG.edges)
+                };
+                return pass2;
+            }));
+            passes.push(...pass2Results);
+        }
+        else if (!wantService) {
+            // file-only mode: call decomposeSlices once on the full scope and
+            // treat the result as Pass 2 (no parent subdivision).
+            const result = await decomposeSlices(rid, prdMarkdown, projectRoot, opts);
+            const slices = result.workUnits.map((wu) => workUnitToSliceV2(wu, 'file'));
+            passes.push({
+                passNumber: 2,
+                granularity: 'file',
+                slices,
+                internalEdges: v1EdgesToV2(result.dependencyDAG.edges)
+            });
+            codegraph = result.codegraph;
+            understandAnything = result.understandAnything;
+        }
+    }
+    let crossPassEdges = [];
+    let llmArbitrations = [];
+    if (passes.length > 1) {
+        const mergeResult = await merge(passes, {
+            projectRoot,
+            ...(opts.llmRunner ? { llmRunner: opts.llmRunner } : {})
+        });
+        crossPassEdges = mergeResult.edges;
+        llmArbitrations = mergeResult.llmCalls.map(toLlmArbitration);
+    }
+    return {
+        schemaVersion: 'v2',
+        rid,
+        generatedAt: new Date().toISOString(),
+        passes,
+        crossPassEdges,
+        llmArbitrations,
+        codegraph,
+        understandAnything,
+        partial: false
+    };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Convert a v1 `WorkUnit` into a v2 `SliceV2`. The `granularity` is supplied
+ * by the caller (per-pass) so it matches the pass's `PassResult.granularity`.
+ * `id` and `parentSliceId` default to the workUnit's own id and null
+ * (i.e. a Pass 1 slice). For Pass 2 children, the orchestrator supplies
+ * `${parent.id}.${i + 1}` as the new id and the parent's id as parent.
+ */
+function workUnitToSliceV2(wu, granularity, overrides = {}) {
+    return {
+        id: overrides.id ?? wu.id,
+        label: wu.label,
+        granularity,
+        files: wu.files,
+        loc: wu.loc,
+        parentSliceId: overrides.parentSliceId ?? null,
+        semanticAnchor: `file:${wu.filePath}`
+    };
+}
+/**
+ * Keep only workUnits that touch at least one file in the parent's scope.
+ * Used to scope Pass 2 results to their parent slice's file set, since the
+ * 6-stage algorithm does not accept a `scopeFilter` option.
+ */
+function filterWorkUnitsByScope(wus, scope) {
+    const scopeSet = new Set(scope);
+    return wus.filter((wu) => wu.files.some((f) => scopeSet.has(f)));
+}
+/**
+ * Map a v1 `DependencyEdge[]` (from the 6-stage algorithm's `dependencyDAG`)
+ * to v2 `InternalEdge[]`. The two kinds unions are identical
+ * (`'imports' | 'calls' | 'depends_on' | 'contains_flow' | 'flow_step'`), so
+ * `kind` is a direct pass-through. `confidence` collapses `isSemantic`
+ * (`true` → `'semantic'`, `false` → `'structural'`) to match the v2
+ * `EdgeConfidence` union.
+ */
+function v1EdgesToV2(v1Edges) {
+    return v1Edges.map((e) => ({
+        from: e.from,
+        to: e.to,
+        kind: e.kind,
+        weight: e.weight,
+        evidence: e.evidence,
+        confidence: e.isSemantic ? 'semantic' : 'structural'
+    }));
+}
+/**
+ * Pure shape pass-through from `MergeResult.llmCalls` to v2 `LlmArbitration`.
+ * The merger now populates `promptHash`/`input`/`output`/`confidence` itself;
+ * we just coalesce a possible `null` `tokens` to a zeroed pair to satisfy
+ * the non-nullable `LlmArbitration.tokens` contract.
+ */
+function toLlmArbitration(c) {
+    return {
+        callId: c.callId,
+        promptHash: c.promptHash,
+        input: c.input,
+        output: c.output,
+        confidence: c.confidence,
+        tokens: c.tokens ?? { input: 0, output: 0 }
+    };
+}
+function zeroCodegraph() {
+    return {
+        nodes: 0,
+        edges: 0,
+        dbMB: 0,
+        freshness: 'unindexed',
+        affectedCrossFile: false,
+        note: 'no decomposition run'
+    };
+}
+function zeroUnderstand() {
+    return {
+        kgNodes: 0,
+        kgEdges: 0,
+        available: false,
+        fallback: 'structural-only',
+        note: 'no decomposition run'
+    };
+}

package/dist/services/slice/schema-router.d.ts

@@ -0,0 +1,44 @@
+/**
+ * SchemaRouter — dual-read JSON router for `DecompositionResult` (v1/v2).
+ *
+ * v1 files (legacy, pre-Wave-1 slice decompose output) do NOT carry a
+ * `schemaVersion` field; v2 files always carry `schemaVersion: 'v2'`.
+ * The router reads the file, dispatches on the discriminator, and returns
+ * the parsed object typed as `DecompositionResult` or `DecompositionResultV2`.
+ *
+ * Why a router (and not a parse-on-write migration):
+ *  - v1 files may exist in user workspaces long after v2 ships; rewriting
+ *    them on read would force a write-back side-effect that callers don't
+ *    need (and breaks `peaks slice pick` which only needs the v1 fields).
+ *  - The discriminated return type lets callers narrow once at the boundary
+ *    (`schemaVersion === 'v2' ? handleV2(r) : handleV1(r)`) and stay typed
+ *    downstream.
+ *
+ * Unknown versions throw `UnknownSchemaVersionError` so callers can
+ * surface a clear migration hint instead of silently treating v3 as v1.
+ */
+import type { DecompositionResult } from './slice-decompose-types.js';
+import type { DecompositionResultV2 } from './slice-topology-types.js';
+/**
+ * Thrown by `readResult` when the JSON carries a `schemaVersion` value
+ * that is neither absent (v1) nor `'v2'`. The `code` is the stable
+ * machine-readable discriminator; downstream CLI surfaces should map it
+ * to the appropriate exit code.
+ */
+export declare class UnknownSchemaVersionError extends Error {
+    readonly code: "UNKNOWN_SCHEMA_VERSION";
+    constructor(message: string);
+}
+/**
+ * Read a decomposition-result JSON file and return it typed as either
+ * `DecompositionResult` (v1, no `schemaVersion` field) or
+ * `DecompositionResultV2` (`schemaVersion: 'v2'`).
+ *
+ * Throws `UnknownSchemaVersionError` for any other `schemaVersion` value.
+ */
+export declare function readResult(filePath: string): DecompositionResult | DecompositionResultV2;
+/**
+ * Serialize a v1 or v2 decomposition result to disk as pretty-printed JSON.
+ * The `schemaVersion` field (or its absence) is preserved as-is.
+ */
+export declare function writeResult(filePath: string, result: DecompositionResult | DecompositionResultV2): void;

package/dist/services/slice/schema-router.js

@@ -0,0 +1,61 @@
+/**
+ * SchemaRouter — dual-read JSON router for `DecompositionResult` (v1/v2).
+ *
+ * v1 files (legacy, pre-Wave-1 slice decompose output) do NOT carry a
+ * `schemaVersion` field; v2 files always carry `schemaVersion: 'v2'`.
+ * The router reads the file, dispatches on the discriminator, and returns
+ * the parsed object typed as `DecompositionResult` or `DecompositionResultV2`.
+ *
+ * Why a router (and not a parse-on-write migration):
+ *  - v1 files may exist in user workspaces long after v2 ships; rewriting
+ *    them on read would force a write-back side-effect that callers don't
+ *    need (and breaks `peaks slice pick` which only needs the v1 fields).
+ *  - The discriminated return type lets callers narrow once at the boundary
+ *    (`schemaVersion === 'v2' ? handleV2(r) : handleV1(r)`) and stay typed
+ *    downstream.
+ *
+ * Unknown versions throw `UnknownSchemaVersionError` so callers can
+ * surface a clear migration hint instead of silently treating v3 as v1.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+/**
+ * Thrown by `readResult` when the JSON carries a `schemaVersion` value
+ * that is neither absent (v1) nor `'v2'`. The `code` is the stable
+ * machine-readable discriminator; downstream CLI surfaces should map it
+ * to the appropriate exit code.
+ */
+export class UnknownSchemaVersionError extends Error {
+    code = 'UNKNOWN_SCHEMA_VERSION';
+    constructor(message) {
+        super(message);
+        this.name = 'UnknownSchemaVersionError';
+    }
+}
+/**
+ * Read a decomposition-result JSON file and return it typed as either
+ * `DecompositionResult` (v1, no `schemaVersion` field) or
+ * `DecompositionResultV2` (`schemaVersion: 'v2'`).
+ *
+ * Throws `UnknownSchemaVersionError` for any other `schemaVersion` value.
+ */
+export function readResult(filePath) {
+    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new UnknownSchemaVersionError(`Unknown schemaVersion: ${String(parsed)}. Supported: v1 (no field), v2.`);
+    }
+    const schemaVersion = parsed.schemaVersion;
+    if (schemaVersion === 'v2') {
+        return parsed;
+    }
+    if (schemaVersion === undefined) {
+        return parsed;
+    }
+    throw new UnknownSchemaVersionError(`Unknown schemaVersion: ${String(schemaVersion)}. Supported: v1 (no field), v2.`);
+}
+/**
+ * Serialize a v1 or v2 decomposition result to disk as pretty-printed JSON.
+ * The `schemaVersion` field (or its absence) is preserved as-is.
+ */
+export function writeResult(filePath, result) {
+    writeFileSync(filePath, JSON.stringify(result, null, 2), 'utf8');
+}

package/dist/services/slice/slice-archive-service.d.ts

@@ -0,0 +1,20 @@
+export declare const ARCHIVE_RETENTION_MS: number;
+export interface ArchiveResult {
+    readonly archivedCompleted: number;
+    readonly archivedInFlight: number;
+    readonly gcDeleted: number;
+}
+/** Build the canonical archive dir for a given session + slice id. */
+export declare function archiveDir(projectRoot: string, sessionId: string, sliceId: string): string;
+/** Build the in-flight subdir (records not yet disposed). */
+export declare function inFlightArchiveDir(projectRoot: string, sessionId: string, sliceId: string): string;
+/**
+ * Archive the current `.peaks/_sub_agents/<sid>/` tree under
+ * `<archiveDir>` (per the sliceId), separating completed vs in-flight.
+ * Then run the 30-day GC over the archive dir.
+ */
+export declare function archiveSubAgentRecords(projectRoot: string, options: {
+    sessionId: string;
+    sliceId: string;
+    now?: () => Date;
+}): ArchiveResult;

package/dist/services/slice/slice-archive-service.js

@@ -0,0 +1,111 @@
+/**
+ * Slice #009 / G5 RL-8 — sub-agent dispatch record archival + 30-day GC.
+ *
+ * Called by the `peaks session finish` / `peaks session abandon` /
+ * new-rid-startup hooks. Walks the per-session `.peaks/_sub_agents/<sid>/`
+ * tree and moves completed + disposed records to
+ * `.peaks/_runtime/<sid>/_archive/_sub_agents/<sliceId>/`.
+ *
+ * GC policy:
+ *   - Records with `disposed: true` AND `outcome ∈ {success, failed,
+ *     timeout, cancelled}` (not "no-execution") → archive + 30-day GC.
+ *   - Records with `disposed: false` (any outcome) → archive but NOT
+ *     GC'd. Next session will see them as still-pending in
+ *     `_archive/.../in-flight/` and can resume reducer work.
+ *
+ * Lazy GC: `archiveSubAgentRecords` also scans the archive dir and
+ * deletes entries older than 30 days. No cron, no background daemon.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { isDispatchStatus, isOutcome } from '../dispatch/dispatch-record-writer.js';
+export const ARCHIVE_RETENTION_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
+/** Build the canonical archive dir for a given session + slice id. */
+export function archiveDir(projectRoot, sessionId, sliceId) {
+    return join(projectRoot, '.peaks', '_runtime', sessionId, '_archive', '_sub_agents', sliceId);
+}
+/** Build the in-flight subdir (records not yet disposed). */
+export function inFlightArchiveDir(projectRoot, sessionId, sliceId) {
+    return join(archiveDir(projectRoot, sessionId, sliceId), 'in-flight');
+}
+/**
+ * Archive the current `.peaks/_sub_agents/<sid>/` tree under
+ * `<archiveDir>` (per the sliceId), separating completed vs in-flight.
+ * Then run the 30-day GC over the archive dir.
+ */
+export function archiveSubAgentRecords(projectRoot, options) {
+    const now = options.now ?? (() => new Date());
+    const sourceDir = join(projectRoot, '.peaks', '_sub_agents', options.sessionId);
+    const completedDir = archiveDir(projectRoot, options.sessionId, options.sliceId);
+    const inFlightDir = inFlightArchiveDir(projectRoot, options.sessionId, options.sliceId);
+    mkdirSync(completedDir, { recursive: true });
+    mkdirSync(inFlightDir, { recursive: true });
+    let archivedCompleted = 0;
+    let archivedInFlight = 0;
+    if (existsSync(sourceDir)) {
+        for (const entry of readdirSync(sourceDir)) {
+            if (!entry.startsWith('dispatch-') || !entry.endsWith('.json'))
+                continue;
+            const src = join(sourceDir, entry);
+            const record = readRecordOrNull(src);
+            if (record === null)
+                continue;
+            if (record.disposed === true && isCompletedOutcome(record.outcome)) {
+                renameSync(src, join(completedDir, entry));
+                archivedCompleted += 1;
+            }
+            else {
+                renameSync(src, join(inFlightDir, entry));
+                archivedInFlight += 1;
+            }
+        }
+    }
+    // 30-day GC: walk the archive root (any sliceId), delete entries
+    // whose file mtime is older than the retention.
+    const gcDeleted = runGarbageCollection(completedDir, now().getTime());
+    return { archivedCompleted, archivedInFlight, gcDeleted };
+}
+function isCompletedOutcome(outcome) {
+    return outcome === 'success' || outcome === 'failed' || outcome === 'timeout' || outcome === 'cancelled';
+}
+function readRecordOrNull(path) {
+    try {
+        const raw = readFileSync(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null)
+            return null;
+        const obj = parsed;
+        if (!isOutcome(obj.outcome) || !isDispatchStatus(obj.status))
+            return null;
+        if (typeof obj.disposed !== 'boolean')
+            return null;
+        return obj;
+    }
+    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+        return null;
+    }
+}
+function runGarbageCollection(dir, nowMs) {
+    if (!existsSync(dir))
+        return 0;
+    let deleted = 0;
+    for (const entry of readdirSync(dir)) {
+        const full = join(dir, entry);
+        try {
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                deleted += runGarbageCollection(full, nowMs);
+                continue;
+            }
+            const ageMs = nowMs - stat.mtimeMs;
+            if (ageMs > ARCHIVE_RETENTION_MS) {
+                unlinkSync(full);
+                deleted += 1;
+            }
+        }
+        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+            /* skip unreadable; do not crash the archive op */
+        }
+    }
+    return deleted;
+}

package/dist/services/slice/slice-benchmark-service.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Slice benchmark wrapper (slice 2026-06-14-fzf-headroom-rollout).
+ *
+ * Wraps `decomposeSlices` with a thin observability layer that records
+ * total wall time, codegraph call count, confidence distribution, and
+ * input/output byte counts. The result is attached to the
+ * DecompositionResult envelope only when `peaks slice decompose --benchmark`
+ * is passed.
+ *
+ * The benchmark does NOT mutate the algorithm's output; it is pure
+ * measurement. Codegraph call counting is achieved by wrapping the
+ * caller-provided `codegraphRunner`.
+ */
+import type { DecomposeOptions, DecompositionResult, SliceBenchmark } from './slice-decompose-types.js';
+export interface BenchmarkEnvelope {
+    benchmark: SliceBenchmark;
+    result: DecompositionResult;
+}
+export declare function decomposeSlicesWithBenchmark(rid: string, prdMarkdown: string, projectRoot: string, options?: DecomposeOptions): Promise<BenchmarkEnvelope>;

package/dist/services/slice/slice-benchmark-service.js

@@ -0,0 +1,60 @@
+/**
+ * Slice benchmark wrapper (slice 2026-06-14-fzf-headroom-rollout).
+ *
+ * Wraps `decomposeSlices` with a thin observability layer that records
+ * total wall time, codegraph call count, confidence distribution, and
+ * input/output byte counts. The result is attached to the
+ * DecompositionResult envelope only when `peaks slice decompose --benchmark`
+ * is passed.
+ *
+ * The benchmark does NOT mutate the algorithm's output; it is pure
+ * measurement. Codegraph call counting is achieved by wrapping the
+ * caller-provided `codegraphRunner`.
+ */
+import { Buffer } from 'node:buffer';
+import { decomposeSlices, defaultCodegraphRunner } from './slice-decompose-service.js';
+export async function decomposeSlicesWithBenchmark(rid, prdMarkdown, projectRoot, options = {}) {
+    const codegraphQueries = { count: 0 };
+    const baseRunner = options.codegraphRunner ?? defaultCodegraphRunner();
+    const wrappedRunner = {
+        query: async (text, root) => {
+            codegraphQueries.count += 1;
+            return baseRunner.query(text, root);
+        },
+        affected: async (files, root) => {
+            codegraphQueries.count += 1;
+            return baseRunner.affected(files, root);
+        },
+        status: async (root) => {
+            codegraphQueries.count += 1;
+            return baseRunner.status(root);
+        }
+    };
+    const t0 = Date.now();
+    const result = await decomposeSlices(rid, prdMarkdown, projectRoot, {
+        ...options,
+        codegraphRunner: wrappedRunner
+    });
+    const totalMs = Date.now() - t0;
+    const p50ConfidenceDistribution = { low: 0, mid: 0, high: 0 };
+    for (const batch of result.parallelBatches) {
+        for (const slice of batch.slices) {
+            if (slice.estimate.confidence === 'low')
+                p50ConfidenceDistribution.low += 1;
+            else if (slice.estimate.confidence === 'medium')
+                p50ConfidenceDistribution.mid += 1;
+            else
+                p50ConfidenceDistribution.high += 1;
+        }
+    }
+    const benchmark = {
+        rid,
+        totalMs,
+        codegraphQueries: codegraphQueries.count,
+        p50ConfidenceDistribution,
+        inputApproxBytes: { prd: Buffer.byteLength(prdMarkdown, 'utf8') },
+        outputJsonBytes: Buffer.byteLength(JSON.stringify(result), 'utf8'),
+        capturedAt: new Date().toISOString()
+    };
+    return { result, benchmark };
+}

package/dist/services/slice/slice-check-service.d.ts

@@ -0,0 +1,2 @@
+import type { SliceCheckOptions, SliceCheckResult } from './slice-check-types.js';
+export declare function sliceCheck(options: SliceCheckOptions): Promise<SliceCheckResult>;