principles-disciple 1.72.0 → 1.74.0

package/src/core/rule-host.ts

@@ -25,21 +25,19 @@ import {
   listImplementationsByLifecycleState,
 } from './principle-tree-ledger.js';
 import { loadEntrySource } from './code-implementation-storage.js';
-import { createRuleHostHelpers } from './rule-host-helpers.js';
+import { createRuleHostHelpers } from '@principles/core/runtime-v2';
+import { mergeDecisions } from '@principles/core/runtime-v2';
 import { loadRuleImplementationModule } from './rule-implementation-runtime.js';
 import type {
   RuleHostInput,
   RuleHostResult,
   RuleHostMeta,
   LoadedImplementation,
-} from './rule-host-types.js';
+} from '@principles/core/runtime-v2';
 import type { Implementation } from '../types/principle-tree-schema.js';
 
-export interface RuleHostLogger {
-   
-  warn?: (_message: string) => void;
-   
-}
+import type { RuleHostLogger } from '@principles/core/runtime-v2';
+export type { RuleHostLogger } from '@principles/core/runtime-v2';
 
 export class RuleHost {
   private readonly stateDir: string;
@@ -62,63 +60,8 @@ export class RuleHost {
      
   evaluate(input: RuleHostInput): RuleHostResult | undefined {
     try {
-      // Load active code implementations from the ledger
       const activeImpls = this._loadActiveCodeImplementations();
-
-      if (activeImpls.length === 0) {
-        return undefined;
-      }
-
-      // Merge decisions from all active implementations
-       
-       
-      let blocked: RuleHostResult | undefined;
-      const approvals: RuleHostResult[] = [];
-
-      for (const impl of activeImpls) {
-        try {
-          const result = impl.evaluate(input);
-
-          if (!result.matched) {
-            continue;
-          }
-
-          if (result.decision === 'block') {
-            blocked = result;
-            break; // Short-circuit on block
-          }
-
-          if (result.decision === 'requireApproval') {
-            approvals.push(result);
-          }
-          // 'allow' is implicit — no action needed
-        } catch (evalError: unknown) {
-          // Individual implementation error: log and continue (D-08)
-          this.logger.warn?.(
-            `[RuleHost] Implementation ${impl.implId} evaluation failed: ${String(evalError)}`
-          );
-        }
-      }
-
-      if (blocked) {
-        return blocked;
-      }
-
-      if (approvals.length > 0) {
-        // Merge multiple requireApproval results
-        return {
-          decision: 'requireApproval',
-          matched: true,
-          reason: approvals.map((a) => a.reason).join('; '),
-          diagnostics: approvals.reduce<Record<string, unknown>>(
-            (acc, a) => ({ ...acc, ...a.diagnostics }),
-            {}
-          ),
-        };
-      }
-
-      // All implementations returned allow or matched=false — no opinion
-      return undefined;
+      return mergeDecisions(activeImpls, input, this.logger);
     } catch (hostError: unknown) {
       // Conservative degradation: log and return undefined (D-08)
       this.logger.warn?.(

package/src/core/runtime-v2-prompt-activation-reader.ts

@@ -0,0 +1,231 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import * as yaml from 'js-yaml';
+import { SqliteConnection, SqliteActivationStateStore, computeEffectiveFlags, DEFAULT_FEATURE_FLAGS } from '@principles/core/runtime-v2';
+import type { ActivationStatusRecord, EffectiveFeatureFlags } from '@principles/core/runtime-v2';
+
+export const RUNTIME_V2_PRINCIPLE_BUDGET = 2000;
+
+export interface ActivatedPrinciple {
+  principleId: string;
+  text: string;
+  artifactId: string;
+  activationId: string;
+}
+
+export interface PromptActivationReaderResult {
+  principles: ActivatedPrinciple[];
+  warnings: string[];
+  source: 'runtime_v2';
+}
+
+export interface PromptActivationReaderDeps {
+  logger?: { warn?: (msg: string) => void; info?: (msg: string) => void; error?: (msg: string) => void };
+}
+
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+export class PromptActivationReader {
+  private readonly workspaceDir: string;
+  private readonly deps: PromptActivationReaderDeps;
+
+  constructor(workspaceDir: string, deps?: PromptActivationReaderDeps) {
+    this.workspaceDir = workspaceDir;
+    this.deps = deps ?? {};
+  }
+
+  async readActivatedPrinciples(): Promise<PromptActivationReaderResult> {
+    const warnings: string[] = [];
+    const principles: ActivatedPrinciple[] = [];
+
+    const flags = this.loadFeatureFlags();
+    const promptFlag = flags.flags['prompt'];
+    if (!promptFlag || !promptFlag.enabled) {
+      this.deps.logger?.info?.(`[PD:RuntimeV2] Prompt feature flag disabled — skipping Runtime V2 activation read`);
+      return { principles, warnings: ['prompt_feature_disabled'], source: 'runtime_v2' };
+    }
+
+    let sqliteConn: SqliteConnection | null = null;
+    try {
+      sqliteConn = new SqliteConnection(this.workspaceDir);
+      const store = new SqliteActivationStateStore(sqliteConn);
+
+      const activations = await store.listPromptActivations();
+
+      for (const activation of activations) {
+        if (activation.channel !== 'prompt' || activation.action !== 'prompt_activate') {
+          continue;
+        }
+
+        const result = this.resolvePrincipleFromActivation(sqliteConn, activation);
+        if (result.ok) {
+          principles.push(result.principle);
+        } else {
+          warnings.push(result.warning);
+          this.deps.logger?.warn?.(`[PD:RuntimeV2] ${result.warning}`);
+        }
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      const warning = `activation_db_unreadable: ${msg}; nextAction=check_workspace_pd_state_db`;
+      warnings.push(warning);
+      this.deps.logger?.warn?.(`[PD:RuntimeV2] ${warning}`);
+    } finally {
+      try {
+        sqliteConn?.close();
+      } catch {
+        // best-effort
+      }
+    }
+
+    return { principles, warnings, source: 'runtime_v2' };
+  }
+
+  private loadFeatureFlags(): EffectiveFeatureFlags {
+    const configPath = path.join(this.workspaceDir, '.pd', 'feature-flags.yaml');
+
+    if (!fs.existsSync(configPath)) {
+      return computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath);
+    }
+
+    let raw: string;
+    try {
+      raw = fs.readFileSync(configPath, 'utf8');
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.deps.logger?.warn?.(`[PD:RuntimeV2] Feature flags unreadable: ${msg} — using defaults`);
+      return computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath);
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
+    } catch {
+      this.deps.logger?.warn?.(`[PD:RuntimeV2] Feature flags YAML parse error — using defaults`);
+      return {
+        ...computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
+        warnings: ['feature-flags.yaml: YAML parse error, using defaults'],
+      };
+    }
+
+    if (!isRecord(parsed)) {
+      this.deps.logger?.warn?.(`[PD:RuntimeV2] Feature flags not a mapping — using defaults`);
+      return {
+        ...computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath),
+        warnings: ['feature-flags.yaml: expected a mapping, using defaults'],
+      };
+    }
+
+    const parsedRecord: Record<string, unknown> = Object.create(null);
+    const yamlWarnings: string[] = [];
+    for (const key of Object.keys(parsed)) {
+      if (DANGEROUS_KEYS.has(key)) {
+        yamlWarnings.push(`feature-flags.yaml: dangerous key '${key}' rejected`);
+        continue;
+      }
+      if (Object.hasOwn(parsed, key)) {
+        parsedRecord[key] = parsed[key];
+      }
+    }
+
+    const result = computeEffectiveFlags(parsedRecord, DEFAULT_FEATURE_FLAGS, configPath);
+    if (yamlWarnings.length > 0) {
+      result.warnings = [...yamlWarnings, ...result.warnings];
+      for (const w of yamlWarnings) {
+        this.deps.logger?.warn?.(`[PD:RuntimeV2] ${w}`);
+      }
+    }
+    return result;
+  }
+
+  private resolvePrincipleFromActivation(
+    sqliteConn: SqliteConnection,
+    activation: ActivationStatusRecord,
+  ): { ok: true; principle: ActivatedPrinciple } | { ok: false; warning: string } {
+    const db = sqliteConn.getDb();
+
+    let contentJson: string;
+
+    try {
+      const row = db.prepare(`
+        SELECT artifact_id, artifact_kind, content_json, validation_status
+        FROM pi_artifacts
+        WHERE artifact_id = ?
+      `).get(activation.artifactId);
+
+      if (!isRecord(row)) {
+        return { ok: false, warning: `artifact_query_unexpected: artifactId=${activation.artifactId}; nextAction=check_pi_artifacts_table` };
+      }
+
+      const artifact_id = Object.hasOwn(row, 'artifact_id') && typeof row.artifact_id === 'string' && row.artifact_id.length > 0 ? row.artifact_id : null;
+      const artifact_kind = Object.hasOwn(row, 'artifact_kind') && typeof row.artifact_kind === 'string' ? row.artifact_kind : null;
+      const raw_content_json = Object.hasOwn(row, 'content_json') && typeof row.content_json === 'string' ? row.content_json : null;
+      const validation_status = Object.hasOwn(row, 'validation_status') && typeof row.validation_status === 'string' ? row.validation_status : null;
+
+      if (!artifact_id) {
+        return { ok: false, warning: `artifact_not_found: artifactId=${activation.artifactId} activationId=${activation.activationId}; nextAction=verify_artifact_exists_or_remove_stale_activation` };
+      }
+
+      if (artifact_kind !== 'principle') {
+        return { ok: false, warning: `artifact_not_principle: artifactId=${artifact_id} kind=${artifact_kind ?? 'missing'}; nextAction=skip_non_principle_activations` };
+      }
+
+      if (validation_status !== 'validated') {
+        return { ok: false, warning: `artifact_not_validated: artifactId=${artifact_id} status=${validation_status ?? 'missing'}; nextAction=skip_unvalidated_artifacts` };
+      }
+
+      if (raw_content_json === null) {
+        return { ok: false, warning: `artifact_missing_content_json: artifactId=${artifact_id}; nextAction=ensure_artifact_has_content_json` };
+      }
+
+      contentJson = raw_content_json;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return { ok: false, warning: `artifact_query_failed: artifactId=${activation.artifactId} reason=${msg}; nextAction=check_pi_artifacts_table` };
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(contentJson);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return { ok: false, warning: `artifact_content_json_parse_error: artifactId=${activation.artifactId} reason=${msg}; nextAction=fix_artifact_content_json` };
+    }
+
+    if (!isRecord(parsed)) {
+      return { ok: false, warning: `artifact_content_malformed: artifactId=${activation.artifactId} reason=parsed_to_non_object; nextAction=fix_artifact_content_json` };
+    }
+
+    const principleId = Object.hasOwn(parsed, 'principleId') && typeof parsed.principleId === 'string' ? parsed.principleId : undefined;
+    const text = Object.hasOwn(parsed, 'text') && typeof parsed.text === 'string' ? parsed.text : undefined;
+
+    const draftObj = Object.hasOwn(parsed, 'principleDraft') && isRecord(parsed.principleDraft) ? parsed.principleDraft : null;
+    const draftTitle = draftObj && Object.hasOwn(draftObj, 'title') && typeof draftObj.title === 'string' ? draftObj.title : undefined;
+    const draftStatement = draftObj && Object.hasOwn(draftObj, 'statement') && typeof draftObj.statement === 'string' ? draftObj.statement : undefined;
+
+    const resolvedPrincipleId = principleId && principleId.length > 0 ? principleId : draftTitle;
+    const resolvedText = text && text.length > 0 ? text : draftStatement;
+
+    if (!resolvedPrincipleId || resolvedPrincipleId.length === 0) {
+      return { ok: false, warning: `artifact_missing_principle_id: artifactId=${activation.artifactId}; nextAction=ensure_artifact_has_principleId_or_principleDraft_title` };
+    }
+
+    if (!resolvedText || resolvedText.length === 0) {
+      return { ok: false, warning: `artifact_missing_text: artifactId=${activation.artifactId} principleId=${resolvedPrincipleId}; nextAction=ensure_artifact_has_text_or_principleDraft_statement` };
+    }
+
+    return {
+      ok: true,
+      principle: {
+        principleId: resolvedPrincipleId,
+        text: resolvedText,
+        artifactId: activation.artifactId,
+        activationId: activation.activationId,
+      },
+    };
+  }
+}

package/src/core/session-tracker.ts

@@ -5,6 +5,14 @@ import { atomicWriteFileSync } from '../utils/io.js';
 import type { PainConfig } from './config.js';
 import { SystemLogger } from './system-logger.js';
 import { TWO_HOURS_MS } from '../config/defaults/runtime.js';
+import {
+  applyFriction as coreApplyFriction,
+  applyDecay as coreApplyDecay,
+  applyRelief as coreApplyRelief,
+  classifyGfiStage,
+  DEFAULT_GFI_POLICY,
+} from '@principles/core/runtime-v2';
+import type { GfiState, GfiEvent, GfiSource } from '@principles/core/runtime-v2';
 
 export interface TokenUsage {
     input?: number;
@@ -14,6 +22,32 @@ export interface TokenUsage {
     total?: number;
 }
 
+// ── GFI Core Kernel Adapter ──────────────────────────────────────────────────
+
+/** Convert SessionState GFI fields to GfiState for core kernel */
+function toGfiState(state: SessionState): GfiState {
+  return {
+    currentGfi: state.currentGfi ?? 0,
+    gfiBySource: (state.gfiBySource ?? {}) as Partial<Record<GfiSource, number>>,
+    lastErrorHash: state.lastErrorHash === '' ? undefined : state.lastErrorHash,
+    lastErrorSource: state.lastErrorSource || undefined,
+    consecutiveErrors: state.consecutiveErrors ?? 0,
+    lastGfiDecayAt: state.lastGfiDecayAt,
+    dailyGfiPeak: state.dailyGfiPeak,
+  };
+}
+
+/** Apply GfiState result back onto SessionState */
+function applyGfiResult(state: SessionState, result: GfiState): void {
+  state.currentGfi = result.currentGfi;
+  state.gfiBySource = { ...result.gfiBySource } as Record<string, number>;
+  state.lastErrorHash = result.lastErrorHash ?? '';
+  state.lastErrorSource = result.lastErrorSource ?? '';
+  state.consecutiveErrors = result.consecutiveErrors;
+  state.lastGfiDecayAt = result.lastGfiDecayAt;
+  state.dailyGfiPeak = result.dailyGfiPeak ?? state.dailyGfiPeak;
+}
+
 export interface SessionState {
     sessionId: string;
     sessionKey?: string;   // Structured session key from OpenClaw (e.g., agent:main:cron:job-1:run:xxx)
@@ -233,13 +267,6 @@ function getOrCreateSession(sessionId: string, workspaceDir?: string, sessionKey
     return state;
 }
 
-function ensureGfiLedger(state: SessionState): Record<string, number> {
-    if (!state.gfiBySource || typeof state.gfiBySource !== 'object') {
-        state.gfiBySource = {};
-    }
-    return state.gfiBySource;
-}
-
 export function trackToolRead(sessionId: string, filePath: string, workspaceDir?: string): SessionState {
     const state = getOrCreateSession(sessionId, workspaceDir);
     const normalizedPath = path.posix.normalize(filePath.replace(/\\/g, '/'));
@@ -287,9 +314,8 @@ export function trackLlmOutput(sessionId: string, usage: TokenUsage | undefined,
 
 /**
  * Tracks physical friction based on tool execution failures.
+ * Delegates to core GFI kernel for scoring.
  */
- 
-     
 export function trackFriction(
     sessionId: string,
     deltaF: number,
@@ -298,40 +324,46 @@ export function trackFriction(
     options?: { source?: string }
 ): SessionState {
     const state = getOrCreateSession(sessionId, workspaceDir);
-    const ledger = ensureGfiLedger(state);
-    
-    if (hash && hash === state.lastErrorHash) {
-        state.consecutiveErrors++;
-    } else {
-        state.lastErrorSource = options?.source || (hash ? `unattributed:${hash}` : 'unattributed:unknown');
-        state.lastErrorHash = hash;
-        state.consecutiveErrors = 1;
+
+    const source: GfiSource = (options?.source as GfiSource) ?? 'unknown';
+    const event: GfiEvent = {
+        source,
+        baseScore: deltaF,
+        hash: hash || undefined,
+    };
+
+    const coreState = toGfiState(state);
+    const nextCore = coreApplyFriction(coreState, event, DEFAULT_GFI_POLICY);
+
+    // Preserve composite source key for unattributed sources
+    if (!options?.source && hash) {
+        const val = nextCore.gfiBySource['unknown'];
+        if (val !== undefined) {
+            const s = nextCore.gfiBySource as Record<string, number>;
+            delete s['unknown'];
+            const key = `unattributed:${hash}`;
+            s[key] = (s[key] ?? 0) + val;
+        }
     }
 
-    // GFI formula with multiplier: GFI = GFI + (Delta_F * 1.5^(n-1))
-    const multiplier = Math.pow(1.5, state.consecutiveErrors - 1);
-    const addedFriction = deltaF * multiplier;
-    state.currentGfi = (state.currentGfi || 0) + addedFriction;
-    const sourceKey = options?.source || (hash ? `unattributed:${hash}` : 'unattributed:unknown');
-    ledger[sourceKey] = (ledger[sourceKey] || 0) + addedFriction;
+    applyGfiResult(state, nextCore);
+
     touchActivity(state, 'control');
-    
-    SystemLogger.log(state.workspaceDir, 'GFI_INC', `Friction added: +${addedFriction.toFixed(1)} (Base: ${deltaF}, Mult: ${multiplier.toFixed(2)}). Total GFI: ${state.currentGfi.toFixed(1)}`);
-    
+
     // Update daily stats
     state.dailyToolFailures++;
     state.dailyGfiPeak = Math.max(state.dailyGfiPeak, state.currentGfi);
-    
+
     // Schedule persistence
-    // Update decay anchor to prevent retroactive decay of the new friction
     state.lastGfiDecayAt = Date.now();
     schedulePersistence(state);
-    
+
     return state;
 }
 
 /**
  * Resets the friction index upon successful action.
+ * Delegates to core GFI kernel for relief computation.
  */
 export function resetFriction(
     sessionId: string,
@@ -339,50 +371,36 @@ export function resetFriction(
     options?: { source?: string; amount?: number }
 ): SessionState {
     const state = getOrCreateSession(sessionId, workspaceDir);
-    const ledger = ensureGfiLedger(state);
 
     if (options?.source) {
-        const sourceKey = options.source;
-        const currentSource = ledger[sourceKey] || 0;
-        const requestedAmount = Number.isFinite(options.amount) ? Number(options.amount) : currentSource;
-        const amountToRemove = Math.max(0, Math.min(currentSource, requestedAmount));
-
-        if (amountToRemove > 0) {
-            ledger[sourceKey] = Math.max(0, currentSource - amountToRemove);
-            if (ledger[sourceKey] === 0) {
-                delete ledger[sourceKey];
-            }
-            state.currentGfi = Math.max(0, (state.currentGfi || 0) - amountToRemove);
+        const coreState = toGfiState(state);
+        const nextCore = coreApplyRelief(coreState, { source: options.source, amount: options.amount ?? 0 }, Date.now(), DEFAULT_GFI_POLICY);
+        applyGfiResult(state, nextCore);
+
+        if (state.currentGfi > 0) {
             SystemLogger.log(
                 state.workspaceDir,
                 'GFI_SLICE_RESET',
-                `Friction slice reset for ${sourceKey}: -${amountToRemove.toFixed(1)}. Total GFI: ${state.currentGfi.toFixed(1)}`
+                `Friction slice reset for ${options.source}: remaining GFI=${state.currentGfi.toFixed(1)}`
             );
-
-            if (state.lastErrorSource === sourceKey) {
-                state.consecutiveErrors = 0;
-                state.lastErrorHash = '';
-                state.lastErrorSource = '';
-            }
         }
         touchActivity(state, 'control');
         schedulePersistence(state);
         return state;
     }
 
-    if (state.currentGfi > 0) {
-        SystemLogger.log(state.workspaceDir, 'GFI_RESET', `Friction reset to 0 (Was: ${state.currentGfi.toFixed(1)}). Action successful.`);
+    // Full reset via core kernel
+    const previousGfi = state.currentGfi;
+    const coreState = toGfiState(state);
+    const nextCore = coreApplyRelief(coreState, { source: 'all', amount: 100 }, Date.now(), DEFAULT_GFI_POLICY);
+    applyGfiResult(state, nextCore);
+
+    if (previousGfi > 0) {
+        SystemLogger.log(state.workspaceDir, 'GFI_RESET', `Friction reset to 0 (Was: ${previousGfi.toFixed(1)}). Action successful.`);
     }
-    state.currentGfi = 0;
-    state.gfiBySource = {};
-    state.lastErrorSource = '';
-    state.consecutiveErrors = 0;
-    state.lastErrorHash = '';
     touchActivity(state, 'control');
-    
-    // Schedule persistence
+
     schedulePersistence(state);
-    
     return state;
 }
 
@@ -538,15 +556,9 @@ export function resetDailyStats(sessionId: string): void {
 }
 
 /**
- * Apply time-based decay to GFI using segmented exponential decay.
- * 
- * Decay rates:
- * - GFI >= 70 (severe): 3%/min - fast recovery to avoid prolonged blocking
- * - GFI 40-70 (moderate): 2%/min - medium decay
- * - GFI < 40 (mild): 1%/min - slow decay to retain as warning
- * 
- * Formula: GFI_new = GFI * (1 - λ)^elapsedMinutes
- * 
+ * Apply time-based decay to GFI using stage-aware linear decay.
+ * Delegates to core GFI kernel.
+ *
  * @param sessionId - The session to decay
  * @param elapsedMinutes - Minutes since last decay
  * @returns Updated session state, or undefined if session not found or GFI is 0
@@ -554,49 +566,23 @@ export function resetDailyStats(sessionId: string): void {
 export function decayGfi(sessionId: string, elapsedMinutes: number): SessionState | undefined {
     const state = sessions.get(sessionId);
     if (!state || state.currentGfi <= 0 || elapsedMinutes <= 0) return undefined;
-    
-    // Determine decay rate based on current GFI level (segmented)
-     
-    let decayRate: number;
-    if (state.currentGfi >= 70) {
-      decayRate = 0.03;  // 3%/min for severe friction
-    } else if (state.currentGfi >= 40) {
-      decayRate = 0.02;  // 2%/min for moderate friction
-    } else {
-      decayRate = 0.01;  // 1%/min for mild friction
-    }
-    
-    // Exponential decay: GFI_new = GFI * (1-λ)^Δt
-    const decayFactor = Math.pow(1 - decayRate, elapsedMinutes);
+
+    const coreState = toGfiState(state);
+    const stage = classifyGfiStage(state.currentGfi, DEFAULT_GFI_POLICY);
+    const nextCore = coreApplyDecay(coreState, elapsedMinutes, DEFAULT_GFI_POLICY, stage, Date.now());
     const previousGfi = state.currentGfi;
-    state.currentGfi = Math.max(0, state.currentGfi * decayFactor);
-    
-    // Apply same decay factor to all sources
-    const ledger = ensureGfiLedger(state);
-    for (const source of Object.keys(ledger)) {
-      ledger[source] = Math.max(0, ledger[source] * decayFactor);
-      // Remove sources that have decayed below 0.1
-      if (ledger[source] < 0.1) {
-        delete ledger[source];
-      }
-    }
-    
-    // Round to 1 decimal place
-    state.currentGfi = Math.round(state.currentGfi * 10) / 10;
-    
-    // Update last decay timestamp
-    state.lastGfiDecayAt = Date.now();
-    
+    applyGfiResult(state, nextCore);
+
     // Log if significant decay
     const decayedAmount = previousGfi - state.currentGfi;
     if (decayedAmount >= 1) {
       SystemLogger.log(
         state.workspaceDir,
         'GFI_DECAY',
-        `GFI decayed by ${decayedAmount.toFixed(1)} (${elapsedMinutes}min at ${decayRate*100}%/min). ${previousGfi.toFixed(1)} → ${state.currentGfi.toFixed(1)}`
+        `GFI decayed by ${decayedAmount.toFixed(1)} (${elapsedMinutes}min). ${previousGfi.toFixed(1)} → ${state.currentGfi.toFixed(1)}`
       );
     }
-    
+
     schedulePersistence(state);
     return state;
 }