create-principles-disciple 1.147.0 → 1.147.2

package/host-runtime/dist/production-pain-evidence.js

@@ -2,13 +2,8 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
-import { applyTrajectorySchemaBase, buildToolFailureObservation, evaluateTriage, evaluateTriggerController, resolveSourceKind, sanitizeToolParams, sanitizeValue, } from '@principles/core/runtime-v2';
-const WRITE_TOOLS = new Set(['write', 'edit', 'apply_patch', 'write_file', 'edit_file', 'replace']);
-/** Shared with the governance admission path so both gate tool failures identically. */
-export const PRODUCTION_WRITE_TOOLS = WRITE_TOOLS;
+import { applyTrajectorySchemaBase, sanitizeToolParams, sanitizeValue, } from '@principles/core/runtime-v2';
 const MAX_PREVIEW = 500;
-const PAIN_COOLDOWN_WINDOW_MS = 15 * 60 * 1000;
-const cooldowns = new Map();
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -33,7 +28,7 @@ function field(value, key) {
  * legitimate completion of the tool contract and stay success (SPEC §5.1).
  */
 function normalizeOutcome(event) {
-    const context = 'context' in event ? event.context : event;
+    const { context } = event;
     const envelope = context.toolOutput;
     const result = field(envelope, 'result') ?? envelope;
     const errorValue = field(envelope, 'error') ?? field(result, 'error');
@@ -79,46 +74,15 @@ function normalizeOutcome(event) {
         result,
     };
 }
-function isEvidence(value) {
-    return Array.isArray(value) && value.length <= 8 && value.every((entry) => isRecord(entry) && typeof field(entry, 'sourceRef') === 'string' && String(field(entry, 'sourceRef')).trim().length > 0
-        && String(field(entry, 'sourceRef')).length <= 300 && typeof field(entry, 'note') === 'string' && String(field(entry, 'note')).length <= 200);
-}
 function parseEnrichment(value) {
     if (value === undefined)
         return {};
     if (!isRecord(value))
         return null;
-    const painScore = field(value, 'painScore');
-    const isRisky = field(value, 'isRisky');
-    const consecutiveErrors = field(value, 'consecutiveErrors');
-    const evidence = field(value, 'evidence');
     const eventId = field(value, 'eventId');
-    const relativePath = field(value, 'relativePath');
-    const agentId = field(value, 'agentId');
-    const errorHash = field(value, 'errorHash');
-    if (painScore !== undefined && (typeof painScore !== 'number' || !Number.isFinite(painScore) || painScore < 0 || painScore > 100))
-        return null;
-    if (isRisky !== undefined && typeof isRisky !== 'boolean')
+    if (eventId !== undefined && (typeof eventId !== 'string' || eventId.trim().length === 0 || eventId.length > 500))
         return null;
-    if (consecutiveErrors !== undefined && (typeof consecutiveErrors !== 'number' || !Number.isInteger(consecutiveErrors) || consecutiveErrors < 0))
-        return null;
-    for (const key of ['eventId', 'relativePath', 'agentId', 'errorHash']) {
-        const candidate = field(value, key);
-        if (candidate !== undefined && (typeof candidate !== 'string' || candidate.trim().length === 0 || candidate.length > 500))
-            return null;
-    }
-    if (evidence !== undefined && !isEvidence(evidence))
-        return null;
-    return {
-        ...(typeof eventId === 'string' ? { eventId } : {}),
-        ...(typeof painScore === 'number' ? { painScore } : {}),
-        ...(typeof isRisky === 'boolean' ? { isRisky } : {}),
-        ...(typeof consecutiveErrors === 'number' ? { consecutiveErrors } : {}),
-        ...(typeof relativePath === 'string' ? { relativePath } : {}),
-        ...(typeof agentId === 'string' ? { agentId } : {}),
-        ...(typeof errorHash === 'string' ? { errorHash } : {}),
-        ...(isEvidence(evidence) ? { evidence } : {}),
-    };
+    return typeof eventId === 'string' ? { eventId } : {};
 }
 function stable(value, seen = new WeakSet()) {
     if (value === null || typeof value !== 'object') {
@@ -165,42 +129,7 @@ function ids(input) {
         failure: outcome.failure,
     });
     const digest = createHash('sha256').update(canonical).digest('hex');
-    return { eventId: `host_${digest}`, painId: `pain_host_${digest}` };
-}
-/**
- * The canonical tool-pain identity derivation, exposed for the governance
- * admission path (Codex Governance Closure SPEC §10): the same normalized
- * fields fed to the live production handler derive the same deterministic
- * `pain_host_<sha256>` id, so live and observation-delivered admissions of one
- * tool call converge on one canonical pain.
- *
- * I1 parity obligation: when the host supplies a call id, BOTH paths must pass
- * the same `toolCallId` (Codex admission candidates carry it from the same
- * `tool_use_id` the live decoder required) — otherwise one real call would
- * derive two canonical pains.
- */
-export function deriveProductionToolPainIdentity(fields) {
-    const outcome = normalizeOutcome(fields);
-    const sanitizedParams = sanitizeToolParams(outcome.params, fields.workspaceDir);
-    const { eventId, painId } = ids({
-        workspaceDir: fields.workspaceDir,
-        sessionId: fields.sessionId,
-        ...(fields.turnId !== undefined ? { turnId: fields.turnId } : {}),
-        ...(fields.toolName !== undefined ? { toolName: fields.toolName } : {}),
-        source: fields.source,
-        ...(fields.canonicalEventId !== undefined ? { canonicalEventId: fields.canonicalEventId } : {}),
-        ...(fields.toolCallId !== undefined ? { toolCallId: fields.toolCallId } : {}),
-        outcome,
-        sanitizedParams,
-    });
-    return {
-        eventId,
-        painId,
-        outcome,
-        sanitizedParams,
-        paramsJson: stable(sanitizedParams),
-        resultPreview: preview({ eventId, result: sanitizeValue(outcome.result, 0, fields.workspaceDir) }),
-    };
+    return { eventId: `host_${digest}` };
 }
 /**
  * The canonical correction-pain identity derivation (SPEC §10/§12): deterministic,
@@ -415,6 +344,13 @@ export function recordVerifiedToolOutcomes(args) {
     return results;
 }
 /**
+ * Shared production tool-call evidence handler.
+ *
+ * Records the real host tool call in `trajectory.db` (tool_calls) and emits the
+ * receipt event. Phase A retired the legacy automatic Pain admission that used
+ * to ride on this path: a technical tool failure is trajectory + health
+ * evidence, never an Owner-pain by itself.
+ *
  * PRI-640: host attribution is supplied by the host adapter that constructs
  * this shared handler (OpenClaw / Codex adapters) — never guessed inside the
  * writer. Omitted -> NULL (unknown).
@@ -445,7 +381,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
         }
         const dbPath = path.join(event.context.workspaceDir, '.state', 'trajectory.db');
         if (!fs.existsSync(dbPath)) {
-            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), 'trajectory_db_not_found'], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'initialize the selected PD workspace before retrying the hook' } };
+            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), 'trajectory_db_not_found'], metadata: { outcome: 'unavailable', duplicate: false, nextAction: 'initialize the selected PD workspace before retrying the hook' } };
         }
         let db;
         try {
@@ -457,7 +393,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
             if (!hasCanonicalSchema(db)) {
                 db.close();
                 db = undefined;
-                return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), 'trajectory_schema_invalid'], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'run the supported PD workspace migration' } };
+                return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), 'trajectory_schema_invalid'], metadata: { outcome: 'unavailable', duplicate: false, nextAction: 'run the supported PD workspace migration' } };
             }
         }
         catch (error) {
@@ -465,7 +401,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
                 db?.close();
             }
             catch { /* best-effort cleanup of an unusable handle */ }
-            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), `trajectory_database_unavailable:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'inspect or repair the selected PD trajectory database' } };
+            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), `trajectory_database_unavailable:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`], metadata: { outcome: 'unavailable', duplicate: false, nextAction: 'inspect or repair the selected PD trajectory database' } };
         }
         const warnings = [];
         let enrichment;
@@ -481,49 +417,12 @@ export function createProductionPainEvidenceHandler(options = {}) {
                 db.close();
             }
             catch { /* no business write occurred */ }
-            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), ...(warnings.length > 0 ? warnings : ['pain_enrichment_invalid'])], metadata: { outcome: 'unavailable', admitted: false, duplicate: false, nextAction: 'inspect host pain enrichment input' } };
+            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), ...(warnings.length > 0 ? warnings : ['pain_enrichment_invalid'])], metadata: { outcome: 'unavailable', duplicate: false, nextAction: 'inspect host tool-call enrichment input' } };
         }
         const outcome = normalizeOutcome(event);
         const sanitizedParams = sanitizeToolParams(outcome.params, event.context.workspaceDir);
         const toolName = event.context.toolName ?? '';
-        const sourceObservation = buildToolFailureObservation({ toolName, error: outcome.error, exitCode: outcome.exitCode ?? undefined });
-        const nonZeroExit = outcome.exitCode !== null && outcome.exitCode !== 0;
-        const sourceKind = resolveSourceKind({
-            observedAt: new Date().toISOString(), workspaceId: event.context.workspaceDir,
-            sessionId: event.context.sessionId, toolName, failureSource: sourceObservation.failureSource,
-            toolNotFound: sourceObservation.toolNotFound, nonZeroExit,
-        });
-        const relativePath = enrichment.relativePath ?? String(field(outcome.params, 'file_path') ?? field(outcome.params, 'path') ?? 'unknown').slice(0, 500);
-        const isRisky = enrichment.isRisky ?? (path.isAbsolute(relativePath) && !path.resolve(relativePath).startsWith(`${path.resolve(event.context.workspaceDir)}${path.sep}`));
-        // Merged scoring semantics (WorkBuddy admission floor × CR-01): the 70
-        // failure base requires a VERIFIED non-zero exit code (branch review
-        // round: a thrown error with no exit evidence stays at the risky-path
-        // bonus only, honestly below the GOVERNANCE_STRONG_PAIN_SCORE floor, so
-        // unverified error shapes never spawn diagnostician work on their own).
-        // Classification and RECORDING remain main's three-way contract — the
-        // row still records outcome='failure' with exit_code NULL (never a
-        // fabricated 0).
-        const verifiedNonZeroExit = outcome.exitCode !== null && outcome.exitCode !== 0;
-        const painScore = enrichment.painScore ?? Math.min(100, (verifiedNonZeroExit ? 70 : 0) + (isRisky ? 20 : 0));
-        const errorHash = enrichment.errorHash ?? createHash('sha256').update(outcome.error ?? String(outcome.exitCode)).digest('hex');
-        // Cooldown is DEBOUNCE, not event identity (I1): the key deliberately has
-        // NO toolCallId. Repeated failures of the same failureSource+error within
-        // the window suppress the diagnostic trigger storm, while each real call
-        // still earns its own tool_calls evidence row through call-id-sensitive
-        // identity below.
-        const cooldownKey = `${path.resolve(event.context.workspaceDir)}:${event.context.sessionId}:${sourceObservation.failureSource}:${errorHash}`;
-        const last = cooldowns.get(cooldownKey);
-        const cooldownActive = last !== undefined && Date.now() - last < PAIN_COOLDOWN_WINDOW_MS;
-        const triage = evaluateTriage({ sourceKind, score: painScore, consecutiveErrors: enrichment.consecutiveErrors, isRisky });
-        const trigger = evaluateTriggerController({ triageResult: triage, isOwnerManual: false, isCooldownActive: cooldownActive, isValid: true, score: painScore, sessionId: event.context.sessionId });
-        // Merged semantics (WorkBuddy × CR-01): the three-way classification from
-        // SPEC-CODEX-PAIN-CLOSURE-001 gates admission ('unknown' results are never
-        // pain), and WorkBuddy tool names are capitalized (Write/Edit — probe P03)
-        // while OpenClaw/Codex are lowercase; admission is about the tool FAMILY,
-        // so compare case-insensitively at this one boundary. tool_calls evidence
-        // above keeps the raw host name.
-        const admitted = outcome.outcome === 'failure' && WRITE_TOOLS.has(toolName.toLowerCase()) && trigger.shouldCreateDiagnosticTask;
-        const { eventId, painId } = ids({
+        const { eventId } = ids({
             workspaceDir: event.context.workspaceDir,
             sessionId: event.context.sessionId,
             ...(event.context.turnId !== undefined ? { turnId: event.context.turnId } : {}),
@@ -542,7 +441,6 @@ export function createProductionPainEvidenceHandler(options = {}) {
         const paramsJson = stable(sanitizedParams);
         const resultPreview = preview({ eventId, result: sanitizeValue(outcome.result, 0, event.context.workspaceDir) });
         let duplicate = false;
-        let duplicateAdmitted = false;
         try {
             db.transaction(() => {
                 // CR-01: the host tool-call id is the stable join key for the
@@ -557,7 +455,6 @@ export function createProductionPainEvidenceHandler(options = {}) {
                         ? db.prepare('SELECT 1 FROM tool_calls WHERE session_id = ? AND tool_use_id = ? AND host_kind = ?').get(event.context.sessionId, event.context.toolCallId, options.hostKind)
                         : db.prepare('SELECT 1 FROM tool_calls WHERE session_id = ? AND tool_use_id = ?').get(event.context.sessionId, event.context.toolCallId)) !== undefined) {
                     duplicate = true;
-                    duplicateAdmitted = db.prepare('SELECT 1 FROM pain_events WHERE canonical_pain_id = ?').get(painId) !== undefined;
                     return;
                 }
                 // Review R3/P2: the content-shape fallback dedup is host-scoped the
@@ -566,40 +463,15 @@ export function createProductionPainEvidenceHandler(options = {}) {
                     ? db.prepare('SELECT 1 FROM tool_calls WHERE session_id = ? AND tool_name = ? AND params_json = ? AND outcome = ? AND exit_code IS ? AND error_message IS ? AND result_preview IS ? AND host_kind = ?').get(event.context.sessionId, toolName, paramsJson, outcome.outcome, outcome.exitCode, outcome.error ?? null, resultPreview, options.hostKind)
                     : db.prepare('SELECT 1 FROM tool_calls WHERE session_id = ? AND tool_name = ? AND params_json = ? AND outcome = ? AND exit_code IS ? AND error_message IS ? AND result_preview IS ?').get(event.context.sessionId, toolName, paramsJson, outcome.outcome, outcome.exitCode, outcome.error ?? null, resultPreview)) !== undefined) {
                     duplicate = true;
-                    duplicateAdmitted = db.prepare('SELECT 1 FROM pain_events WHERE canonical_pain_id = ?').get(painId) !== undefined;
                     return;
                 }
                 db.prepare(`INSERT INTO sessions (session_id, started_at, updated_at) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET updated_at = excluded.updated_at`).run(event.context.sessionId, createdAt, createdAt);
                 db.prepare(`INSERT INTO tool_calls (session_id, tool_name, outcome, duration_ms, exit_code, error_type, error_message, gfi_before, gfi_after, params_json, result_preview, created_at, tool_use_id, project_dir, host_kind) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
                     .run(event.context.sessionId, toolName, outcome.outcome, outcome.durationMs ?? null, outcome.exitCode, outcome.error ? outcome.error.split(/[\s:]/, 1)[0] : null, outcome.error ?? null, null, null, paramsJson, resultPreview, createdAt, event.context.toolCallId ?? null, path.resolve(options.projectDir ?? event.context.workspaceDir), options.hostKind ?? null);
-                if (admitted) {
-                    // Raw observation only (Pain Diagnosis Persistence SPEC §8): the
-                    // pain row must record WHAT happened, not WHY. Attribution
-                    // (People/Design/Assumption/Tooling) belongs to the Diagnostician.
-                    // confidence stays null — no attribution confidence exists at
-                    // detection time. origin remains 'system_infer' because origin is a
-                    // declared enum (event-types.ts: who reported the pain), not an
-                    // attribution claim.
-                    const reason = `tool=${toolName}; error=${outcome.error ?? `exit=${outcome.exitCode}`}; path=${relativePath}`;
-                    db.prepare(`INSERT INTO pain_events (session_id, source, score, reason, severity, origin, confidence, text, canonical_pain_id, runtime_task_id, host_kind, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                        .run(event.context.sessionId, sourceObservation.failureSource ?? 'tool_failure', painScore, reason, painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild', 'system_infer', null, enrichment.evidence?.map((entry) => `${entry.sourceRef}: ${entry.note}`).join('\n') ?? null, painId, null, options.hostKind ?? null, createdAt);
-                }
             })();
-            if (admitted && !duplicate) {
-                const admittedAt = Date.now();
-                // Bound the module-level cooldown map in long-lived host processes
-                // (OpenClaw): keys carry sessionId + errorHash, so unbounded retention
-                // grows monotonically. Evict entries outside the cooldown window —
-                // they can never be consulted again.
-                for (const [staleKey, staleAt] of cooldowns) {
-                    if (admittedAt - staleAt >= PAIN_COOLDOWN_WINDOW_MS)
-                        cooldowns.delete(staleKey);
-                }
-                cooldowns.set(cooldownKey, admittedAt);
-            }
         }
         catch (error) {
-            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), `trajectory_write_failed:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`], metadata: { outcome: outcome.outcome, admitted: false, duplicate: false, nextAction: 'inspect the workspace trajectory database and retry' } };
+            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), `trajectory_write_failed:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`], metadata: { outcome: outcome.outcome, duplicate: false, nextAction: 'inspect the workspace trajectory database and retry' } };
         }
         finally {
             try {
@@ -607,24 +479,14 @@ export function createProductionPainEvidenceHandler(options = {}) {
             }
             catch { /* write result already determined; cleanup is best-effort */ }
         }
-        const effectiveAdmitted = admitted || duplicateAdmitted;
         return {
             decision: 'observe',
             source: event.source,
             ...(emissionWarning ? { warnings: [emissionWarning] } : {}),
             metadata: {
-                eventId, painId: effectiveAdmitted ? painId : null, outcome: outcome.outcome, ...(outcome.unknownReason !== undefined ? { outcomeReason: outcome.unknownReason } : {}), exitCode: outcome.exitCode, admitted: effectiveAdmitted, duplicate,
-                sourceKind, failureSource: sourceObservation.failureSource ?? null, triggerOutcome: trigger.outcome,
-                triggerReason: trigger.reason, painScore, isRisky, relativePath, agentId: enrichment.agentId ?? null,
-                evidence: enrichment.evidence ?? [],
+                eventId, outcome: outcome.outcome, ...(outcome.unknownReason !== undefined ? { outcomeReason: outcome.unknownReason } : {}), exitCode: outcome.exitCode, duplicate,
             }
         };
     };
 }
-export function resetProductionPainCooldownForTest() {
-    cooldowns.clear();
-}
-export function productionPainCooldownEntryCountForTest() {
-    return cooldowns.size;
-}
 export { hasCanonicalSchema as hasProductionPainSchema };

package/host-runtime/dist/prompt-injection-budget-observation.js

@@ -107,6 +107,7 @@ const BUDGET_CAPACITY_SOURCES = new Set([
     'operator_declared',
     'host_effective_window',
     'pi_catalog_exact',
+    'pi_catalog_model_id',
     'legacy_fallback',
 ]);
 const BUDGET_CAPACITY_STATUSES = new Set(['confirmed', 'unknown']);
@@ -181,8 +182,9 @@ function narrowObservation(parsed, workspaceDir, nowMs) {
         // PRI-1020: operator_declared joins the confirmed set — a declared window
         // is a real window (the Owner's explicit cap), so its observations carry
         // the window and the exact formula budget like the other confirmed
-        // sources.
-        if (rawSource !== 'operator_declared' && rawSource !== 'host_effective_window' && rawSource !== 'pi_catalog_exact')
+        // sources. v0.3: pi_catalog_model_id is the weaker name-only catalog tier
+        // (still a real window claim, own source label).
+        if (rawSource !== 'operator_declared' && rawSource !== 'host_effective_window' && rawSource !== 'pi_catalog_exact' && rawSource !== 'pi_catalog_model_id')
             return null;
         if (!isValidContextWindowTokens(rawWindow))
             return null;

package/host-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/host-runtime",
-  "version": "0.15.0",
+  "version": "1.0.0",
   "description": "Shared host-neutral orchestration for Principles Disciple MVP-Core hook paths.",
   "type": "module",
   "main": "./dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-principles-disciple",
-  "version": "1.147.0",
+  "version": "1.147.2",
   "description": "Interactive CLI installer for Principles Disciple OpenClaw plugin",
   "type": "module",
   "bin": {
@@ -98,7 +98,7 @@
     "directory": "packages/create-principles-disciple"
   },
   "pd": {
-    "bundledPluginVersion": "2.4.0"
+    "bundledPluginVersion": "2.5.0"
   },
-  "gitHead": "d3355465b090daf098581cdb4c174634fe1e5279"
+  "gitHead": "94d353a428b6fc27dd41ff63b767bf915b9ed147"
 }

package/pd-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/pd-cli",
-  "version": "1.162.8",
+  "version": "1.163.1",
   "description": "PD CLI — Pain recording, sample management, and governance tasks for Principles Disciple",
   "type": "module",
   "bin": {

package/pd-mcp-server/dist/version.d.ts

@@ -7,7 +7,7 @@
  * package.json. A unit test pins it to package.json so the two cannot drift.
  */
 export declare const SERVER_NAME: 'pd-mcp-server';
-export declare const SERVER_VERSION: '0.2.0';
+export declare const SERVER_VERSION: '0.2.1';
 /** The only MCP SDK family/version this server is released against
  * (Gate 4-A freeze, PD_MCP_GATE4A_REALITY_CHECK §3). Exact pin — no ranges. */
 export declare const MCP_SDK_PIN: '@modelcontextprotocol/server@2.4.0';

package/pd-mcp-server/dist/version.js

@@ -7,7 +7,7 @@
  * package.json. A unit test pins it to package.json so the two cannot drift.
  */
 export const SERVER_NAME = 'pd-mcp-server';
-export const SERVER_VERSION = '0.2.0';
+export const SERVER_VERSION = '0.2.1';
 /** The only MCP SDK family/version this server is released against
  * (Gate 4-A freeze, PD_MCP_GATE4A_REALITY_CHECK §3). Exact pin — no ranges. */
 export const MCP_SDK_PIN = '@modelcontextprotocol/server@2.4.0';

package/pd-mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/pd-mcp-server",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Principles Disciple MCP Server — the single shared MCP server implementation for the three PD hosts (Codex, OpenClaw, WorkBuddy). Read-only pain recall through the Gate 3 Capability (SPEC-PD-MCP-GATE4-001).",
   "type": "module",
   "main": "./dist/index.js",