principles-disciple 1.127.0 → 1.129.0

package/src/core/pain.ts

@@ -1,309 +0,0 @@
-import * as fs from 'fs';
-import { parseKvLines } from '../utils/io.js';
-import { resolvePdPath } from './paths.js';
-import { ConfigService } from './config-service.js';
-import { SystemLogger } from './system-logger.js';
-
-// =========================================================================
-// Legacy Pain Flag Contract (Compatibility Only)
-//
-// Runtime V2 pain diagnosis does NOT write .state/.pain_flag or consume it as
-// an entry point. New pain signals must enter through emitPainDetectedEvent() or
-// `pd pain record`, which both route to PainSignalBridge.
-//
-// The readers below remain only for legacy sleep-reflection context and
-// historical state inspection. They must not trigger the diagnostician.
-// =========================================================================
-
-/**
- * Required fields — every pain flag MUST have these.
- */
-export interface PainFlagData {
-  /** What triggered this pain signal (e.g., tool_failure, human_intervention, intercept_extraction) */
-  source: string;
-  /** Pain score 0-100 */
-  score: string;
-  /** ISO 8601 timestamp */
-  time: string;
-  /** Human-readable reason / error description */
-  reason: string;
-  /** Session ID — identifies which conversation this happened in */
-  session_id: string;
-  /** Agent ID — identifies which agent (main, builder, diagnostician, etc.) */
-  agent_id: string;
-  /** Whether this involves risky operation ('true' / 'false') */
-  is_risky: string;
-  /** Correlation trace ID (for linking events across the pipeline) */
-  trace_id: string;
-  /** Preview of the text that triggered this pain */
-  trigger_text_preview: string;
-  /** Trajectory pain_events row ID (set by recordPainEvent) */
-  pain_event_id?: string;
-}
-
-export interface PainFlagContractResult {
-  status: 'missing' | 'valid' | 'invalid';
-  format: 'missing' | 'empty' | 'kv' | 'json' | 'invalid_json';
-  data: Record<string, string>;
-  missingFields: string[];
-}
-
-/**
- * Builds legacy pain flag data for compatibility tests and historical readers.
- * Do not use this to create new Runtime V2 diagnosis requests.
- */
-export function buildPainFlag(input: {
-  source: string;
-  score: string;
-  time?: string;
-  reason: string;
-  session_id?: string;
-  agent_id?: string;
-  is_risky?: boolean;
-  trace_id?: string;
-  trigger_text_preview?: string;
-  pain_event_id?: string;
-}): PainFlagData {
-  // Omit optional fields when not provided — prevents writing empty lines to disk
-  // which causes agent confusion (SKILL.md vs reality drift)
-  return {
-    source: input.source,
-    score: input.score,
-    time: input.time || new Date().toISOString(),
-    reason: input.reason,
-    session_id: input.session_id ?? '',
-    agent_id: input.agent_id ?? '',
-    is_risky: input.is_risky ? 'true' : 'false',
-    trace_id: input.trace_id ?? '',
-    trigger_text_preview: input.trigger_text_preview ?? '',
-    pain_event_id: input.pain_event_id,
-  };
-}
-
-/**
- * Validates a pain flag read from disk.
- * Returns list of missing required fields — empty string means all present.
- */
-export function validatePainFlag(data: Record<string, string>): string[] {
-  const missing: string[] = [];
-  // Only source/score/time/reason are truly required — session_id/agent_id
-  // may be empty in automated contexts (heartbeat, background workers)
-  const required = ['source', 'score', 'time', 'reason'] as const;
-  for (const field of required) {
-    if (!data[field] || data[field].trim() === '') {
-      missing.push(field);
-    }
-  }
-  return missing;
-}
-
- 
-export function computePainScore(rc: number, isSpiral: boolean, missingTestCommand: boolean, softScore: number, projectDir?: string): number {
-  let score = Math.max(0, softScore || 0);
-  
-  const stateDir = projectDir ? resolvePdPath(projectDir, 'STATE_DIR') : undefined;
-  const config = stateDir ? ConfigService.get(stateDir) : null;
-  const scoreSettings = config ? config.get('scores') : {
-    exit_code_penalty: 70,
-    spiral_penalty: 40,
-    missing_test_command_penalty: 30
-  };
-
-  if (rc !== 0) {
-    score += scoreSettings.exit_code_penalty;
-  }
-
-  if (isSpiral) {
-    score += scoreSettings.spiral_penalty;
-  }
-
-  if (missingTestCommand) {
-    score += scoreSettings.missing_test_command_penalty;
-  }
-
-  return Math.min(100, score);
-}
-
-export function painSeverityLabel(painScore: number, isSpiral = false, projectDir?: string): string {
-  if (isSpiral) {
-    return "critical";
-  }
-
-  const stateDir = projectDir ? resolvePdPath(projectDir, 'STATE_DIR') : undefined;
-  const config = stateDir ? ConfigService.get(stateDir) : null;
-  const thresholds = config ? config.get('severity_thresholds') : {
-    high: 70,
-    medium: 40,
-    low: 20
-  };
-
-  if (painScore >= thresholds.high) {
-    return "high";
-  } else if (painScore >= thresholds.medium) {
-    return "medium";
-  } else if (painScore >= thresholds.low) {
-    return "low";
-  } else {
-    return "info";
-  }
-}
-
-/**
- * Converts a JSON pain flag object to KV format.
- */
-function convertJsonToKv(json: Record<string, unknown>): Record<string, string> {
-  const kvData: Record<string, string> = {};
-  const fieldMap: Record<string, string> = {
-    source: 'source',
-    score: 'score',
-    time: 'time',
-    timestamp: 'time',
-    reason: 'reason',
-    session_id: 'session_id',
-    sessionId: 'session_id',
-    agent_id: 'agent_id',
-    agentId: 'agent_id',
-    is_risky: 'is_risky',
-    isRisky: 'is_risky',
-    severity: 'severity',
-    painId: 'pain_id',
-  };
-  for (const [jsonKey, kvKey] of Object.entries(fieldMap)) {
-    if (json[jsonKey] !== undefined) {
-      kvData[kvKey] = String(json[jsonKey]);
-    }
-  }
-  for (const [key, value] of Object.entries(json)) {
-    if (fieldMap[key] === undefined && value !== undefined && value !== null) {
-      kvData[key] = String(value);
-    }
-  }
-  return kvData;
-}
-
-/**
- * Reads and validates the legacy pain flag file.
- *
- * - If file doesn't exist → returns {}
- * - If file is JSON format → converts to KV in memory only
- * - If file is KV format → validates required fields, logs warning if missing
- * - If file has unknown fields → silently ignores them (forward-compatible)
- */
-export function readPainFlagData(projectDir: string): Record<string, string> {
-  const painFlagPath = resolvePdPath(projectDir, 'PAIN_FLAG');
-  try {
-    if (!fs.existsSync(painFlagPath)) {
-      return {};
-    }
-    const content = fs.readFileSync(painFlagPath, "utf-8").trim();
-    if (!content) {
-      return {};
-    }
-
-    // Detect JSON format. Legacy compatibility only: parse in memory and do not
-    // rewrite .pain_flag, because Runtime V2 must not create or repair this file.
-    if (content.startsWith('{')) {
-       
-      let json: Record<string, unknown>;
-      try {
-        json = JSON.parse(content);
-      } catch {
-        SystemLogger.log(projectDir, 'PAIN_FLAG_CORRUPT', 'Pain flag file contains invalid JSON');
-        return {};
-      }
-
-      const kvData = convertJsonToKv(json);
-      SystemLogger.log(projectDir, 'PAIN_FLAG_LEGACY_JSON_READ', `Read legacy JSON pain flag in memory (${Object.keys(json).length} fields)`);
-      return kvData;
-    }
-
-    // KV format — parse and validate
-    const data = parseKvLines(content);
-    const missing = validatePainFlag(data);
-    if (missing.length > 0) {
-      SystemLogger.log(projectDir, 'PAIN_FLAG_INCOMPLETE', `Pain flag missing required fields: ${missing.join(', ')}`);
-    }
-    return data;
-  } catch (e) {
-    SystemLogger.log(projectDir, 'PAIN_FLAG_READ_ERROR', `Failed to read pain flag: ${String(e)}`);
-    return {};
-  }
-}
-
-export function readPainFlagContract(projectDir: string): PainFlagContractResult {
-  const data = readPainFlagData(projectDir);
-
-  if (Object.keys(data).length === 0) {
-    const painFlagPath = resolvePdPath(projectDir, 'PAIN_FLAG');
-    if (!fs.existsSync(painFlagPath)) {
-      return { status: 'missing', format: 'missing', data: {}, missingFields: [] };
-    }
-
-    const raw = fs.readFileSync(painFlagPath, 'utf-8').trim();
-    if (!raw) {
-      return { status: 'missing', format: 'empty', data: {}, missingFields: [] };
-    }
-
-    return {
-      status: 'invalid',
-      format: raw.startsWith('{') ? 'invalid_json' : 'kv',
-      data: {},
-      missingFields: ['unparseable'],
-    };
-  }
-
-  const missing = validatePainFlag(data);
-  return {
-    status: missing.length > 0 ? 'invalid' : 'valid',
-    format: 'kv',
-    data,
-    missingFields: missing,
-  };
-}
-
-/**
- * Track principle value metrics when a pain signal is written.
- * This is observation-only — it does NOT affect the pain flag write flow.
- * If any principle matches the pain signal, its painPreventedCount is incremented.
- * Errors are silently ignored to avoid disrupting the pain pipeline.
- */
- 
-     
-export function trackPrincipleValue(
-  workspaceDir: string,
-  painData: { reason?: string; source?: string; score?: string },
-  getActivePrinciples: () => {
-    id: string;
-    trigger: string;
-    valueMetrics?: { painPreventedCount: number; lastPainPreventedAt?: string; calculatedAt: string };
-  }[],
-  updatePrincipleMetrics: (_id: string, _metrics: { painPreventedCount: number; lastPainPreventedAt: string; calculatedAt: string }) => void,  
-): void {
-  try {
-    const activePrinciples = getActivePrinciples();
-    if (!activePrinciples.length) return;
-
-    const painText = `${painData.reason || ''} ${painData.source || ''}`.toLowerCase();
-    const now = new Date().toISOString();
-
-    for (const principle of activePrinciples) {
-      const triggerPattern = principle.trigger?.toLowerCase();
-      if (!triggerPattern) continue;
-
-      // Simple keyword match — if any word from the trigger appears in the pain text
-      const triggerWords = triggerPattern.split(/[\s|\\.+*?()[\]{}^$-]+/).filter((w) => w.length > 2);
-      const matchCount = triggerWords.filter((word) => painText.includes(word)).length;
-
-      if (matchCount >= 2 || (triggerWords.length <= 3 && matchCount >= 1)) {
-        const currentMetrics = principle.valueMetrics ?? { painPreventedCount: 0, calculatedAt: now };
-        updatePrincipleMetrics(principle.id, {
-          painPreventedCount: currentMetrics.painPreventedCount + 1,
-          lastPainPreventedAt: now,
-          calculatedAt: now,
-        });
-      }
-    }
-  } catch {
-    // Observation only — never disrupt the pain pipeline
-  }
-}

package/src/core/pd-config-loader.ts

@@ -1,400 +0,0 @@
-/**
- * PD Config Loader (Plugin I/O boundary) — PRI-307
- *
- * Reads `.pd/config.yaml`, validates via core, computes effective config.
- * Replaces the old `.pd/feature-flags.yaml` and `.state/workflows.yaml` reading
- * for plugin production paths.
- *
- * ADR-0016: PD owns exactly one user config file.
- * - Missing config → defaults with nextAction
- * - Malformed config → fail loud with errors and nextAction
- * - No secrets in output
- * - Observer disabled → no start / no noisy log cycling
- * - Observer enabled + missing setup → structured needs_setup + nextAction
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import yaml from 'js-yaml';
-import {
-  validatePdConfig,
-  computeEffectivePdConfig,
-  computeFeatureFlagsFromConfig,
-  INTERNAL_AGENT_NAMES,
-} from '@principles/core/runtime-v2';
-import type {
-  EffectivePdConfig,
-  PdConfigValidationResult,
-  InternalAgentName,
-} from '@principles/core/runtime-v2';
-
-// ── Constants ────────────────────────────────────────────────────────────────
-
-export const PD_CONFIG_DIR = '.pd';
-export const PD_CONFIG_FILENAME = 'config.yaml';
-
-// ── Types ────────────────────────────────────────────────────────────────────
-
-export type ObserverReadiness = 'disabled' | 'needs_setup' | 'ready' | 'not_ready' | 'config_malformed';
-
-export interface ObserverConfigResult {
-  /** Whether the observer feature is enabled in config */
-  enabled: boolean;
-  /** Observer readiness state */
-  readiness: ObserverReadiness;
-  /** Config source: 'defaults' | 'user_config' | 'malformed' */
-  source: string;
-  /** Reason for current state */
-  reason: string;
-  /** What the user should do next */
-  nextAction: string;
-  /** The runtime profile ID for this observer, if configured */
-  runtimeProfileId: string | null;
-  /** The runtime profile type, if configured */
-  runtimeProfileType: string | null;
-  /** The apiKeyEnv for the runtime profile, if applicable */
-  apiKeyEnv: string | null;
-  /** Whether the apiKeyEnv is present in process.env */
-  apiKeyPresent: boolean;
-  /** Provider name from runtime profile */
-  provider: string | null;
-  /** Model name from runtime profile */
-  model: string | null;
-  /** Timeout from runtime profile */
-  timeoutMs: number | null;
-  /** Base URL from runtime profile */
-  baseUrl: string | null;
-  /** Config validation errors (only present when readiness=config_malformed) */
-  configErrors?: Array<{ path: string; reason: string; nextAction: string }>;
-}
-
-export interface PluginConfigLoadResult {
-  ok: boolean;
-  effective: EffectivePdConfig;
-  source: 'defaults' | 'user_config' | 'malformed';
-  configPath: string;
-  warnings: string[];
-  errors: Array<{ path: string; reason: string; nextAction: string }>;
-}
-
-// ── Config Path ──────────────────────────────────────────────────────────────
-
-export function getPdConfigPath(workspaceDir: string): string {
-  return path.join(workspaceDir, PD_CONFIG_DIR, PD_CONFIG_FILENAME);
-}
-
-// ── Load PD Config ───────────────────────────────────────────────────────────
-
-/**
- * Load and validate `.pd/config.yaml` from the workspace.
- * Never throws on malformed input. Always provides a usable fallback.
- */
-export function loadPdConfigForPlugin(workspaceDir: string): PluginConfigLoadResult {
-  const configPath = getPdConfigPath(workspaceDir);
-
-  // 1) Config file missing → use defaults
-  if (!fs.existsSync(configPath)) {
-    const effective = computeEffectivePdConfig(null);
-    return {
-      ok: true,
-      effective,
-      source: 'defaults',
-      configPath,
-      warnings: effective.warnings,
-      errors: [],
-    };
-  }
-
-  // 2) Read the file
-  let raw: string;
-  try {
-    raw = fs.readFileSync(configPath, 'utf8');
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const effective = computeEffectivePdConfig(null);
-    return {
-      ok: false,
-      effective,
-      source: 'malformed',
-      configPath,
-      warnings: [],
-      errors: [{ path: '', reason: `Failed to read .pd/config.yaml: ${message}`, nextAction: 'Check file permissions for .pd/config.yaml' }],
-    };
-  }
-
-  // 3) Parse YAML — treat as unknown (ERR-001)
-  let parsed: unknown;
-  try {
-    parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const effective = computeEffectivePdConfig(null);
-    return {
-      ok: false,
-      effective,
-      source: 'malformed',
-      configPath,
-      warnings: [],
-      errors: [{ path: '', reason: `YAML parse error in .pd/config.yaml: ${message}`, nextAction: 'Fix YAML syntax in .pd/config.yaml' }],
-    };
-  }
-
-  // 4) Validate via core (ERR-001, ERR-005: no `as` bypasses)
-  const validationResult: PdConfigValidationResult = validatePdConfig(parsed);
-
-  if (!validationResult.ok) {
-    const effective = computeEffectivePdConfig(null);
-    return {
-      ok: false,
-      effective,
-      source: 'malformed',
-      configPath,
-      warnings: [],
-      errors: validationResult.errors.map(e => ({
-        path: e.path,
-        reason: e.reason,
-        nextAction: e.nextAction,
-      })),
-    };
-  }
-
-  // 5) Compute effective config
-  const effective = computeEffectivePdConfig(validationResult.value);
-
-  return {
-    ok: true,
-    effective,
-    source: 'user_config',
-    configPath,
-    warnings: effective.warnings,
-    errors: [],
-  };
-}
-
-// ── Feature Flag from Config ─────────────────────────────────────────────────
-
-/**
- * Get a single feature flag's enabled state from .pd/config.yaml.
- * Replaces the old `loadFeatureFlagFromWorkspace` which read .pd/feature-flags.yaml.
- */
-export function loadFeatureFlagFromConfig(
-  workspaceDir: string,
-  flagId: string,
-  logger?: { warn?: (msg: string) => void; info?: (msg: string) => void },
-): { enabled: boolean; source: string } {
-  const result = loadPdConfigForPlugin(workspaceDir);
-  const flags = computeFeatureFlagsFromConfig(result.effective);
-  const flag = flags.flags[flagId];
-
-  if (!result.ok) {
-    logger?.warn?.(`[PD:Config] Config validation failed: ${result.errors.map(e => e.reason).join('; ')} — using defaults`);
-  }
-
-  return {
-    enabled: flag?.enabled ?? false,
-    source: result.source,
-  };
-}
-
-// ── Observer Config Resolution ───────────────────────────────────────────────
-
-/**
- * Resolve observer configuration from .pd/config.yaml.
- *
- * Returns structured state:
- * - config_malformed: config file is invalid — no guessing, fail loud
- * - disabled: observer feature flag is off OR agent.enabled=false → no start, no noisy logs
- * - needs_setup: observer enabled but runtime profile missing, API key not set, or unsupported profile type
- * - ready: observer enabled and fully configured (pi-ai with key present)
- * - not_ready: observer enabled, API key present, but runtime availability unknown
- */
-export function resolveObserverConfig(
-  workspaceDir: string,
-  observerFlagId: string,
-  observerAgentName: string,
-  _logger?: { warn?: (msg: string) => void; info?: (msg: string) => void; debug?: (msg: string) => void },
-): ObserverConfigResult {
-  const result = loadPdConfigForPlugin(workspaceDir);
-
-  // 0) Malformed config → fail loud, do NOT swallow as "disabled"
-  if (!result.ok) {
-    return {
-      enabled: false,
-      readiness: 'config_malformed',
-      source: 'malformed',
-      reason: `Config validation failed: ${result.errors.map(e => e.reason).join('; ')}`,
-      nextAction: result.errors[0]?.nextAction ?? 'Fix .pd/config.yaml and retry',
-      runtimeProfileId: null,
-      runtimeProfileType: null,
-      apiKeyEnv: null,
-      apiKeyPresent: false,
-      provider: null,
-      model: null,
-      timeoutMs: null,
-      baseUrl: null,
-      configErrors: result.errors,
-    };
-  }
-
-  const config = result.effective.config;
-
-  // 1) Check if the observer feature flag is enabled
-  const featureFlag = config.features[observerFlagId];
-  if (!featureFlag || !featureFlag.enabled) {
-    return {
-      enabled: false,
-      readiness: 'disabled',
-      source: result.source,
-      reason: `${observerFlagId} is disabled in .pd/config.yaml`,
-      nextAction: `Set features.${observerFlagId}.enabled=true in .pd/config.yaml to enable`,
-      runtimeProfileId: null,
-      runtimeProfileType: null,
-      apiKeyEnv: null,
-      apiKeyPresent: false,
-      provider: null,
-      model: null,
-      timeoutMs: null,
-      baseUrl: null,
-    };
-  }
-
-  // 2) Check if the agent itself is enabled (feature flag ≠ agent.enabled)
-  const knownNames: readonly string[] = INTERNAL_AGENT_NAMES;
-  if (!knownNames.includes(observerAgentName)) {
-    return {
-      enabled: false,
-      readiness: 'needs_setup',
-      source: result.source,
-      reason: `Unknown agent name '${observerAgentName}'`,
-      nextAction: `Use one of the known agent names: ${INTERNAL_AGENT_NAMES.join(', ')}`,
-      runtimeProfileId: null,
-      runtimeProfileType: null,
-      apiKeyEnv: null,
-      apiKeyPresent: false,
-      provider: null,
-      model: null,
-      timeoutMs: null,
-      baseUrl: null,
-    };
-  }
-  const agentKey = observerAgentName as InternalAgentName;
-  const agentConfig = config.internalAgents.agents[agentKey];
-
-  // Feature flag on but agent.enabled=false → disabled (not enabled)
-  if (!agentConfig || !agentConfig.enabled) {
-    return {
-      enabled: false,
-      readiness: 'disabled',
-      source: result.source,
-      reason: `${observerFlagId} feature flag is enabled but internalAgents.agents.${observerAgentName}.enabled is false`,
-      nextAction: `Set internalAgents.agents.${observerAgentName}.enabled=true in .pd/config.yaml, or disable features.${observerFlagId}`,
-      runtimeProfileId: null,
-      runtimeProfileType: null,
-      apiKeyEnv: null,
-      apiKeyPresent: false,
-      provider: null,
-      model: null,
-      timeoutMs: null,
-      baseUrl: null,
-    };
-  }
-
-  // 3) Find the agent's runtime profile
-  const runtimeProfileId = agentConfig.runtimeProfile ?? config.internalAgents.defaultRuntime;
-  const profile = config.runtimeProfiles[runtimeProfileId];
-
-  if (!profile) {
-    return {
-      enabled: true,
-      readiness: 'needs_setup',
-      source: result.source,
-      reason: `Runtime profile '${runtimeProfileId}' not found in .pd/config.yaml`,
-      nextAction: `Add runtime profile '${runtimeProfileId}' to .pd/config.yaml runtimeProfiles`,
-      runtimeProfileId,
-      runtimeProfileType: null,
-      apiKeyEnv: null,
-      apiKeyPresent: false,
-      provider: null,
-      model: null,
-      timeoutMs: null,
-      baseUrl: null,
-    };
-  }
-
-  // 4) For pi-ai profiles, check API key
-  if (profile.type === 'pi-ai') {
-    const apiKeyEnv = profile.apiKeyEnv ?? null;
-    const apiKeyPresent = !!apiKeyEnv && Object.prototype.hasOwnProperty.call(process.env, apiKeyEnv) && !!process.env[apiKeyEnv];
-
-    if (!apiKeyEnv) {
-      return {
-        enabled: true,
-        readiness: 'needs_setup',
-        source: result.source,
-        reason: `pi-ai profile '${runtimeProfileId}' missing apiKeyEnv`,
-        nextAction: `Add apiKeyEnv to runtime profile '${runtimeProfileId}' in .pd/config.yaml`,
-        runtimeProfileId,
-        runtimeProfileType: profile.type,
-        apiKeyEnv: null,
-        apiKeyPresent: false,
-        provider: profile.provider ?? null,
-        model: profile.model ?? null,
-        timeoutMs: profile.timeoutMs ?? null,
-        baseUrl: profile.baseUrl ?? null,
-      };
-    }
-
-    if (!apiKeyPresent) {
-      return {
-        enabled: true,
-        readiness: 'needs_setup',
-        source: result.source,
-        reason: `Environment variable '${apiKeyEnv}' is not set or empty`,
-        nextAction: `Set the environment variable '${apiKeyEnv}' with a valid API key`,
-        runtimeProfileId,
-        runtimeProfileType: profile.type,
-        apiKeyEnv,
-        apiKeyPresent: false,
-        provider: profile.provider ?? null,
-        model: profile.model ?? null,
-        timeoutMs: profile.timeoutMs ?? null,
-        baseUrl: profile.baseUrl ?? null,
-      };
-    }
-
-    // pi-ai with key present — runtime availability unknown without actual probe
-    return {
-      enabled: true,
-      readiness: 'not_ready',
-      source: result.source,
-      reason: `pi-ai profile configured with apiKeyEnv='${apiKeyEnv}' (key present); runtime availability unknown`,
-      nextAction: 'Run pd runtime probe to verify end-to-end connectivity',
-      runtimeProfileId,
-      runtimeProfileType: profile.type,
-      apiKeyEnv,
-      apiKeyPresent: true,
-      provider: profile.provider ?? null,
-      model: profile.model ?? null,
-      timeoutMs: profile.timeoutMs ?? null,
-      baseUrl: profile.baseUrl ?? null,
-    };
-  }
-
-  // 5) OpenClaw profile — CorrectionObserver does NOT support OpenClaw runtime
-  //    Mark as needs_setup with nextAction to configure a pi-ai profile
-  return {
-    enabled: true,
-    readiness: 'needs_setup',
-    source: result.source,
-    reason: `OpenClaw profile '${runtimeProfileId}' is not supported for observer runtime. Observers require a pi-ai profile with an API key.`,
-    nextAction: `Configure a pi-ai runtime profile for ${observerAgentName} in .pd/config.yaml (e.g., add a pi-ai profile with provider, model, and apiKeyEnv)`,
-    runtimeProfileId,
-    runtimeProfileType: profile.type,
-    apiKeyEnv: null,
-    apiKeyPresent: false,
-    provider: profile.provider ?? null,
-    model: profile.model ?? null,
-    timeoutMs: null,
-    baseUrl: null,
-  };
-}