create-principles-disciple 1.147.1 → 1.147.2

package/plugin/dist/hooks/after-tool-call-helpers.d.ts

@@ -4,7 +4,7 @@
  * Extracted functions from handleAfterToolCall that implement
  * individual pipeline stages. Each function has a focused responsibility.
  *
- * Pipeline order: classify → record → triage → gate → emit
+ * Pipeline order: classify → record → friction tracking → hygiene
  *
  * ERR checklist:
  * - ERR-001: No `as` casts on untrusted runtime values.
@@ -16,7 +16,7 @@ import { normalizeProfile } from '../core/profile.js';
 import { type SessionState } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import type { PluginHookAfterToolCallEvent } from '../openclaw-sdk.js';
-import type { ToolCallOutcome, ToolCallObservation, PainAdmissionDecision } from './after-tool-call-types.js';
+import type { ToolCallOutcome, ToolCallObservation } from './after-tool-call-types.js';
 /**
  * Extract a preview string from tool call result for diagnostic evidence.
  * Pure function — no I/O, no side effects. ERR-001 / ERR-014 compliant.
@@ -59,36 +59,3 @@ export declare function handleFrictionTrackingForSuccess(sessionId: string, even
  * Record hygiene tracking for memory/plan persistence actions on success.
  */
 export declare function recordHygieneTracking(event: PluginHookAfterToolCallEvent, observation: ToolCallObservation, wctx: WorkspaceContext): void;
-/**
- * Evaluate whether a tool failure should trigger pain diagnosis.
- *
- * PRI-363: Single-gate architecture — only TriggerController decides.
- *
- * Combines:
- * 1. Write-tool check — only write tools on failures enter this path
- * 2. PEAT-B1 triage — evidence triage (always enabled now)
- * 3. PEAT-B2 trigger controller — single source of truth for task creation
- * 4. Cooldown tracking — plugin layer owns this state
- *
- * Returns a structured decision with reason and stage.
- */
-export declare function evaluatePainAdmissionForToolCall(event: PluginHookAfterToolCallEvent, observation: ToolCallObservation, outcome: ToolCallOutcome, latestFailureState: SessionState | undefined, sessionState: SessionState | undefined, sessionId: string, workspaceDir: string, _config: {
-    get: (key: string) => unknown;
-}): PainAdmissionDecision;
-/**
- * Emit pain signal after admission.
- *
- * Records to trajectory, event log, principle value tracker,
- * and emits the pain_detected event.
- *
- * Only called when the admission decision is 'admitted'.
- */
-export declare function emitPainIfAdmitted(wctx: WorkspaceContext, event: PluginHookAfterToolCallEvent, observation: ToolCallObservation, outcome: ToolCallOutcome, admission: PainAdmissionDecision, sessionId: string, agentId: string | undefined, workspaceDir: string, emitPainDetectedEvent: (wctx: WorkspaceContext, event: import('../core/evolution-types.js').EvolutionLoopEvent, options?: {
-    recordObservability?: boolean;
-}) => Promise<void>): void;
-export { buildTrajectoryEvidence } from './trajectory-evidence.js';
-/**
- * Reset trigger cooldown state (for tests).
- * PRI-454: Delegates to shared cooldown Map reset.
- */
-export declare function resetTriggerCooldownForTest(): void;

package/plugin/dist/hooks/after-tool-call-types.d.ts

@@ -10,7 +10,6 @@
  * - ERR-002: Every decision/result carries structured reason + nextAction.
  * - EP-01: These types document boundaries, not runtime validation targets.
  */
-import type { SessionState } from '../core/session-tracker.js';
 /**
  * Result of classifying what happened in a tool call event.
  *
@@ -27,7 +26,7 @@ export interface ToolCallOutcome {
 /**
  * Normalized observation built from the tool call event and context.
  *
- * Used by friction tracking, event recording, and pain admission.
+ * Used by friction tracking, event log recording, and trajectory recording.
  * Constructed after classification, before any I/O.
  */
 export interface ToolCallObservation {
@@ -56,31 +55,3 @@ export interface ToolCallObservation {
     /** Trace ID for this observation chain */
     readonly traceId: string;
 }
-/**
- * Result of evaluating whether a tool failure should trigger pain diagnosis.
- *
- * Encapsulates the single-gate trigger controller decision.
- */
-export interface PainAdmissionDecision {
-    /** Whether the tool failure should proceed to pain emission */
-    readonly admitted: boolean;
-    /** The admission stage that made the decision */
-    readonly stage: 'not_applicable' | 'trigger_admitted' | 'trigger_rejected';
-    /** Human-readable reason for the decision */
-    readonly reason: string;
-    /** Detail about the decision */
-    readonly detail: string;
-}
-/**
- * Result of friction tracking for a tool call.
- */
-export interface FrictionUpdateResult {
-    /** GFI before this update */
-    readonly gfiBefore: number;
-    /** GFI after this update */
-    readonly gfiAfter: number;
-    /** Updated session state (if failure) */
-    readonly sessionState: SessionState | undefined;
-    /** The error hash used for tracking */
-    readonly errorHash: string;
-}

package/plugin/dist/hooks/pain.d.ts

@@ -1,32 +1,23 @@
 /**
  * Pain Hook — PRI-326 decomposed
  *
- * After-tool-call hook that captures tool failures and emits pain signals.
+ * After-tool-call hook. Phase A retired every automatic Pain admission that
+ * was triggered by a technical tool failure: failures are still classified,
+ * recorded in the trajectory, and tracked for GFI health, but they never
+ * create a Pain Event or a Diagnostician task by themselves.
  *
- * Pipeline stages (delegated to after-tool-call-helpers):
+ * Remaining 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. evaluatePainAdmission      — triage + gate evaluation
- *   5. 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).
+ * has a different control flow (early return, Owner-explicit admission).
  */
 import { WorkspaceContext } from '../core/workspace-context.js';
 import type { EvolutionLoopEvent } from '../core/evolution-types.js';
 import type { PluginHookAfterToolCallEvent, PluginHookToolContext, OpenClawPluginApi } from '../openclaw-sdk.js';
 import type { ProductionPainEnrichment } from '@principles/host-runtime';
-import type { HostEventResult } from '@principles/core/host';
-import { buildTrajectoryEvidence } from './trajectory-evidence.js';
-export { buildTrajectoryEvidence };
-/**
- * Host-owned best-effort continuation after durable shared persistence.
- * The hook may return once SQLite commits, while rejections remain observable
- * and tests/shutdown code can explicitly drain scheduled work.
- */
-export declare function schedulePainContinuation(workspaceDir: string, continuation: Promise<void>): void;
-export declare function drainPainContinuationsForTest(): Promise<void>;
 export declare function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent, options?: {
     recordObservability?: boolean;
 }): Promise<void>;
@@ -50,7 +41,3 @@ export declare function prepareOrdinaryAfterToolCallForSharedRuntime(event: Plug
     workspaceDir: string;
     pluginConfig?: Record<string, unknown>;
 }): ProductionPainEnrichment;
-/** Restore OpenClaw-owned pain UX/diagnosis after the shared atomic evidence write. */
-export declare function handleSharedPainEvidenceResult(event: PluginHookAfterToolCallEvent, ctx: PluginHookToolContext & {
-    workspaceDir: string;
-}, result: HostEventResult): void;

package/plugin/dist/hooks/trajectory-evidence.d.ts

@@ -7,10 +7,9 @@
  * Pure data extraction — reads from trajectory DB, sanitizes, returns evidence entries.
  *
  * PRI-642 Scope A adds the typed acquisition API `acquireTrajectoryEvidence`
- * (discriminated available/unavailable, SPEC §7.2). The legacy array API
- * `buildTrajectoryEvidence` remains as a compatibility wrapper for automatic
- * emitters and MUST keep its exact sentinel shapes until Scope B migrates
- * those consumers (frozen decision #3).
+ * (discriminated available/unavailable, SPEC §7.2). Phase A retired the last
+ * automatic emitter, so the legacy untyped array wrapper was removed: the
+ * Owner manual pain path is the only consumer and it uses the typed API.
  */
 import type { PainEvidenceEntry } from '@principles/core/runtime-v2';
 import type { WorkspaceContext } from '../core/workspace-context.js';
@@ -34,9 +33,3 @@ export type TrajectoryEvidenceAcquisition = {
  * as available evidence.
  */
 export declare function acquireTrajectoryEvidence(wctx: WorkspaceContext, sessionId: string): TrajectoryEvidenceAcquisition;
-/**
- * Legacy array API (compatibility wrapper, PRI-642 frozen decision #3).
- * Automatic emitters still consume this shape; Scope B migrates them to the
- * typed API one family at a time before this wrapper may be removed.
- */
-export declare function buildTrajectoryEvidence(wctx: WorkspaceContext, sessionId: string): PainEvidenceEntry[];

package/plugin/dist/hooks/triage-adapter.d.ts

@@ -14,6 +14,10 @@
  * (TriggerController) is the only admission authority.
  * Core only sees SourceKind and TriageResult.
  *
+ * Phase A: the context-driven upgrade flags (unsafe-high-confidence,
+ * risky-high-score, repeated-failure) are retired. A descriptor decision is
+ * final; technical failures and RuleHost blocks never self-admit as Pain.
+ *
  * ERR checklist:
  * - ERR-001: Source kind derived from runtime values with guards, not `as` casts.
  * - ERR-002: Every triage result carries reason + nextAction.
@@ -30,30 +34,13 @@ import { type TriageResult, type SourceKind } from '@principles/core/runtime-v2'
  */
 export { resolveSourceKind, buildToolFailureObservation, type RawObservation } from './raw-observation-adapter.js';
 /**
- * Evaluate evidence triage for a given source kind and context.
+ * Evaluate evidence triage for a given source kind and score.
  *
  * This is the main entry point for hooks. It calls the pure triage policy
- * from principles-core and returns the result.
+ * from principles-core and returns the descriptor decision unchanged.
  *
  * PRI-752 reality check: the painEvidenceAdmission flag is NOT consulted by
  * any caller on this path — Gate B admission is unconditional. This doc block
  * previously described a flag check / fallback that does not exist as code.
  */
-export declare function evaluateEvidenceTriage(sourceKind: SourceKind, score: number, options?: {
-    isUnsafeHighConfidence?: boolean;
-    provenance?: 'host_context_bound' | 'owner_reported_no_host_trace' | 'automatic_hook';
-    consecutiveErrors?: number;
-    isRisky?: boolean;
-}): TriageResult;
-/**
- * Determine if a gate-blocked action is a high-confidence unsafe action.
- *
- * This is a heuristic that the plugin adapter owns. Core does not know about
- * these heuristics — it only receives the boolean flag.
- *
- * Criteria for high-confidence unsafe:
- * - Score >= 70 (high severity)
- * - Tool is in the risky write set
- * - Action would be irreversible (file deletion, force push, etc.)
- */
-export declare function isHighConfidenceUnsafeAction(score: number, isRisky: boolean): boolean;
+export declare function evaluateEvidenceTriage(sourceKind: SourceKind, score: number): TriageResult;

package/plugin/dist/host-runtime/openclaw-host-runtime.d.ts

@@ -7,7 +7,6 @@ export interface OpenClawHostRuntimeOptions {
     ruleInputEnrichmentProvider?(event: PluginHookBeforeToolCallEvent, context: PluginHookToolContext, request: ProductionRuleContextRequest): unknown | Promise<unknown>;
     onBeforeToolResult?(event: PluginHookBeforeToolCallEvent, context: PluginHookToolContext, result: HostEventResult): PluginHookBeforeToolCallResult | void;
     painEnrichmentProvider?(event: PluginHookAfterToolCallEvent, context: PluginHookToolContext): ProductionPainEnrichment | Promise<ProductionPainEnrichment>;
-    onAfterToolResult?(event: PluginHookAfterToolCallEvent, context: PluginHookToolContext, result: HostEventResult): void | Promise<void>;
 }
 export interface OpenClawHostRuntime {
     readonly runtime: HostRuntime;

package/plugin/dist/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Principles Disciple is an AI Agent Governance System. Stop correcting the same AI behavior across sessions. Turn repeated Agent corrections into Owner-approved, observable, reversible behavior principles.",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "activation": {
     "onStartup": true,
     "onCapabilities": [

package/plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Principles Disciple is an AI Agent Governance System. Stop correcting the same AI behavior across sessions. Turn repeated Agent corrections into Owner-approved, observable, reversible behavior principles.",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "activation": {
     "onStartup": true,
     "onCapabilities": [

package/plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "Principles Disciple is an AI Agent Governance System. Stop correcting the same AI behavior across sessions. Turn repeated Agent corrections into Owner-approved, observable, reversible behavior principles.",
   "type": "module",
   "main": "./dist/index.js",

package/release-manager/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-principles-disciple",
-  "version": "1.147.1",
+  "version": "1.147.2",
   "description": "Interactive CLI installer for Principles Disciple OpenClaw plugin",
   "type": "module",
   "bin": {

package/workbuddy-adapter/dist/pd-hook.js

@@ -400,32 +400,6 @@ export async function processWorkbuddyHookInvocation(rawStdin, channelEventName,
                 currentToolCallId: event.context.toolCallId ?? '',
                 toolSemantics: WORKBUDDY_TOOL_SEMANTICS,
             }),
-            // Remediation R2 (candidate-level admission): the diagnostician's
-            // candidates are admitted ONLY with input evidence (needs_evidence
-            // otherwise), and Codex-style transcript promotion does not exist on
-            // this host. OpenClaw-parity: the HOOK supplies the evidence — a
-            // sourceRef to the durable raw event line (idempotent replay source,
-            // SPEC §13.7) plus a bounded failure note. No raw tool output is copied
-            // (ADR-0027 hook-log content rule).
-            painEnrichmentProvider: (hostEvent) => {
-                if (hostEvent.kind !== 'after_tool_call')
-                    return {};
-                const toolName = hostEvent.context.toolName ?? 'unknown-tool';
-                const output = hostEvent.context.toolOutput;
-                const detail = typeof output === 'object' && output !== null && !Array.isArray(output)
-                    ? Object.hasOwn(output, 'tool_error_code')
-                        ? `tool_error_code=${String(output.tool_error_code)}`
-                        : Object.hasOwn(output, 'exitCode')
-                            ? `exitCode=${String(output.exitCode)}`
-                            : 'failure'
-                    : 'failure';
-                return {
-                    evidence: [{
-                            sourceRef: `workbuddy-pd-hook-event-log:${hostEvent.context.sessionId}`,
-                            note: `${toolName} failed (${detail}); raw payload in the durable workbuddy hook event log for this session`,
-                        }],
-                };
-            },
         }).dispatch(event);
         const evaluationDiagnostics = recordRuleHostEvaluations(stateDir, event.context.sessionId, result.metadata?.evaluations);
         // Encode BEFORE recording an attributed deny: a runtime_verified

package/workbuddy-adapter/dist/worker/workspace-worker.d.ts

@@ -1,13 +1,7 @@
-import { type AdmitBareHostPainsResult, type InternalizationConsumerCycleOutcome, type ConsumerCycleLogger, type ReconcileGovernanceContinuationResult, type SignalLlmClassifier, type Stage2CorrectionCycleReport } from '@principles/host-runtime';
+import { type InternalizationConsumerCycleOutcome, type ConsumerCycleLogger, type ReconcileGovernanceContinuationResult, type SignalLlmClassifier, type Stage2CorrectionCycleReport } from '@principles/host-runtime';
 export type WorkbuddyWorkerMode = 'ready' | 'manual_action_required' | 'paused' | 'degraded';
 export interface WorkbuddyWorkerCycleStepReport {
     readonly reconcile: ReconcileGovernanceContinuationResult;
-    /**
-     * Bare-pain admission sweep (review R2/P1): the WorkBuddy hook writes bare
-     * failure pains with no inline admission, so the worker admits them into the
-     * shared governance queue before the diagnostician step.
-     */
-    readonly admission: AdmitBareHostPainsResult;
     /** At most ONE diagnostician execution per cycle (bounded work). */
     readonly diagnostician: {
         readonly taskId: string;

package/workbuddy-adapter/dist/worker/workspace-worker.js

@@ -7,10 +7,7 @@
  * the WorkBuddy MVP excludes transcript ingestion (SPEC §1 Excluded; the
  * hook itself is the only evidence producer):
  *
- *   1. run the idempotent reconciliation pass (shared host-runtime authority),
- *      then admit the hook's BARE failure pains into the same governance
- *      queue (review R2/P1 — no inline admission exists on this host; the
- *      sweep reuses the ONE admission table and the crash-safe task ensure)
+ *   1. run the idempotent reconciliation pass (shared host-runtime authority)
  *   2. lease + run one Diagnostician execution, then ONE bounded downstream
  *      consumer cycle through the SHARED host-neutral executor
  *      (internalization_auto_consumer = workspace execution authority)
@@ -33,7 +30,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { computeFeatureFlagsFromConfig, createRuntimeStateHandle, createPainSignalBridge, isRetryWaitBackoffElapsed, PrincipleTreeLedgerAdapter, resolveDiagnosticianCapability, } from '@principles/core/runtime-v2';
-import { admitBareHostPains, loadPdConfigForPlugin, loadFeatureFlagFromConfig, reconcileGovernanceContinuation, runInternalizationConsumerCycle, runStage2CorrectionCycle, createSignalClassifierForWorkspace, saveHostToolDeclaration, } from '@principles/host-runtime';
+import { loadPdConfigForPlugin, loadFeatureFlagFromConfig, reconcileGovernanceContinuation, runInternalizationConsumerCycle, runStage2CorrectionCycle, createSignalClassifierForWorkspace, saveHostToolDeclaration, } from '@principles/host-runtime';
 import { WORKBUDDY_TOOL_SEMANTICS, WORKBUDDY_TOOL_SEMANTIC_MAPPINGS } from '../tool-semantics.js';
 const WORKER_OWNER = 'companion-worker';
 const DEFAULT_DIAG_CANDIDATE_LIMIT = 5;
@@ -103,12 +100,6 @@ export async function runWorkbuddyWorkspaceWorkerCycle(options) {
     const diagnosticianDisabled = !capability.available;
     // Step 2 — Idempotent reconciliation (always runs; creates no LLM work).
     const reconcile = await reconcileGovernanceContinuation({ workspaceDir, conversationIngestionEnabled: false });
-    // Step 2b — Bare-pain admission (review R2/P1): the hook leaves bare
-    // workbuddy failure pains that no inline admission exists for. Without this
-    // sweep the evidence rows never reach the diagnostician queue. Runs AFTER
-    // reconcile (which continues already-admitted markers) and ensures tasks
-    // through the same crash-safe seam; bounded and idempotent.
-    const admission = await admitBareHostPains({ workspaceDir, hostKind: 'workbuddy' });
     // Steps 3–5 — execution authority: internalization_auto_consumer.
     let diagnostician = null;
     if (diagnosticianDisabled) {
@@ -125,7 +116,7 @@ export async function runWorkbuddyWorkspaceWorkerCycle(options) {
             mode: 'paused',
             reason: 'internalization_auto_consumer_disabled',
             nextAction: 'Automatic internalization execution is paused for this governance workspace; manual commands remain available: pd diagnose, pd runtime internalization run-once.',
-            report: { reconcile, admission, diagnostician: null, downstream: null },
+            report: { reconcile, diagnostician: null, downstream: null },
         };
     }
     else {
@@ -174,7 +165,7 @@ export async function runWorkbuddyWorkspaceWorkerCycle(options) {
                 mode: 'degraded',
                 reason: `diagnostician_execution_failed:${detail}`,
                 nextAction: 'Inspect the governance workspace runtime profile and provider configuration; the task keeps its pending/retry state and no evidence was mutated.',
-                report: { reconcile, admission, diagnostician: null, downstream: null },
+                report: { reconcile, diagnostician: null, downstream: null },
             };
         }
     }
@@ -194,7 +185,7 @@ export async function runWorkbuddyWorkspaceWorkerCycle(options) {
             mode: 'degraded',
             reason: `host_tool_declaration_persist_failed:${declared.reason}`,
             nextAction: 'Repair WorkBuddy host declaration persistence (.pd/host-tool-semantics/workbuddy.json) before running the downstream internalization cycle; the worker retries automatically on the next cycle.',
-            report: { reconcile, admission, diagnostician, downstream: null },
+            report: { reconcile, diagnostician, downstream: null },
         };
     }
     const downstream = await runInternalizationConsumerCycle(workspaceDir, {
@@ -226,16 +217,15 @@ export async function runWorkbuddyWorkspaceWorkerCycle(options) {
         onEvent: emitEvent,
     });
     const degradedReason = !reconcile.ok ? `reconcile:${reconcile.reason ?? 'failed'}`
-        : !admission.ok ? `admission:${admission.reason ?? 'failed'}`
-            : diagnostician?.status === 'failed' && diagnostician.errorCategory !== 'lease_conflict' ? `diagnostician_failed:${diagnostician.message ?? 'max_attempts_exceeded'}`
-                : diagnostician?.status === 'degraded' ? `diagnostician_degraded:${diagnostician.message ?? 'unknown'}`
-                    : downstream.skipReason === 'runtime_config_error' || downstream.skipReason === 'cycle_error' || downstream.skipReason === 'config_malformed' ? `downstream:${downstream.skipReason}`
-                        : !stage2.ok ? `stage2:${stage2.reason ?? 'failed'}`
-                            : undefined;
+        : diagnostician?.status === 'failed' && diagnostician.errorCategory !== 'lease_conflict' ? `diagnostician_failed:${diagnostician.message ?? 'max_attempts_exceeded'}`
+            : diagnostician?.status === 'degraded' ? `diagnostician_degraded:${diagnostician.message ?? 'unknown'}`
+                : downstream.skipReason === 'runtime_config_error' || downstream.skipReason === 'cycle_error' || downstream.skipReason === 'config_malformed' ? `downstream:${downstream.skipReason}`
+                    : !stage2.ok ? `stage2:${stage2.reason ?? 'failed'}`
+                        : undefined;
     return {
         ...base,
         mode: degradedReason !== undefined ? 'degraded' : 'ready',
         ...(degradedReason !== undefined ? { reason: degradedReason, nextAction: 'Inspect the governance workspace .pd/config.yaml runtime profile and the per-step report above; the worker retries automatically on the next cycle.' } : {}),
-        report: { reconcile, admission, diagnostician, downstream, stage2 },
+        report: { reconcile, diagnostician, downstream, stage2 },
     };
 }

package/workbuddy-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/workbuddy-adapter",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "WorkBuddy host adapter for Principles Disciple — implements the HostAdapter interface for WorkBuddy's Git Bash command-hook model (ADR-0020 third host, SPEC workbuddy-host-adapter v0.3.0).",
   "type": "module",
   "main": "./dist/index.js",