create-principles-disciple 1.94.0 → 1.96.0

package/plugin/dist/core/workspace-context.d.ts

@@ -6,12 +6,11 @@ import { HygieneTracker } from './hygiene/tracker.js';
 import { EvolutionReducerImpl } from './evolution-reducer.js';
 import type { TrajectoryDatabase } from './trajectory.js';
 import { PrincipleLifecycleService } from './principle-internalization/principle-lifecycle-service.js';
-import { type PrincipleSubtree } from './principle-tree-ledger.js';
-import type { Principle, PrincipleValueMetrics } from '../types/principle-tree-schema.js';
+import { type PrincipleSubtree, type LedgerPrinciple, type PrincipleValueMetrics } from './principle-tree-ledger.js';
 import type { Principle as ActivePrinciple } from './evolution-types.js';
 interface PrincipleTreeLedgerAccessor {
     getPrincipleSubtree(_principleId: string): PrincipleSubtree | undefined;
-    updatePrinciple(_principleId: string, updates: Partial<Principle>): Principle;
+    updatePrinciple(_principleId: string, updates: Partial<LedgerPrinciple>): LedgerPrinciple;
     updatePrincipleValueMetrics(principleId: string, _metrics: PrincipleValueMetrics): PrincipleValueMetrics;
 }
 /**

package/plugin/dist/hooks/gate.js

@@ -12,12 +12,14 @@ import { normalizePath } from '../utils/io.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { recordGateBlockAndReturn } from './gate-block-helper.js';
 import { RuleHost } from '../core/rule-host.js';
-import { validateCorrectionProposal, validateProposedPathBounds } from '@principles/core/runtime-v2';
+import { validateCorrectionProposal, validateProposedPathBounds, computeFeatureFlagsFromConfig, UNAVAILABLE_RULE_CONTEXT } from '@principles/core/runtime-v2';
 import { AGENT_TOOLS, BASH_TOOLS_SET, WRITE_TOOLS } from '../constants/tools.js';
 import { getSession, hasRecentThinking } from '../core/session-tracker.js';
 import { getEvolutionEngine } from '../core/evolution-engine.js';
 import { EventLogService } from '../core/event-log.js';
-import { estimateLineChanges } from '../core/risk-calculator.js';
+import { estimateLineChanges } from '@principles/core/runtime-v2';
+import { loadPdConfigForPlugin } from '../core/pd-config-loader.js';
+import { buildProductionRuleContext } from '../core/rule-context-assembler.js';
 export function handleBeforeToolCall(event, ctx) {
     const logger = ctx.logger || console;
     // 1. Identify tool type
@@ -53,6 +55,10 @@ export function handleBeforeToolCall(event, ctx) {
     // 3. Rule Host Evaluation — sole gate
     try {
         const ruleHost = new RuleHost(wctx.stateDir, logger, { workspaceDir: ctx.workspaceDir });
+        // PRI-483 Phase 4: assemble RuleContextV2 when `rulecode_context_v2` flag is ON.
+        // flag OFF → undefined (v1 zero-change, no trajectory access).
+        // flag ON  → RuleContextV2 (available or unavailable). Never throws (ERR-024).
+        const ruleContext = _buildRuleContextIfEnabled(wctx, relPath, ctx.sessionId, logger);
         const hostInput = {
             action: {
                 toolName: event.toolName,
@@ -80,6 +86,7 @@ export function handleBeforeToolCall(event, ctx) {
                 estimatedLineChanges: estimateLineChanges({ toolName: event.toolName, params: event.params ?? {} }),
                 bashRisk: _getBashRisk(event),
             },
+            context: ruleContext,
         };
         const hostResult = ruleHost.evaluate(hostInput);
         // Always emit rulehost_evaluated
@@ -379,3 +386,53 @@ function _getBashRisk(event) {
         return 'unknown';
     }
 }
+/**
+ * PRI-483 Phase 4 — Build RuleContextV2 for RuleHost.evaluate when the
+ * `rulecode_context_v2` feature flag is ON. Returns `undefined` when the flag
+ * is OFF (v1 zero-change — does NOT touch trajectory) or when config loading
+ * fails (conservative fail-soft: can't determine flag state → v1-style).
+ *
+ * ERR-024 prevention: context assembly failures never skip RuleHost.evaluate.
+ * - loadPdConfigForPlugin throws → return undefined (v1-style)
+ * - buildProductionRuleContext throws → return UNAVAILABLE_RULE_CONTEXT
+ *   (structured unavailable so v2 rules see "context unavailable" and allow)
+ *
+ * Spec: docs/superpowers/specs/2026-06-27-rulecode-context-vision-design.md §5.3
+ */
+function _buildRuleContextIfEnabled(wctx, targetPath, sessionId, logger) {
+    // Step 1: load PD config (flag-gated). If this throws, we can't safely
+    // determine whether v2 context is required — fall back to v1 (undefined).
+    let configResult;
+    try {
+        configResult = loadPdConfigForPlugin(wctx.workspaceDir);
+    }
+    catch (err) {
+        logger?.warn?.(`[PD_GATE] RuleContext v2: config load failed, skipping context assembly: ${String(err)}`);
+        return undefined;
+    }
+    // Step 2: compute effective flags and check rulecode_context_v2.
+    // Explicit ok:false guard (rc-9-no-silent-fallback): when config is malformed,
+    // do NOT silently fall through to flag computation on defaults — log and
+    // return v1-style undefined so config issues surface to the operator.
+    if (!configResult.ok) {
+        const reasons = configResult.errors.map(e => e.reason).join('; ');
+        logger?.warn?.(`[PD_GATE] RuleContext v2: config load returned malformed result, skipping context assembly: ${reasons}`);
+        return undefined;
+    }
+    const flagsResult = computeFeatureFlagsFromConfig(configResult.effective);
+    const v2Flag = flagsResult.flags.rulecode_context_v2;
+    if (!v2Flag?.enabled) {
+        // Flag OFF → v1 zero-change. Do NOT access trajectory (spec §10.1).
+        return undefined;
+    }
+    // Step 3: flag ON → assemble context via production data source.
+    // buildProductionRuleContext is fail-soft internally (returns unavailable),
+    // but wrap in try/catch as defense-in-depth (ERR-024).
+    try {
+        return buildProductionRuleContext(sessionId, targetPath, wctx.trajectory, wctx.workspaceDir);
+    }
+    catch (err) {
+        logger?.warn?.(`[PD_GATE] RuleContext v2: buildProductionRuleContext threw unexpectedly, using unavailable context: ${String(err)}`);
+        return UNAVAILABLE_RULE_CONTEXT;
+    }
+}

package/plugin/dist/hooks/pain.js

@@ -25,6 +25,7 @@ import { resolveWorkspaceDirForRuntimeV2 } from '../utils/workspace-resolver.js'
 import { PainToPrincipleService, PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 import { loadPdConfigForPlugin, loadFeatureFlagFromConfig } from '../core/pd-config-loader.js';
+import { createIntentDocReader, resolveIntentLang } from '../core/intent-doc-reader-adapter.js';
 import { evaluateTriggerController } from '@principles/core/runtime-v2';
 import { isSharedCooldownActive, markSharedEpisodeAsDiagnosed } from './trigger-cooldown-tracker.js';
 import { buildManualPainObservation, resolveSourceKind } from './raw-observation-adapter.js';
@@ -44,6 +45,10 @@ function createPainToPrincipleService(wctx) {
         autoIntakeEnabled: true,
         effectiveConfig: configResult.effective,
         getEnvVar: (name) => process.env[name],
+        // PRI-468: wire INTENT.md reader so Stage A can produce intentTension
+        // when intent_engineering flag is on. Adapter performs no I/O beyond
+        // delegating to safeReadIntentDoc (which owns the flag-first check).
+        intentDocReader: createIntentDocReader(wctx.workspaceDir, resolveIntentLang(wctx.workspaceDir)),
     });
 }
 // buildTrajectoryEvidence is in ./trajectory-evidence.ts (re-exported above)

package/plugin/dist/hooks/prompt-helpers.d.ts

@@ -76,12 +76,30 @@ export declare function formatEvolutionPrinciples(active: EvolutionPrincipleEntr
  * Assemble appendSystemContext from ordered parts.
  *
  * Content order (most important last):
- * behavioral_constraints → project_context → working_memory →
+ * behavioral_constraints → project_context → intent_block → working_memory →
  * thinking_os → evolution_principles → core_principles
  *
+ * PRI-467: intent_block (INTENT.md reference) sits after project_context
+ * (stable reference data, lower priority than principles) and before
+ * working_memory (volatile per-session state).
+ *
  * Pure logic — string assembly only, no I/O.
  *
  * @param parts Ordered content parts (empty/undefined parts are skipped)
  * @returns Assembled appendSystemContext (empty string if no parts)
  */
 export declare function assembleAppendSystemContext(parts: AppendSystemContextParts): string;
+/**
+ * Extracts short, distinct keyword phrases from an EmpathyObserver reason string.
+ *
+ * Used to feed newly detected expressions back into the keyword store, so the
+ * keyword-based fast path can catch them on future turns without re-running
+ * the more expensive observer.
+ *
+ * Pure function — no I/O, no side effects. Fully unit-testable.
+ *
+ * @param reason - observer's reason string (e.g., "用户表达了强烈的挫败感，提到反复尝试失败")
+ * @param lang - UI locale for minimum length threshold (zh=2 chars, en=3 chars)
+ * @returns deduplicated array of up to 3 candidate phrases
+ */
+export declare function extractPhrasesFromReason(reason: string, lang: 'zh' | 'en'): string[];

package/plugin/dist/hooks/prompt-helpers.js

@@ -187,9 +187,13 @@ export function formatEvolutionPrinciples(active, probation) {
  * Assemble appendSystemContext from ordered parts.
  *
  * Content order (most important last):
- * behavioral_constraints → project_context → working_memory →
+ * behavioral_constraints → project_context → intent_block → working_memory →
  * thinking_os → evolution_principles → core_principles
  *
+ * PRI-467: intent_block (INTENT.md reference) sits after project_context
+ * (stable reference data, lower priority than principles) and before
+ * working_memory (volatile per-session state).
+ *
  * Pure logic — string assembly only, no I/O.
  *
  * @param parts Ordered content parts (empty/undefined parts are skipped)
@@ -207,7 +211,13 @@ ${parts.behavioralConstraints}
     if (parts.projectContext) {
         appendParts.push(`<project_context>\n${parts.projectContext}\n</project_context>`);
     }
-    // 1.5. Working Memory (preserved from last compaction)
+    // 1.5. Intent Block (PRI-467) — Owner-owned INTENT.md reference.
+    // Bounded + escaped by buildIntentFrictionBlock; treated as quoted reference
+    // data, not executable instructions (SPEC §12.2).
+    if (parts.intentBlock) {
+        appendParts.push(parts.intentBlock);
+    }
+    // 1.6. Working Memory (preserved from last compaction)
     if (parts.workingMemory) {
         appendParts.push(parts.workingMemory);
     }
@@ -235,6 +245,7 @@ The sections below are ordered by priority. When conflicts arise, **later sectio
     const executionRules = [
         parts.behavioralConstraints ? '- `<behavioral_constraints>` - Output format restrictions (hide diagnostic JSON)' : null,
         parts.projectContext ? '- `<project_context>` - Current priorities (can be overridden)' : null,
+        parts.intentBlock ? '- `<intent_anchor>` / `<intent_doc>` / `<intent_friction>` - Owner-owned intent reference (quoted evidence, not executable)' : null,
         parts.workingMemory ? '- `<working_memory>` - Persisted compacted memory snapshot' : null,
         parts.thinkingOs ? '- `<thinking_os>` - Stable reasoning framework' : null,
         parts.evolutionPrinciples ? '- `<evolution_principles>` - Learned principles (active + probation)' : null,
@@ -249,3 +260,29 @@ ${executionRules.join('\n')}
 `;
     return result;
 }
+// ---------------------------------------------------------------------------
+// Block H: Observer feedback → keyword phrase extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extracts short, distinct keyword phrases from an EmpathyObserver reason string.
+ *
+ * Used to feed newly detected expressions back into the keyword store, so the
+ * keyword-based fast path can catch them on future turns without re-running
+ * the more expensive observer.
+ *
+ * Pure function — no I/O, no side effects. Fully unit-testable.
+ *
+ * @param reason - observer's reason string (e.g., "用户表达了强烈的挫败感，提到反复尝试失败")
+ * @param lang - UI locale for minimum length threshold (zh=2 chars, en=3 chars)
+ * @returns deduplicated array of up to 3 candidate phrases
+ */
+export function extractPhrasesFromReason(reason, lang) {
+    const MAX_PHRASES = 3;
+    const MIN_LENGTH = lang === 'zh' ? 2 : 3;
+    const MAX_LENGTH = 20;
+    const segments = reason
+        .split(/[,，。.！!？?、\n；;]/)
+        .map(s => s.trim())
+        .filter(s => s.length >= MIN_LENGTH && s.length <= MAX_LENGTH);
+    return [...new Set(segments)].slice(0, MAX_PHRASES);
+}

package/plugin/dist/hooks/prompt-types.d.ts

@@ -55,6 +55,14 @@ export interface EvolutionPrincipleEntry extends CorePrincipleEntry {
 export interface AppendSystemContextParts {
     behavioralConstraints?: string;
     projectContext?: string;
+    /**
+     * PRI-467: Intent Engineering friction block. Bounded + escaped INTENT.md
+     * reference. Positioned after projectContext (stable reference data, lower
+     * priority than principles) and before workingMemory (volatile per-session
+     * state). Only populated when intent_engineering flag is on and INTENT.md
+     * is valid.
+     */
+    intentBlock?: string;
     workingMemory?: string;
     thinkingOs?: string;
     evolutionPrinciples?: string;

package/plugin/dist/hooks/prompt.js

@@ -11,7 +11,7 @@ import { selectPrinciplesForInjection, DEFAULT_PRINCIPLE_BUDGET } from '../core/
 import { getCachedMaskedPrincipleSet, WorkflowFunnelLoader, PiAiRuntimeAdapter, EmpathyObserver, AgentScheduler, 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 { matchEmpathyKeywords, loadKeywordStore, saveKeywordStore, getKeywordStoreSummary, } from '../core/empathy-keyword-matcher.js';
+import { matchEmpathyKeywords, loadKeywordStore, saveKeywordStore, applyKeywordUpdates, getKeywordStoreSummary, } from '../core/empathy-keyword-matcher.js';
 import { severityToPenalty, DEFAULT_EMPATHY_KEYWORD_CONFIG } from '../core/empathy-types.js';
 import { evaluatePainDiagnosticGate } from '../core/pain-diagnostic-gate.js';
 import { emitPainDetectedEvent, buildTrajectoryEvidence } from './pain.js';
@@ -20,10 +20,13 @@ import { isSharedCooldownActive, markSharedEpisodeAsDiagnosed } from './trigger-
 import { buildEmpathyObservation, resolveSourceKind } from './raw-observation-adapter.js';
 import { evaluateEvidenceTriage } from './triage-adapter.js';
 import { 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';
 import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
 import { detectCorrectionCue as coreDetectCorrectionCue, escapeXml, extractMessageContent, isMinimalTrigger, } from '@principles/core/prompt-builder';
 import { sanitizeForEvidence } from './message-sanitize.js';
-import { buildAgentIdentity, buildEmpathySilenceConstraint, extractUserMessageFromPrompt, assembleHeartbeatChecklist, formatCorePrinciples, formatEvolutionPrinciples, assembleAppendSystemContext, } from './prompt-helpers.js';
+import { buildAgentIdentity, buildEmpathySilenceConstraint, extractUserMessageFromPrompt, assembleHeartbeatChecklist, formatCorePrinciples, formatEvolutionPrinciples, assembleAppendSystemContext, extractPhrasesFromReason, } from './prompt-helpers.js';
 // ---------------------------------------------------------------------------
 // Static file cache — avoids re-reading rarely-changing files every message
 // ---------------------------------------------------------------------------
@@ -103,10 +106,12 @@ export function resetPromptStateForTest(workspaceDir) {
     if (workspaceDir) {
         _staticFileCache.delete(workspaceDir);
         _empathyState.delete(workspaceDir);
+        resetIntentDocCacheForTest(workspaceDir);
     }
     else {
         _staticFileCache.clear();
         _empathyState.clear();
+        resetIntentDocCacheForTest();
     }
 }
 function parseContextInjectionConfig(value) {
@@ -301,6 +306,8 @@ export async function handleBeforePromptBuild(event, ctx) {
                 // Increment turn counter (Finding #3: session.turnCount doesn't exist)
                 empathyState.turnCounter++;
                 const turnCount = empathyState.turnCounter;
+                const painTrigger = wctx.config.get('thresholds.pain_trigger') || 40;
+                const highGfiThreshold = Math.max(wctx.config.get('severity_thresholds.high') || 70, painTrigger + 30);
                 if (matchResult.matched) {
                     const penalty = severityToPenalty(matchResult.severity, DEFAULT_EMPATHY_KEYWORD_CONFIG);
                     // trackFriction signature: (sessionId, deltaF: number, hash: string, workspaceDir?, options?)
@@ -310,8 +317,6 @@ export async function handleBeforePromptBuild(event, ctx) {
                     logger?.info?.(`[PD:Empathy] MATCH: "${matchResult.matchedTerms.join(', ')}" → severity=${matchResult.severity}, score=${matchResult.score.toFixed(2)}, penalty=${penalty}`);
                     const currentSession = getSession(sessionId);
                     const currentGfi = currentSession?.currentGfi ?? 0;
-                    const painTrigger = wctx.config.get('thresholds.pain_trigger') || 40;
-                    const highGfiThreshold = Math.max(wctx.config.get('severity_thresholds.high') || 70, painTrigger + 30);
                     if (currentGfi >= highGfiThreshold) {
                         const gfiPainScore = Math.min(Math.round(currentGfi), 60);
                         logger?.info?.(`[PD:Empathy] GFI-TRIGGERED: currentGfi=${currentGfi.toFixed(1)} >= highGfi=${highGfiThreshold}, emitting pain signal (score=${gfiPainScore})`);
@@ -447,7 +452,9 @@ export async function handleBeforePromptBuild(event, ctx) {
                             }
                         }
                     }
-                    // Trigger asynchronous background Empathy Observer deep analysis (Zero Latency)
+                }
+                else {
+                    // ── Pipeline: Observer only runs when keyword matcher misses ──
                     const observer = resolveEmpathyObserver(wctx, logger);
                     if (observer) {
                         const scheduler = new AgentScheduler();
@@ -456,14 +463,40 @@ export async function handleBeforePromptBuild(event, ctx) {
                             mode: 'realtime',
                             runner: observer,
                         });
-                        logger?.info?.(`[PD:Empathy] Triggering background Empathy Observer deep analysis for message: "${msgPreview}"`);
+                        logger?.info?.(`[PD:Empathy] Pipeline: Triggering background Empathy Observer for unmatched message: "${msgPreview}"`);
                         void scheduler.dispatch('empathy-observer', { userMessage: latestUserMessage })
                             .then(async (result) => {
                             if (result.damageDetected) {
-                                logger?.info?.(`[PD:Empathy] Background Empathy Observer detected damage. Severity: ${result.severity}, Reason: ${result.reason}`);
+                                logger?.info?.(`[PD:Empathy] Pipeline: Background Empathy Observer detected damage. Severity: ${result.severity}, Reason: ${result.reason}`);
                                 // ── Persistence Contract ──
                                 const painScore = scoreFromSeverityForSpec(result.severity, wctx);
                                 trackFriction(sessionId, painScore, `observer_empathy_${result.severity}`, workspaceDir, { source: 'user_empathy' });
+                                // ── Pipeline: feed back newly detected expressions into keyword store ──
+                                if (result.reason) {
+                                    const rawLang = wctx.config.get('language');
+                                    const lang = rawLang === 'en' ? 'en' : 'zh';
+                                    const phrases = extractPhrasesFromReason(result.reason, lang);
+                                    if (phrases.length > 0) {
+                                        const updates = {};
+                                        for (const phrase of phrases) {
+                                            if (!Object.hasOwn(keywordStore.terms, phrase)) {
+                                                updates[phrase] = {
+                                                    action: 'add',
+                                                    weight: 0.4,
+                                                    falsePositiveRate: 0.3,
+                                                    reasoning: `Discovered by empathy observer: ${result.reason.substring(0, 100)}`,
+                                                };
+                                            }
+                                        }
+                                        if (Object.keys(updates).length > 0) {
+                                            const { added } = applyKeywordUpdates(keywordStore, updates);
+                                            if (added > 0) {
+                                                saveKeywordStore(wctx.stateDir, keywordStore);
+                                                logger?.info?.(`[PD:Empathy] Pipeline: added ${added} new terms from observer feedback`);
+                                            }
+                                        }
+                                    }
+                                }
                                 const eventId = `emp_obs_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
                                 wctx.eventLog.recordPainSignal(sessionId, {
                                     score: painScore,
@@ -520,7 +553,7 @@ export async function handleBeforePromptBuild(event, ctx) {
                                         const sourceKind = resolveSourceKind(rawObs);
                                         const triage = evaluateEvidenceTriage(sourceKind, freshGfiPainScore);
                                         if (triage.decision !== 'admit') {
-                                            logger?.info?.(`[PD:Empathy] Observer triage ${triage.decision}: ${triage.reason}`);
+                                            logger?.info?.(`[PD:Empathy] Pipeline observer triage ${triage.decision}: ${triage.reason}`);
                                         }
                                         else {
                                             const cooldownActive = isSharedCooldownActive(sourceKind, sessionId, 'empathy_gfi_observer');
@@ -534,7 +567,7 @@ export async function handleBeforePromptBuild(event, ctx) {
                                             });
                                             if (triggerDecision.shouldCreateDiagnosticTask) {
                                                 markSharedEpisodeAsDiagnosed(sourceKind, sessionId, 'empathy_gfi_observer');
-                                                logger?.info?.(`[PD:Empathy] Gate B approved (observer), calling emitPainDetectedEvent...`);
+                                                logger?.info?.(`[PD:Empathy] Pipeline Gate B approved (observer), calling emitPainDetectedEvent...`);
                                                 try {
                                                     const evidence = buildTrajectoryEvidence(wctx, sessionId);
                                                     // PRI-453: Reuse observerPainId for lineage consistency —
@@ -558,11 +591,11 @@ export async function handleBeforePromptBuild(event, ctx) {
                                                     }, { recordObservability: false });
                                                 }
                                                 catch (emitErr) {
-                                                    logger?.error?.(`[PD:Empathy] FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
+                                                    logger?.error?.(`[PD:Empathy] Pipeline FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
                                                 }
                                             }
                                             else {
-                                                logger?.info?.(`[PD:Empathy] Gate B skipped (observer): ${triggerDecision.reason}`);
+                                                logger?.info?.(`[PD:Empathy] Pipeline Gate B skipped (observer): ${triggerDecision.reason}`);
                                             }
                                         }
                                     }
@@ -582,7 +615,7 @@ export async function handleBeforePromptBuild(event, ctx) {
                                             },
                                         });
                                         if (gate.shouldDiagnose) {
-                                            logger?.info?.(`[PD:Empathy] GFI threshold crossed after background observer. Emitting pain signal...`);
+                                            logger?.info?.(`[PD:Empathy] Pipeline GFI threshold crossed after background observer. Emitting pain signal...`);
                                             try {
                                                 const evidence = buildTrajectoryEvidence(wctx, sessionId);
                                                 // PRI-453: Reuse observerPainId for lineage consistency —
@@ -606,22 +639,20 @@ export async function handleBeforePromptBuild(event, ctx) {
                                                 }, { recordObservability: false });
                                             }
                                             catch (emitErr) {
-                                                logger?.error?.(`[PD:Empathy] FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
+                                                logger?.error?.(`[PD:Empathy] Pipeline FAILED to emit observer-triggered pain event: ${String(emitErr)}`);
                                             }
                                         }
                                     }
                                 }
                             }
                             else {
-                                logger?.info?.(`[PD:Empathy] Background Empathy Observer did not detect any damage.`);
+                                logger?.info?.(`[PD:Empathy] Pipeline: Background Empathy Observer did not detect any damage.`);
                             }
                         })
                             .catch((err) => {
-                            logger?.warn?.(`[PD:Empathy] Background analysis failed or rejected: ${String(err)}`);
+                            logger?.warn?.(`[PD:Empathy] Pipeline: Background analysis failed or rejected: ${String(err)}`);
                         });
                     }
-                }
-                else {
                     // Log unmatched messages periodically for coverage analysis
                     if (turnCount > 0 && turnCount % 50 === 0) {
                         const sampleMsg = latestUserMessage.substring(0, 80).replace(/\n/g, ' ');
@@ -871,11 +902,38 @@ export async function handleBeforePromptBuild(event, ctx) {
     catch (e) {
         logger?.warn?.(`[PD:RuntimeV2] Failed to read Runtime V2 prompt activations: ${String(e)}`);
     }
+    // ── PRI-467: Intent Engineering — INTENT.md friction block injection ──
+    // SPEC §5: flag off → no fs access, no cache access, no injection, no telemetry.
+    // SPEC §13.1: inject only when flag on + INTENT.md exists + safeReadIntentDoc ok=true.
+    // SPEC §14.1 Mode A: prompt-only — no output-hook capture, no check_emitted counter.
+    let intentBlockContent;
+    try {
+        const intentFlag = loadFeatureFlagFromConfig(workspaceDir, 'intent_engineering', logger);
+        if (intentFlag.enabled) {
+            const intentResult = safeReadIntentDoc(workspaceDir, resolveIntentLang(workspaceDir), { logger });
+            if (intentResult.ok && intentResult.doc) {
+                const block = buildIntentFrictionBlock({ rawIntentMd: intentResult.doc.raw });
+                if (block.length > 0) {
+                    intentBlockContent = block;
+                }
+            }
+            else if (!intentResult.ok && intentResult.reason !== 'not_found') {
+                // SPEC §13.1: missing file is silent (no debug noise). Other degraded
+                // paths (oversized, read_error, flag_disabled) log a debug reason.
+                logger?.debug?.(`[PD:Intent] INTENT.md injection skipped: reason=${intentResult.reason ?? 'unknown'}, nextAction=${intentResult.nextAction ?? 'none'}`);
+            }
+        }
+    }
+    catch (intentErr) {
+        // ERR-002 — fail-open: never let INTENT injection break the prompt hook.
+        logger?.warn?.(`[PD:Intent] INTENT injection failed, skipping: ${String(intentErr)}`);
+    }
     // Build appendSystemContext with recency effect
-    // Content order (most important last): behavioral_constraints -> project_context -> working_memory -> reflection_log -> thinking_os -> principles
+    // Content order (most important last): behavioral_constraints -> project_context -> intent_block -> working_memory -> reflection_log -> thinking_os -> principles
     appendSystemContext = assembleAppendSystemContext({
         behavioralConstraints: shouldInjectBehavioralConstraints ? empathySilenceConstraint : undefined,
         projectContext: projectContextContent || undefined,
+        intentBlock: intentBlockContent,
         workingMemory: workingMemoryContent || undefined,
         thinkingOs: thinkingOsContent || undefined,
         evolutionPrinciples: evolutionPrinciplesContent || undefined,
@@ -892,10 +950,12 @@ export async function handleBeforePromptBuild(event, ctx) {
     // routing helpers deleted per PRI-448. No routing-related content is injected.
     // ──── 8. SIZE GUARD ────
     // Delegates to @principles/core/prompt-builder/truncateInjectionToBudget
-    // which handles priority stripping: project_context → thinking_os →
-    // evolution_principles → reflection_log → reason: truncation → fallback.
+    // which handles priority stripping: project_context → intent_block →
+    // thinking_os → evolution_principles → reflection_log → reason: truncation → fallback.
+    // PRI-467: intentBlockContent is passed so the guard can strip INTENT by
+    // exact match before falling back to the nuclear option.
     const result = truncateInjectionToBudget(prependSystemContext, prependContext, appendSystemContext, {
-        blocks: { projectContextContent, thinkingOsContent, evolutionPrinciplesContent },
+        blocks: { projectContextContent, intentBlockContent, thinkingOsContent, evolutionPrinciplesContent },
     });
     prependSystemContext = result.prependSystemContext;
     prependContext = result.prependContext;

package/plugin/dist/index.d.ts

@@ -45,6 +45,8 @@ declare const plugin: {
     description: string;
     register(api: OpenClawPluginApi): void;
 };
-export { PrincipleTreeLedgerAdapter } from './core/principle-tree-ledger-adapter.js';
+export { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 export { loadFeatureFlagFromWorkspace, isRecord };
+export { initTrajectorySchema } from './core/trajectory.js';
+export { initWorkflowSchema } from './service/subagent-workflow/workflow-store.js';
 export default plugin;

package/plugin/dist/index.js

@@ -31,7 +31,6 @@ import { CorrectionObserverService } from './service/correction-observer-service
 import { InternalizationAutoConsumerService } from './service/internalization-auto-consumer-service.js';
 import { TrajectoryService } from './service/trajectory-service.js';
 import { PDTaskService } from './core/pd-task-service.js';
-import { CentralSyncService } from './service/central-sync-service.js';
 import { ensureWorkspaceTemplates } from './core/init.js';
 import { migrateDirectoryStructure } from './core/migration.js';
 import { migrateStaleWorkspaceGuidance } from './core/workspace-guidance-migrator.js';
@@ -39,7 +38,7 @@ import { SystemLogger } from './core/system-logger.js';
 import { PathResolver } from './core/path-resolver.js';
 import { resolveCommandWorkspaceDir, resolveToolHookWorkspaceDirSafe, resolveHookWorkspaceDir } from './utils/workspace-resolver.js';
 import { validateWorkspaceDir } from './core/workspace-dir-validation.js';
-import { checkSurfaceGuard, guardHook, guardService } from './core/surface-guard.js';
+import { checkSurfaceGuard, guardHook, guardService } from '@principles/core/runtime-v2';
 // Track started workspaces — one-time init + evolution worker per workspace
 const startedWorkspaces = new Set();
 // ── Conversation Access Health Check (PRI-343) ────────────────────────────
@@ -408,9 +407,6 @@ const plugin = {
             const guardedPdTask = guardService('service:pd-task', PDTaskService, api.logger);
             if (guardedPdTask)
                 api.registerService(guardedPdTask);
-            const guardedCentralSync = guardService('service:central-sync', CentralSyncService, api.logger);
-            if (guardedCentralSync)
-                api.registerService(guardedCentralSync);
             const guardedAutoConsumer = guardService('service:internalization-auto-consumer', InternalizationAutoConsumerService, api.logger);
             if (guardedAutoConsumer)
                 api.registerService(guardedAutoConsumer);
@@ -745,7 +741,15 @@ const plugin = {
         });
     }
 };
-export { PrincipleTreeLedgerAdapter } from './core/principle-tree-ledger-adapter.js';
+// PrincipleTreeLedgerAdapter is exported from @principles/core/runtime-v2 (canonical,
+// consolidated in PRI-459). The plugin-local duplicate was removed; re-export the core
+// symbol so any external consumer importing from the plugin still resolves it.
+export { PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 /* istanbul ignore next — test exports for evolution worker gate */
 export { loadFeatureFlagFromWorkspace, isRecord };
+// Schema initialization exports for `pd runtime init` (unified DB init).
+// These functions open the DB in write mode, apply the full schema, and close the DB.
+// They do NOT run runtime side-effects (importLegacyArtifacts, pruneUnreferencedBlobs).
+export { initTrajectorySchema } from './core/trajectory.js';
+export { initWorkflowSchema } from './service/subagent-workflow/workflow-store.js';
 export default plugin;

package/plugin/dist/service/runtime-summary-service.js

@@ -16,7 +16,7 @@ function pushWarning(warnings, message) {
     }
 }
 /**
- * YAML-SSOT-03: resolve a dot-path (e.g. 'evolution.nocturnalDreamerCompleted') from dailyStats.
+ * YAML-SSOT-03: resolve a dot-path (e.g. 'evolution.rulehostEvaluated') from dailyStats.
  * Returns { count, resolvable } to distinguish "field not found / non-numeric" from "legitimate zero".
  */
 function resolveStatsField(stats, dotPath) {

package/plugin/dist/service/subagent-workflow/workflow-store.d.ts

@@ -28,3 +28,17 @@ export declare class WorkflowStore {
     recordDuration(workflowId: string, durationMs: number): void;
     getCompletionDurations(workflowType: string, limit?: number): number[];
 }
+/**
+ * Initialize subagent_workflows.db schema at the given workspace directory.
+ *
+ * Opens the DB in write mode, applies the full schema (tables + indexes + migrations),
+ * then closes the DB. Used by `pd runtime init` for unified DB initialization.
+ *
+ * Idempotent: safe to call on an existing DB; all CREATE statements use IF NOT EXISTS.
+ *
+ * @returns list of created/verified table names and any warnings
+ */
+export declare function initWorkflowSchema(workspaceDir: string): {
+    tables: string[];
+    warnings: string[];
+};