peaks-loop 4.0.0-beta.2 → 4.0.0-beta.21

package/dist/src/services/workflow/plan-trigger-detector.js

@@ -1,142 +0,0 @@
-/**
- * `peaks workflow plan detect-trigger` — slice 025 (Security + Perf
- * Plan/Result split).
- *
- * Compares the current project state (filesystem + package.json) to the
- * last-refresh fingerprint and returns whether a plan refresh is
- * warranted. Five trigger rules, locked decision 1 excludes
- * devDependencies.
- *
- * The slice's "diff" is supplied as a `SliceDiff` object; when not
- * supplied, the detector scans the project directly (the same scan the
- * refresh plan performs).
- */
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { fail, ok } from '../../shared/result.js';
-/** F-1 (slice 025 security): canonical request-id shape. */
-export const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
-const SENSITIVE_SERVICE_DIRS = ['auth', 'security', 'secrets', 'payments', 'filesystem'];
-function readPackageJson(projectRoot) {
-    const path = join(projectRoot, 'package.json');
-    if (!existsSync(path))
-        return null;
-    try {
-        return JSON.parse(readFileSync(path, 'utf8'));
-    }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-        return null;
-    }
-}
-function isAuthFile(path) {
-    return /auth.*\.ts$|\.ts$/i.test(path) && /auth/i.test(path);
-}
-function isHotPathFile(path) {
-    return /router\.ts$|commands\/.*-commands\.ts$/i.test(path);
-}
-function isSensitiveServiceFile(path) {
-    if (!/^src\/services\/(auth|security|secrets|payments|filesystem)\//.test(path))
-        return false;
-    return /\.ts$/.test(path);
-}
-function freshScan(projectRoot) {
-    const pkg = readPackageJson(projectRoot);
-    const newFiles = [];
-    const root = join(projectRoot, 'src');
-    if (existsSync(root)) {
-        const stack = [root];
-        while (stack.length > 0) {
-            const dir = stack.pop();
-            if (dir === undefined)
-                continue;
-            let entries;
-            try {
-                entries = readdirSync(dir, { withFileTypes: true });
-            }
-            catch {
-                continue;
-            }
-            for (const entry of entries) {
-                if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'dist')
-                    continue;
-                const full = join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    stack.push(full);
-                }
-                else if (entry.isFile() && entry.name.endsWith('.ts')) {
-                    // For the purposes of trigger detection, every TS file is a
-                    // candidate; the gate logic decides which class it falls into.
-                    newFiles.push(full);
-                }
-            }
-        }
-    }
-    return {
-        packageJson: {
-            dependencies: { added: Object.keys(pkg?.dependencies ?? {}), removed: [], changed: [] },
-            optionalDependencies: { added: Object.keys(pkg?.optionalDependencies ?? {}), removed: [], changed: [] },
-            devDependencies: { added: Object.keys(pkg?.devDependencies ?? {}), removed: [], changed: [] }
-        },
-        newFiles: newFiles.sort(),
-        changedFiles: []
-    };
-}
-function anyAddedDeps(diff) {
-    const dep = diff.packageJson?.dependencies?.added ?? [];
-    const opt = diff.packageJson?.optionalDependencies?.added ?? [];
-    return dep.length > 0 || opt.length > 0;
-}
-function findNewAuthFile(diff) {
-    for (const f of diff.newFiles ?? []) {
-        if (isAuthFile(f))
-            return f;
-    }
-    return null;
-}
-function findNewSensitiveServiceFile(diff) {
-    for (const f of diff.newFiles ?? []) {
-        if (isSensitiveServiceFile(f))
-            return f;
-    }
-    return null;
-}
-function findNewHotPathFile(diff) {
-    for (const f of diff.newFiles ?? []) {
-        if (isHotPathFile(f))
-            return f;
-    }
-    return null;
-}
-export function detectTrigger(args) {
-    // F-1 (slice 025 security): reject traversal/separator payloads at
-    // the service boundary so every caller (CLI, skill, integration test)
-    // gets the same rejection shape.
-    if (!REQUEST_ID_PATTERN.test(args.rid)) {
-        return fail('workflow.plan.detect-trigger', 'INVALID_RID', 'request id must match [A-Za-z0-9][A-Za-z0-9._-]*', {
-            triggered: false,
-            reason: 'no-triggering-change'
-        });
-    }
-    if (args.manualOverride === true) {
-        return ok('workflow.plan.detect-trigger', { triggered: true, reason: 'manual-override' });
-    }
-    const diff = args.diff ?? freshScan(args.project);
-    // Rule 1: new top-level dependency in `dependencies` or `optionalDependencies`
-    // (devDependencies explicitly excluded per locked decision 1).
-    if (anyAddedDeps(diff)) {
-        return ok('workflow.plan.detect-trigger', { triggered: true, reason: 'new-dependency' });
-    }
-    // Rule 2: new file under src/services/{auth,security,secrets,payments,filesystem}/
-    if (findNewSensitiveServiceFile(diff) !== null) {
-        return ok('workflow.plan.detect-trigger', { triggered: true, reason: 'auth-surface-added' });
-    }
-    // Rule 3: new *auth*.ts file anywhere in src/
-    if (findNewAuthFile(diff) !== null) {
-        return ok('workflow.plan.detect-trigger', { triggered: true, reason: 'auth-surface-added' });
-    }
-    // Rule 4: new endpoint / route registration
-    if (findNewHotPathFile(diff) !== null) {
-        return ok('workflow.plan.detect-trigger', { triggered: true, reason: 'hot-path-added' });
-    }
-    return ok('workflow.plan.detect-trigger', { triggered: false, reason: 'no-triggering-change' });
-}

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

@@ -1,85 +0,0 @@
-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 = 'code' | 'team';
-export type CodeMode = 'full-auto' | 'guided' | 'rnd';
-export type ModelTier = 'top-tier' | 'mid-tier';
-export type ModelRole = 'strongest' | 'execution';
-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;
-    codeMode?: CodeMode;
-    maxWorkers?: number;
-    dryRun: true;
-    artifactWorkspacePath?: string;
-    workspace?: WorkspaceConfig;
-    config?: {
-        economyMode?: boolean;
-        swarmMode?: boolean;
-        providers?: ModelProviderConfig;
-    };
-};
-export type WorkflowRouterStep = {
-    readonly id: string;
-    readonly stage: WorkflowStepStage;
-    readonly owner: WorkflowStepOwner;
-    readonly modelTier: ModelTier;
-    readonly modelRole: ModelRole;
-    readonly modelId: string;
-    readonly reason: string;
-    readonly dryRunOnly: true;
-    readonly invokesAgents: false;
-    readonly writesArtifacts: false;
-    readonly dependsOn: readonly string[];
-};
-export type WorkflowModelRouting = {
-    readonly strongestModel: {
-        readonly modelId: 'claude-opus-4-7';
-        readonly uses: readonly WorkflowStepStage[];
-    };
-    readonly executionModel: {
-        readonly modelId: string;
-        readonly uses: readonly WorkflowStepStage[];
-    };
-};
-export type WorkflowModelAssignment = {
-    readonly stage: WorkflowStepStage;
-    readonly owner: WorkflowStepOwner;
-    readonly modelTier: ModelTier;
-    readonly modelRole: ModelRole;
-    readonly modelId: string;
-};
-export type WorkflowModeStatus = {
-    readonly economyModeEnabled: boolean;
-    readonly swarmModeEnabled: boolean;
-    readonly executionModelId: string;
-    readonly executionModelSource: string;
-    readonly summary: string;
-};
-export type WorkflowRouterPlan = {
-    readonly sessionId: string;
-    readonly goal: string;
-    readonly mode: WorkflowMode;
-    readonly codeMode?: CodeMode;
-    readonly executionMode: 'autonomous';
-    readonly decisionProfile: string;
-    readonly dryRun: true;
-    readonly routePolicy: WorkflowRoutePolicy;
-    readonly modelRouting: WorkflowModelRouting;
-    readonly modelAssignments: readonly WorkflowModelAssignment[];
-    readonly modeStatus: WorkflowModeStatus;
-    readonly techStatus: TechStatus;
-    readonly techPlan: TechPlanResult;
-    readonly rdPlan: RdPlanResult;
-    readonly steps: readonly WorkflowRouterStep[];
-    readonly blockedReasons: readonly string[];
-    readonly nextActions: readonly string[];
-    readonly constraints: readonly string[];
-};
-export declare function isWorkflowMode(mode: string): mode is WorkflowMode;
-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

@@ -1,227 +0,0 @@
-import { getConfiguredExecutionModelId, STRONGEST_MODEL_ID } from '../config/model-routing.js';
-import { getLocalArtifactPath } from '../artifacts/workspace-service.js';
-import { createRdSwarmPlan } from '../rd/rd-service.js';
-import { createTechPlan, getTechStatus } from '../tech/tech-service.js';
-// Slice 2026-06-29-change-id-root-removal: `validateChangeIdOrThrow`
-// was removed with the change-id axis. Path-safety helpers now live
-// at `shared/path-safety.ts` if this module ever needs them.
-import { WORKSPACE_UNAVAILABLE_NEXT_ACTIONS } from '../../shared/planner-response.js';
-const WORKFLOW_CONSTRAINTS = Object.freeze([
-    'dry-run-only',
-    'requires-swarm-execution-for-rd-and-qa-when-enabled',
-    'execution-model-from-config-providers',
-    'do-not-launch-agents',
-    'do-not-write-artifacts',
-    'do-not-mutate-target-repo'
-]);
-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 === 'code' || mode === 'team';
-}
-function assertSupportedMode(mode) {
-    if (!isWorkflowMode(mode)) {
-        throw new Error('Unsupported workflow mode');
-    }
-}
-function normalizeGoal(goal) {
-    const normalized = goal.trim();
-    if (!normalized) {
-        throw new Error('Goal must be non-empty');
-    }
-    return normalized;
-}
-function assertCodeModeAllowed(mode, codeMode) {
-    if (mode !== 'code' && codeMode !== undefined) {
-        throw new Error('codeMode requires code workflow mode');
-    }
-}
-function step(input, executionModelId) {
-    const modelRole = EXECUTION_STAGES.includes(input.stage) ? 'execution' : 'strongest';
-    return {
-        ...input,
-        modelRole,
-        modelId: modelRole === 'execution' ? executionModelId : STRONGEST_MODEL_ID,
-        dryRunOnly: true,
-        invokesAgents: false,
-        writesArtifacts: false
-    };
-}
-export function isCodeMode(value) {
-    return value === 'full-auto' || value === 'guided' || value === 'rnd';
-}
-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 (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 (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, codeMode) {
-    const decisionStages = codeMode === 'guided'
-        ? GUIDED_DECISION_STAGES
-        : GOVERNED_DECISION_STAGES;
-    return steps.map((currentStep) => {
-        const isDecisionStage = decisionStages.includes(currentStep.stage);
-        const reasonPrefix = isDecisionStage
-            ? `[${codeMode}] decision stage`
-            : '[routed] execution stage';
-        return {
-            ...currentStep,
-            reason: `${reasonPrefix}: ${currentStep.reason}`
-        };
-    });
-}
-function createSoloSteps(executionModelId) {
-    return [
-        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(codeMode, executionModelId) {
-    return annotateSteps(createSoloSteps(executionModelId), codeMode);
-}
-function createTeamSteps(executionModelId) {
-    return [
-        step({ id: 'team-product-direction', stage: 'product-direction', owner: 'human', modelTier: 'top-tier', reason: 'Team product direction should stay on the governed planning path.', dependsOn: [] }, executionModelId),
-        step({ id: 'team-design-direction', stage: 'design-direction', owner: 'human', modelTier: 'top-tier', reason: 'Team design direction should preserve reviewability and accountability.', dependsOn: ['team-product-direction'] }, executionModelId),
-        step({ id: 'team-tech-direction', stage: 'tech-direction', owner: 'peaks-tech', modelTier: 'top-tier', reason: 'Team technical plans should remain strongly governed before RD execution.', dependsOn: ['team-design-direction'] }, executionModelId),
-        step({ id: 'team-tech-review', stage: 'tech-review', owner: 'peaks-tech', modelTier: 'top-tier', reason: 'Team tech approval requires strong review before execution.', dependsOn: ['team-tech-direction'] }, executionModelId),
-        step({ id: 'team-rd-planning', stage: 'rd-planning', owner: 'peaks-rd', modelTier: 'top-tier', reason: 'Team RD task decomposition remains on the governed strongest-model path.', dependsOn: ['team-tech-review'] }, executionModelId),
-        step({ id: 'team-coding-execution', stage: 'coding-execution', owner: 'peaks-rd', modelTier: executionModelId === STRONGEST_MODEL_ID ? 'top-tier' : 'mid-tier', reason: `Bounded coding tasks must use the configured execution worker model ${executionModelId}.`, dependsOn: ['team-rd-planning'] }, executionModelId),
-        step({ id: 'team-unit-test-execution', stage: 'unit-test-execution', owner: 'peaks-rd', modelTier: executionModelId === STRONGEST_MODEL_ID ? 'top-tier' : 'mid-tier', reason: `Unit-test tasks must use the configured execution worker model ${executionModelId}.`, dependsOn: ['team-coding-execution'] }, executionModelId),
-        step({ id: 'team-quality-review', stage: 'quality-review', owner: 'peaks-rd', modelTier: 'top-tier', reason: 'Team RD outputs still need reducer and quality review gates.', dependsOn: ['team-unit-test-execution'] }, executionModelId)
-    ];
-}
-function uniqueStrings(values) {
-    return [...new Set(values)];
-}
-function createModelRouting(steps, executionModelId) {
-    return {
-        strongestModel: {
-            modelId: STRONGEST_MODEL_ID,
-            uses: steps.filter((step) => step.modelRole === 'strongest').map((step) => step.stage)
-        },
-        executionModel: {
-            modelId: executionModelId,
-            uses: steps.filter((step) => step.modelRole === 'execution').map((step) => step.stage)
-        }
-    };
-}
-function createModelAssignments(steps) {
-    return steps.map((step) => ({
-        stage: step.stage,
-        owner: step.owner,
-        modelTier: step.modelTier,
-        modelRole: step.modelRole,
-        modelId: step.modelId
-    }));
-}
-function getTechPlanBlockedReasons(techPlan) {
-    return techPlan.available ? techPlan.blockedReasons : techPlan.preview.blockedReasons;
-}
-function getTechPlanNextActions(techPlan) {
-    return [...techPlan.nextActions];
-}
-function createModeStatus(economyMode, swarmMode, executionModelId, executionModelSource) {
-    const economySummary = economyMode
-        ? `Economy mode enabled: code worker and test worker strictly use ${executionModelId} from config providers.`
-        : `Economy mode disabled: code worker and test worker use ${STRONGEST_MODEL_ID}, matching planner/reviewer.`;
-    const swarmSummary = swarmMode
-        ? 'Swarm mode enabled: peaks-rd coding, unit-test, and peaks-qa quality work must be represented as swarm worker tasks.'
-        : 'Swarm mode disabled: swarm worker graph generation is bypassed.';
-    return {
-        economyModeEnabled: economyMode,
-        swarmModeEnabled: swarmMode,
-        executionModelId,
-        executionModelSource,
-        summary: `${economySummary} ${swarmSummary}`
-    };
-}
-function getCodeMode(mode, codeMode) {
-    if (mode !== 'code') {
-        return undefined;
-    }
-    if (codeMode === undefined) {
-        return 'full-auto';
-    }
-    if (!isCodeMode(codeMode)) {
-        throw new Error('Unsupported code mode');
-    }
-    return codeMode;
-}
-export function createWorkflowRouterPlan(request) {
-    assertSupportedMode(request.mode);
-    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);
-    const maxWorkers = request.maxWorkers ?? 40;
-    // Slice 2.0.1-bug1 round 3: project policy defaults. The slim 2.0.1 DEFAULT_CONFIG
-    // no longer carries economyMode / swarmMode (those moved to per-project preferences),
-    // so we cannot fall back to `DEFAULT_CONFIG.economyMode` / `swarmMode` here. Both
-    // flags are project-policy opt-outs: the absence of an explicit `false` means
-    // "enabled" (matches the pre-2.0.1 implicit default).
-    const economyMode = request.config?.economyMode ?? true;
-    const swarmMode = request.config?.swarmMode ?? true;
-    // Pre-2.0.1 DEFAULT_CONFIG carried an implicit `minimax-2.7` provider
-    // for test fixtures that did not pass `config.providers`. The slim
-    // DEFAULT_CONFIG removed that field, so we re-supply it here only when
-    // the caller did not pass any providers at all. An explicit empty
-    // object (`config: { providers: {} }`) still surfaces the "must be
-    // configured" error from `getConfiguredExecutionModelId`.
-    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 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 } : {}),
-        ...(request.workspace ? { workspace: request.workspace } : {})
-    };
-    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 = codeMode ? createSoloStepsForMode(codeMode, executionModelId) : createTeamSteps(executionModelId);
-    const blockedReasons = uniqueStrings([
-        ...techStatus.blockedReasons,
-        ...getTechPlanBlockedReasons(techPlan),
-        ...rdPlan.blockedReasons
-    ]);
-    const nextActions = blockedReasons.includes('artifact-workspace-unavailable')
-        ? [...WORKSPACE_UNAVAILABLE_NEXT_ACTIONS]
-        : uniqueStrings([...techStatus.nextActions, ...getTechPlanNextActions(techPlan), ...rdPlan.nextActions]);
-    return {
-        sessionId: request.sessionId,
-        goal,
-        mode: request.mode,
-        ...(codeMode ? { codeMode } : {}),
-        executionMode: 'autonomous',
-        decisionProfile,
-        dryRun: true,
-        routePolicy: request.mode === 'code' ? 'code-broad-multi-model' : 'team-rd-limited-multi-model',
-        modelRouting: createModelRouting(steps, executionModelId),
-        modelAssignments: createModelAssignments(steps),
-        modeStatus,
-        techStatus,
-        techPlan,
-        rdPlan,
-        steps,
-        blockedReasons,
-        nextActions,
-        constraints: [...WORKFLOW_CONSTRAINTS]
-    };
-}