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

package/dist/src/services/standards/loop-engineering-readiness-lint.js

@@ -0,0 +1,248 @@
+/**
+ * Loop Engineering Readiness linter (M6 — peak-spec §7.5 + §8.4).
+ *
+ * Pure function: takes the raw markdown text of a peaks-* SKILL.md
+ * file and returns either
+ *   { ok: true, findings: [] }
+ * or
+ *   { ok: false, findings: string[] }.
+ *
+ * The lint asserts three structural properties the spec binds every
+ * Loop-Engineering-participating peaks-* skill to:
+ *
+ *   1. The skill references the shared guideline file
+ *      `.peaks/standards/loop-engineering-guidelines.md` (or its
+ *      alias `.peaks/standards/loop-engineering-guidelines.md`).
+ *      Reference may appear anywhere in the body — code fence,
+ *      plain prose, or list item — as long as the literal token is
+ *      present.
+ *
+ *   2. The skill does NOT introduce a CLI verb that bypasses the
+ *      LLM-coordinated model. We flag lines that look like
+ *      "Run `peaks <verb>` to …" where `<verb>` is not in the
+ *      allowlist of LLM-owned sediment / asset / evolution verbs.
+ *      The user types NL; the LLM runs the CLI on the user's behalf
+ *      (RL-1 / Human-NL-Choice-Only).
+ *
+ *   3. The skill does NOT introduce a JSON / manifest
+ *      hand-authoring surface. We flag lines containing phrases
+ *      like "Edit the manifest", "write the JSON", "fill the JSON
+ *      file", etc., when they are not part of an explicit allowlist
+ *      (allowlist only references; never an instructional phrase).
+ *
+ * Each finding is a single line of the form:
+ *   "<rule>: <offending excerpt>"
+ * so a downstream CLI can render it directly without further
+ * parsing.
+ *
+ * The lint intentionally does NOT touch any application-level
+ * code; it only parses a SKILL.md text. The peaks CLI command
+ * `peaks skill lint --category loop-engineering-readiness
+ *   --path <skill-dir>`
+ * (registered in src/cli/commands/skill-loop-engineering-readiness.ts)
+ * reads the SKILL.md from disk and calls this function.
+ *
+ * Per RL-1 / Human-NL-Choice-Only and
+ * `.peaks/memory/two-forms-only-rule.md`, the user only ever picks
+ * via AskUserQuestion or describes in NL; the LLM runs the CLI.
+ * This lint is what stops a future peaks-* skill from regressing
+ * that rule at the textual layer.
+ */
+/**
+ * The shared guideline file that every Loop-Engineering-participating
+ * peaks-* skill must reference. Both the canonical path and the
+ * common alias are accepted.
+ *
+ * The alias is intentionally identical to the canonical path here:
+ * the spec sometimes renders it as
+ *   `.peaks/standards/loop-engineering-guidelines.md`
+ * with a slash prefix and sometimes without. We accept both.
+ */
+export const LOOP_ENGINEERING_GUIDELINE_PATHS = [
+    '.peaks/standards/loop-engineering-guidelines.md',
+];
+/**
+ * The allowlist of CLI verbs that a peaks-* SKILL.md may legitimately
+ * instruct an LLM to invoke on the user's behalf. These are the
+ * sediment / asset / evolution surface verbs introduced in
+ * 2026-07-07-loop-engineering-crystallization-design §7.4 plus the
+ * 18-verb sediment pool from 2026-07-04-peaks-maker-dynamic-skill-
+ * sediment-design §4.2.
+ *
+ * Any other `peaks <verb>` token that appears in the form
+ *   "Run `peaks <verb>` to …"
+ * is treated as a CLI-verb-bypass attempt and flagged.
+ */
+export const ALLOWED_CLI_VERBS = new Set([
+    // sediment pool verbs (M6 reference; peak-maker's owned surface)
+    'add-segment',
+    'add-bee',
+    'refine-bee',
+    'clone-bee',
+    'promote',
+    'retire',
+    'dispose',
+    'releases',
+    'release-show',
+    'release-diff',
+    'export',
+    'import',
+    'gc-blobs',
+    'list',
+    'show',
+    'search',
+    'recent',
+    'rebuild-index',
+    // loop crystallizer surface (§7.4)
+    'loop',
+    'crystallize',
+    // evolution ratchet surface (§7.4)
+    'evolution',
+    'propose',
+    'evaluate',
+    'revert',
+    'mark-keep',
+    // umbrella asset surface (§7.4)
+    'asset',
+    'status',
+    // adapter surface (peaks-maker's owned skill runtime)
+    'adapter',
+    // lint surface (this command's own kind)
+    'lint',
+    'standards',
+    'skill',
+    'ready',
+]);
+/**
+ * Phrases that constitute a JSON / manifest hand-authoring surface.
+ * If a SKILL.md instructs the user to perform one of these actions,
+ * it violates RL-1 / Human-NL-Choice-Only and is flagged.
+ *
+ * Each entry is a lowercase substring matched against each line of
+ * the SKILL.md. The match is case-insensitive; the surrounding
+ * `<verb>` placeholders in the original spec are matched literally.
+ */
+export const JSON_HAND_AUTHORING_PHRASES = [
+    'edit the manifest',
+    'edit your manifest',
+    'edit the json',
+    'edit the .json file',
+    'write the json',
+    'write the json manifest',
+    'write the manifest json',
+    'fill the json',
+    'fill in the json',
+    'fill in the manifest',
+    'fill in the manifest.json',
+    'hand-author the manifest',
+    'hand-author the json',
+    'open the manifest and',
+    'open the manifest.json and',
+    'manually edit the manifest',
+    'manually edit the json',
+];
+/**
+ * Phrases that explicitly reference a JSON / manifest surface but
+ * in an ALLOWED way — e.g. "the manifest is written by the CLI" or
+ * "see manifest schema for details". A line that contains one of
+ * these allowlisted phrases is NOT flagged even if it contains a
+ * JSON-hand-authoring phrase elsewhere on the same line.
+ *
+ * The allowlist is intentionally narrow; it must mention either
+ * the CLI as the writer OR a schema reference, NOT an instructional
+ * verb targeting the user.
+ */
+export const JSON_REFERENCE_ALLOWLIST = [
+    'the cli writes',
+    'written by the cli',
+    'written by peaks',
+    'manifest schema',
+    'see the manifest schema',
+    'see manifest schema',
+    'schema_version',
+    'peaks.bundle/1',
+    'peaks.loop/1',
+    'peaks.bee/1',
+];
+// ---------------------------------------------------------------------------
+// Pure function
+// ---------------------------------------------------------------------------
+/**
+ * Lint a SKILL.md text for Loop Engineering readiness.
+ *
+ * @param skillMdText raw markdown text of a peaks-* SKILL.md
+ * @returns a ReadinessLintResult
+ */
+export function lintSkillLoopEngineeringReadiness(skillMdText) {
+    const findings = [];
+    if (typeof skillMdText !== 'string' || skillMdText.trim().length === 0) {
+        return {
+            ok: false,
+            findings: ['skill-md-empty: SKILL.md text is empty or missing'],
+        };
+    }
+    checkGuidelineReference(skillMdText, findings);
+    checkCliVerbBypass(skillMdText, findings);
+    checkJsonHandAuthoring(skillMdText, findings);
+    if (findings.length > 0) {
+        return { ok: false, findings };
+    }
+    return { ok: true, findings: [] };
+}
+// ---------------------------------------------------------------------------
+// Individual checks
+// ---------------------------------------------------------------------------
+function checkGuidelineReference(text, findings) {
+    // Strip code fences before checking — references inside ``` blocks
+    // are still valid references (the lint accepts them), but we strip
+    // so the substring match is unambiguous.
+    const stripped = text;
+    for (const ref of LOOP_ENGINEERING_GUIDELINE_PATHS) {
+        if (stripped.includes(ref)) {
+            return;
+        }
+    }
+    findings.push(`missing-guideline-reference: SKILL.md must reference ${LOOP_ENGINEERING_GUIDELINE_PATHS[0]} (spec §7.5 / §8.4 / RL-8)`);
+}
+function checkCliVerbBypass(text, findings) {
+    // Match lines that contain `peaks <verb>` in a run-this-command
+    // pattern: "Run `peaks <verb>` to …" or "`peaks <verb>` to …" or
+    // "use `peaks <verb>` to …".
+    //
+    // The regex is intentionally narrow: it requires backticks around
+    // `peaks <verb>` so prose that mentions "peaks <verb>" as a noun
+    // (e.g. "peaks skill sediment list") is not flagged. The verb
+    // token is captured as the first `[a-z][a-z0-9-]*` chunk after
+    // "peaks "; everything between the verb and the closing backtick
+    // is allowed (e.g. `peaks custom-evolve my-bee` — verb is
+    // "custom-evolve", args are "my-bee").
+    const lineRegex = /^\s*[-*]?\s*(?:Run|Use|Type|Execute)\s+`peaks\s+([a-z][a-z0-9-]*)[^`]*`/gim;
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        let m;
+        lineRegex.lastIndex = 0;
+        while ((m = lineRegex.exec(line)) !== null) {
+            const verb = m[1];
+            if (!ALLOWED_CLI_VERBS.has(verb)) {
+                const excerpt = line.trim().slice(0, 120);
+                findings.push(`cli-verb-bypass: line ${i + 1} introduces CLI verb \`peaks ${verb}\` to be typed by the user (${excerpt}) — only LLM-coordinated verbs from the sediment/asset/evolution surface are allowed (RL-1)`);
+            }
+        }
+    }
+}
+function checkJsonHandAuthoring(text, findings) {
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lowered = line.toLowerCase();
+        const matchedPhrase = JSON_HAND_AUTHORING_PHRASES.find((p) => lowered.includes(p));
+        if (!matchedPhrase)
+            continue;
+        const isAllowlisted = JSON_REFERENCE_ALLOWLIST.some((p) => lowered.includes(p));
+        if (isAllowlisted)
+            continue;
+        const excerpt = line.trim().slice(0, 120);
+        findings.push(`json-hand-authoring: line ${i + 1} introduces JSON / manifest hand-authoring surface ("${matchedPhrase}") — ${excerpt} (RL-1: user only picks or describes in NL)`);
+    }
+}

package/dist/src/services/upgrade/1x-detector-service.js

@@ -2,7 +2,7 @@
  * 1.x → 2.0 detection service — TypeScript mirror of
  * `scripts/install-skills.mjs:detect1xProjectState`.
  *
- * Slice: 2026-06-12-solo-step-0-55-1x-detection.
+ * Slice: 2026-06-12-code-step-0-55-1x-detection.
  *
  * The canonical implementation lives in the .mjs postinstall
  * (because the postinstall runs before any TS compile step).

package/dist/src/services/workflow/pipeline-verify-service.d.ts

@@ -63,7 +63,7 @@ export type PipelineVerification = {
      */
     gateH?: 'pass' | 'fail';
     /**
-     * Slice 2026-06-28-solo-mode-bypass-fix (defect #3): `true` when
+     * Slice 2026-06-28-code-mode-bypass-fix (defect #3): `true` when
      * every evidence file resolved on the canonical path
      * (`.peaks/_runtime/change/<sessionId>/...`). `false` when at least
      * one evidence file resolved via a legacy fallback (`.peaks/<sessionId>/...`

package/dist/src/services/workflow/pipeline-verify-service.js

@@ -26,7 +26,7 @@ async function findRequestFile(projectRoot, role, rid) {
     const artifact = await showRequestArtifact({ projectRoot, role: role, requestId: rid });
     if (artifact === null)
         return null;
-    // Slice 2026-06-28-solo-mode-bypass-fix (defect #3): the legacy
+    // Slice 2026-06-28-code-mode-bypass-fix (defect #3): the legacy
     // `showRequestArtifact` returns the FULL SCOPE (`_runtime/<sid>`)
     // as `sessionId`, not just the trailing id segment. The canonical
     // evidence lookup needs only the bare id (`.peaks/_runtime/change/<id>/`).
@@ -158,7 +158,7 @@ export async function verifyPipeline(options) {
     // preferred filesystem scope; falling through to `options.rid` would
     // make every missing-evidence path look like a per-rid scope dir.
     const rdEvidenceDir = resolvedChangeId || options.sessionId || getSessionIdCanonical(options.projectRoot) || options.rid;
-    // Slice 2026-06-28-solo-mode-bypass-fix (defect #3): track whether
+    // Slice 2026-06-28-code-mode-bypass-fix (defect #3): track whether
     // every resolved evidence file landed on the canonical path. Drives
     // the `usedCanonicalPath` envelope field. The flag stays `true` if
     // no evidence file was resolved at all (nothing to be non-canonical
@@ -410,7 +410,7 @@ export async function verifyPipeline(options) {
                 : 'suffixed';
     const gateC = allQaGatesPassed ? 'pass' : 'fail';
     const gateH = allFeedbackGatesPassed ? 'pass' : 'fail';
-    // Slice 2026-06-28-solo-mode-bypass-fix (defect #3): `true` when
+    // Slice 2026-06-28-code-mode-bypass-fix (defect #3): `true` when
     // every gate resolved on the canonical path; `false` when at least
     // one fell back to a legacy form. QA / TXT surface the value so the
     // user knows the legacy content must be moved into the canonical

package/dist/src/services/workflow/workflow-autonomous-service.d.ts

@@ -1,7 +1,7 @@
 import type { CapabilityItemType } from '../recommendations/recommendation-types.js';
 import type { ModelProviderConfig, WorkspaceConfig } from '../config/config-types.js';
 import { type RdPlanResult } from '../rd/rd-service.js';
-import { type SoloMode, type WorkflowMode, type WorkflowRouterPlan } from './workflow-router-service.js';
+import { type CodeMode, type WorkflowMode, type WorkflowRouterPlan } from './workflow-router-service.js';
 export { getResumeRequiredArtifacts, getResumeArtifactsStatus, createResumePlan } from './workflow-autonomous-resume-helpers.js';
 export type CapabilitySurface = 'skill' | 'mcp' | 'plugin' | 'expert';
 export type CapabilityPurpose = 'code-review' | 'security-review' | 'coding-standards' | 'docs-lookup' | 'browser-validation' | 'browser-debug' | 'design-context' | 'design-source' | 'code-search' | 'database-inspection' | 'browser-agent' | 'worker-guidance' | 'memory' | 'context-management' | 'ui-components' | 'spec-workflow' | 'repo-intelligence' | 'openspec' | 'workflow-methodology' | 'workflow-reference' | 'workflow-guidance' | 'product-guidance' | 'design-reference' | 'ui-reference' | 'engineering-guidance' | 'typescript-guidance' | 'quality-guidance' | 'skill-pack' | 'external-skill' | 'design-critique' | 'design-guidance' | 'cloud-skill-pack';
@@ -20,7 +20,7 @@ export type CapabilityCandidate = {
 };
 export type AutonomousWorkflowRequest = {
     readonly mode: WorkflowMode;
-    readonly soloMode?: SoloMode;
+    readonly codeMode?: CodeMode;
     readonly sessionId: string;
     readonly goal: string;
     readonly maxWorkers?: number;
@@ -68,7 +68,7 @@ export type AutonomousStoragePlan = {
 };
 export type AutonomousMvpPackage = {
     readonly mode: WorkflowMode;
-    readonly soloMode: SoloMode | undefined;
+    readonly codeMode: CodeMode | undefined;
     readonly executionMode: 'preview';
     readonly dryRun: true;
     readonly routePolicy: WorkflowRouterPlan['routePolicy'];

package/dist/src/services/workflow/workflow-autonomous-service.js

@@ -205,7 +205,7 @@ function createCapabilityPlan(request) {
 function createMvpPackage(request, routePlan, rdPlan, capabilityPlan, ready) {
     return {
         mode: request.mode,
-        soloMode: routePlan.soloMode,
+        codeMode: routePlan.codeMode,
         executionMode: 'preview',
         dryRun: true,
         routePolicy: routePlan.routePolicy,
@@ -240,7 +240,7 @@ export function createAutonomousWorkflowPlan(request) {
     const available = hasArtifactWorkspace(request, artifactWorkspacePath);
     const routePlan = createWorkflowRouterPlan({
         mode: request.mode,
-        ...(request.soloMode !== undefined ? { soloMode: request.soloMode } : {}),
+        ...(request.codeMode !== undefined ? { codeMode: request.codeMode } : {}),
         sessionId: request.sessionId,
         goal,
         maxWorkers,

package/dist/src/services/workflow/workflow-router-service.d.ts

@@ -1,18 +1,18 @@
 import { type ModelProviderConfig, type WorkspaceConfig } from '../config/config-types.js';
 import { type RdPlanResult } from '../rd/rd-service.js';
 import { type TechPlanResult, type TechStatus } from '../tech/tech-service.js';
-export type WorkflowMode = 'solo' | 'team';
-export type SoloMode = 'full-auto' | 'guided' | 'rnd';
+export type WorkflowMode = 'code' | 'team';
+export type CodeMode = 'full-auto' | 'guided' | 'rnd';
 export type ModelTier = 'top-tier' | 'mid-tier';
 export type ModelRole = 'strongest' | 'execution';
-export type WorkflowRoutePolicy = 'solo-broad-multi-model' | 'team-rd-limited-multi-model';
+export type WorkflowRoutePolicy = 'code-broad-multi-model' | 'team-rd-limited-multi-model';
 export type WorkflowStepStage = 'product-direction' | 'design-direction' | 'tech-direction' | 'tech-review' | 'rd-planning' | 'coding-execution' | 'unit-test-execution' | 'quality-review';
 export type WorkflowStepOwner = 'peaks-code' | 'peaks-rd' | 'peaks-tech' | 'human';
 export type WorkflowRouterRequest = {
     sessionId: string;
     goal: string;
     mode: WorkflowMode;
-    soloMode?: SoloMode;
+    codeMode?: CodeMode;
     maxWorkers?: number;
     dryRun: true;
     artifactWorkspacePath?: string;
@@ -64,7 +64,7 @@ export type WorkflowRouterPlan = {
     readonly sessionId: string;
     readonly goal: string;
     readonly mode: WorkflowMode;
-    readonly soloMode?: SoloMode;
+    readonly codeMode?: CodeMode;
     readonly executionMode: 'autonomous';
     readonly decisionProfile: string;
     readonly dryRun: true;
@@ -81,5 +81,5 @@ export type WorkflowRouterPlan = {
     readonly constraints: readonly string[];
 };
 export declare function isWorkflowMode(mode: string): mode is WorkflowMode;
-export declare function isSoloMode(value: string): value is SoloMode;
+export declare function isCodeMode(value: string): value is CodeMode;
 export declare function createWorkflowRouterPlan(request: WorkflowRouterRequest): WorkflowRouterPlan;

package/dist/src/services/workflow/workflow-router-service.js

@@ -18,7 +18,7 @@ const EXECUTION_STAGES = ['coding-execution', 'unit-test-execution'];
 const GUIDED_DECISION_STAGES = ['product-direction', 'design-direction'];
 const GOVERNED_DECISION_STAGES = ['product-direction', 'design-direction', 'tech-direction', 'tech-review'];
 export function isWorkflowMode(mode) {
-    return mode === 'solo' || mode === 'team';
+    return mode === 'code' || mode === 'team';
 }
 function assertSupportedMode(mode) {
     if (!isWorkflowMode(mode)) {
@@ -32,9 +32,9 @@ function normalizeGoal(goal) {
     }
     return normalized;
 }
-function assertSoloModeAllowed(mode, soloMode) {
-    if (mode !== 'solo' && soloMode !== undefined) {
-        throw new Error('soloMode requires solo workflow mode');
+function assertCodeModeAllowed(mode, codeMode) {
+    if (mode !== 'code' && codeMode !== undefined) {
+        throw new Error('codeMode requires code workflow mode');
     }
 }
 function step(input, executionModelId) {
@@ -48,29 +48,29 @@ function step(input, executionModelId) {
         writesArtifacts: false
     };
 }
-export function isSoloMode(value) {
+export function isCodeMode(value) {
     return value === 'full-auto' || value === 'guided' || value === 'rnd';
 }
-function getDecisionProfileSummary(mode, soloMode) {
+function getDecisionProfileSummary(mode, codeMode) {
     if (mode === 'team') {
         return 'Team mode keeps product and design governance on a human-controlled path while RD execution follows recommended defaults.';
     }
-    if (soloMode === 'guided') {
+    if (codeMode === 'guided') {
         return 'Guided mode keeps the user in the decision loop for the early recommended defaults, while later execution remains bounded by the routing plan.';
     }
-    if (soloMode === 'rnd') {
+    if (codeMode === 'rnd') {
         return 'R&D mode asks for technical confirmation up front, then applies recommended defaults for implementation, testing, review, and safety checks.';
     }
     return 'Full-auto mode applies recommended defaults for product, design, and tech decisions, then runs the engineering pipeline end to end under routing gates.';
 }
-function annotateSteps(steps, soloMode) {
-    const decisionStages = soloMode === 'guided'
+function annotateSteps(steps, codeMode) {
+    const decisionStages = codeMode === 'guided'
         ? GUIDED_DECISION_STAGES
         : GOVERNED_DECISION_STAGES;
     return steps.map((currentStep) => {
         const isDecisionStage = decisionStages.includes(currentStep.stage);
         const reasonPrefix = isDecisionStage
-            ? `[${soloMode}] decision stage`
+            ? `[${codeMode}] decision stage`
             : '[routed] execution stage';
         return {
             ...currentStep,
@@ -80,18 +80,18 @@ function annotateSteps(steps, soloMode) {
 }
 function createSoloSteps(executionModelId) {
     return [
-        step({ id: 'solo-product-direction', stage: 'product-direction', owner: 'peaks-code', modelTier: 'top-tier', reason: 'Product direction needs strong judgment before execution work is delegated.', dependsOn: [] }, executionModelId),
-        step({ id: 'solo-design-direction', stage: 'design-direction', owner: 'peaks-code', modelTier: 'top-tier', reason: 'Design direction uses the recommended default before cheaper implementation work.', dependsOn: ['solo-product-direction'] }, executionModelId),
-        step({ id: 'solo-tech-direction', stage: 'tech-direction', owner: 'peaks-tech', modelTier: 'top-tier', reason: 'Technical boundaries and approval gates use the recommended default with high-confidence planning.', dependsOn: ['solo-design-direction'] }, executionModelId),
-        step({ id: 'solo-tech-review', stage: 'tech-review', owner: 'peaks-tech', modelTier: 'top-tier', reason: 'Tech artifacts and gate decisions require strong review and a recommended default path.', dependsOn: ['solo-tech-direction'] }, executionModelId),
-        step({ id: 'solo-rd-planning', stage: 'rd-planning', owner: 'peaks-rd', modelTier: 'top-tier', reason: 'RD task decomposition and acceptance criteria use the recommended default before execution delegation.', dependsOn: ['solo-tech-review'] }, executionModelId),
-        step({ id: 'solo-coding-execution', stage: 'coding-execution', owner: 'peaks-rd', modelTier: executionModelId === STRONGEST_MODEL_ID ? 'top-tier' : 'mid-tier', reason: `Coding and routine refactoring must use the configured execution worker model ${executionModelId}.`, dependsOn: ['solo-rd-planning'] }, executionModelId),
-        step({ id: 'solo-unit-test-execution', stage: 'unit-test-execution', owner: 'peaks-rd', modelTier: executionModelId === STRONGEST_MODEL_ID ? 'top-tier' : 'mid-tier', reason: `Unit test authoring and focused test runs must use the configured execution worker model ${executionModelId}.`, dependsOn: ['solo-coding-execution'] }, executionModelId),
-        step({ id: 'solo-quality-review', stage: 'quality-review', owner: 'peaks-code', modelTier: 'top-tier', reason: 'Reducer and final quality gates need strong synthesis and risk review.', dependsOn: ['solo-unit-test-execution'] }, executionModelId)
+        step({ id: 'code-product-direction', stage: 'product-direction', owner: 'peaks-code', modelTier: 'top-tier', reason: 'Product direction needs strong judgment before execution work is delegated.', dependsOn: [] }, executionModelId),
+        step({ id: 'code-design-direction', stage: 'design-direction', owner: 'peaks-code', modelTier: 'top-tier', reason: 'Design direction uses the recommended default before cheaper implementation work.', dependsOn: ['code-product-direction'] }, executionModelId),
+        step({ id: 'code-tech-direction', stage: 'tech-direction', owner: 'peaks-tech', modelTier: 'top-tier', reason: 'Technical boundaries and approval gates use the recommended default with high-confidence planning.', dependsOn: ['code-design-direction'] }, executionModelId),
+        step({ id: 'code-tech-review', stage: 'tech-review', owner: 'peaks-tech', modelTier: 'top-tier', reason: 'Tech artifacts and gate decisions require strong review and a recommended default path.', dependsOn: ['code-tech-direction'] }, executionModelId),
+        step({ id: 'code-rd-planning', stage: 'rd-planning', owner: 'peaks-rd', modelTier: 'top-tier', reason: 'RD task decomposition and acceptance criteria use the recommended default before execution delegation.', dependsOn: ['code-tech-review'] }, executionModelId),
+        step({ id: 'code-coding-execution', stage: 'coding-execution', owner: 'peaks-rd', modelTier: executionModelId === STRONGEST_MODEL_ID ? 'top-tier' : 'mid-tier', reason: `Coding and routine refactoring must use the configured execution worker model ${executionModelId}.`, dependsOn: ['code-rd-planning'] }, executionModelId),
+        step({ id: 'code-unit-test-execution', stage: 'unit-test-execution', owner: 'peaks-rd', modelTier: executionModelId === STRONGEST_MODEL_ID ? 'top-tier' : 'mid-tier', reason: `Unit test authoring and focused test runs must use the configured execution worker model ${executionModelId}.`, dependsOn: ['code-coding-execution'] }, executionModelId),
+        step({ id: 'code-quality-review', stage: 'quality-review', owner: 'peaks-code', modelTier: 'top-tier', reason: 'Reducer and final quality gates need strong synthesis and risk review.', dependsOn: ['code-unit-test-execution'] }, executionModelId)
     ];
 }
-function createSoloStepsForMode(soloMode, executionModelId) {
-    return annotateSteps(createSoloSteps(executionModelId), soloMode);
+function createSoloStepsForMode(codeMode, executionModelId) {
+    return annotateSteps(createSoloSteps(executionModelId), codeMode);
 }
 function createTeamSteps(executionModelId) {
     return [
@@ -150,21 +150,21 @@ function createModeStatus(economyMode, swarmMode, executionModelId, executionMod
         summary: `${economySummary} ${swarmSummary}`
     };
 }
-function getSoloMode(mode, soloMode) {
-    if (mode !== 'solo') {
+function getCodeMode(mode, codeMode) {
+    if (mode !== 'code') {
         return undefined;
     }
-    if (soloMode === undefined) {
+    if (codeMode === undefined) {
         return 'full-auto';
     }
-    if (!isSoloMode(soloMode)) {
-        throw new Error('Unsupported solo mode');
+    if (!isCodeMode(codeMode)) {
+        throw new Error('Unsupported code mode');
     }
-    return soloMode;
+    return codeMode;
 }
 export function createWorkflowRouterPlan(request) {
     assertSupportedMode(request.mode);
-    assertSoloModeAllowed(request.mode, request.soloMode);
+    assertCodeModeAllowed(request.mode, request.codeMode);
     // Slice 2026-06-29-change-id-root-removal: change-id is metadata-only;
     // no structural validation gate fires here.
     const goal = normalizeGoal(request.goal);
@@ -185,8 +185,8 @@ export function createWorkflowRouterPlan(request) {
     const effectiveProviders = request.config?.providers ?? { minimax: { model: 'minimax-2.7' } };
     const executionModelId = economyMode !== false ? getConfiguredExecutionModelId(effectiveProviders) : STRONGEST_MODEL_ID;
     const modeStatus = createModeStatus(economyMode, swarmMode, executionModelId, economyMode ? 'config.providers' : 'planner-reviewer-strongest-model');
-    const soloMode = getSoloMode(request.mode, request.soloMode);
-    const decisionProfile = getDecisionProfileSummary(request.mode, soloMode);
+    const codeMode = getCodeMode(request.mode, request.codeMode);
+    const decisionProfile = getDecisionProfileSummary(request.mode, codeMode);
     const artifactWorkspacePath = request.artifactWorkspacePath ?? (request.workspace ? getLocalArtifactPath(request.workspace) : undefined);
     const sharedWorkspaceOptions = {
         ...(artifactWorkspacePath ? { artifactWorkspacePath } : {}),
@@ -195,7 +195,7 @@ export function createWorkflowRouterPlan(request) {
     const techStatus = getTechStatus({ sessionId: request.sessionId, ...sharedWorkspaceOptions });
     const techPlan = createTechPlan({ sessionId: request.sessionId, goal, swarm: swarmMode, dryRun: true, ...sharedWorkspaceOptions });
     const rdPlan = createRdSwarmPlan({ skill: 'rd', sessionId: request.sessionId, goal, maxWorkers, swarmMode, executionModelId, dryRun: true, ...sharedWorkspaceOptions });
-    const steps = soloMode ? createSoloStepsForMode(soloMode, executionModelId) : createTeamSteps(executionModelId);
+    const steps = codeMode ? createSoloStepsForMode(codeMode, executionModelId) : createTeamSteps(executionModelId);
     const blockedReasons = uniqueStrings([
         ...techStatus.blockedReasons,
         ...getTechPlanBlockedReasons(techPlan),
@@ -208,11 +208,11 @@ export function createWorkflowRouterPlan(request) {
         sessionId: request.sessionId,
         goal,
         mode: request.mode,
-        ...(soloMode ? { soloMode } : {}),
+        ...(codeMode ? { codeMode } : {}),
         executionMode: 'autonomous',
         decisionProfile,
         dryRun: true,
-        routePolicy: request.mode === 'solo' ? 'solo-broad-multi-model' : 'team-rd-limited-multi-model',
+        routePolicy: request.mode === 'code' ? 'code-broad-multi-model' : 'team-rd-limited-multi-model',
         modelRouting: createModelRouting(steps, executionModelId),
         modelAssignments: createModelAssignments(steps),
         modeStatus,

package/dist/src/services/workspace/claude-settings-template.d.ts

@@ -51,7 +51,7 @@ export declare const CLAUDE_SETTINGS_LOCAL_FILENAME = ".claude/settings.local.js
  *           bypass is the only emit. Bash enforcement is owned by
  *           `peaks gate enforce` in `settings.json`.
  *   1.3.0 — added the v3.1.2 `Bash` PreToolUse matcher that runs
- *           `peaks solo gate-step-08 --project .` (Step 0.8 mechanical
+ *           `peaks code gate-step-08 --project .` (Step 0.8 mechanical
  *           gate). The existing Write|Edit|MultiEdit matcher is
  *           preserved. The new matcher's exit code is the load-bearing
  *           signal: 0 = allow, 2 = block (with stderr BLOCKED reason).

package/dist/src/services/workspace/claude-settings-template.js

@@ -51,7 +51,7 @@ export const CLAUDE_SETTINGS_LOCAL_FILENAME = '.claude/settings.local.json';
  *           bypass is the only emit. Bash enforcement is owned by
  *           `peaks gate enforce` in `settings.json`.
  *   1.3.0 — added the v3.1.2 `Bash` PreToolUse matcher that runs
- *           `peaks solo gate-step-08 --project .` (Step 0.8 mechanical
+ *           `peaks code gate-step-08 --project .` (Step 0.8 mechanical
  *           gate). The existing Write|Edit|MultiEdit matcher is
  *           preserved. The new matcher's exit code is the load-bearing
  *           signal: 0 = allow, 2 = block (with stderr BLOCKED reason).
@@ -216,7 +216,7 @@ export function buildClaudeSettingsLocalJson() {
                 },
                 {
                     // v3.1.2 Step 0.8 — Mechanical PreToolUse gate. Runs
-                    // `peaks solo gate-step-08 --project .` before every Bash
+                    // `peaks code gate-step-08 --project .` before every Bash
                     // tool call. Exit 0 = allow (with structured stdout
                     // describing the decision + optional `Next: slice #N+1 of
                     // M (<currentSlice>)` line when progress.json exists). Exit
@@ -235,7 +235,7 @@ export function buildClaudeSettingsLocalJson() {
     };
 }
 /**
- * v3.1.2: build the Bash matcher command that runs `peaks solo
+ * v3.1.2: build the Bash matcher command that runs `peaks code
  * gate-step-08`. We invoke the CLI directly (not via `node -e "..."`)
  * because the CLI is the only legitimate source of the structured
  * decision + Next: slice context. Exit code is the load-bearing
@@ -246,9 +246,9 @@ export function buildClaudeSettingsLocalJson() {
  */
 function buildBashGateStep08Command() {
     // The hook receives the tool call on stdin. We ignore stdin and
-    // delegate entirely to `peaks solo gate-step-08`, which reads
+    // delegate entirely to `peaks code gate-step-08`, which reads
     // .peaks/_runtime/<sessionId>/job-shape.json and last-prompt.txt.
     // `${CLAUDE_PROJECT_DIR}` resolves to the consumer project's root
     // (Claude Code's standard convention).
-    return 'peaks solo gate-step-08 --project "${CLAUDE_PROJECT_DIR}"';
+    return 'peaks code gate-step-08 --project "${CLAUDE_PROJECT_DIR}"';
 }

package/dist/src/shared/version.d.ts

@@ -1 +1 @@
-export declare const CLI_VERSION = "4.0.0-beta";
+export declare const CLI_VERSION = "4.0.0-beta.3";

package/dist/src/shared/version.js

@@ -1 +1 @@
-export const CLI_VERSION = "4.0.0-beta";
+export const CLI_VERSION = "4.0.0-beta.3";

package/examples/video-demo/README.md

@@ -0,0 +1,57 @@
+# peaks-loop video demo
+
+Remotion-based 30-second brand walk-through for peaks-loop 4.0. Mirrors `README.md`.
+
+## Composition
+
+- Two compositions, one per locale:
+  - `peaks-loop-demo`     — 30 seconds @ 30fps (900 frames), 1920×1080 — Chinese primary.
+  - `peaks-loop-demo-en`  — same frame budget, English primary.
+- Scene timeline (frozen in `src/Root.tsx`):
+  - 0–90    — **TitleScene** (`peaks-loop`, no ·, no emoji)
+  - 90–240  — **PhilosophyScene** — 5 hero philosophy items, bilingual
+  - 240–540 — **DemoScene × 3** — `写长任务代码` / `修 bug 当天发` / `接一个长跑的需求`
+  - 540–780 — **SedimentScene** — 3-beat `NL → MANIFEST → BEE`
+  - 780–900 — **ClosingScene** — `npm i -g peaks-loop` + repo-name vs skill-name arc + 5,439 tests stats
+
+## Visual style
+
+- Background: `#0f172a` (slate-900) via `bg-brand-bg`
+- Primary text: `#f8fafc` (slate-50) via `text-brand-fg`
+- Accent: `#6366f1` (indigo-500) via `text-brand-accent`
+- Stable badge: `#22c55e` (green-500)
+- Mono font for kickers / install chip / chat bubbles; sans font for headlines
+
+## Public preview files (tracked)
+
+The READMEs embed `<video>` tags that point at:
+
+- `preview/peaks-loop-demo.mp4`    (zh, 4.9 MB)
+- `preview/peaks-loop-demo-en.mp4` (en, 5.0 MB)
+
+These are produced by the render command below and committed to git so a clone (and the GitHub rendering) sees the same path. The shell snippet under **Render** keeps `preview/` in sync after a fresh build.
+
+## Render
+
+```bash
+cd examples/video-demo
+pnpm install
+npx remotion render peaks-loop-demo out/peaks-loop-demo.mp4
+npx remotion render peaks-loop-demo-en out/peaks-loop-demo-en.mp4
+
+mkdir -p preview
+cp out/peaks-loop-demo.mp4    preview/peaks-loop-demo.mp4
+cp out/peaks-loop-demo-en.mp4 preview/peaks-loop-demo-en.mp4
+```
+
+Fallback (no Chromium available):
+
+```bash
+npx remotion still peaks-loop-demo out/still.png --frame=120
+```
+
+## Preview during dev
+
+```bash
+npx remotion studio   # http://localhost:3000
+```