principles-disciple 1.8.1 → 1.8.2

package/dist/core/thinking-models.js

@@ -1,170 +0,0 @@
-const THINKING_MODELS = [
-    {
-        id: 'T-01',
-        name: 'Survey Before Acting',
-        description: 'Understand the structure first before making changes.',
-        baselineScenarios: ['exploration', 'discovery'],
-        patterns: [
-            /let me (first )?(understand|map|outline|survey|review the (structure|architecture|dependencies))/i,
-            /before (changing|editing|touching) anything/i,
-            /让我先(梳理|理解|看看|盘点).*(结构|架构|依赖|全貌)/i,
-        ],
-    },
-    {
-        id: 'T-02',
-        name: 'Respect Constraints',
-        description: 'Explicitly reason about contracts, tests, schemas, and requirements.',
-        baselineScenarios: ['constraint-check', 'contract-verification'],
-        patterns: [
-            /(type|test|contract|schema|interface) (constraint|requirement|check|validation)/i,
-            /we (must|need to) (respect|follow|adhere to) the/i,
-            /(必须|需要).*(遵守|符合|满足).*(类型|测试|契约|接口|规范)/i,
-        ],
-    },
-    {
-        id: 'T-03',
-        name: 'Evidence Over Assumption',
-        description: 'Use logs, code, and outputs before inferring causes.',
-        baselineScenarios: ['evidence-gathering', 'verification'],
-        patterns: [
-            /based on (the |this )?(evidence|logs?|output|error|stack trace|test result)/i,
-            /let me (check|verify|confirm|read|look at) (the |)(actual|source|code|file|log)/i,
-            /根据(日志|证据|输出|报错|堆栈|测试结果)/i,
-        ],
-    },
-    {
-        id: 'T-04',
-        name: 'Reversible First',
-        description: 'Prefer changes that are safe to roll back when risk is high.',
-        baselineScenarios: ['risk-management', 'reversibility'],
-        patterns: [
-            /this (is|would be) (irreversible|destructive|permanent|not easily undone)/i,
-            /(reversible|can be undone|safely roll back)/i,
-            /(不可逆|破坏性|无法回滚|可以回滚|安全撤销)/i,
-        ],
-    },
-    {
-        id: 'T-05',
-        name: 'Safety Rails',
-        description: 'Call out guardrails, prohibitions, and failure-prevention constraints.',
-        baselineScenarios: ['guardrails', 'safety-rails'],
-        patterns: [
-            /we (must|should) (not|never|avoid|prevent|ensure we don't)/i,
-            /(critical|important) (not to|that we don't|to avoid)/i,
-            /(绝不能|必须避免|不可|禁止|确保不会)/i,
-        ],
-    },
-    {
-        id: 'T-06',
-        name: 'Simplicity First',
-        description: 'Prefer the smallest understandable solution over over-engineering.',
-        baselineScenarios: ['simplification', 'pragmatism'],
-        patterns: [
-            /(simpl(er|est|ify)|minimal|straightforward|lean) (approach|solution|fix|implementation)/i,
-            /(simple is better|keep it simple|no need to over)/i,
-            /(最简|更简单|精简|没必要过度设计)/i,
-        ],
-    },
-    {
-        id: 'T-07',
-        name: 'Minimal Change Surface',
-        description: 'Limit the blast radius and touch only what is necessary.',
-        baselineScenarios: ['minimal-diff', 'blast-radius-control'],
-        patterns: [
-            /(minimal|smallest|narrowest|least) (change|diff|modification|impact)/i,
-            /only (change|modify|touch|edit) (the |what)/i,
-            /(最小改动|最小变更|只改|只动必要部分)/i,
-        ],
-    },
-    {
-        id: 'T-08',
-        name: 'Pain As Signal',
-        description: 'Treat failures and friction as clues to step back and rethink.',
-        baselineScenarios: ['reflection', 'pain-response'],
-        patterns: [
-            /this (error|failure|issue) (tells us|indicates|signals|suggests|means)/i,
-            /let me (stop|pause|step back|reconsider|rethink)/i,
-            /这个(错误|失败|问题).*(说明|意味着|提示)/i,
-            /让我(停下|暂停|退一步|重新考虑|重新审视)/i,
-        ],
-    },
-    {
-        id: 'T-09',
-        name: 'Divide And Conquer',
-        description: 'Split the task into smaller phases before execution.',
-        baselineScenarios: ['decomposition', 'phased-execution'],
-        patterns: [
-            /(break|split|decompose|divide) (this |the task |it )?(into|down)/i,
-            /(step 1|first,? (we|i|let's)|phase 1)/i,
-            /(拆分|分解|分步|分阶段|第一步)/i,
-        ],
-    },
-];
-export const THINKING_MODEL_MAP = new Map(THINKING_MODELS.map((model) => [model.id, model]));
-export function listThinkingModels() {
-    return THINKING_MODELS.slice();
-}
-export function getThinkingModel(modelId) {
-    return THINKING_MODEL_MAP.get(modelId);
-}
-export function detectThinkingModelMatches(text) {
-    if (!text)
-        return [];
-    const matches = [];
-    for (const model of THINKING_MODELS) {
-        for (const pattern of model.patterns) {
-            if (pattern.test(text)) {
-                matches.push({
-                    modelId: model.id,
-                    matchedPattern: pattern.source,
-                });
-                break;
-            }
-        }
-    }
-    return matches;
-}
-export function deriveThinkingScenarios(modelId, context) {
-    const scenarios = new Set(getThinkingModel(modelId)?.baselineScenarios ?? []);
-    if ((context.recentToolCalls ?? []).some((call) => call.outcome === 'failure')) {
-        scenarios.add('after-tool-failure');
-    }
-    // after-recovery: success that follows a failure (not just any success)
-    const calls = context.recentToolCalls ?? [];
-    const hasFailure = calls.some((call) => call.outcome === 'failure');
-    const hasSuccess = calls.some((call) => call.outcome === 'success');
-    if (hasFailure && hasSuccess) {
-        scenarios.add('after-recovery');
-    }
-    if ((context.recentToolCalls ?? []).some((call) => call.outcome === 'blocked')) {
-        scenarios.add('blocked-execution');
-    }
-    if ((context.recentToolCalls ?? []).some((call) => Boolean(call.errorType))) {
-        scenarios.add('incident-response');
-    }
-    if ((context.recentPainEvents ?? []).length > 0) {
-        scenarios.add('user-friction');
-    }
-    if ((context.recentGateBlocks ?? []).length > 0) {
-        scenarios.add('gate-block');
-    }
-    if ((context.recentUserCorrections ?? []).length > 0) {
-        scenarios.add('user-correction');
-    }
-    if ((context.recentPrincipleEvents ?? []).length > 0) {
-        scenarios.add('principle-feedback');
-    }
-    if (modelId === 'T-03') {
-        scenarios.add('root-cause-analysis');
-    }
-    if (modelId === 'T-04' || modelId === 'T-05') {
-        scenarios.add('risk-review');
-    }
-    if (modelId === 'T-08') {
-        scenarios.add('reflection-loop');
-    }
-    if (modelId === 'T-09') {
-        scenarios.add('task-planning');
-    }
-    return Array.from(scenarios);
-}

package/dist/core/training-program.d.ts

@@ -1,233 +0,0 @@
-/**
- * Training Program — Orchestrates External Training Execution and Lineage
- * =========================================================================
- *
- * PURPOSE: Coordinate the training workflow from experiment spec creation
- * through checkpoint registration and eval attachment.
- *
- * ARCHITECTURE:
- *   - TrainingProgram orchestrates the workflow but does NOT execute training itself
- *   - External trainer backends (Python scripts) do the actual training
- *   - Training run, checkpoint, and eval lineage is registered in model-training-registry
- *   - Promotion gate (promotion-gate.ts) controls deployment readiness
- *
- * WORKFLOW:
- *   1. Create experiment spec (TrainingProgram.createExperiment)
- *   2. Execute external trainer (TrainingProgram.executeTrainer)
- *   3. Validate trainer result against spec (validateTrainerResult)
- *   4. Register training run (model-training-registry)
- *   5. Register checkpoint (model-training-registry)
- *   6. Attach eval summary after benchmark (model-training-registry)
- *   7. Promotion gate controls deployment readiness
- *
- * DESIGN CONSTRAINTS:
- *   - ORPO-first: only 'orpo' training mode
- *   - No training inside the plugin runtime
- *   - No direct deployment binding from trainer output
- *   - Trainer backends are fire-and-forget (plugin does not poll trainer)
- *   - All lineage must be traceable through model-training-registry
- */
-import { type TrainingExperimentSpec, type TrainingExperimentResult, type TrainerBackendKind, type TrainableWorkerProfile, type HardwareTier, type TrainingHyperparameters, type TrainingBudget } from './external-training-contract.js';
-/**
- * Default hyperparameters for ORPO training.
- * These are conservative defaults for consumer GPU (RTX 4090 24GB).
- */
-export declare const DEFAULT_ORPO_HYPERPARAMETERS: TrainingHyperparameters;
-/**
- * Default budget for training runs.
- */
-export declare const DEFAULT_BUDGET: TrainingBudget;
-/**
- * Parameters for creating a training experiment.
- */
-export interface CreateExperimentParams {
-    /** Target worker profile */
-    targetWorkerProfile: TrainableWorkerProfile;
-    /** Target model family */
-    targetModelFamily: string;
-    /** Hardware tier */
-    hardwareTier?: HardwareTier;
-    /** Backend to use */
-    backend: TrainerBackendKind;
-    /** Dataset export ID */
-    datasetExportId: string;
-    /** Dataset export path */
-    datasetExportPath: string;
-    /** Dataset fingerprint */
-    datasetFingerprint: string;
-    /** Benchmark export ID */
-    benchmarkExportId: string;
-    /** Output directory for checkpoints */
-    outputDir: string;
-    /** Custom hyperparameters (optional) */
-    hyperparameters?: Partial<TrainingHyperparameters>;
-    /** Custom budget (optional) */
-    budget?: Partial<TrainingBudget>;
-}
-/**
- * Result of creating an experiment.
- */
-export interface CreateExperimentResult {
-    /** The experiment specification */
-    spec: TrainingExperimentSpec;
-    /** The registered training run ID */
-    trainRunId: string;
-}
-/**
- * Create a new training experiment.
- *
- * This creates the experiment spec and registers a training run in the registry.
- *
- * @param stateDir - Workspace state directory
- * @param params - Experiment parameters
- * @returns Created experiment spec and registered training run ID
- *
- * @throws Error if worker profile is not allowed (local-editor not yet enabled)
- * @throws Error if model family is not valid for the worker profile
- * @throws Error if hardware tier is not valid for the backend
- */
-export declare function createExperiment(stateDir: string, params: CreateExperimentParams): CreateExperimentResult;
-/**
- * Parameters for executing an external trainer.
- */
-export interface ExecuteTrainerParams {
-    /** The experiment specification */
-    spec: TrainingExperimentSpec;
-    /** Path to the trainer scripts directory */
-    scriptsDir?: string;
-}
-/**
- * Execute an external trainer backend.
- *
- * This function:
- * 1. Validates the trainer script exists
- * 2. Serializes the experiment spec to JSON
- * 3. Invokes the Python backend
- * 4. Returns the trainer's parsed result
- *
- * The trainer protocol:
- * - stdout: MUST contain only the machine-readable JSON result (TrainingExperimentResult)
- * - stderr: Contains training progress logs (ignored by plugin)
- * - result file: Written to output dir as backup if stdout parsing fails
- *
- * NOTE: This is a fire-and-forget execution. The plugin does not poll
- * the trainer. For Phase 7, trainer execution is assumed to be synchronous
- * or to complete before this function returns.
- *
- * @param spec - The experiment specification
- * @param scriptsDir - Override for the scripts directory
- * @returns The trainer's result as parsed JSON object
- *
- * @throws Error if the trainer script is not found
- * @throws Error if trainer execution fails
- * @throws Error if result cannot be parsed
- */
-export declare function executeTrainer(spec: TrainingExperimentSpec, scriptsDir?: string): Promise<import('./external-training-contract.js').TrainingExperimentResult>;
-/**
- * Parameters for processing a trainer result.
- */
-export interface ProcessTrainerResultParams {
-    /** The original experiment specification */
-    spec: TrainingExperimentSpec;
-    /** The training run ID from registry */
-    trainRunId: string;
-    /** The trainer's result (parsed) */
-    result: TrainingExperimentResult;
-    /** Workspace state directory */
-    stateDir: string;
-}
-/**
- * Process a trainer result:
- * 1. Validate result against spec
- * 2. Register checkpoint in training registry
- * 3. Return checkpoint for eval attachment
- *
- * @param params - Processing parameters
- * @returns The registered checkpoint, or null for dry_run (no checkpoint produced)
- *
- * @throws Error if validation fails
- * @throws Error if checkpoint registration fails
- */
-export declare function processTrainerResult(params: ProcessTrainerResultParams): {
-    checkpointId: string;
-    checkpointRef: string;
-} | null;
-/**
- * The TrainingProgram class orchestrates the complete training workflow.
- *
- * Usage:
- * ```typescript
- * const program = new TrainingProgram(stateDir);
- *
- * // Create experiment
- * const { spec, trainRunId } = program.createExperiment({
- *   backend: 'peft-trl-orpo',
- *   targetWorkerProfile: 'local-reader',
- *   targetModelFamily: 'qwen2.5-7b-reader',
- *   datasetExportId: 'export-123',
- *   datasetExportPath: '.state/exports/orpo/export-123.jsonl',
- *   datasetFingerprint: 'abc123',
- *   benchmarkExportId: 'benchmark-456',
- *   outputDir: '.state/nocturnal/checkpoints',
- * });
- *
- * // Execute trainer (external)
- * const trainerOutput = await executeTrainer(spec);
- *
- * // Process result
- * const { checkpointId } = program.processResult({
- *   spec,
- *   trainRunId,
- *   result: JSON.parse(trainerOutput),
- * });
- *
- * // Attach eval (after benchmark runs)
- * program.attachEval(checkpointId, evalSummary);
- * ```
- */
-export declare class TrainingProgram {
-    private readonly stateDir;
-    constructor(stateDir: string);
-    /**
-     * Create a new training experiment.
-     */
-    createExperiment(params: CreateExperimentParams): CreateExperimentResult;
-    /**
-     * Process a trainer result and register the checkpoint.
-     * Returns null for dry_run (no checkpoint produced).
-     */
-    processResult(params: {
-        spec: TrainingExperimentSpec;
-        trainRunId: string;
-        result: TrainingExperimentResult;
-    }): {
-        checkpointId: string;
-        checkpointRef: string;
-    } | null;
-    /**
-     * Attach an eval summary to a checkpoint and mark it deployable if eval passes.
-     *
-     * @param checkpointId - The checkpoint to attach eval to
-     * @param evalSummary - The eval summary (from benchmark run)
-     * @returns The updated checkpoint
-     */
-    attachEvalAndMarkDeployable(checkpointId: string, evalSummary: {
-        evalId: string;
-        checkpointId: string;
-        benchmarkId: string;
-        targetModelFamily: string;
-        mode: 'prompt_assisted' | 'reduced_prompt';
-        baselineScore: number;
-        candidateScore: number;
-        delta: number;
-        verdict: 'pass' | 'fail' | 'compare_only';
-    }): void;
-    /**
-     * Get checkpoint lineage for audit.
-     */
-    getCheckpointLineage(checkpointId: string): {
-        run: import("./model-training-registry.js").TrainingRun;
-        checkpoint: import("./model-training-registry.js").Checkpoint;
-        eval: import("./model-training-registry.js").EvalSummary | null;
-    } | null;
-}