create-principles-disciple 1.147.1 → 1.147.3

package/_release/product-identity.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 1,
   "productVersion": "2.8.0",
-  "sourceCommit": "32312b70d5b4f8a661949680fe765e91077e5c16"
+  "sourceCommit": "5c3371c3935192081585d741f50a899bc4445b0e"
 }

package/codex-adapter/dist/ingestion/admission.d.ts

@@ -29,17 +29,12 @@ export declare function buildLiveCorrectionCandidate(args: {
     fields: PayloadFields;
     rolloutIdentity: string;
 }): GovernanceSignalCandidate | null;
-/** Live PostToolUse payload → tool-failure candidate (logical key mirrors the observation). */
-export declare function buildLiveToolCandidate(args: {
-    fields: PayloadFields;
-    rolloutIdentity: string;
-    projectDir?: string;
-}): GovernanceSignalCandidate | null;
 /**
- * Decoded transcript observations → candidates. User turns carry visibleText;
- * tool calls carry the CommandExecution facts projection. The logical keys are
- * the decoded ones, so a replay of an already-admitted live event is an
- * observation-level no-op (SPEC §10).
+ * Decoded transcript observations → candidates. Only user turns produce
+ * candidates: tool-call observations remain technical trajectory (recorded by
+ * the workflow's own writers), never a behavioral-deviation Pain by themselves.
+ * The logical keys are the decoded ones, so a replay of an already-admitted
+ * live event is an observation-level no-op (SPEC §10).
  */
 export declare function buildTranscriptCandidates(observations: readonly GovernanceObservationInput[]): readonly GovernanceSignalCandidate[];
 /**

package/codex-adapter/dist/ingestion/admission.js

@@ -14,9 +14,6 @@
  * authority exists here.
  */
 import { admitGovernanceSignals, ensureGovernanceContinuation, } from '@principles/host-runtime';
-import { isRecord, own } from './ingestion-fields.js';
-/** The live host-event source used by the identity derivation (parity with the dispatch handler). */
-const CODEX_POST_TOOL_USE_SOURCE = 'codex:post_tool_use';
 /** Live UserPromptSubmit payload → correction candidate (logical key mirrors the observation). */
 export function buildLiveCorrectionCandidate(args) {
     const { fields } = args;
@@ -33,85 +30,30 @@ export function buildLiveCorrectionCandidate(args) {
         observedAt: new Date().toISOString(),
     };
 }
-/** Live PostToolUse payload → tool-failure candidate (logical key mirrors the observation). */
-export function buildLiveToolCandidate(args) {
-    const { fields } = args;
-    if (fields.turnId === null || fields.toolUseId === null)
-        return null;
-    return {
-        kind: 'tool_failure',
-        hostKind: 'codex',
-        logicalObservationKey: `codex|${args.rolloutIdentity}|${fields.toolUseId}`,
-        rolloutIdentity: args.rolloutIdentity,
-        rootSessionId: fields.sessionId,
-        hostTurnId: fields.turnId,
-        toolName: fields.toolName ?? '',
-        source: CODEX_POST_TOOL_USE_SOURCE,
-        // Merge semantics (WorkBuddy × SPEC-CODEX-PAIN-CLOSURE-001): the same host
-        // `tool_use_id` feeds TWO consumers, so the candidate carries both views.
-        // I1 identity parity — the live handler derives the canonical pain from the
-        // same tool_use_id, so `toolCallId` must be present (one real call → one
-        // canonical pain across the admission + dispatch deliveries).
-        toolCallId: fields.toolUseId,
-        // CR-01 — `toolUseId` is recorded into tool_calls.tool_use_id and used for
-        // the admission dedup join against the live PostToolUse row.
-        toolUseId: fields.toolUseId,
-        ...(args.projectDir !== undefined ? { projectDir: args.projectDir } : {}),
-        ...(fields.toolInput !== undefined ? { toolInput: fields.toolInput } : {}),
-        ...(fields.toolResponse !== undefined ? { toolOutput: fields.toolResponse } : {}),
-        observedAt: new Date().toISOString(),
-    };
-}
 /**
- * Decoded transcript observations → candidates. User turns carry visibleText;
- * tool calls carry the CommandExecution facts projection. The logical keys are
- * the decoded ones, so a replay of an already-admitted live event is an
- * observation-level no-op (SPEC §10).
+ * Decoded transcript observations → candidates. Only user turns produce
+ * candidates: tool-call observations remain technical trajectory (recorded by
+ * the workflow's own writers), never a behavioral-deviation Pain by themselves.
+ * The logical keys are the decoded ones, so a replay of an already-admitted
+ * live event is an observation-level no-op (SPEC §10).
  */
 export function buildTranscriptCandidates(observations) {
     const candidates = [];
     for (const observation of observations) {
-        if (observation.kind === 'user_turn') {
-            if (observation.visibleText === undefined)
-                continue;
-            candidates.push({
-                kind: 'user_correction',
-                hostKind: 'codex',
-                logicalObservationKey: observation.logicalObservationKey,
-                rolloutIdentity: observation.rolloutIdentity,
-                rootSessionId: observation.rootSessionId,
-                hostTurnId: observation.hostTurnId,
-                text: observation.visibleText,
-                observedAt: observation.observedAt,
-            });
-        }
-        else if (observation.kind === 'tool_call') {
-            const facts = observation.toolFacts;
-            if (!isRecord(facts))
-                continue;
-            const toolName = own(facts, 'toolName');
-            const exitCode = own(facts, 'exitCode');
-            candidates.push({
-                kind: 'tool_failure',
-                hostKind: 'codex',
-                logicalObservationKey: observation.logicalObservationKey,
-                rolloutIdentity: observation.rolloutIdentity,
-                rootSessionId: observation.rootSessionId,
-                hostTurnId: observation.hostTurnId,
-                toolName: typeof toolName === 'string' ? toolName : '',
-                source: CODEX_POST_TOOL_USE_SOURCE,
-                // Merge semantics: both merged views of the same host tool_use_id.
-                // I1 identity parity — the decoded observation carries the same
-                // tool_use_id the live delivery derived its canonical pain from, so a
-                // transcript replay converges on that pain instead of a second one.
-                ...(typeof observation.toolUseId === 'string' && observation.toolUseId.length > 0 ? { toolCallId: observation.toolUseId } : {}),
-                // CR-01 — recorded into tool_calls.tool_use_id for the dedup join.
-                ...(observation.toolUseId !== undefined ? { toolUseId: observation.toolUseId } : {}),
-                toolInput: own(facts, 'command') ?? null,
-                ...(exitCode !== undefined ? { toolOutput: { exitCode, stdout: own(facts, 'stdout') ?? null, stderr: own(facts, 'stderr') ?? null } } : {}),
-                observedAt: observation.observedAt,
-            });
-        }
+        if (observation.kind !== 'user_turn')
+            continue;
+        if (observation.visibleText === undefined)
+            continue;
+        candidates.push({
+            kind: 'user_correction',
+            hostKind: 'codex',
+            logicalObservationKey: observation.logicalObservationKey,
+            rolloutIdentity: observation.rolloutIdentity,
+            rootSessionId: observation.rootSessionId,
+            hostTurnId: observation.hostTurnId,
+            text: observation.visibleText,
+            observedAt: observation.observedAt,
+        });
     }
     return candidates;
 }

package/codex-adapter/dist/ingestion/explicit-owner-statement.js

@@ -78,7 +78,7 @@ export async function recordExplicitOwnerStatement(args) {
     if (outcome === undefined || !('disposition' in outcome)) {
         return { status: 'rejected', reason: 'continuation_failed', nextAction: 'The governance admission returned no disposition; nothing was recorded.' };
     }
-    if (outcome.disposition === 'not_a_signal' || outcome.disposition === 'not_admitted') {
+    if (outcome.disposition === 'not_a_signal') {
         return { status: 'rejected', reason: 'continuation_failed', nextAction: 'reason' in outcome ? String(outcome.reason) : 'the signal was not admitted' };
     }
     if (outcome.disposition === 'rate_limited') {

package/codex-adapter/dist/ingestion/ingestion.d.ts

@@ -23,8 +23,6 @@ import { type GovernanceSignalCandidate } from '@principles/host-runtime';
 import { type TranscriptPort } from './transcript-decoder.js';
 export interface CodexIngestionOptions {
     readonly workspaceDir: string;
-    /** Native live-hook cwd; intentionally omitted for transcript catch-up. */
-    readonly projectDir?: string;
     readonly env?: {
         CODEX_HOME?: string | undefined;
     };

package/codex-adapter/dist/ingestion/ingestion.js

@@ -4,7 +4,7 @@ import { validateCodexTranscriptPath } from './transcript-path.js';
 import { classifyCodexVersion, CODEX_VERSION_NEXT_ACTION } from './codex-version.js';
 import { decodeTranscriptWindow, createNodeTranscriptPort, CODEX_INGESTION_MAX_BATCH_BYTES, TranscriptReplacedError } from './transcript-decoder.js';
 import { extractFields } from './ingestion-fields.js';
-import { buildLiveCorrectionCandidate, buildLiveToolCandidate, buildTranscriptCandidates } from './admission.js';
+import { buildLiveCorrectionCandidate, buildTranscriptCandidates } from './admission.js';
 let activePort = null;
 /** Test seam: inject/inspect the transcript filesystem boundary (zero-read proofs). */
 export function setCodexTranscriptPortForTest(port) {
@@ -13,7 +13,7 @@ export function setCodexTranscriptPortForTest(port) {
 function activeTranscriptPort(options) {
     return options.port ?? activePort ?? createNodeTranscriptPort();
 }
-function ingestLiveObservation({ fields, rolloutIdentity, workspaceDir, projectDir, now }) {
+function ingestLiveObservation({ fields, rolloutIdentity, workspaceDir, now }) {
     const nowIso = now.toISOString();
     let observation = null;
     if (fields.turnId !== null && fields.prompt !== null) {
@@ -61,9 +61,11 @@ function ingestLiveObservation({ fields, rolloutIdentity, workspaceDir, projectD
         return { status: 'degraded', reason: result.reason ?? 'governance_write_failed', nextAction: result.nextAction ?? 'inspect the workspace trajectory database.', warnings: result.warnings };
     // Slice B: hand the live observation to the admission pass as a normalized
     // candidate (SPEC §12) — the caller (pd-hook) runs detection/admission.
+    // Phase A: tool-call observations stay technical trajectory only; they never
+    // become a behavioral-deviation Pain candidate by themselves.
     const candidate = observation.kind === 'user_turn'
         ? buildLiveCorrectionCandidate({ fields, rolloutIdentity })
-        : buildLiveToolCandidate({ fields, rolloutIdentity, ...(projectDir !== undefined ? { projectDir } : {}) });
+        : null;
     return {
         status: 'ok', inserted: result.inserted, enriched: result.enriched, duplicates: result.duplicates, warnings: result.warnings, lagBytes: 0,
         admissionCandidates: candidate !== null ? [candidate] : [],
@@ -258,7 +260,7 @@ export function ingestCodexConversation(rawPayload, kind, options) {
         return { status: 'degraded', reason: validated.reason, nextAction: validated.nextAction, warnings: [] };
     const now = options.now ?? new Date();
     if (kind === 'before_prompt_build' || kind === 'after_tool_call') {
-        return ingestLiveObservation({ fields, rolloutIdentity: validated.rolloutIdentity, workspaceDir: options.workspaceDir, ...(options.projectDir !== undefined ? { projectDir: options.projectDir } : {}), now });
+        return ingestLiveObservation({ fields, rolloutIdentity: validated.rolloutIdentity, workspaceDir: options.workspaceDir, now });
     }
     return ingestTranscriptDelta({
         fallbackRootSessionId: fields.sessionId,

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

@@ -151,17 +151,16 @@ function recordRuleHostEvaluations(stateDir, sessionId, evaluations) {
 // Runs only when BOTH host.codex and codex_conversation_ingestion are
 // enabled — the flag gate below happens BEFORE any transcript path
 // validation or filesystem I/O, so flag-off means the transcript boundary
-// receives zero calls (SPEC §10 hard privacy invariant). Admission runs
-// BEFORE dispatch so a live tool failure is admitted through the same
-// canonical derivation first and the production handler's duplicate probe
-// then converges to a no-op (exactly one pain per real tool call).
+// receives zero calls (SPEC §10 hard privacy invariant). Admission covers
+// Owner corrections only: tool-call facts stay technical trajectory and never
+// become a behavioral-deviation Pain by themselves (Phase A).
 async function runConversationIngestion(args) {
-    const { rawPayload, kind, workspaceDir, projectDir, env } = args;
+    const { rawPayload, kind, workspaceDir, env } = args;
     if (kind !== 'turn_complete' && kind !== 'before_prompt_build' && kind !== 'after_tool_call')
         return [];
     const diagnostics = [];
     try {
-        const outcome = ingestCodexConversation(rawPayload, kind, { workspaceDir, ...(projectDir !== undefined ? { projectDir } : {}), env });
+        const outcome = ingestCodexConversation(rawPayload, kind, { workspaceDir, env });
         if (outcome.status === 'degraded') {
             diagnostics.push(diagnostic(outcome.reason, outcome.nextAction));
         }
@@ -334,7 +333,6 @@ export async function processHookInvocation(rawStdin, _env = process.env, cwd =
                 rawPayload: parsed,
                 kind: event.kind,
                 workspaceDir: resolution.workspaceDir,
-                projectDir: requestedCwd,
                 env: _env,
                 // CR-07: the prefix parse above already decided this turn's user
                 // prompt belongs to the explicit path — suppress the generic

package/codex-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/codex-adapter",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Codex CLI host adapter for Principles Disciple — implements HostAdapter interface for OpenAI Codex CLI's stdin/stdout JSON hook model (ADR-0020).",
   "type": "module",
   "main": "./dist/index.js",

package/core/dist/runtime-v2/evidence-triage/index.d.ts

@@ -9,7 +9,6 @@ export { isSourceKind } from './types.js';
 export type { SourceDescriptor } from './source-descriptors.js';
 export { SOURCE_DESCRIPTORS, getSourceDescriptor } from './source-descriptors.js';
 export { evaluateTriage } from './triage-policy.js';
-export { RISKY_HIGH_SCORE_THRESHOLD, REPEATED_FAILURE_THRESHOLD } from './triage-policy.js';
 export type { RawObservation } from './observation-resolver.js';
 export { resolveSourceKind, buildToolFailureObservation, buildManualPainObservation, } from './observation-resolver.js';
 export type { TriggerOutcome, TriggerDecision, TriggerControllerInput, } from './trigger-controller.js';

package/core/dist/runtime-v2/evidence-triage/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,YAAY,EACV,UAAU,EACV,cAAc,EACd,YAAY,EACZ,WAAW,GACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG1C,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAGlF,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,OAAO,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAK5F,YAAY,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EACL,iBAAiB,EACjB,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AAGnC,YAAY,EACV,cAAc,EACd,eAAe,EACf,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,YAAY,EACV,UAAU,EACV,cAAc,EACd,YAAY,EACZ,WAAW,GACZ,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG1C,YAAY,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAGlF,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAKpD,YAAY,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EACL,iBAAiB,EACjB,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AAGnC,YAAY,EACV,cAAc,EACd,eAAe,EACf,sBAAsB,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,yBAAyB,CAAC"}

package/core/dist/runtime-v2/evidence-triage/index.js

@@ -8,8 +8,6 @@ export { isSourceKind } from './types.js';
 export { SOURCE_DESCRIPTORS, getSourceDescriptor } from './source-descriptors.js';
 // Triage policy
 export { evaluateTriage } from './triage-policy.js';
-// PRI-446: upgrade thresholds (single source of truth, migrated from plugin)
-export { RISKY_HIGH_SCORE_THRESHOLD, REPEATED_FAILURE_THRESHOLD } from './triage-policy.js';
 export { resolveSourceKind, buildToolFailureObservation, buildManualPainObservation, } from './observation-resolver.js';
 export { evaluateTriggerController, shouldCreateTask, isAdmittedOutcome, isSkippedOutcome, } from './trigger-controller.js';
 //# sourceMappingURL=index.js.map

package/core/dist/runtime-v2/evidence-triage/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI1C,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAElF,gBAAgB;AAChB,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,6EAA6E;AAC7E,OAAO,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAM5F,OAAO,EACL,iBAAiB,EACjB,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AAQnC,OAAO,EACL,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI1C,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAElF,gBAAgB;AAChB,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAMpD,OAAO,EACL,iBAAiB,EACjB,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,2BAA2B,CAAC;AAQnC,OAAO,EACL,yBAAyB,EACzB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,yBAAyB,CAAC"}

package/core/dist/runtime-v2/evidence-triage/source-descriptors.d.ts

@@ -9,8 +9,9 @@
  * - defaultDecision: the default triage decision
  * - reason: why this default was chosen
  * - nextAction: what should happen when this decision is applied
- * - canUpgrade: whether the plugin adapter may upgrade the decision
- *   (e.g., rulehost_block can be upgraded to 'admit' for unsafe actions)
+ *
+ * Phase A: descriptor decisions are final. Technical failures and RuleHost
+ * blocks never upgrade to an admitted Pain (no context flags, no escalation).
  *
  * ERR checklist:
  * - ERR-002: Every descriptor carries reason + nextAction.
@@ -22,12 +23,6 @@ export interface SourceDescriptor {
     readonly defaultDecision: TriageDecision;
     readonly reason: string;
     readonly nextAction: string;
-    /**
-     * Whether the plugin adapter may upgrade this decision.
-     * When true, the adapter can override defaultDecision based on context
-     * (e.g., isUnsafeHighConfidence for rulehost_block).
-     */
-    readonly canUpgrade: boolean;
 }
 /**
  * Source kind descriptors. Order does not matter — lookup is by kind.

package/core/dist/runtime-v2/evidence-triage/source-descriptors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-descriptors.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/source-descriptors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAI7D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,eAAe,EAAE,cAAc,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAID;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,UAAU,EAAE,gBAAgB,CA4FvE,CAAC;AAIH;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAElF"}
+{"version":3,"file":"source-descriptors.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/source-descriptors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAI7D,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,eAAe,EAAE,cAAc,CAAC;IACzC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAID;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,UAAU,EAAE,gBAAgB,CA+EvE,CAAC;AAIH;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,gBAAgB,GAAG,SAAS,CAElF"}

package/core/dist/runtime-v2/evidence-triage/source-descriptors.js

@@ -9,8 +9,9 @@
  * - defaultDecision: the default triage decision
  * - reason: why this default was chosen
  * - nextAction: what should happen when this decision is applied
- * - canUpgrade: whether the plugin adapter may upgrade the decision
- *   (e.g., rulehost_block can be upgraded to 'admit' for unsafe actions)
+ *
+ * Phase A: descriptor decisions are final. Technical failures and RuleHost
+ * blocks never upgrade to an admitted Pain (no context flags, no escalation).
  *
  * ERR checklist:
  * - ERR-002: Every descriptor carries reason + nextAction.
@@ -33,91 +34,78 @@ export const SOURCE_DESCRIPTORS = new Map([
             defaultDecision: 'admit',
             reason: 'Owner explicitly reported pain. Highest confidence signal.',
             nextAction: 'none',
-            canUpgrade: false,
         }],
     ['agent_on_owner_request', {
             kind: 'agent_on_owner_request',
             defaultDecision: 'admit',
             reason: 'Agent recorded pain at owner request. Owner intent preserved.',
             nextAction: 'none',
-            canUpgrade: false,
         }],
     ['tool_failure', {
             kind: 'tool_failure',
             defaultDecision: 'evidence_only',
-            reason: 'Tool failure is infrastructure noise. PD does not own tool repair (ADR-0014).',
+            reason: 'Tool failure is a technical trajectory fact, never a behavioral-deviation Pain by itself (Phase A).',
             nextAction: 'store_as_evidence_for_later_correlation',
-            canUpgrade: false,
         }],
     ['dispatch_error', {
             kind: 'dispatch_error',
             defaultDecision: 'evidence_only',
             reason: 'Dispatch/subagent routing error. Not a behavior pattern.',
             nextAction: 'store_as_evidence_for_later_correlation',
-            canUpgrade: false,
         }],
     ['provider_failure', {
             kind: 'provider_failure',
             defaultDecision: 'health_only',
             reason: 'LLM provider failure. Infrastructure health signal, not owner-relevant behavior.',
             nextAction: 'record_in_health_telemetry',
-            canUpgrade: false,
         }],
     ['rate_limit', {
             kind: 'rate_limit',
             defaultDecision: 'health_only',
             reason: 'LLM provider rate limit. Infrastructure health signal, not owner-relevant behavior.',
             nextAction: 'record_in_health_telemetry',
-            canUpgrade: false,
         }],
     ['rulehost_block', {
             kind: 'rulehost_block',
             defaultDecision: 'evidence_only',
-            reason: 'RuleHost block is near-miss evidence. Default evidence-only.',
+            reason: 'RuleHost block is a technical block fact. Correct blocks are not Owner pain; wrong blocks reach correction detection (Phase A).',
             nextAction: 'store_as_evidence_for_later_correlation',
-            canUpgrade: true, // adapter can upgrade to 'admit' for high-confidence unsafe actions
         }],
     ['empathy_inferred', {
             kind: 'empathy_inferred',
             defaultDecision: 'owner_confirm',
             reason: 'Empathy-inferred frustration. Never silently creates diagnosis (PRODUCT_IDENTITY: owner-governed).',
             nextAction: 'request_owner_confirmation_before_diagnosis',
-            canUpgrade: false,
         }],
     ['semantic', {
             kind: 'semantic',
             defaultDecision: 'evidence_only',
             reason: 'Keyword/detection match. Not explicit owner pain. Needs accumulation.',
             nextAction: 'store_as_evidence_for_later_correlation',
-            canUpgrade: false,
         }],
     ['llm_paralysis', {
             kind: 'llm_paralysis',
             defaultDecision: 'evidence_only',
             reason: 'Session health signal. GFI alone cannot create diagnosis.',
             nextAction: 'store_as_evidence_for_later_correlation',
-            canUpgrade: false,
         }],
     ['subagent_error', {
             kind: 'subagent_error',
             defaultDecision: 'evidence_only',
             reason: 'Subagent workflow failure. Not a behavior pattern by itself.',
             nextAction: 'store_as_evidence_for_later_correlation',
-            canUpgrade: false,
         }],
     ['gfi_threshold', {
             kind: 'gfi_threshold',
             defaultDecision: 'evidence_only',
             reason: 'Accumulated GFI. GFI alone cannot create diagnosis per acceptance criteria.',
             nextAction: 'store_as_evidence_for_later_correlation',
-            canUpgrade: false,
         }],
     ['unknown', {
             kind: 'unknown',
             defaultDecision: 'evidence_only',
             reason: 'Unclassified source. Conservative default.',
             nextAction: 'classify_source_kind_and_store_as_evidence',
-            canUpgrade: false,
         }],
 ]);
 // ── Lookup ───────────────────────────────────────────────────────────────────

package/core/dist/runtime-v2/evidence-triage/source-descriptors.js.map

@@ -1 +1 @@
-{"version":3,"file":"source-descriptors.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/source-descriptors.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"source-descriptors.js","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/source-descriptors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAaH,+EAA+E;AAE/E;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAA8C,IAAI,GAAG,CAA+B;IACjH,CAAC,gBAAgB,EAAE;YACjB,IAAI,EAAE,gBAAgB;YACtB,eAAe,EAAE,OAAO;YACxB,MAAM,EAAE,4DAA4D;YACpE,UAAU,EAAE,MAAM;SACnB,CAAC;IACF,CAAC,wBAAwB,EAAE;YACzB,IAAI,EAAE,wBAAwB;YAC9B,eAAe,EAAE,OAAO;YACxB,MAAM,EAAE,+DAA+D;YACvE,UAAU,EAAE,MAAM;SACnB,CAAC;IACF,CAAC,cAAc,EAAE;YACf,IAAI,EAAE,cAAc;YACpB,eAAe,EAAE,eAAe;YAChC,MAAM,EAAE,qGAAqG;YAC7G,UAAU,EAAE,yCAAyC;SACtD,CAAC;IACF,CAAC,gBAAgB,EAAE;YACjB,IAAI,EAAE,gBAAgB;YACtB,eAAe,EAAE,eAAe;YAChC,MAAM,EAAE,0DAA0D;YAClE,UAAU,EAAE,yCAAyC;SACtD,CAAC;IACF,CAAC,kBAAkB,EAAE;YACnB,IAAI,EAAE,kBAAkB;YACxB,eAAe,EAAE,aAAa;YAC9B,MAAM,EAAE,kFAAkF;YAC1F,UAAU,EAAE,4BAA4B;SACzC,CAAC;IACF,CAAC,YAAY,EAAE;YACb,IAAI,EAAE,YAAY;YAClB,eAAe,EAAE,aAAa;YAC9B,MAAM,EAAE,qFAAqF;YAC7F,UAAU,EAAE,4BAA4B;SACzC,CAAC;IACF,CAAC,gBAAgB,EAAE;YACjB,IAAI,EAAE,gBAAgB;YACtB,eAAe,EAAE,eAAe;YAChC,MAAM,EAAE,iIAAiI;YACzI,UAAU,EAAE,yCAAyC;SACtD,CAAC;IACF,CAAC,kBAAkB,EAAE;YACnB,IAAI,EAAE,kBAAkB;YACxB,eAAe,EAAE,eAAe;YAChC,MAAM,EAAE,oGAAoG;YAC5G,UAAU,EAAE,6CAA6C;SAC1D,CAAC;IACF,CAAC,UAAU,EAAE;YACX,IAAI,EAAE,UAAU;YAChB,eAAe,EAAE,eAAe;YAChC,MAAM,EAAE,uEAAuE;YAC/E,UAAU,EAAE,yCAAyC;SACtD,CAAC;IACF,CAAC,eAAe,EAAE;YAChB,IAAI,EAAE,eAAe;YACrB,eAAe,EAAE,eAAe;YAChC,MAAM,EAAE,2DAA2D;YACnE,UAAU,EAAE,yCAAyC;SACtD,CAAC;IACF,CAAC,gBAAgB,EAAE;YACjB,IAAI,EAAE,gBAAgB;YACtB,eAAe,EAAE,eAAe;YAChC,MAAM,EAAE,8DAA8D;YACtE,UAAU,EAAE,yCAAyC;SACtD,CAAC;IACF,CAAC,eAAe,EAAE;YAChB,IAAI,EAAE,eAAe;YACrB,eAAe,EAAE,eAAe;YAChC,MAAM,EAAE,6EAA6E;YACrF,UAAU,EAAE,yCAAyC;SACtD,CAAC;IACF,CAAC,SAAS,EAAE;YACV,IAAI,EAAE,SAAS;YACf,eAAe,EAAE,eAAe;YAChC,MAAM,EAAE,4CAA4C;YACpD,UAAU,EAAE,4CAA4C;SACzD,CAAC;CACH,CAAC,CAAC;AAEH,gFAAgF;AAEhF;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAgB;IAClD,OAAO,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AACtC,CAAC"}

package/core/dist/runtime-v2/evidence-triage/triage-policy.d.ts

@@ -4,20 +4,22 @@
  * Pure policy evaluation for pre-diagnosis evidence triage.
  * No I/O, no plugin imports, no side effects.
  *
- * This module evaluates a TriageInput against source descriptors
- * and returns a TriageResult. The plugin adapter calls this function
- * and uses the result to decide whether to proceed to diagnosis.
+ * This module evaluates a TriageInput against source descriptors and returns
+ * a TriageResult. The plugin adapter calls this function and uses the result to
+ * decide whether to proceed to diagnosis.
+ *
+ * Phase A (legacy retirement): the context-dependent upgrade rules that used to
+ * turn technical failures or RuleHost blocks into admitted Pain are gone
+ * (`rulehost_block` / `tool_failure` upgrades, risky high-score and
+ * `consecutiveErrors >= 4` escalation). Triage is now a pure descriptor
+ * evaluation: only Owner-reported / Owner-requested evidence admits.
  *
  * ERR checklist:
  * - ERR-001: No `as` casts. Input validated with runtime guards.
  * - ERR-002: Every result carries structured reason + nextAction.
  * - ERR-005: Input is unknown, validated field-by-field.
  */
-import type { TriageInput, TriageResult } from './types.js';
-/** Pain score at or above which a risky action upgrades to admit. */
-export declare const RISKY_HIGH_SCORE_THRESHOLD = 70;
-/** Consecutive failures at or above which a tool failure upgrades to admit. */
-export declare const REPEATED_FAILURE_THRESHOLD = 4;
+import type { TriageResult, TriageInput } from './types.js';
 /**
  * Evaluate triage policy for incoming evidence.
  *
@@ -26,7 +28,7 @@ export declare const REPEATED_FAILURE_THRESHOLD = 4;
  * - Create diagnostic tasks
  * - Import anything from the plugin layer
  *
- * It only reads source descriptors and applies policy rules.
+ * It only reads source descriptors.
  *
  * @param input - Triage input with source kind and context
  * @returns Structured triage result with decision, reason, and nextAction

package/core/dist/runtime-v2/evidence-triage/triage-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triage-policy.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/triage-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAA8B,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAWxF,qEAAqE;AACrE,eAAO,MAAM,0BAA0B,KAAK,CAAC;AAC7C,+EAA+E;AAC/E,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAyF5C;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CA4C/D"}
+{"version":3,"file":"triage-policy.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/evidence-triage/triage-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAc,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAIxE;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,YAAY,CAsB/D"}

package/core/dist/runtime-v2/evidence-triage/triage-policy.js

@@ -4,9 +4,15 @@
  * Pure policy evaluation for pre-diagnosis evidence triage.
  * No I/O, no plugin imports, no side effects.
  *
- * This module evaluates a TriageInput against source descriptors
- * and returns a TriageResult. The plugin adapter calls this function
- * and uses the result to decide whether to proceed to diagnosis.
+ * This module evaluates a TriageInput against source descriptors and returns
+ * a TriageResult. The plugin adapter calls this function and uses the result to
+ * decide whether to proceed to diagnosis.
+ *
+ * Phase A (legacy retirement): the context-dependent upgrade rules that used to
+ * turn technical failures or RuleHost blocks into admitted Pain are gone
+ * (`rulehost_block` / `tool_failure` upgrades, risky high-score and
+ * `consecutiveErrors >= 4` escalation). Triage is now a pure descriptor
+ * evaluation: only Owner-reported / Owner-requested evidence admits.
  *
  * ERR checklist:
  * - ERR-001: No `as` casts. Input validated with runtime guards.
@@ -15,85 +21,6 @@
  */
 import { isSourceKind } from './types.js';
 import { getSourceDescriptor } from './source-descriptors.js';
-// ── Upgrade Thresholds (PRI-446 — migrated verbatim from the plugin adapter) ──
-//
-// These constants previously lived inline in the plugin-side triage-adapter
-// as magic numbers `70` and `4`. They are moved here byte-for-byte so the
-// upgrade decision has a single source of truth. The adapter now passes
-// isRisky / consecutiveErrors through to core instead of overriding the result.
-/** Pain score at or above which a risky action upgrades to admit. */
-export const RISKY_HIGH_SCORE_THRESHOLD = 70;
-/** Consecutive failures at or above which a tool failure upgrades to admit. */
-export const REPEATED_FAILURE_THRESHOLD = 4;
-// ── Upgrade Rules ───────────────────────────────────────────────────────────
-/**
- * Apply upgrade rules for upgradable source kinds.
- *
- * Three rules (PRI-446 consolidated all of them into core):
- * 1. rulehost_block + isUnsafeHighConfidence → admit
- * 2. tool_failure (or any evidence_only upgradeable kind) + isRisky + score >= 70 → admit
- * 3. tool_failure (or any evidence_only upgradeable kind) + consecutiveErrors >= 4 → admit
- *
- * This is the ONLY place where context-dependent upgrades happen in core.
- * The plugin adapter sets the context flags based on hook context.
- *
- * Rule precedence matches the prior plugin implementation: risky high-score is
- * checked before repeated failure, but since both produce the same upgraded
- * decision with the same nextAction, the order is only observable via the
- * reason string. We preserve the plugin's prior order (risky first).
- */
-function applyUpgradeRules(input, defaultDecision) {
-    if (defaultDecision !== 'evidence_only') {
-        return defaultDecision;
-    }
-    // Rule 1: rulehost_block unsafe action (pre-existing).
-    if (input.sourceKind === 'rulehost_block' && input.isUnsafeHighConfidence === true) {
-        return 'admit';
-    }
-    // Rule 2: risky high-score (migrated from plugin, PRI-446).
-    if (input.isRisky === true && input.score >= RISKY_HIGH_SCORE_THRESHOLD) {
-        return 'admit';
-    }
-    // Rule 3: repeated failure (migrated from plugin, PRI-446).
-    if (input.consecutiveErrors !== undefined && input.consecutiveErrors >= REPEATED_FAILURE_THRESHOLD) {
-        return 'admit';
-    }
-    return defaultDecision;
-}
-function getUpgradeReason(sourceKind, decision, input) {
-    if (decision !== 'admit') {
-        return `Upgraded decision for ${sourceKind}: ${decision}`;
-    }
-    if (sourceKind === 'rulehost_block' && input.isUnsafeHighConfidence === true) {
-        return `RuleHost blocked a high-confidence unsafe action (score=${input.score}). Upgrading to direct diagnosis.`;
-    }
-    // PRI-446: verbatim string from the plugin triage-adapter
-    if (input.isRisky === true && input.score >= RISKY_HIGH_SCORE_THRESHOLD) {
-        return 'Risky high-score operation overrides evidence-only decision. Immediate diagnosis required.';
-    }
-    // PRI-446: verbatim string from the plugin triage-adapter
-    if (input.consecutiveErrors !== undefined && input.consecutiveErrors >= REPEATED_FAILURE_THRESHOLD) {
-        return 'Repeated failures override evidence-only decision. Pattern suggests systemic issue requiring diagnosis.';
-    }
-    // Should not reach here — fallback
-    return `Upgraded decision for ${sourceKind}: ${decision}`;
-}
-function getUpgradeNextAction(sourceKind, decision, input) {
-    if (decision !== 'admit') {
-        return 'none';
-    }
-    if (sourceKind === 'rulehost_block' && input.isUnsafeHighConfidence === true) {
-        return 'none';
-    }
-    // PRI-446: verbatim nextAction from the plugin triage-adapter
-    // (both risky-high-score and repeated-failure used 'create_diagnostic_task').
-    if ((input.isRisky === true && input.score >= RISKY_HIGH_SCORE_THRESHOLD) ||
-        (input.consecutiveErrors !== undefined && input.consecutiveErrors >= REPEATED_FAILURE_THRESHOLD)) {
-        return 'create_diagnostic_task';
-    }
-    return 'none';
-}
-// ── Evaluation ──────────────────────────────────────────────────────────────
 /**
  * Evaluate triage policy for incoming evidence.
  *
@@ -102,7 +29,7 @@ function getUpgradeNextAction(sourceKind, decision, input) {
  * - Create diagnostic tasks
  * - Import anything from the plugin layer
  *
- * It only reads source descriptors and applies policy rules.
+ * It only reads source descriptors.
  *
  * @param input - Triage input with source kind and context
  * @returns Structured triage result with decision, reason, and nextAction
@@ -121,26 +48,6 @@ export function evaluateTriage(input) {
             nextAction: 'classify_source_kind_and_store_as_evidence',
         };
     }
-    // Apply upgrade rules. PRI-446: rule 1 (rulehost_block) is gated by
-    // descriptor.canUpgrade; rules 2/3 (risky high-score / repeated failure) are
-    // context-driven and apply to any evidence_only kind when the relevant flag is
-    // present, matching the prior plugin behavior. applyUpgradeRules internally
-    // guards on defaultDecision === 'evidence_only', so non-upgradeable kinds
-    // (admit/health_only/owner_confirm) are never affected.
-    const upgradeable = descriptor.canUpgrade ||
-        input.isRisky !== undefined ||
-        input.consecutiveErrors !== undefined;
-    if (upgradeable) {
-        const upgraded = applyUpgradeRules(input, descriptor.defaultDecision);
-        if (upgraded !== descriptor.defaultDecision) {
-            return {
-                decision: upgraded,
-                sourceKind,
-                reason: getUpgradeReason(sourceKind, upgraded, input),
-                nextAction: getUpgradeNextAction(sourceKind, upgraded, input),
-            };
-        }
-    }
     return {
         decision: descriptor.defaultDecision,
         sourceKind,