principles-disciple 1.72.0 → 1.74.0

package/src/core/nocturnal-rule-implementation-validator.ts

@@ -1,246 +0,0 @@
-import { createRuleHostHelpers, type RuleHostHelpers } from './rule-host-helpers.js';
-import { loadRuleImplementationModule } from './rule-implementation-runtime.js';
-import type {
-  RuleHostDecision,
-  RuleHostInput,
-  RuleHostMeta,
-  RuleHostResult,
-} from './rule-host-types.js';
-
-export interface RuleImplementationValidationFailure {
-  code:
-    | 'forbidden-api'
-    | 'compile-error'
-    | 'missing-meta'
-    | 'invalid-meta'
-    | 'missing-evaluate'
-    | 'invalid-result';
-  message: string;
-  detail?: string;
-}
-
-export interface RuleImplementationValidationResult {
-  passed: boolean;
-  failures: RuleImplementationValidationFailure[];
-  helperUsage: string[];
-  normalizedSource?: string;
-  meta?: RuleHostMeta;
-}
-
-const FORBIDDEN_PATTERNS: { pattern: RegExp; label: string }[] = [
-  { pattern: /\beval\s*\(/, label: 'eval' },
-  { pattern: /\bFunction\s*\(/, label: 'Function' },
-  { pattern: /\bimport\s*\(/, label: 'dynamic import' },
-  { pattern: /\brequire\s*\(/, label: 'require' },
-  { pattern: /\bfetch\s*\(/, label: 'fetch' },
-  { pattern: /\bXMLHttpRequest\b/, label: 'XMLHttpRequest' },
-  { pattern: /\bchild_process\b/, label: 'child_process' },
-  { pattern: /\bprocess\b/, label: 'process' },
-  { pattern: /\bfs\b/, label: 'fs' },
-  { pattern: /\bhttp\b/, label: 'http' },
-  { pattern: /\bhttps\b/, label: 'https' },
-  { pattern: /\bnet\b/, label: 'net' },
-];
-
-const HELPER_NAMES: (keyof RuleHostHelpers)[] = [
-  'isRiskPath',
-  'getToolName',
-  'getEstimatedLineChanges',
-  'getBashRisk',
-  'hasPlanFile',
-  'getPlanStatus',
-  'getCurrentEpiTier',
-];
-
-function createValidationInput(): RuleHostInput {
-  return {
-    action: {
-      toolName: 'write',
-      normalizedPath: 'src/risk.ts',
-      paramsSummary: {},
-    },
-    workspace: {
-      isRiskPath: true,
-      planStatus: 'DRAFT',
-      hasPlanFile: true,
-    },
-    session: {
-      sessionId: 'validator-session',
-      currentGfi: 3,
-      recentThinking: false,
-    },
-    evolution: {
-      epTier: 2,
-    },
-    derived: {
-      estimatedLineChanges: 42,
-      bashRisk: 'normal',
-    },
-  };
-}
-
-function extractHelperUsage(sourceCode: string): string[] {
-  return HELPER_NAMES.filter((helperName) =>
-    new RegExp(`\\bhelpers\\.${helperName}\\b|\\b${helperName}\\s*\\(`).test(sourceCode)
-  );
-}
-
-     
-function validateMeta(meta: unknown): RuleImplementationValidationFailure[] {
-  if (!meta || typeof meta !== 'object') {
-    return [
-      {
-        code: 'missing-meta',
-        message: 'Candidate must export a meta object.',
-      },
-    ];
-  }
-
-  const candidate = meta as Partial<RuleHostMeta>;
-  const failures: RuleImplementationValidationFailure[] = [];
-
-  if (typeof candidate.name !== 'string' || candidate.name.trim().length === 0) {
-    failures.push({
-      code: 'invalid-meta',
-      message: 'meta.name must be a non-empty string.',
-      detail: 'name',
-    });
-  }
-  if (typeof candidate.version !== 'string' || candidate.version.trim().length === 0) {
-    failures.push({
-      code: 'invalid-meta',
-      message: 'meta.version must be a non-empty string.',
-      detail: 'version',
-    });
-  }
-  if (typeof candidate.ruleId !== 'string' || candidate.ruleId.trim().length === 0) {
-    failures.push({
-      code: 'invalid-meta',
-      message: 'meta.ruleId must be a non-empty string.',
-      detail: 'ruleId',
-    });
-  }
-  if (
-    typeof candidate.coversCondition !== 'string' ||
-    candidate.coversCondition.trim().length === 0
-  ) {
-    failures.push({
-      code: 'invalid-meta',
-      message: 'meta.coversCondition must be a non-empty string.',
-      detail: 'coversCondition',
-    });
-  }
-
-  return failures;
-}
-
-function validateResult(result: unknown): RuleImplementationValidationFailure[] {
-  if (!result || typeof result !== 'object') {
-    return [
-      {
-        code: 'invalid-result',
-        message: 'evaluate must return a RuleHostResult object.',
-      },
-    ];
-  }
-
-  const candidate = result as Partial<RuleHostResult>;
-  const failures: RuleImplementationValidationFailure[] = [];
-  const allowedDecisions: RuleHostDecision[] = ['allow', 'block', 'requireApproval'];
-
-  if (!allowedDecisions.includes(candidate.decision as RuleHostDecision)) {
-    failures.push({
-      code: 'invalid-result',
-      message: 'evaluate.decision must be allow, block, or requireApproval.',
-      detail: 'decision',
-    });
-  }
-  if (typeof candidate.matched !== 'boolean') {
-    failures.push({
-      code: 'invalid-result',
-      message: 'evaluate.matched must be a boolean.',
-      detail: 'matched',
-    });
-  }
-  if (typeof candidate.reason !== 'string') {
-    failures.push({
-      code: 'invalid-result',
-      message: 'evaluate.reason must be a string.',
-      detail: 'reason',
-    });
-  }
-
-  return failures;
-}
-
-export function validateRuleImplementationCandidate(
-  sourceCode: string
-): RuleImplementationValidationResult {
-  const helperUsage = extractHelperUsage(sourceCode);
-  const failures: RuleImplementationValidationFailure[] = [];
-
-  for (const forbidden of FORBIDDEN_PATTERNS) {
-    if (forbidden.pattern.test(sourceCode)) {
-      failures.push({
-        code: 'forbidden-api',
-        message: `Candidate uses forbidden API: ${forbidden.label}.`,
-        detail: forbidden.label,
-      });
-    }
-  }
-
-  if (failures.length > 0) {
-    return {
-      passed: false,
-      failures,
-      helperUsage,
-    };
-  }
-
-  const normalizedSource = sourceCode;
-
-  try {
-    const moduleExports = loadRuleImplementationModule(normalizedSource, 'nocturnal-candidate.js') as {
-      meta?: unknown;
-       
-      evaluate?: (_input: RuleHostInput, _helpers: RuleHostHelpers) => unknown;
-    };
-
-    const metaFailures = validateMeta(moduleExports.meta);
-    failures.push(...metaFailures);
-
-    if (typeof moduleExports.evaluate !== 'function') {
-      failures.push({
-        code: 'missing-evaluate',
-        message: 'Candidate must export an evaluate function.',
-      });
-    } else {
-      const result = moduleExports.evaluate(
-        createValidationInput(),
-        createRuleHostHelpers(createValidationInput())
-      );
-      failures.push(...validateResult(result));
-    }
-
-    return {
-      passed: failures.length === 0,
-      failures,
-      helperUsage,
-      normalizedSource,
-      meta: metaFailures.length === 0 ? (moduleExports.meta as RuleHostMeta) : undefined,
-    };
-  } catch (error: unknown) {
-    return {
-      passed: false,
-      failures: [
-        {
-          code: 'compile-error',
-          message: 'Candidate could not be compiled with RuleHost-compatible semantics.',
-          detail: String(error),
-        },
-      ],
-      helperUsage,
-      normalizedSource,
-    };
-  }
-}

package/src/core/nocturnal-snapshot-contract.ts

@@ -1,99 +0,0 @@
-import type { NocturnalSessionSnapshot } from './nocturnal-trajectory-extractor.js';
-
-export interface NocturnalSnapshotContractResult {
-  status: 'valid' | 'invalid';
-  reasons: string[];
-  snapshot?: NocturnalSessionSnapshot;
-}
-
-function isObjectRecord(value: unknown): value is Record<string, unknown> {
-  return !!value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === 'string' && value.trim().length > 0;
-}
-
-/** #246: Stats fields must now be finite numbers — null is no longer accepted. */
-function isFiniteNumber(value: unknown): value is number {
-  return typeof value === 'number' && Number.isFinite(value);
-}
-
-export function validateNocturnalSnapshotIngress(
-  value: unknown
-): NocturnalSnapshotContractResult {
-  const reasons: string[] = [];
-
-  if (!isObjectRecord(value)) {
-    return { status: 'invalid', reasons: ['snapshot must be an object'] };
-  }
-
-  if (!isNonEmptyString(value.sessionId)) {
-    reasons.push('snapshot.sessionId must be a non-empty string');
-  }
-
-  if (!isNonEmptyString(value.startedAt)) {
-    reasons.push('snapshot.startedAt must be a non-empty string');
-  }
-
-  if (!isNonEmptyString(value.updatedAt)) {
-    reasons.push('snapshot.updatedAt must be a non-empty string');
-  }
-
-  const arrayFields = [
-    'assistantTurns',
-    'userTurns',
-    'toolCalls',
-    'painEvents',
-    'gateBlocks',
-  ] as const;
-  for (const field of arrayFields) {
-    if (!Array.isArray(value[field])) {
-      reasons.push(`snapshot.${field} must be an array`);
-    }
-  }
-
-   
-  const stats = value.stats;
-  if (!isObjectRecord(stats)) {
-    reasons.push('snapshot.stats must be an object');
-  } else {
-    if (!isFiniteNumber(stats.totalAssistantTurns)) {
-      reasons.push('snapshot.stats.totalAssistantTurns must be a finite number');
-    }
-    if (!isFiniteNumber(stats.totalToolCalls)) {
-      reasons.push('snapshot.stats.totalToolCalls must be a finite number');
-    }
-    if (!isFiniteNumber(stats.totalPainEvents)) {
-      reasons.push('snapshot.stats.totalPainEvents must be a finite number');
-    }
-    if (!isFiniteNumber(stats.totalGateBlocks)) {
-      reasons.push('snapshot.stats.totalGateBlocks must be a finite number');
-    }
-    if (!isFiniteNumber(stats.failureCount)) {
-      reasons.push('snapshot.stats.failureCount must be a finite number');
-    }
-  }
-
-  const isFallback = value._dataSource === 'pain_context_fallback';
-  if (value._dataSource !== undefined && !isFallback) {
-    reasons.push('snapshot._dataSource must be omitted or pain_context_fallback');
-  }
-
-  if (isFallback && isObjectRecord(stats) && Array.isArray(value.painEvents)) {
-    const hasPainSignal = value.painEvents.length > 0 || ((stats.totalPainEvents as number) > 0);
-    if (!hasPainSignal) {
-      reasons.push('fallback snapshot must contain at least one pain signal');
-    }
-  }
-
-  if (reasons.length > 0) {
-    return { status: 'invalid', reasons };
-  }
-
-  return {
-    status: 'valid',
-    reasons: [],
-    snapshot: value as unknown as NocturnalSessionSnapshot,
-  };
-}