peaks-loop 4.0.32 → 4.0.34

package/skills/peaks-code/references/swarm-dispatch-contract.md

@@ -48,7 +48,7 @@ Return a compact JSON envelope — do not write prose.
 - session-id: <sid>          (from .peaks/.active-skill.json or .peaks/.session.json)
 - request-id: <rid>          (PRD id)
 - type: <type>               (feature | bugfix | refactor | config | docs | chore)
-- mode: <mode>               (full-auto | swarm | assisted | strict)
+- mode: <mode>               (full-auto | assisted | strict | 24h)
 - project-scan-path: <path>  (read this for component library / CSS / build tool)
 - existing-system-path: <path>  (legacy projects only)
 - frontendOnly: <bool>       (from project-scan)
@@ -209,7 +209,7 @@ Sub-agent presence in this list = Code launched a Task for it. Absence = the rol
 | Mode | How the swarm plan is decided | What Code does |
 |---|---|---|
 | `full-auto` | Compute plan from signals above, no question to user | Auto-launch all sub-agents in the plan in parallel |
-| `swarm` | Same as `full-auto` | Same as `full-auto` (this profile name is historical — behavior is identical) |
+| `24h` | Same as `full-auto` | Same as `full-auto` (long-run profile; the fan-out shape is identical, only the auto-compact cadence differs) |
 | `assisted` | `AskUserQuestion` with three options: (a) Full — UI + RD(planning) + QA(test-cases); (b) Backend-only — RD(planning) + QA(test-cases); (c) Sequential — run RD first, then QA, skip UI | Use the user's choice as the plan |
 | `strict` | Same as `assisted` (the question is informational; strict still enforces confirmation gates later) | Same as `assisted` |
 

package/skills/peaks-code/references/workflow-gates-and-types.md

@@ -182,5 +182,5 @@ ls <repo>/.claude/rules/common/coding-style.md \
 # standards init/update with --apply and re-verify.
 # Skipping Peaks-Loop Gate G (e.g. because the user did not explicitly authorize writes) is
 # only acceptable in `assisted`/`strict` modes where the user actively declined; in
-# `full-auto`/`swarm` the absence of these files is a workflow violation.
+# `full-auto`/`24h` the absence of these files is a workflow violation.
 ```

package/skills/peaks-doctor/SKILL.md

@@ -50,7 +50,7 @@ If a doctor finding requires a code change, the workflow hands off to `peaks-rd`
 ## Boundaries
 
 - The doctor is read-only. It does NOT modify code, fix bugs, or clean up sessions.
-- The doctor does NOT install UA or any third-party tool. The opt-in UX is surfaced via `peaks understand opt-in`; the doctor just reports state.
+- The doctor does NOT install any third-party tool. It just reports state.
 - The doctor does NOT generate change records automatically; it surfaces findings + the LLM calls `peaks openspec from-doctor` to generate them.
 
 ## References

package/skills/peaks-slice-decompose/SKILL.md

@@ -84,7 +84,6 @@ The envelope is a `DecompositionResultV2` (see `references/v2-schema.md`):
 | `crossPassEdges` | Edges spanning passes (see `references/cross-pass-edge-interpretation.md`). |
 | `llmArbitrations` | Trace of every LLM call made during decomposition (capped at 2 per invocation). |
 | `codegraph` | `CodegraphEnvelope` — nodes/edges/dbMB/freshness/affectedCrossFile/note. |
-| `understandAnything` | `UnderstandAnythingEnvelope` — kgNodes/kgEdges/available/fallback/note. |
 | `partial` | `true` iff any pass failed to complete. |
 
 The file is pretty-printed (`JSON.stringify(result, null, 2)`). Size scales with `passes.length * slices.length` plus the arbitration trace; typical runs are 5–80 KB.

package/skills/peaks-slice-decompose/references/v2-schema.md

@@ -21,7 +21,6 @@ The CLI serialises via `SchemaRouter.writeResult()` → `JSON.stringify(result,
 | `crossPassEdges` | `readonly CrossPassEdge[]` | `cross-pass-edge-merger.ts` (via `merge`) | Empty when `opts.llmRunner` is not provided. |
 | `llmArbitrations` | `readonly LlmArbitration[]` | `merge.llmCalls` mapped via `llmCallsToArbitrations` | Empty when no LLM call was made. Cap: ≤ 2 calls per invocation. |
 | `codegraph` | `CodegraphEnvelope` | from Pass 1 / Pass 2 result | Reused from v1 (see `slice-decompose-types.ts`). Falls back to `zeroCodegraph()` if neither pass ran. |
-| `understandAnything` | `UnderstandAnythingEnvelope` | from Pass 1 / Pass 2 result | Reused from v1. Falls back to `zeroUnderstand()` if neither pass ran. |
 | `partial` | `boolean` | orchestrator | `true` iff any pass failed to complete. Currently always `false` from `MultiPassOrchestrator`; reserved for future partial-failure paths. |
 
 ## `CodegraphEnvelope` (re-exported from v1)
@@ -35,16 +34,6 @@ The CLI serialises via `SchemaRouter.writeResult()` → `JSON.stringify(result,
 | `affectedCrossFile` | `boolean` | `true` iff `codegraph.affected` reported > 0 cross-file dependents. |
 | `note` | `string` | Free-form operator note; `'no decomposition run'` when both passes were skipped. |
 
-## `UnderstandAnythingEnvelope` (re-exported from v1)
-
-| Field | Type | Notes |
-|---|---|---|
-| `kgNodes` | `number` | Knowledge-graph node count. |
-| `kgEdges` | `number` | Knowledge-graph edge count. |
-| `available` | `boolean` | `false` when the `.understand-anything/knowledge-graph.json` file is missing. |
-| `fallback` | `'semantic' \| 'structural-only'` | `'structural-only'` when `available` is `false`. |
-| `note` | `string` | Free-form note. |
-
 ## `PassResult`
 
 | Field | Type | Notes |
@@ -64,7 +53,7 @@ The CLI serialises via `SchemaRouter.writeResult()` → `JSON.stringify(result,
 | `files` | `readonly string[]` | Project-relative paths. |
 | `loc` | `number` | Total LoC across all `files`. |
 | `parentSliceId` | `string \| null` | `null` for Pass 1. For Pass 2, the id of the parent Pass 1 slice. |
-| `semanticAnchor` | `string` | `"domain:<name>"` when understand-anything indexed, else `"file:<path>"`. Currently always `"file:<wu.filePath>"` from the orchestrator's `workUnitToSliceV2`. |
+| `semanticAnchor` | `string` | Always `"file:<wu.filePath>"` from the orchestrator's `workUnitToSliceV2` (codegraph / structural evidence). |
 
 ### `InternalEdge` (reserved)
 

package/dist/cli/commands/understand-commands.d.ts

@@ -1,3 +0,0 @@
-import { Command } from 'commander';
-import { type ProgramIO } from '../cli-helpers.js';
-export declare function registerUnderstandCommands(program: Command, io: ProgramIO): void;

package/dist/cli/commands/understand-commands.js

@@ -1,148 +0,0 @@
-import { InvalidArgumentError } from 'commander';
-import { scanUnderstandAnything, summarizeKnowledgeGraph } from '../../services/understand/understand-scan-service.js';
-import { buildUnderstandContext } from '../../services/understand/understand-hybrid-service.js';
-import { fail, ok } from 'peaks-loop-shared/result';
-import { addJsonOption, getErrorMessage, printResult } from '../cli-helpers.js';
-function parsePositiveInteger(value) {
-    if (!/^\d+$/.test(value)) {
-        throw new InvalidArgumentError('must be a positive integer');
-    }
-    const parsed = Number(value);
-    if (!Number.isSafeInteger(parsed) || parsed < 1) {
-        throw new InvalidArgumentError('must be a positive integer');
-    }
-    return parsed;
-}
-const INSTALL_HINT = 'Install Understand Anything in Claude Code: `/plugin marketplace add Lum1104/Understand-Anything` then `/plugin install understand-anything`, then run `/understand` in the target project to generate .understand-anything/knowledge-graph.json.';
-export function registerUnderstandCommands(program, io) {
-    const understand = program.command('understand').description('Inspect Understand Anything artifacts inside a project (read-only)');
-    addJsonOption(understand
-        .command('status')
-        .description('Report whether Understand Anything has produced a knowledge graph in the target project')
-        .requiredOption('--project <path>', 'target project root')
-        .option('--artifact-dir <path>', 'override the default .understand-anything directory')).action(async (options) => {
-        try {
-            const scanOptions = { projectRoot: options.project };
-            if (options.artifactDir !== undefined) {
-                scanOptions.artifactDir = options.artifactDir;
-            }
-            const report = await scanUnderstandAnything(scanOptions);
-            const nextActions = [];
-            if (!report.exists) {
-                nextActions.push(INSTALL_HINT);
-            }
-            else if (!report.graph.exists) {
-                nextActions.push('Run `/understand` inside Claude Code on this project to generate .understand-anything/knowledge-graph.json.');
-            }
-            else if (report.graph.parseError !== undefined) {
-                nextActions.push('Re-run `/understand` to regenerate the knowledge graph; the current file is not valid JSON.');
-            }
-            printResult(io, ok('understand.status', report, [], nextActions), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('understand.status', 'UNDERSTAND_STATUS_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Check the project path and .understand-anything directory before retrying']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    addJsonOption(understand
-        .command('show')
-        .description('Summarize the Understand Anything knowledge graph (counts, layers, tours, sample nodes) for RD/TXT consumption')
-        .requiredOption('--project <path>', 'target project root')
-        .option('--artifact-dir <path>', 'override the default .understand-anything directory')
-        .option('--sample <n>', 'maximum number of sample node ids to return (default 5)', parsePositiveInteger)).action(async (options) => {
-        try {
-            const summaryOptions = { projectRoot: options.project };
-            if (options.artifactDir !== undefined) {
-                summaryOptions.artifactDir = options.artifactDir;
-            }
-            if (options.sample !== undefined) {
-                summaryOptions.sampleSize = options.sample;
-            }
-            const summary = await summarizeKnowledgeGraph(summaryOptions);
-            if (!summary.exists) {
-                printResult(io, fail('understand.show', 'UNDERSTAND_GRAPH_MISSING', `No knowledge graph found at ${summary.path}`, summary, [INSTALL_HINT]), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            if (summary.parseError !== undefined) {
-                printResult(io, fail('understand.show', 'UNDERSTAND_GRAPH_PARSE_ERROR', `Knowledge graph at ${summary.path} is not valid JSON: ${summary.parseError}`, summary, ['Re-run `/understand` to regenerate the knowledge graph']), options.json);
-                process.exitCode = 1;
-                return;
-            }
-            printResult(io, ok('understand.show', summary), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('understand.show', 'UNDERSTAND_SHOW_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Check the project path and .understand-anything directory before retrying']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // L3.1: opt-in UX subcommand. Returns the AskUserQuestion payload that
-    // the LLM-side UX layer (peaks-code / peaks-ide) should surface when
-    // uaPrompt === 'unset' and UA is absent. When uaPrompt is skip-this-session
-    // or skip-forever, returns a no-op envelope (caller does not prompt).
-    addJsonOption(understand
-        .command('opt-in')
-        .description('Returns the UA opt-in prompt payload (Slice L3.1) when uaPrompt is unset; no-op otherwise')
-        .requiredOption('--project <path>', 'target project root')).action(async (options) => {
-        try {
-            const report = await scanUnderstandAnything({ projectRoot: options.project });
-            const uaPrompt = report.uaPrompt ?? 'unset';
-            if (report.exists || uaPrompt !== 'unset') {
-                // No prompt needed: UA is installed OR user already decided.
-                printResult(io, ok('understand.opt-in', { promptNeeded: false, uaPrompt, uaInstalled: report.exists }), options.json);
-                return;
-            }
-            const prompt = {
-                version: 1,
-                tool: 'ua-opt-in',
-                artifactDir: report.artifactDir,
-                reason: 'ua-artifact-missing',
-                options: [
-                    { id: 'install', label: 'Install UA in Claude Code', description: INSTALL_HINT },
-                    { id: 'fallback-this-session', label: 'Use codegraph fallback this session', description: 'Skip UA this run; do not write preferences.json' },
-                    { id: 'fallback-forever', label: 'Use codegraph fallback forever', description: 'Write preferences.json:uaPrompt=skip-forever; suppress future prompts' }
-                ]
-            };
-            printResult(io, ok('understand.opt-in', { promptNeeded: true, uaPrompt, uaInstalled: false, prompt }), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('understand.opt-in', 'UNDERSTAND_OPTIN_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Check the project path']), options.json);
-            process.exitCode = 1;
-        }
-    });
-    // Slice 2026-07-02-codegraph-ua-hybrid: hybrid context subcommand.
-    // Routes UA-first / codegraph-fallback / hybrid in the service layer;
-    // the CLI is a thin shell that surfaces the envelope and exit code.
-    addJsonOption(understand
-        .command('context')
-        .description('Build a hybrid project-context envelope: UA knowledge graph when present, codegraph affected as fallback, or both in parallel')
-        .requiredOption('--project <path>', 'target project root')
-        .option('--artifact-dir <path>', 'override the default .understand-anything directory')
-        .option('--sample <n>', 'maximum number of sample node ids to include (default 5)', parsePositiveInteger)
-        .option('--files <file...>', 'file globs to feed `codegraph affected` (default: src/index.ts, package.json, README.md)')).action(async (options) => {
-        try {
-            const ctxOptions = { projectRoot: options.project };
-            if (options.artifactDir !== undefined)
-                ctxOptions.artifactDir = options.artifactDir;
-            if (options.sample !== undefined)
-                ctxOptions.sampleSize = options.sample;
-            if (options.files !== undefined)
-                ctxOptions.files = options.files;
-            const result = await buildUnderstandContext(ctxOptions);
-            const exitCode = result.source === 'both-missing' ? 2 : 0;
-            if (exitCode !== 0) {
-                printResult(io, fail('understand.context', 'UNDERSTAND_CONTEXT_NO_EVIDENCE', `No UA graph and codegraph affected produced no usable evidence`, result, [
-                    INSTALL_HINT,
-                    'Run `peaks codegraph index` in this project to populate the codegraph index, then retry'
-                ]), options.json);
-                process.exitCode = exitCode;
-                return;
-            }
-            printResult(io, ok('understand.context', result, [], result.warnings.length > 0 ? result.warnings : undefined), options.json);
-        }
-        catch (error) {
-            printResult(io, fail('understand.context', 'UNDERSTAND_CONTEXT_FAILED', getErrorMessage(error), { projectRoot: options.project }, ['Check the project path and codegraph installation before retrying']), options.json);
-            process.exitCode = 1;
-        }
-    });
-}

package/dist/services/understand/hybrid-types.d.ts

@@ -1,32 +0,0 @@
-import type { CodegraphExecutionResult } from '../codegraph/codegraph-service.js';
-import type { UnderstandScanReport } from './understand-types.js';
-import type { UnderstandGraphSummary } from './understand-scan-service.js';
-/**
- * Slice 2026-07-02-codegraph-ua-hybrid — envelope contract for the
- * `peaks understand context` command. The service layer decides which
- * evidence to include based on environment detection; the source field
- * is the authoritative routing signal.
- */
-export type UnderstandContextSource = 'ua-only' | 'ua-missing-fallback-codegraph' | 'ua-and-codegraph-hybrid' | 'both-missing';
-export type CodegraphContextBlock = {
-    invocation: {
-        subcommand: 'affected';
-        files: string[];
-    };
-    execution: CodegraphExecutionResult;
-    /** Parsed JSON from `codegraph affected --json` when exitCode === 0; null otherwise. */
-    payload: unknown;
-    parseError?: string;
-};
-export type UnderstandContextResult = {
-    projectRoot: string;
-    source: UnderstandContextSource;
-    ua?: {
-        scan: UnderstandScanReport;
-        summary?: UnderstandGraphSummary;
-    };
-    codegraph?: CodegraphContextBlock;
-    /** Wall-clock milliseconds spent on the slowest parallel branch. */
-    durationMs: number;
-    warnings: string[];
-};

package/dist/services/understand/hybrid-types.js

@@ -1 +0,0 @@
-export {};

package/dist/services/understand/understand-hybrid-service.d.ts

@@ -1,10 +0,0 @@
-import { type CodegraphProcessRunner } from '../codegraph/codegraph-service.js';
-import type { UnderstandContextResult } from './hybrid-types.js';
-export type BuildUnderstandContextOptions = {
-    projectRoot: string;
-    files?: string[];
-    sampleSize?: number;
-    artifactDir?: string;
-    codegraphRunner?: CodegraphProcessRunner;
-};
-export declare function buildUnderstandContext(options: BuildUnderstandContextOptions): Promise<UnderstandContextResult>;

package/dist/services/understand/understand-hybrid-service.js

@@ -1,100 +0,0 @@
-import { createCodegraphInvocation, executeCodegraphInvocation } from '../codegraph/codegraph-service.js';
-import { scanUnderstandAnything, summarizeKnowledgeGraph } from './understand-scan-service.js';
-import { getErrorMessage } from 'peaks-loop-shared/result';
-const DEFAULT_FILES = ['src/index.ts', 'package.json', 'README.md'];
-function resolveFiles(files) {
-    if (files !== undefined && files.length > 0) {
-        return [...files];
-    }
-    return [...DEFAULT_FILES];
-}
-async function safeSummarize(options) {
-    try {
-        return { summary: await summarizeKnowledgeGraph(options) };
-    }
-    catch (error) {
-        return { warning: `UA summary failed: ${getErrorMessage(error)}` };
-    }
-}
-async function runCodegraph(projectRoot, files, runner) {
-    try {
-        const invocation = createCodegraphInvocation({
-            subcommand: 'affected',
-            project: projectRoot,
-            files,
-            json: true
-        });
-        const execution = await executeCodegraphInvocation(invocation, runner);
-        if (execution.exitCode !== 0) {
-            return { warning: `codegraph affected exited with code ${execution.exitCode}: ${execution.stderr.slice(0, 200)}` };
-        }
-        let payload = null;
-        let parseError;
-        try {
-            payload = JSON.parse(execution.stdout);
-        }
-        catch (error) {
-            parseError = getErrorMessage(error);
-        }
-        return {
-            block: {
-                invocation: { subcommand: 'affected', files },
-                execution,
-                payload,
-                ...(parseError !== undefined ? { parseError } : {})
-            }
-        };
-    }
-    catch (error) {
-        return { warning: `codegraph affected failed: ${getErrorMessage(error)}` };
-    }
-}
-function decideSource(uaScan, hasCodegraph) {
-    const uaPresent = uaScan.exists && uaScan.graph.exists && uaScan.graph.parseError === undefined;
-    if (uaPresent && hasCodegraph)
-        return 'ua-and-codegraph-hybrid';
-    if (uaPresent)
-        return 'ua-only';
-    if (hasCodegraph)
-        return 'ua-missing-fallback-codegraph';
-    return 'both-missing';
-}
-export async function buildUnderstandContext(options) {
-    const startedAt = Date.now();
-    const files = resolveFiles(options.files);
-    const sampleSize = options.sampleSize ?? 5;
-    const warnings = [];
-    const scanOptions = { projectRoot: options.projectRoot };
-    if (options.artifactDir !== undefined) {
-        scanOptions.artifactDir = options.artifactDir;
-    }
-    const uaScan = await scanUnderstandAnything(scanOptions);
-    const uaSummaryPromise = uaScan.exists && uaScan.graph.exists
-        ? safeSummarize({ projectRoot: options.projectRoot, sampleSize, ...(options.artifactDir !== undefined ? { artifactDir: options.artifactDir } : {}) })
-        : Promise.resolve({});
-    const [uaSummary, codegraphResult] = await Promise.all([
-        uaSummaryPromise,
-        runCodegraph(options.projectRoot, files, options.codegraphRunner)
-    ]);
-    if (uaSummary.warning)
-        warnings.push(uaSummary.warning);
-    if (codegraphResult.warning)
-        warnings.push(codegraphResult.warning);
-    const source = decideSource(uaScan, codegraphResult.block !== undefined);
-    const result = {
-        projectRoot: options.projectRoot,
-        source,
-        durationMs: Date.now() - startedAt,
-        warnings
-    };
-    if (source === 'ua-only' || source === 'ua-and-codegraph-hybrid') {
-        result.ua = {
-            scan: uaScan,
-            ...(uaSummary.summary !== undefined ? { summary: uaSummary.summary } : {})
-        };
-    }
-    if (codegraphResult.block) {
-        result.codegraph = codegraphResult.block;
-    }
-    return result;
-}

package/dist/services/understand/understand-scan-service.d.ts

@@ -1,28 +0,0 @@
-import type { UnderstandScanReport } from './understand-types.js';
-export type UnderstandScanOptions = {
-    projectRoot: string;
-    artifactDir?: string;
-};
-export declare function scanUnderstandAnything(options: UnderstandScanOptions): Promise<UnderstandScanReport>;
-export type UnderstandGraphSummary = {
-    exists: boolean;
-    path: string;
-    generatedAt: string | null;
-    topLevelFields: string[];
-    counts: {
-        nodes: number;
-        edges: number;
-        layers: number;
-        tours: number;
-    };
-    layerNames: string[];
-    tourNames: string[];
-    sampleNodes: string[];
-    parseError?: string;
-};
-export type SummarizeKnowledgeGraphOptions = {
-    projectRoot: string;
-    artifactDir?: string;
-    sampleSize?: number;
-};
-export declare function summarizeKnowledgeGraph(options: SummarizeKnowledgeGraphOptions): Promise<UnderstandGraphSummary>;

package/dist/services/understand/understand-scan-service.js

@@ -1,170 +0,0 @@
-import { stat } from 'node:fs/promises';
-import { join } from 'node:path';
-import { isDirectory, pathExists, readText } from 'peaks-loop-shared/fs';
-import { getErrorMessage } from 'peaks-loop-shared/result';
-import { loadPreferences } from '../preferences/preferences-service.js';
-function defaultArtifactDir(projectRoot) {
-    return join(projectRoot, '.understand-anything');
-}
-function countArrayField(record, key) {
-    const value = record[key];
-    return Array.isArray(value) ? value.length : 0;
-}
-async function readFlag(path) {
-    return { exists: await pathExists(path), path };
-}
-async function readGraph(graphPath) {
-    if (!(await pathExists(graphPath))) {
-        return { exists: false, path: graphPath };
-    }
-    const stats = await stat(graphPath);
-    const raw = await readText(graphPath);
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return {
-                exists: true,
-                path: graphPath,
-                sizeBytes: stats.size,
-                parseError: 'knowledge-graph.json must be a JSON object'
-            };
-        }
-        const record = parsed;
-        return {
-            exists: true,
-            path: graphPath,
-            sizeBytes: stats.size,
-            topLevelFields: Object.keys(record).sort(),
-            counts: {
-                nodes: countArrayField(record, 'nodes'),
-                edges: countArrayField(record, 'edges'),
-                layers: countArrayField(record, 'layers'),
-                tours: countArrayField(record, 'tours')
-            }
-        };
-    }
-    catch (error) {
-        return {
-            exists: true,
-            path: graphPath,
-            sizeBytes: stats.size,
-            parseError: getErrorMessage(error)
-        };
-    }
-}
-export async function scanUnderstandAnything(options) {
-    const artifactDir = options.artifactDir ?? defaultArtifactDir(options.projectRoot);
-    const exists = await isDirectory(artifactDir);
-    // L3.1: read uaPrompt from preferences.json (graceful — returns 'unset' if missing/broken)
-    const uaPrompt = await readUaPrompt(options.projectRoot);
-    if (!exists) {
-        return {
-            exists: false,
-            artifactDir,
-            graph: { exists: false, path: join(artifactDir, 'knowledge-graph.json') },
-            intermediate: { exists: false, path: join(artifactDir, 'intermediate') },
-            diffOverlay: { exists: false, path: join(artifactDir, 'diff-overlay.json') },
-            uaPrompt
-        };
-    }
-    const graph = await readGraph(join(artifactDir, 'knowledge-graph.json'));
-    const intermediate = await readFlag(join(artifactDir, 'intermediate'));
-    const diffOverlay = await readFlag(join(artifactDir, 'diff-overlay.json'));
-    return { exists: true, artifactDir, graph, intermediate, diffOverlay, uaPrompt };
-}
-async function readUaPrompt(projectRoot) {
-    try {
-        const prefs = await loadPreferences(projectRoot);
-        return prefs.uaPrompt;
-    }
-    catch {
-        return 'unset';
-    }
-}
-function pickStringId(value) {
-    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-        return null;
-    }
-    const record = value;
-    for (const key of ['id', 'path', 'name', 'label']) {
-        const candidate = record[key];
-        if (typeof candidate === 'string' && candidate.length > 0) {
-            return candidate;
-        }
-    }
-    return null;
-}
-function pickStringField(record, key) {
-    const value = record[key];
-    return typeof value === 'string' && value.length > 0 ? value : null;
-}
-function pickNameArray(record, key) {
-    const value = record[key];
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value
-        .map((entry) => {
-        if (typeof entry === 'string') {
-            return entry;
-        }
-        return pickStringId(entry);
-    })
-        .filter((entry) => entry !== null);
-}
-export async function summarizeKnowledgeGraph(options) {
-    const scanOptions = { projectRoot: options.projectRoot };
-    if (options.artifactDir !== undefined) {
-        scanOptions.artifactDir = options.artifactDir;
-    }
-    const scan = await scanUnderstandAnything(scanOptions);
-    const sampleSize = options.sampleSize ?? 5;
-    if (!scan.graph.exists) {
-        return {
-            exists: false,
-            path: scan.graph.path,
-            generatedAt: null,
-            topLevelFields: [],
-            counts: { nodes: 0, edges: 0, layers: 0, tours: 0 },
-            layerNames: [],
-            tourNames: [],
-            sampleNodes: []
-        };
-    }
-    if (scan.graph.parseError !== undefined) {
-        return {
-            exists: true,
-            path: scan.graph.path,
-            generatedAt: null,
-            topLevelFields: [],
-            counts: { nodes: 0, edges: 0, layers: 0, tours: 0 },
-            layerNames: [],
-            tourNames: [],
-            sampleNodes: [],
-            parseError: scan.graph.parseError
-        };
-    }
-    const raw = await readText(scan.graph.path);
-    const parsed = JSON.parse(raw);
-    const record = parsed;
-    const generatedAt = pickStringField(record, 'generatedAt');
-    const nodes = Array.isArray(record.nodes) ? record.nodes : [];
-    const sampleNodes = nodes.slice(0, sampleSize)
-        .map((entry) => pickStringId(entry))
-        .filter((entry) => entry !== null);
-    return {
-        exists: true,
-        path: scan.graph.path,
-        generatedAt,
-        topLevelFields: Object.keys(record).sort(),
-        counts: {
-            nodes: countArrayField(record, 'nodes'),
-            edges: countArrayField(record, 'edges'),
-            layers: countArrayField(record, 'layers'),
-            tours: countArrayField(record, 'tours')
-        },
-        layerNames: pickNameArray(record, 'layers'),
-        tourNames: pickNameArray(record, 'tours'),
-        sampleNodes
-    };
-}

package/dist/services/understand/understand-types.d.ts

@@ -1,50 +0,0 @@
-export type UnderstandGraphReport = {
-    exists: boolean;
-    path: string;
-    sizeBytes?: number;
-    topLevelFields?: string[];
-    counts?: {
-        nodes: number;
-        edges: number;
-        layers: number;
-        tours: number;
-    };
-    parseError?: string;
-};
-export type UnderstandFlagReport = {
-    exists: boolean;
-    path: string;
-};
-/**
- * Slice L3.1 — UA opt-in UX state. 'unset' triggers an opt-in prompt on
- * first scan; 'skip-this-session' suppresses the prompt for the current
- * session; 'skip-forever' writes to .peaks/preferences.json to suppress
- * all future prompts. Mirrors preferences.json:uaPrompt.
- */
-export type UaPromptDecision = 'unset' | 'skip-this-session' | 'skip-forever';
-export type UnderstandScanReport = {
-    exists: boolean;
-    artifactDir: string;
-    graph: UnderstandGraphReport;
-    intermediate: UnderstandFlagReport;
-    diffOverlay: UnderstandFlagReport;
-    /** Slice L3.1: opt-in UX state from preferences.json:uaPrompt. */
-    readonly uaPrompt?: UaPromptDecision;
-};
-/**
- * Slice L3.1 — opt-in prompt payload. When uaPrompt === 'unset' and UA is
- * absent, the peaks-code / peaks-ide layer surfaces this to the user via
- * AskUserQuestion. The CLI does not prompt directly; it returns this
- * payload so the LLM-side UX layer can decide.
- */
-export interface UaOptInPrompt {
-    readonly version: 1;
-    readonly tool: 'ua-opt-in';
-    readonly artifactDir: string;
-    readonly reason: 'ua-artifact-missing';
-    readonly options: readonly {
-        readonly id: 'install' | 'fallback-this-session' | 'fallback-forever';
-        readonly label: string;
-        readonly description: string;
-    }[];
-}

package/dist/services/understand/understand-types.js

@@ -1 +0,0 @@
-export {};