create-principles-disciple 1.147.0 → 1.147.2

package/_release/product-identity.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 1,
   "productVersion": "2.8.0",
-  "sourceCommit": "d3355465b090daf098581cdb4c174634fe1e5279"
+  "sourceCommit": "94d353a428b6fc27dd41ff63b767bf915b9ed147"
 }

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/console/dist/shared/prompt-injection-contract.d.ts

@@ -15,7 +15,7 @@
 export type PromptInjectionTargetHostName = 'openclaw' | 'codex' | 'workbuddy';
 export type PromptInjectionRouteName = 'legacy_trim' | 'shared_render';
 export type PromptInjectionBudgetScopeName = 'selected_lines' | 'full_directive_context';
-export type PromptBudgetCapacitySourceWire = 'operator_declared' | 'host_effective_window' | 'pi_catalog_exact' | 'legacy_fallback';
+export type PromptBudgetCapacitySourceWire = 'operator_declared' | 'host_effective_window' | 'pi_catalog_exact' | 'pi_catalog_model_id' | 'legacy_fallback';
 export type PromptBudgetCapacityStatusWire = 'confirmed' | 'unknown';
 /**
  * Bounded machine-readable fallback reason. Closed set mirroring the core