create-principles-disciple 1.147.1 → 1.147.3

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/dist/installer.js

@@ -133,9 +133,6 @@ function installsOpenClaw(host) {
 function installsWorkbuddy(host) {
     return host === 'workbuddy' || host === 'all';
 }
-function installedPluginDir() {
-    return getInstalledPluginDir();
-}
 function pluginInstallDirs() {
     return installsOpenClaw(activeHostTarget)
         ? [getInstalledPluginDir(), getPluginExtDir()]
@@ -1909,77 +1906,13 @@ function syncPdCli(pluginDir) {
     if (existsSync(bundledNodeModules)) {
         cpSync(bundledNodeModules, path.join(installedPdCliDir, 'node_modules'), { recursive: true });
     }
-    // Create node_modules/@principles/core symlink so pd-cli can resolve
-    // its @principles/core dependency (rewritten to "file:../core" by bundle-plugin.mjs).
-    // Without this, `node dist/index.js --version` fails because static imports
-    // from @principles/core/runtime-v2 cannot be resolved.
-    const coreLinkDir = path.join(installedPdCliDir, 'node_modules', '@principles');
-    const coreLinkTarget = path.join(getPdRuntimeDir(), 'core');
-    mkdirSync(coreLinkDir, { recursive: true });
-    const coreLinkPath = path.join(coreLinkDir, 'core');
-    if (!existsSync(coreLinkPath)) {
-        if (isWindows()) {
-            // On Windows, use a junction (directory symlink) which doesn't require elevated privileges
-            symlinkSync(coreLinkTarget, coreLinkPath, 'junction');
-        }
-        else {
-            // On Unix, use a relative symlink for portability
-            symlinkSync('../../../core', coreLinkPath, 'dir');
-        }
-    }
-    // Create node_modules/@principles/host-runtime symlink so pd-cli can resolve
-    // its @principles/host-runtime dependency (rewritten to "file:../host-runtime"
-    // by bundle-plugin.mjs). Without this, `pd --version` crashes with
-    // ERR_MODULE_NOT_FOUND because pd-cli statically imports createProductionHostRuntime.
-    // host-runtime's own better-sqlite3 / js-yaml / @principles/core dependencies
-    // resolve through the plugin's <ext>/node_modules/ (shared via Node's upward
-    // module resolution), so no separate npm install is needed.
-    const hostRuntimeLinkTarget = path.join(getPdRuntimeDir(), 'host-runtime');
-    const hostRuntimeLinkPath = path.join(coreLinkDir, 'host-runtime');
-    if (!existsSync(hostRuntimeLinkPath)) {
-        if (isWindows()) {
-            symlinkSync(hostRuntimeLinkTarget, hostRuntimeLinkPath, 'junction');
-        }
-        else {
-            symlinkSync('../../../host-runtime', hostRuntimeLinkPath, 'dir');
-        }
-    }
-    // Create node_modules/@principles/codex-adapter symlink so pd-cli can resolve
-    // its @principles/codex-adapter dependency (rewritten to
-    // "file:../codex-adapter" by bundle-plugin.mjs). Without this, `pd codex
-    // worker` crashes with ERR_MODULE_NOT_FOUND (PRI-624).
-    const codexAdapterLinkTarget = path.join(getPdRuntimeDir(), 'codex-adapter');
-    const codexAdapterLinkPath = path.join(coreLinkDir, 'codex-adapter');
-    if (!existsSync(codexAdapterLinkPath)) {
-        if (isWindows()) {
-            symlinkSync(codexAdapterLinkTarget, codexAdapterLinkPath, 'junction');
-        }
-        else {
-            symlinkSync('../../../codex-adapter', codexAdapterLinkPath, 'dir');
-        }
-    }
-    // Create node_modules/principles-disciple symlink so pd-cli can resolve
-    // its principles-disciple dependency (the plugin package, rewritten to
-    // "file:../plugin" by bundle-plugin.mjs). The plugin is installed at the
-    // extension dir root (getPluginExtDir()), so the symlink target is the
-    // ext dir itself — Node resolves `import 'principles-disciple'` via the
-    // plugin's package.json exports field.
-    // Without this, `pd runtime init` crashes with ERR_MODULE_NOT_FOUND
-    // because runtime-init.ts statically imports initTrajectorySchema.
-    const pdLinkDir = path.join(installedPdCliDir, 'node_modules');
-    const pdLinkTarget = installedPluginDir();
-    mkdirSync(pdLinkDir, { recursive: true });
-    const pdLinkPath = path.join(pdLinkDir, 'principles-disciple');
-    if (!existsSync(pdLinkPath)) {
-        if (isWindows()) {
-            symlinkSync(pdLinkTarget, pdLinkPath, 'junction');
-        }
-        else {
-            // Relative from <ext>/pd-cli/node_modules/ to <ext>/: go up twice
-            // (node_modules → pd-cli → ext)
-            symlinkSync('../../', pdLinkPath, 'dir');
-        }
-    }
+    // G3 §10.5: the pd-cli sibling links (core / host-runtime / codex-adapter /
+    // workbuddy-adapter / install-layout / principles-disciple) are NO LONGER
+    // hand-rolled here. install() materializes them via
+    // ensurePdCliResolution() AFTER installPdCliDependencies(), so a physical
+    // copy produced by the dependency stage can never be silently kept — this
+    // block used to short-circuit on existsSync() and leave npm-materialized
+    // copies in place.
     tryUpgradePdCliFromNpm(installedPdCliDir);
     const installedBinDir = getInstalledBinDir();
     mkdirSync(installedBinDir, { recursive: true });
@@ -2157,29 +2090,11 @@ function installConsole(consoleDir) {
     }
     rmSync(consoleDest, { recursive: true, force: true });
     cpSync(consoleSrc, consoleDest, { recursive: true });
-    const pluginLinkPath = path.join(consoleDest, 'node_modules', 'principles-disciple');
-    mkdirSync(path.dirname(pluginLinkPath), { recursive: true });
-    if (!existsSync(pluginLinkPath)) {
-        if (isWindows()) {
-            symlinkSync(installedPluginDir(), pluginLinkPath, 'junction');
-        }
-        else {
-            symlinkSync(path.relative(path.dirname(pluginLinkPath), installedPluginDir()), pluginLinkPath, 'dir');
-        }
-    }
-    // PRI-672: console resolves its create-principles-disciple dependency (the
-    // ReleaseManager authority module, rewritten to file:../release-manager by
-    // bundle-plugin.mjs) through this link into ~/.pd/runtime.
-    const releaseManagerLinkPath = path.join(consoleDest, 'node_modules', 'create-principles-disciple');
-    if (!existsSync(releaseManagerLinkPath)) {
-        mkdirSync(path.dirname(releaseManagerLinkPath), { recursive: true });
-        if (isWindows()) {
-            symlinkSync(getInstalledReleaseManagerDir(), releaseManagerLinkPath, 'junction');
-        }
-        else {
-            symlinkSync(path.relative(path.dirname(releaseManagerLinkPath), getInstalledReleaseManagerDir()), releaseManagerLinkPath, 'dir');
-        }
-    }
+    // G3 §10.5: the console's sibling links (core / host-runtime / install-layout
+    // / principles-disciple / create-principles-disciple) are materialized by
+    // ensureConsoleResolution() AFTER installConsoleDependencies() — see
+    // ensurePdCliResolution() for why the old existsSync() short-circuit was
+    // removed instead of kept.
 }
 function getInstalledCoreDir() {
     return path.join(getPdRuntimeDir(), 'core');
@@ -2312,6 +2227,11 @@ function ensureComponentFileDependencyLinks(componentDir, componentLabel) {
         if (!existsSync(siblingDir)) {
             throw new Error(`${componentLabel} depends on ${ref} but the sibling runtime component is missing: ${siblingDir}`);
         }
+        // rc-1: the dependency NAME is manifest input too — it becomes a path
+        // segment under node_modules, so a crafted name must not escape it.
+        if (!/^(@[A-Za-z0-9._-]+\/)?[A-Za-z0-9._-]+$/.test(name)) {
+            throw new Error(`Installed ${componentLabel} declares an unsupported dependency name "${name}".`);
+        }
         const linkPath = path.join(componentDir, 'node_modules', name);
         let stat;
         try {
@@ -2341,6 +2261,30 @@ function ensureComponentFileDependencyLinks(componentDir, componentLabel) {
         }
     }
 }
+/**
+ * G3 §10.5: materialize the INSTALLED pd-cli's `file:../` sibling links
+ * (core / host-runtime / codex-adapter / workbuddy-adapter / install-layout /
+ * principles-disciple) through the shared helper. Replaces the hand-rolled
+ * per-dependency blocks that used to live in syncPdCli(): those short-circuited
+ * on existsSync(), so an npm-materialized physical copy silently won over the
+ * intended runtime sibling.
+ *
+ * Ordering contract: MUST run after installPdCliDependencies() (the dependency
+ * stage is what can (re)materialize node_modules) AND after every sibling is
+ * deployed. A missing sibling fails the install loud (the helper).
+ */
+export function ensurePdCliResolution() {
+    ensureComponentFileDependencyLinks(getInstalledPdCliDir(), '@principles/pd-cli');
+}
+/**
+ * G3 §10.5: same contract for the INSTALLED pd-console (core / host-runtime /
+ * install-layout / principles-disciple / create-principles-disciple). Runs
+ * after installConsoleDependencies() so npm-materialized copies are corrected
+ * instead of silently kept.
+ */
+export function ensureConsoleResolution() {
+    ensureComponentFileDependencyLinks(getInstalledConsoleDir(), '@principles/pd-console');
+}
 /**
  * PRI-711: materialize node_modules links for the INSTALLED codex-adapter so
  * its declared `file:../<component>` dependencies resolve under ESM realpath
@@ -3805,6 +3749,10 @@ transaction) {
         if (pdCliSync.globalShim !== null)
             globalShimRecord = pdCliSync.globalShim;
         await installPdCliDependencies();
+        // G3 §10.5: materialize the sibling links AFTER the dependency stage — every
+        // sibling component is already deployed at this point, and a physical copy
+        // the dependency stage produced is now corrected rather than silently kept.
+        ensurePdCliResolution();
         stepIndex++;
         if (spinner)
             updateProgress(spinner, stepIndex, 'Preparing core library for pd-cli...');
@@ -3836,6 +3784,10 @@ transaction) {
         if (spinner)
             updateProgress(spinner, stepIndex, 'Validating bundled console dependencies...');
         await installConsoleDependencies();
+        // G3 §10.5: same ordering contract as pd-cli — links after the dependency
+        // stage, with every console sibling (plugin / release-manager / core /
+        // host-runtime / install-layout) already deployed.
+        ensureConsoleResolution();
         stepIndex++;
         // PRI-912 (SPEC-P1′-A): dedup the plugin's bundled @principles/core copy
         // into a canonical junction only after EVERY component is deployed, so a

package/release-manager/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-principles-disciple",
-  "version": "1.147.1",
+  "version": "1.147.3",
   "description": "Interactive CLI installer for Principles Disciple OpenClaw plugin",
   "type": "module",
   "bin": {
@@ -47,6 +47,7 @@
     "prepublishOnly": "npm run build:deps && npm run build && npm run bundle",
     "test": "vitest run",
     "test:fast": "vitest run --exclude tests/smoke-packaged-install.test.ts --exclude tests/release-asset-smoke.test.ts --exclude tests/release-upgrade-gate.test.ts --exclude tests/release-junction-lifecycle.test.ts",
+    "typecheck:tests": "tsc -p tsconfig.tests.json",
     "test:smoke:packaged": "vitest run tests/smoke-packaged-install.test.ts",
     "test:smoke:release-asset": "vitest run tests/release-asset-smoke.test.ts"
   },

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",