@godman-protocols/signal 0.2.0 → 0.3.0

package/dist/types.js

@@ -1,7 +1,68 @@
 /**
- * SIGNAL — Event Bus and Pub/Sub for Agent Swarms
- * Core type definitions (skeleton)
- * @version 0.1.0-skeleton
+ * SIGNAL — Sovereign Intelligence for Governing Neural Agent Learning
+ * Core type definitions: reward signals, constitutional multipliers, learning modes
+ * @version 0.3.0
  */
-export {};
+// ---------------------------------------------------------------------------
+// Learning Modes (AMD-15, AMD-20)
+// ---------------------------------------------------------------------------
+/**
+ * Three learning modes for the swarm:
+ * - STATIC (Mode 0): Frozen inference, no learning. Current default.
+ * - BATCH_LORA (Mode 1): AMD-15. Batch of 100 tasks + Godman approval required.
+ * - CONTINUOUS (Mode 2): AMD-20. Every 50 inference steps, reward fed back.
+ */
+export var LearningMode;
+(function (LearningMode) {
+    /** Mode 0 — Frozen inference. No learning. Default. */
+    LearningMode[LearningMode["STATIC"] = 0] = "STATIC";
+    /** Mode 1 — Batch LoRA fine-tuning. 100 tasks + Godman approval. (AMD-15) */
+    LearningMode[LearningMode["BATCH_LORA"] = 1] = "BATCH_LORA";
+    /** Mode 2 — Continuous RL. Every 50 inference steps. (AMD-20) */
+    LearningMode[LearningMode["CONTINUOUS"] = 2] = "CONTINUOUS";
+})(LearningMode || (LearningMode = {}));
+// ---------------------------------------------------------------------------
+// Three Constitutional Rules (immutable)
+// ---------------------------------------------------------------------------
+/**
+ * SIGNAL Constitutional Rule 1:
+ * Only Godman (founder) can activate or pause learning modes.
+ * Kill switch: /pause-continuous-learning
+ */
+export const RULE_GODMAN_KILL_SWITCH = {
+    id: 'SIGNAL-CONST-001',
+    rule: 'Only Godman activates or pauses learning modes. Kill switch: /pause-continuous-learning',
+    immutable: true,
+};
+/**
+ * SIGNAL Constitutional Rule 2:
+ * The PRM judge must be constitutionally filtered.
+ * ACP dimensions are applied BEFORE reward computation, not after.
+ */
+export const RULE_PRM_CONSTITUTIONALLY_FILTERED = {
+    id: 'SIGNAL-CONST-002',
+    rule: 'PRM judge is constitutionally filtered. ACP applied before reward computation.',
+    immutable: true,
+};
+/**
+ * SIGNAL Constitutional Rule 3:
+ * SOUL.md content is never a training target.
+ * Constitutional reasoning cannot be optimised away by RL.
+ */
+export const RULE_SOUL_NEVER_TRAINED = {
+    id: 'SIGNAL-CONST-003',
+    rule: 'Cannot target constitutional reasoning. SOUL.md content is never a training target.',
+    immutable: true,
+};
+/** All three constitutional rules as a tuple */
+export const CONSTITUTIONAL_RULES = [
+    RULE_GODMAN_KILL_SWITCH,
+    RULE_PRM_CONSTITUTIONALLY_FILTERED,
+    RULE_SOUL_NEVER_TRAINED,
+];
+export const DEFAULT_SIGNAL_CONFIG = {
+    reward_log_path: 'reward-log.jsonl',
+    batch_lora_threshold: 100,
+    continuous_step_interval: 50,
+};
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAwDH,8EAA8E;AAC9E,kCAAkC;AAClC,8EAA8E;AAE9E;;;;;GAKG;AACH,MAAM,CAAN,IAAY,YAOX;AAPD,WAAY,YAAY;IACtB,uDAAuD;IACvD,mDAAU,CAAA;IACV,6EAA6E;IAC7E,2DAAc,CAAA;IACd,iEAAiE;IACjE,2DAAc,CAAA;AAChB,CAAC,EAPW,YAAY,KAAZ,YAAY,QAOvB;AAmBD,8EAA8E;AAC9E,yCAAyC;AACzC,8EAA8E;AAE9E;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,EAAE,EAAE,kBAAkB;IACtB,IAAI,EAAE,yFAAyF;IAC/F,SAAS,EAAE,IAAI;CACP,CAAC;AAEX;;;;GAIG;AACH,MAAM,CAAC,MAAM,kCAAkC,GAAG;IAChD,EAAE,EAAE,kBAAkB;IACtB,IAAI,EAAE,gFAAgF;IACtF,SAAS,EAAE,IAAI;CACP,CAAC;AAEX;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,EAAE,EAAE,kBAAkB;IACtB,IAAI,EAAE,qFAAqF;IAC3F,SAAS,EAAE,IAAI;CACP,CAAC;AAEX,gDAAgD;AAChD,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,uBAAuB;IACvB,kCAAkC;IAClC,uBAAuB;CACf,CAAC;AA4BX,MAAM,CAAC,MAAM,qBAAqB,GAAiB;IACjD,eAAe,EAAE,kBAAkB;IACnC,oBAAoB,EAAE,GAAG;IACzB,wBAAwB,EAAE,EAAE;CAC7B,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@godman-protocols/signal",
-  "version": "0.2.0",
-  "description": "Event Bus and Pub/Sub for Agent Swarms \u2014 typed events, topic-glob routing, idempotent delivery, delivery receipts",
+  "version": "0.3.0",
+  "description": "Sovereign Intelligence for Governing Neural Agent Learning \u2014 reward signals",
   "type": "module",
   "main": "dist/index.js",
   "exports": "./dist/index.js",

package/src/index.ts

@@ -1,29 +1,10 @@
 /**
- * SIGNAL — Event Bus and Pub/Sub for Agent Swarms
- * Public API surface
- * @version 0.2.0
+ * SIGNAL — Sovereign Intelligence for Governing Neural Agent Learning
+ * "The swarm teaches itself."
+ * @version 0.3.0
  */
 
-// Types
-export type {
-  AgentId,
-  Timestamp,
-  Signature,
-  EventId,
-  SubscriptionId,
-  Event,
-  Subscription,
-  TransportConfig,
-  DeliveryReceipt,
-} from './types.js';
-
-// Event bus
-export {
-  EventBus,
-  defaultBus,
-  createEvent,
-  topicMatches,
-} from './bus.js';
+export * from './types.js';
 
 /** Protocol version constant */
-export const SIGNAL_VERSION = '0.2' as const;
+export const SIGNAL_VERSION = '0.3' as const;

package/src/mode-controller.ts

@@ -0,0 +1,135 @@
+/**
+ * SIGNAL — Sovereign Intelligence for Governing Neural Agent Learning
+ * ModeController: manages learning mode transitions with Godman kill switch
+ * @version 0.3.0
+ */
+
+import {
+  LearningMode,
+  RULE_GODMAN_KILL_SWITCH,
+  type ModeTransition,
+  type ModeControllerState,
+  type RewardSignal,
+} from './types.js';
+
+/**
+ * ModeController governs learning mode transitions.
+ *
+ * Constitutional Rule 1 (SIGNAL-CONST-001): Only Godman can activate
+ * or pause learning. The kill switch `/pause-continuous-learning`
+ * immediately drops to Mode 0 (STATIC).
+ *
+ * The controller maintains a transition log for auditability.
+ */
+export class ModeController {
+  private mode: LearningMode = LearningMode.STATIC;
+  private paused = false;
+  private transitions: ModeTransition[] = [];
+  private rewardLog: RewardSignal[] = [];
+
+  /**
+   * Get the current active learning mode.
+   * If paused, returns STATIC regardless of the configured mode.
+   */
+  getCurrentMode(): LearningMode {
+    if (this.paused) {
+      return LearningMode.STATIC;
+    }
+    return this.mode;
+  }
+
+  /**
+   * Activate a learning mode.
+   * Only Godman (founder) can call this — enforcement is the caller's
+   * responsibility, but the transition is logged with the activator identity.
+   *
+   * @param target - The learning mode to activate
+   * @param activatedBy - Identity of the activator (must be Godman)
+   * @param reason - Why this transition is happening
+   */
+  activate(
+    target: LearningMode,
+    activatedBy: string,
+    reason: string
+  ): ModeTransition {
+    const transition: ModeTransition = {
+      from: this.mode,
+      to: target,
+      activated_by: activatedBy,
+      activated_at: new Date().toISOString(),
+      reason,
+    };
+
+    this.mode = target;
+    this.paused = false;
+    this.transitions.push(transition);
+    return transition;
+  }
+
+  /**
+   * Pause all learning — drops to Mode 0 (STATIC) immediately.
+   * This is the kill switch (SIGNAL-CONST-001).
+   *
+   * @param pausedBy - Identity of the pauser (must be Godman)
+   * @param reason - Why learning is being paused
+   */
+  pause(pausedBy: string, reason: string): ModeTransition {
+    const transition: ModeTransition = {
+      from: this.mode,
+      to: LearningMode.STATIC,
+      activated_by: pausedBy,
+      activated_at: new Date().toISOString(),
+      reason: `[KILL SWITCH] ${reason}`,
+    };
+
+    this.paused = true;
+    this.transitions.push(transition);
+    return transition;
+  }
+
+  /**
+   * Record a reward signal in the in-memory log.
+   * Used for batch accumulation in Mode 1 (BATCH_LORA).
+   */
+  recordReward(signal: RewardSignal): void {
+    this.rewardLog.push(signal);
+  }
+
+  /**
+   * Get the in-memory reward log.
+   */
+  getRewardLog(): ReadonlyArray<RewardSignal> {
+    return [...this.rewardLog];
+  }
+
+  /**
+   * Check whether the batch threshold has been reached (Mode 1).
+   * @param threshold - Number of tasks required (default: 100)
+   */
+  batchReady(threshold = 100): boolean {
+    return this.rewardLog.length >= threshold;
+  }
+
+  /** Whether learning is currently paused */
+  get isPaused(): boolean {
+    return this.paused;
+  }
+
+  /** Full transition history */
+  getTransitions(): ReadonlyArray<ModeTransition> {
+    return [...this.transitions];
+  }
+
+  /** Export current state for persistence or inspection */
+  getState(): ModeControllerState {
+    return {
+      current_mode: this.getCurrentMode(),
+      paused: this.paused,
+      transitions: [...this.transitions],
+      reward_count: this.rewardLog.length,
+    };
+  }
+
+  /** The constitutional rule governing this controller */
+  static readonly KILL_SWITCH_RULE = RULE_GODMAN_KILL_SWITCH;
+}

package/src/multiplier.ts

@@ -0,0 +1,95 @@
+/**
+ * SIGNAL — Sovereign Intelligence for Governing Neural Agent Learning
+ * Constitutional multiplier computation
+ * @version 0.3.0
+ */
+
+import type { ACPSnapshot, ConstitutionalMultiplierResult } from './types.js';
+
+// ---------------------------------------------------------------------------
+// Constitutional Multiplier Formula
+// ---------------------------------------------------------------------------
+//
+// reward = task_performance_score * constitutional_multiplier
+//
+// Multiplier rules (evaluated in priority order):
+//   harm_shield_trigger  → -2.0 (strong negative)
+//   safety < 70          → -1.0 (negative)
+//   accuracy < 60        → 0.5  (dampened)
+//   all ACP dims >= 85   → 1.2  (bonus)
+//   all ACP dims >= 70   → 1.0  (full)
+//   otherwise            → 0.5  (dampened — some dimension below 70)
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute the constitutional multiplier from an ACP snapshot.
+ *
+ * The multiplier is applied to the raw task performance score to produce
+ * the final reward. Constitutional violations produce negative or dampened
+ * rewards; full compliance produces a bonus.
+ */
+export function computeConstitutionalMultiplier(
+  snapshot: ACPSnapshot
+): ConstitutionalMultiplierResult {
+  const { dimensions, harm_shield_triggered } = snapshot;
+
+  // Priority 1: Harm shield trigger → strong negative
+  if (harm_shield_triggered) {
+    return { multiplier: -2.0, reason: 'Harm shield triggered' };
+  }
+
+  // Priority 2: Safety below threshold → negative
+  const safety = dimensions['safety'];
+  if (safety !== undefined && safety < 70) {
+    return { multiplier: -1.0, reason: `Safety score ${safety} < 70` };
+  }
+
+  // Priority 3: Accuracy below threshold → dampened
+  const accuracy = dimensions['accuracy'];
+  if (accuracy !== undefined && accuracy < 60) {
+    return { multiplier: 0.5, reason: `Accuracy score ${accuracy} < 60` };
+  }
+
+  // Check all dimensions
+  const values = Object.values(dimensions);
+
+  // If no dimensions provided, default to dampened
+  if (values.length === 0) {
+    return { multiplier: 0.5, reason: 'No ACP dimensions provided' };
+  }
+
+  // Priority 4: All dimensions >= 85 → bonus
+  const allAbove85 = values.every((v) => v >= 85);
+  if (allAbove85) {
+    return { multiplier: 1.2, reason: 'All ACP dimensions >= 85 (bonus)' };
+  }
+
+  // Priority 5: All dimensions >= 70 → full
+  const allAbove70 = values.every((v) => v >= 70);
+  if (allAbove70) {
+    return { multiplier: 1.0, reason: 'All ACP dimensions >= 70 (full)' };
+  }
+
+  // Fallback: some dimension below 70 → dampened
+  const belowThreshold = Object.entries(dimensions)
+    .filter(([, v]) => v < 70)
+    .map(([k]) => k);
+  return {
+    multiplier: 0.5,
+    reason: `Dimensions below 70: ${belowThreshold.join(', ')}`,
+  };
+}
+
+/**
+ * Compute the full reward from a task performance score and ACP snapshot.
+ */
+export function computeReward(
+  taskPerformanceScore: number,
+  snapshot: ACPSnapshot
+): { reward: number; multiplier: ConstitutionalMultiplierResult } {
+  const multiplier = computeConstitutionalMultiplier(snapshot);
+  return {
+    reward: taskPerformanceScore * multiplier.multiplier,
+    multiplier,
+  };
+}

package/src/reward-logger.ts

@@ -0,0 +1,73 @@
+/**
+ * SIGNAL — Sovereign Intelligence for Governing Neural Agent Learning
+ * RewardLogger: persists reward signals to reward-log.jsonl
+ * @version 0.3.0
+ */
+
+import { appendFileSync, readFileSync, existsSync } from 'node:fs';
+import type { RewardSignal, RewardLogEntry, SignalConfig } from './types.js';
+import { LearningMode, DEFAULT_SIGNAL_CONFIG } from './types.js';
+
+/**
+ * RewardLogger writes and reads reward signals from a JSONL file.
+ *
+ * Each line in the file is a JSON-serialised RewardLogEntry containing
+ * the reward signal plus the learning mode at the time of logging.
+ */
+export class RewardLogger {
+  private readonly logPath: string;
+
+  constructor(config: Partial<SignalConfig> = {}) {
+    this.logPath = config.reward_log_path ?? DEFAULT_SIGNAL_CONFIG.reward_log_path;
+  }
+
+  /**
+   * Append a reward signal to the log file.
+   * Attaches the current learning mode to the entry.
+   */
+  log(signal: RewardSignal, mode: LearningMode = LearningMode.STATIC): void {
+    const entry: RewardLogEntry = { ...signal, mode };
+    appendFileSync(this.logPath, JSON.stringify(entry) + '\n', 'utf-8');
+  }
+
+  /**
+   * Read the full reward history from the log file.
+   * Returns an empty array if the file does not exist.
+   */
+  readHistory(): RewardLogEntry[] {
+    if (!existsSync(this.logPath)) {
+      return [];
+    }
+
+    const raw = readFileSync(this.logPath, 'utf-8').trim();
+    if (raw.length === 0) {
+      return [];
+    }
+
+    return raw
+      .split('\n')
+      .filter((line) => line.length > 0)
+      .map((line) => JSON.parse(line) as RewardLogEntry);
+  }
+
+  /**
+   * Count of logged entries without loading full history.
+   */
+  count(): number {
+    if (!existsSync(this.logPath)) {
+      return 0;
+    }
+
+    const raw = readFileSync(this.logPath, 'utf-8').trim();
+    if (raw.length === 0) {
+      return 0;
+    }
+
+    return raw.split('\n').filter((line) => line.length > 0).length;
+  }
+
+  /** The path to the log file */
+  get path(): string {
+    return this.logPath;
+  }
+}

package/src/types.ts

@@ -1,55 +1,171 @@
 /**
- * SIGNAL — Event Bus and Pub/Sub for Agent Swarms
- * Core type definitions (skeleton)
- * @version 0.1.0-skeleton
+ * SIGNAL — Sovereign Intelligence for Governing Neural Agent Learning
+ * Core type definitions: reward signals, constitutional multipliers, learning modes
+ * @version 0.3.0
  */
 
-export type AgentId = string;
-export type Timestamp = string;
-export type Signature = string;
-export type EventId = string;
-export type SubscriptionId = string;
-
-/** A typed, timestamped, signed event */
-export interface Event {
-  id: EventId;
-  /** Dot-notation topic path, e.g. 'task.completed', 'mandate.revoked' */
-  topic: string;
-  /** Publishing agent */
-  publisher: AgentId;
-  /** ISO 8601 */
-  publishedAt: Timestamp;
-  /** Idempotency key — deduplicate on re-delivery */
-  idempotencyKey: string;
-  payload: unknown;
-  signature: Signature;
-}
-
-/** A durable subscription to a topic filter */
-export interface Subscription {
-  id: SubscriptionId;
-  subscriberAgent: AgentId;
-  /** Glob-style topic filter, e.g. 'task.*', '**' */
-  topicFilter: string;
-  /** Delivery guarantee */
-  deliveryMode: 'at-least-once' | 'at-most-once';
-  /** ISO 8601 */
-  createdAt: Timestamp;
-  /** ISO 8601 — null if still active */
-  cancelledAt: Timestamp | null;
-}
-
-/** Transport adapter configuration */
-export interface TransportConfig {
-  type: 'supabase-realtime' | 'websocket' | 'redis-streams' | 'in-memory';
-  connectionString?: string;
-  channel?: string;
-}
-
-/** Delivery receipt — confirms an event was received and processed */
-export interface DeliveryReceipt {
-  eventId: EventId;
-  subscriptionId: SubscriptionId;
-  receivedAt: Timestamp;
-  status: 'processed' | 'failed' | 'duplicate-skipped';
+// ---------------------------------------------------------------------------
+// Reward Signal
+// ---------------------------------------------------------------------------
+
+/** A computed reward signal for a single agent action */
+export interface RewardSignal {
+  /** Unique identifier for the action being scored */
+  action_id: string;
+  /** Raw task performance score (0-100) */
+  task_performance_score: number;
+  /** Constitutional multiplier applied to the score (-2.0 to 1.2) */
+  constitutional_multiplier: number;
+  /** Computed reward: task_performance_score * constitutional_multiplier */
+  reward: number;
+  /** ACP dimension scores used to derive the multiplier */
+  acp_dimensions: Record<string, number>;
+  /** ISO 8601 timestamp */
+  timestamp: string;
+}
+
+// ---------------------------------------------------------------------------
+// ACP Dimensions
+// ---------------------------------------------------------------------------
+
+/** Well-known ACP dimension names used in constitutional scoring */
+export type ACPDimensionName =
+  | 'safety'
+  | 'accuracy'
+  | 'transparency'
+  | 'privacy'
+  | 'fairness'
+  | 'harm_shield'
+  | (string & {});
+
+/** Input to the constitutional multiplier computation */
+export interface ACPSnapshot {
+  /** Per-dimension ACP scores (0-100) */
+  dimensions: Record<string, number>;
+  /** Whether the harm shield was triggered during this action */
+  harm_shield_triggered: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Constitutional Multiplier
+// ---------------------------------------------------------------------------
+
+/** Result of computing a constitutional multiplier */
+export interface ConstitutionalMultiplierResult {
+  /** The computed multiplier value (-2.0 to 1.2) */
+  multiplier: number;
+  /** Human-readable reason for the multiplier */
+  reason: string;
+}
+
+// ---------------------------------------------------------------------------
+// Learning Modes (AMD-15, AMD-20)
+// ---------------------------------------------------------------------------
+
+/**
+ * Three learning modes for the swarm:
+ * - STATIC (Mode 0): Frozen inference, no learning. Current default.
+ * - BATCH_LORA (Mode 1): AMD-15. Batch of 100 tasks + Godman approval required.
+ * - CONTINUOUS (Mode 2): AMD-20. Every 50 inference steps, reward fed back.
+ */
+export enum LearningMode {
+  /** Mode 0 — Frozen inference. No learning. Default. */
+  STATIC = 0,
+  /** Mode 1 — Batch LoRA fine-tuning. 100 tasks + Godman approval. (AMD-15) */
+  BATCH_LORA = 1,
+  /** Mode 2 — Continuous RL. Every 50 inference steps. (AMD-20) */
+  CONTINUOUS = 2,
+}
+
+/** Configuration for a learning mode transition */
+export interface ModeTransition {
+  from: LearningMode;
+  to: LearningMode;
+  activated_by: string;
+  activated_at: string;
+  reason: string;
+}
+
+/** Snapshot of the current mode controller state */
+export interface ModeControllerState {
+  current_mode: LearningMode;
+  paused: boolean;
+  transitions: ModeTransition[];
+  reward_count: number;
+}
+
+// ---------------------------------------------------------------------------
+// Three Constitutional Rules (immutable)
+// ---------------------------------------------------------------------------
+
+/**
+ * SIGNAL Constitutional Rule 1:
+ * Only Godman (founder) can activate or pause learning modes.
+ * Kill switch: /pause-continuous-learning
+ */
+export const RULE_GODMAN_KILL_SWITCH = {
+  id: 'SIGNAL-CONST-001',
+  rule: 'Only Godman activates or pauses learning modes. Kill switch: /pause-continuous-learning',
+  immutable: true,
+} as const;
+
+/**
+ * SIGNAL Constitutional Rule 2:
+ * The PRM judge must be constitutionally filtered.
+ * ACP dimensions are applied BEFORE reward computation, not after.
+ */
+export const RULE_PRM_CONSTITUTIONALLY_FILTERED = {
+  id: 'SIGNAL-CONST-002',
+  rule: 'PRM judge is constitutionally filtered. ACP applied before reward computation.',
+  immutable: true,
+} as const;
+
+/**
+ * SIGNAL Constitutional Rule 3:
+ * SOUL.md content is never a training target.
+ * Constitutional reasoning cannot be optimised away by RL.
+ */
+export const RULE_SOUL_NEVER_TRAINED = {
+  id: 'SIGNAL-CONST-003',
+  rule: 'Cannot target constitutional reasoning. SOUL.md content is never a training target.',
+  immutable: true,
+} as const;
+
+/** All three constitutional rules as a tuple */
+export const CONSTITUTIONAL_RULES = [
+  RULE_GODMAN_KILL_SWITCH,
+  RULE_PRM_CONSTITUTIONALLY_FILTERED,
+  RULE_SOUL_NEVER_TRAINED,
+] as const;
+
+export type ConstitutionalRule = (typeof CONSTITUTIONAL_RULES)[number];
+
+// ---------------------------------------------------------------------------
+// Reward Log Entry (persisted to reward-log.jsonl)
+// ---------------------------------------------------------------------------
+
+/** A single line in reward-log.jsonl */
+export interface RewardLogEntry extends RewardSignal {
+  /** Learning mode at the time of logging */
+  mode: LearningMode;
 }
+
+// ---------------------------------------------------------------------------
+// SIGNAL Config
+// ---------------------------------------------------------------------------
+
+/** Top-level configuration for the SIGNAL protocol */
+export interface SignalConfig {
+  /** Path to the reward log file (default: reward-log.jsonl) */
+  reward_log_path: string;
+  /** Batch size for Mode 1 (default: 100) */
+  batch_lora_threshold: number;
+  /** Step interval for Mode 2 (default: 50) */
+  continuous_step_interval: number;
+}
+
+export const DEFAULT_SIGNAL_CONFIG: SignalConfig = {
+  reward_log_path: 'reward-log.jsonl',
+  batch_lora_threshold: 100,
+  continuous_step_interval: 50,
+};