principles-disciple 1.7.5 → 1.7.8

package/dist/core/evolution-reducer.js

@@ -6,6 +6,7 @@ import { PathResolver } from './path-resolver.js';
 import { SystemLogger } from './system-logger.js';
 import { shouldIgnorePainProtocolText } from './dictionary.js';
 import { TrajectoryRegistry } from './trajectory.js';
+import { isCompleteDetectorMetadata } from './evolution-types.js';
 const PROBATION_SUCCESS_THRESHOLD = 3;
 const CIRCUIT_BREAKER_THRESHOLD = 3;
 const PROBATION_MAX_AGE_DAYS = 30;
@@ -147,15 +148,45 @@ export class EvolutionReducerImpl {
             SystemLogger.log(this.workspaceDir, 'PRINCIPLE_BLACKLISTED', `Principle creation blocked by blacklist for trigger: "${params.triggerPattern.slice(0, 50)}..."`);
             return null;
         }
+        // Evaluability defaults to 'manual_only' — the only way to get auto-trainable
+        // is to explicitly provide valid detectorMetadata.
+        // Enforce: deterministic/weak_heuristic requires complete detectorMetadata to be present.
+        let evaluability = params.evaluability ?? 'manual_only';
+        if (evaluability !== 'manual_only' && !isCompleteDetectorMetadata(params.detectorMetadata)) {
+            SystemLogger.log(this.workspaceDir, 'EVALUABILITY_DOWNGRADED', `Principle for painId "${params.painId}" requested evaluability="${evaluability}" without detectorMetadata — downgrading to "manual_only". Provide valid detectorMetadata to enable auto-training.`);
+            evaluability = 'manual_only';
+        }
         // Check if a principle already exists for this painId
         const existingPrinciple = [...this.principles.values()].find(p => p.source.painId === params.painId);
         if (existingPrinciple) {
-            // Update existing principle instead of creating new one
+            // Update existing principle instead of creating new one.
+            // Apply the same evaluability normalization as new creation:
+            // deterministic/weak_heuristic without detectorMetadata → downgraded to manual_only.
             existingPrinciple.trigger = params.triggerPattern;
             existingPrinciple.action = params.action;
             existingPrinciple.text = `When ${params.triggerPattern}, then ${params.action}.`;
             existingPrinciple.version += 1;
-            SystemLogger.log(this.workspaceDir, 'PRINCIPLE_UPDATED', `Principle ${existingPrinciple.id} updated from diagnostician: "${params.triggerPattern.slice(0, 50)}..."`);
+            if (params.evaluability !== undefined) {
+                // Apply normalization (params.evaluability may be invalid without complete metadata)
+                const normalizedEvaluability = (() => {
+                    if (params.evaluability === 'manual_only' || isCompleteDetectorMetadata(params.detectorMetadata)) {
+                        return params.evaluability;
+                    }
+                    SystemLogger.log(this.workspaceDir, 'EVALUABILITY_DOWNGRADED', `Principle update for painId "${params.painId}" requested evaluability="${params.evaluability}" without detectorMetadata — downgrading to "manual_only".`);
+                    return 'manual_only';
+                })();
+                existingPrinciple.evaluability = normalizedEvaluability;
+            }
+            // Preserve detectorMetadata unless explicitly provided in this call.
+            // Accept only if complete (defense in depth — subagent should already filter).
+            if (isCompleteDetectorMetadata(params.detectorMetadata)) {
+                existingPrinciple.detectorMetadata = structuredClone(params.detectorMetadata);
+            }
+            else if (params.detectorMetadata !== undefined) {
+                // Malformed metadata provided — clear any existing metadata
+                existingPrinciple.detectorMetadata = undefined;
+            }
+            SystemLogger.log(this.workspaceDir, 'PRINCIPLE_UPDATED', `Principle ${existingPrinciple.id} updated from diagnostician: "${params.triggerPattern.slice(0, 50)}..." [evaluability: ${existingPrinciple.evaluability}]`);
             return existingPrinciple.id;
         }
         // Create new principle with generalized content
@@ -178,6 +209,10 @@ export class EvolutionReducerImpl {
             feedbackScore: 0,
             usageCount: 0,
             createdAt: now,
+            evaluability,
+            detectorMetadata: isCompleteDetectorMetadata(params.detectorMetadata)
+                ? structuredClone(params.detectorMetadata)
+                : undefined,
         };
         this.principles.set(principleId, principle);
         this.emitSync({
@@ -185,15 +220,20 @@ export class EvolutionReducerImpl {
             type: 'candidate_created',
             data: {
                 painId: principle.source.painId,
+                painType: params.painType,
                 principleId,
                 trigger: params.triggerPattern,
                 action: params.action,
                 status: 'candidate',
+                evaluability,
+                detectorMetadata: isCompleteDetectorMetadata(params.detectorMetadata)
+                    ? structuredClone(params.detectorMetadata)
+                    : undefined,
             },
         });
         // Auto-promote since it's already generalized
         this.promote(principleId, 'diagnostician_generalized');
-        SystemLogger.log(this.workspaceDir, 'PRINCIPLE_CREATED', `Principle ${principleId} created from diagnostician: "${params.triggerPattern.slice(0, 50)}..."`);
+        SystemLogger.log(this.workspaceDir, 'PRINCIPLE_CREATED', `Principle ${principleId} created from diagnostician: "${params.triggerPattern.slice(0, 50)}..." [evaluability: ${evaluability}]`);
         return principleId;
     }
     getStats() {
@@ -260,6 +300,13 @@ export class EvolutionReducerImpl {
         const existing = this.principles.get(data.principleId);
         if (existing) {
             existing.status = 'candidate';
+            // Apply evaluability from event if present (supports event replay)
+            if (data.evaluability) {
+                existing.evaluability = data.evaluability;
+            }
+            if (data.detectorMetadata) {
+                existing.detectorMetadata = structuredClone(data.detectorMetadata);
+            }
             return;
         }
         const principle = {
@@ -268,7 +315,7 @@ export class EvolutionReducerImpl {
             text: `When ${data.trigger}, then ${data.action}.`,
             source: {
                 painId: data.painId,
-                painType: 'tool_failure',
+                painType: data.painType ?? 'tool_failure',
                 timestamp: ts,
             },
             trigger: data.trigger,
@@ -279,6 +326,11 @@ export class EvolutionReducerImpl {
             feedbackScore: 0,
             usageCount: 0,
             createdAt: ts,
+            // Evaluability defaults to 'manual_only' for replayed events without the field
+            evaluability: data.evaluability ?? 'manual_only',
+            detectorMetadata: data.detectorMetadata
+                ? structuredClone(data.detectorMetadata)
+                : undefined,
         };
         this.principles.set(principle.id, principle);
     }

package/dist/core/evolution-types.d.ts

@@ -8,10 +8,10 @@
  * - 5级成长路径：Seed → Forest
  */
 export declare enum EvolutionTier {
-    Seed = 1,// 萌芽：只读 + 基础文档
-    Sprout = 2,// 新芽：单文件编辑 (<50行)
-    Sapling = 3,// 幼苗：多文件 + 测试 + 子智能体
-    Tree = 4,// 大树：重构 + 风险路径
+    Seed = 1,// 起步：150行 + 3文件 + 子智能体（现代 AI 能力已足够强）
+    Sprout = 2,// 成长：300行 + 5文件
+    Sapling = 3,// 独当：500行 + 10文件 + 风险路径
+    Tree = 4,// 专家：1000行 + 20文件
     Forest = 5
 }
 export interface TierPermissions {
@@ -91,11 +91,6 @@ export interface EvolutionConfig {
         tier5Trivial: number;
         tier5Normal: number;
     };
-    /** 信任分系统双轨运行时的配置 */
-    dualTrack: {
-        enabled: boolean;
-        primarySystem: 'trust' | 'evolution';
-    };
 }
 export declare const DEFAULT_EVOLUTION_CONFIG: EvolutionConfig;
 export interface ArchivedEventStats {
@@ -125,6 +120,45 @@ export interface TierPromotionEvent {
     newPermissions: TierPermissions;
 }
 export type PrincipleStatus = 'candidate' | 'probation' | 'active' | 'deprecated';
+/**
+ * Evaluability classification — determines whether a P_xxx principle can enter
+ * automatic nocturnal targeting.
+ *
+ * - deterministic:    Machine-checkable via deterministic rules/tool detectors
+ * - weak_heuristic:  Checkable via heuristic signals, may have false positives
+ * - manual_only:     No machine-checkable detector — stays in prompts only
+ */
+export type PrincipleEvaluatorLevel = 'deterministic' | 'weak_heuristic' | 'manual_only';
+/**
+ * Shared alias for PrincipleEvaluatorLevel — used by modules that reference
+ * the same evaluability classification without direct coupling to evolution-types.
+ * @deprecated Use PrincipleEvaluatorLevel directly. This alias exists for
+ * backwards compatibility with principle-training-state.ts.
+ */
+export type Evaluability = PrincipleEvaluatorLevel;
+/**
+ * Structured detector metadata for P_xxx principles.
+ * Allows the principle to enter automatic nocturnal targeting.
+ *
+ * If any required field is missing, the principle defaults to 'manual_only'.
+ */
+export interface PrincipleDetectorSpec {
+    /** Topic/scenario tags where this detector applies */
+    applicabilityTags: string[];
+    /** Evidence that the principle was followed */
+    positiveSignals: string[];
+    /** Evidence that the principle was violated */
+    negativeSignals: string[];
+    /** Tool call sequences that indicate the principle is relevant */
+    toolSequenceHints: string[][];
+    /** Confidence in the detector's signal quality */
+    confidence: 'high' | 'medium' | 'low';
+}
+/**
+ * Validates that a detector metadata object has all required fields with non-empty values.
+ * Used as defense-in-depth before accepting detectorMetadata for auto-trainable principles.
+ */
+export declare function isCompleteDetectorMetadata(meta: unknown): meta is PrincipleDetectorSpec;
 export interface Principle {
     id: string;
     version: number;
@@ -148,6 +182,18 @@ export interface Principle {
     createdAt: string;
     activatedAt?: string;
     deprecatedAt?: string;
+    /**
+     * Evaluability classification. Defaults to 'manual_only' if not set.
+     * Principles with 'manual_only' evaluability cannot enter automatic
+     * nocturnal targeting.
+     */
+    evaluability: PrincipleEvaluatorLevel;
+    /**
+     * Structured detector metadata. If present and valid, the principle
+     * may be auto-trainable (deterministic / weak_heuristic).
+     * Absent or malformed = 'manual_only' evaluability.
+     */
+    detectorMetadata?: PrincipleDetectorSpec;
 }
 export type EvolutionLoopEventType = 'pain_detected' | 'candidate_created' | 'principle_promoted' | 'principle_deprecated' | 'principle_rolled_back' | 'circuit_breaker_opened' | 'legacy_import';
 export interface PainDetectedData {
@@ -167,6 +213,12 @@ export interface CandidateCreatedData {
     trigger: string;
     action: string;
     status: 'candidate';
+    /** Pain type that generated this candidate — preserved on replay */
+    painType?: 'tool_failure' | 'subagent_error' | 'user_frustration';
+    /** Optional evaluability — defaults to 'manual_only' if omitted */
+    evaluability?: PrincipleEvaluatorLevel;
+    /** Optional detector metadata — absent = manual_only */
+    detectorMetadata?: PrincipleDetectorSpec;
 }
 export interface PrinciplePromotedData {
     principleId: string;

package/dist/core/evolution-types.js

@@ -14,13 +14,19 @@ export var EvolutionTier;
     EvolutionTier[EvolutionTier["Sprout"] = 2] = "Sprout";
     EvolutionTier[EvolutionTier["Sapling"] = 3] = "Sapling";
     EvolutionTier[EvolutionTier["Tree"] = 4] = "Tree";
-    EvolutionTier[EvolutionTier["Forest"] = 5] = "Forest"; // 森林：完全自主
+    EvolutionTier[EvolutionTier["Forest"] = 5] = "Forest"; // 大师：完全自主
 })(EvolutionTier || (EvolutionTier = {}));
 export const TIER_DEFINITIONS = [
-    { tier: EvolutionTier.Seed, name: 'Seed', requiredPoints: 0, permissions: { maxLinesPerWrite: 20, maxFilesPerTask: 1, allowRiskPath: false, allowSubagentSpawn: false } },
-    { tier: EvolutionTier.Sprout, name: 'Sprout', requiredPoints: 50, permissions: { maxLinesPerWrite: 50, maxFilesPerTask: 2, allowRiskPath: false, allowSubagentSpawn: false } },
-    { tier: EvolutionTier.Sapling, name: 'Sapling', requiredPoints: 200, permissions: { maxLinesPerWrite: 200, maxFilesPerTask: 5, allowRiskPath: false, allowSubagentSpawn: true } },
-    { tier: EvolutionTier.Tree, name: 'Tree', requiredPoints: 500, permissions: { maxLinesPerWrite: 500, maxFilesPerTask: 10, allowRiskPath: true, allowSubagentSpawn: true } },
+    // 2026-03-28: 大幅放宽限制，现代 AI 能力已很强
+    // Seed: 从 20 行提升到 150 行，允许 3 文件，允许子智能体
+    { tier: EvolutionTier.Seed, name: 'Seed', requiredPoints: 0, permissions: { maxLinesPerWrite: 150, maxFilesPerTask: 3, allowRiskPath: false, allowSubagentSpawn: true } },
+    // Sprout: 中等规模开发
+    { tier: EvolutionTier.Sprout, name: 'Sprout', requiredPoints: 50, permissions: { maxLinesPerWrite: 300, maxFilesPerTask: 5, allowRiskPath: false, allowSubagentSpawn: true } },
+    // Sapling: 较大规模开发，可访问风险路径（需 PLAN）
+    { tier: EvolutionTier.Sapling, name: 'Sapling', requiredPoints: 200, permissions: { maxLinesPerWrite: 500, maxFilesPerTask: 10, allowRiskPath: true, allowSubagentSpawn: true } },
+    // Tree: 大型重构
+    { tier: EvolutionTier.Tree, name: 'Tree', requiredPoints: 500, permissions: { maxLinesPerWrite: 1000, maxFilesPerTask: 20, allowRiskPath: true, allowSubagentSpawn: true } },
+    // Forest: 完全自主
     { tier: EvolutionTier.Forest, name: 'Forest', requiredPoints: 1000, permissions: { maxLinesPerWrite: Infinity, maxFilesPerTask: Infinity, allowRiskPath: true, allowSubagentSpawn: true } },
 ];
 export function getTierDefinition(tier) {
@@ -49,8 +55,24 @@ export const DEFAULT_EVOLUTION_CONFIG = {
         tier5Trivial: 0.1,
         tier5Normal: 0.5,
     },
-    dualTrack: {
-        enabled: true,
-        primarySystem: 'evolution',
-    },
 };
+/**
+ * Validates that a detector metadata object has all required fields with non-empty values.
+ * Used as defense-in-depth before accepting detectorMetadata for auto-trainable principles.
+ */
+export function isCompleteDetectorMetadata(meta) {
+    if (!meta || typeof meta !== 'object')
+        return false;
+    const m = meta;
+    const VALID_CONFIDENCE = ['high', 'medium', 'low'];
+    if (typeof m.confidence !== 'string' ||
+        !VALID_CONFIDENCE.includes(m.confidence)) {
+        return false;
+    }
+    const nonEmptyStringArray = (arr) => Array.isArray(arr) &&
+        arr.length > 0 &&
+        arr.every((s) => typeof s === 'string' && s.length > 0);
+    return (nonEmptyStringArray(m.applicabilityTags) &&
+        nonEmptyStringArray(m.positiveSignals) &&
+        nonEmptyStringArray(m.negativeSignals));
+}

package/dist/core/external-training-contract.d.ts

@@ -0,0 +1,276 @@
+/**
+ * External Training Contract — Normalized Experiment Spec and Result Schema
+ * ========================================================================
+ *
+ * PURPOSE: Define the stable contract between the plugin and external trainer
+ * backends. The plugin produces a constrained experiment specification that an
+ * external trainer consumes. The trainer returns a normalized result that the
+ * plugin can register, evaluate, and gate for rollout.
+ *
+ * ARCHITECTURE:
+ *   - Plugin is responsible for creating the experiment spec
+ *   - Plugin is responsible for validating the trainer result
+ *   - Plugin is responsible for registering lineage (train run → checkpoint → eval)
+ *   - Plugin is responsible for invoking benchmark evaluation
+ *   - Plugin is responsible for invoking promotion gate logic
+ *   - Plugin is responsible for binding deployment only after gate approval
+ *
+ * DESIGN CONSTRAINTS:
+ *   - ORPO-first: trainingMode must be 'orpo' for production runs
+ *   - No real training inside the plugin
+ *   - No direct deployment promotion from trainer output
+ *   - No direct trainer writes to review/eval/deployment state
+ *   - Backend-pluggable: same contract works for all backends
+ *
+ * CONTRACT GOALS:
+ *   - support ORPO training for approved nocturnal exports
+ *   - support multiple backend implementations behind one schema
+ *   - preserve dataset / config / checkpoint lineage
+ *   - remain valid on consumer hardware
+ *   - fail closed when inputs are incomplete or inconsistent
+ */
+/**
+ * Allowed backend identifiers.
+ *
+ * - `peft-trl-orpo`: primary reference implementation using PEFT + TRL ORPO
+ * - `unsloth-orpo`: compatible accelerated implementation using Unsloth
+ * - `dry-run`: validates paths/spec/environment only, no real training
+ */
+export type TrainerBackendKind = 'peft-trl-orpo' | 'unsloth-orpo' | 'dry-run';
+/**
+ * Hardware tier for training.
+ *
+ * - `consumer-gpu`: RTX 4090 24GB or equivalent (production target)
+ * - `small-gpu`: 8GB-16GB VRAM (compatibility target)
+ * - `cpu-experimental`: CPU-only experimental runs (dry-run or tiny models only)
+ */
+export type HardwareTier = 'consumer-gpu' | 'small-gpu' | 'cpu-experimental';
+/**
+ * Worker profiles supported for training.
+ *
+ * Phase 7 first rollout: `local-reader` only.
+ * `local-editor` requires explicit human approval to enable.
+ */
+export type TrainableWorkerProfile = 'local-reader' | 'local-editor';
+/**
+ * Training mode — Phase 7 production is ORPO-only.
+ */
+export type TrainingMode = 'orpo';
+/**
+ * Hyperparameters for ORPO training.
+ */
+export interface TrainingHyperparameters {
+    learningRate: number;
+    batchSize: number;
+    gradientAccumulation: number;
+    loraRank: number;
+    loraAlpha: number;
+    loraDropout: number;
+    warmupRatio: number;
+    maxSteps: number;
+    maxSeqLength: number;
+}
+/**
+ * Budget constraints for a training experiment.
+ */
+export interface TrainingBudget {
+    maxWallClockMinutes: number;
+    maxTrainTokens?: number;
+}
+/**
+ * Expected artifact from a successful training run.
+ */
+export interface ExpectedArtifact {
+    checkpointName: string;
+    adapterFormat: 'peft-adapter';
+}
+/**
+ * The experiment specification sent to an external trainer.
+ * This defines WHAT to train, not HOW to train (backend-specific).
+ */
+export interface TrainingExperimentSpec {
+    /** Unique identifier for this experiment */
+    experimentId: string;
+    /** Which backend to use */
+    backend: TrainerBackendKind;
+    /** Training mode — only 'orpo' is supported in Phase 7 */
+    trainingMode: TrainingMode;
+    /** Target worker profile for this experiment */
+    targetWorkerProfile: TrainableWorkerProfile;
+    /** Target model family to train */
+    targetModelFamily: string;
+    /** Hardware tier for this experiment */
+    hardwareTier: HardwareTier;
+    /** Reference to the ORPO export providing training data */
+    datasetExportId: string;
+    datasetExportPath: string;
+    /** Fingerprint of the dataset for lineage verification */
+    datasetFingerprint: string;
+    /** Reference to the benchmark export for eval */
+    benchmarkExportId: string;
+    /** Output directory for checkpoint artifacts */
+    outputDir: string;
+    /** Fingerprint of the training configuration */
+    configFingerprint: string;
+    /** Hash of the training code/contract version */
+    codeHash: string;
+    /** Training hyperparameters */
+    hyperparameters: TrainingHyperparameters;
+    /** Budget constraints */
+    budget: TrainingBudget;
+    /** Expected artifact from training */
+    expectedArtifact: ExpectedArtifact;
+}
+/**
+ * Training metrics recorded by the backend.
+ */
+export interface TrainingMetrics {
+    wallClockMinutes: number;
+    finalLoss?: number;
+    tokensSeen?: number;
+}
+/**
+ * Artifact produced by a successful training run.
+ */
+export interface TrainingArtifact {
+    adapterFormat: 'peft-adapter';
+    artifactPath: string;
+}
+/**
+ * Status of a training experiment.
+ */
+export type ExperimentStatus = 'completed' | 'failed' | 'dry_run';
+/**
+ * The result returned by an external trainer after execution.
+ * This defines the output contract — all backends must return the same shape.
+ */
+export interface TrainingExperimentResult {
+    /** Experiment ID (must match the spec's experimentId) */
+    experimentId: string;
+    /** Which backend was used */
+    backend: TrainerBackendKind;
+    /** Final status of the experiment */
+    status: ExperimentStatus;
+    /** Registered training run ID (plugin-side) */
+    trainRunId?: string;
+    /** Registered checkpoint ID (plugin-side) */
+    checkpointId?: string;
+    /** Checkpoint reference string (for lineage) */
+    checkpointRef?: string;
+    /** Target worker profile */
+    targetWorkerProfile: TrainableWorkerProfile;
+    /** Target model family */
+    targetModelFamily: string;
+    /** Dataset fingerprint (for lineage verification) */
+    datasetFingerprint: string;
+    /** Config fingerprint (for lineage verification) */
+    configFingerprint: string;
+    /** Code hash (for lineage verification) */
+    codeHash: string;
+    /** Training metrics */
+    metrics?: TrainingMetrics;
+    /** Produced artifact (only if status === 'completed') */
+    artifact?: TrainingArtifact;
+    /** Failure reason (only if status === 'failed') */
+    failureReason?: string;
+    /** ISO-8601 creation timestamp */
+    createdAt: string;
+}
+/**
+ * Validation error for trainer result verification.
+ */
+export interface ValidationError {
+    field: string;
+    expected: string;
+    actual: string;
+    reason: string;
+}
+/**
+ * Result of validating a trainer result against the experiment spec.
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+/**
+ * Validate that a trainer result matches the experiment spec.
+ *
+ * FAILS CLOSED on any mismatch — a checkpoint with invalid lineage must not
+ * be registered or promoted.
+ *
+ * Validation rules:
+ * 1. experimentId must match
+ * 2. backend must match
+ * 3. targetWorkerProfile must match
+ * 4. targetModelFamily must match
+ * 5. datasetFingerprint must match
+ * 6. configFingerprint must match
+ * 7. codeHash must match
+ * 8. dry-run must not produce a deployable checkpoint
+ *
+ * @param spec - The original experiment spec
+ * @param result - The trainer result to validate
+ * @returns ValidationResult indicating pass/fail and any errors
+ */
+export declare function validateTrainerResult(spec: TrainingExperimentSpec, result: TrainingExperimentResult): ValidationResult;
+/**
+ * Generate a fingerprint for a configuration object.
+ * Used for configFingerprint in the experiment spec.
+ */
+export declare function computeConfigFingerprint(config: Partial<TrainingHyperparameters>): string;
+/**
+ * Generate a fingerprint for a dataset export.
+ * Used for datasetFingerprint in the experiment spec.
+ *
+ * Combines file content hash with sampleCount to detect:
+ * - Content changes (file modified/replaced)
+ * - Sample count changes (different export)
+ *
+ * If the file cannot be read, falls back to path+count hash (legacy behavior).
+ */
+export declare function computeDatasetFingerprint(exportPath: string, sampleCount: number): string;
+/**
+ * Generate a code hash for the training contract version.
+ * Used for codeHash in the experiment spec.
+ *
+ * Hashes the actual contract source file content so any change to the
+ * contract produces a different hash, ensuring lineage integrity.
+ *
+ * Falls back to version string + timestamp if source cannot be read.
+ */
+export declare function computeCodeHash(): string;
+/**
+ * Generate a new experiment ID.
+ */
+export declare function generateExperimentId(): string;
+/**
+ * Validate that a hardware tier is appropriate for the backend.
+ *
+ * @param backend - The backend being used
+ * @param tier - The hardware tier
+ * @throws Error if the combination is not supported
+ */
+export declare function validateHardwareTier(backend: TrainerBackendKind, tier: HardwareTier): void;
+/**
+ * Get the default hardware tier for a backend.
+ */
+export declare function getDefaultHardwareTier(backend: TrainerBackendKind): HardwareTier;
+/**
+ * Valid model family patterns for local-reader profile.
+ * Used for family validation in the training contract.
+ */
+export declare const READER_FAMILY_PATTERNS: string[];
+/**
+ * Valid model family patterns for local-editor profile.
+ * Used for family validation in the training contract.
+ */
+export declare const EDITOR_FAMILY_PATTERNS: string[];
+/**
+ * Check if a model family is valid for a worker profile.
+ */
+export declare function isValidModelFamilyForProfile(family: string, profile: TrainableWorkerProfile): boolean;
+/**
+ * Phase 7 first rollout is limited to local-reader.
+ * This flag controls whether local-editor is allowed.
+ */
+export declare const LOCAL_EDITOR_ENABLED = false;