principles-disciple 1.182.0 → 1.184.0

package/dist/commands/context.js

@@ -1,9 +1,11 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import * as yaml from 'js-yaml';
 import { resolvePluginCommandWorkspaceDir } from '../utils/workspace-resolver.js';
 import { atomicWriteFileSync, normalizeCommandArgs } from '../utils/io.js';
 import { defaultContextConfig } from '../types.js';
 import { loadContextInjectionConfig } from '../hooks/prompt.js';
+import { getPdConfigPath } from '../core/pd-config-loader.js';
 /**
  * Get workspace directory from context
  */
@@ -12,26 +14,30 @@ function getWorkspaceDir(ctx) {
     return resolvePluginCommandWorkspaceDir(ctx, 'context');
 }
 /**
- * Save context injection config to PROFILE.json
+ * Save context injection config to .pd/config.yaml
  */
 function saveConfig(workspaceDir, config) {
-    const profilePath = path.join(workspaceDir, '.principles', 'PROFILE.json');
+    const configPath = getPdConfigPath(workspaceDir);
     try {
         // Ensure directory exists
-        const dir = path.dirname(profilePath);
+        const dir = path.dirname(configPath);
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
         }
-        // Load existing profile or create new one
-        let profile = {};
-        if (fs.existsSync(profilePath)) {
-            const raw = fs.readFileSync(profilePath, 'utf-8');
-            profile = JSON.parse(raw);
+        // Load existing config or start fresh
+        let rawConfig = {};
+        if (fs.existsSync(configPath)) {
+            const raw = fs.readFileSync(configPath, 'utf-8');
+            const parsed = yaml.load(raw, { schema: yaml.JSON_SCHEMA });
+            if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                rawConfig = parsed;
+            }
         }
         // Update contextInjection
-        profile.contextInjection = config;
-        // Write back
-        atomicWriteFileSync(profilePath, JSON.stringify(profile, null, 2));
+        rawConfig.contextInjection = config;
+        // Write back as YAML
+        const yamlStr = yaml.dump(rawConfig, { indent: 2, lineWidth: 120, noRefs: true, forceQuotes: false });
+        atomicWriteFileSync(configPath, yamlStr);
         return true;
     }
     catch (e) {

package/dist/core/init.js

@@ -2,7 +2,6 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { PD_DIRS } from './paths.js';
-import { defaultContextConfig } from '../types.js';
 import { loadStore, setPrincipleState } from './principle-training-state.js';
 import { addPrincipleToLedger } from './principle-tree-ledger.js';
 import { atomicWriteFileSync } from '../utils/io.js';
@@ -10,11 +9,11 @@ import { createDefaultKeywordStore, saveKeywordStore } from './empathy-keyword-m
 import { CORE_PRINCIPLES } from '@principles/core/runtime-v2';
 /**
  * Default PROFILE.json content
+ * Note: contextInjection is migrated to .pd/config.yaml — not initialized here.
  */
 const DEFAULT_PROFILE = {
     name: "Principles Disciple Agent",
     version: "1.0.0",
-    contextInjection: defaultContextConfig
 };
 const CORE_GUIDANCE_VERSION = 'pd-core-guidance-v2';
 const CORE_GUIDANCE_FILES = new Set(['AGENTS.md', 'TOOLS.md']);
@@ -85,7 +84,7 @@ export function ensureWorkspaceTemplates(api, workspaceDir, language = 'en') {
             }
             copyRecursiveSync(painTemplatesDir, painDestDir, api);
         }
-        // 4. Initialize PROFILE.json with default contextInjection config
+        // 4. Initialize PROFILE.json with project identity metadata
         const principlesDir = path.join(workspaceDir, PD_DIRS.IDENTITY);
         const profilePath = path.join(principlesDir, 'PROFILE.json');
         if (!fs.existsSync(profilePath)) {
@@ -94,7 +93,7 @@ export function ensureWorkspaceTemplates(api, workspaceDir, language = 'en') {
                 fs.mkdirSync(principlesDir, { recursive: true });
             }
             atomicWriteFileSync(profilePath, JSON.stringify(DEFAULT_PROFILE, null, 2));
-            api.logger.info(`[PD] Initialized PROFILE.json with default contextInjection config`);
+            api.logger.info(`[PD] Initialized PROFILE.json with identity metadata (contextInjection migrated to .pd/config.yaml)`);
         }
     }
     catch (err) {

package/dist/hooks/prompt.d.ts

@@ -11,8 +11,9 @@ export declare function resetPromptStateForTest(workspaceDir?: string): void;
  * Constructs the system prompt injected into LLM context for Principles Disciple
  */
 /**
- * Loads context injection config from .principles/PROFILE.json
- * Parses contextInjection configuration from PROFILE.json for context injection
+ * Loads context injection config from .pd/config.yaml via loadPdConfigForPlugin.
+ * The resolved config is computed by the core config layer (pd-config-effective.ts),
+ * which merges user partial input with DEFAULT_CONTEXT_INJECTION defaults.
  * @internal Used by evolution engine for context settings
  */
 export declare function loadContextInjectionConfig(workspaceDir: string): ContextInjectionConfig;

package/dist/hooks/prompt.js

@@ -1,8 +1,6 @@
 import * as fs from 'fs';
-import * as path from 'path';
 import { clearInjectedProbationIds, getSession, resetFriction, setInjectedProbationIds, decayGfi, getGfiDecayElapsed } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
-import { defaultContextConfig } from '../types.js';
 // local-worker-routing module and its routing helpers removed entirely per PRI-448.
 // Routing guidance is no longer injected into prompts.
 import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingMemoryToInjection, autoCompressFocus, safeReadCurrentFocus } from '../core/focus-history.js';
@@ -11,7 +9,7 @@ import { selectPrinciplesForInjection, DEFAULT_PRINCIPLE_BUDGET } from '../core/
 import { getCachedMaskedPrincipleSet, RUNTIME_V2_PRINCIPLE_BUDGET, trimToBudget, renderPrinciplesToDirectives } from '@principles/core/runtime-v2';
 import { truncateInjectionToBudget } from '@principles/core/prompt-builder';
 import { PromptActivationReader } from '../core/runtime-v2-prompt-activation-reader.js';
-import { loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
+import { loadPdConfigForPlugin, loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
 import { safeReadIntentDoc, resetIntentDocCacheForTest } from '../core/intent-doc-reader.js';
 import { resolveIntentLang } from '../core/intent-doc-reader-adapter.js';
 import { buildIntentFrictionBlock } from '@principles/core/runtime-v2';
@@ -108,81 +106,19 @@ function getSignalCollectorHost(wctx, logger) {
     }
     return host;
 }
-function parseContextInjectionConfig(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return null;
-    const config = { ...defaultContextConfig };
-    const thinkingOs = getOwnValue(value, 'thinkingOs');
-    const projectFocus = getOwnValue(value, 'projectFocus');
-    const evolutionContext = getOwnValue(value, 'evolutionContext');
-    if (thinkingOs !== undefined) {
-        if (typeof thinkingOs !== 'boolean')
-            return null;
-        config.thinkingOs = thinkingOs;
-    }
-    if (projectFocus !== undefined) {
-        if (projectFocus !== 'full' && projectFocus !== 'summary' && projectFocus !== 'off')
-            return null;
-        config.projectFocus = projectFocus;
-    }
-    if (evolutionContext !== undefined) {
-        if (typeof evolutionContext !== 'object' || evolutionContext === null || Array.isArray(evolutionContext))
-            return null;
-        config.evolutionContext = { ...defaultContextConfig.evolutionContext };
-        const enabled = getOwnValue(evolutionContext, 'enabled');
-        const maxMessages = getOwnValue(evolutionContext, 'maxMessages');
-        const maxCharsPerMessage = getOwnValue(evolutionContext, 'maxCharsPerMessage');
-        if (enabled !== undefined) {
-            if (typeof enabled !== 'boolean')
-                return null;
-            config.evolutionContext.enabled = enabled;
-        }
-        if (maxMessages !== undefined) {
-            if (typeof maxMessages !== 'number' || !Number.isFinite(maxMessages))
-                return null;
-            config.evolutionContext.maxMessages = maxMessages;
-        }
-        if (maxCharsPerMessage !== undefined) {
-            if (typeof maxCharsPerMessage !== 'number' || !Number.isFinite(maxCharsPerMessage))
-                return null;
-            config.evolutionContext.maxCharsPerMessage = maxCharsPerMessage;
-        }
-    }
-    return config;
-}
 /**
  * OpenClaw API Prompt Hook
  * Constructs the system prompt injected into LLM context for Principles Disciple
  */
 /**
- * Loads context injection config from .principles/PROFILE.json
- * Parses contextInjection configuration from PROFILE.json for context injection
+ * Loads context injection config from .pd/config.yaml via loadPdConfigForPlugin.
+ * The resolved config is computed by the core config layer (pd-config-effective.ts),
+ * which merges user partial input with DEFAULT_CONTEXT_INJECTION defaults.
  * @internal Used by evolution engine for context settings
  */
 export function loadContextInjectionConfig(workspaceDir) {
-    const profilePath = path.join(workspaceDir, '.principles', 'PROFILE.json');
-    try {
-        const raw = cachedReadFile(profilePath, workspaceDir);
-        if (raw) {
-            const profile = JSON.parse(raw);
-            if (profile && typeof profile === 'object' && !Array.isArray(profile)) {
-                const contextInjection = getOwnValue(profile, 'contextInjection');
-                if (contextInjection !== undefined) {
-                    const parsed = parseContextInjectionConfig(contextInjection);
-                    if (!parsed) {
-                        console.warn(`[PD:Prompt] Invalid contextInjection config in ${profilePath}; using defaults.`);
-                        return { ...defaultContextConfig };
-                    }
-                    return parsed;
-                }
-            }
-        }
-    }
-    catch (e) {
-        // Failed to load config — continue with defaults, but log for diagnostics
-        console.warn(`[PD:Prompt] Failed to load contextInjection config: ${String(e)}`);
-    }
-    return { ...defaultContextConfig };
+    const result = loadPdConfigForPlugin(workspaceDir);
+    return { ...result.effective.resolvedContextInjection };
 }
 export async function handleBeforePromptBuild(event, ctx) {
     const { workspaceDir } = ctx;

package/dist/service/evolution-worker.d.ts

@@ -53,8 +53,8 @@ export interface EvolutionQueueItem {
     resultRef?: string;
     painEventId?: number;
 }
-import { migrateToV2, isLegacyQueueItem, migrateQueueToV2, LegacyEvolutionQueueItem, DEFAULT_TASK_KIND, DEFAULT_PRIORITY, DEFAULT_MAX_RETRIES, type RawQueueItem } from './queue-migration.js';
-export { migrateToV2, isLegacyQueueItem, migrateQueueToV2, LegacyEvolutionQueueItem, DEFAULT_TASK_KIND, DEFAULT_PRIORITY, DEFAULT_MAX_RETRIES };
+import { migrateToV2, isLegacyQueueItem, migrateQueueToV2, LegacyEvolutionQueueItem, DEFAULT_TASK_KIND, DEFAULT_PRIORITY, DEFAULT_MAX_RETRIES, validateQueueItem, VALID_TASK_KINDS, isValidQueueItem, type RawQueueItem } from './queue-migration.js';
+export { migrateToV2, isLegacyQueueItem, migrateQueueToV2, LegacyEvolutionQueueItem, DEFAULT_TASK_KIND, DEFAULT_PRIORITY, DEFAULT_MAX_RETRIES, validateQueueItem, VALID_TASK_KINDS, isValidQueueItem };
 export type { RawQueueItem };
 export declare function extractEvolutionTaskId(task: string): string | null;
 export declare function purgeStaleFailedTasks(queue: EvolutionQueueItem[], logger: PluginLogger): {

package/dist/service/evolution-worker.js

@@ -11,7 +11,7 @@ import { atomicWriteFileSync } from '../utils/io.js';
 // Re-export queue I/O (extracted to queue-io.ts)
 export { loadEvolutionQueue, saveEvolutionQueue, withQueueLock, acquireQueueLock, requireQueueLock } from './queue-io.js';
 export { EVOLUTION_QUEUE_LOCK_SUFFIX, LOCK_MAX_RETRIES, LOCK_RETRY_DELAY_MS, LOCK_STALE_MS } from './queue-io.js';
-import { saveEvolutionQueue, requireQueueLock } from './queue-io.js';
+import { saveEvolutionQueue, requireQueueLock, loadEvolutionQueue } from './queue-io.js';
 import { WorkflowStore } from './subagent-workflow/workflow-store.js';
 import { PrincipleCompiler } from '../core/principle-compiler/index.js';
 import { loadLedger, updatePrinciple } from '../core/principle-tree-ledger.js';
@@ -58,8 +58,8 @@ import { runWorkflowWatchdog } from './workflow-watchdog.js';
 export { runWorkflowWatchdog };
 let timeoutId = null;
 // ── Queue Migration (extracted to queue-migration.ts) ────────────────────────
-import { migrateToV2, isLegacyQueueItem, migrateQueueToV2, DEFAULT_TASK_KIND, DEFAULT_PRIORITY, DEFAULT_MAX_RETRIES } from './queue-migration.js';
-export { migrateToV2, isLegacyQueueItem, migrateQueueToV2, DEFAULT_TASK_KIND, DEFAULT_PRIORITY, DEFAULT_MAX_RETRIES };
+import { migrateToV2, isLegacyQueueItem, migrateQueueToV2, DEFAULT_TASK_KIND, DEFAULT_PRIORITY, DEFAULT_MAX_RETRIES, validateQueueItem, VALID_TASK_KINDS, isValidQueueItem } from './queue-migration.js';
+export { migrateToV2, isLegacyQueueItem, migrateQueueToV2, DEFAULT_TASK_KIND, DEFAULT_PRIORITY, DEFAULT_MAX_RETRIES, validateQueueItem, VALID_TASK_KINDS, isValidQueueItem };
 // Queue lock constants and requireQueueLock are imported from queue-io.ts
 export function extractEvolutionTaskId(task) {
     if (!task)
@@ -302,30 +302,12 @@ async function processEvolutionQueue(wctx, logger, _eventLog, _api) {
             logger?.info?.(`[PD:EvolutionWorker] Dropped ${beforeLegacyPainDrop - queue.length} legacy pain_diagnosis queue item(s); use PainSignalBridge/pd pain record`);
         }
         // Validate queue items — filter out malformed entries before processing.
-        // Malformed items are logged + skipped; they never crash the evolution cycle.
+        // rc-1/rc-4 (ERR-007): consolidated in validateQueueItem (queue-migration.ts)
+        // so every load path applies the same filter. Malformed items are logged +
+        // skipped; they never crash the evolution cycle.
         const beforeValidation = queue.length;
         queue = queue.filter((item) => {
-            const errors = [];
-            if (!item.id || typeof item.id !== 'string')
-                errors.push('missing/invalid id');
-            if (!item.source || typeof item.source !== 'string')
-                errors.push('missing/invalid source');
-            if (typeof item.score !== 'number')
-                errors.push('missing/invalid score');
-            if (!item.status || typeof item.status !== 'string')
-                errors.push('missing/invalid status');
-            if (!item.taskKind || typeof item.taskKind !== 'string')
-                errors.push('missing/invalid taskKind');
-            else {
-                const validTaskKinds = ['model_eval'];
-                if (!validTaskKinds.includes(item.taskKind)) {
-                    errors.push(`invalid taskKind value '${item.taskKind}' (expected one of: ${validTaskKinds.join(', ')})`);
-                }
-            }
-            if (typeof item.retryCount !== 'number')
-                errors.push('missing/invalid retryCount');
-            if (typeof item.maxRetries !== 'number')
-                errors.push('missing/invalid maxRetries');
+            const errors = validateQueueItem(item);
             if (errors.length > 0) {
                 logger?.warn?.(`[PD:EvolutionWorker] Skipping malformed queue item: ${errors.join(', ')} | ${JSON.stringify(item).slice(0, 200)}`);
                 SystemLogger.log(wctx.workspaceDir, 'QUEUE_ITEM_MALFORMED', `Skipped: ${errors.join(', ')} | id=${item.id || 'N/A'}`);
@@ -361,16 +343,16 @@ export async function registerEvolutionTaskSession(workspaceResolve, taskId, ses
         return false;
     const releaseLock = await requireQueueLock(queuePath, logger, 'registerEvolutionTaskSession');
     try {
-        let rawQueue;
-        try {
-            rawQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
-        }
-        catch (parseErr) {
-            logger?.warn?.(`[PD:EvolutionWorker] Failed to parse EVOLUTION_QUEUE for session registration: ${queuePath} - ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
-            return false;
-        }
-        // V2: Migrate queue to current schema
-        const queue = migrateQueueToV2(rawQueue);
+        // loadEvolutionQueue handles JSON parse + migrate + validate (rc-1/rc-4).
+        // Previously this inlined JSON.parse + migrate cast without validating,
+        // so malformed queue items could reach the find() below. Reusing the
+        // shared loader keeps a single chokepoint for queue validation.
+        // Note: loadEvolutionQueue returns core/evolution-types.EvolutionQueueItem,
+        // which saveEvolutionQueue also accepts. We deliberately avoid annotating
+        // with the local EvolutionQueueItem interface (line 87) to prevent the
+        // known type-drift between the two definitions (see follow-up: unify the
+        // three EvolutionQueueItem copies).
+        const queue = loadEvolutionQueue(queuePath);
         const task = queue.find((item) => item.id === taskId && item.status === 'in_progress');
         if (!task) {
             logger?.warn?.(`[PD:EvolutionWorker] Could not find in-progress evolution task ${taskId} for session assignment`);

package/dist/service/queue-io.js

@@ -11,7 +11,7 @@ import { createHash } from 'crypto';
 import { acquireLockAsync, releaseLock as releaseImportedLock } from '../utils/file-lock.js';
 import { atomicWriteFileSync } from '../utils/io.js';
 import { LockUnavailableError } from '../config/errors.js';
-import { migrateQueueToV2 } from './queue-migration.js';
+import { migrateQueueToV2, validateQueueItem } from './queue-migration.js';
 export const EVOLUTION_QUEUE_LOCK_SUFFIX = '.lock';
 export const LOCK_MAX_RETRIES = 50;
 export const LOCK_RETRY_DELAY_MS = 50;
@@ -72,7 +72,19 @@ export function loadEvolutionQueue(queuePath) {
             rawQueue = [];
         }
     }
-    return migrateQueueToV2(rawQueue);
+    // rc-1/rc-4 (ERR-007): every element of the parsed array is untrusted disk
+    // JSON — validate before returning. Malformed items are filtered out and
+    // reported via console.warn (rc-9: no silent drop). This is the single
+    // chokepoint that loadEvolutionQueue callers inherit.
+    const migrated = migrateQueueToV2(rawQueue);
+    return migrated.filter((item) => {
+        const errors = validateQueueItem(item);
+        if (errors.length > 0) {
+            console.warn(`[queue-io] Dropping malformed queue item: ${errors.join(', ')} | id=${item?.id ?? 'N/A'}`);
+            return false;
+        }
+        return true;
+    });
 }
 export function saveEvolutionQueue(queuePath, queue) {
     atomicWriteFileSync(queuePath, JSON.stringify(queue, null, 2));

package/dist/service/queue-migration.d.ts

@@ -81,3 +81,28 @@ export declare function isLegacyQueueItem(item: RawQueueItem): boolean;
  * Returns a new array with all items migrated to V2 format.
  */
 export declare function migrateQueueToV2(queue: RawQueueItem[]): EvolutionQueueItem[];
+/**
+ * Canonical set of valid taskKind values. Single source of truth — mirrors
+ * TaskKind in trajectory-types.ts. Previously the inline validator in
+ * evolution-worker.ts hard-coded `['model_eval']`, which silently rejected
+ * three legitimate taskKind values (pain_diagnosis / sleep_reflection /
+ * keyword_optimization). Keep this in sync with TaskKind.
+ */
+export declare const VALID_TASK_KINDS: readonly TaskKind[];
+/**
+ * Validate a single queue item loaded from untrusted disk JSON.
+ *
+ * Returns an array of human-readable error reasons; an empty array means the
+ * item is valid. Use {@link isValidQueueItem} for a type-guard form.
+ *
+ * This consolidates the inline validation that lived in processEvolutionQueue
+ * (evolution-worker.ts) so every queue load path (loadEvolutionQueue,
+ * registerEvolutionTaskSession) applies the same filter. rc-4 (ERR-007):
+ * array elements from parsed JSON must be element-wise validated.
+ */
+export declare function validateQueueItem(item: unknown): string[];
+/**
+ * Type-guard convenience over {@link validateQueueItem}.
+ * Drops the reason strings (callers that need them should call validateQueueItem).
+ */
+export declare function isValidQueueItem(item: unknown): item is EvolutionQueueItem;

package/dist/service/queue-migration.js

@@ -54,3 +54,60 @@ export function isLegacyQueueItem(item) {
 export function migrateQueueToV2(queue) {
     return queue.map(item => isLegacyQueueItem(item) ? migrateToV2(item) : item);
 }
+// ── Validation (rc-1/rc-2, rc-4: validate array elements from untrusted JSON) ─
+/**
+ * Canonical set of valid taskKind values. Single source of truth — mirrors
+ * TaskKind in trajectory-types.ts. Previously the inline validator in
+ * evolution-worker.ts hard-coded `['model_eval']`, which silently rejected
+ * three legitimate taskKind values (pain_diagnosis / sleep_reflection /
+ * keyword_optimization). Keep this in sync with TaskKind.
+ */
+export const VALID_TASK_KINDS = [
+    'pain_diagnosis',
+    'sleep_reflection',
+    'model_eval',
+    'keyword_optimization',
+];
+/**
+ * Validate a single queue item loaded from untrusted disk JSON.
+ *
+ * Returns an array of human-readable error reasons; an empty array means the
+ * item is valid. Use {@link isValidQueueItem} for a type-guard form.
+ *
+ * This consolidates the inline validation that lived in processEvolutionQueue
+ * (evolution-worker.ts) so every queue load path (loadEvolutionQueue,
+ * registerEvolutionTaskSession) applies the same filter. rc-4 (ERR-007):
+ * array elements from parsed JSON must be element-wise validated.
+ */
+export function validateQueueItem(item) {
+    const errors = [];
+    if (item === null || typeof item !== 'object' || Array.isArray(item)) {
+        return ['item is not an object'];
+    }
+    const it = item;
+    if (!it.id || typeof it.id !== 'string')
+        errors.push('missing/invalid id');
+    if (!it.source || typeof it.source !== 'string')
+        errors.push('missing/invalid source');
+    if (typeof it.score !== 'number')
+        errors.push('missing/invalid score');
+    if (!it.status || typeof it.status !== 'string')
+        errors.push('missing/invalid status');
+    if (!it.taskKind || typeof it.taskKind !== 'string')
+        errors.push('missing/invalid taskKind');
+    else if (!VALID_TASK_KINDS.includes(it.taskKind)) {
+        errors.push(`invalid taskKind value '${it.taskKind}' (expected one of: ${VALID_TASK_KINDS.join(', ')})`);
+    }
+    if (typeof it.retryCount !== 'number')
+        errors.push('missing/invalid retryCount');
+    if (typeof it.maxRetries !== 'number')
+        errors.push('missing/invalid maxRetries');
+    return errors;
+}
+/**
+ * Type-guard convenience over {@link validateQueueItem}.
+ * Drops the reason strings (callers that need them should call validateQueueItem).
+ */
+export function isValidQueueItem(item) {
+    return validateQueueItem(item).length === 0;
+}

package/dist/types.d.ts

@@ -1,33 +1,13 @@
 export type { PluginCommandContext, PluginCommandResult } from './openclaw-sdk.js';
-/**
- * Context Injection Configuration
- * Controls what content gets injected into the LLM prompt.
- *
- * NOTE: Core Principles (PRINCIPLES.md) are ALWAYS injected and cannot be disabled.
- * This is by design - principles are the foundation of the agent's behavior.
- */
-export type ProjectFocusMode = 'full' | 'summary' | 'off';
-export interface EvolutionContextConfig {
-    /** Enable conversation context in evolution task (default: true) */
-    enabled: boolean;
-    /** Max recent messages included in evolution task (default: 4) */
-    maxMessages: number;
-    /** Max chars per message snippet (default: 200) */
-    maxCharsPerMessage: number;
-}
-export interface ContextInjectionConfig {
-    /** Thinking OS (mental models) - can be toggled */
-    thinkingOs: boolean;
-    /** Project context (CURRENT_FOCUS.md) mode */
-    projectFocus: ProjectFocusMode;
-    /** Evolution task context injection settings */
-    evolutionContext: EvolutionContextConfig;
-}
+export type { ContextInjectionConfig, EvolutionContextConfig, ProjectFocusMode, } from '@principles/core';
 /**
  * Default context injection configuration
  * Based on MVP-first strategy (ADR-0014):
  * - principles: always on (not configurable)
  * - thinkingOs: false by default (MVP-Quiet, user can opt-in via /pd-context)
  * - projectFocus: 'off' (default closed, user can enable)
+ *
+ * Migrated to DEFAULT_CONTEXT_INJECTION in @principles/core.
+ * Re-exported for backward compatibility.
  */
-export declare const defaultContextConfig: ContextInjectionConfig;
+export { DEFAULT_CONTEXT_INJECTION as defaultContextConfig } from '@principles/core';

package/dist/types.js

@@ -4,13 +4,8 @@
  * - principles: always on (not configurable)
  * - thinkingOs: false by default (MVP-Quiet, user can opt-in via /pd-context)
  * - projectFocus: 'off' (default closed, user can enable)
+ *
+ * Migrated to DEFAULT_CONTEXT_INJECTION in @principles/core.
+ * Re-exported for backward compatibility.
  */
-export const defaultContextConfig = {
-    thinkingOs: false,
-    projectFocus: 'off',
-    evolutionContext: {
-        enabled: true,
-        maxMessages: 4,
-        maxCharsPerMessage: 200,
-    },
-};
+export { DEFAULT_CONTEXT_INJECTION as defaultContextConfig } from '@principles/core';

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.182.0",
+  "version": "1.184.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.182.0",
+  "version": "1.184.0",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/index.js",