principles-disciple 1.150.0 → 1.152.0

package/dist/commands/pain.js

@@ -5,6 +5,7 @@ import { resolvePluginCommandWorkspaceDir } from '../utils/workspace-resolver.js
 import { computeHash } from '../utils/hashing.js';
 import { PainToPrincipleService, PrincipleTreeLedgerAdapter } from '@principles/core/runtime-v2';
 import { loadPdConfigForPlugin } from '../core/pd-config-loader.js';
+import { createIntentDocReader } from '../core/intent-doc-reader-adapter.js';
 /**
  * Creates a visual progress bar (e.g., [██████░░░░])
  */
@@ -274,6 +275,7 @@ export async function handlePainReportCommand(ctx) {
             autoIntakeEnabled: true,
             effectiveConfig: configResult.effective,
             getEnvVar: (name) => process.env[name],
+            intentDocReader: createIntentDocReader(wctx.workspaceDir),
         });
         const result = await service.recordPain({
             painId: painData.painId,

package/dist/core/intent-doc-reader-adapter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * PRI-468 — Plugin adapter implementing the core `IntentDocReader` port.
+ *
+ * Bridges the plugin-owned `safeReadIntentDoc()` I/O function to the
+ * core-owned `IntentDocReader` interface so Stage A (in core) can read
+ * INTENT.md without core performing any filesystem I/O.
+ *
+ * This adapter only MAPS types — it adds no new I/O, no new flag checks,
+ * and no new telemetry. The underlying `safeReadIntentDoc()` already
+ * performs the flag-first check (SPEC §12), TTL+mtime cache, and size cap.
+ *
+ * ERR checklist:
+ *   EP-01 / ERR-001: never `as` — field-by-field mapping with typeof checks
+ *   EP-02 / ERR-025: plugin I/O file, whitelisted in architecture-regression
+ *   EP-03 / ERR-002: every degraded path flows through with reason + nextAction
+ *
+ * Architecture: this file is I/O (delegates to fs-reading safeReadIntentDoc).
+ * It will be added to KNOWN_PLUGIN_CORE_FILES in architecture-regression.test.ts.
+ */
+import type { IntentDocReader } from '@principles/core/runtime-v2';
+/**
+ * Create an IntentDocReader bound to a specific workspace.
+ *
+ * The returned reader is stateless beyond the workspace binding — each
+ * `readIntentDoc()` call delegates to `safeReadIntentDoc()`, which owns
+ * the TTL+mtime cache.
+ */
+export declare function createIntentDocReader(workspaceDir: string): IntentDocReader;

package/dist/core/intent-doc-reader-adapter.js

@@ -0,0 +1,56 @@
+/**
+ * PRI-468 — Plugin adapter implementing the core `IntentDocReader` port.
+ *
+ * Bridges the plugin-owned `safeReadIntentDoc()` I/O function to the
+ * core-owned `IntentDocReader` interface so Stage A (in core) can read
+ * INTENT.md without core performing any filesystem I/O.
+ *
+ * This adapter only MAPS types — it adds no new I/O, no new flag checks,
+ * and no new telemetry. The underlying `safeReadIntentDoc()` already
+ * performs the flag-first check (SPEC §12), TTL+mtime cache, and size cap.
+ *
+ * ERR checklist:
+ *   EP-01 / ERR-001: never `as` — field-by-field mapping with typeof checks
+ *   EP-02 / ERR-025: plugin I/O file, whitelisted in architecture-regression
+ *   EP-03 / ERR-002: every degraded path flows through with reason + nextAction
+ *
+ * Architecture: this file is I/O (delegates to fs-reading safeReadIntentDoc).
+ * It will be added to KNOWN_PLUGIN_CORE_FILES in architecture-regression.test.ts.
+ */
+import { safeReadIntentDoc } from './intent-doc-reader.js';
+/**
+ * Create an IntentDocReader bound to a specific workspace.
+ *
+ * The returned reader is stateless beyond the workspace binding — each
+ * `readIntentDoc()` call delegates to `safeReadIntentDoc()`, which owns
+ * the TTL+mtime cache.
+ */
+export function createIntentDocReader(workspaceDir) {
+    return {
+        readIntentDoc() {
+            const result = safeReadIntentDoc(workspaceDir);
+            if (result.ok && result.doc) {
+                const doc = result.doc;
+                const reference = {
+                    raw: typeof doc.raw === 'string' ? doc.raw : '',
+                    contentHash: typeof doc.contentHash === 'string' ? doc.contentHash : '',
+                    path: typeof doc.path === 'string' ? doc.path : '',
+                };
+                return {
+                    ok: true,
+                    found: true,
+                    flagEnabled: true,
+                    doc: reference,
+                };
+            }
+            // Degraded path — preserve structured reason + nextAction (EP-03 / ERR-002)
+            return {
+                ok: false,
+                found: result.found,
+                flagEnabled: result.flagEnabled,
+                reason: result.reason,
+                nextAction: result.nextAction,
+            };
+        },
+    };
+}

package/dist/core/intent-doc-reader.d.ts

@@ -0,0 +1,80 @@
+/**
+ * PRI-467 — safeReadIntentDoc: plugin I/O wrapper for reading INTENT.md.
+ *
+ * Reads `.principles/INTENT.md` with:
+ * - Feature flag check FIRST (SPEC §12: flag off → flag_disabled without fs)
+ * - TTL + mtime cache (60s TTL, mtime check) mirroring prompt.ts cachedReadFile
+ * - 32KB size cap (INTENT_MAX_BYTES)
+ * - Never throws — all errors return structured `reason` + `nextAction`
+ *
+ * Trust boundary (SPEC §12.2):
+ * - Raw content is returned for the pure builder to escape; this reader does
+ *   NOT escape or bound the content for prompt injection. The pure builder
+ *   `buildIntentFrictionBlock` handles escaping + bounding.
+ *
+ * ERR checklist:
+ * EP-01 / ERR-001, ERR-005: raw content validated with typeof, never `as`
+ * EP-02 / ERR-025, ERR-070: production path; plugin I/O file in the whitelist
+ * EP-03 / ERR-002, ERR-014: every degraded path returns structured reason + nextAction
+ * EP-09: tests use real fs writes in temp dirs
+ *
+ * Architecture: this file is I/O (fs, path). It is whitelisted in
+ * architecture-regression.test.ts KNOWN_PLUGIN_CORE_FILES.
+ */
+import { type IntentDocSections, type IntentDocWarning } from '@principles/core/runtime-v2';
+export type SafeReadIntentDocReason = 'flag_disabled' | 'not_found' | 'oversized' | 'read_error';
+export interface IntentDoc {
+    /** Raw INTENT.md content (unescaped — caller escapes for prompt injection). */
+    raw: string;
+    /** Parsed sections from the raw content. */
+    sections: IntentDocSections;
+    /** SHA-256 content hash for deduplication and audit. */
+    contentHash: string;
+    /** Absolute path to the INTENT.md file. */
+    path: string;
+    /** ISO timestamp when the doc was read. */
+    readAt: string;
+    /** Validation warnings (missing/empty/too_vague sections). */
+    warnings: IntentDocWarning[];
+}
+export interface SafeReadIntentDocResult {
+    /** True when the doc was successfully read and parsed. */
+    ok: boolean;
+    /** True when the INTENT.md file exists on disk. */
+    found: boolean;
+    /** True when the intent_engineering flag is enabled. */
+    flagEnabled: boolean;
+    /** The parsed IntentDoc, present only when ok=true. */
+    doc?: IntentDoc;
+    /** Structured reason for a degraded path (present when ok=false). */
+    reason?: SafeReadIntentDocReason;
+    /** Next action for the operator (present when ok=false). */
+    nextAction?: string;
+    /** Validation warnings (always present, empty when no warnings). */
+    warnings: IntentDocWarning[];
+}
+/**
+ * Reset the intent doc cache for test isolation.
+ * Call in beforeEach() to ensure tests don't pollute each other.
+ */
+export declare function resetIntentDocCacheForTest(workspaceDir?: string): void;
+/**
+ * Safely read INTENT.md for prompt injection.
+ *
+ * Contract (SPEC §12):
+ * 1. Flag check FIRST via loadFeatureFlagFromConfig. Flag off → flag_disabled
+ *    WITHOUT any fs access to INTENT.md.
+ * 2. Flag on → check TTL + mtime cache. If cached and fresh → return cached.
+ * 3. Otherwise → stat the file (oversized check), read, parse, validate, cache.
+ * 4. Never throws — all errors return structured reason + nextAction.
+ *
+ * @param workspaceDir - Absolute path to the workspace root
+ * @param options - Optional logger for debug-level diagnostics
+ * @returns SafeReadIntentDocResult (never throws)
+ */
+export declare function safeReadIntentDoc(workspaceDir: string, options?: {
+    logger?: {
+        debug?: (msg: string) => void;
+        warn?: (msg: string) => void;
+    };
+}): SafeReadIntentDocResult;

package/dist/core/intent-doc-reader.js

@@ -0,0 +1,189 @@
+/**
+ * PRI-467 — safeReadIntentDoc: plugin I/O wrapper for reading INTENT.md.
+ *
+ * Reads `.principles/INTENT.md` with:
+ * - Feature flag check FIRST (SPEC §12: flag off → flag_disabled without fs)
+ * - TTL + mtime cache (60s TTL, mtime check) mirroring prompt.ts cachedReadFile
+ * - 32KB size cap (INTENT_MAX_BYTES)
+ * - Never throws — all errors return structured `reason` + `nextAction`
+ *
+ * Trust boundary (SPEC §12.2):
+ * - Raw content is returned for the pure builder to escape; this reader does
+ *   NOT escape or bound the content for prompt injection. The pure builder
+ *   `buildIntentFrictionBlock` handles escaping + bounding.
+ *
+ * ERR checklist:
+ * EP-01 / ERR-001, ERR-005: raw content validated with typeof, never `as`
+ * EP-02 / ERR-025, ERR-070: production path; plugin I/O file in the whitelist
+ * EP-03 / ERR-002, ERR-014: every degraded path returns structured reason + nextAction
+ * EP-09: tests use real fs writes in temp dirs
+ *
+ * Architecture: this file is I/O (fs, path). It is whitelisted in
+ * architecture-regression.test.ts KNOWN_PLUGIN_CORE_FILES.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { INTENT_MAX_BYTES, parseIntentDocSections, computeIntentContentHash, validateIntentDocSections, } from '@principles/core/runtime-v2';
+import { loadFeatureFlagFromConfig } from './pd-config-loader.js';
+// ── Constants ────────────────────────────────────────────────────────────────
+const INTENT_FILENAME = 'INTENT.md';
+const INTENT_DIR = '.principles';
+const INTENT_CACHE_TTL_MS = 60_000; // 1 minute (SPEC §12.1)
+// ── Module-level cache (per-workspace) ───────────────────────────────────────
+const _intentDocCache = new Map();
+/**
+ * Reset the intent doc cache for test isolation.
+ * Call in beforeEach() to ensure tests don't pollute each other.
+ */
+export function resetIntentDocCacheForTest(workspaceDir) {
+    if (workspaceDir) {
+        _intentDocCache.delete(workspaceDir);
+    }
+    else {
+        _intentDocCache.clear();
+    }
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function getIntentFilePath(workspaceDir) {
+    return path.join(workspaceDir, INTENT_DIR, INTENT_FILENAME);
+}
+function buildDocFromRaw(raw, filePath, readAt) {
+    const sections = parseIntentDocSections(raw);
+    const warnings = validateIntentDocSections(sections);
+    const contentHash = computeIntentContentHash(raw);
+    return {
+        raw,
+        sections,
+        contentHash,
+        path: filePath,
+        readAt,
+        warnings,
+    };
+}
+// ── Main entrypoint ──────────────────────────────────────────────────────────
+/**
+ * Safely read INTENT.md for prompt injection.
+ *
+ * Contract (SPEC §12):
+ * 1. Flag check FIRST via loadFeatureFlagFromConfig. Flag off → flag_disabled
+ *    WITHOUT any fs access to INTENT.md.
+ * 2. Flag on → check TTL + mtime cache. If cached and fresh → return cached.
+ * 3. Otherwise → stat the file (oversized check), read, parse, validate, cache.
+ * 4. Never throws — all errors return structured reason + nextAction.
+ *
+ * @param workspaceDir - Absolute path to the workspace root
+ * @param options - Optional logger for debug-level diagnostics
+ * @returns SafeReadIntentDocResult (never throws)
+ */
+export function safeReadIntentDoc(workspaceDir, options) {
+    // SPEC §12 — Flag check FIRST. Flag off → no fs access, no cache access.
+    const flagResult = loadFeatureFlagFromConfig(workspaceDir, 'intent_engineering', options?.logger);
+    if (!flagResult.enabled) {
+        return {
+            ok: false,
+            found: false,
+            flagEnabled: false,
+            reason: 'flag_disabled',
+            nextAction: 'Enable the intent_engineering feature flag in .pd/config.yaml to read INTENT.md.',
+            warnings: [],
+        };
+    }
+    const filePath = getIntentFilePath(workspaceDir);
+    const now = Date.now();
+    // Check cache freshness (TTL + mtime)
+    const cached = _intentDocCache.get(workspaceDir);
+    if (cached && (now - cached.loadedAt) < INTENT_CACHE_TTL_MS) {
+        // Cache is within TTL. Verify mtime hasn't changed.
+        try {
+            const stat = fs.statSync(filePath);
+            if (stat.mtimeMs === cached.mtime) {
+                // Cache hit — return cached doc
+                return {
+                    ok: true,
+                    found: true,
+                    flagEnabled: true,
+                    doc: cached.doc,
+                    warnings: cached.doc.warnings,
+                };
+            }
+        }
+        catch {
+            // File may have been deleted since caching. Fall through to not_found path.
+            // Don't return cached doc if the file no longer exists.
+        }
+    }
+    // Fresh read path
+    try {
+        // Check existence first
+        if (!fs.existsSync(filePath)) {
+            // Invalidate stale cache entry if any
+            _intentDocCache.delete(workspaceDir);
+            return {
+                ok: false,
+                found: false,
+                flagEnabled: true,
+                reason: 'not_found',
+                nextAction: 'Create .principles/INTENT.md using "pd intent init".',
+                warnings: [],
+            };
+        }
+        const stat = fs.statSync(filePath);
+        // SPEC §12 — 32KB size cap
+        if (stat.size > INTENT_MAX_BYTES) {
+            _intentDocCache.delete(workspaceDir);
+            return {
+                ok: false,
+                found: true,
+                flagEnabled: true,
+                reason: 'oversized',
+                nextAction: `INTENT.md exceeds ${INTENT_MAX_BYTES} bytes (${stat.size} bytes). Reduce content.`,
+                warnings: [],
+            };
+        }
+        const raw = fs.readFileSync(filePath, 'utf8');
+        // PRI-467 review fix (P2): TOCTOU guard — re-check actual byte length
+        // after readFileSync. The file may have grown between statSync() and
+        // readFileSync(), bypassing the stat.size oversized check. Without this,
+        // an oversized file would enter parse/hash/cache as ok:true.
+        const actualBytes = Buffer.byteLength(raw, 'utf8');
+        if (actualBytes > INTENT_MAX_BYTES) {
+            _intentDocCache.delete(workspaceDir);
+            return {
+                ok: false,
+                found: true,
+                flagEnabled: true,
+                reason: 'oversized',
+                nextAction: `INTENT.md exceeds ${INTENT_MAX_BYTES} bytes (${actualBytes} bytes after read). Reduce content.`,
+                warnings: [],
+            };
+        }
+        const doc = buildDocFromRaw(raw, filePath, new Date(now).toISOString());
+        // Update cache
+        _intentDocCache.set(workspaceDir, {
+            doc,
+            mtime: stat.mtimeMs,
+            loadedAt: now,
+        });
+        return {
+            ok: true,
+            found: true,
+            flagEnabled: true,
+            doc,
+            warnings: doc.warnings,
+        };
+    }
+    catch (err) {
+        // ERR-002 — graceful degradation with reason + nextAction
+        _intentDocCache.delete(workspaceDir);
+        const message = err instanceof Error ? err.message : String(err);
+        options?.logger?.warn?.(`[PD:Intent] safeReadIntentDoc failed: workspace=${workspaceDir}, error=${message}`);
+        return {
+            ok: false,
+            found: false,
+            flagEnabled: true,
+            reason: 'read_error',
+            nextAction: 'Check filesystem permissions for .principles/INTENT.md.',
+            warnings: [],
+        };
+    }
+}

package/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 } 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),
     });
 }
 // buildTrajectoryEvidence is in ./trajectory-evidence.ts (re-exported above)

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

@@ -76,9 +76,13 @@ 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)

package/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,

package/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/dist/hooks/prompt.js

@@ -20,6 +20,8 @@ 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 { 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';
@@ -103,10 +105,12 @@ export function resetPromptStateForTest(workspaceDir) {
     if (workspaceDir) {
         _staticFileCache.delete(workspaceDir);
         _empathyState.delete(workspaceDir);
+        resetIntentDocCacheForTest(workspaceDir);
     }
     else {
         _staticFileCache.clear();
         _empathyState.clear();
+        resetIntentDocCacheForTest();
     }
 }
 function parseContextInjectionConfig(value) {
@@ -871,11 +875,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, { 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 +923,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/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.150.0",
+  "version": "1.152.0",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

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