create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/core/behavior-example-pack-assembler.js

@@ -1,207 +0,0 @@
-/**
- * PRI-484 — Phase 5 Task 28 — BehaviorExamplePackAssembler (plugin I/O)
- *
- * Reads pain lineage + trajectory rows from TrajectoryDatabase and assembles
- * a validated BehaviorExamplePack for the Artificer. Fail loud on any gap
- * (missing pain, empty trajectory, invalid pack) — no silent fallback.
- *
- * Err-prevention:
- *   - ERR-001: every DB row field validated as `unknown` (no `as` bypass on
- *     parsed params_json or row casts).
- *   - ERR-069: Artificer shared schema — invalid pack must fail loud.
- *   - ERR-026: reuses production TrajectoryDatabase (no hand-written DDL).
- *   - rc-2: structural type guards, no `as T` on parsed input.
- *   - rc-5: Object.hasOwn over `in`.
- *   - rc-9: every failure path throws a structured Error with a clear reason.
- *
- * Spec: docs/superpowers/specs/2026-06-27-rulecode-context-vision-design.md §7.2
- *
- * Boundary: this module is I/O. Pure logic (type + validator) lives in
- * `@principles/core/runtime-v2` → `behavior-example-pack.ts`.
- */
-import { buildRuleHostAction, computeBehaviorFacts, validateBehaviorExamplePack, } from '@principles/core/runtime-v2';
-import { TrajectoryRegistry } from './trajectory.js';
-import { assembleHistoryFromRows } from './rule-context-assembler.js';
-// ── internal constants ─────────────────────────────────────────────────────
-const MAX_POSITIVES = 3;
-const MAX_EVIDENCE_REFS = 5;
-const HISTORY_LIMIT = 100;
-const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-// ── type guards (rc-2: no `as` bypass) ─────────────────────────────────────
-function isPlainObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function hasNoProtoKeys(value) {
-    for (const key of Object.keys(value)) {
-        if (PROTO_KEYS.has(key))
-            return false;
-    }
-    return true;
-}
-// ── BehaviorExamplePackAssembler ───────────────────────────────────────────
-/**
- * Plugin I/O assembler: pain lineage + trajectory → validated BehaviorExamplePack.
- *
- * Lifecycle: cheap to construct; obtains TrajectoryDatabase via the registry.
- * Dispose is the registry's responsibility (singleton per workspace).
- */
-export class BehaviorExamplePackAssembler {
-    db;
-    constructor(opts) {
-        // TrajectoryRegistry.get returns the workspace-wide singleton; do NOT
-        // dispose it here. The caller (typically a workspace lifecycle hook)
-        // owns dispose.
-        this.db = TrajectoryRegistry.get(opts.workspaceDir);
-    }
-    /** Assemble only from explicit Owner labels; execution outcome is not a label. */
-    assemble(input) {
-        const pain = this.db.getPainEventByCanonicalId(input.sourcePainId);
-        if (!pain) {
-            throw new Error(`[BehaviorExamplePackAssembler] pain event not found for canonical_pain_id="${input.sourcePainId}" (ERR-069 fail loud)`);
-        }
-        validateOwnerSelection(input);
-        const negativeRow = requireSelectedRow(this.db.getRuleHostEvidenceRow(input.sourceNegativeToolCallId), input.sourceNegativeToolCallId);
-        const positiveRows = input.positiveToolCallIds.map((id) => requireSelectedRow(this.db.getRuleHostEvidenceRow(id), id));
-        for (const row of [negativeRow, ...positiveRows]) {
-            if (row.sessionId !== pain.sessionId) {
-                throw new Error(`[BehaviorExamplePackAssembler] selected tool call ${row.id} session mismatch; all examples must belong to pain session ${pain.sessionId}`);
-            }
-        }
-        const redactionNotes = [];
-        const buildCtx = { projectDir: input.projectDir, redactionNotes };
-        const sourceNegativeCase = this.buildSelectedCase(negativeRow, 'negative', 'block', buildCtx);
-        const positiveCounterexamples = positiveRows.map((row) => this.buildSelectedCase(row, 'positive', 'allow', buildCtx));
-        const pack = {
-            sourceNegativeCase,
-            ownerDesiredOutcome: input.ownerDesiredOutcome,
-            positiveCounterexamples,
-            evidenceRefs: [`pain:${pain.id}`, `tool_call:${negativeRow.id}`, ...positiveRows.map((row) => `tool_call:${row.id}`)].slice(0, MAX_EVIDENCE_REFS),
-            redactionNotes,
-        };
-        // ── 9. Validate — fail loud (ERR-069) ──
-        const validation = validateBehaviorExamplePack(pack);
-        if (!validation.valid) {
-            throw new Error(`[BehaviorExamplePackAssembler] assembled pack failed validateBehaviorExamplePack: ${validation.errors.join('; ')} (ERR-069 fail loud)`);
-        }
-        return pack;
-    }
-    buildSelectedCase(row, kind, expectedDecision, ctx) {
-        const { projectDir, redactionNotes } = ctx;
-        const base = buildCaseFromRow(row, kind, expectedDecision, projectDir);
-        const redaction = redactParams(base.params, projectDir);
-        redactionNotes.push(...redaction.notes);
-        const historyResult = this.db.getRuleHostContextRowsBefore(row.sessionId, row.id, HISTORY_LIMIT);
-        const history = assembleHistoryFromRows(historyResult.rows, historyResult.truncated, projectDir);
-        const action = buildRuleHostAction(row.toolName, redaction.redacted, projectDir);
-        const ruleContext = { version: 2, history, facts: computeBehaviorFacts(history, action.normalizedPath || null, null) };
-        return { ...base, params: redaction.redacted, ruleContext };
-    }
-}
-function validateOwnerSelection(input) {
-    if (!Number.isSafeInteger(input.sourceNegativeToolCallId) || input.sourceNegativeToolCallId <= 0) {
-        throw new Error('[BehaviorExamplePackAssembler] sourceNegativeToolCallId must be a positive integer');
-    }
-    if (!Array.isArray(input.positiveToolCallIds) || input.positiveToolCallIds.length === 0 || input.positiveToolCallIds.length > MAX_POSITIVES) {
-        throw new Error('[BehaviorExamplePackAssembler] positiveToolCallIds must contain 1 to at most 3 IDs');
-    }
-    const allIds = [input.sourceNegativeToolCallId, ...input.positiveToolCallIds];
-    if (allIds.some((id) => !Number.isSafeInteger(id) || id <= 0) || new Set(allIds).size !== allIds.length) {
-        throw new Error('[BehaviorExamplePackAssembler] selected tool call IDs must be unique positive integers');
-    }
-}
-function requireSelectedRow(row, id) {
-    if (!row)
-        throw new Error(`[BehaviorExamplePackAssembler] selected tool call id=${id} not found`);
-    return row;
-}
-// ── internal: case builder ─────────────────────────────────────────────────
-/**
- * Build a GoldenTraceCaseInput from a trajectory tool_call row.
- *
- * ERR-001: parses params_json as unknown and structurally validates (must be
- * a plain object without proto-pollution keys). Throws on malformed input
- * (rc-9: no silent fallback).
- */
-function buildCaseFromRow(row, kind, expectedDecision, _projectDir) {
-    if (typeof row.toolName !== 'string' || row.toolName.length === 0) {
-        throw new Error(`[BehaviorExamplePackAssembler] row id=${row.id}: toolName must be a non-empty string (rc-9 fail loud)`);
-    }
-    if (typeof row.paramsJson !== 'string') {
-        throw new Error(`[BehaviorExamplePackAssembler] row id=${row.id}: paramsJson must be a string (rc-9 fail loud)`);
-    }
-    let parsedParams;
-    try {
-        parsedParams = JSON.parse(row.paramsJson);
-    }
-    catch {
-        throw new Error(`[BehaviorExamplePackAssembler] row id=${row.id}: paramsJson is not valid JSON (rc-9 fail loud)`);
-    }
-    if (!isPlainObject(parsedParams)) {
-        throw new Error(`[BehaviorExamplePackAssembler] row id=${row.id}: paramsJson must parse to a non-array object (rc-9 fail loud)`);
-    }
-    if (!hasNoProtoKeys(parsedParams)) {
-        throw new Error(`[BehaviorExamplePackAssembler] row id=${row.id}: paramsJson must not carry prototype-pollution keys (ERR-076, rc-9 fail loud)`);
-    }
-    return {
-        caseId: `case-${kind}-${row.id}`,
-        kind,
-        toolName: row.toolName,
-        params: parsedParams,
-        expectedDecision,
-    };
-}
-/**
- * Redact sensitive fields from tool call params before they enter the pack.
- *
- * First-version policy:
- *   - Absolute paths outside the project tree → replaced with `<redacted:absolute-path>`
- *   - String values that look like secrets (long base64 / AKIA-style keys / etc.)
- *     → replaced with `<redacted:secret>`
- *
- * Records each redaction in `notes` so the Artificer and the owner can see
- * what was stripped (spec §7.2: redactionNotes is part of the pack contract).
- */
-function redactParams(params, projectDir) {
-    const notes = [];
-    const redacted = {};
-    for (const key of Object.keys(params)) {
-        if (PROTO_KEYS.has(key))
-            continue; // defense in depth (ERR-076)
-        const value = params[key];
-        if (typeof value !== 'string') {
-            redacted[key] = value;
-            continue;
-        }
-        // Path-like values
-        if (looksLikeAbsolutePath(value) && !value.startsWith(projectDir)) {
-            redacted[key] = '<redacted:absolute-path>';
-            notes.push(`redacted absolute path in field "${key}" (outside project tree)`);
-            continue;
-        }
-        // Secret-like values (AWS keys, long base64 tokens, etc.)
-        if (looksLikeSecret(value)) {
-            redacted[key] = '<redacted:secret>';
-            notes.push(`redacted possible secret in field "${key}"`);
-            continue;
-        }
-        redacted[key] = value;
-    }
-    return { redacted, notes };
-}
-function looksLikeAbsolutePath(value) {
-    // POSIX absolute path or Windows drive path
-    return value.startsWith('/') || /^[A-Za-z]:[\\/]/.test(value);
-}
-const SECRET_PATTERNS = [
-    /AKIA[0-9A-Z]{16}/, // AWS access key ID
-    /[A-Za-z0-9+/]{40,}/, // long base64-ish token (≥40 chars, no spaces)
-];
-function looksLikeSecret(value) {
-    if (value.length < 20)
-        return false; // too short to be a real secret
-    for (const pattern of SECRET_PATTERNS) {
-        if (pattern.test(value))
-            return true;
-    }
-    return false;
-}

package/plugin/dist/core/bootstrap-rules.js

@@ -1,187 +0,0 @@
-/**
- * Minimal Rule Bootstrap (Phase 17)
- *
- * Bootstraps 1-3 stub Rule entities for high-value deterministic principles.
- * Selected by: observedViolationCount (descending) + evaluability=deterministic.
- * Falls back to all deterministic principles if violation data is sparse.
- *
- * Rule ID format: {principleId}_stub_bootstrap
- * Scope: BOOT-03 — bounded, no mass migration, no implementations.
- *
- * Usage:
- *   npx vitest run tests/core/bootstrap-rules.test.ts   (tests)
- *   npm run bootstrap-rules                               (production)
- */
-import { loadLedger, createRule, updatePrinciple, addPrincipleToLedger } from './principle-tree-ledger.js';
-import { loadStore } from './principle-training-state.js';
-import { CORE_THINKING_MODELS } from './init.js';
-/**
- * Select principles for bootstrap based on violation count and evaluability.
- *
- * @param stateDir - State directory path
- * @param limit - Maximum number of principles to select (default: 3)
- * @returns Array of principle IDs sorted by observedViolationCount (descending)
- * @throws Error if no deterministic principles found
- */
-export function selectPrinciplesForBootstrap(stateDir, limit = 3) {
-    // Load training store to get evaluability and violation data
-    const store = loadStore(stateDir);
-    // Filter for deterministic principles only
-    const deterministicEntries = Object.values(store).filter((entry) => entry.evaluability === 'deterministic');
-    if (deterministicEntries.length === 0) {
-        throw new Error('No deterministic principles found in training store');
-    }
-    // Sort by observedViolationCount descending, then by principleId for tiebreaker
-    const sorted = deterministicEntries.sort((a, b) => {
-        const violationDiff = b.observedViolationCount - a.observedViolationCount;
-        if (violationDiff !== 0) {
-            return violationDiff;
-        }
-        // Alphabetical tiebreaker
-        return a.principleId.localeCompare(b.principleId);
-    });
-    // Check if we have sparse violation data (all zeros or very low)
-    const hasViolations = sorted.some((entry) => entry.observedViolationCount > 0);
-    if (!hasViolations) {
-        // Log warning and use all deterministic principles
-        console.warn('[bootstrap] No violation data found, using all deterministic principles');
-    }
-    // Return top N
-    return sorted.slice(0, limit).map((entry) => entry.principleId);
-}
-/**
- * Bootstrap stub rules for selected principles.
- *
- * Creates stub Rule entities with format {principleId}_stub_bootstrap.
- * Links rules to principles via suggestedRules array.
- * Idempotent: skips existing rules.
- *
- * @param stateDir - State directory path
- * @param limit - Maximum number of principles to bootstrap (default: 3)
- * @returns Array of results indicating created or skipped status
- * @throws Error if no deterministic principles found
- */
-export function bootstrapRules(stateDir, limit = 3) {
-    // Migration: if T-01..T-10 exist in Training Store but not in Ledger Tree, backfill.
-    // This handles workspaces initialized before Ledger Tree was added.
-    const store = loadStore(stateDir);
-    let ledger = loadLedger(stateDir);
-    const hasTrainingT = Object.keys(store).some((id) => id.startsWith('T-'));
-    const hasAnyLedgerT = Object.keys(ledger.tree.principles).some((id) => id.startsWith('T-'));
-    if (hasTrainingT && !hasAnyLedgerT) {
-        console.warn('[bootstrap] Migrating T-01..T-10 from Training Store to Ledger Tree');
-        const now = new Date().toISOString();
-        for (const [id, entry] of Object.entries(store)) {
-            if (!id.startsWith('T-'))
-                continue;
-            const model = CORE_THINKING_MODELS.find((m) => m.id === id);
-            if (!model)
-                continue;
-            const lp = {
-                id,
-                version: 1,
-                text: model.description,
-                coreAxiomId: id,
-                triggerPattern: '',
-                action: '',
-                status: 'active',
-                priority: 'P1',
-                scope: 'general',
-                evaluability: entry.evaluability,
-                valueScore: 0,
-                adherenceRate: 0,
-                painPreventedCount: 0,
-                derivedFromPainIds: [],
-                ruleIds: [],
-                conflictsWithPrincipleIds: [],
-                createdAt: now,
-                updatedAt: now,
-                suggestedRules: [],
-            };
-            addPrincipleToLedger(stateDir, lp);
-        }
-        // Reload ledger after migration so subsequent reads see the new data.
-        ledger = loadLedger(stateDir);
-    }
-    // Select principles for bootstrap
-    const selectedPrincipleIds = selectPrinciplesForBootstrap(stateDir, limit);
-    const results = [];
-    for (const principleId of selectedPrincipleIds) {
-        // Verify principle exists in ledger
-        const principle = ledger.tree.principles[principleId];
-        if (!principle) {
-            throw new Error(`Principle ${principleId} not found in ledger tree`);
-        }
-        // Compute rule ID
-        const ruleId = `${principleId}_stub_bootstrap`;
-        // Check if rule already exists
-        if (ledger.tree.rules[ruleId]) {
-            results.push({
-                principleId,
-                ruleId,
-                status: 'skipped',
-            });
-            continue;
-        }
-        // Create stub rule
-        const now = new Date().toISOString();
-        createRule(stateDir, {
-            id: ruleId,
-            version: 1,
-            name: `Stub bootstrap rule for ${principleId}`,
-            description: `Placeholder rule for principle-internalization bootstrap`,
-            type: 'hook',
-            triggerCondition: 'stub: bootstrap placeholder',
-            enforcement: 'warn',
-            action: 'allow (stub)',
-            principleId,
-            status: 'proposed',
-            coverageRate: 0,
-            falsePositiveRate: 0,
-            implementationIds: [],
-            createdAt: now,
-            updatedAt: now,
-        });
-        // Link rule to principle via suggestedRules
-        const existingSuggested = principle.suggestedRules || [];
-        updatePrinciple(stateDir, principleId, {
-            suggestedRules: [...existingSuggested, ruleId],
-        });
-        results.push({
-            principleId,
-            ruleId,
-            status: 'created',
-        });
-    }
-    return results;
-}
-/**
- * Validate that bootstrapped state is correct.
- *
- * @param stateDir - State directory path
- * @param expectedPrincipleIds - Principle IDs that should be bootstrapped
- * @returns true if validation passes
- * @throws Error if validation fails
- */
-export function validateBootstrap(stateDir, expectedPrincipleIds) {
-    const ledger = loadLedger(stateDir);
-    for (const principleId of expectedPrincipleIds) {
-        // Verify principle exists
-        const principle = ledger.tree.principles[principleId];
-        if (!principle) {
-            throw new Error(`Principle ${principleId} not found in ledger tree`);
-        }
-        // Verify suggestedRules exists and is not empty
-        if (!principle.suggestedRules || principle.suggestedRules.length === 0) {
-            throw new Error(`Principle ${principleId} has empty or missing suggestedRules`);
-        }
-        // Verify each suggested rule exists in ledger
-        for (const ruleId of principle.suggestedRules) {
-            const rule = ledger.tree.rules[ruleId];
-            if (!rule) {
-                throw new Error(`Rule ${ruleId} referenced by principle ${principleId} not found in ledger`);
-            }
-        }
-    }
-    return true;
-}

package/plugin/dist/core/code-implementation-storage.js

@@ -1,139 +0,0 @@
-/**
- * Code Implementation Asset Storage
- * ================================
- *
- * Manages versioned code implementation assets: manifests, entry files,
- * and metadata pointers for Implementation(type=code) records.
- *
- * DESIGN CONSTRAINTS (per D-09 through D-12):
- *   - Manifest is loading metadata, NOT the source of truth for lifecycle state (D-11)
- *   - The Principle Tree ledger remains canonical for lifecycle and relationships (D-11)
- *   - Asset root follows the PD stateDir convention:
- *     {stateDir}/principles/implementations/{implId}/
- *   - All writes use withLock for atomicity (matching ledger pattern)
- *   - This module does NOT implement replay execution, evaluation report generation,
- *     or promotion logic (D-12)
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { withLock } from '../utils/file-lock.js';
-import { atomicWriteFileSync } from '../utils/io.js';
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const MANIFEST_FILENAME = 'manifest.json';
-const ENTRY_FILENAME = 'entry.js';
-const REPLAYS_DIRNAME = 'replays';
-// ---------------------------------------------------------------------------
-// Path validation
-// ---------------------------------------------------------------------------
-/**
- * Validate that an implId contains no path separators.
- * implId comes from ledger record IDs (controlled namespace), but we
- * validate to prevent path traversal (T-12-08).
- */
-function validateImplId(implId) {
-    if (implId.includes('/') || implId.includes('\\') || implId.includes('..')) {
-        throw new Error(`Invalid implementation ID: "${implId}" contains path separators`);
-    }
-    if (!implId) {
-        throw new Error('Implementation ID must not be empty');
-    }
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function ensureDir(dir) {
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Get the absolute path for an implementation's asset root.
- * Convention: {stateDir}/principles/implementations/{implId}/
- */
-export function getImplementationAssetRoot(stateDir, implId) {
-    validateImplId(implId);
-    return path.join(stateDir, 'principles', 'implementations', implId);
-}
-/**
- * Write manifest atomically using withLock.
- */
-export function writeManifest(stateDir, implId, manifest) {
-    validateImplId(implId);
-    const assetRoot = getImplementationAssetRoot(stateDir, implId);
-    const manifestPath = path.join(assetRoot, MANIFEST_FILENAME);
-    ensureDir(assetRoot);
-    withLock(manifestPath, () => {
-        atomicWriteFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-    });
-}
-export function writeEntrySource(stateDir, implId, sourceCode, entryFile = ENTRY_FILENAME) {
-    validateImplId(implId);
-    const assetRoot = getImplementationAssetRoot(stateDir, implId);
-    const entryPath = path.join(assetRoot, entryFile);
-    ensureDir(assetRoot);
-    withLock(entryPath, () => {
-        atomicWriteFileSync(entryPath, sourceCode);
-    });
-}
-export function deleteImplementationAssetDir(stateDir, implId) {
-    validateImplId(implId);
-    const assetRoot = getImplementationAssetRoot(stateDir, implId);
-    if (!fs.existsSync(assetRoot)) {
-        return;
-    }
-    withLock(assetRoot, () => {
-        fs.rmSync(assetRoot, { recursive: true, force: true });
-    });
-}
-/**
- * Create the full asset directory structure for a new implementation.
- *
- * Creates:
- *   {implId}/            - asset root
- *   {implId}/entry.js    - placeholder entry point (only if not already present)
- *   {implId}/manifest.json - asset manifest with version and timestamps
- *   {implId}/replays/    - empty directory for future replay reports
- *
- * Idempotent: calling again with the same implId will NOT overwrite an existing entry.js.
- */
-export function createImplementationAssetDir(stateDir, implId, version, options = {}) {
-    validateImplId(implId);
-    const assetRoot = getImplementationAssetRoot(stateDir, implId);
-    const replaysDir = path.join(assetRoot, REPLAYS_DIRNAME);
-    const entryPath = path.join(assetRoot, ENTRY_FILENAME);
-    const entrySource = options.entrySource ??
-        [
-            '// Code implementation entry point',
-            '// Exports: meta (RuleHostMeta), evaluate (input: RuleHostInput) => RuleHostResult',
-            '// This file will be replaced by nocturnal candidate generation (Phase 14)',
-            'export const meta = { name: "placeholder", version: "0.0.1", ruleId: "", coversCondition: "" };',
-            'export function evaluate(input) { return { decision: "allow", matched: false, reason: "placeholder" }; }',
-        ].join('\n');
-    withLock(assetRoot, () => {
-        ensureDir(assetRoot);
-        ensureDir(replaysDir);
-        if (!fs.existsSync(entryPath)) {
-            atomicWriteFileSync(entryPath, entrySource);
-        }
-    });
-    if (fs.existsSync(entryPath) && options.entrySource) {
-        writeEntrySource(stateDir, implId, options.entrySource);
-    }
-    const now = new Date().toISOString();
-    const manifest = {
-        version,
-        entryFile: ENTRY_FILENAME,
-        createdAt: now,
-        updatedAt: now,
-        replaySampleRefs: [],
-        lastEvalReportRef: null,
-        ...(options.lineage ? { lineage: options.lineage } : {}),
-    };
-    writeManifest(stateDir, implId, manifest);
-    return manifest;
-}

package/plugin/dist/core/config-health.js

@@ -1,60 +0,0 @@
-/**
- * Conversation Access Health Check (PRI-343 / PRI-346)
- *
- * Pure function for checking whether OpenClaw plugin config has
- * allowConversationAccess set to true. When missing, llm_output and
- * trajectory hooks are silently blocked by OpenClaw, causing evidence
- * to always be empty (PRI-338 root cause).
- *
- * Extracted from index.ts to avoid circular imports when trajectory-collector.ts
- * needs to check conversation access state (PRI-346).
- */
-/**
- * PRI-348: Extract the full plugin entry (including hooks) from the global OpenClaw config.
- * Unlike api.pluginConfig (which is only the entry.config sub-object), this returns
- * the entire entry including hooks, config, enabled, etc.
- */
-export function getPluginEntry(config, pluginId) {
-    if (!config || typeof config !== 'object' || Array.isArray(config))
-        return undefined;
-    const plugins = config.plugins;
-    if (!plugins || typeof plugins !== 'object' || Array.isArray(plugins))
-        return undefined;
-    const entries = plugins.entries;
-    if (!entries || typeof entries !== 'object' || Array.isArray(entries))
-        return undefined;
-    return entries[pluginId];
-}
-/** Keep in sync with @principles/core CONVERSATION_ACCESS_CONFIG_KEY */
-const CONVERSATION_ACCESS_CONFIG_KEY = 'allowConversationAccess';
-const CONVERSATION_ACCESS_FIX_COMMAND = 'openclaw config set plugins.entries.principles-disciple.hooks.allowConversationAccess true --strict-json';
-/**
- * PRI-343: Pure function — checks if pluginConfig has hooks.allowConversationAccess === true.
- * Returns a structured result with reason and nextAction when not authorized (ERR-002).
- */
-export function checkConversationAccessConfig(pluginConfig) {
-    if (pluginConfig === null || pluginConfig === undefined || typeof pluginConfig !== 'object' || Array.isArray(pluginConfig)) {
-        return {
-            authorized: false,
-            reason: 'pluginConfig is missing or invalid — conversation hooks cannot be registered',
-            nextAction: CONVERSATION_ACCESS_FIX_COMMAND,
-        };
-    }
-    const config = pluginConfig;
-    if (typeof config.hooks !== 'object' || config.hooks === null || Array.isArray(config.hooks)) {
-        return {
-            authorized: false,
-            reason: 'allowConversationAccess is not set to true',
-            nextAction: CONVERSATION_ACCESS_FIX_COMMAND,
-        };
-    }
-    const hooks = config.hooks;
-    if (hooks[CONVERSATION_ACCESS_CONFIG_KEY] !== true) {
-        return {
-            authorized: false,
-            reason: 'allowConversationAccess is not set to true',
-            nextAction: CONVERSATION_ACCESS_FIX_COMMAND,
-        };
-    }
-    return { authorized: true };
-}

package/plugin/dist/core/config-service.js

@@ -1,26 +0,0 @@
-import { PainConfig } from './config.js';
-let config = null;
-let lastStateDir = null;
-/**
- * Singleton service to manage the Pain Configuration.
- */
-export const ConfigService = {
-    /**
-     * Gets or initializes the Pain Configuration instance.
-     * @param stateDir The directory where the settings JSON is stored.
-     */
-    get(stateDir) {
-        if (!config || lastStateDir !== stateDir) {
-            config = new PainConfig(stateDir);
-            config.load();
-            lastStateDir = stateDir;
-        }
-        return config;
-    },
-    /**
-     * Resets the singleton instance (primarily for testing).
-     */
-    reset() {
-        config = null;
-    }
-};