peaks-loop 4.0.0-beta.9 → 4.0.1

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

@@ -9,18 +9,17 @@ import { getConfiguredExecutionModelId, getStrongestModelId } from '../config/mo
  * 2.0.1-bug1: the slim 2.0 `~/.peaks/config.json` no longer carries a
  * `providers` block (legacy model config lives in
  * `.peaks/preferences.json` per spec §10.4). `buildPlan` is a pure
- * planner function and historically took its execution model from
- * `DEFAULT_CONFIG.providers.minimax.model`; with the slim default
- * that field is `undefined`, so `getConfiguredExecutionModelId`
- * would throw. We retain the pre-2.0 default here as a literal so
- * the planner remains usable when the caller has not passed an
- * explicit `executionModelId` (unit tests, dry-run previews, the
- * `peaks swarm plan` onboarding path). Production callers that
- * have a real `ocr.llm.model` configured pass it via
- * `request.executionModelId` (or via the legacy preferences.json
- * bridge) and bypass this fallback.
+ * planner function and historically took its execution model from a
+ * legacy provider config; with the slim default that field is
+ * `undefined`, so `getConfiguredExecutionModelId` would throw. We
+ * retain a sensible default here as a literal so the planner remains
+ * usable when the caller has not passed an explicit `executionModelId`
+ * (unit tests, dry-run previews, the `peaks swarm plan` onboarding
+ * path). Production callers that have a real `ocr.llm.model` configured
+ * pass it via `request.executionModelId` (or via the legacy
+ * preferences.json bridge) and bypass this fallback.
  */
-const DEFAULT_EXECUTION_MODEL_ID = 'minimax-2.7';
+const DEFAULT_EXECUTION_MODEL_ID = 'claude-opus-4-7';
 import { getTechStatus, TECH_REQUIRED_ARTIFACTS } from '../tech/tech-service.js';
 import { resolveRdStartupStandardsCheck } from './standards-diagnostic.js';
 import { runStrategicStage } from './strategic-stage.js';

package/dist/services/rd/types.d.ts

@@ -57,19 +57,19 @@ export declare const AstViolationSchema: z.ZodObject<{
     actualVersion: z.ZodString;
     severity: z.ZodEnum<["error", "warning"]>;
 }, "strip", z.ZodTypeAny, {
-    api: string;
     file: string;
+    api: string;
+    severity: "error" | "warning";
     line: number;
     expectedVersion: string;
     actualVersion: string;
-    severity: "error" | "warning";
 }, {
-    api: string;
     file: string;
+    api: string;
+    severity: "error" | "warning";
     line: number;
     expectedVersion: string;
     actualVersion: string;
-    severity: "error" | "warning";
 }>;
 export declare const AstGateResultSchema: z.ZodObject<{
     passed: z.ZodBoolean;
@@ -81,39 +81,39 @@ export declare const AstGateResultSchema: z.ZodObject<{
         actualVersion: z.ZodString;
         severity: z.ZodEnum<["error", "warning"]>;
     }, "strip", z.ZodTypeAny, {
-        api: string;
         file: string;
+        api: string;
+        severity: "error" | "warning";
         line: number;
         expectedVersion: string;
         actualVersion: string;
-        severity: "error" | "warning";
     }, {
-        api: string;
         file: string;
+        api: string;
+        severity: "error" | "warning";
         line: number;
         expectedVersion: string;
         actualVersion: string;
-        severity: "error" | "warning";
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     passed: boolean;
     violations: {
-        api: string;
         file: string;
+        api: string;
+        severity: "error" | "warning";
         line: number;
         expectedVersion: string;
         actualVersion: string;
-        severity: "error" | "warning";
     }[];
 }, {
     passed: boolean;
     violations: {
-        api: string;
         file: string;
+        api: string;
+        severity: "error" | "warning";
         line: number;
         expectedVersion: string;
         actualVersion: string;
-        severity: "error" | "warning";
     }[];
 }>;
 export declare const ExternalApiCallSchema: z.ZodObject<{
@@ -123,13 +123,13 @@ export declare const ExternalApiCallSchema: z.ZodObject<{
     version: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     version: string;
-    api: string;
     file: string;
+    api: string;
     line: number;
 }, {
     version: string;
-    api: string;
     file: string;
+    api: string;
     line: number;
 }>;
 export declare const ImplOutputSchema: z.ZodObject<{
@@ -145,13 +145,13 @@ export declare const ImplOutputSchema: z.ZodObject<{
         version: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         version: string;
-        api: string;
         file: string;
+        api: string;
         line: number;
     }, {
         version: string;
-        api: string;
         file: string;
+        api: string;
         line: number;
     }>, "many">;
     astGateResult: z.ZodObject<{
@@ -164,85 +164,85 @@ export declare const ImplOutputSchema: z.ZodObject<{
             actualVersion: z.ZodString;
             severity: z.ZodEnum<["error", "warning"]>;
         }, "strip", z.ZodTypeAny, {
-            api: string;
             file: string;
+            api: string;
+            severity: "error" | "warning";
             line: number;
             expectedVersion: string;
             actualVersion: string;
-            severity: "error" | "warning";
         }, {
-            api: string;
             file: string;
+            api: string;
+            severity: "error" | "warning";
             line: number;
             expectedVersion: string;
             actualVersion: string;
-            severity: "error" | "warning";
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         passed: boolean;
         violations: {
-            api: string;
             file: string;
+            api: string;
+            severity: "error" | "warning";
             line: number;
             expectedVersion: string;
             actualVersion: string;
-            severity: "error" | "warning";
         }[];
     }, {
         passed: boolean;
         violations: {
-            api: string;
             file: string;
+            api: string;
+            severity: "error" | "warning";
             line: number;
             expectedVersion: string;
             actualVersion: string;
-            severity: "error" | "warning";
         }[];
     }>;
 }, "strip", z.ZodTypeAny, {
     version: "1.0";
     sha256: string;
     generatedAt: string;
-    inputSig: string;
     changedFiles: string[];
+    inputSig: string;
     externalApiCalls: {
         version: string;
-        api: string;
         file: string;
+        api: string;
         line: number;
     }[];
     astGateResult: {
         passed: boolean;
         violations: {
-            api: string;
             file: string;
+            api: string;
+            severity: "error" | "warning";
             line: number;
             expectedVersion: string;
             actualVersion: string;
-            severity: "error" | "warning";
         }[];
     };
 }, {
     version: "1.0";
     sha256: string;
     generatedAt: string;
-    inputSig: string;
     changedFiles: string[];
+    inputSig: string;
     externalApiCalls: {
         version: string;
-        api: string;
         file: string;
+        api: string;
         line: number;
     }[];
     astGateResult: {
         passed: boolean;
         violations: {
-            api: string;
             file: string;
+            api: string;
+            severity: "error" | "warning";
             line: number;
             expectedVersion: string;
             actualVersion: string;
-            severity: "error" | "warning";
         }[];
     };
 }>;

package/dist/services/rd-swarm/rd-swarm-service.d.ts

@@ -0,0 +1,60 @@
+import type { WorkspaceConfig } from '../config/config-types.js';
+import { type BoundaryError } from '../openspec/artifact-boundary.js';
+export type RdSwarmPlanRequest = {
+    skill: 'rd' | string;
+    changeId: string;
+    goal: string;
+    maxWorkers?: number;
+    dryRun: true;
+    workspaceRoot: string;
+    targetRepoRoot?: string;
+    requiresTechApproval?: boolean;
+    workspace?: WorkspaceConfig;
+};
+export type RdWaveName = 'discovery' | 'planning' | 'implementation candidates' | 'quality gates' | 'reducer';
+export type RdTask = {
+    taskId: string;
+    wave: RdWaveName;
+    workerKind: string;
+    purpose: string;
+    inputs: string[];
+    outputs: [string, ...string[]];
+    dependsOn: string[];
+    conflictGroup: string;
+    targetArea: string;
+    expectedEvidence: string;
+};
+export type RdConflictGroup = {
+    groupId: string;
+    ownedPaths: string[];
+    parallelismPolicy: 'parallel' | 'sequential';
+    reason: string;
+};
+export type RdTaskGraph = {
+    changeId: string;
+    goal: string;
+    available: boolean;
+    workerTarget: number;
+    waves: Array<{
+        name: RdWaveName;
+        taskIds: string[];
+    }>;
+    tasks: RdTask[];
+    conflictGroups: RdConflictGroup[];
+    artifactRoot: string;
+    outputs: {
+        taskGraph: string;
+        waveManifests: string[];
+        workerBriefs: string[];
+        reducerReport: string;
+    };
+    gateStatus: {
+        techApprovalRequired: boolean;
+        techStatus: string;
+        skipReason?: string;
+    };
+    blockedReasons: string[];
+    nextActions: string[];
+};
+export declare function planRdSwarmGraph(input: RdSwarmPlanRequest): RdTaskGraph;
+export type { BoundaryError };

package/dist/services/rd-swarm/rd-swarm-service.js

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { planArtifactPath, validateChangeId } from '../openspec/artifact-boundary.js';
+import { getTechStatus as getLegacyTechStatus } from '../tech/tech-service.js';
+const MIN_WORKERS = 25;
+const MAX_WORKERS = 40;
+const REQUIRED_TECH_FILES = ['frontend-tech-doc.md', 'backend-tech-doc.md', 'tech-approval-record.md'];
+function failure(input, reasons, actions, gateStatus, workerTarget) {
+    return { ...input, available: false, workerTarget, waves: [], tasks: [], conflictGroups: [], outputs: { taskGraph: `${input.artifactRoot}/task-graph.json`, waveManifests: [], workerBriefs: [], reducerReport: `${input.artifactRoot}/reducer-report.md` }, gateStatus, blockedReasons: reasons, nextActions: actions };
+}
+function validate(input) {
+    if (input.skill !== 'rd')
+        return { ok: false, error: { code: 'UNSUPPORTED_SWARM_SKILL', message: `Unsupported skill ${input.skill}` } };
+    const id = validateChangeId(input.changeId);
+    if (!id.ok)
+        return { ok: false, error: id.error };
+    const goal = input.goal.trim();
+    if (!goal)
+        return { ok: false, error: { code: 'INVALID_GOAL', message: 'Goal must be non-empty' } };
+    return { ok: true, value: { changeId: id.value.changeId, goal } };
+}
+function localTechStatus(input) {
+    try {
+        const canonical = getLegacyTechStatus({ sessionId: input.changeId, artifactWorkspacePath: input.workspaceRoot, ...(input.workspace ? { workspace: input.workspace } : {}) });
+        if (canonical.status === 'approved')
+            return 'approved';
+    }
+    catch { /* pure planner fallback for an unconfigured workspace */ }
+    const root = join(input.workspaceRoot, input.changeId, 'rd', 'architecture');
+    const missing = REQUIRED_TECH_FILES.filter((name) => !existsSync(join(root, name)));
+    if (missing.length > 0)
+        return missing.includes('tech-approval-record.md') && missing.length === 1 ? 'missing-approval' : 'missing';
+    try {
+        return readFileSync(join(root, 'tech-approval-record.md'), 'utf8').split(/\r?\n/).some((line) => line.trim() === 'status: approved') ? 'approved' : 'not-approved';
+    }
+    catch {
+        return 'not-approved';
+    }
+}
+function path(input, template) {
+    const result = planArtifactPath({ changeId: input.changeId, workspaceRoot: input.workspaceRoot, role: 'rd', requestId: 'swarm', template });
+    if (!result.ok)
+        throw new Error(result.error.message);
+    return result.value.jsonSafeRelativePath;
+}
+function createTask(taskId, wave, goal, dependencies, index) {
+    const output = `workers/${taskId}/brief.md`;
+    return { taskId, wave, workerKind: taskId, purpose: `${taskId} for ${goal}`, inputs: [goal], outputs: [output], dependsOn: [...dependencies], conflictGroup: `group-${wave.replace(/\s/g, '-')}`, targetArea: wave === 'implementation candidates' ? `slice-${index + 1}` : wave, expectedEvidence: `${taskId}-evidence.md` };
+}
+function taskIds(target) {
+    const discovery = ['rd-frontend-scan', 'rd-backend-scan', 'rd-test-scan', 'rd-contract-scan', 'rd-risk-scan'];
+    const planning = ['rd-frontend-slicer', 'rd-backend-slicer', 'rd-unit-test-slicer', 'rd-contract-planner', 'rd-quality-gate-planner'];
+    const quality = ['rd-code-review-worker', 'rd-security-review-worker', 'rd-typecheck-worker', 'rd-coverage-worker', 'rd-regression-worker'];
+    const implementationCount = Math.max(1, target - discovery.length - planning.length - quality.length - 1);
+    const implementation = Array.from({ length: implementationCount }, (_, i) => `rd-impl-${String(i + 1).padStart(3, '0')}`);
+    return { discovery, planning, 'implementation candidates': implementation, 'quality gates': quality, reducer: ['rd-reducer-worker'] };
+}
+export function planRdSwarmGraph(input) {
+    const checked = validate(input);
+    const defaultRoot = `${input.changeId}/swarm`;
+    const common = { changeId: input.changeId, goal: input.goal.trim(), artifactRoot: defaultRoot };
+    const requested = input.maxWorkers ?? 25;
+    if (!checked.ok)
+        return failure(common, [checked.error.code], [checked.error.message], { techApprovalRequired: input.requiresTechApproval === true, techStatus: 'unavailable' }, Number.isInteger(requested) && requested > 0 ? Math.min(requested, MAX_WORKERS) : 0);
+    if (!Number.isInteger(requested) || requested < 1)
+        return failure({ ...common, goal: checked.value.goal, changeId: checked.value.changeId, artifactRoot: `${checked.value.changeId}/swarm` }, ['INVALID_MAX_WORKERS'], ['Use a positive integer for max-workers.'], { techApprovalRequired: input.requiresTechApproval === true, techStatus: 'unavailable' }, 0);
+    const goal = checked.value.goal;
+    const changeId = checked.value.changeId;
+    const artifactRoot = `${changeId}/swarm`;
+    const target = Math.min(requested, MAX_WORKERS);
+    const reasons = requested > MAX_WORKERS ? ['WORKER_CAP_EXCEEDED'] : [];
+    if (requested < MIN_WORKERS)
+        reasons.push('SMALL_SCOPE');
+    const required = input.requiresTechApproval === true;
+    const techStatus = localTechStatus({ ...input, changeId, goal });
+    const gateStatus = { techApprovalRequired: required, techStatus, ...(required ? {} : { skipReason: 'tech-gate-not-required' }) };
+    if (required && techStatus !== 'approved') {
+        reasons.push('TECH_APPROVAL_REQUIRED');
+        if (techStatus === 'missing-approval' || techStatus === 'missing')
+            reasons.push('TECH_APPROVAL_MISSING');
+    }
+    if (reasons.includes('SMALL_SCOPE'))
+        return failure({ changeId, goal, artifactRoot }, reasons, ['Describe the small scope in natural language or increase the worker target to at least 25.'], gateStatus, target);
+    if (required && techStatus !== 'approved')
+        return failure({ changeId, goal, artifactRoot }, reasons, ['Review and approve the technical plan before running the RD swarm.'], gateStatus, target);
+    const ids = taskIds(target);
+    const waves = Object.entries(ids).map(([name, taskIds]) => ({ name, taskIds }));
+    const dependencies = { discovery: [], planning: ids.discovery, 'implementation candidates': ids.planning, 'quality gates': ids['implementation candidates'], reducer: ids['quality gates'] };
+    const tasks = waves.flatMap(({ name, taskIds: waveTaskIds }) => waveTaskIds.map((id, i) => createTask(id, name, goal, dependencies[name], i)));
+    const conflictGroups = waves.map(({ name, taskIds: waveTaskIds }) => ({ groupId: `group-${name.replace(/\s/g, '-')}`, ownedPaths: waveTaskIds.map((id) => `${artifactRoot}/workers/${id}/brief.md`), parallelismPolicy: waveTaskIds.length > 1 ? 'parallel' : 'sequential', reason: `${name} workers have isolated artifact ownership` }));
+    const outputs = { taskGraph: path(input, '<changeId>/swarm/task-graph.json'), waveManifests: waves.map((wave, i) => path(input, `<changeId>/swarm/waves/wave-${i + 1}-${wave.name}.json`)), workerBriefs: tasks.map((task) => path(input, `<changeId>/swarm/${task.outputs[0]}`)), reducerReport: path(input, '<changeId>/swarm/reducer-report.md') };
+    return { changeId, goal, available: true, workerTarget: target, waves, tasks, conflictGroups, artifactRoot, outputs, gateStatus, blockedReasons: reasons, nextActions: reasons.includes('WORKER_CAP_EXCEEDED') ? ['Worker target was capped at 40.'] : [] };
+}

package/dist/services/recommendations/capability-seed-items.js

@@ -93,7 +93,6 @@ export const seedCapabilityItems = [
     capability('searchcode-mcp.code-search', 'searchcode-mcp', 'SearchCode MCP', 'mcp', 'code-search', ['engineer'], 'medium', 'local-code-search', 'Use local Grep/Glob and ask before sending private code externally.', 'External Code Search', '外部代码搜索', 'Searches code examples or repositories outside the current workspace.', '搜索当前工作区外部的代码示例或仓库。'),
     capability('mysql-mcp.database-inspection', 'mysql-mcp-server', 'MySQL Database Inspection', 'mcp', 'database-inspection', ['engineer'], 'high', 'schema-excerpt-input', 'Ask the user for schema excerpts or sanitized query plans.', 'MySQL Inspection', 'MySQL 检查', 'Inspects MySQL schema and data through an MCP boundary.', '通过 MCP 边界检查 MySQL schema 与数据。'),
     capability('agent-browser.browser-agent', 'agent-browser', 'Agent Browser', 'agent', 'browser-agent', ['engineer', 'qa'], 'medium', 'manual-browser-walkthrough', 'Use screenshots and manual test steps if agent browser is unavailable.', 'Agent Browser', '浏览器代理', 'Supports browser-based validation and interaction planning.', '支持基于浏览器的验证和交互规划。'),
-    capability('minimax-skills.worker-guidance', 'minimax-skills', 'MiniMax Worker Guidance', 'skill', 'worker-guidance', ['engineer'], 'medium', 'peaks-worker-contract', 'Use Peaks built-in minimax-worker contract and review handoff.', 'MiniMax Worker Guidance', 'MiniMax Worker 指南', 'Guides MiniMax coding/test worker delegation.', '指导 MiniMax 编码/测试 worker 委托。'),
     capability('claude-mem.memory-persistence', 'claude-mem', 'Claude Memory Persistence', 'skill', 'memory', ['engineer'], 'medium', 'peaks-txt-context-capsule', 'Use peaks-txt context capsules without storing secrets.', 'Memory Persistence', '记忆持久化', 'Persists reusable context when explicitly approved.', '在明确授权时持久化可复用上下文。'),
     capability('openspec.spec-workflow', 'openspec', 'OpenSpec Workflow', 'workflow', 'spec-workflow', ['product', 'engineer'], 'low', 'peaks-prd-rd-qa-artifacts', 'Use Peaks built-in PRD/RD/QA artifact flow.', 'OpenSpec Workflow', 'OpenSpec 规格流程', 'Supports spec-first product and engineering governance.', '支持规格优先的产品与工程治理。'),
     capability('gitnexus.repo-intelligence', 'gitnexus', 'GitNexus Repository Intelligence', 'cli', 'repo-intelligence', ['engineer'], 'medium', 'local-repo-scan', 'Use local project scanning through Peaks RD.', 'Repository Intelligence', '仓库智能分析', 'Repository intelligence should be proxied through Peaks before use.', '仓库智能分析应先通过 Peaks 代理边界再使用。'),

package/dist/services/recommendations/capability-seed-mappings.js

@@ -31,7 +31,6 @@ export const seedCapabilityLandingMappings = [
     mapping({ capabilityId: 'impeccable.quality-guidance', sourceId: 'impeccable', sourceGroup: 'mcp-server', landingKind: 'catalog', target: 'quality reference catalog', guidance: 'Use as quality inspiration; Peaks review gates remain authoritative.' }),
     mapping({ capabilityId: 'vercel-agent-skills.skill-pack', sourceId: 'vercel-agent-skills', sourceGroup: 'mcp-server', landingKind: 'catalog', target: 'external skill catalog', guidance: 'Catalog only until individual skills are inspected and approved.' }),
     mapping({ capabilityId: 'agent-browser.browser-agent', sourceId: 'agent-browser', sourceGroup: 'mcp-server', landingKind: 'skill', target: 'peaks-qa', skillName: 'peaks-qa', guidance: 'Use for browser validation; never submit forms or mutate authenticated state without explicit permission.' }),
-    mapping({ capabilityId: 'minimax-skills.worker-guidance', sourceId: 'minimax-skills', sourceGroup: 'mcp-server', landingKind: 'cli', target: 'peaks minimax-worker', commandPreview: 'peaks minimax-worker --json', guidance: 'Use Peaks worker command only after reviewing inputs; add --confirm manually when explicit external-provider approval exists.' }),
     mapping({ capabilityId: 'claude-mem.memory-persistence', sourceId: 'claude-mem', sourceGroup: 'mcp-server', landingKind: 'skill', target: 'peaks-txt', skillName: 'peaks-txt', guidance: 'Use only with explicit durable-memory consent and never store secrets.' }),
     mapping({ capabilityId: 'darwin-skill.external-skill', sourceId: 'darwin-skill', sourceGroup: 'mcp-server', landingKind: 'catalog', target: 'external skill catalog', guidance: 'Catalog only until inspected for project fit and safety.' }),
     mapping({ capabilityId: 'claude-code-best-practice.workflow-guidance', sourceId: 'claude-code-best-practice', sourceGroup: 'mcp-server', landingKind: 'skill', target: 'peaks-rd', skillName: 'peaks-rd', guidance: 'Use as Claude Code workflow reference while preserving Peaks gates.' }),

package/dist/services/recommendations/capability-seed-sources.js

@@ -15,7 +15,6 @@ export const seedCapabilitySources = [
     { sourceId: 'impeccable', sourceType: 'repo', sourceGroup: 'mcp-server', title: 'impeccable', url: 'https://github.com/pbakaus/impeccable', discoveryStatus: 'unscanned', items: ['impeccable.quality-guidance'] },
     { sourceId: 'vercel-agent-skills', sourceType: 'skills-package', sourceGroup: 'mcp-server', title: 'Vercel Agent Skills', url: 'https://github.com/vercel-labs/agent-skills', discoveryStatus: 'unscanned', items: ['vercel-agent-skills.skill-pack'] },
     { sourceId: 'agent-browser', sourceType: 'repo', sourceGroup: 'mcp-server', title: 'Agent Browser', url: 'https://github.com/vercel-labs/agent-browser', discoveryStatus: 'indexed', items: ['agent-browser.browser-agent'] },
-    { sourceId: 'minimax-skills', sourceType: 'skills-package', sourceGroup: 'mcp-server', title: 'MiniMax Skills', url: 'https://github.com/MiniMax-AI/skills', discoveryStatus: 'indexed', items: ['minimax-skills.worker-guidance'] },
     { sourceId: 'claude-mem', sourceType: 'repo', sourceGroup: 'mcp-server', title: 'claude-mem', url: 'https://github.com/thedotmack/claude-mem', discoveryStatus: 'indexed', items: ['claude-mem.memory-persistence'] },
     { sourceId: 'darwin-skill', sourceType: 'skills-package', sourceGroup: 'mcp-server', title: 'darwin-skill', url: 'https://github.com/alchaincyf/darwin-skill', discoveryStatus: 'unscanned', items: ['darwin-skill.external-skill'] },
     { sourceId: 'claude-code-best-practice', sourceType: 'repo', sourceGroup: 'mcp-server', title: 'Claude Code Best Practice', url: 'https://github.com/shanraisshan/claude-code-best-practice', discoveryStatus: 'indexed', items: ['claude-code-best-practice.workflow-guidance'] },

package/dist/services/release/version-precheck-service.d.ts

@@ -0,0 +1,51 @@
+/**
+ * rid-010 — peaks release precheck (Phase 4 slice 1).
+ *
+ * Module path: src/services/release/version-precheck-service.ts
+ * Mirror of publish.yml gate-cli-version step §(A). The §(B) tarball-content gate
+ * (Layer 5 of the 5-layer root cause) stays CI-only — AC-7 grep test pins
+ * publish.yml so §(B) cannot drift silently.
+ *
+ * 4-layer version precheck mirroring publish.yml gate-cli-version step. Designed
+ * to run BEFORE `peaks release canary` so developers catch CLI_VERSION lag /
+ * tag collision / changeset staged / workspace drift without waiting for CI.
+ *
+ * Mirrors the §(A) on-disk gate from publish.yml. The §(B) tarball-content gate
+ * (Layer 5 of the 5-layer root cause) stays CI-only — AC-7 grep test pins
+ * publish.yml so §(B) cannot drift silently.
+ *
+ * Design contract:
+ *   - Pure functions. NO `process.exitCode` mutation here (cli-helpers owns it).
+ *   - All I/O parameterized via `projectRoot`.
+ *   - Layer A and B are blockers by default; C and D are warnings (--strict
+ *     upgrades them to blockers; hotfix path uses default warning).
+ */
+export type LayerStatus = 'ok' | 'warning' | 'blocker';
+export interface LayerResult {
+    readonly status: LayerStatus;
+    readonly message: string;
+    readonly remediation: string;
+    readonly observed?: Readonly<Record<string, unknown>>;
+}
+export interface PrecheckOptions {
+    readonly projectRoot: string;
+    readonly strict?: boolean;
+}
+export interface PrecheckEnvelope {
+    readonly ok: boolean;
+    readonly overall: LayerStatus;
+    readonly rootVersion: string;
+    readonly strict: boolean;
+    readonly snapshotAt: string;
+    readonly layers: {
+        readonly rootVsShared: LayerResult;
+        readonly tagCollision: LayerResult;
+        readonly changesetStaged: LayerResult;
+        readonly workspaceLockstep: LayerResult;
+    };
+}
+export declare function runRootVsShared(opts: PrecheckOptions): LayerResult;
+export declare function runTagCollision(opts: PrecheckOptions): LayerResult;
+export declare function runChangesetStaged(opts: PrecheckOptions): LayerResult;
+export declare function runWorkspaceLockstep(opts: PrecheckOptions): LayerResult;
+export declare function runAllLayers(opts: PrecheckOptions): PrecheckEnvelope;