create-principles-disciple 1.79.0 → 1.81.0

package/plugin/dist/core/pd-config-loader.js

@@ -0,0 +1,307 @@
+/**
+ * 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';
+// ── Constants ────────────────────────────────────────────────────────────────
+export const PD_CONFIG_DIR = '.pd';
+export const PD_CONFIG_FILENAME = 'config.yaml';
+// ── Config Path ──────────────────────────────────────────────────────────────
+export function getPdConfigPath(workspaceDir) {
+    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) {
+    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;
+    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;
+    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 = 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, flagId, logger) {
+    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, observerFlagId, observerAgentName, _logger) {
+    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 = 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;
+    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,
+    };
+}

package/plugin/dist/core/runtime-v2-prompt-activation-reader.d.ts

@@ -14,5 +14,9 @@ export declare class PromptActivationReader {
     constructor(workspaceDir: string, deps?: PromptActivationReaderDeps);
     readActivatedPrinciples(): Promise<PromptActivationReaderResult>;
     private queryArtifactRow;
+    /**
+     * PRI-305/PRI-307: Load feature flags from .pd/config.yaml instead of .pd/feature-flags.yaml.
+     * Uses the shared plugin config loader for consistency.
+     */
     private loadFeatureFlags;
 }

package/plugin/dist/core/runtime-v2-prompt-activation-reader.js

@@ -1,12 +1,6 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import * as yaml from 'js-yaml';
-import { SqliteConnection, SqliteActivationStateStore, computeEffectiveFlags, DEFAULT_FEATURE_FLAGS, filterPromptActivations, resolvePrincipleFromArtifact } from '@principles/core/runtime-v2';
+import { SqliteConnection, SqliteActivationStateStore, computeFeatureFlagsFromConfig, filterPromptActivations, resolvePrincipleFromArtifact } from '@principles/core/runtime-v2';
+import { loadPdConfigForPlugin } from './pd-config-loader.js';
 export { RUNTIME_V2_PRINCIPLE_BUDGET } from '@principles/core/runtime-v2';
-const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
 export class PromptActivationReader {
     workspaceDir;
     deps;
@@ -88,56 +82,18 @@ export class PromptActivationReader {
             throw new Error(`artifact_query_failed: artifactId=${artifactId} reason=${msg}; nextAction=check_pi_artifacts_table`);
         }
     }
+    /**
+     * PRI-305/PRI-307: Load feature flags from .pd/config.yaml instead of .pd/feature-flags.yaml.
+     * Uses the shared plugin config loader for consistency.
+     */
     loadFeatureFlags() {
-        const configPath = path.join(this.workspaceDir, '.pd', 'feature-flags.yaml');
-        if (!fs.existsSync(configPath)) {
-            return computeEffectiveFlags({}, DEFAULT_FEATURE_FLAGS, configPath);
-        }
-        let raw;
-        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;
-        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 = Object.create(null);
-        const yamlWarnings = [];
-        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}`);
+        const result = loadPdConfigForPlugin(this.workspaceDir);
+        const flags = computeFeatureFlagsFromConfig(result.effective);
+        if (!result.ok) {
+            for (const err of result.errors) {
+                this.deps.logger?.warn?.(`[PD:RuntimeV2] Config error at ${err.path}: ${err.reason}`);
             }
         }
-        return result;
+        return flags;
     }
 }

package/plugin/dist/core/surface-guard.d.ts

@@ -7,6 +7,16 @@ export interface SurfaceGuardResult {
     violations: string[];
     warnings: string[];
 }
+type LoggerLike = {
+    info?: (msg: string) => void;
+    debug?: (msg: string) => void;
+};
+/**
+ * Reset the per-process surface-guard skip log bookkeeping. Intended for tests
+ * that need to assert on the first-fire log without cross-test pollution.
+ * Not part of the production API surface; do not call from runtime code.
+ */
+export declare function __resetSurfaceGuardSkipLogStateForTests(): void;
 export declare function checkSurfaceGuard(): SurfaceGuardResult;
 export declare function getSurfaceIdForHook(hookEvent: string, label?: string): string;
 export declare function getSurfaceIdForService(serviceName: string): string;
@@ -15,13 +25,7 @@ export declare function isSurfaceEnabled(surfaceId: string, overrides?: Record<s
     reason?: string;
 };
 export type HookHandler<E, C, R> = (event: E, ctx: C) => R | Promise<R>;
-export declare function guardHook<E, C, R>(surfaceId: string, logger: {
-    info?: (msg: string) => void;
-    debug?: (msg: string) => void;
-} | undefined, handler: HookHandler<E, C, R>): HookHandler<E, C, R>;
-export declare function guardService<T extends OpenClawPluginService>(surfaceId: string, service: T, logger?: {
-    info?: (msg: string) => void;
-    debug?: (msg: string) => void;
-}): T | null;
+export declare function guardHook<E, C, R>(surfaceId: string, logger: LoggerLike | undefined, handler: HookHandler<E, C, R>): HookHandler<E, C, R>;
+export declare function guardService<T extends OpenClawPluginService>(surfaceId: string, service: T, logger?: LoggerLike): T | null;
 export { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory };
 export type { PluginSurfaceEntry, MvpCategory };

package/plugin/dist/core/surface-guard.js

@@ -1,4 +1,42 @@
 import { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory, } from '@principles/core/runtime-v2';
+// Surface-level once-only log state (PRI-298).
+// The first time a quiet/non-core surface guard actually fires in this
+// process, the disabled reason is emitted once. Subsequent fires for the
+// same surfaceId are still observable (the no-op handler preserves
+// behaviour) but no longer flood the log. Fresh processes start with an
+// empty set, so each plugin load gets one observable skip per surface.
+//
+// The Set is only updated when the log was actually emitted, so passing
+// `undefined` for the logger on a quiet first fire does NOT consume the
+// one-shot slot — a later registration that supplies a logger still gets
+// the first-fire reason (PRI-298 / ERR-002).
+const loggedSkipSurfaces = new Set();
+/**
+ * Emit the disabled-reason log line for `surfaceId` at most once per
+ * process. Returns true if the log was emitted, false if it was suppressed
+ * (already logged, or no logger available). Only marks the surface as
+ * logged when the log was actually written, so a missing logger on first
+ * call does not consume the one-shot slot.
+ */
+function logSkipOnce(surfaceId, logger, message) {
+    if (loggedSkipSurfaces.has(surfaceId)) {
+        return false;
+    }
+    if (!logger?.info) {
+        return false;
+    }
+    loggedSkipSurfaces.add(surfaceId);
+    logger.info(message);
+    return true;
+}
+/**
+ * Reset the per-process surface-guard skip log bookkeeping. Intended for tests
+ * that need to assert on the first-fire log without cross-test pollution.
+ * Not part of the production API surface; do not call from runtime code.
+ */
+export function __resetSurfaceGuardSkipLogStateForTests() {
+    loggedSkipSurfaces.clear();
+}
 export function checkSurfaceGuard() {
     const validation = validateSurfaceRegistry(PLUGIN_SURFACE_REGISTRY);
     const violations = [];
@@ -65,8 +103,15 @@ export function guardHook(surfaceId, logger, handler) {
         return handler;
     }
     const reason = check.reason ?? 'surface not enabled';
+    // Log on the first ACTUAL no-op invocation, not at construction time
+    // (PRI-298). Construction-time logging would emit a `SKIP` line at
+    // plugin startup for every registered quiet hook, regardless of
+    // whether the hook ever fires — which is exactly the startup log
+    // noise this change is meant to prevent. The one-shot is consumed only
+    // when the log was actually written, so `undefined` logger on first
+    // call does not eat the slot.
     return (_event, _ctx) => {
-        logger?.info?.(`[PD:surface-guard] SKIP ${surfaceId}: ${reason}`);
+        logSkipOnce(surfaceId, logger, `[PD:surface-guard] SKIP ${surfaceId}: ${reason}`);
         return undefined;
     };
 }
@@ -76,7 +121,11 @@ export function guardService(surfaceId, service, logger) {
         return service;
     }
     const reason = check.reason ?? 'surface not enabled';
-    logger?.info?.(`[PD:surface-guard] SKIP service ${surfaceId}: ${reason}`);
+    // guardService is called once per service during plugin registration,
+    // so the once-only check fires on the registration call itself. The
+    // shared helper makes the consumption rule identical to guardHook:
+    // a missing logger on first call does not consume the one-shot.
+    logSkipOnce(surfaceId, logger, `[PD:surface-guard] SKIP service ${surfaceId}: ${reason}`);
     return null;
 }
 export { PLUGIN_SURFACE_REGISTRY, validateSurfaceRegistry, getSurfacesByCategory };

package/plugin/dist/hooks/gate.js

@@ -316,6 +316,9 @@ export function handleBeforeToolCall(event, ctx) {
 // ---------------------------------------------------------------------------
 function _extractParamsSummary(params) {
     const summary = {};
+    // NOTE: Do NOT redact here — this feeds into RuleHost.evaluate() which
+    // may match against paramsSummary.command. Redaction happens at
+    // EventLog.record() before persistence.
     if (params.file_path)
         summary.file_path = params.file_path;
     if (params.path)

package/plugin/dist/hooks/prompt.js

@@ -127,7 +127,7 @@ export function loadContextInjectionConfig(workspaceDir) {
         const raw = cachedReadFile(profilePath);
         if (raw) {
             const profile = JSON.parse(raw);
-            if (profile.contextInjection) {
+            if (profile && typeof profile === 'object' && profile.contextInjection && typeof profile.contextInjection === 'object') {
                 const contextInjection = profile.contextInjection;
                 return {
                     ...defaultContextConfig,
@@ -267,6 +267,9 @@ export async function handleBeforePromptBuild(event, ctx) {
         resetFriction(sessionId, workspaceDir);
     }
     // ──── 1. prependSystemContext: Minimal Agent Identity ────
+    // EvolutionWorker-era INTERNAL SYSTEM LAYOUT removed per PRI-294.
+    // The EVOLUTION_WORKER PathResolver key and system layout reference are
+    // not MVP-Core; agents discover what they need via tool calls.
     prependSystemContext = `## 【AGENT IDENTITY】
 
 You are a **self-evolving AI agent** powered by Principles Disciple.
@@ -284,10 +287,6 @@ You are a **self-evolving AI agent** powered by Principles Disciple.
 - Use the current session for the normal user reply.
 - Use sessions_send for cross-session messaging.
 - Use agents_list / sessions_list for peer-agent or peer-session orchestration.
-
-## 🔧 INTERNAL SYSTEM LAYOUT
-- Your core plugin logic is rooted at: ${PathResolver.getExtensionRoot() || 'EXTENSION_ROOT (unresolved)'}
-- If you need self-inspection, prioritize the worker entry pointed by PathResolver key: EVOLUTION_WORKER
 `;
     // ──── 2. Empathy Observer Spawn (async sidecar)
     const empathySilenceConstraint = `

package/plugin/dist/index.d.ts

@@ -1,5 +1,9 @@
 import type { OpenClawPluginApi } from './openclaw-sdk.js';
 declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * PRI-305/PRI-307: Load feature flag from .pd/config.yaml instead of .pd/feature-flags.yaml.
+ * Delegates to the shared plugin config loader for consistency.
+ */
 declare function loadFeatureFlagFromWorkspace(workspaceDir: string, flagId: string, logger?: {
     warn?: (msg: string) => void;
     info?: (msg: string) => void;