peaks-loop 4.0.0-beta.3 → 4.0.0-beta.30

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

@@ -0,0 +1,123 @@
+import { join } from 'node:path';
+import { isDirectory, listDirectories, pathExists, readText } from 'peaks-loop-shared/fs';
+function defaultOpenSpecRoot() {
+    return join(process.cwd(), 'openspec');
+}
+function parseMarkdownSections(markdown) {
+    const sections = new Map();
+    const lines = markdown.split(/\r?\n/);
+    let currentHeading = null;
+    let buffer = [];
+    const flush = () => {
+        if (currentHeading !== null) {
+            sections.set(currentHeading, buffer.join('\n').trim());
+        }
+    };
+    for (const line of lines) {
+        if (line.startsWith('## ')) {
+            flush();
+            currentHeading = line.slice(3).trim();
+            buffer = [];
+        }
+        else if (currentHeading !== null) {
+            buffer.push(line);
+        }
+    }
+    flush();
+    return sections;
+}
+function parseBullets(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('- ') || line === '-')
+        .map((line) => line.replace(/^-\s*/, '').trim())
+        .filter((line) => line.length > 0 && !line.startsWith('[ ]') && !line.startsWith('[x]') && !line.startsWith('[X]'));
+}
+function parseProposal(markdown) {
+    const sections = parseMarkdownSections(markdown);
+    const why = sections.get('Why') ?? '';
+    return {
+        why,
+        whatChanges: parseBullets(sections.get('What Changes') ?? ''),
+        outOfScope: parseBullets(sections.get('Out of Scope') ?? ''),
+        dependencies: parseBullets(sections.get('Dependencies') ?? ''),
+        risks: parseBullets(sections.get('Risks') ?? ''),
+        acceptanceCriteria: parseBullets(sections.get('Acceptance Criteria') ?? '')
+    };
+}
+function parseTaskProgress(markdown) {
+    const sections = parseMarkdownSections(markdown);
+    const sectionEntries = [];
+    let totalTodo = 0;
+    let doneTodo = 0;
+    for (const [heading, body] of sections.entries()) {
+        let sectionTotal = 0;
+        let sectionDone = 0;
+        for (const line of body.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (/^- \[[ xX]\]/.test(trimmed)) {
+                sectionTotal += 1;
+                if (/^- \[[xX]\]/.test(trimmed)) {
+                    sectionDone += 1;
+                }
+            }
+        }
+        if (sectionTotal > 0) {
+            sectionEntries.push({ heading, total: sectionTotal, done: sectionDone });
+            totalTodo += sectionTotal;
+            doneTodo += sectionDone;
+        }
+    }
+    return { totalTodo, doneTodo, sections: sectionEntries };
+}
+async function listSpecs(changeRoot) {
+    const specsRoot = join(changeRoot, 'specs');
+    if (!(await isDirectory(specsRoot))) {
+        return [];
+    }
+    return listDirectories(specsRoot);
+}
+async function resolvePaths(changeRoot) {
+    const proposalPath = join(changeRoot, 'proposal.md');
+    const tasksPath = join(changeRoot, 'tasks.md');
+    const designPath = join(changeRoot, 'design.md');
+    return {
+        root: changeRoot,
+        proposal: (await pathExists(proposalPath)) ? proposalPath : null,
+        tasks: (await pathExists(tasksPath)) ? tasksPath : null,
+        design: (await pathExists(designPath)) ? designPath : null
+    };
+}
+async function buildSummary(id, changeRoot) {
+    const paths = await resolvePaths(changeRoot);
+    const specs = await listSpecs(changeRoot);
+    let taskProgress = null;
+    if (paths.tasks !== null) {
+        taskProgress = parseTaskProgress(await readText(paths.tasks));
+    }
+    return { id, paths, specs, taskProgress };
+}
+export async function scanOpenSpec(options = {}) {
+    const openspecRoot = options.openspecRoot ?? defaultOpenSpecRoot();
+    const changesRoot = join(openspecRoot, 'changes');
+    if (!(await isDirectory(openspecRoot))) {
+        return { openspecRoot, changesRoot, exists: false, changes: [] };
+    }
+    if (!(await isDirectory(changesRoot))) {
+        return { openspecRoot, changesRoot, exists: true, changes: [] };
+    }
+    const ids = await listDirectories(changesRoot);
+    const changes = await Promise.all(ids.map((id) => buildSummary(id, join(changesRoot, id))));
+    return { openspecRoot, changesRoot, exists: true, changes };
+}
+export async function loadOpenSpecChange(changeId, options = {}) {
+    const openspecRoot = options.openspecRoot ?? defaultOpenSpecRoot();
+    const changeRoot = join(openspecRoot, 'changes', changeId);
+    if (!(await isDirectory(changeRoot))) {
+        return null;
+    }
+    const summary = await buildSummary(changeId, changeRoot);
+    const proposal = summary.paths.proposal === null ? null : parseProposal(await readText(summary.paths.proposal));
+    return { ...summary, proposal };
+}

package/dist/services/openspec/openspec-validate-service.js

@@ -0,0 +1,77 @@
+import { join } from 'node:path';
+import { isDirectory } from 'peaks-loop-shared/fs';
+import { loadOpenSpecChange } from './openspec-scan-service.js';
+const CHANGE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function defaultOpenSpecRoot() {
+    return join(process.cwd(), 'openspec');
+}
+async function defaultExternalRunner(_command, _args) {
+    return { available: false, exitCode: null, stdout: '', stderr: '' };
+}
+function buildInternalIssues(changeId, detail) {
+    const issues = [];
+    if (!CHANGE_ID_PATTERN.test(changeId)) {
+        issues.push({
+            level: 'error',
+            rule: 'change-id-format',
+            message: `changeId ${changeId} does not match [A-Za-z0-9][A-Za-z0-9._-]*`
+        });
+    }
+    if (detail === null || detail.proposal === null) {
+        issues.push({ level: 'error', rule: 'proposal-exists', message: 'proposal.md is missing' });
+        return issues;
+    }
+    const proposal = detail.proposal;
+    if (proposal.why.length === 0) {
+        issues.push({ level: 'warning', rule: 'why-non-empty', message: 'Why section is empty' });
+    }
+    if (proposal.whatChanges.length === 0) {
+        issues.push({ level: 'error', rule: 'what-changes-non-empty', message: 'What Changes section has no bullets' });
+    }
+    if (proposal.acceptanceCriteria.length === 0) {
+        issues.push({ level: 'error', rule: 'acceptance-non-empty', message: 'Acceptance Criteria section has no bullets' });
+    }
+    return issues;
+}
+function hasErrors(issues) {
+    return issues.some((issue) => issue.level === 'error');
+}
+async function runInternal(changeId, openspecRoot) {
+    const changeRoot = join(openspecRoot, 'changes', changeId);
+    if (!(await isDirectory(changeRoot))) {
+        return null;
+    }
+    const detail = await loadOpenSpecChange(changeId, { openspecRoot });
+    const issues = buildInternalIssues(changeId, detail);
+    return {
+        changeId,
+        valid: !hasErrors(issues),
+        source: 'internal',
+        issues
+    };
+}
+export async function validateOpenSpecChange(changeId, options = {}) {
+    const openspecRoot = options.openspecRoot ?? defaultOpenSpecRoot();
+    const runner = options.externalRunner ?? defaultExternalRunner;
+    if (options.preferExternal === true) {
+        const outcome = await runner('openspec', ['validate', changeId]);
+        if (outcome.available) {
+            const cliOutput = [outcome.stdout, outcome.stderr].filter((part) => part.length > 0).join('\n').trim();
+            const passed = outcome.exitCode === 0;
+            const issues = passed
+                ? []
+                : [{ level: 'error', rule: 'openspec-cli-failed', message: `openspec validate exited with code ${outcome.exitCode ?? 'null'}` }];
+            return { changeId, valid: passed, source: 'openspec-cli', issues, cliOutput };
+        }
+        const internal = await runInternal(changeId, openspecRoot);
+        if (internal === null) {
+            return null;
+        }
+        internal.issues = [
+            { level: 'warning', rule: 'openspec-cli-unavailable', message: 'openspec CLI not found, fell back to internal lint' },
+            ...internal.issues
+        ];
+        return internal;
+    }
+    return runInternal(changeId, openspecRoot);
+}

package/dist/services/polyrepo/polyrepo-dispatcher.d.ts

@@ -0,0 +1,34 @@
+import type { PolyrepoDispatch, PolyrepoManifest } from './polyrepo-types.js';
+export interface DispatchOptions {
+    /** Manifest returned by scanPolyrepo (root + children list). */
+    readonly manifest: PolyrepoManifest;
+    /** Session id this dispatch belongs to. */
+    readonly sid: string;
+    /** Request id (used in the on-disk filename). */
+    readonly rid: string;
+    /** Target child ids. Empty = root-only dispatch. Unknown ids are
+     *  recorded as warnings in the result, NOT raised as errors. */
+    readonly targets: readonly string[];
+    /** Artifact body — the role + source path on the parent side. */
+    readonly artifact: PolyrepoDispatch['artifact'];
+}
+export interface ChildDispatchResult {
+    readonly childId: string;
+    readonly path: string;
+    readonly ok: boolean;
+    readonly error?: string;
+    /** Where the artifact was mirrored to (child-side path). */
+    readonly mirroredTo?: string;
+}
+export interface DispatchResult {
+    readonly dispatch: PolyrepoDispatch;
+    readonly perChild: ChildDispatchResult[];
+    readonly warnings: string[];
+}
+export declare function dispatchArtifact(opts: DispatchOptions): DispatchResult;
+/** Default location of the polyrepo manifest on disk. */
+export declare function manifestPath(root: string): string;
+/** Read a persisted manifest from disk. Returns null when missing. */
+export declare function readManifest(root: string): PolyrepoManifest | null;
+/** Write a manifest atomically. */
+export declare function writeManifest(root: string, manifest: PolyrepoManifest): void;

package/dist/services/polyrepo/polyrepo-dispatcher.js

@@ -0,0 +1,119 @@
+/**
+ * Polyrepo dispatcher — slice S2-b of RD-2.
+ *
+ * Takes a parent root + a list of target child ids + a PRD/RD/QA
+ * artifact, and mirrors the artifact into each target child's
+ * `.peaks/_runtime/<sid>/<role>/` directory. Mirroring is
+ * best-effort + atomic per child: a failure in one child does NOT
+ * block the others (the dispatcher collects per-child results and
+ * returns them all so the caller can surface partial successes).
+ *
+ * Design notes:
+ *  - Per the project's two-axis convention, the parent's reviewable
+ *    artifact lives under `.peaks/_runtime/<sid>/<role>/`, not as a
+ *    sibling of `.peaks/_runtime/`. We mirror the same shape into
+ *    each child (the child does NOT inherit the parent's session
+ *    id verbatim — it gets the same one, which is fine because the
+ *    sid is the project's binding, not the parent's transient
+ *    pid).
+ *  - The dispatcher does NOT spawn any vendor verb — vendor
+ *    neutrality is preserved. If a child has no peaks-loop binary
+ *    on PATH, the dispatcher writes the artifact to disk and notes
+ *    a `peaksInstalled: false` warning; the user / a future slice
+ *    can pick it up. Per PRD §5 mitigation for "child has no
+ *    peaks-loop installed".
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+/** Compute the child-side path where the artifact should be mirrored.
+ *  Mirrors the parent shape exactly: `.peaks/_runtime/<sid>/<role>/`. */
+function childArtifactPath(childRoot, sid, role, sourcePath) {
+    const filename = sourcePath.split(/[\\/]/).pop() ?? 'artifact.md';
+    return join(childRoot, '.peaks', '_runtime', sid, role, filename);
+}
+function ensureDirFor(file) {
+    mkdirSync(dirname(file), { recursive: true });
+}
+export function dispatchArtifact(opts) {
+    const warnings = [];
+    const perChild = [];
+    // Validate targets against the manifest.
+    const knownIds = new Set(opts.manifest.children.map((c) => c.id));
+    const validTargets = [];
+    for (const t of opts.targets) {
+        if (knownIds.has(t)) {
+            validTargets.push(t);
+        }
+        else {
+            warnings.push(`unknown target id "${t}" — ignored`);
+        }
+    }
+    // Read the source artifact body once (so we can mirror to N children).
+    let sourceBody;
+    try {
+        sourceBody = readFileSync(opts.artifact.path, 'utf8');
+    }
+    catch (err) {
+        throw new Error(`source artifact unreadable at ${opts.artifact.path}: ${err.message}`);
+    }
+    // Per-child write.
+    for (const targetId of validTargets) {
+        const child = opts.manifest.children.find((c) => c.id === targetId);
+        if (child === undefined)
+            continue; // already filtered above
+        const dest = childArtifactPath(child.path, opts.sid, opts.artifact.role, opts.artifact.path);
+        try {
+            ensureDirFor(dest);
+            writeFileSync(dest, sourceBody, 'utf8');
+            perChild.push({
+                childId: targetId,
+                path: child.path,
+                ok: true,
+                mirroredTo: dest
+            });
+            if (!child.peaksInstalled) {
+                warnings.push(`child "${targetId}" has no peaks-loop install — artifact mirrored but not picked up by a running peaks process`);
+            }
+        }
+        catch (err) {
+            perChild.push({
+                childId: targetId,
+                path: child.path,
+                ok: false,
+                error: err.message
+            });
+        }
+    }
+    const dispatch = {
+        rid: opts.rid,
+        sid: opts.sid,
+        root: opts.manifest.root,
+        targets: validTargets,
+        dispatchedAt: new Date().toISOString(),
+        artifact: opts.artifact
+    };
+    return { dispatch, perChild, warnings };
+}
+/** Default location of the polyrepo manifest on disk. */
+export function manifestPath(root) {
+    return join(root, '.peaks', 'polyrepo.json');
+}
+/** Read a persisted manifest from disk. Returns null when missing. */
+export function readManifest(root) {
+    const p = manifestPath(root);
+    if (!existsSync(p))
+        return null;
+    try {
+        const raw = readFileSync(p, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch { // TODO(g2): fail-closed JSON parse — null is the documented contract, caller checks via existsSync
+        return null;
+    }
+}
+/** Write a manifest atomically. */
+export function writeManifest(root, manifest) {
+    const p = manifestPath(root);
+    ensureDirFor(p);
+    writeFileSync(p, JSON.stringify(manifest, null, 2), 'utf8');
+}

package/dist/services/polyrepo/polyrepo-scanner.d.ts

@@ -0,0 +1,9 @@
+import type { PolyrepoManifest } from './polyrepo-types.js';
+export interface ScanOptions {
+    /** Explicit list of child directory names (relative to root). When
+     *  provided, the scanner uses these instead of auto-discovery.
+     *  Matches the `peaks polyrepo init --children <dir1,dir2>` shape. */
+    readonly explicitChildren?: readonly string[];
+}
+/** Walk the parent root at depth 1 and return discovered children. */
+export declare function scanPolyrepo(root: string, opts?: ScanOptions): PolyrepoManifest;

package/dist/services/polyrepo/polyrepo-scanner.js

@@ -0,0 +1,94 @@
+/**
+ * Polyrepo scanner — slice S2-b of RD-2.
+ *
+ * Walks a parent directory looking for child git repos. A "child
+ * git repo" is defined as: a directory that contains a `.git`
+ * entry (file or directory — worktrees + submodules both qualify),
+ * is NOT the root itself, and sits at depth 1 from the root.
+ *
+ * Depth is intentionally bounded to 1 (per the PRD §4.3 model):
+ *   parent/
+ *     .peaks/
+ *     frontend/.git
+ *     backend/.git
+ * We do not recurse into nested monorepos in this slice — that is
+ * a future-slice concern.
+ */
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join, basename, resolve } from 'node:path';
+function isGitRoot(dir) {
+    // A `.git` directory (normal repo) OR a `.git` file (worktree +
+    // submodule pointer) both count. statSync follows the pointer for
+    // a `.git` file, so the existence check is the same.
+    return existsSync(join(dir, '.git'));
+}
+function childHasPeaks(dir) {
+    return existsSync(join(dir, '.peaks'));
+}
+/** Sanitize a candidate child id: lowercase, dash-joined, no
+ *  leading dots or dashes. Used when the dir name itself is the id
+ *  (the common case). */
+function sanitizeId(name) {
+    return name.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '');
+}
+/** Walk the parent root at depth 1 and return discovered children. */
+export function scanPolyrepo(root, opts = {}) {
+    const absRoot = resolve(root);
+    if (!existsSync(absRoot)) {
+        throw new Error(`polyrepo root does not exist: ${absRoot}`);
+    }
+    const rootStat = statSync(absRoot);
+    if (!rootStat.isDirectory()) {
+        throw new Error(`polyrepo root is not a directory: ${absRoot}`);
+    }
+    const children = [];
+    if (opts.explicitChildren !== undefined && opts.explicitChildren.length > 0) {
+        // Explicit mode: only consider the named subdirs. This matches
+        // `peaks polyrepo init --children ./frontend,./backend`.
+        for (const name of opts.explicitChildren) {
+            const childPath = resolve(absRoot, name);
+            if (!existsSync(childPath)) {
+                throw new Error(`polyrepo child directory does not exist: ${childPath}`);
+            }
+            const s = statSync(childPath);
+            if (!s.isDirectory()) {
+                throw new Error(`polyrepo child path is not a directory: ${childPath}`);
+            }
+            children.push({
+                id: sanitizeId(basename(childPath)),
+                path: childPath,
+                gitRoot: isGitRoot(childPath),
+                peaksScope: childHasPeaks(childPath) ? 'root+child' : 'child-only',
+                peaksInstalled: childHasPeaks(childPath)
+            });
+        }
+    }
+    else {
+        // Auto-discovery mode: list immediate entries, filter to dirs with
+        // `.git`. This is intentionally narrow — see the file-level
+        // rationale at the top of this file.
+        const entries = readdirSync(absRoot, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith('.'))
+                continue; // skip .git, .peaks, .vscode, etc.
+            const childPath = join(absRoot, entry.name);
+            if (!isGitRoot(childPath))
+                continue;
+            children.push({
+                id: sanitizeId(entry.name),
+                path: childPath,
+                gitRoot: true,
+                peaksScope: childHasPeaks(childPath) ? 'root+child' : 'child-only',
+                peaksInstalled: childHasPeaks(childPath)
+            });
+        }
+    }
+    return {
+        version: 1,
+        root: absRoot,
+        detectedAt: new Date().toISOString(),
+        children
+    };
+}

package/dist/services/polyrepo/polyrepo-service.d.ts

@@ -0,0 +1,34 @@
+import type { PolyrepoChild, PolyrepoManifest } from './polyrepo-types.js';
+export interface PolyrepoInitOptions {
+    readonly root: string;
+    readonly children?: readonly string[];
+}
+export interface PolyrepoInitResult {
+    readonly manifest: PolyrepoManifest;
+    readonly created: boolean;
+}
+export interface PolyrepoStatusResult {
+    readonly root: string;
+    readonly manifestExists: boolean;
+    readonly children: PolyrepoChild[];
+    readonly detectedAt: string | null;
+}
+export declare class PolyrepoService {
+    /** Run a scan and persist the manifest. Returns the manifest + a
+     *  `created` flag indicating whether a new manifest was written
+     *  (false = existing manifest was overwritten). */
+    init(opts: PolyrepoInitOptions): PolyrepoInitResult;
+    /** Read the persisted manifest + report children. */
+    status(root: string): PolyrepoStatusResult;
+    /** Dispatch an artifact to the named child targets. Wrapper
+     *  around dispatchArtifact that resolves the manifest from disk
+     *  first. Throws when no manifest exists (caller should run init
+     *  first). */
+    dispatch(root: string, params: {
+        sid: string;
+        rid: string;
+        targets: readonly string[];
+        role: 'prd' | 'rd' | 'qa';
+        artifactPath: string;
+    }): import("./polyrepo-dispatcher.js").DispatchResult;
+}

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

@@ -0,0 +1,49 @@
+/**
+ * Polyrepo service — slice S2-b of RD-2.
+ *
+ * Thin orchestrator wrapping the scanner + dispatcher. CLI commands
+ * call into this service so they don't need to know about the
+ * individual helpers.
+ */
+import { dispatchArtifact, readManifest, writeManifest, manifestPath } from './polyrepo-dispatcher.js';
+import { scanPolyrepo } from './polyrepo-scanner.js';
+export class PolyrepoService {
+    /** Run a scan and persist the manifest. Returns the manifest + a
+     *  `created` flag indicating whether a new manifest was written
+     *  (false = existing manifest was overwritten). */
+    init(opts) {
+        const existing = readManifest(opts.root);
+        const manifest = opts.children === undefined
+            ? scanPolyrepo(opts.root)
+            : scanPolyrepo(opts.root, { explicitChildren: opts.children });
+        writeManifest(opts.root, manifest);
+        return { manifest, created: existing === null };
+    }
+    /** Read the persisted manifest + report children. */
+    status(root) {
+        const m = readManifest(root);
+        return {
+            root,
+            manifestExists: m !== null,
+            children: m?.children ?? [],
+            detectedAt: m?.detectedAt ?? null
+        };
+    }
+    /** Dispatch an artifact to the named child targets. Wrapper
+     *  around dispatchArtifact that resolves the manifest from disk
+     *  first. Throws when no manifest exists (caller should run init
+     *  first). */
+    dispatch(root, params) {
+        const manifest = readManifest(root);
+        if (manifest === null) {
+            throw new Error(`no polyrepo manifest at ${manifestPath(root)} — run \`peaks polyrepo init\` first`);
+        }
+        return dispatchArtifact({
+            manifest,
+            sid: params.sid,
+            rid: params.rid,
+            targets: params.targets,
+            artifact: { role: params.role, path: params.artifactPath }
+        });
+    }
+}

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

@@ -0,0 +1,55 @@
+/**
+ * Polyrepo types — slice S2-b of RD-2.
+ *
+ * Models a parent directory that hosts one or more child git repos,
+ * each of which may carry its own `.peaks/` state. The root `.peaks/`
+ * is the source of truth for cross-child orchestration; child
+ * `.peaks/` are subsets that mirror only the artifacts the child
+ * needs (PRD §4.3).
+ */
+export type PeaksScope = 'root+child' | 'child-only';
+/** A single child repo discovered under the parent root. */
+export interface PolyrepoChild {
+    /** Stable id derived from the basename (e.g. `frontend`, `backend`). */
+    readonly id: string;
+    /** Absolute path to the child directory. */
+    readonly path: string;
+    /** Whether `.git` exists at the child root (true git repo, not just a subdir). */
+    readonly gitRoot: boolean;
+    /** Whether the child carries its own `.peaks/` artifact subset. */
+    readonly peaksScope: PeaksScope;
+    /** Whether the child has peaks-loop installed (peaks binary on PATH
+     *  is NOT checked here — that's done at dispatch time). */
+    readonly peaksInstalled: boolean;
+}
+/** The polyrepo manifest, written to `.peaks/polyrepo.json` on init. */
+export interface PolyrepoManifest {
+    /** Schema version — increment on breaking changes. */
+    readonly version: 1;
+    /** Absolute path to the parent (root) directory. */
+    readonly root: string;
+    /** ISO-8601 timestamp of when this manifest was generated. */
+    readonly detectedAt: string;
+    /** Children discovered under the root. */
+    readonly children: PolyrepoChild[];
+}
+/** A dispatch record — written to `.peaks/_runtime/<sid>/sc/dispatch/<rid>.json`
+ *  AND mirrored to each target child's
+ *  `.peaks/_runtime/<sid>/sc/dispatch/<rid>.json`. The two-axis
+ *  convention from .peaks/standards/ is preserved: reviewable
+ *  artifacts live under `.peaks/_runtime/<sid>/<role>/`, never as
+ *  top-level siblings of `.peaks/_runtime/`. */
+export interface PolyrepoDispatch {
+    readonly rid: string;
+    readonly sid: string;
+    readonly root: string;
+    /** Child ids targeted by this dispatch. Empty array = root-only. */
+    readonly targets: string[];
+    /** ISO timestamp. */
+    readonly dispatchedAt: string;
+    /** Source-of-truth for the artifact body. */
+    readonly artifact: {
+        readonly role: 'prd' | 'rd' | 'qa';
+        readonly path: string;
+    };
+}

package/dist/services/prd/project-scan-bootstrap-service.d.ts

@@ -0,0 +1,52 @@
+/**
+ * project-scan bootstrap service — slice 2026-07-15-project-scan-bootstrap
+ * (PRD G1 + G2 + G4b / AC1-AC10 / R1-R4).
+ *
+ * Owns the "first time a project enters Peaks-Loop" bootstrap flow:
+ *   - 0-1 detection (no package.json OR no source files)
+ *   - writes `.peaks/project-scan/project-scan.md` with empty placeholders
+ *     for 0-1 projects, or with archetype + libraryVersions for existing
+ *     projects (calling `scanArchetype` + `scanLibraries` directly, not
+ *     forking a CLI process)
+ *   - boots the 4 audit/business templates (bundled in repo at
+ *     `src/services/workspace/templates/project-scan/`) into
+ *     `.peaks/project-scan/` (AC9)
+ *   - idempotent: skips re-writes when the existing file is at
+ *     schemaVersion:1 (AC3); --force / --force-templates override
+ *
+ * Called by:
+ *   - `peaks project context` (via `generateProjectContext`)
+ *   - `peaks workspace init` (main path)
+ *
+ * The "5 templates" count: 4 bundled audit/business files + the
+ * dynamically-generated `project-scan.md` produced by this service.
+ * `templatesBooted` reflects the count of files actually written;
+ * `templatesSkipped` reflects files already present (sediment-protected).
+ */
+export type BootstrapProjectScanOptions = {
+    readonly projectRoot: string;
+    /** Override the existing-file skip and rewrite project-scan.md. */
+    readonly force?: boolean;
+    /** Override the bundled-template skip and overwrite audit/business files. */
+    readonly forceTemplates?: boolean;
+};
+export type BootstrapProjectScanEnvelope = {
+    /** True iff project-scan.md was written by this call. */
+    readonly created: boolean;
+    /** True iff project-scan.md existed and was skipped (idempotent). */
+    readonly skipped: boolean;
+    /** Count of files written to .peaks/project-scan/ (1 project-scan.md + N templates). */
+    readonly templatesBooted: number;
+    /** Count of files already present and skipped (sediment-preserved). */
+    readonly templatesSkipped: number;
+    /** Absolute path to the project-scan.md file (whether written or pre-existing). */
+    readonly projectScanPath: string;
+    /** Resolved archetype (when existing-project path was taken). */
+    readonly archetype?: string;
+    /** Total wall-time of the bootstrap call. */
+    readonly durationMs: number;
+};
+/**
+ * Public entry point. See the file header for the full contract.
+ */
+export declare function bootstrapProjectScan(options: BootstrapProjectScanOptions): Promise<BootstrapProjectScanEnvelope>;