create-principles-disciple 1.94.0 → 1.95.0

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,12 @@ 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';
-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 +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) {
@@ -301,6 +305,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 +316,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 +451,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 +462,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 +552,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 +566,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 +590,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 +614,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 +638,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 +901,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 +949,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';
@@ -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[];
+};

package/plugin/dist/service/subagent-workflow/workflow-store.js

@@ -78,8 +78,12 @@ export class WorkflowStore {
                 this.db.exec('ALTER TABLE subagent_workflows ADD COLUMN duration_ms INTEGER');
                 console.info(`[PD:WorkflowStore] Schema migration v${fromVersion} → v${toVersion}: added duration_ms column`);
             }
-            catch {
-                void 0;
+            catch (err) {
+                // rc-9: surface failure reason instead of silent void 0
+                const message = err instanceof Error ? err.message : String(err);
+                if (!message.includes('duplicate column name')) {
+                    console.info(`[PD:WorkflowStore] Schema migration v${fromVersion} → v${toVersion} failed: ${message}`);
+                }
             }
         }
     }
@@ -207,3 +211,88 @@ export class WorkflowStore {
         return rows.map(r => r.duration_ms);
     }
 }
+/**
+ * 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 function initWorkflowSchema(workspaceDir) {
+    const resolvedDir = path.resolve(workspaceDir);
+    const stateDir = path.join(resolvedDir, '.state');
+    const dbPath = path.join(stateDir, 'subagent_workflows.db');
+    const warnings = [];
+    const tables = ['schema_version', 'subagent_workflows', 'subagent_workflow_events'];
+    fs.mkdirSync(stateDir, { recursive: true });
+    const db = new Database(dbPath);
+    try {
+        db.pragma('journal_mode = WAL');
+        db.pragma('foreign_keys = ON');
+        db.pragma('synchronous = NORMAL');
+        db.pragma(`busy_timeout = ${DEFAULT_BUSY_TIMEOUT_MS}`);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS schema_version (
+                version INTEGER NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS subagent_workflows (
+                workflow_id TEXT PRIMARY KEY,
+                workflow_type TEXT NOT NULL,
+                transport TEXT NOT NULL,
+                parent_session_id TEXT NOT NULL,
+                child_session_key TEXT NOT NULL,
+                run_id TEXT,
+                state TEXT NOT NULL DEFAULT 'pending',
+                cleanup_state TEXT NOT NULL DEFAULT 'none',
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL,
+                last_observed_at INTEGER,
+                duration_ms INTEGER,
+                metadata_json TEXT NOT NULL DEFAULT '{}'
+            );
+            CREATE TABLE IF NOT EXISTS subagent_workflow_events (
+                workflow_id TEXT NOT NULL,
+                event_type TEXT NOT NULL,
+                from_state TEXT,
+                to_state TEXT NOT NULL,
+                reason TEXT NOT NULL,
+                payload_json TEXT NOT NULL DEFAULT '{}',
+                created_at INTEGER NOT NULL,
+                FOREIGN KEY (workflow_id) REFERENCES subagent_workflows(workflow_id) ON DELETE CASCADE
+            );
+            CREATE INDEX IF NOT EXISTS idx_workflows_parent_session ON subagent_workflows(parent_session_id);
+            CREATE INDEX IF NOT EXISTS idx_workflows_child_session ON subagent_workflows(child_session_key);
+            CREATE INDEX IF NOT EXISTS idx_workflows_state ON subagent_workflows(state);
+            CREATE INDEX IF NOT EXISTS idx_workflows_type ON subagent_workflows(workflow_type);
+            CREATE INDEX IF NOT EXISTS idx_events_workflow ON subagent_workflow_events(workflow_id);
+        `);
+        // Run migrations to bring schema up to SCHEMA_VERSION
+        const row = db.prepare('SELECT version FROM schema_version LIMIT 1').get();
+        const currentVersion = row?.version ?? 0;
+        if (currentVersion === 0) {
+            db.prepare('INSERT INTO schema_version (version) VALUES (?)').run(SCHEMA_VERSION);
+        }
+        else if (currentVersion < SCHEMA_VERSION) {
+            // Inline migration logic (mirrors WorkflowStore.runMigrations)
+            if (currentVersion < 2 && SCHEMA_VERSION >= 2) {
+                try {
+                    db.exec('ALTER TABLE subagent_workflows ADD COLUMN duration_ms INTEGER');
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (!message.includes('duplicate column name')) {
+                        warnings.push(`migration v${currentVersion}→v${SCHEMA_VERSION} duration_ms failed: ${message}`);
+                    }
+                }
+            }
+            db.prepare('UPDATE schema_version SET version = ?').run(SCHEMA_VERSION);
+        }
+        return { tables, warnings };
+    }
+    finally {
+        db.close();
+    }
+}

package/plugin/dist/types/event-types.d.ts

@@ -1,2 +1,2 @@
-export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RuleMatchEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, ToolCallStats, ErrorStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
+export type { EventType, EventCategory, EventLogEntry, ToolCallEventData, PainSignalEventData, RulePromotionEventData, HookExecutionEventData, GateBlockEventData, GateBypassEventData, PlanApprovalEventData, EvolutionTaskEventData, EmpathyRollbackEventData, HeartbeatDiagnosisEventData, DiagnosisTaskEventData, DiagnosticianReportEventData, PrincipleCandidateEventData, RuleEnforcedEventData, RuleHostEvaluatedEventData, RuleHostBlockedEventData, RuleHostRequireApprovalEventData, RuleHostAutoCorrectProposedEventData, RuleHostAutoCorrectAppliedEventData, RuntimeV2PromptActivationsInjectedEventData, RuleHostUnhealthyEventData, ToolCallStats, ErrorStats, EmpathyEventStats, GfiStats, EvolutionStats as EventEvolutionStats, HookStats, DailyStats, } from '@principles/core/runtime-v2';
 export { createEmptyDailyStats, } from '@principles/core/runtime-v2';

package/plugin/package.json

@@ -3,9 +3,13 @@
   "version": "1.74.1",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
-  "main": "./dist/bundle.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/bundle.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
   "repository": {
     "type": "git",
@@ -47,7 +51,6 @@
     "lint": "eslint \"src/**/*.ts\"",
     "bootstrap-rules": "node scripts/bootstrap-rules.mjs",
     "compile-principles": "node scripts/compile-principles.mjs",
-    "validate-live-path": "tsx scripts/validate-live-path.ts",
     "sync-plugin": "node scripts/sync-plugin.mjs"
   },
   "devDependencies": {

package/plugin/scripts/acceptance-test.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 /**
- * Nocturnal Pipeline — End-to-End Acceptance Test
+ * PD Pipeline — End-to-End Acceptance Test
  *
- * Verifies that all components of the Nocturnal reflection pipeline
+ * Verifies that all components of the PD reflection pipeline
  * work correctly in a real environment (not unit tests).
  *
  * Usage:
@@ -71,7 +71,7 @@ function main() {
     process.exit(1);
   }
 
-  console.log('\n🧪 Nocturnal Pipeline Acceptance Test');
+  console.log('\n🧪 PD Pipeline Acceptance Test');
   console.log('═'.repeat(55));
   console.log(`Workspace: ${workspaceDir}`);
   console.log(`Database:  ${dbPath}\n`);

package/plugin/dist/core/principle-tree-ledger-adapter.d.ts

@@ -1,32 +0,0 @@
-import type { LedgerAdapter, LedgerPrincipleEntry } from '@principles/core/runtime-v2';
-/**
- * PrincipleTreeLedgerAdapter — bridges 11-field LedgerPrincipleEntry to 18+ field LedgerPrinciple.
- *
- * This adapter maintains an in-memory idempotency map. Create once and reuse
- * across calls within the same process lifetime. Do not create a new instance
- * per intake call.
- */
-export declare class PrincipleTreeLedgerAdapter implements LedgerAdapter {
-    #private;
-    constructor(opts: {
-        stateDir: string;
-    });
-    /**
-     * Write a probation entry to the ledger.
-     *
-     * Idempotency: if the same candidateId was already written, returns the
-     * existing entry without writing again.
-     *
-     * @throws CandidateIntakeError with code LEDGER_WRITE_FAILED on write failure.
-     */
-    writeProbationEntry(entry: LedgerPrincipleEntry): LedgerPrincipleEntry;
-    /**
-     * Check if a ledger entry already exists for a given candidate.
-     *
-     * Queries both the in-memory Map (fast path for same-process repeat calls)
-     * and the ledger file (for cross-process idempotency across CLI invocations).
-     *
-     * @returns The existing LedgerPrincipleEntry if found, null otherwise.
-     */
-    existsForCandidate(candidateId: string): LedgerPrincipleEntry | null;
-}