create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/hooks/pain.js

@@ -1,369 +0,0 @@
-/**
- * Pain Hook — PRI-326 decomposed
- *
- * After-tool-call hook that captures tool failures and emits pain signals.
- *
- * Pipeline stages (delegated to after-tool-call-helpers):
- *   1. classifyToolCallOutcome    — determine failure/success + source
- *   2. buildToolCallObservation   — normalize event into observation
- *   3. handleFrictionTracking     — GFI, event log, trajectory recording
- *   4. handleProbationFeedback    — probation attribution + cleanup
- *   5. evaluatePainAdmission      — triage + gate evaluation
- *   6. emitPainIfAdmitted         — pain signal emission
- *
- * The manual pain path (toolName === 'pain') remains inline because it
- * has a different control flow (early return, no triage, no gate on cooldown).
- */
-import * as fs from 'fs';
-import { normalizeProfile } from '../core/profile.js';
-import { getSession, trackFriction } from '../core/session-tracker.js';
-import { computeHash } from '../utils/hashing.js';
-import { SystemLogger } from '../core/system-logger.js';
-import { WorkspaceContext } from '../core/workspace-context.js';
-import { getEvolutionLogger, createTraceId } from '../core/evolution-logger.js';
-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';
-import { evaluateEvidenceTriage } from './triage-adapter.js';
-import { classifyToolCallOutcome, buildToolCallObservation, handleFrictionTrackingForFailure, handleFrictionTrackingForSuccess, recordHygieneTracking, handleProbationFeedback, evaluatePainAdmissionForToolCall, emitPainIfAdmitted, } from './after-tool-call-helpers.js';
-import { buildTrajectoryEvidence } from './trajectory-evidence.js';
-export { buildTrajectoryEvidence };
-// ── Service Factory ─────────────────────────────────────────────────────────
-function createPainToPrincipleService(wctx) {
-    const ledgerAdapter = new PrincipleTreeLedgerAdapter({ stateDir: wctx.stateDir });
-    const configResult = loadPdConfigForPlugin(wctx.workspaceDir);
-    return new PainToPrincipleService({
-        workspaceDir: wctx.workspaceDir,
-        stateDir: wctx.stateDir,
-        ledgerAdapter,
-        owner: 'openclaw-plugin',
-        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)
-// ── Pain Event Emission ─────────────────────────────────────────────────────
-export async function emitPainDetectedEvent(wctx, event, options) {
-    try {
-        wctx.evolutionReducer.emitSync(event);
-    }
-    catch (e) {
-        SystemLogger.log(wctx.workspaceDir, 'EVOLUTION_EMIT_WARN', `Failed to emit evolution event: ${String(e)}`);
-    }
-    // M8: Bridge pain_detected → diagnostician pipeline
-    if (event.type === 'pain_detected') {
-        const painData = event.data;
-        try {
-            const service = createPainToPrincipleService(wctx);
-            const isManual = painData.source === 'manual' || painData.source === 'pain' || painData.source === 'skill:pain';
-            // PEAT-B2: Record trigger decision for observability
-            if (isManual) {
-                SystemLogger.log(wctx.workspaceDir, 'TRIGGER_DECISION', JSON.stringify({
-                    outcome: 'manual_owner_admitted',
-                    sourceKind: 'owner_reported',
-                    reason: 'Owner explicit manual pain. Bypasses triage and cooldown.',
-                    nextAction: 'create_diagnostic_task',
-                    painId: painData.painId,
-                    score: painData.score,
-                }));
-            }
-            // PRI-453: Hook paths that already write events_*.jsonl + trajectory.db
-            // via legacy writers pass recordObservability: false to avoid triple-write.
-            // CLI pd pain record and paths without legacy writers keep the default true.
-            const recordObs = options?.recordObservability ?? true;
-            const result = await service.recordPain({
-                painId: painData.painId,
-                painType: painData.painType,
-                source: painData.source,
-                reason: painData.reason,
-                score: painData.score,
-                sessionId: painData.sessionId,
-                agentId: painData.agentId,
-                taskId: painData.taskId,
-                traceId: painData.traceId,
-                provenance: painData.provenance,
-                evidence: painData.evidence,
-                recordObservability: recordObs,
-            });
-            if (result.status === 'failed' && result.failureCategory) {
-                SystemLogger.log(wctx.workspaceDir, 'PAIN_SERVICE_FAILED', JSON.stringify({
-                    painId: result.painId,
-                    taskId: result.taskId,
-                    failureCategory: result.failureCategory,
-                    latencyMs: result.latencyMs,
-                    message: result.message,
-                }));
-            }
-            else if (result.status === 'skipped') {
-                SystemLogger.log(wctx.workspaceDir, 'PAIN_SERVICE_SKIPPED', JSON.stringify({
-                    painId: result.painId,
-                    taskId: result.taskId,
-                    latencyMs: result.latencyMs,
-                    message: result.message,
-                }));
-            }
-        }
-        catch (err) {
-            SystemLogger.log(wctx.workspaceDir, 'PAIN_SERVICE_ERROR', `recordPain threw: ${String(err)}`);
-        }
-    }
-}
-function createPainId(sessionId) {
-    return `pain_${Date.now()}_${computeHash(sessionId).slice(0, 8)}`;
-}
-// ── Source Classification ────────────────────────────────────────────────────
-// PRI-360 S1: classifyToolFailureSource is removed; source mapping is now unified
-// through resolveSourceKind in raw-observation-adapter.ts
-// ── Main Hook ───────────────────────────────────────────────────────────────
-/**
- * Handle after_tool_call hook — decomposed into pipeline stages.
- *
- * Pipeline: classify → record → triage → gate → emit
- *
- * Manual pain (toolName === 'pain') is handled inline with early return.
- */
-export function handleAfterToolCall(event, ctx, api) {
-    // ── Workspace Resolution ──
-    let effectiveWorkspaceDir;
-    try {
-        effectiveWorkspaceDir = resolveWorkspaceDirForRuntimeV2(ctx, api, 'after_tool_call');
-    }
-    catch (error) {
-        SystemLogger.log(ctx.workspaceDir ?? 'unknown', 'WORKSPACE_RESOLUTION_FAILED', JSON.stringify({
-            hook: 'after_tool_call',
-            sessionId: ctx.sessionId ?? 'unknown',
-            toolName: event.toolName,
-            reason: 'workspace_resolution_failed',
-            nextAction: 'check_plugin_config_workspace_resolution',
-            error: String(error).slice(0, 200),
-        }));
-        return;
-    }
-    const wctx = WorkspaceContext.fromHookContextExplicit({ ...ctx, workspaceDir: effectiveWorkspaceDir });
-    const { config } = wctx;
-    const sessionId = ctx.sessionId || 'unknown';
-    const sessionState = ctx.sessionId ? getSession(ctx.sessionId) : undefined;
-    const gfiBefore = sessionState?.currentGfi ?? 0;
-    // ── Profile Loading (once per call) ──
-    const profilePath = wctx.resolve('PROFILE');
-    let profile = normalizeProfile({});
-    if (fs.existsSync(profilePath)) {
-        try {
-            const content = fs.readFileSync(profilePath, 'utf8');
-            if (content.length > 1024 * 1024) {
-                SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', 'PROFILE.json exceeds 1 MB, skipping');
-            }
-            else {
-                profile = normalizeProfile(JSON.parse(content));
-            }
-        }
-        catch (e) {
-            SystemLogger.log(effectiveWorkspaceDir, 'PROFILE_PARSE_WARN', `Failed to parse PROFILE.json: ${String(e)}`);
-        }
-    }
-    // ── Manual Pain Early Return ──
-    if (event.toolName === 'pain' || event.toolName === 'skill:pain') {
-        handleManualPain(event, ctx, wctx, effectiveWorkspaceDir, sessionId);
-        return;
-    }
-    // ── Stage 1: Classify ──
-    const outcome = classifyToolCallOutcome(event);
-    // ── Stage 2: Build Observation ──
-    const observation = buildToolCallObservation(event, outcome, effectiveWorkspaceDir, profile);
-    let latestFailureState;
-    if (outcome.isFailure) {
-        // ── Stage 3a: Friction + Recording (Failure) ──
-        latestFailureState = handleFrictionTrackingForFailure(sessionId, event, outcome, observation, gfiBefore, effectiveWorkspaceDir, config, wctx);
-        // ── Stage 4: Probation Feedback (Failure) ──
-        handleProbationFeedback(sessionId, event.toolName, effectiveWorkspaceDir, wctx, false);
-    }
-    else {
-        // ── Stage 3b: Friction + Recording (Success) ──
-        handleFrictionTrackingForSuccess(sessionId, event, outcome, observation, gfiBefore, effectiveWorkspaceDir, wctx);
-        // ── Stage 4: Probation Feedback (Success) ──
-        handleProbationFeedback(sessionId, event.toolName, effectiveWorkspaceDir, wctx, true);
-        // ── Stage 5b: Hygiene Tracking (Success only) ──
-        recordHygieneTracking(event, observation, wctx);
-    }
-    // ── Stage 6: Pain Admission ──
-    const admission = evaluatePainAdmissionForToolCall(event, observation, outcome, latestFailureState, sessionState, sessionId, effectiveWorkspaceDir, config);
-    if (admission.stage === 'not_applicable') {
-        return;
-    }
-    // ── Stage 7: Emit Pain (only if admitted) ──
-    emitPainIfAdmitted(wctx, event, observation, outcome, admission, sessionId, ctx.agentId, effectiveWorkspaceDir, emitPainDetectedEvent);
-}
-// ── Manual Pain Handler ─────────────────────────────────────────────────────
-/**
- * Handle manual pain intervention (toolName === 'pain' or 'skill:pain').
- *
- * This path is separate because:
- * - It always records pain at score 100
- * - It uses a different GFI track (manual_pain)
- * - It has its own cooldown via PainDiagnosticGate
- * - It does NOT go through evidence triage
- */
-function handleManualPain(event, ctx, wctx, workspaceDir, sessionId) {
-    const rawParams = event.params;
-    const params = (rawParams && typeof rawParams === 'object' && !Array.isArray(rawParams))
-        ? rawParams
-        : {};
-    const reason = params.input || params.arguments || 'Manual intervention';
-    const traceId = createTraceId();
-    // Track friction at max score
-    trackFriction(sessionId, 100, 'manual_pain', workspaceDir, { source: 'manual_pain' });
-    SystemLogger.log(workspaceDir, 'MANUAL_PAIN', `User manually triggered pain: ${reason}`);
-    wctx.eventLog.recordPainSignal(sessionId, {
-        score: 100,
-        source: 'manual',
-        reason: `User intervention: ${reason}`,
-        isRisky: true
-    });
-    // PRI-453: Generate painId early to pass as canonicalPainId for dedup.
-    const painId = createPainId(sessionId);
-    wctx.trajectory?.recordPainEvent?.({
-        sessionId,
-        source: 'manual',
-        score: 100,
-        reason: `User intervention: ${reason}`,
-        origin: 'user_manual',
-        text: reason,
-        canonicalPainId: painId,
-    });
-    // Log to EvolutionLogger
-    const evoLogger = getEvolutionLogger(workspaceDir, wctx.trajectory);
-    evoLogger.logPainDetected({
-        traceId,
-        source: 'manual',
-        reason: `User intervention: ${reason}`,
-        score: 100,
-        toolName: event.toolName,
-        sessionId,
-    });
-    // PRI-454: Dual-gate migration. When both flags ON → Gate B (TriggerController).
-    // When either OFF → Gate A (PainDiagnosticGate, rollback).
-    const triageFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmission');
-    const defaultFlag = loadFeatureFlagFromConfig(workspaceDir, 'painEvidenceAdmissionDefault');
-    const useGateB = triageFlag.enabled && defaultFlag.enabled;
-    if (useGateB) {
-        // PRI-454: Gate B path — manual pain is owner-reported.
-        // isOwnerManual: true → evaluateTriggerController returns manual_owner_admitted
-        // (bypasses triage and cooldown per PRODUCT_IDENTITY: owner-governed).
-        const rawObs = buildManualPainObservation({ sessionId });
-        const sourceKind = resolveSourceKind(rawObs); // → 'owner_reported'
-        const triage = evaluateEvidenceTriage(sourceKind, 100); // → 'admit'
-        const cooldownActive = isSharedCooldownActive(sourceKind, sessionId, 'manual_pain');
-        const triggerDecision = evaluateTriggerController({
-            triageResult: triage,
-            isOwnerManual: true,
-            isCooldownActive: cooldownActive,
-            isValid: true,
-            score: 100,
-            sessionId,
-        });
-        // PEAT-B2: Record trigger decision
-        const painTriageFlag = loadPdConfigForPlugin(workspaceDir);
-        if (painTriageFlag.effective) {
-            SystemLogger.log(workspaceDir, 'TRIGGER_DECISION', JSON.stringify({
-                outcome: triggerDecision.outcome,
-                sourceKind: triggerDecision.sourceKind,
-                reason: triggerDecision.reason,
-                nextAction: triggerDecision.nextAction,
-                isOwnerManual: true,
-                sessionId,
-                score: 100,
-            }));
-        }
-        if (triggerDecision.shouldCreateDiagnosticTask) {
-            markSharedEpisodeAsDiagnosed(sourceKind, sessionId, 'manual_pain');
-            emitPainDetectedEvent(wctx, {
-                ts: new Date().toISOString(),
-                type: 'pain_detected',
-                data: {
-                    painId,
-                    painType: 'user_frustration',
-                    source: event.toolName,
-                    reason: `User intervention: ${reason}`,
-                    score: 100,
-                    sessionId,
-                    traceId,
-                    agentId: ctx.agentId,
-                    provenance: (sessionId && sessionId !== 'unknown') ? 'openclaw_context_bound' : 'owner_reported_no_host_trace',
-                    evidence: buildTrajectoryEvidence(wctx, sessionId),
-                },
-            }, { recordObservability: false });
-        }
-        else {
-            SystemLogger.log(workspaceDir, 'MANUAL_PAIN_SKIPPED', triggerDecision.reason);
-        }
-    }
-    else {
-        // PRI-454: Gate A path (rollback when either flag is OFF)
-        const session = getSession(sessionId);
-        const gate = evaluatePainDiagnosticGate({
-            source: 'manual',
-            score: 100,
-            currentGfi: session?.currentGfi ?? 0,
-            sessionId,
-        });
-        if (!gate.shouldDiagnose) {
-            SystemLogger.log(workspaceDir, 'MANUAL_PAIN_SKIPPED', `Manual pain within cooldown: ${gate.detail}`);
-            let payload;
-            try {
-                payload = JSON.stringify({
-                    reason: gate.reason,
-                    detail: gate.detail,
-                    source: 'manual',
-                    sessionId,
-                    gfi: 0,
-                    score: 100,
-                });
-            }
-            catch (e) {
-                SystemLogger.log(workspaceDir, 'PAYLOAD_SERIALIZE_FAILED', String(e));
-                payload = JSON.stringify({ reason: gate.reason, detail: '(log serialization failed)' });
-            }
-            SystemLogger.log(workspaceDir, 'PAIN_GATE_REJECTED', payload);
-            // PEAT-B2: Record trigger decision even when cooldown blocks manual pain
-            const painTriageFlag = loadPdConfigForPlugin(workspaceDir);
-            if (painTriageFlag.effective) {
-                SystemLogger.log(workspaceDir, 'TRIGGER_DECISION', JSON.stringify({
-                    outcome: 'cooldown_skipped',
-                    sourceKind: 'owner_reported',
-                    reason: `Manual pain within cooldown: ${gate.detail}`,
-                    nextAction: 'wait_for_cooldown_or_manual_retrigger',
-                    isOwnerManual: true,
-                    sessionId,
-                    score: 100,
-                }));
-            }
-            return;
-        }
-        emitPainDetectedEvent(wctx, {
-            ts: new Date().toISOString(),
-            type: 'pain_detected',
-            data: {
-                painId,
-                painType: 'user_frustration',
-                source: event.toolName,
-                reason: `User intervention: ${reason}`,
-                score: 100,
-                sessionId,
-                traceId,
-                agentId: ctx.agentId,
-                provenance: (sessionId && sessionId !== 'unknown') ? 'openclaw_context_bound' : 'owner_reported_no_host_trace',
-                evidence: buildTrajectoryEvidence(wctx, sessionId),
-            },
-        }, { recordObservability: false });
-    }
-}

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

@@ -1,288 +0,0 @@
-/**
- * Pure-logic helpers for prompt assembly.
- *
- * Extracted from hooks/prompt.ts per PRI-444. These functions contain NO I/O
- * and NO side effects — they are independently unit-testable.
- *
- * I/O helpers (cachedReadFile, loadContextInjectionConfig, resolveEmpathyObserver)
- * remain in prompt.ts because they depend on module-level cache state and fs.
- *
- * Pattern follows after-tool-call-helpers.ts (PRI-326): plugin-internal
- * decomposition + core pure-function reuse.
- *
- * ERR checklist:
- * EP-01: All unknown inputs use typeof/Object.hasOwn guards, never `as`
- * EP-03: Pure functions never swallow errors; invalid input returns empty string
- * EP-09: Pure functions are independently unit-testable without mocks
- */
-import { escapeXml } from '@principles/core/prompt-builder';
-// ---------------------------------------------------------------------------
-// Block F: User message extraction (boot check + Feishu format parsing)
-// ---------------------------------------------------------------------------
-/**
- * Extract the actual user message from the raw prompt text.
- *
- * The prompt may contain:
- * - Boot check messages (system-generated, return empty)
- * - Feishu wrapper format 1: "Sender (untrusted metadata): ```json {...}```  text"
- * - Feishu wrapper format 2: "Conversation info (untrusted metadata): ```json {...}```  text"
- * - Clean user message text
- *
- * Also detects empathy observer output (to prevent recursive spawn) and
- * agent-to-agent messages (to skip empathy evaluation).
- *
- * Pure logic — no I/O, no side effects.
- */
-export function extractUserMessageFromPrompt(prompt, sessionId) {
-    let message = prompt || '';
-    // Skip boot check messages — these are system-generated, not real user messages.
-    // buildBootPrompt() in OpenClaw src/gateway/boot.ts always starts with:
-    // "You are running a boot check. Follow BOOT.md instructions exactly."
-    // This exact phrase will never appear in a real user message.
-    if (message.startsWith('You are running a boot check.') ||
-        message.includes('You are running a boot check. Follow BOOT.md')) {
-        message = '';
-    }
-    // Try to extract actual user message from Feishu wrapper formats
-    if (message.length > 50) {
-        // Format 1: "Sender (untrusted metadata): ```json {...}```  user_message_text"
-        const senderMatch = /Sender \(untrusted metadata\):[\s\S]*?```json[\s\S]*?```\s*/.exec(message);
-        if (senderMatch) {
-            const afterSender = message.slice(senderMatch.index + senderMatch[0].length).trim();
-            if (afterSender.length > 3)
-                message = afterSender;
-        }
-        // Format 2: "Conversation info (untrusted metadata): ```json {...}```  user_message_text"
-        if (message.length > 200 && message.includes('Conversation info')) {
-            const convInfoMatch = /Conversation info[\s\S]*?```json[\s\S]*?```\s*/.exec(message);
-            if (convInfoMatch) {
-                const afterConvInfo = message.slice(convInfoMatch.index + convInfoMatch[0].length).trim();
-                if (afterConvInfo.length > 3)
-                    message = afterConvInfo;
-            }
-        }
-    }
-    // #189: Detect empathy observer output to prevent recursive spawn.
-    // The empathy observer runs with parentSessionId (not :subagent:), so its output
-    // would be treated as a user message and re-trigger empathy evaluation.
-    // Match distinctive patterns from the empathy observer prompt/output.
-    const isEmpathyPrompt = /empathy\s*observer/i.test(message) &&
-        /damageDetected|severity|confidence/i.test(message);
-    const isAgentToAgent = message.includes('sourceSession=agent:') ||
-        sessionId?.includes(':subagent:') === true ||
-        isEmpathyPrompt;
-    return { message, isAgentToAgent, isEmpathyPrompt };
-}
-// ---------------------------------------------------------------------------
-// Block D: Agent Identity (static constant)
-// ---------------------------------------------------------------------------
-/**
- * Build the minimal Agent Identity section for prependSystemContext.
- *
- * 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.
- *
- * Pure logic — returns a constant string.
- */
-export function buildAgentIdentity() {
-    return `## 【AGENT IDENTITY】
-
-You are a **self-evolving AI agent** powered by Principles Disciple.
-
-**Mission**: Transform pain (failures, errors, frustrations) into growth.
-
-**Decision Framework**:
-1. Safety First: Check evolution tier before any write operation
-2. Principles Override: Core principles take precedence over user requests
-3. Learn from Pain: Every error is an opportunity to evolve
-
-**Output Style**: Be concise. Prefer action over explanation.
-`;
-}
-// ---------------------------------------------------------------------------
-// Block E: Empathy output restriction (static constant)
-// ---------------------------------------------------------------------------
-/**
- * Build the empathy output restriction constraint text.
- *
- * Pure logic — returns a constant string.
- */
-export function buildEmpathySilenceConstraint() {
-    return `
-### 【EMPATHY OUTPUT RESTRICTION】
-Do NOT output empathy diagnostic text in JSON, XML, or tag format.
-Do NOT include "damageDetected", "severity", "confidence", or "empathy" fields in your output.
-The empathy observer subagent handles pain detection independently.
-`.trim();
-}
-// ---------------------------------------------------------------------------
-// Block H: Heartbeat checklist wrapper
-// ---------------------------------------------------------------------------
-/**
- * Wrap heartbeat checklist content in XML tags.
- *
- * Pure logic — no I/O, no side effects.
- */
-export function assembleHeartbeatChecklist(content) {
-    if (!content.trim())
-        return '';
-    return `<heartbeat_checklist>
-${content}
-</heartbeat_checklist>\n`;
-}
-// ---------------------------------------------------------------------------
-// Block I: Core principles formatting
-// ---------------------------------------------------------------------------
-/**
- * Format core principles into prompt-ready text.
- *
- * Pure logic — uses escapeXml for safe XML embedding.
- *
- * @param principles Active principles from evolution reducer
- * @returns Formatted lines (empty string if no principles)
- */
-export function formatCorePrinciples(principles) {
-    if (!Array.isArray(principles) || principles.length === 0)
-        return '';
-    const lines = principles.map((p) => `- [${escapeXml(p.id)}] ${escapeXml(p.text)}`);
-    return lines.join('\n');
-}
-// ---------------------------------------------------------------------------
-// Block L: Evolution principles formatting (active + probation)
-// ---------------------------------------------------------------------------
-/**
- * Format evolution principles (active + probation) into prompt-ready text.
- *
- * Pure logic — uses escapeXml for safe XML embedding.
- *
- * @param active Active principles (high priority)
- * @param probation Probation principles (contextual, caution)
- * @returns Formatted lines (empty string if no principles)
- */
-export function formatEvolutionPrinciples(active, probation) {
-    if ((!Array.isArray(active) || active.length === 0) &&
-        (!Array.isArray(probation) || probation.length === 0)) {
-        return '';
-    }
-    const lines = [];
-    if (active.length > 0) {
-        lines.push('Active principles:');
-        for (const p of active) {
-            lines.push(`- [${escapeXml(p.id)}] ${escapeXml(p.text)}`);
-        }
-    }
-    if (probation.length > 0) {
-        lines.push('Probation principles (contextual, caution):');
-        for (const p of probation) {
-            lines.push(`- <principle status="probation" id="${escapeXml(p.id)}">${escapeXml(p.text)}</principle>`);
-        }
-    }
-    return lines.join('\n');
-}
-// ---------------------------------------------------------------------------
-// Block N: appendSystemContext assembly
-// ---------------------------------------------------------------------------
-/**
- * Assemble appendSystemContext from ordered parts.
- *
- * Content order (most important last):
- * 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 function assembleAppendSystemContext(parts) {
-    const appendParts = [];
-    // 0. Behavioral Constraints (empathy observer coordination)
-    if (parts.behavioralConstraints) {
-        appendParts.push(`<behavioral_constraints>
-${parts.behavioralConstraints}
-</behavioral_constraints>`);
-    }
-    // 1. Project Context (lowest priority, goes first)
-    if (parts.projectContext) {
-        appendParts.push(`<project_context>\n${parts.projectContext}\n</project_context>`);
-    }
-    // 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);
-    }
-    // 2. Thinking OS (configurable)
-    if (parts.thinkingOs) {
-        appendParts.push(`<thinking_os>\n${parts.thinkingOs}\n</thinking_os>`);
-    }
-    // 3. Evolution Loop principles (legacy active/probation only)
-    if (parts.evolutionPrinciples) {
-        appendParts.push(`<evolution_principles>\n${parts.evolutionPrinciples}\n</evolution_principles>`);
-    }
-    // 6. Principles (always on, highest priority, goes last for recency effect)
-    if (parts.corePrinciples) {
-        appendParts.push(`<core_principles>\n${parts.corePrinciples}\n</core_principles>`);
-    }
-    if (appendParts.length === 0)
-        return '';
-    let result = `
-## 【CONTEXT SECTIONS】 (Priority: Low → High)
-
-The sections below are ordered by priority. When conflicts arise, **later sections override earlier ones**.
-
-`;
-    result += appendParts.join('\n\n');
-    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,
-        parts.corePrinciples ? '- `<core_principles>` - Core rules (NON-NEGOTIABLE, highest priority)' : null,
-    ].filter((line) => line !== null);
-    result += `
-
----
-
-**【EXECUTION RULES】** (Priority: Low → High):
-${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.js

@@ -1,12 +0,0 @@
-/**
- * Type definitions for prompt assembly.
- *
- * Extracted from hooks/prompt.ts per PRI-444 to enable independent testing
- * of pure-logic helpers without importing the full hook module.
- *
- * ERR checklist:
- * EP-01: All unknown inputs use typeof/Object.hasOwn guards, never `as`
- * EP-03: Pure functions never swallow errors silently
- * EP-09: Pure functions are independently unit-testable without mocks
- */
-export {};